fsl_spdif.h

/*
 * Copyright (c) 2016, Freescale Semiconductor, Inc.
 * Copyright 2017-2020 NXP
 * All rights reserved.
 *
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_SPDIF_H_
#define _FSL_SPDIF_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_SPDIF_DRIVER_VERSION (MAKE_VERSION(2, 0, 6)) 
 
enum
{
    kStatus_SPDIF_RxDPLLLocked     = MAKE_STATUS(kStatusGroup_SPDIF, 0), 
    kStatus_SPDIF_TxFIFOError      = MAKE_STATUS(kStatusGroup_SPDIF, 1), 
    kStatus_SPDIF_TxFIFOResync     = MAKE_STATUS(kStatusGroup_SPDIF, 2), 
    kStatus_SPDIF_RxCnew           = MAKE_STATUS(kStatusGroup_SPDIF, 3), 
    kStatus_SPDIF_ValidatyNoGood   = MAKE_STATUS(kStatusGroup_SPDIF, 4), 
    kStatus_SPDIF_RxIllegalSymbol  = MAKE_STATUS(kStatusGroup_SPDIF, 5), 
    kStatus_SPDIF_RxParityBitError = MAKE_STATUS(kStatusGroup_SPDIF, 6), 
    kStatus_SPDIF_UChannelOverrun  = MAKE_STATUS(kStatusGroup_SPDIF, 7), 
    kStatus_SPDIF_QChannelOverrun  = MAKE_STATUS(kStatusGroup_SPDIF, 8), 
    kStatus_SPDIF_UQChannelSync    = MAKE_STATUS(kStatusGroup_SPDIF, 9), 
    kStatus_SPDIF_UQChannelFrameError = MAKE_STATUS(kStatusGroup_SPDIF, 10), 
    kStatus_SPDIF_RxFIFOError         = MAKE_STATUS(kStatusGroup_SPDIF, 11), 
    kStatus_SPDIF_RxFIFOResync = MAKE_STATUS(kStatusGroup_SPDIF, 12), 
    kStatus_SPDIF_LockLoss     = MAKE_STATUS(kStatusGroup_SPDIF, 13), 
    kStatus_SPDIF_TxIdle       = MAKE_STATUS(kStatusGroup_SPDIF, 14), 
    kStatus_SPDIF_RxIdle       = MAKE_STATUS(kStatusGroup_SPDIF, 15), 
    kStatus_SPDIF_QueueFull    = MAKE_STATUS(kStatusGroup_SPDIF, 16)  
};
 
typedef enum _spdif_rxfull_select
{
    kSPDIF_RxFull1Sample = 0x0u, 
    kSPDIF_RxFull4Samples,       
    kSPDIF_RxFull8Samples,       
    kSPDIF_RxFull16Samples,      
} spdif_rxfull_select_t;
 
typedef enum _spdif_txempty_select
{
    kSPDIF_TxEmpty0Sample = 0x0u, 
    kSPDIF_TxEmpty4Samples,       
    kSPDIF_TxEmpty8Samples,       
    kSPDIF_TxEmpty12Samples,      
} spdif_txempty_select_t;
 
typedef enum _spdif_uchannel_source
{
    kSPDIF_NoUChannel     = 0x0U, 
    kSPDIF_UChannelFromRx = 0x1U, 
    kSPDIF_UChannelFromTx = 0x3U, 
} spdif_uchannel_source_t;
 
typedef enum _spdif_gain_select
{
    kSPDIF_GAIN_24 = 0x0U, 
    kSPDIF_GAIN_16,        
    kSPDIF_GAIN_12,        
    kSPDIF_GAIN_8,         
    kSPDIF_GAIN_6,         
    kSPDIF_GAIN_4,         
    kSPDIF_GAIN_3,         
} spdif_gain_select_t;
 
typedef enum _spdif_tx_source
{
    kSPDIF_txFromReceiver = 0x1U, 
    kSPDIF_txNormal       = 0x5U, 
} spdif_tx_source_t;
 
typedef enum _spdif_validity_config
{
    kSPDIF_validityFlagAlwaysSet = 0x0U, 
    kSPDIF_validityFlagAlwaysClear,      
} spdif_validity_config_t;
 
enum
{
    kSPDIF_RxDPLLLocked                   = SPDIF_SIE_LOCK_MASK,        
    kSPDIF_TxFIFOError                    = SPDIF_SIE_TXUNOV_MASK,      
    kSPDIF_TxFIFOResync                   = SPDIF_SIE_TXRESYN_MASK,     
    kSPDIF_RxControlChannelChange         = SPDIF_SIE_CNEW_MASK,        
    kSPDIF_ValidityFlagNoGood             = SPDIF_SIE_VALNOGOOD_MASK,   
    kSPDIF_RxIllegalSymbol                = SPDIF_SIE_SYMERR_MASK,      
    kSPDIF_RxParityBitError               = SPDIF_SIE_BITERR_MASK,      
    kSPDIF_UChannelReceiveRegisterFull    = SPDIF_SIE_URXFUL_MASK,      
    kSPDIF_UChannelReceiveRegisterOverrun = SPDIF_SIE_URXOV_MASK,       
    kSPDIF_QChannelReceiveRegisterFull    = SPDIF_SIE_QRXFUL_MASK,      
    kSPDIF_QChannelReceiveRegisterOverrun = SPDIF_SIE_QRXOV_MASK,       
    kSPDIF_UQChannelSync                  = SPDIF_SIE_UQSYNC_MASK,      
    kSPDIF_UQChannelFrameError            = SPDIF_SIE_UQERR_MASK,       
    kSPDIF_RxFIFOError                    = SPDIF_SIE_RXFIFOUNOV_MASK,  
    kSPDIF_RxFIFOResync                   = SPDIF_SIE_RXFIFORESYN_MASK, 
    kSPDIF_LockLoss                       = SPDIF_SIE_LOCKLOSS_MASK,    
    kSPDIF_TxFIFOEmpty                    = SPDIF_SIE_TXEM_MASK,        
    kSPDIF_RxFIFOFull                     = SPDIF_SIE_RXFIFOFUL_MASK,   
    kSPDIF_AllInterrupt                   = kSPDIF_RxDPLLLocked | kSPDIF_TxFIFOError | kSPDIF_TxFIFOResync |
                          kSPDIF_RxControlChannelChange | kSPDIF_ValidityFlagNoGood | kSPDIF_RxIllegalSymbol |
                          kSPDIF_RxParityBitError | kSPDIF_UChannelReceiveRegisterFull |
                          kSPDIF_UChannelReceiveRegisterOverrun | kSPDIF_QChannelReceiveRegisterFull |
                          kSPDIF_QChannelReceiveRegisterOverrun | kSPDIF_UQChannelSync | kSPDIF_UQChannelFrameError |
                          kSPDIF_RxFIFOError | kSPDIF_RxFIFOResync | kSPDIF_LockLoss | kSPDIF_TxFIFOEmpty |
                          kSPDIF_RxFIFOFull, 
};
 
enum
{
    kSPDIF_RxDMAEnable = SPDIF_SCR_DMA_RX_EN_MASK, 
    kSPDIF_TxDMAEnable = SPDIF_SCR_DMA_TX_EN_MASK, 
};
 
typedef struct _spdif_config
{
    bool isTxAutoSync;                      
    bool isRxAutoSync;                      
    uint8_t DPLLClkSource;                  
    uint8_t txClkSource;                    
    spdif_rxfull_select_t rxFullSelect;     
    spdif_txempty_select_t txFullSelect;    
    spdif_uchannel_source_t uChannelSrc;    
    spdif_tx_source_t txSource;             
    spdif_validity_config_t validityConfig; 
    spdif_gain_select_t gain;               
} spdif_config_t;
 
#define SPDIF_XFER_QUEUE_SIZE (4U)
 
typedef struct _spdif_transfer
{
    uint8_t *data;   
    uint8_t *qdata;  
    uint8_t *udata;  
    size_t dataSize; 
} spdif_transfer_t;
 
typedef struct _spdif_handle spdif_handle_t;
 
typedef void (*spdif_transfer_callback_t)(SPDIF_Type *base, spdif_handle_t *handle, status_t status, void *userData);
 
struct _spdif_handle
{
    uint32_t state;                                     
    spdif_transfer_callback_t callback;                 
    void *userData;                                     
    spdif_transfer_t spdifQueue[SPDIF_XFER_QUEUE_SIZE]; 
    size_t transferSize[SPDIF_XFER_QUEUE_SIZE];         
    volatile uint8_t queueUser;                         
    volatile uint8_t queueDriver;                       
    uint8_t watermark;                                  
};
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif /*_cplusplus*/
 
