fsl_lpspi.c File Reference

Typedefs
typedef void(*	lpspi_master_isr_t) (LPSPI_Type *base, lpspi_master_handle_t *handle)
	Typedef for master interrupt handler.
typedef void(*	lpspi_slave_isr_t) (LPSPI_Type *base, lpspi_slave_handle_t *handle)
	Typedef for slave interrupt handler.

Enumerations
enum	_lpspi_default_watermarks { kLpspiDefaultTxWatermark = 0 , kLpspiDefaultRxWatermark = 0 }
	Default watermark values. More...

Functions
uint32_t	LPSPI_GetInstance (LPSPI_Type *base)
	Get instance number for LPSPI module.
static void	LPSPI_SetOnePcsPolarity (LPSPI_Type *base, lpspi_which_pcs_t pcs, lpspi_pcs_polarity_config_t activeLowOrHigh)
	Configures the LPSPI peripheral chip select polarity.
static uint32_t	LPSPI_CombineWriteData (uint8_t *txData, uint32_t bytesEachWrite, bool isByteSwap)
	Combine the write data for 1 byte to 4 bytes. This is not a public API.
static void	LPSPI_SeparateReadData (uint8_t *rxData, uint32_t readData, uint32_t bytesEachRead, bool isByteSwap)
	Separate the read data for 1 byte to 4 bytes. This is not a public API.
static void	LPSPI_MasterTransferFillUpTxFifo (LPSPI_Type *base, lpspi_master_handle_t *handle)
	Master fill up the TX FIFO with data. This is not a public API.
static void	LPSPI_MasterTransferComplete (LPSPI_Type *base, lpspi_master_handle_t *handle)
	Master finish up a transfer. It would call back if there is callback function and set the state to idle. This is not a public API.
static void	LPSPI_SlaveTransferFillUpTxFifo (LPSPI_Type *base, lpspi_slave_handle_t *handle)
	Slave fill up the TX FIFO with data. This is not a public API.
static void	LPSPI_SlaveTransferComplete (LPSPI_Type *base, lpspi_slave_handle_t *handle)
	Slave finish up a transfer. It would call back if there is callback function and set the state to idle. This is not a public API.
static void	LPSPI_CommonIRQHandler (LPSPI_Type *base, void *param)
	LPSPI common interrupt handler.
void	LPSPI_SetDummyData (LPSPI_Type *base, uint8_t dummyData)
	Set up the dummy data.
void	LPSPI_MasterInit (LPSPI_Type *base, const lpspi_master_config_t *masterConfig, uint32_t srcClock_Hz)
	Initializes the LPSPI master.
void	LPSPI_MasterGetDefaultConfig (lpspi_master_config_t *masterConfig)
	Sets the lpspi_master_config_t structure to default values.
void	LPSPI_SlaveInit (LPSPI_Type *base, const lpspi_slave_config_t *slaveConfig)
	LPSPI slave configuration.
void	LPSPI_SlaveGetDefaultConfig (lpspi_slave_config_t *slaveConfig)
	Sets the lpspi_slave_config_t structure to default values.
void	LPSPI_Reset (LPSPI_Type *base)
	Restores the LPSPI peripheral to reset state. Note that this function sets all registers to reset state. As a result, the LPSPI module can't work after calling this API.
void	LPSPI_Deinit (LPSPI_Type *base)
	De-initializes the LPSPI peripheral. Call this API to disable the LPSPI clock.
uint32_t	LPSPI_MasterSetBaudRate (LPSPI_Type *base, uint32_t baudRate_Bps, uint32_t srcClock_Hz, uint32_t *tcrPrescaleValue)
	Sets the LPSPI baud rate in bits per second.
void	LPSPI_MasterSetDelayScaler (LPSPI_Type *base, uint32_t scaler, lpspi_delay_type_t whichDelay)
	Manually configures a specific LPSPI delay parameter (module must be disabled to change the delay values).
