fsl_csi.h

/*
 * Copyright 2017-2021 NXP
 * All rights reserved.
 *
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_CSI_H_
#define _FSL_CSI_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_CSI_DRIVER_VERSION (MAKE_VERSION(2, 1, 5))
#define CSI_REG_CR1(base)       (base)->CR1
#define CSI_REG_CR2(base)       (base)->CR2
#define CSI_REG_CR3(base)       (base)->CR3
#define CSI_REG_CR18(base)      (base)->CR18
#define CSI_REG_SR(base)        (base)->SR
#define CSI_REG_DMASA_FB1(base) (base)->DMASA_FB1
#define CSI_REG_DMASA_FB2(base) (base)->DMASA_FB2
#define CSI_REG_IMAG_PARA(base) (base)->IMAG_PARA
#define CSI_REG_FBUF_PARA(base) (base)->FBUF_PARA
 
#ifndef CSI_DRIVER_QUEUE_SIZE
#define CSI_DRIVER_QUEUE_SIZE 4U
#endif
 
#ifndef CSI_DRIVER_FRAG_MODE
#define CSI_DRIVER_FRAG_MODE 0U
#endif
 
/*
 * There is one empty room in queue, used to distinguish whether the queue
 * is full or empty. When header equals tail, the queue is empty; when header
 * equals tail + 1, the queue is full.
 */
#define CSI_DRIVER_ACTUAL_QUEUE_SIZE (CSI_DRIVER_QUEUE_SIZE + 1U)
 
/*
 * The queue max size is 254, so that the queue element index could use `uint8_t`.
 */
#if (CSI_DRIVER_ACTUAL_QUEUE_SIZE > 254)
#error Required queue size is too large
#endif
 
/*
 * The interrupt enable bits are in registers CSICR1[16:31], CSICR3[0:7],
 * and CSICR18[2:9]. So merge them into an uint32_t value, place CSICR18 control
 * bits to [8:15].
 */
#define CSI_CR1_INT_EN_MASK  0xFFFF0000U
#define CSI_CR3_INT_EN_MASK  0x000000FFU
#define CSI_CR18_INT_EN_MASK 0x0000FF00U
 
#if ((~CSI_CR1_INT_EN_MASK) &                                                                                   \
     (CSI_CR1_EOF_INT_EN_MASK | CSI_CR1_COF_INT_EN_MASK | CSI_CR1_SF_OR_INTEN_MASK | CSI_CR1_RF_OR_INTEN_MASK | \
      CSI_CR1_SFF_DMA_DONE_INTEN_MASK | CSI_CR1_STATFF_INTEN_MASK | CSI_CR1_FB2_DMA_DONE_INTEN_MASK |           \
      CSI_CR1_FB1_DMA_DONE_INTEN_MASK | CSI_CR1_RXFF_INTEN_MASK | CSI_CR1_SOF_INTEN_MASK))
#error CSI_CR1_INT_EN_MASK could not cover all interrupt bits in CSICR1.
#endif
 
#if ((~CSI_CR3_INT_EN_MASK) & (CSI_CR3_ECC_INT_EN_MASK | CSI_CR3_HRESP_ERR_EN_MASK))
#error CSI_CR3_INT_EN_MASK could not cover all interrupt bits in CSICR3.
#endif
 
#if ((~CSI_CR18_INT_EN_MASK) &                                                                                   \
     ((CSI_CR18_FIELD0_DONE_IE_MASK | CSI_CR18_DMA_FIELD1_DONE_IE_MASK | CSI_CR18_BASEADDR_CHANGE_ERROR_IE_MASK) \
      << 6U))
#error CSI_CR18_INT_EN_MASK could not cover all interrupt bits in CSICR18.
#endif
 
enum
{
    kStatus_CSI_NoEmptyBuffer = MAKE_STATUS(kStatusGroup_CSI, 0), 
    kStatus_CSI_NoFullBuffer  = MAKE_STATUS(kStatusGroup_CSI, 1), 
    kStatus_CSI_QueueFull = MAKE_STATUS(kStatusGroup_CSI, 2), 
    kStatus_CSI_FrameDone = MAKE_STATUS(kStatusGroup_CSI, 3), 
};
 
