fsl_elcdif.h

/*
 * Copyright 2017-2022 NXP
 * All rights reserved.
 *
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_ELCDIF_H_
#define _FSL_ELCDIF_H_
 
#include "fsl_common.h"
 
#if (defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && (0 != FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET))
#include "fsl_memory.h"
#endif
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_ELCDIF_DRIVER_VERSION (MAKE_VERSION(2, 0, 5))
/* All IRQ flags in CTRL1 register. */
#define ELCDIF_CTRL1_IRQ_MASK                                                                         \
    (LCDIF_CTRL1_BM_ERROR_IRQ_MASK | LCDIF_CTRL1_OVERFLOW_IRQ_MASK | LCDIF_CTRL1_UNDERFLOW_IRQ_MASK | \
     LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_MASK | LCDIF_CTRL1_VSYNC_EDGE_IRQ_MASK)
 
/* All IRQ enable control bits in CTRL1 register. */
#define ELCDIF_CTRL1_IRQ_EN_MASK                                                                               \
    (LCDIF_CTRL1_BM_ERROR_IRQ_EN_MASK | LCDIF_CTRL1_OVERFLOW_IRQ_EN_MASK | LCDIF_CTRL1_UNDERFLOW_IRQ_EN_MASK | \
     LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_EN_MASK | LCDIF_CTRL1_VSYNC_EDGE_IRQ_EN_MASK)
 
/* All IRQ flags in AS_CTRL register. */
#if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK)
#define ELCDIF_AS_CTRL_IRQ_MASK (LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK)
#else
#define ELCDIF_AS_CTRL_IRQ_MASK 0U
#endif
 
/* All IRQ enable control bits in AS_CTRL register. */
#if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK)
#define ELCDIF_AS_CTRL_IRQ_EN_MASK (LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK)
#else
#define ELCDIF_AS_CTRL_IRQ_EN_MASK 0U
#endif
 
#if ((0 != (ELCDIF_CTRL1_IRQ_MASK & ELCDIF_AS_CTRL_IRQ_MASK)) || \
     (0 != (ELCDIF_AS_CTRL_IRQ_MASK & ELCDIF_AS_CTRL_IRQ_EN_MASK)))
#error Interrupt bits overlap, need to update the interrupt functions.
#endif
 
#if defined(LCDIF_CTRL_ENABLE_PXP_HANDSHAKE_MASK)
#define FSL_FEATURE_LCDIF_HAS_PXP_HANDSHAKE 1
#else
#define FSL_FEATURE_LCDIF_HAS_PXP_HANDSHAKE 0
#endif
 
#if (defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && (0 != FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET))
#define ELCDIF_ADDR_CPU_2_IP(addr) (MEMORY_ConvertMemoryMapAddress((uint32_t)(addr), kMEMORY_Local2DMA))
#else
#define ELCDIF_ADDR_CPU_2_IP(addr) (addr)
#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */
 
/* LUT memory entery number. */
#define ELCDIF_LUT_ENTRY_NUM 256U
 
enum _elcdif_polarity_flags
{
    kELCDIF_VsyncActiveLow            = 0U, 
    kELCDIF_HsyncActiveLow            = 0U, 
    kELCDIF_DataEnableActiveLow       = 0U, 
    kELCDIF_DriveDataOnFallingClkEdge = 0U, 
    kELCDIF_VsyncActiveHigh          = LCDIF_VDCTRL0_VSYNC_POL_MASK,  
    kELCDIF_HsyncActiveHigh          = LCDIF_VDCTRL0_HSYNC_POL_MASK,  
    kELCDIF_DataEnableActiveHigh     = LCDIF_VDCTRL0_ENABLE_POL_MASK, 
    kELCDIF_DriveDataOnRisingClkEdge = LCDIF_VDCTRL0_DOTCLK_POL_MASK, 
};
 
enum _elcdif_interrupt_enable
{
    kELCDIF_BusMasterErrorInterruptEnable  = LCDIF_CTRL1_BM_ERROR_IRQ_EN_MASK,  
    kELCDIF_TxFifoOverflowInterruptEnable  = LCDIF_CTRL1_OVERFLOW_IRQ_EN_MASK,  
    kELCDIF_TxFifoUnderflowInterruptEnable = LCDIF_CTRL1_UNDERFLOW_IRQ_EN_MASK, 
    kELCDIF_CurFrameDoneInterruptEnable =
        LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_EN_MASK, 
    kELCDIF_VsyncEdgeInterruptEnable =
        LCDIF_CTRL1_VSYNC_EDGE_IRQ_EN_MASK, 
#if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK)
    kELCDIF_SciSyncOnInterruptEnable =
        LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_EN_MASK, 
#endif
};
 