uint32_t	LPSPI_MasterSetDelayTimes (LPSPI_Type *base, uint32_t delayTimeInNanoSec, lpspi_delay_type_t whichDelay, uint32_t srcClock_Hz)
	Calculates the delay based on the desired delay input in nanoseconds (module must be disabled to change the delay values).
void	LPSPI_MasterTransferCreateHandle (LPSPI_Type *base, lpspi_master_handle_t *handle, lpspi_master_transfer_callback_t callback, void *userData)
	Initializes the LPSPI master handle.
bool	LPSPI_CheckTransferArgument (lpspi_transfer_t *transfer, uint32_t bitsPerFrame, uint32_t bytesPerFrame)
	Check the argument for transfer .
status_t	LPSPI_MasterTransferBlocking (LPSPI_Type *base, lpspi_transfer_t *transfer)
	LPSPI master transfer data using a polling method.
status_t	LPSPI_MasterTransferNonBlocking (LPSPI_Type *base, lpspi_master_handle_t *handle, lpspi_transfer_t *transfer)
	LPSPI master transfer data using an interrupt method.
status_t	LPSPI_MasterTransferGetCount (LPSPI_Type *base, lpspi_master_handle_t *handle, size_t *count)
	Gets the master transfer remaining bytes.
void	LPSPI_MasterTransferAbort (LPSPI_Type *base, lpspi_master_handle_t *handle)
	LPSPI master abort transfer which uses an interrupt method.
void	LPSPI_MasterTransferHandleIRQ (LPSPI_Type *base, lpspi_master_handle_t *handle)
	LPSPI Master IRQ handler function.
void	LPSPI_SlaveTransferCreateHandle (LPSPI_Type *base, lpspi_slave_handle_t *handle, lpspi_slave_transfer_callback_t callback, void *userData)
	Initializes the LPSPI slave handle.
status_t	LPSPI_SlaveTransferNonBlocking (LPSPI_Type *base, lpspi_slave_handle_t *handle, lpspi_transfer_t *transfer)
	LPSPI slave transfer data using an interrupt method.
status_t	LPSPI_SlaveTransferGetCount (LPSPI_Type *base, lpspi_slave_handle_t *handle, size_t *count)
	Gets the slave transfer remaining bytes.
void	LPSPI_SlaveTransferAbort (LPSPI_Type *base, lpspi_slave_handle_t *handle)
	LPSPI slave aborts a transfer which uses an interrupt method.
void	LPSPI_SlaveTransferHandleIRQ (LPSPI_Type *base, lpspi_slave_handle_t *handle)
	LPSPI Slave IRQ handler function.
void	LPSPI0_DriverIRQHandler (void)
void	LPSPI1_DriverIRQHandler (void)
void	LPSPI2_DriverIRQHandler (void)
void	LPSPI3_DriverIRQHandler (void)
void	LPSPI4_DriverIRQHandler (void)
void	LPSPI5_DriverIRQHandler (void)
void	DMA_SPI0_INT_DriverIRQHandler (void)
void	DMA_SPI1_INT_DriverIRQHandler (void)
void	DMA_SPI2_INT_DriverIRQHandler (void)
void	DMA_SPI3_INT_DriverIRQHandler (void)
void	ADMA_SPI0_INT_DriverIRQHandler (void)
void	ADMA_SPI1_INT_DriverIRQHandler (void)
void	ADMA_SPI2_INT_DriverIRQHandler (void)
void	ADMA_SPI3_INT_DriverIRQHandler (void)

Variables
static const uint8_t	s_baudratePrescaler [] = {1, 2, 4, 8, 16, 32, 64, 128}
static LPSPI_Type *const	s_lpspiBases [] = LPSPI_BASE_PTRS
	Pointers to lpspi bases for each instance.
static const IRQn_Type	s_lpspiIRQ [] = LPSPI_IRQS
	Pointers to lpspi IRQ number for each instance.
static const clock_ip_name_t	s_lpspiClocks [] = LPSPI_CLOCKS
	Pointers to lpspi clocks for each instance.
static const clock_ip_name_t	s_LpspiPeriphClocks [] = LPSPI_PERIPH_CLOCKS
static void *	s_lpspiHandle [ARRAY_SIZE(s_lpspiBases)] = {NULL}
	Pointers to lpspi handles for each instance.
