SPI Functions

Modules
	SPI Private Functions

Functions
void	sd_spi2_init (void)
void	HAL_SPI_MspInit (SPI_HandleTypeDef *hspi)
void	HAL_SPI_MspDeInit (SPI_HandleTypeDef *hspi)
enum sd_spi_error	sd_spi_dev_init (struct sd_spi_dev *dev, SPI_HandleTypeDef *spi)
	SPI Device Initialization Initialize SPI device structure. More...
enum sd_spi_error	sd_spi_rx_init (struct sd_spi_dev *dev, struct sd_cbuf *rx_buff)
	SPI Receive Interrupt Initialization Enable and prepare the SPI to receive on interrupt. More...
void	sd_spi_irqhandler (struct sd_spi_dev *dev)
	SPI Interrupt Handler Handle interrupt events on the spi peripheral. More...
static enum sd_spi_error	sd_spi_rx_isr (struct sd_spi_dev *dev)
	Receive an amount of data in interrupt mode. More...
static void	sd_spi_error_cb (struct sd_spi_dev *dev)
	Handle SPI error interrupts. More...

Detailed Description

Function Documentation

HAL_SPI_MspDeInit()

void HAL_SPI_MspDeInit

(

SPI_HandleTypeDef *

hspi

)

#include <Src/sd_spi.c>

SPI2 GPIO Configuration
PB15 ---—> SPI2_MOSI PB14 ---—> SPI2_MISO PB13 ---—> SPI2_SCK PB12 ---—> SPI2_NSS

{
    if (hspi->Instance==SPI2) {
        /* Peripheral clock disable */
        __SPI2_CLK_DISABLE();
  
        HAL_GPIO_DeInit(GPIOB, ZYNQ_SPI_MOSI_Pin|ZYNQ_SPI_MISO_Pin|ZYNQ_SPI_CLK_Pin|ZYNQ_SPI_NSS_Pin);

        /* Peripheral interrupt Deinit*/
        HAL_NVIC_DisableIRQ(SPI2_IRQn);

    }
} 

HAL_SPI_MspInit()

void HAL_SPI_MspInit

(

SPI_HandleTypeDef *

hspi

)

#include <Src/sd_spi.c>

SPI2 GPIO Configuration

PB15 ---—> SPI2_MOSI PB14 ---—> SPI2_MISO PB13 ---—> SPI2_SCK PB12 ---—> SPI2_NSS

{
    GPIO_InitTypeDef GPIO_InitStruct;
    
    if (hspi->Instance==SPI2) {
        /* Peripheral clock enable */
        __SPI2_CLK_ENABLE();
  
        GPIO_InitStruct.Pin = ZYNQ_SPI_MOSI_Pin|ZYNQ_SPI_MISO_Pin|ZYNQ_SPI_CLK_Pin|ZYNQ_SPI_NSS_Pin;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
        GPIO_InitStruct.Alternate = GPIO_AF0_SPI2;
        HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

        /* Peripheral interrupt init*/
        HAL_NVIC_SetPriority(SPI2_IRQn, 0, 0);
        HAL_NVIC_EnableIRQ(SPI2_IRQn);
    }
}

sd_spi_dev_init()

enum sd_spi_error sd_spi_dev_init	(	struct sd_spi_dev *	dev,
		SPI_HandleTypeDef *	spi
	)

#include <Src/sd_spi.c>

SPI Device Initialization Initialize SPI device structure.

Parameters

spi_dev

Device structure to initialize

Return values

SD_SPI_SUCCESS

on success, error state otherwise

{
    /* Reset the UART device structure */
    memset(dev, 0, sizeof(struct sd_spi_dev));
    
    dev->spi = spi;
  
    return SD_SPI_SUCCESS;
}

sd_spi_error_cb()

static void sd_spi_error_cb ( struct sd_spi_dev *  dev )

inlinestatic

#include <Src/sd_spi.c>

Handle SPI error interrupts.

Parameters

spi	SPI handle with error triggered error interrupt

Return values

none

{
  /* Handle errors */
}

sd_spi_irqhandler()

void sd_spi_irqhandler

(

struct sd_spi_dev *

dev

)

#include <Src/sd_spi.c>

SPI Interrupt Handler Handle interrupt events on the spi peripheral.

Parameters

spi_dev

SPI device that triggered the interrupt

Return values

none

{
    SPI_HandleTypeDef *spi = dev->spi;

    uint32_t itsource = spi->Instance->CR2;
    uint32_t itflag   = spi->Instance->SR;

    /*---------------------- SPI in mode Receiver ------------------------*/
    if (((itflag & SPI_FLAG_OVR) == RESET) &&
        ((itflag & SPI_FLAG_RXNE) != RESET) && 
        ((itsource & SPI_IT_RXNE) != RESET)) {
        sd_spi_rx_isr(dev);
        return;
    }

    /*--------------------- SPI in mode Transmitter ----------------------*/
    if (((itflag & SPI_FLAG_TXE) != RESET) && 
        ((itsource & SPI_IT_TXE) != RESET)) {
        spi->TxISR(spi);
        return;
    }

    /*-------------------- SPI in Error Treatment ------------------------*/
    if ((itflag & (SPI_FLAG_MODF | SPI_FLAG_OVR | SPI_FLAG_FRE)) != RESET) {
        /* SPI Overrun error interrupt occurred */
        if ((itflag & SPI_FLAG_OVR) != RESET) {
            if (spi->State != HAL_SPI_STATE_BUSY_TX) {
                spi->ErrorCode |= HAL_SPI_ERROR_OVR;
                __HAL_SPI_CLEAR_OVRFLAG(spi);
            } else {
                return;
            }
        }

        /* SPI Mode Fault error interrupt occurred */
        if ((itflag & SPI_FLAG_MODF) != RESET) {
            spi->ErrorCode |= HAL_SPI_ERROR_MODF;
            __HAL_SPI_CLEAR_MODFFLAG(spi);
        }

        /* SPI Frame error interrupt occurred */
        if ((itflag & SPI_FLAG_FRE) != RESET) {
            spi->ErrorCode |= HAL_SPI_ERROR_FRE;
            __HAL_SPI_CLEAR_FREFLAG(spi);
        }

        __HAL_SPI_DISABLE_IT(spi, SPI_IT_RXNE | SPI_IT_TXE | SPI_IT_ERR);
        spi->State = HAL_SPI_STATE_READY;
        sd_spi_error_cb(dev);
        return;
    }
}

