usart.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef  _DMA_USART_SPI_H_INC
#define  _DMA_USART_SPI_H_INC
 
#include <nbrtos.h>
#include <basictypes.h>
#include <xdmac.h>
#include <dspi.h>
 
#ifndef __cplusplus
#error QuadSPI driver is a C++ only library
#endif
 
// #define __DEBUG_USART_SPI     1
 
 
#define DEFAULT_USART_SPI_MODULE 0   
#define USART_SPI_MODULE_COUNT   2   
class SPI_USART : public SPI_SPI
{
protected:
    static  SPI_USART *lastUSARTCtxs[USART_SPI_MODULE_COUNT];
    static  spiDriverStruct UsartSpiDriverCtx[USART_SPI_MODULE_COUNT];
 
private:
    uint32_t    m_regCR;
    uint32_t    m_regBRGR;          // Baud Rate Generator Register
 
    virtual void ReadyHW() override;
    virtual spiDriverStruct *getCtx() override { return UsartSpiDriverCtx + m_moduleNum; }
    inline Usart * usartSpi() { return USART0 + m_moduleNum; }
 
public:
 
#ifdef __DEBUG_QUADSPI
    virtual void    dumpRegs() override;
#endif
 
 
    SPI_USART( uint8_t USARTModule );
 
    SPI_USART( uint8_t USARTModule, uint32_t baudRateInBps,
            uint8_t transferSizeInBits = 8, uint8_t peripheralChipSelects = 0x00,
            uint8_t chipSelectPolarity = 0x0F, uint8_t clockPolarity = 0,
            uint8_t clockPhase = 1, BOOL doutHiz = TRUE,
            uint8_t csToClockDelay = 0, uint8_t delayAfterTransfer = 0 );
 
    virtual uint8_t Init( uint32_t baudRateInBps = 2000000,
            uint8_t transferSizeInBits = 8, uint8_t peripheralChipSelects = 0x00,
            uint8_t chipSelectPolarity = 0x0F, uint8_t clockPolarity = 0,
            uint8_t clockPhase = 1, BOOL doutHiz = TRUE,
            uint8_t csToClockDelay = 0, uint8_t delayAfterTransfer = 0 ) override;
 
    virtual uint32_t SetBusSpeed(uint32_t maxSpeed) override;
 
    virtual uint8_t Start( uint8_t *transmitBufferPtr, volatile uint8_t *receiveBufferPtr,
                uint32_t byteCount, int csReturnToInactive = DEASSERT_AFTER_LAST ) override;
 
    virtual inline uint8_t Tx( uint8_t *transmitBufferPtr, uint32_t byteCount,
                    int csReturnToInactive = DEASSERT_AFTER_LAST ) override
    { return Start(transmitBufferPtr, NULL, byteCount, csReturnToInactive); }
 
    inline uint8_t Rx( uint8_t *receiveBufferPtr, uint32_t byteCount,
                    int csReturnToInactive = DEASSERT_AFTER_LAST )
    { return Start(NULL, receiveBufferPtr, byteCount, csReturnToInactive); }
 
    // The SAME70 always uses DMA. These functions kept here for reference to other platforms
    //    bool EnableDMA(bool enableDMA = true);
    //    inline bool DisableDMA() { return EnableDMA(false); }
 
    /*
     * @brief Register a semaphore for the SPI module. 
     *
     * The SPI module will post to this semaphore when a transaction is complete
     *
     * @param finishedSem  Pointer to the semaphore 
     *
     * @return true if the registration was successful, false if a SPI transaction is in progress
     */
    // bool RegisterSem( OS_SEM *finishedSem );
 
    /*
     * @brief Clear a semaphore registration
     *
     * @return true if the clear was successful, false if a SPI transaction is in progress
     */
    // inline bool ClrSem() { return RegisterSem(NULL); }
 
    /*
     * @brief Obtain a pointer to the SPI finished semaphore
     *
     * @return A pointer to the semaphore
     */
    // inline OS_SEM * GetSem() { return m_finishedSem; }
 
    /*
     * @brief Function to check SPI status
     *
     * Called as a class method on a specific SPI object. For example: MySpi.Done()
     *
     * @return true if SPI is finished, false if active
     */
    // inline bool Done() { return !m_inProgress; }
 
    /*
     * @brief Returns the active baud rate
     *
     * The baud rate will be set to the value specified when the SPI module is initialized. 
     * If that value is not possible, the next lowest baud rate will be chosen. 
     *
     * @return The actual SPI module baud rate
     */
    // inline uint32_t GetActualBaudrate() { return m_busSpeed; }
 
    /*
     * @brief Set the chip select configuration for the SPI object's bus transactions
     *
     * @param CS    USART modules only have one option for chip select.
     *
     * @return true if successful, false if SPI is currently active
     */
    virtual inline bool SetCS( uint8_t CS ) override
    {
        OSLockObj lock;
        if (m_inProgress) { return false; }
 
        return true;
    }
 
    // The ISR used by the USART SPI driver. Internal use only (usart.cpp).
    friend void USART_DMA_Isr(XdmaCh_t *dma, int module);
};
 
#endif   /* ----- #ifndef _DMA_USART_SPI_H_INC  ----- */