static lpspi_master_isr_t	s_lpspiMasterIsr
	Pointer to master IRQ handler for each instance.
static lpspi_slave_isr_t	s_lpspiSlaveIsr
	Pointer to slave IRQ handler for each instance.
volatile uint8_t	g_lpspiDummyData [ARRAY_SIZE(s_lpspiBases)] = {0}
	Global variable for dummy data value setting.

Typedef Documentation

lpspi_master_isr_t

typedef void(* lpspi_master_isr_t) (LPSPI_Type *base, lpspi_master_handle_t *handle)

Typedef for master interrupt handler.

Definition at line 33 of file fsl_lpspi.c.

lpspi_slave_isr_t

typedef void(* lpspi_slave_isr_t) (LPSPI_Type *base, lpspi_slave_handle_t *handle)

Typedef for slave interrupt handler.

Definition at line 36 of file fsl_lpspi.c.

Enumeration Type Documentation

_lpspi_default_watermarks

enum _lpspi_default_watermarks

Default watermark values.

The default watermarks are set to zero.

Enumerator
kLpspiDefaultTxWatermark
kLpspiDefaultRxWatermark

Definition at line 26 of file fsl_lpspi.c.

{
    kLpspiDefaultTxWatermark = 0,
    kLpspiDefaultRxWatermark = 0,
};

Function Documentation

ADMA_SPI0_INT_DriverIRQHandler()

void ADMA_SPI0_INT_DriverIRQHandler

(

void

)

Definition at line 2073 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[LPSPI_GetInstance(ADMA__LPSPI0)]);
    LPSPI_CommonIRQHandler(ADMA__LPSPI0, s_lpspiHandle[LPSPI_GetInstance(ADMA__LPSPI0)]);
}

Here is the call graph for this function:

ADMA_SPI1_INT_DriverIRQHandler()

void ADMA_SPI1_INT_DriverIRQHandler

(

void

)

Definition at line 2081 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[LPSPI_GetInstance(ADMA__LPSPI1)]);
    LPSPI_CommonIRQHandler(ADMA__LPSPI1, s_lpspiHandle[LPSPI_GetInstance(ADMA__LPSPI1)]);
}

Here is the call graph for this function:

ADMA_SPI2_INT_DriverIRQHandler()

void ADMA_SPI2_INT_DriverIRQHandler

(

void

)

Definition at line 2088 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[LPSPI_GetInstance(ADMA__LPSPI2)]);
    LPSPI_CommonIRQHandler(ADMA__LPSPI2, s_lpspiHandle[LPSPI_GetInstance(ADMA__LPSPI2)]);
}

Here is the call graph for this function:

ADMA_SPI3_INT_DriverIRQHandler()

void ADMA_SPI3_INT_DriverIRQHandler

(

void

)

Definition at line 2096 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[LPSPI_GetInstance(ADMA__LPSPI3)]);
    LPSPI_CommonIRQHandler(ADMA__LPSPI3, s_lpspiHandle[LPSPI_GetInstance(ADMA__LPSPI3)]);
}

Here is the call graph for this function:

DMA_SPI0_INT_DriverIRQHandler()

void DMA_SPI0_INT_DriverIRQHandler

(

void

)

Definition at line 2042 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[LPSPI_GetInstance(DMA__LPSPI0)]);
    LPSPI_CommonIRQHandler(DMA__LPSPI0, s_lpspiHandle[LPSPI_GetInstance(DMA__LPSPI0)]);
}

Here is the call graph for this function:

DMA_SPI1_INT_DriverIRQHandler()

void DMA_SPI1_INT_DriverIRQHandler

(

void

)

Definition at line 2050 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[LPSPI_GetInstance(DMA__LPSPI1)]);
    LPSPI_CommonIRQHandler(DMA__LPSPI1, s_lpspiHandle[LPSPI_GetInstance(DMA__LPSPI1)]);
}

Here is the call graph for this function:

DMA_SPI2_INT_DriverIRQHandler()

