quadspi.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef  _DMA_QUADSPI_H_INC
#define  _DMA_QUADSPI_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_QUADSPI     1
 
 
#define DEFAULT_QUADSPI_MODULE 0   
#define QUADSPI_MODULE_COUNT   1   
class SPI_QSPI : public SPI_SPI
{
protected:
    static  SPI_QSPI *lastQuadSPICtxs[QUADSPI_MODULE_COUNT];
    static  spiDriverStruct QuadSPIDriverCtx[QUADSPI_MODULE_COUNT];
 
private:
    uint32_t    m_regSCR;
 
    virtual void ReadyHW() override;
    virtual spiDriverStruct *getCtx() override { return QuadSPIDriverCtx + m_moduleNum; }
    inline Qspi   * quadSpi() { return QSPI + m_moduleNum; }
 
public:
 
#ifdef __DEBUG_QUADSPI
    virtual void    dumpRegs() override;
#endif
 
 
    SPI_QSPI( uint8_t QuadSPIModule = DEFAULT_QUADSPI_MODULE);
 
    SPI_QSPI( uint8_t QuadSPIModule, 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; }
    // virtual 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 m_busSpeed The actual SPI module baud rate
     */
    // inline uint32_t GetActualBaudrate() { return m_busSpeed; }
 
    virtual inline bool SetCS( uint8_t CS ) override
    {
        OSLockObj lock;
        return true;
    }
 
    // The ISR used by the QuadSPI driver. Internal use only (qspi.cpp).
    friend void QuadSPI_DMA_Isr(XdmaCh_t *dma, int module);
};
 
#endif   /* ----- #ifndef _DMA_QUADSPI_H_INC  ----- */