65 #if (defined (SPI_OVER_LPSPI))
70 #if (defined (SPI_OVER_FLEXIO))
75 #if (defined (SPI_OVER_DSPI))
76 #include "dspi_driver.h"
81 #if (defined(SPI_OVER_LPSPI))
85 static uint32_t LpspiStateInstanceMapping[NO_OF_LPSPI_INSTS_FOR_SPI];
87 static bool LpspiStateIsAllocated[NO_OF_LPSPI_INSTS_FOR_SPI];
93 #if (defined(SPI_OVER_FLEXIO))
96 static flexio_device_state_t FlexioState;
98 static uint32_t FlexioSpiStateInstanceMapping[NO_OF_FLEXIO_INSTS_FOR_SPI];
100 static bool FlexioSpiStateIsAllocated[NO_OF_FLEXIO_INSTS_FOR_SPI];
104 #if (defined(SPI_OVER_DSPI))
106 static dspi_state_t dspiState[NO_OF_DSPI_INSTS_FOR_SPI];
108 static uint32_t DspiStateInstanceMapping[NO_OF_DSPI_INSTS_FOR_SPI];
110 static bool DspiStateIsAllocated[NO_OF_DSPI_INSTS_FOR_SPI];
119 static uint8_t
SpiAllocateState(
bool* isAllocated, uint32_t* instanceMapping, uint32_t instance, uint8_t numberOfinstances)
123 for (i = 0;i < numberOfinstances;i++)
125 if (isAllocated[i] ==
false)
127 instanceMapping[i] = instance;
128 isAllocated[i] =
true;
141 static void SpiFreeState(
bool* isAllocated,
const uint32_t* instanceMapping, uint32_t instance, uint8_t numberOfinstances)
145 for (i = 0;i < numberOfinstances;i++)
147 if (instanceMapping[i] == instance)
149 isAllocated[i] =
false;
155 #if (defined(SPI_OVER_FLEXIO))
162 static uint8_t FindFlexioState(
const spi_instance_t *
const instance)
165 for (i = 0;i<NO_OF_FLEXIO_INSTS_FOR_SPI;i++)
167 if (FlexioSpiStateInstanceMapping[i] == instance->
instIdx)
176 #if (defined(SPI_OVER_DSPI))
183 static uint32_t GetDspiIndex(
const spi_instance_t *
const instance)
186 if (instance->
instType == SPI_INST_TYPE_DSPI)
192 inst = instance->
instIdx + DSPI_INSTANCE_COUNT;
211 #if (defined (SPI_OVER_LPSPI))
230 index =
SpiAllocateState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance->
instIdx, NO_OF_LPSPI_INSTS_FOR_SPI);
237 #if (defined (SPI_OVER_FLEXIO))
262 flexioConfig.
mosiPin = ((extension_flexio_for_spi_t*)(config->
extension))->mosiPin;
263 flexioConfig.
misoPin = ((extension_flexio_for_spi_t*)(config->
extension))->misoPin;
264 flexioConfig.
sckPin = ((extension_flexio_for_spi_t*)(config->
extension))->sckPin;
265 flexioConfig.
ssPin = ((extension_flexio_for_spi_t*)(config->
extension))->ssPin;
276 index =
SpiAllocateState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance->
instIdx, NO_OF_FLEXIO_INSTS_FOR_SPI);
284 #if (defined(SPI_OVER_DSPI))
285 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
287 uint32_t inst = GetDspiIndex(instance);
289 dspi_master_config_t dspiConfig;
290 dspiConfig.bitsPerSec = config->
baudRate;
292 dspiConfig.clkPhase = (dspi_clock_phase_t)config->
clockPhase;
293 dspiConfig.clkPolarity = (dspi_polarity_t)config->
clockPolarity;
294 dspiConfig.isClkContinuous =
false;
295 dspiConfig.lsbFirst = config->
bitOrder;
297 #if(defined(FEATURE_DSPI_HAS_EXTENDED_MODE))
298 dspiConfig.transferType = (dspi_transfer_type_t)config->
transferType;
300 dspiConfig.transferType = DSPI_USING_INTERRUPTS;
304 dspiConfig.whichPCS = config->
ssPin;
305 dspiConfig.pcsPolarity = (dspi_polarity_t)config->
ssPolarity;
306 dspiConfig.callback = config->
callback;
309 index =
SpiAllocateState(DspiStateIsAllocated, DspiStateInstanceMapping, inst, NO_OF_DSPI_INSTS_FOR_SPI);
310 status = DSPI_MasterInit((dspi_instance_t)inst, (dspi_state_t*)&dspiState[index] ,&dspiConfig);
332 #if defined(SPI_OVER_LPSPI)
341 #if defined(SPI_OVER_FLEXIO)
350 #if (defined(SPI_OVER_DSPI))
351 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
353 uint32_t inst = GetDspiIndex(instance);
355 status = DSPI_MasterTransfer((dspi_instance_t)inst, txBuffer, rxBuffer, numberOfFrames);
377 #if defined(SPI_OVER_LPSPI)
386 #if defined(SPI_OVER_FLEXIO)
395 #if (defined(SPI_OVER_DSPI))
396 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
398 uint32_t inst = GetDspiIndex(instance);
400 status = DSPI_MasterTransferBlocking((dspi_instance_t)inst, txBuffer, rxBuffer, numberOfFrames, timeout);
423 #if (defined (SPI_OVER_LPSPI))
439 index =
SpiAllocateState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance->
instIdx, NO_OF_LPSPI_INSTS_FOR_SPI);
446 #if (defined (SPI_OVER_FLEXIO))
470 flexioConfig.
mosiPin = ((extension_flexio_for_spi_t*)(config->
extension))->mosiPin;
471 flexioConfig.
misoPin = ((extension_flexio_for_spi_t*)(config->
extension))->misoPin;
472 flexioConfig.
sckPin = ((extension_flexio_for_spi_t*)(config->
extension))->sckPin;
473 flexioConfig.
ssPin = ((extension_flexio_for_spi_t*)(config->
extension))->ssPin;
484 index =
SpiAllocateState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance->
instIdx, NO_OF_FLEXIO_INSTS_FOR_SPI);
492 #if (defined(SPI_OVER_DSPI))
493 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
497 uint32_t inst = GetDspiIndex(instance);
498 dspi_slave_config_t dspiConfig;
500 dspiConfig.clkPhase = (dspi_clock_phase_t)config->
clockPhase;
501 dspiConfig.clkPolarity = (dspi_polarity_t)config->
clockPolarity;
502 dspiConfig.transferType = (dspi_transfer_type_t)config->
transferType;
505 dspiConfig.callback = config->
callback;
508 index =
SpiAllocateState(DspiStateIsAllocated, DspiStateInstanceMapping, inst, NO_OF_DSPI_INSTS_FOR_SPI);
509 status = DSPI_SlaveInit((dspi_instance_t)inst, (dspi_state_t*)&dspiState[index] ,&dspiConfig);
531 #if defined(SPI_OVER_LPSPI)
540 #if defined(SPI_OVER_FLEXIO)
549 #if (defined(SPI_OVER_DSPI))
550 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
552 uint32_t inst = GetDspiIndex(instance);
553 status = DSPI_SlaveTransfer((dspi_instance_t)inst, txBuffer, rxBuffer, numberOfFrames);
575 #if defined(SPI_OVER_LPSPI)
584 #if defined(SPI_OVER_FLEXIO)
592 #if (defined(SPI_OVER_DSPI))
593 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
595 uint32_t inst = GetDspiIndex(instance);
596 status = DSPI_SlaveTransferBlocking((dspi_instance_t)inst, txBuffer, rxBuffer, numberOfFrames, timeout);
666 #if defined(SPI_OVER_LPSPI)
672 SpiFreeState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance->
instIdx, NO_OF_LPSPI_INSTS_FOR_SPI);
679 #if defined(SPI_OVER_FLEXIO)
685 SpiFreeState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance->
instIdx, NO_OF_FLEXIO_INSTS_FOR_SPI);
692 #if (defined(SPI_OVER_DSPI))
693 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
695 uint32_t inst = GetDspiIndex(instance);
696 status = DSPI_Deinit((dspi_instance_t)inst);
699 SpiFreeState(DspiStateIsAllocated, DspiStateInstanceMapping, inst, NO_OF_DSPI_INSTS_FOR_SPI);
722 #if defined(SPI_OVER_LPSPI)
728 SpiFreeState(LpspiStateIsAllocated, LpspiStateInstanceMapping, instance->
instIdx, NO_OF_LPSPI_INSTS_FOR_SPI);
735 #if defined(SPI_OVER_FLEXIO)
741 SpiFreeState(FlexioSpiStateIsAllocated, FlexioSpiStateInstanceMapping, instance->
instIdx, NO_OF_FLEXIO_INSTS_FOR_SPI);
748 #if (defined(SPI_OVER_DSPI))
749 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
751 uint32_t inst = GetDspiIndex(instance);
752 status = DSPI_Deinit((dspi_instance_t)inst);
755 SpiFreeState(DspiStateIsAllocated, DspiStateInstanceMapping, inst, NO_OF_DSPI_INSTS_FOR_SPI);
778 #if defined(SPI_OVER_LPSPI)
787 #if defined(SPI_OVER_FLEXIO)
797 #if (defined(SPI_OVER_DSPI))
798 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
800 uint32_t inst = GetDspiIndex(instance);
801 status = DSPI_UpdateCS((dspi_instance_t)inst, ss);
824 #if defined(SPI_OVER_LPSPI)
829 for (i = 0; i < NO_OF_LPSPI_INSTS_FOR_SPI; i++)
831 if (LpspiStateInstanceMapping[i] == instance->
instIdx)
841 #if defined(SPI_OVER_FLEXIO)
857 #if (defined(SPI_OVER_DSPI))
858 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
860 dspi_transfer_status_t dspiStatus;
861 uint32_t inst = GetDspiIndex(instance);
862 (void)DSPI_GetTransferStatus((dspi_instance_t)inst, &dspiStatus);
863 if (dspiStatus == DSPI_TRANSFER_OK)
888 uint32_t delaySCKtoPCS, uint32_t delayPCStoSCK)
893 #if defined(SPI_OVER_LPSPI)
902 #if defined(SPI_OVER_FLEXIO)
911 #if (defined(SPI_OVER_DSPI))
912 if ((instance->
instType == SPI_INST_TYPE_SPI) || (instance->
instType == SPI_INST_TYPE_DSPI))
914 uint32_t inst = GetDspiIndex(instance);
915 status = DSPI_MasterSetDelay((dspi_instance_t)inst, delayBetweenTransfers, delaySCKtoPCS, delayPCStoSCK);
spi_clock_phase_t clockPhase
#define LPSPI_INSTANCE_COUNT
status_t SPI_SlaveTransferBlocking(const spi_instance_t *const instance, const void *txBuffer, void *rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
Initializes a blocking slave transfer.
Runtime state structure for the LPSPI master driver.
Data structure containing information about a device on the SPI bus.
flexio_spi_transfer_size_t transferSize
spi_polarity_t clockPolarity
lpspi_signal_polarity_t pcsPolarity
status_t FLEXIO_SPI_DRV_MasterTransferBlocking(flexio_spi_master_state_t *master, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize, uint32_t timeout)
Perform a blocking SPI master transaction.
status_t SPI_SetSS(const spi_instance_t *const instance, uint8_t ss)
Update the SS.
status_t LPSPI_DRV_SetPcs(uint32_t instance, lpspi_which_pcs_t whichPcs, lpspi_signal_polarity_t polarity)
Select the chip to communicate with.
status_t SPI_SlaveTransfer(const spi_instance_t *const instance, const void *txBuffer, void *rxBuffer, uint16_t numberOfFrames)
Initializes a non-blocking slave transfer.
status_t LPSPI_DRV_MasterDeinit(uint32_t instance)
Shuts down a LPSPI instance.
lpspi_transfer_type transferType
lpspi_signal_polarity_t pcsPolarity
status_t FLEXIO_SPI_DRV_MasterTransfer(flexio_spi_master_state_t *master, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize)
Perform a non-blocking SPI master transaction.
flexio_spi_transfer_bit_order_t
Order in which the data bits are transferred Implements : flexio_spi_transfer_bit_order_t_Class.
flexio_spi_transfer_bit_order_t bitOrder
status_t LPSPI_DRV_MasterInit(uint32_t instance, lpspi_state_t *lpspiState, const lpspi_master_config_t *spiConfig)
Initializes a LPSPI instance for interrupt driven master mode operation.
status_t LPSPI_DRV_MasterTransfer(uint32_t instance, const uint8_t *sendBuffer, uint8_t *receiveBuffer, uint16_t transferByteCount)
Performs an interrupt driven non-blocking SPI master mode transfer.
lpspi_which_pcs_t whichPcs
status_t LPSPI_DRV_SlaveTransfer(uint32_t instance, const uint8_t *sendBuffer, uint8_t *receiveBuffer, uint16_t transferByteCount)
Starts the transfer data on LPSPI bus using a non-blocking call.
status_t SPI_GetDefaultMasterConfig(spi_master_t *config)
Gets the default configuration structure for master.
lpspi_clock_phase_t clkPhase
status_t FLEXIO_SPI_DRV_MasterGetStatus(flexio_spi_master_state_t *master, uint32_t *bytesRemaining)
Get the status of the current non-blocking SPI master transaction.
Slave configuration structure.
static status_t FLEXIO_SPI_DRV_SlaveTransfer(flexio_spi_slave_state_t *slave, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize)
Perform a non-blocking SPI slave transaction.
flexio_driver_type_t driverType
status_t LPSPI_DRV_SlaveTransferBlocking(uint32_t instance, const uint8_t *sendBuffer, uint8_t *receiveBuffer, uint16_t transferByteCount, uint32_t timeout)
Transfers data on LPSPI bus using a blocking call.
lpspi_clock_phase_t clkPhase
status_t CLOCK_SYS_GetFreq(clock_names_t clockName, uint32_t *frequency)
Gets the clock frequency for a specific clock name.
spi_clock_phase_t clockPhase
status_t LPSPI_DRV_MasterTransferBlocking(uint32_t instance, const uint8_t *sendBuffer, uint8_t *receiveBuffer, uint16_t transferByteCount, uint32_t timeout)
Performs an interrupt driven blocking SPI master mode transfer.
lpspi_sck_polarity_t clkPolarity
flexio_spi_transfer_size_t transferSize
status_t LPSPI_DRV_MasterSetDelay(uint32_t instance, uint32_t delayBetwenTransfers, uint32_t delaySCKtoPCS, uint32_t delayPCStoSCK)
Configures the LPSPI master mode bus timing delay options.
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
spi_transfer_bit_order_t bitOrder
lpspi_signal_polarity_t
LPSPI Signal (PCS and Host Request) Polarity configuration. Implements : lpspi_signal_polarity_t_Clas...
Master configuration structure.
lpspi_transfer_type
Type of LPSPI transfer (based on interrupts or DMA). Implements : lpspi_transfer_type_Class.
static status_t FLEXIO_SPI_DRV_SlaveTransferBlocking(flexio_spi_slave_state_t *slave, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize, uint32_t timeout)
Perform a blocking SPI slave transaction.
status_t LPSPI_DRV_SlaveInit(uint32_t instance, lpspi_state_t *lpspiState, const lpspi_slave_config_t *slaveConfig)
Initializes a LPSPI instance for a slave mode operation, using interrupt mechanism.
lpspi_which_pcs_t
LPSPI Peripheral Chip Select (PCS) configuration (which PCS to configure). Implements : lpspi_which_p...
spi_polarity_t clockPolarity
Defines the configuration structure for SPI slave Implements: spi_slave_t_Class.
status_t SPI_GetStatus(const spi_instance_t *const instance)
Gets the status of the last transfer.
status_t FLEXIO_SPI_DRV_SlaveInit(uint32_t instance, const flexio_spi_slave_user_config_t *userConfigPtr, flexio_spi_slave_state_t *slave)
Initialize the FLEXIO_SPI slave mode driver.
#define FEATURE_LPSPI_CLOCKS_NAMES
User configuration structure for the SPI slave driver. Implements : lpspi_slave_config_t_Class.
lpspi_clock_phase_t
LPSPI clock phase configuration. Implements : lpspi_clock_phase_t_Class.
flexio_spi_transfer_bit_order_t bitOrder
spi_transfer_type_t transferType
spi_transfer_bit_order_t bitOrder
Defines the configuration structure for SPI master Implements : spi_master_t_Class.
lpspi_sck_polarity_t
LPSPI Clock Signal (SCK) Polarity configuration. Implements : lpspi_sck_polarity_t_Class.
status_t SPI_MasterDeinit(const spi_instance_t *const instance)
De-initializes the spi master module.
static void SpiFreeState(bool *isAllocated, const uint32_t *instanceMapping, uint32_t instance, uint8_t numberOfinstances)
spi_polarity_t ssPolarity
lpspi_which_pcs_t whichPcs
Structure storing PAL instance information.
volatile bool isTransferInProgress
static status_t FLEXIO_SPI_DRV_SlaveDeinit(flexio_spi_slave_state_t *slave)
De-initialize the FLEXIO_SPI slave mode driver.
status_t SPI_GetDefaultSlaveConfig(spi_slave_t *config)
Gets the default configuration structure for slave.
status_t FLEXIO_SPI_DRV_MasterInit(uint32_t instance, const flexio_spi_master_user_config_t *userConfigPtr, flexio_spi_master_state_t *master)
Initialize the FLEXIO_SPI master mode driver.
status_t SPI_MasterInit(const spi_instance_t *const instance, const spi_master_t *config)
Initializes the SPI module in master mode.
status_t SPI_MasterTransfer(const spi_instance_t *const instance, const void *txBuffer, void *rxBuffer, uint16_t numberOfFrames)
Initializes a non-blocking master transfer.
status_t FLEXIO_SPI_DRV_MasterDeinit(flexio_spi_master_state_t *master)
De-initialize the FLEXIO_SPI master mode driver.
lpspi_transfer_type transferType
spi_polarity_t ssPolarity
status_t LPSPI_DRV_SlaveDeinit(uint32_t instance)
Shuts down an LPSPI instance interrupt mechanism.
status_t SPI_MasterSetDelay(const spi_instance_t *const instance, uint32_t delayBetweenTransfers, uint32_t delaySCKtoPCS, uint32_t delayPCStoSCK)
Configures the SPI_PAL master mode bus timing delay options.
status_t SPI_SlaveInit(const spi_instance_t *const instance, const spi_slave_t *config)
Initializes the SPI module in slave mode.
lpspi_sck_polarity_t clkPolarity
Master internal context structure.
flexio_driver_type_t driverType
clock_names_t
Clock names.
status_t SPI_MasterTransferBlocking(const spi_instance_t *const instance, const void *txBuffer, void *rxBuffer, uint16_t numberOfFrames, uint16_t timeout)
Initializes a blocking master transfer.
status_t FLEXIO_DRV_InitDevice(uint32_t instance, flexio_device_state_t *deviceState)
Initializes the FlexIO device.
spi_transfer_type_t transferType
status_t SPI_SlaveDeinit(const spi_instance_t *const instance)
De-initializes the spi slave module.
static uint8_t SpiAllocateState(bool *isAllocated, uint32_t *instanceMapping, uint32_t instance, uint8_t numberOfinstances)