csu3_am335x/linux-devkit/sysroots/armv7ahf-neon-linux-gnueabi/usr/include/ti/drv/pruss/pruicss.h

/*
 * Copyright (c) 2015, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*
 * Copyright (c) 2015, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/** ============================================================================
 *  @file       pruicss.h
 *
 *  @brief      pruicss driver interface
 *
 *  The pruss header file should be included in an application as follows:
 *  @code
 *  #include <ti/drv/pruss/pruss.h>
 *  @endcode
 *
 *  ============================================================================
 */

#ifndef ti_drivers_PRUICSS__include
#define ti_drivers_PRUICSS__include

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>
#include <stddef.h>

#define PRUICSS_NUM_PRU_HOSTS        (10U)
#define PRUICSS_NUM_PRU_CHANNELS     (10U)
#define PRUICSS_NUM_PRU_SYS_EVTS     (64U)
#define PRUICSS_MAX_WAIT_EVENTS	     (10U)

#define PRUICSS_PRU0_DATARAM     (0U)
#define PRUICSS_PRU1_DATARAM     (1U)
#define PRUICSS_PRU0_IRAM        (2U)
#define PRUICSS_PRU1_IRAM        (3U)
#define PRUICSS_SHARED_DATARAM   (4U)
#define	PRUICSS_CFG              (5U)
#define	PRUICSS_UART             (6U)
#define	PRUICSS_IEP              (7U)
#define	PRUICSS_ECAP             (8U)
#define	PRUICSS_MII_RT           (9U)
#define	PRUICSS_MDIO             (10U)

/**< Invalid Intc Mux number, intc Mux not used if assigned PRUSS_INVALID_INTC_MUX_NUM */
#define PRUSS_INVALID_INTC_MUX_NUM      ((uint32_t)0xffff)
/*!
 *  @brief    PRUICSS Instance IDs
 */
typedef enum PRUICSS_MaxInstances_s
{
   PRUICCSS_INSTANCE_ONE=1,
   PRUICCSS_INSTANCE_TWO=2,
   PRUICCSS_INSTANCE_MAX=3
}PRUICSS_MaxInstances;
/** \brief Interrupt handler   */
typedef void (*PRUICSSDRV_IRQ_HANDLER)(void* buf);
typedef struct  PRUICSS_Config_s          *PRUICSS_Handle;

/*!
 *  @brief    PRUICSS Constant Table Register Entries
 */
typedef enum PRUICSS_ConstTblEntry_s
{
   PRUICCSS_ConstTblEntryC24,
   PRUICCSS_ConstTblEntryC25,
   PRUICCSS_ConstTblEntryC26,
   PRUICCSS_ConstTblEntryC27,
   PRUICCSS_ConstTblEntryC28,
   PRUICCSS_ConstTblEntryC29,
   PRUICCSS_ConstTblEntryC30,
   PRUICCSS_ConstTblEntryC31,
   PRUICCSS_ConstTblEntryMax
}PRUICSS_ConstTblEntry;

/***********************************************************************
*  Macros to support dynamic chip detecting feature
***********************************************************************/



typedef void *(*prussdrv_function_handler) (void * buf);


/*!
 *  @brief      PRUICSS system to channel map
 *
 */
typedef struct PRUICSS_SysevtToChannelMap_s
{
    uint8_t sysevt;   /*System event number */
    uint8_t channel;  /*Channel number */

    uint8_t polarity;  /*Interrupt polarity [ 0 - active low , 1 - active high ] */

    uint8_t type;  /*Interrupt type [ 0 - level or pulse interrupt , 1 - edge interrupt ] */
}PRUICSS_SysevtToChannelMap;

/*!
 *  @brief      PRUICSS channel to host map
 *
 */
typedef struct PRUICSS_ChannelToHostMap_s
 {
     int16_t channel;
     int16_t host;
 }PRUICSS_ChannelToHostMap;

/*!
 *  @brief      PRUICSS Interrupt controller initialisation data structure
 *
 */
 typedef struct PRUICSS_IntcInitData_s
 {
     /*Enabled SYSEVTs - Range:0..63
     {-1} indicates end of list*/
     int8_t sysevts_enabled[PRUICSS_NUM_PRU_SYS_EVTS];

      /*SysEvt to Channel map. SYSEVTs - Range:0..63 Channels -Range: 0..9
     {-1, -1} indicates end of list*/
     PRUICSS_SysevtToChannelMap sysevt_to_channel_map[PRUICSS_NUM_PRU_SYS_EVTS];

     /*Channel to Host map.Channels -Range: 0..9  HOSTs - Range:0..9
     {-1, -1} indicates end of list*/
     PRUICSS_ChannelToHostMap channel_to_host_map[PRUICSS_NUM_PRU_CHANNELS];

     /*10-bit mask - Enable Host0-Host9 {Host0/1:PRU0/1, Host2..9 : PRUEVT_OUT0..7)*/
     uint32_t host_enable_bitmask;
 }PRUICSS_IntcInitData;