void DMA_SPI2_INT_DriverIRQHandler

(

void

)

Definition at line 2057 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[LPSPI_GetInstance(DMA__LPSPI2)]);
    LPSPI_CommonIRQHandler(DMA__LPSPI2, s_lpspiHandle[LPSPI_GetInstance(DMA__LPSPI2)]);
}

Here is the call graph for this function:

DMA_SPI3_INT_DriverIRQHandler()

void DMA_SPI3_INT_DriverIRQHandler

(

void

)

Definition at line 2065 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[LPSPI_GetInstance(DMA__LPSPI3)]);
    LPSPI_CommonIRQHandler(DMA__LPSPI3, s_lpspiHandle[LPSPI_GetInstance(DMA__LPSPI3)]);
}

Here is the call graph for this function:

LPSPI0_DriverIRQHandler()

void LPSPI0_DriverIRQHandler

(

void

)

Definition at line 1994 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[0]);
    LPSPI_CommonIRQHandler(LPSPI0, s_lpspiHandle[0]);
}

Here is the call graph for this function:

LPSPI1_DriverIRQHandler()

void LPSPI1_DriverIRQHandler

(

void

)

Definition at line 2002 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[1]);
    LPSPI_CommonIRQHandler(LPSPI1, s_lpspiHandle[1]);
}

Here is the call graph for this function:

LPSPI2_DriverIRQHandler()

void LPSPI2_DriverIRQHandler

(

void

)

Definition at line 2010 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[2]);
    LPSPI_CommonIRQHandler(LPSPI2, s_lpspiHandle[2]);
}

Here is the call graph for this function:

LPSPI3_DriverIRQHandler()

void LPSPI3_DriverIRQHandler

(

void

)

Definition at line 2018 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[3]);
    LPSPI_CommonIRQHandler(LPSPI3, s_lpspiHandle[3]);
}

Here is the call graph for this function:

LPSPI4_DriverIRQHandler()

void LPSPI4_DriverIRQHandler

(

void

)

Definition at line 2026 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[4]);
    LPSPI_CommonIRQHandler(LPSPI4, s_lpspiHandle[4]);
}

Here is the call graph for this function:

LPSPI5_DriverIRQHandler()

void LPSPI5_DriverIRQHandler

(

void

)

Definition at line 2034 of file fsl_lpspi.c.

{
    assert(s_lpspiHandle[5]);
    LPSPI_CommonIRQHandler(LPSPI5, s_lpspiHandle[5]);
}

Here is the call graph for this function:

LPSPI_CombineWriteData()

static uint32_t LPSPI_CombineWriteData ( uint8_t *  txData, uint32_t  bytesEachWrite, bool  isByteSwap  )

static

Combine the write data for 1 byte to 4 bytes. This is not a public API.

Definition at line 1812 of file fsl_lpspi.c.

{
    assert(txData);
 
    uint32_t wordToSend = 0;
 
    switch (bytesEachWrite)
    {
        case 1:
            wordToSend = *txData;
            ++txData;
            break;
 
        case 2:
            if (!isByteSwap)
            {
                wordToSend = *txData;
                ++txData;
                wordToSend |= (unsigned)(*txData) << 8U;
                ++txData;
            }
            else
            {
                wordToSend = (unsigned)(*txData) << 8U;
                ++txData;
                wordToSend |= *txData;
                ++txData;
            }
 
            break;
 
        case 3:
            if (!isByteSwap)
            {
                wordToSend = *txData;
                ++txData;
                wordToSend |= (unsigned)(*txData) << 8U;
                ++txData;
                wordToSend |= (unsigned)(*txData) << 16U;
                ++txData;
            }
            else
            {
                wordToSend = (unsigned)(*txData) << 16U;
                ++txData;
                wordToSend |= (unsigned)(*txData) << 8U;
                ++txData;
                wordToSend |= *txData;
                ++txData;
            }
            break;
 
        case 4:
            if (!isByteSwap)
            {
                wordToSend = *txData;
                ++txData;
                wordToSend |= (unsigned)(*txData) << 8U;
                ++txData;
                wordToSend |= (unsigned)(*txData) << 16U;
                ++txData;
                wordToSend |= (unsigned)(*txData) << 24U;
                ++txData;
            }
            else
            {
                wordToSend = (unsigned)(*txData) << 24U;
                ++txData;
                wordToSend |= (unsigned)(*txData) << 16U;
                ++txData;
                wordToSend |= (unsigned)(*txData) << 8U;
                ++txData;
                wordToSend |= *txData;
                ++txData;
            }
            break;
 
        default:
            assert(false);
            break;
    }
    return wordToSend;
}