enum _elcdif_interrupt_flags
{
    kELCDIF_BusMasterError  = LCDIF_CTRL1_BM_ERROR_IRQ_MASK,  
    kELCDIF_TxFifoOverflow  = LCDIF_CTRL1_OVERFLOW_IRQ_MASK,  
    kELCDIF_TxFifoUnderflow = LCDIF_CTRL1_UNDERFLOW_IRQ_MASK, 
    kELCDIF_CurFrameDone =
        LCDIF_CTRL1_CUR_FRAME_DONE_IRQ_MASK,             
    kELCDIF_VsyncEdge = LCDIF_CTRL1_VSYNC_EDGE_IRQ_MASK, 
#if defined(LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK)
    kELCDIF_SciSyncOn = LCDIF_AS_CTRL_CSI_SYNC_ON_IRQ_MASK, 
#endif
};
 
enum _elcdif_status_flags
{
    kELCDIF_LFifoFull   = LCDIF_STAT_LFIFO_FULL_MASK,   
    kELCDIF_LFifoEmpty  = LCDIF_STAT_LFIFO_EMPTY_MASK,  
    kELCDIF_TxFifoFull  = LCDIF_STAT_TXFIFO_FULL_MASK,  
    kELCDIF_TxFifoEmpty = LCDIF_STAT_TXFIFO_EMPTY_MASK, 
#if defined(LCDIF_STAT_BUSY_MASK)
    kELCDIF_LcdControllerBusy = LCDIF_STAT_BUSY_MASK, 
#endif
#if defined(LCDIF_STAT_DVI_CURRENT_FIELD_MASK)
    kELCDIF_CurDviField2 = LCDIF_STAT_DVI_CURRENT_FIELD_MASK, 
#endif
};
 
typedef enum _elcdif_pixel_format
{
    kELCDIF_PixelFormatRAW8   = 0,   
    kELCDIF_PixelFormatRGB565 = 1,   
    kELCDIF_PixelFormatRGB666 = 2,   
    kELCDIF_PixelFormatXRGB8888 = 3, 
    kELCDIF_PixelFormatRGB888   = 4, 
} elcdif_pixel_format_t;
 
typedef enum _elcdif_lcd_data_bus
{
    kELCDIF_DataBus8Bit  = LCDIF_CTRL_LCD_DATABUS_WIDTH(1), 
    kELCDIF_DataBus16Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(0), 
    kELCDIF_DataBus18Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(2), 
    kELCDIF_DataBus24Bit = LCDIF_CTRL_LCD_DATABUS_WIDTH(3), 
} elcdif_lcd_data_bus_t;
 
typedef struct _elcdif_pixel_format_reg
{
    uint32_t regCtrl;  
    uint32_t regCtrl1; 
} elcdif_pixel_format_reg_t;
 
typedef struct _elcdif_rgb_mode_config
{
    uint16_t panelWidth;    
    uint16_t panelHeight;   
    uint8_t hsw;            
    uint8_t hfp;            
    uint8_t hbp;            
    uint8_t vsw;            
    uint8_t vfp;            
    uint8_t vbp;            
    uint32_t polarityFlags; 
    uint32_t bufferAddr;    
    elcdif_pixel_format_t pixelFormat; 
    elcdif_lcd_data_bus_t dataBus;     
} elcdif_rgb_mode_config_t;
 
typedef enum _elcdif_as_pixel_format
{
    kELCDIF_AsPixelFormatARGB8888 = 0x0, 
    kELCDIF_AsPixelFormatRGB888   = 0x4, 
    kELCDIF_AsPixelFormatARGB1555 = 0x8, 
    kELCDIF_AsPixelFormatARGB4444 = 0x9, 
    kELCDIF_AsPixelFormatRGB555   = 0xC, 
    kELCDIF_AsPixelFormatRGB444   = 0xD, 
    kELCDIF_AsPixelFormatRGB565   = 0xE, 
} elcdif_as_pixel_format_t;
 
typedef struct _elcdif_as_buffer_config
{
    uint32_t bufferAddr;                  
    elcdif_as_pixel_format_t pixelFormat; 
} elcdif_as_buffer_config_t;
 
typedef enum _elcdif_alpha_mode
{
    kELCDIF_AlphaEmbedded, 
    kELCDIF_AlphaOverride, 
    kELCDIF_AlphaMultiply, 
    kELCDIF_AlphaRop       
} elcdif_alpha_mode_t;
 
