fsl_lcdifv2.h

/*
 * Copyright 2019-2022 NXP
 * All rights reserved.
 *
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_LCDIFV2_H_
#define _FSL_LCDIFV2_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_LCDIFV2_DRIVER_VERSION (MAKE_VERSION(2, 3, 2))
#if defined(FSL_FEATURE_LCDIFV2_LAYER_COUNT) && (!defined(LCDIFV2_LAYER_COUNT))
#define LCDIFV2_LAYER_COUNT FSL_FEATURE_LCDIFV2_LAYER_COUNT
#endif
 
#if defined(FSL_FEATURE_LCDIFV2_LAYER_CSC_COUNT) && (!defined(LCDIFV2_LAYER_CSC_COUNT))
#define LCDIFV2_LAYER_CSC_COUNT FSL_FEATURE_LCDIFV2_LAYER_CSC_COUNT
#endif
 
#if (defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && (0 != FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET))
#define LCDIFV2_ADDR_CPU_2_IP(addr) (MEMORY_ConvertMemoryMapAddress((uint32_t)(addr), kMEMORY_Local2DMA))
#else
#define LCDIFV2_ADDR_CPU_2_IP(addr) (addr)
#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */
 
#define LCDIFV2_MAKE_FIFO_EMPTY_INTERRUPT(layer) (1UL << ((uint32_t)(layer) + 24U))
#define LCDIFV2_MAKE_DMA_DONE_INTERRUPT(layer) (1UL << ((uint32_t)(layer) + 16U))
#define LCDIFV2_MAKE_DMA_ERROR_INTERRUPT(layer) (1UL << ((uint32_t)(layer) + 8U))
 
/* LUT memory entery number. */
#define LCDIFV2_LUT_ENTRY_NUM 256U
 
enum _lcdifv2_polarity_flags
{
    kLCDIFV2_VsyncActiveHigh          = 0U, 
    kLCDIFV2_HsyncActiveHigh          = 0U, 
    kLCDIFV2_DataEnableActiveHigh     = 0U, 
    kLCDIFV2_DriveDataOnRisingClkEdge = 0U, 
    kLCDIFV2_DataActiveHigh = 0U,           
    kLCDIFV2_VsyncActiveLow            = LCDIFV2_CTRL_INV_VS_MASK,   
    kLCDIFV2_HsyncActiveLow            = LCDIFV2_CTRL_INV_HS_MASK,   
    kLCDIFV2_DataEnableActiveLow       = LCDIFV2_CTRL_INV_DE_MASK,   
    kLCDIFV2_DriveDataOnFallingClkEdge = LCDIFV2_CTRL_INV_PXCK_MASK, 
    kLCDIFV2_DataActiveLow = LCDIFV2_CTRL_NEG_MASK,                  
};
 
