sai.h

Go to the documentation of this file.

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
 
#include <predef.h>
#include <sim.h>
#include <nbrtos.h>
#include <edma.h>
 
#define SAI_HW_COUNT    3
 
#define SAI_TXBD_COUNT  4
 
#define SAI_RXBD_COUNT  4
 
 // end of sai_constants
 
typedef void (*SAI_BufferDoneFn_t)(void *buffer, int doneInvalid);
 
 // end of sai_callbacks
 
enum clkSrc_t
{
    CLK_SRC_MCK, 
    CLK_SRC_EXT, 
};
 
enum clkCh_t
{
    CLK_CH_CH, 
    CLK_CH_RK, 
    CLK_CH_TK, 
};
 
enum clkPol_t
{
    CLK_ACTIVE_HIGH, 
    CLK_ACTIVE_LOW,  
};
 
enum frameSyncCh_t
{
    SYNC_CH_CH,  
    SYNC_CH_RX,  
    SYNC_CH_TX,  
};
 
enum startCond_t
{
    START_CONTINUOUS,    
    START_SYNC_RX_TX,    
    START_FRAME_LOW,     
    START_FRAME_HIGH,    
    START_FRAME_FALLING, 
    START_FRAME_RISING,  
    START_FRAME_LEVEL,   
    START_FRAME_EDGE,    
    START_CMP_0          
};
 
enum clkGate_t
{
    CLK_GATE_CONTINUOUS, 
    CLK_GATE_FRAME_LOW,  
    CLK_GATE_FRAME_HIGH, 
};
 
enum frameEdge_t
{
    FRAME_SYNC_RISING,  
    FRAME_SYNC_FALLING  
};
 
enum clkOut_t
{
    CLK_OUT_INPUT,      
    CLK_OUT_CONTINUOUS, 
    CLK_OUT_TRANSFER    
};
 
enum frameSyncOut_t
{
    FRAME_SYNC_INPUT,    
    FRAME_SYNC_NEGATIVE, 
    FRAME_SYNC_POSITIVE, 
};
 
enum dataPacking_t
{
    BUFFER_WORD8,        
    BUFFER_WORD16_LEFT,  
    BUFFER_WORD16_RIGHT, 
    BUFFER_WORD32_LEFT,  
    BUFFER_WORD32_RIGHT, 
};
 
enum bitOrder_t
{
    LEAST_SIG_FIRST, 
    MOST_SIG_FIRST   
};
 
enum bufferDepletionBehavior_t
{
    DEPLETED_PAUSE,       
    DEPLETED_REPEAT_LAST, 
};
 
enum rxTxSync_t
{
    RXTX_ASYNC,   
    RXTX_SYNC_RX, 
    RXTX_SYNC_TX  
};
 
 // end of sai_enums
 
struct SAI_rxtx_cfg_t
{
    bool enable{false};
    
    uint8_t startDly{1};
    
    startCond_t startCond{START_FRAME_EDGE};
    
    clkGate_t clkGate{CLK_GATE_CONTINUOUS};
    
    clkOut_t clkOut{CLK_OUT_CONTINUOUS};
    
    clkSrc_t clkSrc{CLK_SRC_MCK};
    
    clkCh_t clkCh{CLK_CH_CH};
    
    clkPol_t clkPol{CLK_ACTIVE_HIGH};
 
    uint8_t syncLen{0};
    
    frameEdge_t syncEdge{FRAME_SYNC_FALLING};
    
    frameSyncOut_t syncOut{FRAME_SYNC_INPUT};
    
    frameSyncCh_t syncCh{SYNC_CH_CH};
    
    uint8_t wordsPerFrame{2};
    
    dataPacking_t dataPacking{BUFFER_WORD32_RIGHT};
    
    bool unifyDataStream{false};
    
    bitOrder_t bitOrder{MOST_SIG_FIRST};
    
    bool lineIdleState{1};
    
    uint8_t bitsPerWord{24};
    
    uint32_t wordMask{0};
 
    bufferDepletionBehavior_t depletionBehavior{DEPLETED_PAUSE};
};
 
struct SAI_cfg_t
{
    uint32_t txClkFreq{12288000};
    
    uint32_t rxClkFreq{12288000};
    
    rxTxSync_t rxTxSync{RXTX_ASYNC};
 
    I2S_Type *sai;
    
    SAI_rxtx_cfg_t rx;
    
    SAI_rxtx_cfg_t tx;
};
 
 // end of sai_structs
 
extern const SAI_cfg_t SAI_I2S_SLAVE_24_TXRX_RK;
 
extern const SAI_cfg_t SAI_I2S_SLAVE_24_TXRX_TK;
 
extern const SAI_cfg_t SAI_I2S_SLAVE_24_TXRX_TKRK;
 
extern const SAI_cfg_t SAI_I2S_SLAVE_16_TXRX_RK;
 
extern const SAI_cfg_t SAI_I2S_SLAVE_16_TXRX_TK;
 
extern const SAI_cfg_t SAI_I2S_SLAVE_16_TXRX_TKRK;
 
extern const SAI_cfg_t SAI_I2S_SLAVE_8_TXRX_RK;
 
extern const SAI_cfg_t SAI_I2S_SLAVE_8_TXRX_TK;
 