/*!
 *  @brief     brief PRUICSS Global configuration
 *
 */
typedef struct PRUICSS_Config_s {

    /*! Pointer to a driver specific data object */
    void                   *object;

    /*! Pointer to a driver specific hardware attributes structure */
    void          const    *hwAttrs;
} PRUICSS_Config;

extern  PRUICSS_Config pruss_config[];

/*!
 *  @brief     brief PRUICSS IRQ handlers mapping
 *
 */
typedef struct PRUICSS_IrqFunMap_s
{

	PRUICSSDRV_IRQ_HANDLER irqHandler;
	/**< Interrupt handler*/
	void* semHandle;
    /**< Binary semaphore to wait on */
    void* handle;
}PRUICSS_IrqFunMap;


/**
 *  \brief PRU Firmware binary header
 *
 */
typedef struct PRUICSS_FirmwareBinHeader_s
{

	uint32_t image_size;
    /**< Image size */
	uint32_t load_addr;
    /**< Address to which this binary need to be loaded */
	uint32_t run_addr;
    /**< Address at which the execution should start */
}PRUICSS_FirmwareBinHeader;


/*!
 *  @brief PRUICSS interrupt config structure 
 *
 *  Default interrrupt configuration parametetrs
 */
typedef struct PRUICSS_IntrCfg_s
{
     uint32_t pruEvtoutNum;  /**< PRU Event number */
     uint8_t waitEnable;         /**< Flag specifying whether application can wait on this interrupt
                                                using PRUICSSPruWaitEvent function */
    PRUICSSDRV_IRQ_HANDLER irqHandler; /**< Pointer to a function which will be called on interrupt.*/
    /**< DSP: int vector number; ARM: GIC int number (peripheral event ID + 32) */
    uint32_t          intNum;
    /**< CorePac specific Event ID, input to CorePac interrupt controller */
    uint32_t          eventId;
     /**< intc mux number, Keystone inc mux is Chip Interrupt Controller
       if assigned -1, system resource manager will decide the mux num */
    int32_t           intcMuxNum;
     /**< intc mux input event ID, for Keystone, it is the input event to CIC
       if assigned -1, system resource manager will decide the mux input event ID */
    int32_t           intcMuxInEvent;
     /**< intc mux output event ID, for Keystone, it is the Host interrupt num
       if assigned -1, system resource manager will decide the mux output event ID */
    int32_t           intcMuxOutEvent;

 }PRUICSS_IntrCfg;

typedef enum PRUICSS_Return_e
{
  PRUICSS_RETURN_FAILURE = -1,
  PRUICSS_RETURN_SUCCESS = 0

}PRUICSS_Return;
/**
 * @brief   This function creates the handle for the PRUICSS instance \n
 *
 * @param   config   configuration structure of PRUICSS.
 * @param   instance PRUICSS instance no.
 *
 * @return  PRUICSS handle. \n
 */
PRUICSS_Handle  PRUICSS_create(PRUICSS_Config *config ,int32_t instance);

/**
 * @brief   This function Executes the program in the specified PRU \n
 *
 * @param 	handle    Pruss's driver handle
 * @param   pruNum    PRU instance number.\n
 *
 * @return  0 in case of successful transition, -1 otherwise. \n
 */
int32_t PRUICSS_pruExecProgram(PRUICSS_Handle handle,int32_t pruNum );
/**
 * @brief   Routine to
 *
 * @param 	handle              Pruss's driver handle
 * @param   pru_instance        PRU instance number
 * @param   spi_offset          Offset on SPI flash to where this need to be flashed
 *
 *
 * @return  None.
 *
 **/
int8_t PRUICSS_loadBinary (PRUICSS_Handle handle, uint8_t pru_instance,uint32_t spi_offset);

/**
 * @brief  This function waits for a System event to happen \n
 *
 * @param 	handle              Pruss's driver handle
 * @param   pruEvtoutNum        The AINTC Event number.\n
 *
 * @return  0 in case of successful transition, -1 otherwise. \n
 */
int32_t PRUICSS_pruWaitEvent(PRUICSS_Handle handle,uint32_t pruEvtoutNum );