typedef enum _csi_work_mode
{
    kCSI_GatedClockMode         = CSI_CR1_GCLK_MODE(1U), 
    kCSI_NonGatedClockMode      = 0U,                    
    kCSI_CCIR656ProgressiveMode = CSI_CR1_CCIR_EN(1U),   
} csi_work_mode_t;
 
typedef enum _csi_data_bus
{
    kCSI_DataBus8Bit,  
    kCSI_DataBus16Bit, 
    kCSI_DataBus24Bit, 
} csi_data_bus_t;
 
enum _csi_polarity_flags
{
    kCSI_HsyncActiveLow         = 0U,                     
    kCSI_HsyncActiveHigh        = CSI_CR1_HSYNC_POL_MASK, 
    kCSI_DataLatchOnRisingEdge  = CSI_CR1_REDGE_MASK,     
    kCSI_DataLatchOnFallingEdge = 0U,                     
    kCSI_VsyncActiveHigh        = 0U,                     
    kCSI_VsyncActiveLow         = CSI_CR1_SOF_POL_MASK,   
};
 
typedef struct _csi_config
{
    uint16_t width;           
    uint16_t height;          
    uint32_t polarityFlags;   
    uint8_t bytesPerPixel;    
    uint16_t linePitch_Bytes; 
    csi_work_mode_t workMode; 
    csi_data_bus_t dataBus;   
    bool useExtVsync;         
} csi_config_t;
 
typedef enum _csi_fifo
{
    kCSI_RxFifo   = (1U << 0U),  
    kCSI_StatFifo = (1U << 1U),  
    kCSI_AllFifo  = 0x01 | 0x02, 
} csi_fifo_t;
 
enum _csi_interrupt_enable
{
    kCSI_EndOfFrameInterruptEnable       = CSI_CR1_EOF_INT_EN_MASK,         
    kCSI_ChangeOfFieldInterruptEnable    = CSI_CR1_COF_INT_EN_MASK,         
    kCSI_StatFifoOverrunInterruptEnable  = CSI_CR1_SF_OR_INTEN_MASK,        
    kCSI_RxFifoOverrunInterruptEnable    = CSI_CR1_RF_OR_INTEN_MASK,        
    kCSI_StatFifoDmaDoneInterruptEnable  = CSI_CR1_SFF_DMA_DONE_INTEN_MASK, 
    kCSI_StatFifoFullInterruptEnable     = CSI_CR1_STATFF_INTEN_MASK,       
    kCSI_RxBuffer1DmaDoneInterruptEnable = CSI_CR1_FB2_DMA_DONE_INTEN_MASK, 
    kCSI_RxBuffer0DmaDoneInterruptEnable = CSI_CR1_FB1_DMA_DONE_INTEN_MASK, 
    kCSI_RxFifoFullInterruptEnable       = CSI_CR1_RXFF_INTEN_MASK,         
    kCSI_StartOfFrameInterruptEnable     = CSI_CR1_SOF_INTEN_MASK, 
    kCSI_EccErrorInterruptEnable    = CSI_CR3_ECC_INT_EN_MASK,   
    kCSI_AhbResErrorInterruptEnable = CSI_CR3_HRESP_ERR_EN_MASK, 
    kCSI_BaseAddrChangeErrorInterruptEnable = CSI_CR18_BASEADDR_CHANGE_ERROR_IE_MASK << 6U,
 
    kCSI_Field0DoneInterruptEnable = CSI_CR18_FIELD0_DONE_IE_MASK << 6U,     
    kCSI_Field1DoneInterruptEnable = CSI_CR18_DMA_FIELD1_DONE_IE_MASK << 6U, 
};
 
