SPI

Functions
static int32_t	spi_detectPCS (bool isMaster, ioportid_t ssport, uint16_t sspad, int *alt)
static int32_t	spi_detectBaudRate (SPIDriver *spip)
void	spi_lld_master_callback (LPSPI_Type *base, lpspi_master_handle_t *handle, status_t status, void *userData)
void	spi_lld_slave_callback (LPSPI_Type *base, lpspi_slave_handle_t *handle, status_t status, void *userData)

Variables
SPIDriver	SPID1
	SPI0 driver identifier.
SPIDriver	SPID2
	SPI1 driver identifier.

Configuration options
typedef void(*	spicallback_t) (SPIDriver *spip)
	SPI notification callback type.
SPIDriver	SPID1
	SPI0 driver identifier.
SPIDriver	SPID2
	SPI1 driver identifier.
void	spi_lld_init (void)
	Low level SPI driver initialization.
void	spi_lld_start (SPIDriver *spip)
	Configures and activates the SPI peripheral.
void	spi_lld_stop (SPIDriver *spip)
	Deactivates the SPI peripheral.
void	spi_lld_select (SPIDriver *spip)
	Asserts the slave select signal and prepares for transfers.
void	spi_lld_unselect (SPIDriver *spip)
	Deasserts the slave select signal.
void	spi_lld_ignore (SPIDriver *spip, size_t n)
	Ignores data on the SPI bus.
void	spi_lld_exchange (SPIDriver *spip, size_t n, const void *txbuf, void *rxbuf)
	Exchanges data on the SPI bus.
void	spi_lld_send (SPIDriver *spip, size_t n, const void *txbuf)
	Sends data over the SPI bus.
void	spi_lld_receive (SPIDriver *spip, size_t n, void *rxbuf)
	Receives data from the SPI bus.
void	spi_lld_abort (SPIDriver *spip)
	Aborts the ongoing SPI operation, if any.
uint16_t	spi_lld_polled_exchange (SPIDriver *spip, uint16_t frame)
	Exchanges one frame using a polled wait.

Detailed Description

Typedef Documentation

spicallback_t

typedef void(* spicallback_t) (SPIDriver *spip)

SPI notification callback type.

Parameters

[in]

spip

pointer to the SPIDriver object triggering the callback

Definition at line 123 of file hal_spi_lld.h.

Function Documentation

spi_detectBaudRate()

static int32_t spi_detectBaudRate ( SPIDriver *  spip )

static

Definition at line 90 of file hal_spi_lld.c.

                                                   {
    static const int baudRates[] = { 21000000, 10500000, 5250000, 2626000, 1312500, 656250, 328125, 164060 };
    int flags = 0;
    if (spip->config->cr1 & SPI_CR1_BR_0)
        flags |= 1;
    if (spip->config->cr1 & SPI_CR1_BR_1)
        flags |= 2;
    if (spip->config->cr1 & SPI_CR1_BR_2)
        flags |= 4;
    int br = baudRates[flags];
    // SPI1 is faster on STM32 (42 MHz max) so we imitate this behavior
    if (spip == &SPID1)
        br *= 2;
    return br;
}

Referenced by spi_lld_start().

Here is the caller graph for this function:

spi_detectPCS()

static int32_t spi_detectPCS ( bool  isMaster, ioportid_t  ssport, uint16_t  sspad, int *  alt  )

static

Definition at line 58 of file hal_spi_lld.c.

                                                                                         {
    // todo: check if PCS corresponds to SPI number
    *alt = 3;
    if (ssport == GPIOA) {
        switch (sspad) {
        case 6: 
            return isMaster ? kLPSPI_MasterPcs1 : kLPSPI_SlavePcs1;
        case 15:
            return isMaster ? kLPSPI_MasterPcs3 : kLPSPI_SlavePcs3;
        case 16:
            return isMaster ? kLPSPI_MasterPcs2 : kLPSPI_SlavePcs2;
        }
    } else if (ssport == GPIOB) {
        switch (sspad) {
        case 0:
            return isMaster ? kLPSPI_MasterPcs0 : kLPSPI_SlavePcs0;
        case 5:
            return isMaster ? kLPSPI_MasterPcs1 : kLPSPI_SlavePcs1;
        case 17:
            return isMaster ? kLPSPI_MasterPcs3 : kLPSPI_SlavePcs3;
        }
    } else if (ssport == GPIOD && sspad == 3) {
        return isMaster ? kLPSPI_MasterPcs0 : kLPSPI_SlavePcs0;
    } else if (ssport == GPIOE && sspad == 6) {
        *alt = 2;
        return isMaster ? kLPSPI_MasterPcs2 : kLPSPI_SlavePcs2;
    }
    // wrong/unrecognized PCS!
    *alt = 0;
    return -1;
}

