5.12. SPI¶

5.12.1.1. Modes of Operation¶

Following modes of operations are supported:

SPI_MODE_BLOCKING SPI_transfer() API blocks code execution until transaction has completed. By default, SPI driver operates in blocking mode. This ensures only one SPI transaction operates at a given time. This mode is supported in both interrupt or non-interrupt configurations.

SPI_MODE_CALLBACK SPI_transfer() API returns without waiting for completion of transaction in this case. Callback function registered by application is invoked once transaction is complete.This mode is supported only in interrupt configuration.

5.12.2.1. Board Specific Configuration¶

All board specific configurations eg:enabling clock and pin-mux for SPI pins are required before calling any driver APIs.By default Board_Init() API supports all initialization sequence for TI supported EVMs. In addition it initializes UART instance for Console/STDIO.Refer PDK Board Support for additional details.Once board specific configuration is complete SPI_init() API should be called to initialize driver.

5.12.2.2. SoC Specific Configuration¶

All SoC specific configurations (eg: SPI module registers base address, interrupt configurations, etc.) can be set using SPI_socSetInitCfg() SoC driver API before calling any SPI driver APIs. The default SoC specific configurations can be retrieved using SPI_socGetInitCfg() SoC driver API. Use the APIs OSPI_socSetInitCfg and OSPI_socGetInitCfg for changing the SoC specific configurations for OSPI.

5.12.2.3. SPI Configuration Structure¶

The SPI_soc.c file binds driver with hardware attributes on the board through SPI_config[] structure. This structure must be provided to the SPI driver. It must be initialized before the SPI_init() function is called and cannot be changed afterwards.

Driver  requires common SPI_config[]  to configure hardware attributes of MCSPI and QSPI/OSPI peripherals on SOC and board. First all MCSPI related hardware attributes is defined followed by QSPI/OSPI hardware attributes. Application will need to include appropriate offset to instance while invoking SPI_open() API..

For details about individual fields of this library structure, see the PDK doxygen documentation

5.12.3.1. Open SPI¶

...
Board_init(boardCfg);
...
SPI_socGetInitCfg(SPI_MCSPI_DOMAIN_MCU, peripheralNum, &spi_cfg);
...
SPI_socSetInitCfg(SPI_MCSPI_DOMAIN_MCU, peripheralNum, &spi_cfg);
SPI_Params_init(&spiParams);
spiParams.transferMode = SPI_MODE_BLOCKING;
spiParams.transferCallbackFxn = NULL;
handle = SPI_open(SPI_MCSPI_DOMAIN_MCU, peripheralNum, &spiParams);

Use below sequence for opening the OSPI instance:

...
OSPI_Params ospiParams;
Board_init(boardCfg);
...
OSPI_socGetInitCfg(SPI_OSPI_DOMAIN_MCU, peripheralNum, &spi_cfg);
...
OSPI_socSetInitCfg(SPI_OSPI_DOMAIN_MCU, peripheralNum, &spi_cfg);
OSPI_Params_init(&ospiParams);
ospiParams.transferMode = OSPI_MODE_BLOCKING;
ospiParams.transferCallbackFxn = NULL;
handle = OSPI_open(SPI_OSPI_DOMAIN_MCU, peripheralNum, &ospiParams);

SPI IP V1 driver also supports multi-channel open API’s:

...
Board_init(boardCfg);
...
MCSPI_Params_init(&spiParams);
spiParams.transferMode = SPI_MODE_BLOCKING;
spiParams.transferCallbackFxn = NULL;
handle = MCSPI_open(SPI_MCSPI_DOMAIN_MCU, peripheralNum, channel, &spiParams);

At this point SPI driver is ready for data transfer in blocking mode on specific instance identified by handle. Pseudo/Sample code for SPI read/write transaction is included below. Refer example for additional details

...
spiTransaction.count = n;    /* Transfer Length */
spiTransaction. txBuf = transmitBuffer; /* Buffer to be written */
spiTransaction.rxBuf = NULL;  /* Buffer holding the received data */
transferOK = SPI_transfer(spi, &spiTransaction); /* Perform SPI transfer */
if (!transferOK) {
/* SPI transaction failed */
}

Use below sequence for initiating the transfer with OSPI:

...
OSPI_Transaction ospiTransaction;
ospiTransaction.count = n;    /* Transfer Length */
ospiTransaction.txBuf = transmitBuffer; /* Buffer to be written */
ospiTransaction.rxBuf = NULL;  /* Buffer holding the received data */
transferOK = OSPI_transfer(ospi, &ospiTransaction); /* Perform OSPI transfer */
if (!transferOK) {
/* OSPI transaction failed */
}

SPI IP V1 driver also supports multi-channel transfer API’s:

...
spiTransaction.count = n;    /* Transfer Length */
spiTransaction. txBuf = transmitBuffer; /* Buffer to be written */
spiTransaction.rxBuf = NULL;  /* Buffer holding the received data */
transferOK = MCSPI_transfer(spi, &spiTransaction); /* Perform SPI transfer */
if (!transferOK) {
/* SPI transaction failed */
}

5.12.4.1. OSPI¶

5.12.4.2. MCSPI¶