Referenced by LPSPI_MasterTransferBlocking(), LPSPI_MasterTransferFillUpTxFifo(), LPSPI_SlaveTransferFillUpTxFifo(), and LPSPI_SlaveTransferHandleIRQ().

Here is the caller graph for this function:

LPSPI_CommonIRQHandler()

static void LPSPI_CommonIRQHandler ( LPSPI_Type *  base, void *  param  )

static

LPSPI common interrupt handler.

Parameters

handle

pointer to s_lpspiHandle which stores the transfer state.

Definition at line 1976 of file fsl_lpspi.c.

{
    if (LPSPI_IsMaster(base))
    {
        s_lpspiMasterIsr(base, (lpspi_master_handle_t *)param);
    }
    else
    {
        s_lpspiSlaveIsr(base, (lpspi_slave_handle_t *)param);
    }
/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
  exception return operation might vector to incorrect interrupt */
#if defined __CORTEX_M && (__CORTEX_M == 4U)
    __DSB();
#endif
}

Referenced by ADMA_SPI0_INT_DriverIRQHandler(), ADMA_SPI1_INT_DriverIRQHandler(), ADMA_SPI2_INT_DriverIRQHandler(), ADMA_SPI3_INT_DriverIRQHandler(), DMA_SPI0_INT_DriverIRQHandler(), DMA_SPI1_INT_DriverIRQHandler(), DMA_SPI2_INT_DriverIRQHandler(), DMA_SPI3_INT_DriverIRQHandler(), LPSPI0_DriverIRQHandler(), LPSPI1_DriverIRQHandler(), LPSPI2_DriverIRQHandler(), LPSPI3_DriverIRQHandler(), LPSPI4_DriverIRQHandler(), and LPSPI5_DriverIRQHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

LPSPI_GetInstance()

static uint32_t LPSPI_GetInstance

(

LPSPI_Type *

base

)

Get instance number for LPSPI module.

Parameters

base	LPSPI peripheral base address.

Returns

Return the value of LPSPI instance.

Definition at line 146 of file fsl_lpspi.c.

{
    uint8_t instance = 0;
 
    /* Find the instance index from base address mappings. */
    for (instance = 0; instance < ARRAY_SIZE(s_lpspiBases); instance++)
    {
        if (s_lpspiBases[instance] == base)
        {
            break;
        }
    }
 
    assert(instance < ARRAY_SIZE(s_lpspiBases));
 
    return instance;
}

Referenced by ADMA_SPI0_INT_DriverIRQHandler(), ADMA_SPI1_INT_DriverIRQHandler(), ADMA_SPI2_INT_DriverIRQHandler(), ADMA_SPI3_INT_DriverIRQHandler(), DMA_SPI0_INT_DriverIRQHandler(), DMA_SPI1_INT_DriverIRQHandler(), DMA_SPI2_INT_DriverIRQHandler(), DMA_SPI3_INT_DriverIRQHandler(), LPSPI_Deinit(), LPSPI_MasterInit(), LPSPI_MasterTransferBlocking(), LPSPI_MasterTransferCreateHandle(), LPSPI_MasterTransferNonBlocking(), LPSPI_SetDummyData(), LPSPI_SlaveInit(), LPSPI_SlaveTransferCreateHandle(), and LPSPI_SlaveTransferNonBlocking().

Here is the caller graph for this function:

LPSPI_MasterTransferComplete()

