TivaSPI.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_TI_TIVASPI_HXX_
#define _FREERTOS_DRIVERS_TI_TIVASPI_HXX_
 
 
#include "SPI.hxx"
#include "driverlib/ssi.h"
#include "inc/hw_ssi.h"
#include "inc/hw_types.h"
#include "driverlib/udma.h"
 
class TivaSPI : public SPI
{
public:
    TivaSPI(const char *name, unsigned long base, uint32_t interrupt,
            ChipSelectMethod cs_assert, ChipSelectMethod cs_deassert,
            OSMutex *bus_lock = nullptr,
            size_t dma_threshold = DEFAULT_DMA_THRESHOLD_BYTES,
            uint32_t dma_channel_index_tx = UDMA_CH11_SSI0TX,
            uint32_t dma_channel_index_rx = UDMA_CH10_SSI0RX);
    
    ~TivaSPI();
 
    void interrupt_handler();
 
    OSMutex *get_lock()
    {
        return &lock_;
    }
    
private:
    static constexpr size_t DEFAULT_DMA_THRESHOLD_BYTES = 0;
 
    static constexpr size_t MAX_DMA_TRANSFER_AMOUNT = 1024;
 
    static constexpr uint32_t dmaRxConfig_[] =
    {
        UDMA_SIZE_8  | UDMA_SRC_INC_NONE | UDMA_DST_INC_8  | UDMA_ARB_1,
        UDMA_SIZE_16 | UDMA_SRC_INC_NONE | UDMA_DST_INC_16 | UDMA_ARB_1,
    };
 
    static constexpr uint32_t dmaTxConfig_[] =
    {
        UDMA_SIZE_8  | UDMA_SRC_INC_8  | UDMA_DST_INC_NONE | UDMA_ARB_1,
        UDMA_SIZE_16 | UDMA_SRC_INC_16 | UDMA_DST_INC_NONE | UDMA_ARB_1,
    };
 
    static constexpr uint32_t dmaNullConfig_[] =
    {
        UDMA_SIZE_8  | UDMA_SRC_INC_NONE | UDMA_DST_INC_NONE | UDMA_ARB_1,
        UDMA_SIZE_16 | UDMA_SRC_INC_NONE | UDMA_DST_INC_NONE | UDMA_ARB_1,
    };
    
    void enable() override;
 
    void disable() override;
 
    int update_configuration() override;
 
    __attribute__((optimize("-O3")))
    int transfer(struct spi_ioc_transfer *msg) override
    {
        return transfer_polled(msg);
#if 0
        if (LIKELY(msg->len < dmaThreshold_))
        {
            return transfer_polled(msg);
        }
        else
        {
            /* use DMA */
            config_dma(msg);
        }
 
        return msg->len;
#endif        
    }
    
    template<typename T>
    __attribute__((optimize("-O3")))
    int transfer_polled(struct spi_ioc_transfer *msg)
    {
        T dummy = 0;
 
        /* we are assuming that at least one byte will be transferred, and
         * we want to start tranfering data as soon as possible
         */
        data_put(msg->tx_buf ? *((T*)msg->tx_buf) : 0xFFFFFFFF);
 
        T *tx_buf = msg->tx_buf ? ((T*)msg->tx_buf) + 1 : &dummy;
        T *rx_buf = (T*)msg->rx_buf;
 
        /* note that we already have transmitted one SPI word above, hence the
         * subtract one from the tx_len
         */
        uint32_t rx_len = msg->len / sizeof(T);
        uint32_t tx_len = rx_len - 1;
 
        uint16_t data;
 
        do
        {
            /* fill TX FIFO but make sure we don't fill it to overflow */
            if (tx_len && ((rx_len - tx_len) < 8))
            {
                if (data_put_non_blocking(*tx_buf) != 0)
                {
                    if (msg->tx_buf)
                    {
                        ++tx_buf;
                    }
                    --tx_len;
                }
            }
 
            /* empty RX FIFO */
            if (rx_len)
            {
                if (data_get_non_blocking(&data) != 0)
                {
                    if (msg->rx_buf)
                    {
                        *rx_buf++ = data;
                    }
                    --rx_len;
                }
            }
        }
        while (tx_len || rx_len);
 
        return msg->len;
    }
 
    __attribute__((optimize("-O3")))
    int transfer_polled(struct spi_ioc_transfer *msg) override
    {
        /* set instance specific configuration */
        set_configuration();
 
        switch (bitsPerWord)
        {
            default:
            case 8:
                return transfer_polled<uint8_t>(msg);
            case 16:
                return transfer_polled<uint16_t>(msg);
            case 32:
                DIE("32-bit transers are not supported on this MCU.");
        }
    }
 
    void config_dma(struct spi_ioc_transfer *msg);
 
    __attribute__((optimize("-O3")))
    long data_get_non_blocking(uint16_t *data)
    {
        if(HWREG(base_ + SSI_O_SR) & SSI_SR_RNE)
        {
            *data = HWREG(base_ + SSI_O_DR);
            return 1;
        }
 
        return 0;
    }
 
    __attribute__((optimize("-O3")))
    long data_put_non_blocking(uint16_t data)
    {
        if(HWREG(base_ + SSI_O_SR) & SSI_SR_TNF)
        {
            HWREG(base_ + SSI_O_DR) = data;
            return 1;
        }
 
        return 0;
    }
 
    void data_put(uint16_t data)
    {
        while((HWREG(base_ + SSI_O_SR) & SSI_SR_TNF) == 0);
        HWREG(base_ + SSI_O_DR) = data;
    }
 
    void set_configuration()
    {
        // Disable port first for reconfiguration.
        HWREG(base_ + SSI_O_CR1) &= ~SSI_CR1_SSE;
        
        HWREG(base_ + SSI_O_CR0) = spiCr0_;
        HWREG(base_ + SSI_O_CPSR) = spiPrescaler_;
        HWREG(base_ + SSI_O_CR1) = spiCr1_;
    }
 
    OSSem *sem_; 
    unsigned long base_; 
    unsigned long interrupt_; 
    size_t dmaThreshold_; 
    uint32_t dmaChannelIndexTx_; 
    uint32_t dmaChannelIndexRx_; 
    uint16_t spiCr0_;  
    uint16_t spiCr1_;  
    uint16_t spiPrescaler_;  
 
    DISALLOW_COPY_AND_ASSIGN(TivaSPI);
};
 
 
#endif // _FREERTOS_DRIVERS_TI_TIVASPI_HXX_