Referenced by spi_lld_start().

Here is the caller graph for this function:

spi_lld_abort()

void spi_lld_abort

(

SPIDriver *

spip

)

Aborts the ongoing SPI operation, if any.

Parameters

[in]

spip

pointer to the SPIDriver object

@notapi

Definition at line 390 of file hal_spi_lld.c.

                                    {
#if 0
  //SPI_DisableDMA(base, kLPSPI_TxDmaEnable | kLPSPI_RxDmaEnable);
  /* Stopping DMAs.*/
  dmaStreamDisable(spip->dmatx);
  dmaStreamDisable(spip->dmarx);
#endif
}

spi_lld_exchange()

void spi_lld_exchange	(	SPIDriver *	spip,
		size_t	n,
		const void *	txbuf,
		void *	rxbuf
	)

Exchanges data on the SPI bus.

This asynchronous function starts a simultaneous transmit/receive operation.

Postcondition

At the end of the operation the configured callback is invoked.

Note

The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the SPIDriver object
[in]	n	number of words to be exchanged
[in]	txbuf	the pointer to the transmit buffer
[out]	rxbuf	the pointer to the receive buffer

@notapi

Definition at line 314 of file hal_spi_lld.c.

                                                      {
    spip->handleXfer.txData = (uint8_t *)txbuf;
    spip->handleXfer.rxData = rxbuf;
    spip->handleXfer.dataSize = n;
    spip->handleXfer.configFlags = spip->flags;
    
    if (spip->isMaster) {
        LPSPI_MasterTransferNonBlocking(spip->spi, &spip->masterHandle, &spip->handleXfer);
    } else {
        LPSPI_SlaveTransferNonBlocking(spip->spi, &spip->slaveHandle, &spip->handleXfer);
    }
}

Here is the call graph for this function:

spi_lld_ignore()

void spi_lld_ignore	(	SPIDriver *	spip,
		size_t	n
	)

Ignores data on the SPI bus.

This asynchronous function starts the transmission of a series of idle words on the SPI bus and ignores the received data.

Postcondition

At the end of the operation the configured callback is invoked.

Parameters

[in]	spip	pointer to the SPIDriver object
[in]	n	number of words to be ignored

@notapi

Definition at line 289 of file hal_spi_lld.c.

                                               {
/*
  spip->count = n;
  spip->rxbuf = NULL;
  spip->txbuf = NULL;
 
  spi_start_xfer(spip, false);
*/
}

spi_lld_init()

void spi_lld_init

(

void

)

Low level SPI driver initialization.

@notapi

Definition at line 135 of file hal_spi_lld.c.

                        {
#if KINETIS_SPI_USE_SPI0
  spiObjectInit(&SPID1);
#endif
#if KINETIS_SPI_USE_SPI1
  spiObjectInit(&SPID2);
#endif
}

spi_lld_master_callback()

void spi_lld_master_callback	(	LPSPI_Type *	base,
		lpspi_master_handle_t *	handle,
		status_t	status,
		void *	userData
	)

Definition at line 110 of file hal_spi_lld.c.

                                                       {
    SPIDriver *spi = (SPIDriver *)userData;
 
    // todo: check status?
    _spi_isr_code(spi);
}

Referenced by spi_lld_start().

Here is the caller graph for this function:

spi_lld_polled_exchange()

uint16_t spi_lld_polled_exchange	(	SPIDriver *	spip,
		uint16_t	frame
	)

Exchanges one frame using a polled wait.

This synchronous function exchanges one frame using a polled synchronization method. This function is useful when exchanging small amount of data on high speed channels, usually in this situation is much more efficient just wait for completion using polling than suspending the thread waiting for an interrupt.

Parameters

[in]	spip	pointer to the SPIDriver object
[in]	frame	the data frame to send over the SPI bus

Returns

The received data frame from the SPI bus.

Definition at line 412 of file hal_spi_lld.c.

                                                                  {
    // todo: use faster LPSPI_WriteData()
    uint16_t rxFrame = 0;
    spip->handleXfer.txData = (uint8_t *)&frame;
    spip->handleXfer.rxData = (uint8_t *)&rxFrame;
    spip->handleXfer.dataSize = sizeof(frame);
    spip->handleXfer.configFlags = spip->flags;
 
    if (spip->isMaster) {
        LPSPI_MasterTransferBlocking(spip->spi, &spip->handleXfer);
    } else {
        // todo: slave support?
    }
    // todo: check status?
    return rxFrame;
}

Here is the call graph for this function:

spi_lld_receive()

void spi_lld_receive	(	SPIDriver *	spip,
		size_t	n,
		void *	rxbuf
	)

Receives data from the SPI bus.

This asynchronous function starts a receive operation.

Postcondition

At the end of the operation the configured callback is invoked.

Note

