csl_spi.h

Configuring External Interrupts on TMS320C672x Devices

/** @brief This will have the base-address information for the peripheral
 *  instance
 */
typedef struct {
	/** Base-address of the Configuration registers of SPI.
	*/
	CSL_SpiRegsOvly regs;
} CSL_SpiBaseAddress;

/** @brief SPI specific parameters. Present implementation doesn't have
 *  any specific parameters.
 */
typedef struct {
	/** Bit mask to be used for module specific parameters.
	*  The below declaration is just a place-holder for future
	*  implementation.
	*/
	CSL_BitMask16   flags;
} CSL_SpiParam;

/** @brief SPI specific context information. Present implementation doesn't
 *  have any Context information.
 */

typedef struct {
	/** Context information of SPI.
	*  The below declaration is just a place-holder for future
	*  implementation.
	*/
	Uint16  contextInfo;
} CSL_SpiContext;


typedef struct  {
	volatile Uint32 SPIGCR0;
	volatile Uint32 SPIGCR1;
	volatile Uint32 SPIINT0;
	volatile Uint32 SPILVL;
	volatile Uint32 SPIFLG;
	volatile Uint32 SPIPC0;
	volatile Uint32 SPIPC1;
	volatile Uint32 SPIPC2;
	volatile Uint32 SPIPC3;
	volatile Uint32 SPIPC4;
	volatile Uint32 SPIPC5;
	volatile Uint32 SPIDAT0;
	volatile Uint32 SPIDAT1;
	volatile Uint32 SPIBUF;
	volatile Uint32 SPIEMU;
	volatile Uint32 SPIDELAY;
	volatile Uint32 SPIDEF;
	volatile Uint32 SPIFMT[4];
	volatile Uint32 TGINTVEC[2];
} CSL_SpiConfig;

/** Default Values for Config structure */
#define CSL_SPI_CONFIG_DEFAULTS {     \
        CSL_SPI_SPIGCR0_RESETVAL,     \
        CSL_SPI_SPIGCR1_RESETVAL,     \
        CSL_SPI_SPIINT0_RESETVAL,     \
        CSL_SPI_SPILVL_RESETVAL,      \
        CSL_SPI_SPIFLG_RESETVAL,      \
        CSL_SPI_SPIPC0_RESETVAL,      \
        CSL_SPI_SPIPC1_RESETVAL,      \
        CSL_SPI_SPIPC2_RESETVAL,      \
        CSL_SPI_SPIPC3_RESETVAL,      \
        CSL_SPI_SPIPC4_RESETVAL,      \
        CSL_SPI_SPIPC5_RESETVAL,      \
        CSL_SPI_SPIDAT0_RESETVAL,     \
        CSL_SPI_SPIDAT1_RESETVAL,     \
        CSL_SPI_SPIBUF_RESETVAL,      \
        CSL_SPI_SPIEMU_RESETVAL       \
        CSL_SPI_SPIDELAY_RESETVAL,    \
        CSL_SPI_SPIDEF_RESETVAL,      \
        CSL_SPI_SPIFMT_RESETVAL,      \
        CSL_SPI_TGINTVEC_RESETVAL     \
}

/** @brief a pointer to @a CSL_SpiObj; this is passed to all SPI CSL
 * APIs */
typedef struct CSL_SpiObj *CSL_SpiHandle;


/** @brief sets up the properties if the pins of Spi
 *
 * This object is used to setup or get the setup of the pins in Spi */
typedef struct CSL_SpiHwSetupPins {
	/** decides if the pins will be Spi or GPIO */
	Uint16  func;
	/** if GPIO, decides the directions of the pins */
	Uint16  dir;
} CSL_SpiHwSetupPins;


/** @brief sets up the format selection for a set of transfers
 *
 * This object is used to setup or get the setup of the format selection
 * for a set of transfers */
typedef struct CSL_SpiHwSetupFmtCtrl {
	/** decides if chip select is to be held active between transfers */
	CSL_SpiCsHold    csHold;
	/** decides if delay specified in the selected format must be allowed
	* between 2 consecutive transfers */
	CSL_SpiWDelayEn  wDel;
	/** decides which format to select */
	CSL_SpiFmtSel    fmtSel;
	/** defines the chip select that will be activated for the transfer */
	Uint8               cSel;
} CSL_SpiHwSetupFmtCtrl;


/** @brief sets up the Spi for compatibility mode
 *
 * This structure is used to setup or get the setup of Spi in comaptibility
 * mode */