typedef enum _elcdif_rop_mode
{
    kELCDIF_RopMaskAs     = 0x0, 
    kELCDIF_RopMaskNotAs  = 0x1, 
    kELCDIF_RopMaskAsNot  = 0x2, 
    kELCDIF_RopMergeAs    = 0x3, 
    kELCDIF_RopMergeNotAs = 0x4, 
    kELCDIF_RopMergeAsNot = 0x5, 
    kELCDIF_RopNotCopyAs  = 0x6, 
    kELCDIF_RopNot        = 0x7, 
    kELCDIF_RopNotMaskAs  = 0x8, 
    kELCDIF_RopNotMergeAs = 0x9, 
    kELCDIF_RopXorAs      = 0xA, 
    kELCDIF_RopNotXorAs   = 0xB  
} elcdif_rop_mode_t;
 
typedef struct _elcdif_as_blend_config
{
    uint8_t alpha;    
    bool invertAlpha; 
    elcdif_alpha_mode_t alphaMode; 
    elcdif_rop_mode_t ropMode;     
} elcdif_as_blend_config_t;
 
typedef enum _elcdif_lut
{
    kELCDIF_Lut0 = 0, 
    kELCDIF_Lut1,     
} elcdif_lut_t;
 
/*******************************************************************************
 * APIs
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
 
void ELCDIF_RgbModeInit(LCDIF_Type *base, const elcdif_rgb_mode_config_t *config);
 
void ELCDIF_RgbModeGetDefaultConfig(elcdif_rgb_mode_config_t *config);
 
void ELCDIF_Deinit(LCDIF_Type *base);
 
/* @} */
 
void ELCDIF_RgbModeSetPixelFormat(LCDIF_Type *base, elcdif_pixel_format_t pixelFormat);
 
static inline void ELCDIF_RgbModeStart(LCDIF_Type *base)
{
    base->CTRL_SET = LCDIF_CTRL_RUN_MASK | LCDIF_CTRL_DOTCLK_MODE_MASK;
}
 
void ELCDIF_RgbModeStop(LCDIF_Type *base);
 
static inline void ELCDIF_SetNextBufferAddr(LCDIF_Type *base, uint32_t bufferAddr)
{
    base->NEXT_BUF = ELCDIF_ADDR_CPU_2_IP(bufferAddr);
}
 
void ELCDIF_Reset(LCDIF_Type *base);
 
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_RESET_PIN) && (0 != FSL_FEATURE_LCDIF_HAS_NO_RESET_PIN))
static inline void ELCDIF_PullUpResetPin(LCDIF_Type *base, bool pullUp)
{
    if (pullUp)
    {
        base->CTRL1_SET = LCDIF_CTRL1_RESET_MASK;
    }
    else
    {
        base->CTRL1_CLR = LCDIF_CTRL1_RESET_MASK;
    }
}
#endif
 
#if (defined(FSL_FEATURE_LCDIF_HAS_PXP_HANDSHAKE) && (0 != FSL_FEATURE_LCDIF_HAS_PXP_HANDSHAKE))
static inline void ELCDIF_EnablePxpHandShake(LCDIF_Type *base, bool enable)
{
    if (enable)
    {
        base->CTRL_SET = LCDIF_CTRL_ENABLE_PXP_HANDSHAKE_MASK;
    }
    else
    {
        base->CTRL_CLR = LCDIF_CTRL_ENABLE_PXP_HANDSHAKE_MASK;
    }
}
#endif
 
/* @} */
 
static inline uint32_t ELCDIF_GetCrcValue(const LCDIF_Type *base)
{
    return base->CRC_STAT;
}
 
static inline uint32_t ELCDIF_GetBusMasterErrorAddr(const LCDIF_Type *base)
{
    return base->BM_ERROR_STAT;
}
 
static inline uint32_t ELCDIF_GetStatus(const LCDIF_Type *base)
{
    return base->STAT & (LCDIF_STAT_LFIFO_FULL_MASK | LCDIF_STAT_LFIFO_EMPTY_MASK | LCDIF_STAT_TXFIFO_FULL_MASK |
                         LCDIF_STAT_TXFIFO_EMPTY_MASK
#if defined(LCDIF_STAT_BUSY_MASK)
                         | LCDIF_STAT_BUSY_MASK
#endif
#if defined(LCDIF_STAT_DVI_CURRENT_FIELD_MASK)
                         | LCDIF_STAT_DVI_CURRENT_FIELD_MASK
#endif
                        );
}
 
static inline uint32_t ELCDIF_GetLFifoCount(const LCDIF_Type *base)
{
    return (base->STAT & LCDIF_STAT_LFIFO_COUNT_MASK) >> LCDIF_STAT_LFIFO_COUNT_SHIFT;
}
 
/* @} */
 
static inline void ELCDIF_EnableInterrupts(LCDIF_Type *base, uint32_t mask)
{
    base->CTRL1_SET = (mask & ELCDIF_CTRL1_IRQ_EN_MASK);
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && (0 != FSL_FEATURE_LCDIF_HAS_NO_AS))
    base->AS_CTRL |= (mask & ELCDIF_AS_CTRL_IRQ_EN_MASK);
