fsl_flexio_i2s.h

/*
 * Copyright (c) 2015, Freescale Semiconductor, Inc.
 * Copyright 2016-2020 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef _FSL_FLEXIO_I2S_H_
#define _FSL_FLEXIO_I2S_H_
 
#include "fsl_common.h"
#include "fsl_flexio.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_FLEXIO_I2S_DRIVER_VERSION (MAKE_VERSION(2, 2, 0))
#ifndef I2S_RETRY_TIMES
#define I2S_RETRY_TIMES 0U /* Define to zero means keep waiting until the flag is assert/deassert. */
#endif
 
enum
{
    kStatus_FLEXIO_I2S_Idle      = MAKE_STATUS(kStatusGroup_FLEXIO_I2S, 0), 
    kStatus_FLEXIO_I2S_TxBusy    = MAKE_STATUS(kStatusGroup_FLEXIO_I2S, 1), 
    kStatus_FLEXIO_I2S_RxBusy    = MAKE_STATUS(kStatusGroup_FLEXIO_I2S, 2), 
    kStatus_FLEXIO_I2S_Error     = MAKE_STATUS(kStatusGroup_FLEXIO_I2S, 3), 
    kStatus_FLEXIO_I2S_QueueFull = MAKE_STATUS(kStatusGroup_FLEXIO_I2S, 4), 
    kStatus_FLEXIO_I2S_Timeout =
        MAKE_STATUS(kStatusGroup_FLEXIO_I2S, 5), 
};
 
typedef struct _flexio_i2s_type
{
    FLEXIO_Type *flexioBase; 
    uint8_t txPinIndex;      
    uint8_t rxPinIndex;      
    uint8_t bclkPinIndex;    
    uint8_t fsPinIndex;      
    uint8_t txShifterIndex;  
    uint8_t rxShifterIndex;  
    uint8_t bclkTimerIndex;  
    uint8_t fsTimerIndex;    
} FLEXIO_I2S_Type;
 
typedef enum _flexio_i2s_master_slave
{
    kFLEXIO_I2S_Master = 0x0U, 
    kFLEXIO_I2S_Slave  = 0x1U  
} flexio_i2s_master_slave_t;
 
enum
{
    kFLEXIO_I2S_TxDataRegEmptyInterruptEnable = 0x1U, 
    kFLEXIO_I2S_RxDataRegFullInterruptEnable  = 0x2U, 
};
 
enum
{
    kFLEXIO_I2S_TxDataRegEmptyFlag = 0x1U, 
    kFLEXIO_I2S_RxDataRegFullFlag  = 0x2U, 
};
 
typedef struct _flexio_i2s_config
{
    bool enableI2S;                                  
    flexio_i2s_master_slave_t masterSlave;           
    flexio_pin_polarity_t txPinPolarity;             
    flexio_pin_polarity_t rxPinPolarity;             
    flexio_pin_polarity_t bclkPinPolarity;           
    flexio_pin_polarity_t fsPinPolarity;             
    flexio_shifter_timer_polarity_t txTimerPolarity; 
    flexio_shifter_timer_polarity_t rxTimerPolarity; 
} flexio_i2s_config_t;
 
typedef struct _flexio_i2s_format
{
    uint8_t bitWidth;       
    uint32_t sampleRate_Hz; 
} flexio_i2s_format_t;
 
#define FLEXIO_I2S_XFER_QUEUE_SIZE (4U)
 
typedef enum _flexio_i2s_sample_rate
{
    kFLEXIO_I2S_SampleRate8KHz    = 8000U,  
    kFLEXIO_I2S_SampleRate11025Hz = 11025U, 
    kFLEXIO_I2S_SampleRate12KHz   = 12000U, 
    kFLEXIO_I2S_SampleRate16KHz   = 16000U, 
    kFLEXIO_I2S_SampleRate22050Hz = 22050U, 
    kFLEXIO_I2S_SampleRate24KHz   = 24000U, 
    kFLEXIO_I2S_SampleRate32KHz   = 32000U, 
    kFLEXIO_I2S_SampleRate44100Hz = 44100U, 
    kFLEXIO_I2S_SampleRate48KHz   = 48000U, 
    kFLEXIO_I2S_SampleRate96KHz   = 96000U  
} flexio_i2s_sample_rate_t;
 
typedef enum _flexio_i2s_word_width
{
    kFLEXIO_I2S_WordWidth8bits  = 8U,  
    kFLEXIO_I2S_WordWidth16bits = 16U, 
    kFLEXIO_I2S_WordWidth24bits = 24U, 
    kFLEXIO_I2S_WordWidth32bits = 32U  
} flexio_i2s_word_width_t;
 
typedef struct _flexio_i2s_transfer
{
    uint8_t *data;   
    size_t dataSize; 
} flexio_i2s_transfer_t;
 
typedef struct _flexio_i2s_handle flexio_i2s_handle_t;
 
typedef void (*flexio_i2s_callback_t)(FLEXIO_I2S_Type *base,
                                      flexio_i2s_handle_t *handle,
                                      status_t status,
                                      void *userData);
 
struct _flexio_i2s_handle
{
    uint32_t state;                                          
    flexio_i2s_callback_t callback;                          
    void *userData;                                          
    uint8_t bitWidth;                                        
    flexio_i2s_transfer_t queue[FLEXIO_I2S_XFER_QUEUE_SIZE]; 
    size_t transferSize[FLEXIO_I2S_XFER_QUEUE_SIZE];         
    volatile uint8_t queueUser;                              
    volatile uint8_t queueDriver;                            
};
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif /*_cplusplus*/
 