/**
 * @brief  This function does Interrupt-Channel-host mapping.
 *
 * @param   handle     Pruss's driver handle
 * @param   prussintc_init_data   The pointer to structure containing mapping information.
 *
 * @return  0 in case of successful transition, -1 otherwise. \n
 */
int32_t PRUICSS_pruIntcInit(PRUICSS_Handle handle, const PRUICSS_IntcInitData * prussintc_init_data);

/**
 * \brief  This function generates and INTC event, waits for AINTC event and
 *		   clears an INTC event \n
 *
 * @param   handle     Pruss's driver handle
 * @param   sendEventNum   Event number.\n
 * @param   pruEvtoutNum   PRU Event number.\n
 * @param   ackEventNum    Acknowlodegement event number.\n
 *
 * \return  0 in case of successful transition, -1 otherwise. \n
 */
int32_t PRUICSS_pruSendWaitCearEvent(PRUICSS_Handle handle,uint32_t sendEventNum,
										uint32_t pruEvtoutNum,
										uint32_t ackEventNum
										);
/**
 * @brief  This function Registers an Interrupt Handler for an event.\n
 *
 * @param   handle     Pruss's driver handle
 *
 * @param   pruEvtoutNum   The ARM side event number.\n
 *
 * @param	intrNum        Interrupt number of MPU/C66x
 *
 * @param	eventNum       Event number of PRUICSS
 *
 * @param	waitEnable     Flag specifying whether application can wait on this interrupt
 * 						   using PRUICSSPruWaitEvent function
 *
 * @param   irqHandler     Pointer to a function which will be called on interrupt.\n
 *
 *
 * \return  0 in case of successful registration, -1 otherwise. \n
 */
int32_t PRUICSS_registerIrqHandler(PRUICSS_Handle handle,uint32_t pruEvtoutNum,
                           int32_t intrNum,
						   int32_t eventNum,
						   uint8_t waitEnable,
						   PRUICSSDRV_IRQ_HANDLER irqHandler
						   );

/**
 * @brief  This function Registers an Interrupt Handler for an event.\n
 *
 * @param   handle     Pruss's driver handle
 *
 *
 * @param	intrCfg        pointer to interrupt configuration parameter
 *
 * \return  0 in case of successful registration, -1 otherwise. \n
 */
int32_t PRUICSS_registerIrqHandler2(PRUICSS_Handle handle,
                                    PRUICSS_IntrCfg*  intrCfg);


/**
 * @brief  This function sets the buffer pointer for PRU. The contents of this buffer will be \n
 *         loaded to IRAM.\n
 *
 * @param   handle     Pruss's driver handle
 * @param   pruNum     The PRU number.\n
 * @param   buffer	   Pointer to buffer.\n
 * @param   numBytes    Number of bytes in the buffer.\n
 *
 * @return  0 in case of successful transition, -1 otherwise. \n
 */
int32_t PRUICSS_setPRUBuffer(PRUICSS_Handle handle,
                         uint32_t pruNum,
						 void *buffer,
						 uint32_t numBytes);


/**
 * @brief   Configure PIN_MUX_SEL
 *
 * @param   handle     Pruss's driver handle
 * @param	regVal		value to be written
 *
 * @return  None.
 *
 **/
void PRUICSS_pinMuxConfig(PRUICSS_Handle handle, uint64_t regVal);


/*The following are the static functions to be moved to .c file.*/

/**
 * @brief    Resets PRU: \n
 *
 * @param   handle     Pruss's driver handle
 * @param    pruNum          PRU instance number[0 or 1].
 *
 * @return   0 in case of successful reset, -1 otherwise.
 **/
int32_t PRUICSS_pruReset(PRUICSS_Handle handle ,uint8_t pruNum);

/**
 * @brief    Disables PRU: \n
 *
 * @param   handle     Pruss's driver handle
 * @param    pruNum          PRU instance number[0 or 1].
 *
 * @return   0 in case of successful disable, -1 otherwise.
 **/
int32_t PRUICSS_pruDisable(PRUICSS_Handle handle,uint8_t pruNum);

/**
 * @brief    Enables PRU: \n
 *
 * @param    handle     Pruss's driver handle
 * @param    pruNum          PRU instance number[0 or 1].
 *
 * @return   0 in case of successful enable, -1 otherwise.
 **/
int32_t PRUICSS_pruEnable(PRUICSS_Handle handle,uint8_t pruNum);