static void LPSPI_MasterTransferComplete ( LPSPI_Type *  base, lpspi_master_handle_t *  handle  )

static

Master finish up a transfer. It would call back if there is callback function and set the state to idle. This is not a public API.

Definition at line 1170 of file fsl_lpspi.c.

{
    assert(handle);
 
    /* Disable interrupt requests*/
    LPSPI_DisableInterrupts(base, kLPSPI_AllInterruptEnable);
 
    handle->state = kLPSPI_Idle;
 
    if (handle->callback)
    {
        handle->callback(base, handle, kStatus_Success, handle->userData);
    }
}

Referenced by LPSPI_MasterTransferHandleIRQ().

Here is the call graph for this function:

Here is the caller graph for this function:

LPSPI_MasterTransferFillUpTxFifo()

static void LPSPI_MasterTransferFillUpTxFifo ( LPSPI_Type *  base, lpspi_master_handle_t *  handle  )

static

Master fill up the TX FIFO with data. This is not a public API.

Definition at line 1110 of file fsl_lpspi.c.

{
    assert(handle);
 
    uint32_t wordToSend = 0;
 
    /* Make sure the difference in remaining TX and RX byte counts does not exceed FIFO depth
    * and that the number of TX FIFO entries does not exceed the FIFO depth.
    * But no need to make the protection if there is no rxData.
    */
    while ((LPSPI_GetTxFifoCount(base) < (handle->fifoSize)) &&
           (((handle->readRegRemainingTimes - handle->writeRegRemainingTimes) < handle->fifoSize) ||
            (handle->rxData == NULL)))
    {
        if (handle->txRemainingByteCount < handle->bytesEachWrite)
        {
            handle->bytesEachWrite = handle->txRemainingByteCount;
        }
 
        if (handle->txData)
        {
            wordToSend = LPSPI_CombineWriteData(handle->txData, handle->bytesEachWrite, handle->isByteSwap);
            handle->txData += handle->bytesEachWrite;
        }
        else
        {
            wordToSend = handle->txBuffIfNull;
        }
 
        /*Write the word to TX register*/
        LPSPI_WriteData(base, wordToSend);
 
        /*Decrease the write TX register times.*/
        --handle->writeRegRemainingTimes;
 
        /*Decrease the remaining TX byte count.*/
        handle->txRemainingByteCount -= handle->bytesEachWrite;
 
        if (handle->txRemainingByteCount == 0)
        {
            /* If PCS is continuous, update TCR to de-assert PCS */
            if (handle->isPcsContinuous)
            {
                /* Only write to the TCR if the FIFO has room */
                if ((LPSPI_GetTxFifoCount(base) < (handle->fifoSize)))
                {
                    base->TCR = (base->TCR & ~(LPSPI_TCR_CONTC_MASK));
                    handle->writeTcrInIsr = false;
                }
                /* Else, set a global flag to tell the ISR to do write to the TCR */
                else
                {
                    handle->writeTcrInIsr = true;
                }
            }
            break;
        }
    }
}

Referenced by LPSPI_MasterTransferHandleIRQ(), and LPSPI_MasterTransferNonBlocking().

Here is the call graph for this function:

Here is the caller graph for this function:

LPSPI_SeparateReadData()

static void LPSPI_SeparateReadData ( uint8_t *  rxData, uint32_t  readData, uint32_t  bytesEachRead, bool  isByteSwap  )

static

Separate the read data for 1 byte to 4 bytes. This is not a public API.

Definition at line 1896 of file fsl_lpspi.c.