typedef struct CSL_SpiHwSetupCpt {
	/** selects if interrupts should go to lines INT0 or INT1 */
	Uint32                    *lvl;
	/** selects the format & associated controls */
	CSL_SpiHwSetupFmtCtrl  *fmtCtrlPtr;
} CSL_SpiHwSetupCpt;


/** @brief sets up the a formatting for an outgoing word
 *
 * This object is used to set up or get the setup of the format registers in
 * Spi */
typedef struct CSL_SpiHwSetupPriFmt {
	/** delay between 2 consecutive words */
	Uint8             wDelay;
	/** the factor with which to multiply functional clock in order to get the
	* serial clock */
	Uint8             preScale;
	/** the length of the word to be transmitted and/or received */
	Uint8             charLen;
	/** if in master mode; whether Spi should wait for ENA from slave */
	CSL_SpiWaitEn  waitEna;
	/** whether clock should be high or low when inactive */
	CSL_SpiClkPolarity  polarity;
	/** whether data should be in phase of 1/2 cycle ahead of the clock */
	CSL_SpiClkPhase   phase;
	/** whether LSB or MSB should be shifted first */
	CSL_SpiShDir   shiftDir;
} CSL_SpiHwSetupPriFmt;


/** @brief sets up the parameters to be setup in priority mode
 *
 * This object is used to setup or get the setup of the parameters to be setup
 * in priority mode */
typedef struct CSL_SpiHwSetupPri {
	/** array of pointers to structures of formats of an outgoing word */
	CSL_SpiHwSetupPriFmt  *fmt[4];
} CSL_SpiHwSetupPri;


/** @brief sets up the parameters that are needed by multi-buffer as well as
 * compatibility modes
 *
 * This objetc is used to set up or get the setup of parameters that are needed
 * by multi-buffer as well as compatibility modes */
typedef struct CSL_SpiHwSetupGen {
	/** master or slave mode */
	CSL_SpiOpMod      opMode;
	/** whether ENA signal should be tristated when inactive or if it should
	* bear a value */
	CSL_SpiEnaHiZ     enaHiZ;
	/** the default value on Chip select when inactive */
	Uint8                csDefault;
	/** Chip-select-active-to-transmit-start-delay */
	Uint8                c2tDelay;
	/** Transmit-end-to-chip-select-inactive-delay */
	Uint8                t2cDelay;
	/** Transmit-data-finished-to-ENA-pin-inactive-time-out */
	Uint8                t2eTmout;
	/** Chip-select-active-to-ENA-signal-active-time-out */
	Uint8                c2eTmout;
} CSL_SpiHwSetupGen;


/** @brief main structure that is used to setup the SPI
 *
 * This structure is used to setup or obtain the existing setup of SPI
 * using @a CSL_spiHwSetup() & @a CSL_spiGetHwStatus() functions
 * respectively. If a particular member pointer is null, then these functions
 * do not setup or get the setup of the corresponding part of SPI
 * respectively */
typedef struct CSL_SpiHwSetup {
	/** This pointer to @a CSL_SpiHwSetupCommon is used to hold
	* information on the common part of the SPI setup */
	CSL_SpiHwSetupGen   *genPtr;
	/** This pointer to @a CSL_SpiHwSetupFifo is used to hold information
	* on the data FIFO part of the SPI setup */
	CSL_SpiHwSetupPri   *priPtr;
	/** This pointer to @a CSL_SpiHwSetupSdio is used to hold information
	* on the SDIO part of the SPI setup */
	CSL_SpiHwSetupCpt   *cptPtr;
	/** This pointer to @a CSL_SpiHwSetupSdio is used to hold information
	* on the SPI part of the SPI setup */
	CSL_SpiHwSetupPins  *pinsPtr;
} CSL_SpiHwSetup;


/** @brief gets the information for interrupt vectors */
typedef struct CSL_SpiIntVec {
	/** interrupt vector number */
	Uint8  intVal;
} CSL_SpiIntVec;


/** @brief gets the status of buffer after a transfer */
typedef struct CSL_SpiBufStat {
	/** status as a bit-vector of the different events */
	Uint8  status;
} CSL_SpiBufStat;


typedef struct CSL_SpiCptData {
	/** Place to hold the data */
	Uint16            data;
	/** Place to hold the status */
	CSL_SpiBufStat *bufStat;
} CSL_SpiCptData;


/** default setting for @a CSL_SpiHwSetup */
#define CSL_SPI_HWSETUP_DEFAULTS { 		\
	NULL,                             	\
	NULL,                             	\
	NULL,                             	\
	NULL                              	\
}