sd_spi_rx_init()

enum sd_spi_error sd_spi_rx_init	(	struct sd_spi_dev *	dev,
		struct sd_cbuf *	rx_buff
	)

#include <Src/sd_spi.c>

SPI Receive Interrupt Initialization Enable and prepare the SPI to receive on interrupt.

Note

This function expects that the SPI peripheral and the buffer have already been inititialized and are ready to be used.

Parameters

dev	Device to initialize SPI and buffer
spi	SPI peripheral handle
rx_buff	Buffer to use for UART receive function

Return values

SD_SPI_SUCCESS

on success, error state otherwise

{
    SPI_HandleTypeDef *spi = dev->spi;

    if ((dev == NULL) || (spi == NULL))
        goto error;
                        
    dev->spi = spi;      /* Set the UART handle pointer */
       
    /* Process Locked */            
    if (spi->Lock == HAL_LOCKED)
        return SD_SPI_LOCKED;
    else
        spi->Lock = HAL_LOCKED;

    /* Configure communication */
    spi->State       = HAL_SPI_STATE_BUSY_RX;
    spi->ErrorCode   = HAL_SPI_ERROR_NONE;


    if (spi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE) {
        spi->CRCSize = 1;
        if ((spi->Init.DataSize <= SPI_DATASIZE_8BIT) && (spi->Init.CRCLength == SPI_CRC_LENGTH_16BIT)) {
            spi->CRCSize = 2;
        }
    } else {
        spi->CRCSize = 0;
    }

    /* set fiforxthresold according the reception data length: 8 bit */
    SET_BIT(spi->Instance->CR2, SPI_RXFIFO_THRESHOLD);
//  spi->RxISR = SPI_RxISR_8BIT;

    /* Configure communication direction : 1Line */
    if (spi->Init.Direction == SPI_DIRECTION_1LINE)
        SPI_1LINE_RX(spi);

    /* Reset CRC Calculation */
    if (spi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
        SPI_RESET_CRC(spi);
    

    /* Enable RXNE and ERR interrupt */
    __HAL_SPI_ENABLE_IT(spi, (SPI_IT_RXNE | SPI_IT_ERR));

    /* Check if the SPI is already enabled */
    if ((spi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)
        __HAL_SPI_ENABLE(spi);         /* Enable SPI peripheral */

    error :
        /* Process Unlocked */
        __HAL_UNLOCK(spi);
        return SD_SPI_ERROR;
}

sd_spi_rx_isr()

enum sd_spi_error sd_spi_rx_isr ( struct sd_spi_dev *  dev )

static

#include <Src/sd_spi.c>

Receive an amount of data in interrupt mode.

Parameters

spi_dev

The SPI peripheral that triggered interrupt

Return values

SD_SPI_SUCCESS

on success, error status otherwise

Todo:

Determine where to put the collected data based on the first two bytes (register and packet length) and point to the peripheral that matches the the register.

{
    struct sd_cbuf *rx_buff = dev->rx_buff;
    SPI_HandleTypeDef *spi = dev->spi;
    uint8_t c;
    
    rx_buff->buff[rx_buff->in++] = (uint8_t)spi->Instance->DR;
    
    if (rx_buff->in >= rx_buff->size)
        rx_buff->in = 0;
    
    switch (dev->rx_state) {
    case SD_SPI_RX_WAITING:
    /*
     * Use the received byte to point to the corresponding
     * peripheral/interface.
     */
        dev->pkt->hdr = c;
        dev->rx_state = SD_SPI_RX_LENGTH;
        break;
    
    case SD_SPI_RX_LENGTH:
        /*
     * Use the received byte to determine the length of the packet
     * message that is to be received.
     */
        dev->pkt->len = c;
        dev->pkt->pload = &spi_pkt_buff[0];
        dev->rx_state = SD_SPI_RX_PACKET;
        break;
        
    case SD_SPI_RX_PACKET:
        /* In the process of receiving a packet. */
        *(dev->pkt->pload++) = c;
        if (--dev->pkt->len == 0) {
            /* Retransmit the buffer */
            dev->pkt->pload = &spi_pkt_buff[0];
            /* sd_spi_bridge(dev); */
            dev->rx_state = SD_SPI_RX_WAITING;
        }
        break;
    }
    
        
    
//  if (sd_char_buff_putc_to(rx_buff, c, 100) == SD_BUFF_SUCCESS)
        return SD_SPI_SUCCESS;
//  else
//      return SD_SPI_ERROR;    
}