enum _csi_flags
{
    kCSI_RxFifoDataReadyFlag     = CSI_SR_DRDY_MASK,          
    kCSI_EccErrorFlag            = CSI_SR_ECC_INT_MASK,       
    kCSI_AhbResErrorFlag         = CSI_SR_HRESP_ERR_INT_MASK, 
    kCSI_ChangeOfFieldFlag       = CSI_SR_COF_INT_MASK,       
    kCSI_Field0PresentFlag       = CSI_SR_F1_INT_MASK,        
    kCSI_Field1PresentFlag       = CSI_SR_F2_INT_MASK,        
    kCSI_StartOfFrameFlag        = CSI_SR_SOF_INT_MASK,       
    kCSI_EndOfFrameFlag          = CSI_SR_EOF_INT_MASK,       
    kCSI_RxFifoFullFlag          = CSI_SR_RxFF_INT_MASK, 
    kCSI_RxBuffer1DmaDoneFlag    = CSI_SR_DMA_TSF_DONE_FB2_MASK,       
    kCSI_RxBuffer0DmaDoneFlag    = CSI_SR_DMA_TSF_DONE_FB1_MASK,       
    kCSI_StatFifoFullFlag        = CSI_SR_STATFF_INT_MASK,             
    kCSI_StatFifoDmaDoneFlag     = CSI_SR_DMA_TSF_DONE_SFF_MASK,       
    kCSI_StatFifoOverrunFlag     = CSI_SR_SF_OR_INT_MASK,              
    kCSI_RxFifoOverrunFlag       = CSI_SR_RF_OR_INT_MASK,              
    kCSI_Field0DoneFlag          = CSI_SR_DMA_FIELD0_DONE_MASK,        
    kCSI_Field1DoneFlag          = CSI_SR_DMA_FIELD1_DONE_MASK,        
    kCSI_BaseAddrChangeErrorFlag = CSI_SR_BASEADDR_CHHANGE_ERROR_MASK, 
};
 
/* Forward declaration of the handle typedef. */
typedef struct _csi_handle csi_handle_t;
 
typedef void (*csi_transfer_callback_t)(CSI_Type *base, csi_handle_t *handle, status_t status, void *userData);
 
struct _csi_handle
{
    uint32_t frameBufferQueue[CSI_DRIVER_ACTUAL_QUEUE_SIZE]; 
    volatile uint8_t queueWriteIdx;  
    volatile uint8_t queueReadIdx;   
    void *volatile emptyBuffer;      
    volatile uint8_t emptyBufferCnt; 
    volatile uint8_t activeBufferNum; 
    volatile bool transferStarted; 
    csi_transfer_callback_t callback; 
    void *userData;                   
};
 
#if CSI_DRIVER_FRAG_MODE
 
typedef enum _csi_frag_input_pixel_format
{
    kCSI_FragInputRGB565 = 0, 
    kCSI_FragInputYUYV,       
    kCSI_FragInputUYVY,       
} csi_frag_input_pixel_format_t;
 
typedef struct _csi_frag_config
{
    uint16_t width;           
    uint16_t height;          
    uint32_t polarityFlags;   
    csi_work_mode_t workMode; 
    csi_data_bus_t dataBus;   
    bool useExtVsync;         
    csi_frag_input_pixel_format_t inputFormat; 
    uint32_t dmaBufferAddr0;  
    uint32_t dmaBufferAddr1;  
    uint16_t dmaBufferLine;   
    bool isDmaBufferCachable; 
} csi_frag_config_t;
 
/* Forward declaration of the handle typedef. */
typedef struct _csi_frag_handle csi_frag_handle_t;
 
typedef void (*csi_frag_transfer_callback_t)(CSI_Type *base,
                                             csi_frag_handle_t *handle,
                                             status_t status,
                                             void *userData);
 
typedef void (*csi_frag_copy_func_t)(void *pDest, const void *pSrc, size_t cnt);
 
struct _csi_frag_handle
{
    uint16_t width;                            
    uint16_t height;                           
    uint16_t maxLinePerFrag;                   
    uint16_t linePerFrag;                      
    uint16_t dmaBytePerLine;                   
    uint16_t datBytePerLine;                   
    uint16_t dmaCurLine;                       
    uint16_t windowULX;                        
    uint16_t windowULY;                        
    uint16_t windowLRX;                        
    uint16_t windowLRY;                        
    uint32_t outputBuffer;                     
    uint32_t datCurWriteAddr;                  
    csi_frag_input_pixel_format_t inputFormat; 
    csi_frag_transfer_callback_t callback; 
    void *userData;                        
    csi_frag_copy_func_t copyFunc;         
    bool isDmaBufferCachable;              
};
 