#endif
}
 
static inline void ELCDIF_DisableInterrupts(LCDIF_Type *base, uint32_t mask)
{
    base->CTRL1_CLR = (mask & ELCDIF_CTRL1_IRQ_EN_MASK);
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && (0 != FSL_FEATURE_LCDIF_HAS_NO_AS))
    base->AS_CTRL &= ~(mask & ELCDIF_AS_CTRL_IRQ_EN_MASK);
#endif
}
 
static inline uint32_t ELCDIF_GetInterruptStatus(const LCDIF_Type *base)
{
    uint32_t flags;
 
    flags = (base->CTRL1 & ELCDIF_CTRL1_IRQ_MASK);
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && (0 != FSL_FEATURE_LCDIF_HAS_NO_AS))
    flags |= (base->AS_CTRL & ELCDIF_AS_CTRL_IRQ_MASK);
#endif
 
    return flags;
}
 
static inline void ELCDIF_ClearInterruptStatus(LCDIF_Type *base, uint32_t mask)
{
    base->CTRL1_CLR = (mask & ELCDIF_CTRL1_IRQ_MASK);
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && (0 != FSL_FEATURE_LCDIF_HAS_NO_AS))
    base->AS_CTRL &= ~(mask & ELCDIF_AS_CTRL_IRQ_MASK);
#endif
}
 
/* @} */
 
#if !(defined(FSL_FEATURE_LCDIF_HAS_NO_AS) && (0 != FSL_FEATURE_LCDIF_HAS_NO_AS))
void ELCDIF_SetAlphaSurfaceBufferConfig(LCDIF_Type *base, const elcdif_as_buffer_config_t *config);
 
void ELCDIF_SetAlphaSurfaceBlendConfig(LCDIF_Type *base, const elcdif_as_blend_config_t *config);
 
static inline void ELCDIF_SetNextAlphaSurfaceBufferAddr(LCDIF_Type *base, uint32_t bufferAddr)
{
    base->AS_NEXT_BUF = ELCDIF_ADDR_CPU_2_IP(bufferAddr);
}
 
static inline void ELCDIF_SetOverlayColorKey(LCDIF_Type *base, uint32_t colorKeyLow, uint32_t colorKeyHigh)
{
    base->AS_CLRKEYLOW  = colorKeyLow;
    base->AS_CLRKEYHIGH = colorKeyHigh;
}
 
static inline void ELCDIF_EnableOverlayColorKey(LCDIF_Type *base, bool enable)
{
    if (enable)
    {
        base->AS_CTRL |= LCDIF_AS_CTRL_ENABLE_COLORKEY_MASK;
    }
    else
    {
        base->AS_CTRL &= ~LCDIF_AS_CTRL_ENABLE_COLORKEY_MASK;
    }
}
 
static inline void ELCDIF_EnableAlphaSurface(LCDIF_Type *base, bool enable)
{
    if (enable)
    {
        base->AS_CTRL |= LCDIF_AS_CTRL_AS_ENABLE_MASK;
    }
    else
    {
        base->AS_CTRL &= ~LCDIF_AS_CTRL_AS_ENABLE_MASK;
    }
}
 
static inline void ELCDIF_EnableProcessSurface(LCDIF_Type *base, bool enable)
{
    if (enable)
    {
        base->AS_CTRL &= ~LCDIF_AS_CTRL_PS_DISABLE_MASK;
    }
    else
    {
        base->AS_CTRL |= LCDIF_AS_CTRL_PS_DISABLE_MASK;
    }
}
 
/* @} */
#endif /* FSL_FEATURE_LCDIF_HAS_NO_AS */
 
#if (defined(FSL_FEATURE_LCDIF_HAS_LUT) && (0 != FSL_FEATURE_LCDIF_HAS_LUT))
static inline void ELCDIF_EnableLut(LCDIF_Type *base, bool enable)
{
    if (enable)
    {
        base->LUT_CTRL &= ~LCDIF_LUT_CTRL_LUT_BYPASS_MASK;
    }
    else
    {
        base->LUT_CTRL |= LCDIF_LUT_CTRL_LUT_BYPASS_MASK;
    }
}
 
status_t ELCDIF_UpdateLut(
    LCDIF_Type *base, elcdif_lut_t lut, uint16_t startIndex, const uint32_t *lutData, uint16_t count);
 
/* @} */
#endif /* FSL_FEATURE_LCDIF_HAS_LUT */
 
#if defined(__cplusplus)
}
#endif /* __cplusplus */
 
/* @} */
 
#endif /*_FSL_ELCDIF_H_*/