| /* |
| * Copyright (c) 2015, Freescale Semiconductor, Inc. |
| * Copyright 2016-2017 NXP |
| * All rights reserved. |
| * |
| * SPDX-License-Identifier: BSD-3-Clause |
| */ |
| |
| #include "fsl_flexio_spi.h" |
| |
| /******************************************************************************* |
| * Definitions |
| ******************************************************************************/ |
| |
| /* Component ID definition, used by tools. */ |
| #ifndef FSL_COMPONENT_ID |
| #define FSL_COMPONENT_ID "platform.drivers.flexio_spi" |
| #endif |
| |
| /*! @brief FLEXIO SPI transfer state, which is used for SPI transactiaonl APIs' internal state. */ |
| enum _flexio_spi_transfer_states |
| { |
| kFLEXIO_SPI_Idle = 0x0U, /*!< Nothing in the transmitter/receiver's queue. */ |
| kFLEXIO_SPI_Busy, /*!< Transmiter/Receive's queue is not finished. */ |
| }; |
| |
| /******************************************************************************* |
| * Prototypes |
| ******************************************************************************/ |
| |
| /*! |
| * @brief Send a piece of data for SPI. |
| * |
| * This function computes the number of data to be written into D register or Tx FIFO, |
| * and write the data into it. At the same time, this function updates the values in |
| * master handle structure. |
| * |
| * @param base pointer to FLEXIO_SPI_Type structure |
| * @param handle Pointer to SPI master handle structure. |
| */ |
| static void FLEXIO_SPI_TransferSendTransaction(FLEXIO_SPI_Type *base, flexio_spi_master_handle_t *handle); |
| |
| /*! |
| * @brief Receive a piece of data for SPI master. |
| * |
| * This function computes the number of data to receive from D register or Rx FIFO, |
| * and write the data to destination address. At the same time, this function updates |
| * the values in master handle structure. |
| * |
| * @param base pointer to FLEXIO_SPI_Type structure |
| * @param handle Pointer to SPI master handle structure. |
| */ |
| static void FLEXIO_SPI_TransferReceiveTransaction(FLEXIO_SPI_Type *base, flexio_spi_master_handle_t *handle); |
| |
| /******************************************************************************* |
| * Variables |
| ******************************************************************************/ |
| |
| /******************************************************************************* |
| * Codes |
| ******************************************************************************/ |
| |
| static uint32_t FLEXIO_SPI_GetInstance(FLEXIO_SPI_Type *base) |
| { |
| return FLEXIO_GetInstance(base->flexioBase); |
| } |
| |
| static void FLEXIO_SPI_TransferSendTransaction(FLEXIO_SPI_Type *base, flexio_spi_master_handle_t *handle) |
| { |
| uint16_t tmpData = FLEXIO_SPI_DUMMYDATA; |
| |
| if (handle->txData != NULL) |
| { |
| /* Transmit data and update tx size/buff. */ |
| if (handle->bytePerFrame == 1U) |
| { |
| tmpData = *(handle->txData); |
| handle->txData++; |
| } |
| else |
| { |
| if (handle->direction == kFLEXIO_SPI_MsbFirst) |
| { |
| tmpData = (uint32_t)(handle->txData[0]) << 8U; |
| tmpData += handle->txData[1]; |
| } |
| else |
| { |
| tmpData = (uint32_t)(handle->txData[1]) << 8U; |
| tmpData += handle->txData[0]; |
| } |
| handle->txData += 2U; |
| } |
| } |
| else |
| { |
| tmpData = FLEXIO_SPI_DUMMYDATA; |
| } |
| |
| handle->txRemainingBytes -= handle->bytePerFrame; |
| |
| FLEXIO_SPI_WriteData(base, handle->direction, tmpData); |
| |
| if (!handle->txRemainingBytes) |
| { |
| FLEXIO_SPI_DisableInterrupts(base, kFLEXIO_SPI_TxEmptyInterruptEnable); |
| } |
| } |
| |
| static void FLEXIO_SPI_TransferReceiveTransaction(FLEXIO_SPI_Type *base, flexio_spi_master_handle_t *handle) |
| { |
| uint16_t tmpData; |
| |
| tmpData = FLEXIO_SPI_ReadData(base, handle->direction); |
| |
| if (handle->rxData != NULL) |
| { |
| if (handle->bytePerFrame == 1U) |
| { |
| *handle->rxData = tmpData; |
| handle->rxData++; |
| } |
| else |
| { |
| if (handle->direction == kFLEXIO_SPI_MsbFirst) |
| { |
| *((uint16_t *)(handle->rxData)) = tmpData; |
| } |
| else |
| { |
| *((uint16_t *)(handle->rxData)) = (((tmpData << 8) & 0xff00U) | ((tmpData >> 8) & 0x00ffU)); |
| } |
| handle->rxData += 2U; |
| } |
| } |
| handle->rxRemainingBytes -= handle->bytePerFrame; |
| } |
| |
| /*! |
| * brief Ungates the FlexIO clock, resets the FlexIO module, configures the FlexIO SPI master hardware, |
| * and configures the FlexIO SPI with FlexIO SPI master configuration. The |
| * configuration structure can be filled by the user, or be set with default values |
| * by the FLEXIO_SPI_MasterGetDefaultConfig(). |
| * |
| * note FlexIO SPI master only support CPOL = 0, which means clock inactive low. |
| * |
| * Example |
| code |
| FLEXIO_SPI_Type spiDev = { |
| .flexioBase = FLEXIO, |
| .SDOPinIndex = 0, |
| .SDIPinIndex = 1, |
| .SCKPinIndex = 2, |
| .CSnPinIndex = 3, |
| .shifterIndex = {0,1}, |
| .timerIndex = {0,1} |
| }; |
| flexio_spi_master_config_t config = { |
| .enableMaster = true, |
| .enableInDoze = false, |
| .enableInDebug = true, |
| .enableFastAccess = false, |
| .baudRate_Bps = 500000, |
| .phase = kFLEXIO_SPI_ClockPhaseFirstEdge, |
| .direction = kFLEXIO_SPI_MsbFirst, |
| .dataMode = kFLEXIO_SPI_8BitMode |
| }; |
| FLEXIO_SPI_MasterInit(&spiDev, &config, srcClock_Hz); |
| endcode |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param masterConfig Pointer to the flexio_spi_master_config_t structure. |
| * param srcClock_Hz FlexIO source clock in Hz. |
| */ |
| void FLEXIO_SPI_MasterInit(FLEXIO_SPI_Type *base, flexio_spi_master_config_t *masterConfig, uint32_t srcClock_Hz) |
| { |
| assert(base); |
| assert(masterConfig); |
| |
| flexio_shifter_config_t shifterConfig; |
| flexio_timer_config_t timerConfig; |
| uint32_t ctrlReg = 0; |
| uint16_t timerDiv = 0; |
| uint16_t timerCmp = 0; |
| |
| /* Clear the shifterConfig & timerConfig struct. */ |
| memset(&shifterConfig, 0, sizeof(shifterConfig)); |
| memset(&timerConfig, 0, sizeof(timerConfig)); |
| |
| #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) |
| /* Ungate flexio clock. */ |
| CLOCK_EnableClock(s_flexioClocks[FLEXIO_SPI_GetInstance(base)]); |
| #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ |
| |
| /* Configure FLEXIO SPI Master */ |
| ctrlReg = base->flexioBase->CTRL; |
| ctrlReg &= ~(FLEXIO_CTRL_DOZEN_MASK | FLEXIO_CTRL_DBGE_MASK | FLEXIO_CTRL_FASTACC_MASK | FLEXIO_CTRL_FLEXEN_MASK); |
| ctrlReg |= (FLEXIO_CTRL_DBGE(masterConfig->enableInDebug) | FLEXIO_CTRL_FASTACC(masterConfig->enableFastAccess) | |
| FLEXIO_CTRL_FLEXEN(masterConfig->enableMaster)); |
| if (!masterConfig->enableInDoze) |
| { |
| ctrlReg |= FLEXIO_CTRL_DOZEN_MASK; |
| } |
| |
| base->flexioBase->CTRL = ctrlReg; |
| |
| /* Do hardware configuration. */ |
| /* 1. Configure the shifter 0 for tx. */ |
| shifterConfig.timerSelect = base->timerIndex[0]; |
| shifterConfig.pinConfig = kFLEXIO_PinConfigOutput; |
| shifterConfig.pinSelect = base->SDOPinIndex; |
| shifterConfig.pinPolarity = kFLEXIO_PinActiveHigh; |
| shifterConfig.shifterMode = kFLEXIO_ShifterModeTransmit; |
| shifterConfig.inputSource = kFLEXIO_ShifterInputFromPin; |
| if (masterConfig->phase == kFLEXIO_SPI_ClockPhaseFirstEdge) |
| { |
| shifterConfig.timerPolarity = kFLEXIO_ShifterTimerPolarityOnNegitive; |
| shifterConfig.shifterStop = kFLEXIO_ShifterStopBitDisable; |
| shifterConfig.shifterStart = kFLEXIO_ShifterStartBitDisabledLoadDataOnEnable; |
| } |
| else |
| { |
| shifterConfig.timerPolarity = kFLEXIO_ShifterTimerPolarityOnPositive; |
| shifterConfig.shifterStop = kFLEXIO_ShifterStopBitLow; |
| shifterConfig.shifterStart = kFLEXIO_ShifterStartBitDisabledLoadDataOnShift; |
| } |
| |
| FLEXIO_SetShifterConfig(base->flexioBase, base->shifterIndex[0], &shifterConfig); |
| |
| /* 2. Configure the shifter 1 for rx. */ |
| shifterConfig.timerSelect = base->timerIndex[0]; |
| shifterConfig.pinConfig = kFLEXIO_PinConfigOutputDisabled; |
| shifterConfig.pinSelect = base->SDIPinIndex; |
| shifterConfig.pinPolarity = kFLEXIO_PinActiveHigh; |
| shifterConfig.shifterMode = kFLEXIO_ShifterModeReceive; |
| shifterConfig.inputSource = kFLEXIO_ShifterInputFromPin; |
| shifterConfig.shifterStop = kFLEXIO_ShifterStopBitDisable; |
| shifterConfig.shifterStart = kFLEXIO_ShifterStartBitDisabledLoadDataOnEnable; |
| if (masterConfig->phase == kFLEXIO_SPI_ClockPhaseFirstEdge) |
| { |
| shifterConfig.timerPolarity = kFLEXIO_ShifterTimerPolarityOnPositive; |
| } |
| else |
| { |
| shifterConfig.timerPolarity = kFLEXIO_ShifterTimerPolarityOnNegitive; |
| } |
| |
| FLEXIO_SetShifterConfig(base->flexioBase, base->shifterIndex[1], &shifterConfig); |
| |
| /*3. Configure the timer 0 for SCK. */ |
| timerConfig.triggerSelect = FLEXIO_TIMER_TRIGGER_SEL_SHIFTnSTAT(base->shifterIndex[0]); |
| timerConfig.triggerPolarity = kFLEXIO_TimerTriggerPolarityActiveLow; |
| timerConfig.triggerSource = kFLEXIO_TimerTriggerSourceInternal; |
| timerConfig.pinConfig = kFLEXIO_PinConfigOutput; |
| timerConfig.pinSelect = base->SCKPinIndex; |
| timerConfig.pinPolarity = kFLEXIO_PinActiveHigh; |
| timerConfig.timerMode = kFLEXIO_TimerModeDual8BitBaudBit; |
| timerConfig.timerOutput = kFLEXIO_TimerOutputZeroNotAffectedByReset; |
| timerConfig.timerDecrement = kFLEXIO_TimerDecSrcOnFlexIOClockShiftTimerOutput; |
| timerConfig.timerReset = kFLEXIO_TimerResetNever; |
| timerConfig.timerDisable = kFLEXIO_TimerDisableOnTimerCompare; |
| timerConfig.timerEnable = kFLEXIO_TimerEnableOnTriggerHigh; |
| timerConfig.timerStop = kFLEXIO_TimerStopBitEnableOnTimerDisable; |
| timerConfig.timerStart = kFLEXIO_TimerStartBitEnabled; |
| |
| timerDiv = srcClock_Hz / masterConfig->baudRate_Bps; |
| timerDiv = timerDiv / 2 - 1; |
| |
| timerCmp = ((uint32_t)(masterConfig->dataMode * 2 - 1U)) << 8U; |
| timerCmp |= timerDiv; |
| |
| timerConfig.timerCompare = timerCmp; |
| |
| FLEXIO_SetTimerConfig(base->flexioBase, base->timerIndex[0], &timerConfig); |
| |
| /* 4. Configure the timer 1 for CSn. */ |
| timerConfig.triggerSelect = FLEXIO_TIMER_TRIGGER_SEL_TIMn(base->timerIndex[0]); |
| timerConfig.triggerPolarity = kFLEXIO_TimerTriggerPolarityActiveHigh; |
| timerConfig.triggerSource = kFLEXIO_TimerTriggerSourceInternal; |
| timerConfig.pinConfig = kFLEXIO_PinConfigOutput; |
| timerConfig.pinSelect = base->CSnPinIndex; |
| timerConfig.pinPolarity = kFLEXIO_PinActiveLow; |
| timerConfig.timerMode = kFLEXIO_TimerModeSingle16Bit; |
| timerConfig.timerOutput = kFLEXIO_TimerOutputOneNotAffectedByReset; |
| timerConfig.timerDecrement = kFLEXIO_TimerDecSrcOnFlexIOClockShiftTimerOutput; |
| timerConfig.timerReset = kFLEXIO_TimerResetNever; |
| timerConfig.timerDisable = kFLEXIO_TimerDisableOnPreTimerDisable; |
| timerConfig.timerEnable = kFLEXIO_TimerEnableOnPrevTimerEnable; |
| timerConfig.timerStop = kFLEXIO_TimerStopBitDisabled; |
| timerConfig.timerStart = kFLEXIO_TimerStartBitDisabled; |
| |
| timerConfig.timerCompare = 0xFFFFU; |
| |
| FLEXIO_SetTimerConfig(base->flexioBase, base->timerIndex[1], &timerConfig); |
| } |
| |
| /*! |
| * brief Resets the FlexIO SPI timer and shifter config. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type. |
| */ |
| void FLEXIO_SPI_MasterDeinit(FLEXIO_SPI_Type *base) |
| { |
| base->flexioBase->SHIFTCFG[base->shifterIndex[0]] = 0; |
| base->flexioBase->SHIFTCTL[base->shifterIndex[0]] = 0; |
| base->flexioBase->SHIFTCFG[base->shifterIndex[1]] = 0; |
| base->flexioBase->SHIFTCTL[base->shifterIndex[1]] = 0; |
| base->flexioBase->TIMCFG[base->timerIndex[0]] = 0; |
| base->flexioBase->TIMCMP[base->timerIndex[0]] = 0; |
| base->flexioBase->TIMCTL[base->timerIndex[0]] = 0; |
| base->flexioBase->TIMCFG[base->timerIndex[1]] = 0; |
| base->flexioBase->TIMCMP[base->timerIndex[1]] = 0; |
| base->flexioBase->TIMCTL[base->timerIndex[1]] = 0; |
| } |
| |
| /*! |
| * brief Gets the default configuration to configure the FlexIO SPI master. The configuration |
| * can be used directly by calling the FLEXIO_SPI_MasterConfigure(). |
| * Example: |
| code |
| flexio_spi_master_config_t masterConfig; |
| FLEXIO_SPI_MasterGetDefaultConfig(&masterConfig); |
| endcode |
| * param masterConfig Pointer to the flexio_spi_master_config_t structure. |
| */ |
| void FLEXIO_SPI_MasterGetDefaultConfig(flexio_spi_master_config_t *masterConfig) |
| { |
| assert(masterConfig); |
| |
| /* Initializes the configure structure to zero. */ |
| memset(masterConfig, 0, sizeof(*masterConfig)); |
| |
| masterConfig->enableMaster = true; |
| masterConfig->enableInDoze = false; |
| masterConfig->enableInDebug = true; |
| masterConfig->enableFastAccess = false; |
| /* Default baud rate 500kbps. */ |
| masterConfig->baudRate_Bps = 500000U; |
| /* Default CPHA = 0. */ |
| masterConfig->phase = kFLEXIO_SPI_ClockPhaseFirstEdge; |
| /* Default bit count at 8. */ |
| masterConfig->dataMode = kFLEXIO_SPI_8BitMode; |
| } |
| |
| /*! |
| * brief Ungates the FlexIO clock, resets the FlexIO module, configures the FlexIO SPI slave hardware |
| * configuration, and configures the FlexIO SPI with FlexIO SPI slave configuration. The |
| * configuration structure can be filled by the user, or be set with default values |
| * by the FLEXIO_SPI_SlaveGetDefaultConfig(). |
| * |
| * note Only one timer is needed in the FlexIO SPI slave. As a result, the second timer index is ignored. |
| * FlexIO SPI slave only support CPOL = 0, which means clock inactive low. |
| * Example |
| code |
| FLEXIO_SPI_Type spiDev = { |
| .flexioBase = FLEXIO, |
| .SDOPinIndex = 0, |
| .SDIPinIndex = 1, |
| .SCKPinIndex = 2, |
| .CSnPinIndex = 3, |
| .shifterIndex = {0,1}, |
| .timerIndex = {0} |
| }; |
| flexio_spi_slave_config_t config = { |
| .enableSlave = true, |
| .enableInDoze = false, |
| .enableInDebug = true, |
| .enableFastAccess = false, |
| .phase = kFLEXIO_SPI_ClockPhaseFirstEdge, |
| .direction = kFLEXIO_SPI_MsbFirst, |
| .dataMode = kFLEXIO_SPI_8BitMode |
| }; |
| FLEXIO_SPI_SlaveInit(&spiDev, &config); |
| endcode |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param slaveConfig Pointer to the flexio_spi_slave_config_t structure. |
| */ |
| void FLEXIO_SPI_SlaveInit(FLEXIO_SPI_Type *base, flexio_spi_slave_config_t *slaveConfig) |
| { |
| assert(base && slaveConfig); |
| |
| flexio_shifter_config_t shifterConfig; |
| flexio_timer_config_t timerConfig; |
| uint32_t ctrlReg = 0; |
| |
| /* Clear the shifterConfig & timerConfig struct. */ |
| memset(&shifterConfig, 0, sizeof(shifterConfig)); |
| memset(&timerConfig, 0, sizeof(timerConfig)); |
| |
| #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) |
| /* Ungate flexio clock. */ |
| CLOCK_EnableClock(s_flexioClocks[FLEXIO_SPI_GetInstance(base)]); |
| #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ |
| |
| /* Configure FLEXIO SPI Slave */ |
| ctrlReg = base->flexioBase->CTRL; |
| ctrlReg &= ~(FLEXIO_CTRL_DOZEN_MASK | FLEXIO_CTRL_DBGE_MASK | FLEXIO_CTRL_FASTACC_MASK | FLEXIO_CTRL_FLEXEN_MASK); |
| ctrlReg |= (FLEXIO_CTRL_DBGE(slaveConfig->enableInDebug) | FLEXIO_CTRL_FASTACC(slaveConfig->enableFastAccess) | |
| FLEXIO_CTRL_FLEXEN(slaveConfig->enableSlave)); |
| if (!slaveConfig->enableInDoze) |
| { |
| ctrlReg |= FLEXIO_CTRL_DOZEN_MASK; |
| } |
| |
| base->flexioBase->CTRL = ctrlReg; |
| |
| /* Do hardware configuration. */ |
| /* 1. Configure the shifter 0 for tx. */ |
| shifterConfig.timerSelect = base->timerIndex[0]; |
| shifterConfig.pinConfig = kFLEXIO_PinConfigOutput; |
| shifterConfig.pinSelect = base->SDOPinIndex; |
| shifterConfig.pinPolarity = kFLEXIO_PinActiveHigh; |
| shifterConfig.shifterMode = kFLEXIO_ShifterModeTransmit; |
| shifterConfig.inputSource = kFLEXIO_ShifterInputFromPin; |
| shifterConfig.shifterStop = kFLEXIO_ShifterStopBitDisable; |
| if (slaveConfig->phase == kFLEXIO_SPI_ClockPhaseFirstEdge) |
| { |
| shifterConfig.timerPolarity = kFLEXIO_ShifterTimerPolarityOnNegitive; |
| shifterConfig.shifterStart = kFLEXIO_ShifterStartBitDisabledLoadDataOnEnable; |
| } |
| else |
| { |
| shifterConfig.timerPolarity = kFLEXIO_ShifterTimerPolarityOnPositive; |
| shifterConfig.shifterStart = kFLEXIO_ShifterStartBitDisabledLoadDataOnShift; |
| } |
| |
| FLEXIO_SetShifterConfig(base->flexioBase, base->shifterIndex[0], &shifterConfig); |
| |
| /* 2. Configure the shifter 1 for rx. */ |
| shifterConfig.timerSelect = base->timerIndex[0]; |
| shifterConfig.pinConfig = kFLEXIO_PinConfigOutputDisabled; |
| shifterConfig.pinSelect = base->SDIPinIndex; |
| shifterConfig.pinPolarity = kFLEXIO_PinActiveHigh; |
| shifterConfig.shifterMode = kFLEXIO_ShifterModeReceive; |
| shifterConfig.inputSource = kFLEXIO_ShifterInputFromPin; |
| shifterConfig.shifterStop = kFLEXIO_ShifterStopBitDisable; |
| shifterConfig.shifterStart = kFLEXIO_ShifterStartBitDisabledLoadDataOnEnable; |
| if (slaveConfig->phase == kFLEXIO_SPI_ClockPhaseFirstEdge) |
| { |
| shifterConfig.timerPolarity = kFLEXIO_ShifterTimerPolarityOnPositive; |
| } |
| else |
| { |
| shifterConfig.timerPolarity = kFLEXIO_ShifterTimerPolarityOnNegitive; |
| } |
| |
| FLEXIO_SetShifterConfig(base->flexioBase, base->shifterIndex[1], &shifterConfig); |
| |
| /*3. Configure the timer 0 for shift clock. */ |
| timerConfig.triggerSelect = FLEXIO_TIMER_TRIGGER_SEL_PININPUT(base->CSnPinIndex); |
| timerConfig.triggerPolarity = kFLEXIO_TimerTriggerPolarityActiveLow; |
| timerConfig.triggerSource = kFLEXIO_TimerTriggerSourceInternal; |
| timerConfig.pinConfig = kFLEXIO_PinConfigOutputDisabled; |
| timerConfig.pinSelect = base->SCKPinIndex; |
| timerConfig.pinPolarity = kFLEXIO_PinActiveHigh; |
| timerConfig.timerMode = kFLEXIO_TimerModeSingle16Bit; |
| timerConfig.timerOutput = kFLEXIO_TimerOutputZeroNotAffectedByReset; |
| timerConfig.timerDecrement = kFLEXIO_TimerDecSrcOnPinInputShiftPinInput; |
| timerConfig.timerReset = kFLEXIO_TimerResetNever; |
| timerConfig.timerEnable = kFLEXIO_TimerEnableOnTriggerRisingEdge; |
| timerConfig.timerStop = kFLEXIO_TimerStopBitDisabled; |
| if (slaveConfig->phase == kFLEXIO_SPI_ClockPhaseFirstEdge) |
| { |
| /* The configuration kFLEXIO_TimerDisableOnTimerCompare only support continuous |
| PCS access, change to kFLEXIO_TimerDisableNever to enable discontinuous PCS access. */ |
| timerConfig.timerDisable = kFLEXIO_TimerDisableOnTimerCompare; |
| timerConfig.timerStart = kFLEXIO_TimerStartBitDisabled; |
| } |
| else |
| { |
| timerConfig.timerDisable = kFLEXIO_TimerDisableOnTriggerFallingEdge; |
| timerConfig.timerStart = kFLEXIO_TimerStartBitEnabled; |
| } |
| |
| timerConfig.timerCompare = slaveConfig->dataMode * 2 - 1U; |
| |
| FLEXIO_SetTimerConfig(base->flexioBase, base->timerIndex[0], &timerConfig); |
| } |
| |
| /*! |
| * brief Gates the FlexIO clock. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type. |
| */ |
| void FLEXIO_SPI_SlaveDeinit(FLEXIO_SPI_Type *base) |
| { |
| FLEXIO_SPI_MasterDeinit(base); |
| } |
| |
| /*! |
| * brief Gets the default configuration to configure the FlexIO SPI slave. The configuration |
| * can be used directly for calling the FLEXIO_SPI_SlaveConfigure(). |
| * Example: |
| code |
| flexio_spi_slave_config_t slaveConfig; |
| FLEXIO_SPI_SlaveGetDefaultConfig(&slaveConfig); |
| endcode |
| * param slaveConfig Pointer to the flexio_spi_slave_config_t structure. |
| */ |
| void FLEXIO_SPI_SlaveGetDefaultConfig(flexio_spi_slave_config_t *slaveConfig) |
| { |
| assert(slaveConfig); |
| |
| /* Initializes the configure structure to zero. */ |
| memset(slaveConfig, 0, sizeof(*slaveConfig)); |
| |
| slaveConfig->enableSlave = true; |
| slaveConfig->enableInDoze = false; |
| slaveConfig->enableInDebug = true; |
| slaveConfig->enableFastAccess = false; |
| /* Default CPHA = 0. */ |
| slaveConfig->phase = kFLEXIO_SPI_ClockPhaseFirstEdge; |
| /* Default bit count at 8. */ |
| slaveConfig->dataMode = kFLEXIO_SPI_8BitMode; |
| } |
| |
| /*! |
| * brief Enables the FlexIO SPI interrupt. |
| * |
| * This function enables the FlexIO SPI interrupt. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param mask interrupt source. The parameter can be any combination of the following values: |
| * arg kFLEXIO_SPI_RxFullInterruptEnable |
| * arg kFLEXIO_SPI_TxEmptyInterruptEnable |
| */ |
| void FLEXIO_SPI_EnableInterrupts(FLEXIO_SPI_Type *base, uint32_t mask) |
| { |
| if (mask & kFLEXIO_SPI_TxEmptyInterruptEnable) |
| { |
| FLEXIO_EnableShifterStatusInterrupts(base->flexioBase, 1 << base->shifterIndex[0]); |
| } |
| if (mask & kFLEXIO_SPI_RxFullInterruptEnable) |
| { |
| FLEXIO_EnableShifterStatusInterrupts(base->flexioBase, 1 << base->shifterIndex[1]); |
| } |
| } |
| |
| /*! |
| * brief Disables the FlexIO SPI interrupt. |
| * |
| * This function disables the FlexIO SPI interrupt. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param mask interrupt source The parameter can be any combination of the following values: |
| * arg kFLEXIO_SPI_RxFullInterruptEnable |
| * arg kFLEXIO_SPI_TxEmptyInterruptEnable |
| */ |
| void FLEXIO_SPI_DisableInterrupts(FLEXIO_SPI_Type *base, uint32_t mask) |
| { |
| if (mask & kFLEXIO_SPI_TxEmptyInterruptEnable) |
| { |
| FLEXIO_DisableShifterStatusInterrupts(base->flexioBase, 1 << base->shifterIndex[0]); |
| } |
| if (mask & kFLEXIO_SPI_RxFullInterruptEnable) |
| { |
| FLEXIO_DisableShifterStatusInterrupts(base->flexioBase, 1 << base->shifterIndex[1]); |
| } |
| } |
| |
| /*! |
| * brief Enables/disables the FlexIO SPI transmit DMA. This function enables/disables the FlexIO SPI Tx DMA, |
| * which means that asserting the kFLEXIO_SPI_TxEmptyFlag does/doesn't trigger the DMA request. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param mask SPI DMA source. |
| * param enable True means enable DMA, false means disable DMA. |
| */ |
| void FLEXIO_SPI_EnableDMA(FLEXIO_SPI_Type *base, uint32_t mask, bool enable) |
| { |
| if (mask & kFLEXIO_SPI_TxDmaEnable) |
| { |
| FLEXIO_EnableShifterStatusDMA(base->flexioBase, 1U << base->shifterIndex[0], enable); |
| } |
| |
| if (mask & kFLEXIO_SPI_RxDmaEnable) |
| { |
| FLEXIO_EnableShifterStatusDMA(base->flexioBase, 1U << base->shifterIndex[1], enable); |
| } |
| } |
| |
| /*! |
| * brief Gets FlexIO SPI status flags. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * return status flag; Use the status flag to AND the following flag mask and get the status. |
| * arg kFLEXIO_SPI_TxEmptyFlag |
| * arg kFLEXIO_SPI_RxEmptyFlag |
| */ |
| |
| uint32_t FLEXIO_SPI_GetStatusFlags(FLEXIO_SPI_Type *base) |
| { |
| uint32_t shifterStatus = FLEXIO_GetShifterStatusFlags(base->flexioBase); |
| uint32_t status = 0; |
| |
| status = ((shifterStatus & (1U << base->shifterIndex[0])) >> base->shifterIndex[0]); |
| status |= (((shifterStatus & (1U << base->shifterIndex[1])) >> (base->shifterIndex[1])) << 1U); |
| |
| return status; |
| } |
| |
| /*! |
| * brief Clears FlexIO SPI status flags. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param mask status flag |
| * The parameter can be any combination of the following values: |
| * arg kFLEXIO_SPI_TxEmptyFlag |
| * arg kFLEXIO_SPI_RxEmptyFlag |
| */ |
| |
| void FLEXIO_SPI_ClearStatusFlags(FLEXIO_SPI_Type *base, uint32_t mask) |
| { |
| if (mask & kFLEXIO_SPI_TxBufferEmptyFlag) |
| { |
| FLEXIO_ClearShifterStatusFlags(base->flexioBase, 1U << base->shifterIndex[0]); |
| } |
| if (mask & kFLEXIO_SPI_RxBufferFullFlag) |
| { |
| FLEXIO_ClearShifterStatusFlags(base->flexioBase, 1U << base->shifterIndex[1]); |
| } |
| } |
| |
| /*! |
| * brief Sets baud rate for the FlexIO SPI transfer, which is only used for the master. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param baudRate_Bps Baud Rate needed in Hz. |
| * param srcClockHz SPI source clock frequency in Hz. |
| */ |
| void FLEXIO_SPI_MasterSetBaudRate(FLEXIO_SPI_Type *base, uint32_t baudRate_Bps, uint32_t srcClockHz) |
| { |
| uint16_t timerDiv = 0; |
| uint16_t timerCmp = 0; |
| FLEXIO_Type *flexioBase = base->flexioBase; |
| |
| /* Set TIMCMP[7:0] = (baud rate divider / 2) - 1.*/ |
| timerDiv = srcClockHz / baudRate_Bps; |
| timerDiv = timerDiv / 2 - 1U; |
| |
| timerCmp = flexioBase->TIMCMP[base->timerIndex[0]]; |
| timerCmp &= 0xFF00U; |
| timerCmp |= timerDiv; |
| |
| flexioBase->TIMCMP[base->timerIndex[0]] = timerCmp; |
| } |
| |
| /*! |
| * brief Sends a buffer of data bytes. |
| * |
| * note This function blocks using the polling method until all bytes have been sent. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param direction Shift direction of MSB first or LSB first. |
| * param buffer The data bytes to send. |
| * param size The number of data bytes to send. |
| */ |
| void FLEXIO_SPI_WriteBlocking(FLEXIO_SPI_Type *base, |
| flexio_spi_shift_direction_t direction, |
| const uint8_t *buffer, |
| size_t size) |
| { |
| assert(buffer); |
| assert(size); |
| |
| while (size--) |
| { |
| /* Wait until data transfer complete. */ |
| while (!(FLEXIO_SPI_GetStatusFlags(base) & kFLEXIO_SPI_TxBufferEmptyFlag)) |
| { |
| } |
| FLEXIO_SPI_WriteData(base, direction, *buffer++); |
| } |
| } |
| |
| /*! |
| * brief Receives a buffer of bytes. |
| * |
| * note This function blocks using the polling method until all bytes have been received. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param direction Shift direction of MSB first or LSB first. |
| * param buffer The buffer to store the received bytes. |
| * param size The number of data bytes to be received. |
| * param direction Shift direction of MSB first or LSB first. |
| */ |
| void FLEXIO_SPI_ReadBlocking(FLEXIO_SPI_Type *base, |
| flexio_spi_shift_direction_t direction, |
| uint8_t *buffer, |
| size_t size) |
| { |
| assert(buffer); |
| assert(size); |
| |
| while (size--) |
| { |
| /* Wait until data transfer complete. */ |
| while (!(FLEXIO_SPI_GetStatusFlags(base) & kFLEXIO_SPI_RxBufferFullFlag)) |
| { |
| } |
| *buffer++ = FLEXIO_SPI_ReadData(base, direction); |
| } |
| } |
| |
| /*! |
| * brief Receives a buffer of bytes. |
| * |
| * note This function blocks via polling until all bytes have been received. |
| * |
| * param base pointer to FLEXIO_SPI_Type structure |
| * param xfer FlexIO SPI transfer structure, see #flexio_spi_transfer_t. |
| */ |
| void FLEXIO_SPI_MasterTransferBlocking(FLEXIO_SPI_Type *base, flexio_spi_transfer_t *xfer) |
| { |
| flexio_spi_shift_direction_t direction; |
| uint8_t bytesPerFrame; |
| uint32_t dataMode = 0; |
| uint16_t timerCmp = base->flexioBase->TIMCMP[base->timerIndex[0]]; |
| uint16_t tmpData = FLEXIO_SPI_DUMMYDATA; |
| |
| timerCmp &= 0x00FFU; |
| /* Configure the values in handle. */ |
| switch (xfer->flags) |
| { |
| case kFLEXIO_SPI_8bitMsb: |
| dataMode = (8 * 2 - 1U) << 8U; |
| bytesPerFrame = 1; |
| direction = kFLEXIO_SPI_MsbFirst; |
| break; |
| |
| case kFLEXIO_SPI_8bitLsb: |
| dataMode = (8 * 2 - 1U) << 8U; |
| bytesPerFrame = 1; |
| direction = kFLEXIO_SPI_LsbFirst; |
| break; |
| |
| case kFLEXIO_SPI_16bitMsb: |
| dataMode = (16 * 2 - 1U) << 8U; |
| bytesPerFrame = 2; |
| direction = kFLEXIO_SPI_MsbFirst; |
| break; |
| |
| case kFLEXIO_SPI_16bitLsb: |
| dataMode = (16 * 2 - 1U) << 8U; |
| bytesPerFrame = 2; |
| direction = kFLEXIO_SPI_LsbFirst; |
| break; |
| |
| default: |
| dataMode = (8 * 2 - 1U) << 8U; |
| bytesPerFrame = 1; |
| direction = kFLEXIO_SPI_MsbFirst; |
| assert(true); |
| break; |
| } |
| |
| dataMode |= timerCmp; |
| |
| /* Configure transfer size. */ |
| base->flexioBase->TIMCMP[base->timerIndex[0]] = dataMode; |
| |
| while (xfer->dataSize) |
| { |
| /* Wait until data transfer complete. */ |
| while (!(FLEXIO_SPI_GetStatusFlags(base) & kFLEXIO_SPI_TxBufferEmptyFlag)) |
| { |
| } |
| if (xfer->txData != NULL) |
| { |
| /* Transmit data and update tx size/buff. */ |
| if (bytesPerFrame == 1U) |
| { |
| tmpData = *(xfer->txData); |
| xfer->txData++; |
| } |
| else |
| { |
| if (direction == kFLEXIO_SPI_MsbFirst) |
| { |
| tmpData = (uint32_t)(xfer->txData[0]) << 8U; |
| tmpData += xfer->txData[1]; |
| } |
| else |
| { |
| tmpData = (uint32_t)(xfer->txData[1]) << 8U; |
| tmpData += xfer->txData[0]; |
| } |
| xfer->txData += 2U; |
| } |
| } |
| else |
| { |
| tmpData = FLEXIO_SPI_DUMMYDATA; |
| } |
| |
| xfer->dataSize -= bytesPerFrame; |
| |
| FLEXIO_SPI_WriteData(base, direction, tmpData); |
| |
| while (!(FLEXIO_SPI_GetStatusFlags(base) & kFLEXIO_SPI_RxBufferFullFlag)) |
| { |
| } |
| tmpData = FLEXIO_SPI_ReadData(base, direction); |
| |
| if (xfer->rxData != NULL) |
| { |
| if (bytesPerFrame == 1U) |
| { |
| *xfer->rxData = tmpData; |
| xfer->rxData++; |
| } |
| else |
| { |
| if (direction == kFLEXIO_SPI_MsbFirst) |
| { |
| *((uint16_t *)(xfer->rxData)) = tmpData; |
| } |
| else |
| { |
| *((uint16_t *)(xfer->rxData)) = (((tmpData << 8) & 0xff00U) | ((tmpData >> 8) & 0x00ffU)); |
| } |
| xfer->rxData += 2U; |
| } |
| } |
| } |
| } |
| |
| /*! |
| * brief Initializes the FlexIO SPI Master handle, which is used in transactional functions. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param handle Pointer to the flexio_spi_master_handle_t structure to store the transfer state. |
| * param callback The callback function. |
| * param userData The parameter of the callback function. |
| * retval kStatus_Success Successfully create the handle. |
| * retval kStatus_OutOfRange The FlexIO type/handle/ISR table out of range. |
| */ |
| status_t FLEXIO_SPI_MasterTransferCreateHandle(FLEXIO_SPI_Type *base, |
| flexio_spi_master_handle_t *handle, |
| flexio_spi_master_transfer_callback_t callback, |
| void *userData) |
| { |
| assert(handle); |
| |
| IRQn_Type flexio_irqs[] = FLEXIO_IRQS; |
| |
| /* Zero the handle. */ |
| memset(handle, 0, sizeof(*handle)); |
| |
| /* Register callback and userData. */ |
| handle->callback = callback; |
| handle->userData = userData; |
| |
| /* Enable interrupt in NVIC. */ |
| EnableIRQ(flexio_irqs[FLEXIO_SPI_GetInstance(base)]); |
| |
| /* Save the context in global variables to support the double weak mechanism. */ |
| return FLEXIO_RegisterHandleIRQ(base, handle, FLEXIO_SPI_MasterTransferHandleIRQ); |
| } |
| |
| /*! |
| * brief Master transfer data using IRQ. |
| * |
| * This function sends data using IRQ. This is a non-blocking function, which returns |
| * right away. When all data is sent out/received, the callback function is called. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param handle Pointer to the flexio_spi_master_handle_t structure to store the transfer state. |
| * param xfer FlexIO SPI transfer structure. See #flexio_spi_transfer_t. |
| * retval kStatus_Success Successfully start a transfer. |
| * retval kStatus_InvalidArgument Input argument is invalid. |
| * retval kStatus_FLEXIO_SPI_Busy SPI is not idle, is running another transfer. |
| */ |
| status_t FLEXIO_SPI_MasterTransferNonBlocking(FLEXIO_SPI_Type *base, |
| flexio_spi_master_handle_t *handle, |
| flexio_spi_transfer_t *xfer) |
| { |
| assert(handle); |
| assert(xfer); |
| |
| uint32_t dataMode = 0; |
| uint16_t timerCmp = base->flexioBase->TIMCMP[base->timerIndex[0]]; |
| uint16_t tmpData = FLEXIO_SPI_DUMMYDATA; |
| |
| timerCmp &= 0x00FFU; |
| |
| /* Check if SPI is busy. */ |
| if (handle->state == kFLEXIO_SPI_Busy) |
| { |
| return kStatus_FLEXIO_SPI_Busy; |
| } |
| |
| /* Check if the argument is legal. */ |
| if ((xfer->txData == NULL) && (xfer->rxData == NULL)) |
| { |
| return kStatus_InvalidArgument; |
| } |
| |
| /* Configure the values in handle */ |
| switch (xfer->flags) |
| { |
| case kFLEXIO_SPI_8bitMsb: |
| dataMode = (8 * 2 - 1U) << 8U; |
| handle->bytePerFrame = 1U; |
| handle->direction = kFLEXIO_SPI_MsbFirst; |
| break; |
| case kFLEXIO_SPI_8bitLsb: |
| dataMode = (8 * 2 - 1U) << 8U; |
| handle->bytePerFrame = 1U; |
| handle->direction = kFLEXIO_SPI_LsbFirst; |
| break; |
| case kFLEXIO_SPI_16bitMsb: |
| dataMode = (16 * 2 - 1U) << 8U; |
| handle->bytePerFrame = 2U; |
| handle->direction = kFLEXIO_SPI_MsbFirst; |
| break; |
| case kFLEXIO_SPI_16bitLsb: |
| dataMode = (16 * 2 - 1U) << 8U; |
| handle->bytePerFrame = 2U; |
| handle->direction = kFLEXIO_SPI_LsbFirst; |
| break; |
| default: |
| dataMode = (8 * 2 - 1U) << 8U; |
| handle->bytePerFrame = 1U; |
| handle->direction = kFLEXIO_SPI_MsbFirst; |
| assert(true); |
| break; |
| } |
| |
| dataMode |= timerCmp; |
| |
| /* Configure transfer size. */ |
| base->flexioBase->TIMCMP[base->timerIndex[0]] = dataMode; |
| |
| handle->state = kFLEXIO_SPI_Busy; |
| handle->txData = xfer->txData; |
| handle->rxData = xfer->rxData; |
| handle->rxRemainingBytes = xfer->dataSize; |
| |
| /* Save total transfer size. */ |
| handle->transferSize = xfer->dataSize; |
| |
| /* Send first byte of data to trigger the rx interrupt. */ |
| if (handle->txData != NULL) |
| { |
| /* Transmit data and update tx size/buff. */ |
| if (handle->bytePerFrame == 1U) |
| { |
| tmpData = *(handle->txData); |
| handle->txData++; |
| } |
| else |
| { |
| if (handle->direction == kFLEXIO_SPI_MsbFirst) |
| { |
| tmpData = (uint32_t)(handle->txData[0]) << 8U; |
| tmpData += handle->txData[1]; |
| } |
| else |
| { |
| tmpData = (uint32_t)(handle->txData[1]) << 8U; |
| tmpData += handle->txData[0]; |
| } |
| handle->txData += 2U; |
| } |
| } |
| else |
| { |
| tmpData = FLEXIO_SPI_DUMMYDATA; |
| } |
| |
| handle->txRemainingBytes = xfer->dataSize - handle->bytePerFrame; |
| |
| FLEXIO_SPI_WriteData(base, handle->direction, tmpData); |
| |
| /* Enable transmit and receive interrupt to handle rx. */ |
| FLEXIO_SPI_EnableInterrupts(base, kFLEXIO_SPI_RxFullInterruptEnable); |
| |
| return kStatus_Success; |
| } |
| |
| /*! |
| * brief Gets the data transfer status which used IRQ. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param handle Pointer to the flexio_spi_master_handle_t structure to store the transfer state. |
| * param count Number of bytes transferred so far by the non-blocking transaction. |
| * retval kStatus_InvalidArgument count is Invalid. |
| * retval kStatus_Success Successfully return the count. |
| */ |
| status_t FLEXIO_SPI_MasterTransferGetCount(FLEXIO_SPI_Type *base, flexio_spi_master_handle_t *handle, size_t *count) |
| { |
| assert(handle); |
| |
| if (!count) |
| { |
| return kStatus_InvalidArgument; |
| } |
| |
| /* Return remaing bytes in different cases. */ |
| if (handle->rxData) |
| { |
| *count = handle->transferSize - handle->rxRemainingBytes; |
| } |
| else |
| { |
| *count = handle->transferSize - handle->txRemainingBytes; |
| } |
| |
| return kStatus_Success; |
| } |
| |
| /*! |
| * brief Aborts the master data transfer, which used IRQ. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param handle Pointer to the flexio_spi_master_handle_t structure to store the transfer state. |
| */ |
| void FLEXIO_SPI_MasterTransferAbort(FLEXIO_SPI_Type *base, flexio_spi_master_handle_t *handle) |
| { |
| assert(handle); |
| |
| FLEXIO_SPI_DisableInterrupts(base, kFLEXIO_SPI_RxFullInterruptEnable); |
| FLEXIO_SPI_DisableInterrupts(base, kFLEXIO_SPI_TxEmptyInterruptEnable); |
| |
| /* Transfer finished, set the state to idle. */ |
| handle->state = kFLEXIO_SPI_Idle; |
| |
| /* Clear the internal state. */ |
| handle->rxRemainingBytes = 0; |
| handle->txRemainingBytes = 0; |
| } |
| |
| /*! |
| * brief FlexIO SPI master IRQ handler function. |
| * |
| * param spiType Pointer to the FLEXIO_SPI_Type structure. |
| * param spiHandle Pointer to the flexio_spi_master_handle_t structure to store the transfer state. |
| */ |
| void FLEXIO_SPI_MasterTransferHandleIRQ(void *spiType, void *spiHandle) |
| { |
| assert(spiHandle); |
| |
| flexio_spi_master_handle_t *handle = (flexio_spi_master_handle_t *)spiHandle; |
| FLEXIO_SPI_Type *base; |
| uint32_t status; |
| |
| if (handle->state == kFLEXIO_SPI_Idle) |
| { |
| return; |
| } |
| |
| base = (FLEXIO_SPI_Type *)spiType; |
| status = FLEXIO_SPI_GetStatusFlags(base); |
| |
| /* Handle rx. */ |
| if ((status & kFLEXIO_SPI_RxBufferFullFlag) && (handle->rxRemainingBytes)) |
| { |
| FLEXIO_SPI_TransferReceiveTransaction(base, handle); |
| } |
| |
| /* Handle tx. */ |
| if ((status & kFLEXIO_SPI_TxBufferEmptyFlag) && (handle->txRemainingBytes)) |
| { |
| FLEXIO_SPI_TransferSendTransaction(base, handle); |
| } |
| |
| /* All the transfer finished. */ |
| if ((handle->txRemainingBytes == 0U) && (handle->rxRemainingBytes == 0U)) |
| { |
| FLEXIO_SPI_MasterTransferAbort(base, handle); |
| if (handle->callback) |
| { |
| (handle->callback)(base, handle, kStatus_FLEXIO_SPI_Idle, handle->userData); |
| } |
| } |
| } |
| |
| /*! |
| * brief Initializes the FlexIO SPI Slave handle, which is used in transactional functions. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param handle Pointer to the flexio_spi_slave_handle_t structure to store the transfer state. |
| * param callback The callback function. |
| * param userData The parameter of the callback function. |
| * retval kStatus_Success Successfully create the handle. |
| * retval kStatus_OutOfRange The FlexIO type/handle/ISR table out of range. |
| */ |
| status_t FLEXIO_SPI_SlaveTransferCreateHandle(FLEXIO_SPI_Type *base, |
| flexio_spi_slave_handle_t *handle, |
| flexio_spi_slave_transfer_callback_t callback, |
| void *userData) |
| { |
| assert(handle); |
| |
| IRQn_Type flexio_irqs[] = FLEXIO_IRQS; |
| |
| /* Zero the handle. */ |
| memset(handle, 0, sizeof(*handle)); |
| |
| /* Register callback and userData. */ |
| handle->callback = callback; |
| handle->userData = userData; |
| |
| /* Enable interrupt in NVIC. */ |
| EnableIRQ(flexio_irqs[FLEXIO_SPI_GetInstance(base)]); |
| |
| /* Save the context in global variables to support the double weak mechanism. */ |
| return FLEXIO_RegisterHandleIRQ(base, handle, FLEXIO_SPI_SlaveTransferHandleIRQ); |
| } |
| |
| /*! |
| * brief Slave transfer data using IRQ. |
| * |
| * This function sends data using IRQ. This is a non-blocking function, which returns |
| * right away. When all data is sent out/received, the callback function is called. |
| * param handle Pointer to the flexio_spi_slave_handle_t structure to store the transfer state. |
| * |
| * param base Pointer to the FLEXIO_SPI_Type structure. |
| * param xfer FlexIO SPI transfer structure. See #flexio_spi_transfer_t. |
| * retval kStatus_Success Successfully start a transfer. |
| * retval kStatus_InvalidArgument Input argument is invalid. |
| * retval kStatus_FLEXIO_SPI_Busy SPI is not idle; it is running another transfer. |
| */ |
| status_t FLEXIO_SPI_SlaveTransferNonBlocking(FLEXIO_SPI_Type *base, |
| flexio_spi_slave_handle_t *handle, |
| flexio_spi_transfer_t *xfer) |
| { |
| assert(handle); |
| assert(xfer); |
| |
| uint32_t dataMode = 0; |
| |
| /* Check if SPI is busy. */ |
| if (handle->state == kFLEXIO_SPI_Busy) |
| { |
| return kStatus_FLEXIO_SPI_Busy; |
| } |
| |
| /* Check if the argument is legal. */ |
| if ((xfer->txData == NULL) && (xfer->rxData == NULL)) |
| { |
| return kStatus_InvalidArgument; |
| } |
| |
| /* Configure the values in handle */ |
| switch (xfer->flags) |
| { |
| case kFLEXIO_SPI_8bitMsb: |
| dataMode = 8 * 2 - 1U; |
| handle->bytePerFrame = 1U; |
| handle->direction = kFLEXIO_SPI_MsbFirst; |
| break; |
| case kFLEXIO_SPI_8bitLsb: |
| dataMode = 8 * 2 - 1U; |
| handle->bytePerFrame = 1U; |
| handle->direction = kFLEXIO_SPI_LsbFirst; |
| break; |
| case kFLEXIO_SPI_16bitMsb: |
| dataMode = 16 * 2 - 1U; |
| handle->bytePerFrame = 2U; |
| handle->direction = kFLEXIO_SPI_MsbFirst; |
| break; |
| case kFLEXIO_SPI_16bitLsb: |
| dataMode = 16 * 2 - 1U; |
| handle->bytePerFrame = 2U; |
| handle->direction = kFLEXIO_SPI_LsbFirst; |
| break; |
| default: |
| dataMode = 8 * 2 - 1U; |
| handle->bytePerFrame = 1U; |
| handle->direction = kFLEXIO_SPI_MsbFirst; |
| assert(true); |
| break; |
| } |
| |
| /* Configure transfer size. */ |
| base->flexioBase->TIMCMP[base->timerIndex[0]] = dataMode; |
| |
| handle->state = kFLEXIO_SPI_Busy; |
| handle->txData = xfer->txData; |
| handle->rxData = xfer->rxData; |
| handle->txRemainingBytes = xfer->dataSize; |
| handle->rxRemainingBytes = xfer->dataSize; |
| |
| /* Save total transfer size. */ |
| handle->transferSize = xfer->dataSize; |
| |
| /* Enable transmit and receive interrupt to handle tx and rx. */ |
| FLEXIO_SPI_EnableInterrupts(base, kFLEXIO_SPI_TxEmptyInterruptEnable); |
| FLEXIO_SPI_EnableInterrupts(base, kFLEXIO_SPI_RxFullInterruptEnable); |
| |
| return kStatus_Success; |
| } |
| |
| /*! |
| * brief FlexIO SPI slave IRQ handler function. |
| * |
| * param spiType Pointer to the FLEXIO_SPI_Type structure. |
| * param spiHandle Pointer to the flexio_spi_slave_handle_t structure to store the transfer state. |
| */ |
| void FLEXIO_SPI_SlaveTransferHandleIRQ(void *spiType, void *spiHandle) |
| { |
| assert(spiHandle); |
| |
| flexio_spi_master_handle_t *handle = (flexio_spi_master_handle_t *)spiHandle; |
| FLEXIO_SPI_Type *base; |
| uint32_t status; |
| |
| if (handle->state == kFLEXIO_SPI_Idle) |
| { |
| return; |
| } |
| |
| base = (FLEXIO_SPI_Type *)spiType; |
| status = FLEXIO_SPI_GetStatusFlags(base); |
| |
| /* Handle tx. */ |
| if ((status & kFLEXIO_SPI_TxBufferEmptyFlag) && (handle->txRemainingBytes)) |
| { |
| FLEXIO_SPI_TransferSendTransaction(base, handle); |
| } |
| |
| /* Handle rx. */ |
| if ((status & kFLEXIO_SPI_RxBufferFullFlag) && (handle->rxRemainingBytes)) |
| { |
| FLEXIO_SPI_TransferReceiveTransaction(base, handle); |
| } |
| |
| /* All the transfer finished. */ |
| if ((handle->txRemainingBytes == 0U) && (handle->rxRemainingBytes == 0U)) |
| { |
| FLEXIO_SPI_SlaveTransferAbort(base, handle); |
| if (handle->callback) |
| { |
| (handle->callback)(base, handle, kStatus_FLEXIO_SPI_Idle, handle->userData); |
| } |
| } |
| } |