The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the SPIDriver object
[in]	n	number of words to receive
[out]	rxbuf	the pointer to the receive buffer

@notapi

Definition at line 368 of file hal_spi_lld.c.

                                                             {
 
    spip->handleXfer.txData = NULL;
    spip->handleXfer.rxData = (uint8_t *)rxbuf;
    spip->handleXfer.dataSize = n;
    spip->handleXfer.configFlags = spip->flags;
 
    if (spip->isMaster) {
        LPSPI_MasterTransferNonBlocking(spip->spi, &spip->masterHandle, &spip->handleXfer);
    } else {
        LPSPI_SlaveTransferNonBlocking(spip->spi, &spip->slaveHandle, &spip->handleXfer);
    }
}

Here is the call graph for this function:

spi_lld_select()

void spi_lld_select

(

SPIDriver *

spip

)

Asserts the slave select signal and prepares for transfers.

Parameters

[in]

spip

pointer to the SPIDriver object

@notapi

Definition at line 258 of file hal_spi_lld.c.

                                     {
    // software PCS control for non-standard pins
    if (!(spip->flags & LPSPI_MASTER_PCS_MASK))
        palClearPad(spip->config->ssport, spip->config->sspad);
}

spi_lld_send()

void spi_lld_send	(	SPIDriver *	spip,
		size_t	n,
		const void *	txbuf
	)

Sends data over the SPI bus.

This asynchronous function starts a transmit operation.

Postcondition

At the end of the operation the configured callback is invoked.

Note

The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the SPIDriver object
[in]	n	number of words to send
[in]	txbuf	the pointer to the transmit buffer

@notapi

Definition at line 341 of file hal_spi_lld.c.

                                                                {
 
    spip->handleXfer.txData = (uint8_t *)txbuf;
    spip->handleXfer.rxData = NULL;
    spip->handleXfer.dataSize = n;
    spip->handleXfer.configFlags = spip->flags;
 
    if (spip->isMaster) {
        LPSPI_MasterTransferNonBlocking(spip->spi, &spip->masterHandle, &spip->handleXfer);
    } else {
        LPSPI_SlaveTransferNonBlocking(spip->spi, &spip->slaveHandle, &spip->handleXfer);
    }
}

Here is the call graph for this function:

spi_lld_slave_callback()

void spi_lld_slave_callback	(	LPSPI_Type *	base,
		lpspi_slave_handle_t *	handle,
		status_t	status,
		void *	userData
	)

Definition at line 118 of file hal_spi_lld.c.

                                                       {
    SPIDriver *spi = (SPIDriver *)userData;
 
    // todo: check status?
    _spi_isr_code(spi);
}

Referenced by spi_lld_start().

Here is the caller graph for this function:

spi_lld_start()

void spi_lld_start

(

SPIDriver *

spip

)

Configures and activates the SPI peripheral.

Parameters

[in]

spip

pointer to the SPIDriver object

@notapi