{
    assert(rxData);
 
    switch (bytesEachRead)
    {
        case 1:
            *rxData = readData;
            ++rxData;
            break;
 
        case 2:
            if (!isByteSwap)
            {
                *rxData = readData;
                ++rxData;
                *rxData = readData >> 8;
                ++rxData;
            }
            else
            {
                *rxData = readData >> 8;
                ++rxData;
                *rxData = readData;
                ++rxData;
            }
            break;
 
        case 3:
            if (!isByteSwap)
            {
                *rxData = readData;
                ++rxData;
                *rxData = readData >> 8;
                ++rxData;
                *rxData = readData >> 16;
                ++rxData;
            }
            else
            {
                *rxData = readData >> 16;
                ++rxData;
                *rxData = readData >> 8;
                ++rxData;
                *rxData = readData;
                ++rxData;
            }
            break;
 
        case 4:
            if (!isByteSwap)
            {
                *rxData = readData;
                ++rxData;
                *rxData = readData >> 8;
                ++rxData;
                *rxData = readData >> 16;
                ++rxData;
                *rxData = readData >> 24;
                ++rxData;
            }
            else
            {
                *rxData = readData >> 24;
                ++rxData;
                *rxData = readData >> 16;
                ++rxData;
                *rxData = readData >> 8;
                ++rxData;
                *rxData = readData;
                ++rxData;
            }
            break;
 
        default:
            assert(false);
            break;
    }
}

Referenced by LPSPI_MasterTransferBlocking(), LPSPI_MasterTransferHandleIRQ(), and LPSPI_SlaveTransferHandleIRQ().

Here is the caller graph for this function:

LPSPI_SetOnePcsPolarity()

static void LPSPI_SetOnePcsPolarity ( LPSPI_Type *  base, lpspi_which_pcs_t  pcs, lpspi_pcs_polarity_config_t  activeLowOrHigh  )

static

Configures the LPSPI peripheral chip select polarity.

This function takes in the desired peripheral chip select (Pcs) and it's corresponding desired polarity and configures the Pcs signal to operate with the desired characteristic.

Parameters

base	LPSPI peripheral address.
pcs	The particular peripheral chip select (parameter value is of type lpspi_which_pcs_t) for which we wish to apply the active high or active low characteristic.
activeLowOrHigh	The setting for either "active high, inactive low (0)" or "active low, inactive high(1)" of type lpspi_pcs_polarity_config_t.

Definition at line 385 of file fsl_lpspi.c.

{
    uint32_t cfgr1Value = 0;
    /* Clear the PCS polarity bit */
    cfgr1Value = base->CFGR1 & ~(1U << (LPSPI_CFGR1_PCSPOL_SHIFT + pcs));
 
    /* Configure the PCS polarity bit according to the activeLowOrHigh setting */
    base->CFGR1 = cfgr1Value | ((uint32_t)activeLowOrHigh << (LPSPI_CFGR1_PCSPOL_SHIFT + pcs));
}

Referenced by LPSPI_MasterInit(), and LPSPI_SlaveInit().

Here is the caller graph for this function:

LPSPI_SlaveTransferComplete()

static void LPSPI_SlaveTransferComplete ( LPSPI_Type *  base, lpspi_slave_handle_t *  handle  )

static

Slave finish up a transfer. It would call back if there is callback function and set the state to idle. This is not a public API.

Definition at line 1593 of file fsl_lpspi.c.

{
    assert(handle);
 
    status_t status = 0;
 
    /* Disable interrupt requests*/
    LPSPI_DisableInterrupts(base, kLPSPI_AllInterruptEnable);
 
    if (handle->state == kLPSPI_Error)
    {
        status = kStatus_LPSPI_Error;
    }
    else
    {
        status = kStatus_Success;
    }
 
    handle->state = kLPSPI_Idle;
 
    if (handle->callback)
    {
        handle->callback(base, handle, status, handle->userData);
    }
}

Referenced by LPSPI_SlaveTransferHandleIRQ().

Here is the call graph for this function:

Here is the caller graph for this function:

LPSPI_SlaveTransferFillUpTxFifo()

static void LPSPI_SlaveTransferFillUpTxFifo ( LPSPI_Type *  base, lpspi_slave_handle_t *  handle  )

static

Slave fill up the TX FIFO with data. This is not a public API.

Definition at line 1564 of file fsl_lpspi.c.