enum _lcdifv2_interrupt
{
    kLCDIFV2_Layer0FifoEmptyInterrupt  = LCDIFV2_MAKE_FIFO_EMPTY_INTERRUPT(0), 
    kLCDIFV2_Layer1FifoEmptyInterrupt  = LCDIFV2_MAKE_FIFO_EMPTY_INTERRUPT(1), 
    kLCDIFV2_Layer2FifoEmptyInterrupt  = LCDIFV2_MAKE_FIFO_EMPTY_INTERRUPT(2), 
    kLCDIFV2_Layer3FifoEmptyInterrupt  = LCDIFV2_MAKE_FIFO_EMPTY_INTERRUPT(3), 
    kLCDIFV2_Layer4FifoEmptyInterrupt  = LCDIFV2_MAKE_FIFO_EMPTY_INTERRUPT(4), 
    kLCDIFV2_Layer5FifoEmptyInterrupt  = LCDIFV2_MAKE_FIFO_EMPTY_INTERRUPT(5), 
    kLCDIFV2_Layer6FifoEmptyInterrupt  = LCDIFV2_MAKE_FIFO_EMPTY_INTERRUPT(6), 
    kLCDIFV2_Layer7FifoEmptyInterrupt  = LCDIFV2_MAKE_FIFO_EMPTY_INTERRUPT(7), 
    kLCDIFV2_Layer0DmaDoneInterrupt    = LCDIFV2_MAKE_DMA_DONE_INTERRUPT(0),   
    kLCDIFV2_Layer1DmaDoneInterrupt    = LCDIFV2_MAKE_DMA_DONE_INTERRUPT(1),   
    kLCDIFV2_Layer2DmaDoneInterrupt    = LCDIFV2_MAKE_DMA_DONE_INTERRUPT(2),   
    kLCDIFV2_Layer3DmaDoneInterrupt    = LCDIFV2_MAKE_DMA_DONE_INTERRUPT(3),   
    kLCDIFV2_Layer4DmaDoneInterrupt    = LCDIFV2_MAKE_DMA_DONE_INTERRUPT(4),   
    kLCDIFV2_Layer5DmaDoneInterrupt    = LCDIFV2_MAKE_DMA_DONE_INTERRUPT(5),   
    kLCDIFV2_Layer6DmaDoneInterrupt    = LCDIFV2_MAKE_DMA_DONE_INTERRUPT(6),   
    kLCDIFV2_Layer7DmaDoneInterrupt    = LCDIFV2_MAKE_DMA_DONE_INTERRUPT(7),   
    kLCDIFV2_Layer0DmaErrorInterrupt   = LCDIFV2_MAKE_DMA_ERROR_INTERRUPT(0),  
    kLCDIFV2_Layer1DmaErrorInterrupt   = LCDIFV2_MAKE_DMA_ERROR_INTERRUPT(1),  
    kLCDIFV2_Layer2DmaErrorInterrupt   = LCDIFV2_MAKE_DMA_ERROR_INTERRUPT(2),  
    kLCDIFV2_Layer3DmaErrorInterrupt   = LCDIFV2_MAKE_DMA_ERROR_INTERRUPT(3),  
    kLCDIFV2_Layer4DmaErrorInterrupt   = LCDIFV2_MAKE_DMA_ERROR_INTERRUPT(4),  
    kLCDIFV2_Layer5DmaErrorInterrupt   = LCDIFV2_MAKE_DMA_ERROR_INTERRUPT(5),  
    kLCDIFV2_Layer6DmaErrorInterrupt   = LCDIFV2_MAKE_DMA_ERROR_INTERRUPT(6),  
    kLCDIFV2_Layer7DmaErrorInterrupt   = LCDIFV2_MAKE_DMA_ERROR_INTERRUPT(7),  
    kLCDIFV2_VerticalBlankingInterrupt = (1U << 2U), 
    kLCDIFV2_OutputUnderrunInterrupt   = (1U << 1U), 
    kLCDIFV2_VsyncEdgeInterrupt        = (1U << 0U), 
};
 
typedef enum _lcdifv2_line_order
{
    kLCDIFV2_LineOrderRGB = 0, 
    kLCDIFV2_LineOrderRBG,     
    kLCDIFV2_LineOrderGBR,     
    kLCDIFV2_LineOrderGRB,     
    kLCDIFV2_LineOrderBRG,     
    kLCDIFV2_LineOrderBGR,     
} lcdifv2_line_order_t;
 
typedef struct _lcdifv2_display_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; 
    lcdifv2_line_order_t lineOrder; 
} lcdifv2_display_config_t;
 
typedef enum _lcdifv2_csc_mode
{
    kLCDIFV2_CscDisable = 0U, 
    kLCDIFV2_CscYUV2RGB,      
    kLCDIFV2_CscYCbCr2RGB,    
} lcdifv2_csc_mode_t;
 
typedef enum _lcdifv2_pixel_format
{
    kLCDIFV2_PixelFormatIndex1BPP = LCDIFV2_CTRLDESCL5_BPP(0U), 
    kLCDIFV2_PixelFormatIndex2BPP = LCDIFV2_CTRLDESCL5_BPP(1U), 
    kLCDIFV2_PixelFormatIndex4BPP = LCDIFV2_CTRLDESCL5_BPP(2U), 
    kLCDIFV2_PixelFormatIndex8BPP = LCDIFV2_CTRLDESCL5_BPP(3U), 
    kLCDIFV2_PixelFormatRGB565    = LCDIFV2_CTRLDESCL5_BPP(4U), 
    kLCDIFV2_PixelFormatARGB1555  = LCDIFV2_CTRLDESCL5_BPP(5U), 
    kLCDIFV2_PixelFormatARGB4444  = LCDIFV2_CTRLDESCL5_BPP(6U), 
    kLCDIFV2_PixelFormatUYVY      = LCDIFV2_CTRLDESCL5_BPP(7U) |
                               LCDIFV2_CTRLDESCL5_YUV_FORMAT(0U), 
    kLCDIFV2_PixelFormatVYUY = LCDIFV2_CTRLDESCL5_BPP(7U) |
                               LCDIFV2_CTRLDESCL5_YUV_FORMAT(1U), 
    kLCDIFV2_PixelFormatYUYV = LCDIFV2_CTRLDESCL5_BPP(7U) |
                               LCDIFV2_CTRLDESCL5_YUV_FORMAT(2U), 
    kLCDIFV2_PixelFormatYVYU = LCDIFV2_CTRLDESCL5_BPP(7U) |
                               LCDIFV2_CTRLDESCL5_YUV_FORMAT(3U), 
    kLCDIFV2_PixelFormatRGB888   = LCDIFV2_CTRLDESCL5_BPP(8U),    
    kLCDIFV2_PixelFormatARGB8888 = LCDIFV2_CTRLDESCL5_BPP(9U),    
    kLCDIFV2_PixelFormatABGR8888 = LCDIFV2_CTRLDESCL5_BPP(10U),   
} lcdifv2_pixel_format_t;
 