typedef struct _csi_frag_window
{
    uint16_t windowULX; 
    uint16_t windowULY; 
    uint16_t windowLRX; 
    uint16_t windowLRY; 
} csi_frag_window_t;
 
typedef struct _csi_frag_capture_config
{
    bool outputGrayScale;      
    uint32_t buffer;           
    csi_frag_window_t *window; 
} csi_frag_capture_config_t;
 
#endif /* CSI_DRIVER_FRAG_MODE */
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif
 
status_t CSI_Init(CSI_Type *base, const csi_config_t *config);
 
void CSI_Deinit(CSI_Type *base);
 
void CSI_Reset(CSI_Type *base);
 
void CSI_GetDefaultConfig(csi_config_t *config);
 
/* @} */
 
void CSI_ClearFifo(CSI_Type *base, csi_fifo_t fifo);
 
void CSI_ReflashFifoDma(CSI_Type *base, csi_fifo_t fifo);
 
void CSI_EnableFifoDmaRequest(CSI_Type *base, csi_fifo_t fifo, bool enable);
 
static inline void CSI_Start(CSI_Type *base)
{
    CSI_EnableFifoDmaRequest(base, kCSI_RxFifo, true);
    CSI_REG_CR18(base) |= CSI_CR18_CSI_ENABLE_MASK;
}
 
static inline void CSI_Stop(CSI_Type *base)
{
    CSI_REG_CR18(base) &= ~CSI_CR18_CSI_ENABLE_MASK;
    CSI_EnableFifoDmaRequest(base, kCSI_RxFifo, false);
}
 
void CSI_SetRxBufferAddr(CSI_Type *base, uint8_t index, uint32_t addr);
/* @} */
 
void CSI_EnableInterrupts(CSI_Type *base, uint32_t mask);
 
void CSI_DisableInterrupts(CSI_Type *base, uint32_t mask);
 
/* @} */
 
static inline uint32_t CSI_GetStatusFlags(CSI_Type *base)
{
    return CSI_REG_SR(base);
}
 
static inline void CSI_ClearStatusFlags(CSI_Type *base, uint32_t statusMask)
{
    CSI_REG_SR(base) = statusMask;
}
/* @} */
 
#if !CSI_DRIVER_FRAG_MODE
status_t CSI_TransferCreateHandle(CSI_Type *base,
                                  csi_handle_t *handle,
                                  csi_transfer_callback_t callback,
                                  void *userData);
 
status_t CSI_TransferStart(CSI_Type *base, csi_handle_t *handle);
 
status_t CSI_TransferStop(CSI_Type *base, csi_handle_t *handle);
 
status_t CSI_TransferSubmitEmptyBuffer(CSI_Type *base, csi_handle_t *handle, uint32_t frameBuffer);
 
status_t CSI_TransferGetFullBuffer(CSI_Type *base, csi_handle_t *handle, uint32_t *frameBuffer);
 
void CSI_TransferHandleIRQ(CSI_Type *base, csi_handle_t *handle);
/* @} */
 
#else
 
void CSI_FragModeInit(CSI_Type *base);
 
void CSI_FragModeDeinit(CSI_Type *base);
 
status_t CSI_FragModeCreateHandle(CSI_Type *base,
                                  csi_frag_handle_t *handle,
                                  const csi_frag_config_t *config,
                                  csi_frag_transfer_callback_t callback,
                                  void *userData);
 
status_t CSI_FragModeTransferCaptureImage(CSI_Type *base,
                                          csi_frag_handle_t *handle,
                                          const csi_frag_capture_config_t *config);
 
void CSI_FragModeTransferAbortCaptureImage(CSI_Type *base, csi_frag_handle_t *handle);
 
void CSI_FragModeTransferHandleIRQ(CSI_Type *base, csi_frag_handle_t *handle);
 
/* @} */
 
#endif /* CSI_DRIVER_FRAG_MODE */
 
#if defined(__cplusplus)
}
#endif
 
#endif /* _FSL_CSI_H_ */