extern const SAI_cfg_t SAI_I2S_SLAVE_8_TXRX_TKRK;
 
 // end of I2S slave configs
 
extern const SAI_cfg_t SAI_LJUST_SLAVE_24_TXRX_RK;
 
extern const SAI_cfg_t SAI_LJUST_SLAVE_24_TXRX_TK;
 
extern const SAI_cfg_t SAI_LJUST_SLAVE_24_TXRX_TKRK;
 
extern const SAI_cfg_t SAI_LJUST_SLAVE_16_TXRX_RK;
 
extern const SAI_cfg_t SAI_LJUST_SLAVE_16_TXRX_TK;
 
extern const SAI_cfg_t SAI_LJUST_SLAVE_16_TXRX_TKRK;
 
extern const SAI_cfg_t SAI_LJUST_SLAVE_8_TXRX_RK;
 
extern const SAI_cfg_t SAI_LJUST_SLAVE_8_TXRX_TK;
 
extern const SAI_cfg_t SAI_LJUST_SLAVE_8_TXRX_TKRK;
 
 // end of left-justified configs
 // end of sai_presets
 
class SAICtx_t
{
public:
    enum ctxState_t
    {
        CTX_STATE_STOPPED, 
        CTX_STATE_INIT,    
        CTX_STATE_TX,      
        CTX_STATE_RX,      
        CTX_STATE_TXRX,    
    };
 
private:
    // Static members for managing all SAI instances
    static DmaTcd sDmaTcd[SAI_HW_COUNT][SAI_TXBD_COUNT + SAI_RXBD_COUNT];
    static SAICtx_t *sCtx[SAI_HW_COUNT];
    static int sDmaIsr(void *ctx, DmaCh *dmaCh, bool haveError);
    static void sIsr();
 
    // Hardware and DMA resources
    I2S_Type *sai;
    DmaCh *txDma;
    uint32_t txBDFlag;
    DmaCh *rxDma;
    uint32_t rxBDFlag;
 
    // Synchronization primitives
    OS_SEM txSem;
    OS_SEM rxSem;
    
    // User callbacks
    SAI_BufferDoneFn_t txBufDone;
    SAI_BufferDoneFn_t rxBufDone;
    
    // Statistics and status
    uint32_t txReadyCount;
    uint32_t rxReadyCount;
    uint32_t nTxIrq;
    uint32_t nTxErr;
    uint32_t nTxPost;
    uint32_t nTxCall;
    uint32_t nTxStart;
    uint32_t nTxAdd;
    uint32_t nRxIrq;
    uint32_t nRxErr;
    uint32_t nRxPost;
    uint32_t nRxCall;
    uint32_t nRxStart;
    uint32_t nRxAdd;
    uint8_t stickyTxErr;
    uint8_t stickyRxErr;
 
    ctxState_t state;
    
    // Internal methods
    void InitBDs();
    void initHw_Pins(const SAI_cfg_t &cfg);
    void initHw_SAI(const SAI_cfg_t &cfg);
    void initHw_DMA(const SAI_cfg_t &cfg);
    int validateClockSync(const SAI_cfg_t &cfg) const;
    int validateCfg(const SAI_cfg_t &cfg) const;
    int InitClocks(uint32_t *saiClk, uint32_t divRem);
    
    DmaTcd &getFirstTxBD() const;
    DmaTcd &getLastTxBD() const;
    DmaTcd &getNextTxBD() const;
    DmaTcd &getFirstRxBD() const;
    DmaTcd &getLastRxBD() const;
    DmaTcd &getNextRxBD() const;
    DmaTcd &getFirstBD(const DmaCh *dma) const;
    DmaTcd &getLastBD(const DmaCh *dma) const;
    DmaTcd &getNextBD(const DmaCh *dma) const;
    
    int queueBuffer(void *buffer, uint32_t bufferLen, bool waitIfNeeded, 
                    bool enableHalfNotify, DmaCh *dma);
    int getIdx() const;
    int DmaIsr(DmaCh *dma, bool haveError);
    void Isr();
 
public:
    int Init(const SAI_cfg_t &cfg);
 
    void Shutdown();
 
    inline int GetMaxTxBuffers() { return SAI_TXBD_COUNT; }
 
    inline int GetMaxRxBuffers() { return SAI_RXBD_COUNT; }
 
    int getCurrentConfig(SAI_cfg_t &cfg);
 
    inline ctxState_t getState() const { return state; }
 
    int TransmitBuffer(void *buffer, uint32_t bufferLen, bool waitIfNeeded, 
                       bool enableHalfNotify = false);
 
    int ReadyReceiveBuffer(void *buffer, uint32_t bufferLen, bool waitIfNeeded, 
                           bool enableHalfNotify = false);
 
    void RegisterTxBufferCB(SAI_BufferDoneFn_t cb);
 
    void RegisterRxBufferCB(SAI_BufferDoneFn_t cb);
 
    inline void clrStickyTxError() { stickyTxErr = 0; }
 
    inline void clrStickyRxError() { stickyRxErr = 0; }
 
    inline uint8_t getStickyTxError() { return stickyTxErr; }
 
    inline uint8_t getStickyRxError() { return stickyRxErr; }
 
    void dump();
};
 
 // end of sai_driver
 
extern SAICtx_t sai;
 
 
 // end of saiGroup