void SPDIF_Init(SPDIF_Type *base, const spdif_config_t *config);
 
void SPDIF_GetDefaultConfig(spdif_config_t *config);
 
void SPDIF_Deinit(SPDIF_Type *base);
 
uint32_t SPDIF_GetInstance(SPDIF_Type *base);
 
static inline void SPDIF_TxFIFOReset(SPDIF_Type *base)
{
    base->SCR |= SPDIF_SCR_RXFIFO_RST_MASK;
}
 
static inline void SPDIF_RxFIFOReset(SPDIF_Type *base)
{
    base->SCR |= SPDIF_SCR_RXFIFO_RST_MASK;
}
 
void SPDIF_TxEnable(SPDIF_Type *base, bool enable);
 
static inline void SPDIF_RxEnable(SPDIF_Type *base, bool enable)
{
    if (enable)
    {
        /* Open Rx FIFO */
        base->SCR &= ~(SPDIF_SCR_RXFIFO_CTRL_MASK | SPDIF_SCR_RXFIFO_OFF_ON_MASK);
    }
    else
    {
        base->SCR |= SPDIF_SCR_RXFIFO_OFF_ON_MASK;
    }
}
 
static inline uint32_t SPDIF_GetStatusFlag(SPDIF_Type *base)
{
    return base->SIS;
}
 