typedef struct _lcdifv2_buffer_config
{
    uint16_t strideBytes; 
    lcdifv2_pixel_format_t pixelFormat; 
} lcdifv2_buffer_config_t;
 
typedef enum _lcdifv2_alpha_mode
{
    kLCDIFV2_AlphaDisable,   
    kLCDIFV2_AlphaOverride,  
    kLCDIFV2_AlphaEmbedded,  
    kLCDIFV2_AlphaPoterDuff, 
} lcdifv2_alpha_mode_t;
 
typedef enum _lcdifv2_pd_alpha_mode
{
    kLCDIFV2_PD_AlphaStraight = 0, 
    kLCDIFV2_PD_AlphaInversed = 1, 
} lcdifv2_pd_alpha_mode_t;
 
typedef enum _lcdifv2_pd_color_mode
{
    kLCDIFV2_PD_ColorNoAlpha   = 0, 
    kLCDIFV2_PD_ColorWithAlpha = 1, 
} lcdifv2_pd_color_mode_t;
 
typedef enum _lcdifv2_pd_global_alpha_mode
{
    kLCDIFV2_PD_GlobalAlpha = 0, 
    kLCDIFV2_PD_LocalAlpha  = 1, 
    kLCDIFV2_PD_ScaledAlpha = 2, 
} lcdifv2_pd_global_alpha_mode_t;
 
typedef enum _lcdifv2_pd_factor_mode
{
    kLCDIFV2_PD_FactorOne           = 0, 
    kLCDIFV2_PD_FactorZero          = 1, 
    kLCDIFV2_PD_FactorStraightAlpha = 2, 
    kLCDIFV2_PD_FactorInversedAlpha = 3, 
} lcdifv2_pd_factor_mode_t;
 
typedef struct _lcdifv2_blend_config
{
    uint8_t globalAlpha;                              
    lcdifv2_alpha_mode_t alphaMode;                   
    lcdifv2_pd_alpha_mode_t pdAlphaMode;              
    lcdifv2_pd_color_mode_t pdColorMode;              
    lcdifv2_pd_global_alpha_mode_t pdGlobalAlphaMode; 
    lcdifv2_pd_factor_mode_t pdFactorMode;            
} lcdifv2_blend_config_t;
 
typedef enum _lcdifv2_pd_blend_mode
{
    kLCDIFV2_PD_Src = 0, 
    kLCDIFV2_PD_Atop,    
    kLCDIFV2_PD_Over,    
    kLCDIFV2_PD_In,      
    kLCDIFV2_PD_Out,     
    kLCDIFV2_PD_Dst,     
    kLCDIFV2_PD_DstAtop, 
    kLCDIFV2_PD_DstOver, 
    kLCDIFV2_PD_DstIn,   
    kLCDIFV2_PD_DstOut,  
    kLCDIFV2_PD_Xor,     
    kLCDIFV2_PD_Clear,   
    kLCDIFV2_PD_Max,     
} lcdifv2_pd_blend_mode_t;
 
typedef enum _lcdifv2_pd_layer
{
    kLCDIFV2_PD_SrcLayer  = 0, 
    kLCDIFV2_PD_DestLayer = 1, 
    kLCDIFV2_PD_LayerMax  = 2, 
} lcdifv2_pd_layer_t;
 
/*******************************************************************************
 * APIs
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
 
void LCDIFV2_Init(LCDIFV2_Type *base);
 
void LCDIFV2_Deinit(LCDIFV2_Type *base);
 
void LCDIFV2_Reset(LCDIFV2_Type *base);
 
/* @} */
 
void LCDIFV2_DisplayGetDefaultConfig(lcdifv2_display_config_t *config);
 
void LCDIFV2_SetDisplayConfig(LCDIFV2_Type *base, const lcdifv2_display_config_t *config);
 
