SPI Bridge

Bridging from SPI to other peripherals. More...

Data Structures
struct	sd_spbr_cmd
	SPI bridge device operation structure. More...
struct	sd_spbr_dev
	SPI bridge device structure. More...
struct	sd_spbr
	SPI bridge structure. More...

Macros
#define	SD_SPBR_NDEV   (3)
#define	SD_SPBR_I2C_STATUS   ((uint8_t)(1 << 0))
#define	SD_SPBR_LED_STATUS   ((uint8_t)(1 << 1))
#define	SD_SPBR_UART_STATUS   ((uint8_t)(1 << 2))
#define	SD_SPBR_DEV_MASK   (0xF8)
#define	SD_SPBR_I2C_DEV   (0x80)
#define	SD_SPBR_CMD_MASK   (0xE0)
#define	SD_SPBR_I2C_RW_CMD   (0xA0)
#define	SD_SPBR_I2C_READ_TRANS   ((uint8_t)(1 << 2))
#define	SD_SPBR_I2C_ADDR_10BIT   ((uint8_t)(1 << 3))
#define	SD_SPBR_I2C_FREQ_400K   ((uint8_t)(1 << 4))
#define	SD_SPBR_NULL_DEV   { 0, NULL, NULL }
#define	SD_SPBR_NULL_OP   { 0, NULL, NULL }

Enumerations
enum	sd_spbr_state { SD_SPBR_READ_DEVICE, SD_SPBR_READ_CMD, SD_SPBR_IN_PROCESS }

Functions
static void	sd_spbr_rx_isr (struct sd_spbr *spbr)
	SPI Bridge Receive Interrupt Routine. More...
static struct sd_spbr_dev *	sd_spbr_find_device (struct sd_spbr_dev *head, uint8_t id)
	SPI Bridge Find Device Searches a sentinel terminated table pointed to by head for a matching ID and returns a pointer to the device or NULL. More...
static struct sd_spbr_cmd *	sd_spbr_find_cmd (struct sd_spbr_cmd *head, uint8_t opcode)
	SPI Bridge Find Command Searches a sentinel terminated table pointed to by head for a matching ID and returns a pointer to the device or NULL. More...
void	sd_spbr_init (struct sd_spbr *spbr, SPI_HandleTypeDef *spi)
	SPI Bridge Initialize. More...
void	sd_spbr_irqhandler (struct sd_spbr *spbr)
	SPI Bridge Interrupt Handler Handle interrupt events on the SPI peripheral. More...

Variables
struct sd_spbr	spi2_spbr
static struct sd_spbr_dev	spbr_dev_tab []

Detailed Description

Bridging from SPI to other peripherals.

Function Documentation

sd_spbr_find_cmd()

static struct sd_spbr_cmd* sd_spbr_find_cmd ( struct sd_spbr_cmd *  head, uint8_t  opcode  )

static

#include <Src/sd_spi_bridge.c>

SPI Bridge Find Command Searches a sentinel terminated table pointed to by head for a matching ID and returns a pointer to the device or NULL.

Note

To speed up the loops, this function expects the device mask be applied to the id before it is passed to this function.

Parameters

head	Pointer to head of table for searching
id	ID value to search for

Return values

Pointer

to matching device or NULL if not found

{
    struct sd_spbr_cmd *pcmd = head;
    
    while ((pcmd != NULL) && (pcmd->opcode > 0)) {
        if (pcmd->opcode == opcode)
            return pcmd;
            
        pcmd++;
    }
    
    return NULL;
}

sd_spbr_find_device()

static struct sd_spbr_dev* sd_spbr_find_device ( struct sd_spbr_dev *  head, uint8_t  id  )

static

#include <Src/sd_spi_bridge.c>

SPI Bridge Find Device Searches a sentinel terminated table pointed to by head for a matching ID and returns a pointer to the device or NULL.

Note

To speed up the loops, this function expects the device mask be applied to the id before it is passed to this function.

Parameters

head	Pointer to head of table for searching
id	ID value to search for

Return values

Pointer

to matching device or NULL if not found

{
    struct sd_spbr_dev *pdev = head;

    while ((pdev != NULL) && (pdev->id > 0)) {
        if (pdev->id == id)
            return pdev;
            
        pdev++;
    }

    return NULL;
}

sd_spbr_init()

void sd_spbr_init	(	struct sd_spbr *	spbr,
		SPI_HandleTypeDef *	spi
	)

#include <Src/sd_spi_bridge.c>

SPI Bridge Initialize.

Parameters

spbr	Pointer to SPI bridge structure to initialize
spi	SPI handle to use for bridge

Return values

None

{

    /* Reset the UART device structure */
    memset(spbr, 0, sizeof(struct sd_spbr));
    
    spbr->spi = spi;

    /* Prepare the peripheral to receive */
    /* 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 */

    spbr->state = SD_SPBR_READ_DEVICE;
}

sd_spbr_irqhandler()

void sd_spbr_irqhandler

(

struct sd_spbr *

spbr

)

#include <Src/sd_spi_bridge.c>

SPI Bridge Interrupt Handler Handle interrupt events on the SPI peripheral.

Parameters

spbr	Pointer to SPI bridge structure

Return values

None

{
    SPI_HandleTypeDef *spi = spbr->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_spbr_rx_isr(spbr);
        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;
        return;
    }
}

sd_spbr_rx_isr()

static void sd_spbr_rx_isr ( struct sd_spbr *  spbr )

static

#include <Src/sd_spi_bridge.c>

SPI Bridge Receive Interrupt Routine.

Parameters

spbr	Pointer to SPI bridge structure

Return values

None

{
    uint8_t data = (uint8_t)(spbr->spi->Instance->DR);

    switch (spbr->state) {
    case SD_SPBR_READ_DEVICE:
    
        /* Find the device from the table */
        spbr->curr_dev = sd_spbr_find_device(spbr_dev_tab, data & SD_SPBR_DEV_MASK);
        if (spbr->curr_dev == NULL)
            return;
            
        /* Run callback for device, if one exists */
        if (spbr->curr_dev->dev_start != NULL)
            spbr->curr_dev->dev_start(&data);
            
        /* Set the device ID in the transmit buffer */
        HAL_SPI_Transmit_IT(spbr->spi, &data, 1);
        
        spbr->state = SD_SPBR_READ_CMD;
        break;
    
    case SD_SPBR_READ_CMD:
    
        spbr->curr_dev->curr_cmd = sd_spbr_find_cmd(spbr->curr_dev->cmds, 
                                (data & SD_SPBR_CMD_MASK));
                                
        if (spbr->curr_dev->curr_cmd == NULL) {
            /* A matching command from the device list was not found
             * This is an exception that needs to be handled
             */
            spbr->state = SD_SPBR_READ_DEVICE;
            return;
        }
        
        if (spbr->curr_dev->curr_cmd != NULL)
            spbr->curr_dev->curr_cmd->start(&data);
            
        /* Set the device ID in the transmit buffer */
        HAL_SPI_Transmit_IT(spbr->spi, &data, 1);
        
        spbr->state = SD_SPBR_IN_PROCESS;
    
        break;
        
    case SD_SPBR_IN_PROCESS:
    
    
        break;
    }
}

Variable Documentation

spbr_dev_tab

struct sd_spbr_dev spbr_dev_tab[]

static

#include <Src/sd_spi_bridge.c>

Initial value:

= {
    { SD_SPBR_I2C_DEV, NULL, NULL },
    SD_SPBR_NULL_DEV
}