void FLEXIO_I2S_Init(FLEXIO_I2S_Type *base, const flexio_i2s_config_t *config);
 
void FLEXIO_I2S_GetDefaultConfig(flexio_i2s_config_t *config);
 
void FLEXIO_I2S_Deinit(FLEXIO_I2S_Type *base);
 
static inline void FLEXIO_I2S_Enable(FLEXIO_I2S_Type *base, bool enable)
{
    if (enable)
    {
        base->flexioBase->CTRL |= FLEXIO_CTRL_FLEXEN_MASK;
    }
}
 
uint32_t FLEXIO_I2S_GetStatusFlags(FLEXIO_I2S_Type *base);
 
void FLEXIO_I2S_EnableInterrupts(FLEXIO_I2S_Type *base, uint32_t mask);
 
void FLEXIO_I2S_DisableInterrupts(FLEXIO_I2S_Type *base, uint32_t mask);
 
static inline void FLEXIO_I2S_TxEnableDMA(FLEXIO_I2S_Type *base, bool enable)
{
    FLEXIO_EnableShifterStatusDMA(base->flexioBase, 1UL << base->txShifterIndex, enable);
}
 
static inline void FLEXIO_I2S_RxEnableDMA(FLEXIO_I2S_Type *base, bool enable)
{
    FLEXIO_EnableShifterStatusDMA(base->flexioBase, 1UL << base->rxShifterIndex, enable);
}
 
static inline uint32_t FLEXIO_I2S_TxGetDataRegisterAddress(FLEXIO_I2S_Type *base)
{
    return FLEXIO_GetShifterBufferAddress(base->flexioBase, kFLEXIO_ShifterBufferBitSwapped, base->txShifterIndex);
}
 
static inline uint32_t FLEXIO_I2S_RxGetDataRegisterAddress(FLEXIO_I2S_Type *base)
{
    return FLEXIO_GetShifterBufferAddress(base->flexioBase, kFLEXIO_ShifterBufferBitSwapped, base->rxShifterIndex);
}
 
void FLEXIO_I2S_MasterSetFormat(FLEXIO_I2S_Type *base, flexio_i2s_format_t *format, uint32_t srcClock_Hz);
 
void FLEXIO_I2S_SlaveSetFormat(FLEXIO_I2S_Type *base, flexio_i2s_format_t *format);
 
status_t FLEXIO_I2S_WriteBlocking(FLEXIO_I2S_Type *base, uint8_t bitWidth, uint8_t *txData, size_t size);
 
static inline void FLEXIO_I2S_WriteData(FLEXIO_I2S_Type *base, uint8_t bitWidth, uint32_t data)
{
    base->flexioBase->SHIFTBUFBIS[base->txShifterIndex] = (data << (32U - bitWidth));
}
 
status_t FLEXIO_I2S_ReadBlocking(FLEXIO_I2S_Type *base, uint8_t bitWidth, uint8_t *rxData, size_t size);
 
static inline uint32_t FLEXIO_I2S_ReadData(FLEXIO_I2S_Type *base)
{
    return base->flexioBase->SHIFTBUFBIS[base->rxShifterIndex];
}
 
void FLEXIO_I2S_TransferTxCreateHandle(FLEXIO_I2S_Type *base,
                                       flexio_i2s_handle_t *handle,
                                       flexio_i2s_callback_t callback,
                                       void *userData);
 
void FLEXIO_I2S_TransferSetFormat(FLEXIO_I2S_Type *base,
                                  flexio_i2s_handle_t *handle,
                                  flexio_i2s_format_t *format,
                                  uint32_t srcClock_Hz);
 
void FLEXIO_I2S_TransferRxCreateHandle(FLEXIO_I2S_Type *base,
                                       flexio_i2s_handle_t *handle,
                                       flexio_i2s_callback_t callback,
                                       void *userData);
 
status_t FLEXIO_I2S_TransferSendNonBlocking(FLEXIO_I2S_Type *base,
                                            flexio_i2s_handle_t *handle,
                                            flexio_i2s_transfer_t *xfer);
 
status_t FLEXIO_I2S_TransferReceiveNonBlocking(FLEXIO_I2S_Type *base,
                                               flexio_i2s_handle_t *handle,
                                               flexio_i2s_transfer_t *xfer);
 
void FLEXIO_I2S_TransferAbortSend(FLEXIO_I2S_Type *base, flexio_i2s_handle_t *handle);
 
void FLEXIO_I2S_TransferAbortReceive(FLEXIO_I2S_Type *base, flexio_i2s_handle_t *handle);
 
status_t FLEXIO_I2S_TransferGetSendCount(FLEXIO_I2S_Type *base, flexio_i2s_handle_t *handle, size_t *count);
 
status_t FLEXIO_I2S_TransferGetReceiveCount(FLEXIO_I2S_Type *base, flexio_i2s_handle_t *handle, size_t *count);
 
void FLEXIO_I2S_TransferTxHandleIRQ(void *i2sBase, void *i2sHandle);
 
void FLEXIO_I2S_TransferRxHandleIRQ(void *i2sBase, void *i2sHandle);
 
#if defined(__cplusplus)
}
#endif /*_cplusplus*/
 
#endif /* _FSL_FLEXIO_I2S_H_ */