static inline void LCDIFV2_EnableDisplay(LCDIFV2_Type *base, bool enable)
{
    if (enable)
    {
        base->DISP_PARA |= LCDIFV2_DISP_PARA_DISP_ON_MASK;
    }
    else
    {
        base->DISP_PARA &= ~LCDIFV2_DISP_PARA_DISP_ON_MASK;
    }
}
 
/* @} */
 
static inline void LCDIFV2_EnableInterrupts(LCDIFV2_Type *base, uint8_t domain, uint32_t mask)
{
    base->INT[domain].INT_ENABLE |= mask;
}
 
static inline void LCDIFV2_DisableInterrupts(LCDIFV2_Type *base, uint8_t domain, uint32_t mask)
{
    base->INT[domain].INT_ENABLE &= ~mask;
}
 
static inline uint32_t LCDIFV2_GetInterruptStatus(LCDIFV2_Type *base, uint8_t domain)
{
    return base->INT[domain].INT_STATUS;
}
 
static inline void LCDIFV2_ClearInterruptStatus(LCDIFV2_Type *base, uint8_t domain, uint32_t mask)
{
    base->INT[domain].INT_STATUS = mask;
}
 
/* @} */
 
status_t LCDIFV2_SetLut(
    LCDIFV2_Type *base, uint8_t layerIndex, const uint32_t *lutData, uint16_t count, bool useShadowLoad);
 
/* @} */
 
static inline void LCDIFV2_SetLayerSize(LCDIFV2_Type *base, uint8_t layerIndex, uint16_t width, uint16_t height)
{
    base->LAYER[layerIndex].CTRLDESCL1 =
        ((uint32_t)height << LCDIFV2_CTRLDESCL1_HEIGHT_SHIFT) | ((uint32_t)width << LCDIFV2_CTRLDESCL1_WIDTH_SHIFT);
}
 
static inline void LCDIFV2_SetLayerOffset(LCDIFV2_Type *base, uint8_t layerIndex, uint16_t offsetX, uint16_t offsetY)
{
    base->LAYER[layerIndex].CTRLDESCL2 =
        ((uint32_t)offsetX << LCDIFV2_CTRLDESCL2_POSX_SHIFT) | ((uint32_t)offsetY << LCDIFV2_CTRLDESCL2_POSY_SHIFT);
}
 
void LCDIFV2_SetLayerBufferConfig(LCDIFV2_Type *base, uint8_t layerIndex, const lcdifv2_buffer_config_t *config);
 
static inline void LCDIFV2_SetLayerBufferAddr(LCDIFV2_Type *base, uint8_t layerIndex, uint32_t addr)
{
    base->LAYER[layerIndex].CTRLDESCL4 = LCDIFV2_ADDR_CPU_2_IP(addr);
}
 
static inline void LCDIFV2_EnableLayer(LCDIFV2_Type *base, uint8_t layerIndex, bool enable)
{
    if (enable)
    {
        base->LAYER[layerIndex].CTRLDESCL5 |= LCDIFV2_CTRLDESCL5_EN_MASK;
    }
    else
    {
        base->LAYER[layerIndex].CTRLDESCL5 &= ~LCDIFV2_CTRLDESCL5_EN_MASK;
    }
}
 
static inline void LCDIFV2_TriggerLayerShadowLoad(LCDIFV2_Type *base, uint8_t layerIndex)
{
    base->LAYER[layerIndex].CTRLDESCL5 |= LCDIFV2_CTRLDESCL5_SHADOW_LOAD_EN_MASK;
}
 
static inline void LCDIFV2_SetLayerBackGroundColor(LCDIFV2_Type *base, uint8_t layerIndex, uint32_t backGroundColor)
{
    base->LAYER[layerIndex].CTRLDESCL6 = backGroundColor;
}
 
void LCDIFV2_SetLayerBlendConfig(LCDIFV2_Type *base, uint8_t layerIndex, const lcdifv2_blend_config_t *config);
 
void LCDIFV2_SetCscMode(LCDIFV2_Type *base, uint8_t layerIndex, lcdifv2_csc_mode_t mode);
 
/* @} */
 
status_t LCDIFV2_GetPorterDuffConfig(lcdifv2_pd_blend_mode_t mode,
                                     lcdifv2_pd_layer_t layer,
                                     lcdifv2_blend_config_t *config);
 
/* @} */
 
status_t LCDIFV2_GetMultiLayerGlobalAlpha(const uint8_t blendedAlpha[], uint8_t globalAlpha[], uint8_t layerCount);
 
/* @} */
 
#if defined(__cplusplus)
}
#endif /* __cplusplus */
 
/* @} */
 
#endif /*_FSL_LCDIFV2_H_*/