/** default setting for @a CSL_SpiHwSetupGen */
#define CSL_SPI_HWSETUP_GEN_DEFAULTS {		\
	CSL_SPI_OPMOD_SLAVE,               	\
	CSL_SPI_ENAHIZ_NO,                 	\
	0,                                  	\
	0,                                  	\
	0,                                  	\
	0,                                  	\
	0                                   	\
}


/** default setting for @a CSL_SpiHwSetupPri */
#define CSL_SPI_HWSETUP_PRI_DEFAULTS { 	\
	NULL,                           \
	NULL,                           \
	NULL,                           \
	NULL                            \
}
	

/** default setting for @a CSL_SpiHwSetupPriFmt */
#define CSL_SPI_HWSETUP_PRI_FMT_DEFAULTS { \
	0,                                     \
	0,                                     \
	0,                                     \
	CSL_SPI_WAITEN_NO,                     \
	CSL_SPI_PHASE_IN,                      \
	CSL_SPI_SHDIR_LSBFIRST                 \
}


/** default setting for @a CSL_SpiHwSetupCpt */
#define CSL_SPI_HWSETUP_CPT_DEFAULTS { 		\
	NULL,                             	\
	NULL                                	\
}


/** default setting for @a CSL_SpiHwSetupFmtCtrl */
#define CSL_SPI_HWSETUP_FMTCTRL_DEFAULTS { 	\
	CSL_SPI_CSHOLD_NO,                     	\
	CSL_SPI_WDELAYEN_NO,                   	\
	CSL_SPI_FMTSEL_0,                      	\
	0,                                     	\
}


/** default setting for @a CSL_SpiHwSetupPins */
#define CSL_SPI_HWSETUP_PINS_DEFAULTS { 	\
	NULL,                               	\
	NULL                                	\
}

/** ===========================================================================
 *   @func CSL_spiOpen
 *
 *   @desc
 *        This function populates the peripheral data object for the instance
 *        and returns a handle to the instance.
 *        The open call sets up the data structures for the particular instance
 *        of SPI device. The device can be re-opened anytime after it has been
 *        normally closed if so required. SPI Hardware setup will be performed
 *        at the end of the open call only if the HwSetup Pointer supplied was
 *        non-NULL. The handle returned by this call is input as an essential
 *        argument for rest of the APIs described for this module.
 *
 *   @arg pSpiObj
 *        Pointer to the SPI instance object
 *
 *   @arg spiNum
 *        Instance of the SPI to be opened.
 *
 *   @arg pSpiParam
 *        Pointer to module specific parameters
 *
 *   @arg pStatus
 *        pointer for returning status of the function call
 *
 *   @ret CSL_SpiHandle
 *        Valid SPI instance handle will be returned if status value is
 *        equal to CSL_SOK.
 *
 *   @eg
 *        CSL_Status        status;
 *        CSL_SpiObj        spiObj;
 *        CSL_SpiHandle     hSpi;
 *
 *        hSpi = CSL_spiOpen (&spiObj,
 *                            CSL_SPI_0,
 *                            NULL,
 *                            &status
 *                            );
 *
 * ===========================================================================
 */
/** @brief opens if possible the instance of SPI requested */
CSL_SpiHandle CSL_spiOpen(
	/** pointer to the object that holds reference to the instance of SPI
	* requested after the call */
	CSL_SpiObj                            *hSpiObj,
	/** instance of SPI to which a handle is requested */
	CSL_InstNum                           spiNum,
	/** specifies if SPI should be opened with excusive or share access to
	* the associate pins */
	CSL_SpiParam                          *pSpiParam,
	/** This returns the status (success/errors) of the call */
	CSL_Status                            *status
);

/** ===========================================================================
 *   @func CSL_spiClose
 *
 *   @b Description
 *   @n Unreserves the SPI identified by the handle.
 *
 *   @arg  hSpi
           Handle to the Spi instance
 *
 *   @ret CSL_Status
 *         CSL_SOK            - Close successful
 *         CSL_ESYS_BADHANDLE - Invalid handle
 *
 *   <b> Pre Condition </b>
 *   @n  Both @a CSL_spiInit() and @a CSL_spiOpen() must be called successfully
 *       in that order before @a CSL_spiClose() can be called.
 *
 *   <b> Post Condition </b>
 *   @n  None.
 *
 *   @b Example
 *   @verbatim
        CSL_SpiHandle       hSpi;