Definition at line 151 of file hal_spi_lld.c.

                                    {
 
  /* If in stopped state then enables the SPI and DMA clocks.*/
  if (spip->state == SPI_STOP) {
    clock_ip_name_t clockName;
#if KINETIS_SPI_USE_SPI0
    if (&SPID1 == spip) {
      spip->spi = LPSPI0;
      clockName = kCLOCK_Lpspi0;
    }
#endif
 
#if KINETIS_SPI_USE_SPI1
    if (&SPID2 == spip) {
      spip->spi = LPSPI1;
      clockName = kCLOCK_Lpspi1;
    }
#endif
 
    spip->isMaster = (spip->config->cr1 & SPI_CR1_MSTR) != 0;
    spip->flags = 0;  // kLPSPI_MasterByteSwap;
    int pcsAlt;
    int pcsIdx = spi_detectPCS(spip->isMaster, spip->config->ssport, spip->config->sspad, &pcsAlt);
    if (pcsIdx >= 0) {
        spip->flags |= pcsIdx;
        // enable corresponding alt.mode for hardware PCS control
        palSetPadMode(spip->config->ssport, spip->config->sspad, PAL_MODE_ALTERNATE(pcsAlt));
    } else {
        // software PCS control for non-standard pins
        palSetPadMode(spip->config->ssport, spip->config->sspad, PAL_MODE_OUTPUT_OPENDRAIN);
    }
    
    //CLOCK_SetIpSrc(clockName, kCLOCK_IpSrcSysPllAsync);
 
    if (spip->isMaster) {
        // Master mode
        lpspi_master_config_t masterConfig;
        LPSPI_MasterGetDefaultConfig(&masterConfig);
 
        masterConfig.baudRate = spi_detectBaudRate(spip);
        masterConfig.bitsPerFrame = (spip->config->cr1 & SPI_CR1_DFF) ? 16 : 8;
        masterConfig.cpol = (spip->config->cr1 & SPI_CR1_CPOL) ? kLPSPI_ClockPolarityActiveLow : kLPSPI_ClockPolarityActiveHigh;
        masterConfig.cpha = (spip->config->cr1 & SPI_CR1_CPHA) ? kLPSPI_ClockPhaseSecondEdge : kLPSPI_ClockPhaseFirstEdge;
        masterConfig.direction = (spip->config->cr1 & SPI_CR1_LSBFIRST) ? kLPSPI_LsbFirst : kLPSPI_MsbFirst;
 
        masterConfig.pcsToSckDelayInNanoSec = 1000000000 / masterConfig.baudRate * 2;
        masterConfig.lastSckToPcsDelayInNanoSec = 1000000000 / masterConfig.baudRate * 2;
        masterConfig.betweenTransferDelayInNanoSec = 1000000000 / masterConfig.baudRate * 2;
        
        masterConfig.whichPcs = pcsIdx;
 
        if (spip->config->circular)
            spip->flags |= kLPSPI_MasterPcsContinuous;
        
        uint32_t srcClock_Hz = CLOCK_GetIpFreq(clockName);
        LPSPI_MasterInit(spip->spi, &masterConfig, srcClock_Hz);
 
        LPSPI_MasterTransferCreateHandle(spip->spi, &spip->masterHandle, spi_lld_master_callback, spip);
    } else {
        // todo: add slave support
        lpspi_slave_config_t slaveConfig;
        LPSPI_SlaveGetDefaultConfig(&slaveConfig);
        LPSPI_SlaveInit(spip->spi, &slaveConfig);
        
        LPSPI_SlaveTransferCreateHandle(spip->spi, &spip->slaveHandle, spi_lld_slave_callback, spip);
    }
 
    // todo: add DMA support?
    //nvicEnableVector(DMA0_IRQn, KINETIS_SPI0_RX_DMA_IRQ_PRIORITY);
  }
}

Here is the call graph for this function:

spi_lld_stop()

void spi_lld_stop

(

SPIDriver *

spip

)

Deactivates the SPI peripheral.

Parameters

[in]

spip

pointer to the SPIDriver object

@notapi

Definition at line 230 of file hal_spi_lld.c.

                                   {
 
  /* If in ready state then disables the SPI clock.*/
  if (spip->state == SPI_READY) {
 
    //nvicDisableVector(DMA0_IRQn);
 
#if KINETIS_SPI_USE_SPI0
    if (&SPID1 == spip) {
        LPSPI_Deinit(LPSPI0);
    }
#endif
 
#if KINETIS_SPI_USE_SPI1
    if (&SPID2 == spip) {
        LPSPI_Deinit(LPSPI1);
    }
#endif
  }
}

Here is the call graph for this function:

spi_lld_unselect()

void spi_lld_unselect

(

SPIDriver *

spip

)

Deasserts the slave select signal.

The previously selected peripheral is unselected.

Parameters

[in]

spip

pointer to the SPIDriver object

@notapi

Definition at line 272 of file hal_spi_lld.c.

                                       {
    // software PCS control for non-standard pins
    if (!(spip->flags & LPSPI_MASTER_PCS_MASK))
        palSetPad(spip->config->ssport, spip->config->sspad);
}

Variable Documentation

SPID1 [1/2]

SPIDriver SPID1

SPI0 driver identifier.

Definition at line 42 of file hal_spi_lld.c.

Referenced by getAfListForSpi(), getSpiAf(), getSpiAf(), getSpiDevice(), spi_detectBaudRate(), spi_lld_init(), spi_lld_start(), spi_lld_stop(), spiGetBaseClock(), and turnOnSpi().

SPID1 [2/2]

SPIDriver SPID1

extern

SPI0 driver identifier.

Definition at line 42 of file hal_spi_lld.c.

Referenced by getAfListForSpi(), getSpiAf(), getSpiAf(), getSpiDevice(), spi_detectBaudRate(), spi_lld_init(), spi_lld_start(), spi_lld_stop(), spiGetBaseClock(), and turnOnSpi().

SPID2 [1/2]

SPIDriver SPID2

SPI1 driver identifier.

Definition at line 47 of file hal_spi_lld.c.

Referenced by getAfListForSpi(), getSpiAf(), getSpiAf(), getSpiDevice(), spi_lld_init(), spi_lld_start(), spi_lld_stop(), spiGetBaseClock(), and turnOnSpi().

SPID2 [2/2]

SPIDriver SPID2

extern

SPI1 driver identifier.

Definition at line 47 of file hal_spi_lld.c.

Referenced by getAfListForSpi(), getSpiAf(), getSpiAf(), getSpiDevice(), spi_lld_init(), spi_lld_start(), spi_lld_stop(), spiGetBaseClock(), and turnOnSpi().