/**
 *
 *  @brief   This function writes the given data to PRU memory
 *
 * @param     handle     Pruss's driver handle
 * @param     pruMem         PRU Memory Macro [DATARAM0_PHYS_BASE
 * @param     wordoffset     Offset at which the write will happen.
 * @param     source_mem     Source memory[ Array of uint32_tegers ]
 * @param     bytelength     Total number of bytes to be writen
 *
 * pruMem can have values
 *		PRU0_DATARAM\n
 *		PRU0_IRAM\n
 *		PRU1_DATARAM\n
 *		PRU1_IRAM\n
 * 		PRUICSS_SHARED_DATARAM
 * @return                    word length written or 0 on error.
 *
 **/
int32_t PRUICSS_pruWriteMemory(PRUICSS_Handle handle,
                           uint32_t pruMem,
                           uint32_t wordoffset,
                           const uint32_t *source_mem,
                           uint32_t bytelength
						   );

/**
 * @brief  This function Generates an INTC event \n
 *
 * @param   handle     Pruss's driver handle
 * @param   eventnum   The INTC Event number.\n
 *
 * @return  0 in case of successful transition, -1 otherwise. \n
 **/
int32_t PRUICSS_pruSendEvent(PRUICSS_Handle handle,uint32_t eventnum);


/**
 * @brief  This function clears an INTC event \n
 *
 * @param   handle     Pruss's driver handle
 * @param   eventnum   The INTC Event number.\n
 *
 * @return  0 in case of successful transition, -1 otherwise. \n
 **/
int32_t PRUICSS_pruClearEvent(PRUICSS_Handle handle,uint32_t eventnum);

/**
 * @brief  This function returns the address of PRU components.
 *
 * @param   handle     Pruss's driver handle
 * @param   pru_ram_id   PRU components' Id. \n
 * @param   address  Memory to which address to be copied. \n
 *
 * @return 0 in case of success, -1 otherwise. \n
 **/
int32_t PRUICSS_mapPruMem(PRUICSS_Handle handle,uint32_t pru_ram_id, void **address);

/**
 * @brief  This function returns the base address of peripheral IO modules.
 *
 * @param   per_id   Peripheral Module's Id.
 *
 * @param   handle     Pruss's driver handle
 * @param   address  Memory to which address to be copied. \n
 *
 * @return 0 in case of success, -1 otherwise. \n
 **/
int32_t PRUICSS_mapPeripheralIO(PRUICSS_Handle handle,uint32_t per_id, void **address);

void PRUICSS_enableOCPMasterAccess(PRUICSS_Handle handle );

/**
 * @brief    Detects the Chip Type \n
 *
 */
uint32_t PRUICSS_detectHWVersion(void);

/**
 * @brief    Get PRU ICSS version \n
 *
 * @param    handle     Pruss's driver handle
 *
 * @return   PRU ICSS version
 **/
uint32_t PRUICSS_getICSSVersion(PRUICSS_Handle handle);
/**
 * \brief  This API gets the SoC level of PRUICSS intial configuration
 *
 * \param  cfg       Pointer to PRUICSS SOC initial config.
 *
 * \return 0 success
 *
 */
int32_t PRUICSS_socGetInitCfg( PRUICSS_Config **cfg);

/**
 * \brief  This API sets the SoC level of PRUICSS intial configuration
 *
 * \param  cfg       Pointer to PRUICSS SOC initial config.
 *
 * \return           0 success
 *
 */
int32_t PRUICSS_socSetInitCfg(PRUICSS_Config *cfg);

/**
 * @brief  This function clears all Interrupt-Channel-host mapping.
 *
 * @param   handle                Pruss's driver handle
 *
 * @return  0 in case of successful transition, -1 otherwise. \n
 */
int32_t PRUICSS_pruIntcClear(PRUICSS_Handle handle);

/**
 * \brief  This API updates the constant table  for specified constant table entry
             which have write permissions.
 *
 * @param    handle     Pruss's driver handle
 * @param    pruNum PRU number[0 or 1] for which constant table is being updated.
 * @param    constantTblEntry contant table entry being updated
 * @param    constantTblVal contant table value to be written
 *
 * \return           0 success, -1 on error
 *
 */
int32_t PRUICSS_setConstantTblEntry(PRUICSS_Handle handle, uint8_t pruNum, int32_t constantTblEntry, uint32_t constantTblVal);

/**
 * \brief  This API configures the General Purpose Mux Selector field of
 *          the General Purpose Config Register (PRUSS_GPCFG)
 *
 * @param    handle     Pruss's driver handle
 * @param    pruNum PRU number[0 or 1].
 * @param    mode PRU-ICSS wrap mux selection
 *
 * \return           0 success, -1 on error
 *
 */
int32_t PRUICSS_setGpMuxSel(PRUICSS_Handle handle, uint8_t pruNum, uint32_t mode);

#ifdef __cplusplus
}
#endif

#endif /* ti_drivers_PRUICSS__include */