{
    assert(handle);
 
    uint32_t wordToSend = 0;
 
    while (LPSPI_GetTxFifoCount(base) < (handle->fifoSize))
    {
        if (handle->txRemainingByteCount < handle->bytesEachWrite)
        {
            handle->bytesEachWrite = handle->txRemainingByteCount;
        }
 
        wordToSend = LPSPI_CombineWriteData(handle->txData, handle->bytesEachWrite, handle->isByteSwap);
        handle->txData += handle->bytesEachWrite;
 
        /*Decrease the remaining TX byte count.*/
        handle->txRemainingByteCount -= handle->bytesEachWrite;
 
        /*Write the word to TX register*/
        LPSPI_WriteData(base, wordToSend);
 
        if (handle->txRemainingByteCount == 0)
        {
            break;
        }
    }
}

Referenced by LPSPI_SlaveTransferHandleIRQ(), and LPSPI_SlaveTransferNonBlocking().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

s_baudratePrescaler

const uint8_t s_baudratePrescaler[] = {1, 2, 4, 8, 16, 32, 64, 128}

static

Definition at line 116 of file fsl_lpspi.c.

{1, 2, 4, 8, 16, 32, 64, 128};

Referenced by LPSPI_MasterSetBaudRate(), and LPSPI_MasterSetDelayTimes().

s_lpspiBases

LPSPI_Type* const s_lpspiBases[] = LPSPI_BASE_PTRS

static

Pointers to lpspi bases for each instance.

Definition at line 119 of file fsl_lpspi.c.

Referenced by LPSPI_GetInstance().

s_lpspiClocks

const clock_ip_name_t s_lpspiClocks[] = LPSPI_CLOCKS

static

Pointers to lpspi clocks for each instance.

Definition at line 126 of file fsl_lpspi.c.

Referenced by LPSPI_Deinit(), LPSPI_MasterInit(), and LPSPI_SlaveInit().

s_lpspiHandle

void* s_lpspiHandle[ARRAY_SIZE(s_lpspiBases)] = {NULL}

static

Pointers to lpspi handles for each instance.

Definition at line 135 of file fsl_lpspi.c.

{NULL};

Referenced by ADMA_SPI0_INT_DriverIRQHandler(), ADMA_SPI1_INT_DriverIRQHandler(), ADMA_SPI2_INT_DriverIRQHandler(), ADMA_SPI3_INT_DriverIRQHandler(), DMA_SPI0_INT_DriverIRQHandler(), DMA_SPI1_INT_DriverIRQHandler(), DMA_SPI2_INT_DriverIRQHandler(), DMA_SPI3_INT_DriverIRQHandler(), LPSPI0_DriverIRQHandler(), LPSPI1_DriverIRQHandler(), LPSPI2_DriverIRQHandler(), LPSPI3_DriverIRQHandler(), LPSPI4_DriverIRQHandler(), LPSPI5_DriverIRQHandler(), LPSPI_MasterTransferCreateHandle(), and LPSPI_SlaveTransferCreateHandle().

s_lpspiIRQ

const IRQn_Type s_lpspiIRQ[] = LPSPI_IRQS

static

Pointers to lpspi IRQ number for each instance.

Definition at line 122 of file fsl_lpspi.c.

Referenced by LPSPI_MasterTransferNonBlocking(), and LPSPI_SlaveTransferNonBlocking().

s_lpspiMasterIsr

lpspi_master_isr_t s_lpspiMasterIsr

static

Pointer to master IRQ handler for each instance.

Definition at line 138 of file fsl_lpspi.c.

Referenced by LPSPI_CommonIRQHandler(), and LPSPI_MasterTransferCreateHandle().

s_LpspiPeriphClocks

const clock_ip_name_t s_LpspiPeriphClocks[] = LPSPI_PERIPH_CLOCKS

static

Definition at line 129 of file fsl_lpspi.c.

Referenced by LPSPI_Deinit(), LPSPI_MasterInit(), and LPSPI_SlaveInit().

s_lpspiSlaveIsr

lpspi_slave_isr_t s_lpspiSlaveIsr

static

Pointer to slave IRQ handler for each instance.

Definition at line 140 of file fsl_lpspi.c.

Referenced by LPSPI_CommonIRQHandler(), and LPSPI_SlaveTransferCreateHandle().

Go to the source code of this file.