static inline void SPDIF_ClearStatusFlags(SPDIF_Type *base, uint32_t mask)
{
    base->SIC = mask;
}
 
static inline void SPDIF_EnableInterrupts(SPDIF_Type *base, uint32_t mask)
{
    base->SIE |= mask;
}
 
static inline void SPDIF_DisableInterrupts(SPDIF_Type *base, uint32_t mask)
{
    base->SIE &= ~mask;
}
 
static inline void SPDIF_EnableDMA(SPDIF_Type *base, uint32_t mask, bool enable)
{
    if (enable)
    {
        base->SCR |= mask;
    }
    else
    {
        base->SCR &= ~mask;
    }
}
 
static inline uint32_t SPDIF_TxGetLeftDataRegisterAddress(SPDIF_Type *base)
{
    return (uint32_t)(&(base->STL));
}
 
static inline uint32_t SPDIF_TxGetRightDataRegisterAddress(SPDIF_Type *base)
{
    return (uint32_t)(&(base->STR));
}
 
static inline uint32_t SPDIF_RxGetLeftDataRegisterAddress(SPDIF_Type *base)
{
    return (uint32_t)(&(base->SRL));
}
 
static inline uint32_t SPDIF_RxGetRightDataRegisterAddress(SPDIF_Type *base)
{
    return (uint32_t)(&(base->SRR));
}
 
void SPDIF_TxSetSampleRate(SPDIF_Type *base, uint32_t sampleRate_Hz, uint32_t sourceClockFreq_Hz);
 
uint32_t SPDIF_GetRxSampleRate(SPDIF_Type *base, uint32_t clockSourceFreq_Hz);
 
void SPDIF_WriteBlocking(SPDIF_Type *base, uint8_t *buffer, uint32_t size);
 
static inline void SPDIF_WriteLeftData(SPDIF_Type *base, uint32_t data)
{
    base->STL = data;
}
 
static inline void SPDIF_WriteRightData(SPDIF_Type *base, uint32_t data)
{
    base->STR = data;
}
 
static inline void SPDIF_WriteChannelStatusHigh(SPDIF_Type *base, uint32_t data)
{
    base->STCSCH = data;
}
 
static inline void SPDIF_WriteChannelStatusLow(SPDIF_Type *base, uint32_t data)
{
    base->STCSCL = data;
}
 
void SPDIF_ReadBlocking(SPDIF_Type *base, uint8_t *buffer, uint32_t size);
 
static inline uint32_t SPDIF_ReadLeftData(SPDIF_Type *base)
{
    return base->SRL;
}
 
static inline uint32_t SPDIF_ReadRightData(SPDIF_Type *base)
{
    return base->SRR;
}
 
static inline uint32_t SPDIF_ReadChannelStatusHigh(SPDIF_Type *base)
{
    return base->SRCSH;
}
 
static inline uint32_t SPDIF_ReadChannelStatusLow(SPDIF_Type *base)
{
    return base->SRCSL;
}
 
static inline uint32_t SPDIF_ReadQChannel(SPDIF_Type *base)
{
    return base->SRQ;
}
 
static inline uint32_t SPDIF_ReadUChannel(SPDIF_Type *base)
{
    return base->SRU;
}
 
void SPDIF_TransferTxCreateHandle(SPDIF_Type *base,
                                  spdif_handle_t *handle,
                                  spdif_transfer_callback_t callback,
                                  void *userData);
 
void SPDIF_TransferRxCreateHandle(SPDIF_Type *base,
                                  spdif_handle_t *handle,
                                  spdif_transfer_callback_t callback,
                                  void *userData);
 
status_t SPDIF_TransferSendNonBlocking(SPDIF_Type *base, spdif_handle_t *handle, spdif_transfer_t *xfer);
 
status_t SPDIF_TransferReceiveNonBlocking(SPDIF_Type *base, spdif_handle_t *handle, spdif_transfer_t *xfer);
 
status_t SPDIF_TransferGetSendCount(SPDIF_Type *base, spdif_handle_t *handle, size_t *count);
 
status_t SPDIF_TransferGetReceiveCount(SPDIF_Type *base, spdif_handle_t *handle, size_t *count);
 
void SPDIF_TransferAbortSend(SPDIF_Type *base, spdif_handle_t *handle);
 
void SPDIF_TransferAbortReceive(SPDIF_Type *base, spdif_handle_t *handle);
 
void SPDIF_TransferTxHandleIRQ(SPDIF_Type *base, spdif_handle_t *handle);
 
void SPDIF_TransferRxHandleIRQ(SPDIF_Type *base, spdif_handle_t *handle);
 
#if defined(__cplusplus)
}
#endif /*_cplusplus*/
 
#endif /* _FSL_SPDIF_H_ */