/* * Copyright 2019-2022 NXP * All rights reserved. * * * SPDX-License-Identifier: BSD-3-Clause */ #include "fsl_lcdifv2.h" /******************************************************************************* * Definitions ******************************************************************************/ /* Component ID definition, used by tools. */ #ifndef FSL_COMPONENT_ID #define FSL_COMPONENT_ID "platform.drivers.lcdifv2" #endif #define LCDIFV2_LUT_MEM(base) \ ((volatile uint32_t *)(((uint32_t)(base)) + (uint32_t)FSL_FEATURE_LCDIFV2_CLUT_RAM_OFFSET)) /******************************************************************************* * Prototypes ******************************************************************************/ /*! * @brief Get instance number for LCDIF module. * * @param base LCDIF peripheral base address */ static uint32_t LCDIFV2_GetInstance(LCDIFV2_Type *base); /*! * @brief Reset register value to default status. * * @param base LCDIF peripheral base address */ static void LCDIFV2_ResetRegister(LCDIFV2_Type *base); /******************************************************************************* * Variables ******************************************************************************/ /*! @brief Pointers to LCDIF bases for each instance. */ static LCDIFV2_Type *const s_lcdifv2Bases[] = LCDIFV2_BASE_PTRS; #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) /*! @brief Pointers to LCDIF clock for each instance. */ static const clock_ip_name_t s_lcdifv2Clocks[] = LCDIFV2_CLOCKS; #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ /*! @brief Porter Duff layer factors for different configuration. */ static const lcdifv2_pd_factor_mode_t s_lcdifv2PdLayerFactors[][2] = { /* kLCDIFV2_PD_Src */ { /* s1_s0_factor_mode. */ kLCDIFV2_PD_FactorZero, /* s0_s1_factor_mode. */ kLCDIFV2_PD_FactorOne, }, /* kLCDIFV2_PD_Atop */ {kLCDIFV2_PD_FactorInversedAlpha, kLCDIFV2_PD_FactorStraightAlpha}, /* kLCDIFV2_PD_Over */ {kLCDIFV2_PD_FactorInversedAlpha, kLCDIFV2_PD_FactorOne}, /* kLCDIFV2_PD_In */ {kLCDIFV2_PD_FactorZero, kLCDIFV2_PD_FactorStraightAlpha}, /* kLCDIFV2_PD_Out */ {kLCDIFV2_PD_FactorZero, kLCDIFV2_PD_FactorInversedAlpha}, /* kLCDIFV2_PD_Dst */ {kLCDIFV2_PD_FactorOne, kLCDIFV2_PD_FactorZero}, /* kLCDIFV2_PD_DstAtop */ {kLCDIFV2_PD_FactorStraightAlpha, kLCDIFV2_PD_FactorInversedAlpha}, /* kLCDIFV2_PD_DstOver */ {kLCDIFV2_PD_FactorOne, kLCDIFV2_PD_FactorInversedAlpha}, /* kLCDIFV2_PD_DstIn */ {kLCDIFV2_PD_FactorStraightAlpha, kLCDIFV2_PD_FactorZero}, /* kLCDIFV2_PD_DstOut */ {kLCDIFV2_PD_FactorInversedAlpha, kLCDIFV2_PD_FactorZero}, /* kLCDIFV2_PD_Xor */ {kLCDIFV2_PD_FactorInversedAlpha, kLCDIFV2_PD_FactorInversedAlpha}, /* kLCDIFV2_PD_Clear */ { kLCDIFV2_PD_FactorZero, kLCDIFV2_PD_FactorZero, }, }; /******************************************************************************* * Codes ******************************************************************************/ static uint32_t LCDIFV2_GetInstance(LCDIFV2_Type *base) { uint32_t instance; /* Find the instance index from base address mappings. */ for (instance = 0; instance < ARRAY_SIZE(s_lcdifv2Bases); instance++) { if (s_lcdifv2Bases[instance] == base) { break; } } assert(instance < ARRAY_SIZE(s_lcdifv2Bases)); return instance; } static void LCDIFV2_ResetRegister(LCDIFV2_Type *base) { uint32_t i; base->DISP_PARA = 0U; base->CTRL = 0x80000000U; base->DISP_SIZE = 0U; base->HSYN_PARA = 0x00C01803U; base->VSYN_PARA = 0x00C01803U; base->INT[0].INT_ENABLE = 0U; base->INT[1].INT_ENABLE = 0U; base->PDI_PARA = 0x00001000U; for (i = 0; i < (uint32_t)LCDIFV2_LAYER_COUNT; i++) { base->LAYER[i].CTRLDESCL5 = 0U; base->LAYER[i].CTRLDESCL1 = 0U; base->LAYER[i].CTRLDESCL2 = 0U; base->LAYER[i].CTRLDESCL3 = 0U; base->LAYER[i].CTRLDESCL4 = 0U; base->LAYER[i].CTRLDESCL6 = 0U; } for (i = 0; i < (uint32_t)LCDIFV2_LAYER_CSC_COUNT; i++) { base->LAYER[i].CSC_COEF0 = 0x04000000U; base->LAYER[i].CSC_COEF1 = 0x01230208U; base->LAYER[i].CSC_COEF2 = 0x076B079CU; } /* Clear interrupt status. */ base->INT[0].INT_STATUS = 0xFFFFFFFFU; base->INT[1].INT_STATUS = 0xFFFFFFFFU; } /*! * brief Initializes the LCDIF v2. * * This function ungates the LCDIF v2 clock and release the peripheral reset. * * param base LCDIF v2 peripheral base address. */ void LCDIFV2_Init(LCDIFV2_Type *base) { #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) uint32_t instance = LCDIFV2_GetInstance(base); /* Enable the clock. */ CLOCK_EnableClock(s_lcdifv2Clocks[instance]); #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ LCDIFV2_ResetRegister(base); /* Out of reset. */ base->CTRL = 0U; } /*! * brief Deinitializes the LCDIF peripheral. * * param base LCDIF peripheral base address. */ void LCDIFV2_Deinit(LCDIFV2_Type *base) { LCDIFV2_ResetRegister(base); #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) uint32_t instance = LCDIFV2_GetInstance(base); /* Disable the clock. */ CLOCK_DisableClock(s_lcdifv2Clocks[instance]); #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ } /*! * brief Reset the LCDIF v2. * * param base LCDIF peripheral base address. */ void LCDIFV2_Reset(LCDIFV2_Type *base) { LCDIFV2_ResetRegister(base); /* Release and ready to work. */ base->CTRL = 0U; } /*! * brief Gets the LCDIF display default configuration structure. * * param config Pointer to the LCDIF configuration structure. */ void LCDIFV2_DisplayGetDefaultConfig(lcdifv2_display_config_t *config) { assert(NULL != config); config->panelWidth = 0U; config->panelHeight = 0U; config->hsw = 3U; config->hfp = 3U; config->hbp = 3U; config->vsw = 3U; config->vfp = 3U; config->vbp = 3U; config->polarityFlags = (uint32_t)kLCDIFV2_VsyncActiveHigh | (uint32_t)kLCDIFV2_HsyncActiveHigh | (uint32_t)kLCDIFV2_DataEnableActiveHigh | (uint32_t)kLCDIFV2_DriveDataOnRisingClkEdge | (uint32_t)kLCDIFV2_DataActiveHigh; config->lineOrder = kLCDIFV2_LineOrderRGB; } /*! * brief Set the LCDIF v2 display configurations. * * param base LCDIF peripheral base address. * param config Pointer to the LCDIF configuration structure. */ void LCDIFV2_SetDisplayConfig(LCDIFV2_Type *base, const lcdifv2_display_config_t *config) { assert(NULL != config); /* Configure the parameters. */ base->DISP_SIZE = ((uint32_t)config->panelWidth << LCDIFV2_DISP_SIZE_DELTA_X_SHIFT) | ((uint32_t)config->panelHeight << LCDIFV2_DISP_SIZE_DELTA_Y_SHIFT); base->HSYN_PARA = ((uint32_t)config->hsw << LCDIFV2_HSYN_PARA_PW_H_SHIFT) | ((uint32_t)config->hbp << LCDIFV2_HSYN_PARA_BP_H_SHIFT) | ((uint32_t)config->hfp << LCDIFV2_HSYN_PARA_FP_H_SHIFT); base->VSYN_PARA = ((uint32_t)config->vsw << LCDIFV2_VSYN_PARA_PW_V_SHIFT) | ((uint32_t)config->vbp << LCDIFV2_VSYN_PARA_BP_V_SHIFT) | ((uint32_t)config->vfp << LCDIFV2_VSYN_PARA_FP_V_SHIFT); base->DISP_PARA = LCDIFV2_DISP_PARA_LINE_PATTERN(config->lineOrder); base->CTRL = (uint32_t)(config->polarityFlags); } /*! * brief Set the color space conversion mode. * * Supports YUV2RGB and YCbCr2RGB. * * param base LCDIFv2 peripheral base address. * param layerIndex Index of the layer. * param mode The conversion mode. */ void LCDIFV2_SetCscMode(LCDIFV2_Type *base, uint8_t layerIndex, lcdifv2_csc_mode_t mode) { assert(layerIndex < (uint32_t)LCDIFV2_LAYER_CSC_COUNT); /* * The equations used for Colorspace conversion are: * * R = C0*(Y+Y_OFFSET) + C1(V+UV_OFFSET) * G = C0*(Y+Y_OFFSET) + C3(U+UV_OFFSET) + C2(V+UV_OFFSET) * B = C0*(Y+Y_OFFSET) + C4(U+UV_OFFSET) */ if (kLCDIFV2_CscYUV2RGB == mode) { base->LAYER[layerIndex].CSC_COEF0 = LCDIFV2_CSC_COEF0_ENABLE_MASK | LCDIFV2_CSC_COEF0_C0(0x100U) /* 1.00. */ | LCDIFV2_CSC_COEF0_Y_OFFSET(0x0U) /* 0. */ | LCDIFV2_CSC_COEF0_UV_OFFSET(0x0U); /* 0. */ base->LAYER[layerIndex].CSC_COEF1 = LCDIFV2_CSC_COEF1_C1(0x0123U) /* 1.140. */ | LCDIFV2_CSC_COEF1_C4(0x0208U); /* 2.032. */ base->LAYER[layerIndex].CSC_COEF2 = LCDIFV2_CSC_COEF2_C2(0x076BU) /* -0.851. */ | LCDIFV2_CSC_COEF2_C3(0x079BU); /* -0.394. */ } else if (kLCDIFV2_CscYCbCr2RGB == mode) { base->LAYER[layerIndex].CSC_COEF0 = LCDIFV2_CSC_COEF0_ENABLE_MASK | LCDIFV2_CSC_COEF0_YCBCR_MODE_MASK | LCDIFV2_CSC_COEF0_C0(0x12AU) /* 1.164. */ | LCDIFV2_CSC_COEF0_Y_OFFSET(0x1F0U) /* -16. */ | LCDIFV2_CSC_COEF0_UV_OFFSET(0x180U); /* -128. */ base->LAYER[layerIndex].CSC_COEF1 = LCDIFV2_CSC_COEF1_C1(0x0198U) /* 1.596. */ | LCDIFV2_CSC_COEF1_C4(0x0204U); /* 2.017. */ base->LAYER[layerIndex].CSC_COEF2 = LCDIFV2_CSC_COEF2_C2(0x0730U) /* -0.813. */ | LCDIFV2_CSC_COEF2_C3(0x079CU); /* -0.392. */ } else { base->LAYER[layerIndex].CSC_COEF0 = 0U; base->LAYER[layerIndex].CSC_COEF1 = 0U; base->LAYER[layerIndex].CSC_COEF2 = 0U; } } /*! * brief Set the layer source buffer configuration. * * param base LCDIFv2 peripheral base address. * param layerIndex Layer layerIndex. * param config Pointer to the configuration. */ void LCDIFV2_SetLayerBufferConfig(LCDIFV2_Type *base, uint8_t layerIndex, const lcdifv2_buffer_config_t *config) { assert(NULL != config); uint32_t reg; base->LAYER[layerIndex].CTRLDESCL3 = config->strideBytes; reg = base->LAYER[layerIndex].CTRLDESCL5; reg = (reg & ~(LCDIFV2_CTRLDESCL5_BPP_MASK | LCDIFV2_CTRLDESCL5_YUV_FORMAT_MASK)) | (uint32_t)config->pixelFormat; if (0U == (reg & LCDIFV2_CTRLDESCL5_AB_MODE_MASK)) { reg |= LCDIFV2_CTRLDESCL5_SAFETY_EN_MASK; } base->LAYER[layerIndex].CTRLDESCL5 = reg; } /*! * brief Set the LUT data. * * This function sets the specific layer LUT data, if useShadowLoad is true, * call LCDIFV2_TriggerLayerShadowLoad after this function, the * LUT will be loaded to the hardware during next vertical blanking period. * If useShadowLoad is false, the LUT data is loaded to hardware directly. * * param base LCDIF v2 peripheral base address. * param layerIndex Which layer to set. * param lutData The LUT data to load. * param count Count of lutData. * retval kStatus_Success Set success. * retval kStatus_Fail Previous LUT data is not loaded to hardware yet. */ status_t LCDIFV2_SetLut( LCDIFV2_Type *base, uint8_t layerIndex, const uint32_t *lutData, uint16_t count, bool useShadowLoad) { assert(count <= LCDIFV2_LUT_ENTRY_NUM); uint16_t i; status_t status; /* Previous setting is not updated. */ if ((base->CLUT_LOAD & LCDIFV2_CLUT_LOAD_CLUT_UPDATE_EN_MASK) != 0U) { status = kStatus_Fail; } else { if (useShadowLoad) { base->CLUT_LOAD = LCDIFV2_CLUT_LOAD_SEL_CLUT_NUM(layerIndex) | LCDIFV2_CLUT_LOAD_CLUT_UPDATE_EN_MASK; } else { base->CLUT_LOAD = LCDIFV2_CLUT_LOAD_SEL_CLUT_NUM(layerIndex); } for (i = 0; i < count; i++) { (LCDIFV2_LUT_MEM(base))[i + LCDIFV2_LUT_ENTRY_NUM * layerIndex] = lutData[i]; } status = kStatus_Success; } return status; } /*! * brief Set the layer alpha blend mode. * * param base LCDIFv2 peripheral base address. * param layerIndex Index of the CSC unit. * param config Pointer to the blend configuration. */ void LCDIFV2_SetLayerBlendConfig(LCDIFV2_Type *base, uint8_t layerIndex, const lcdifv2_blend_config_t *config) { assert(NULL != config); uint32_t reg; reg = base->LAYER[layerIndex].CTRLDESCL5; reg &= ~(LCDIFV2_CTRLDESCL5_GLOBAL_ALPHA_MASK | LCDIFV2_CTRLDESCL5_AB_MODE_MASK | LCDIFV2_CTRLDESCL5_PD_FACTOR_MODE_MASK | LCDIFV2_CTRLDESCL5_PD_ALPHA_MODE_MASK | LCDIFV2_CTRLDESCL5_PD_COLOR_MODE_MASK | LCDIFV2_CTRLDESCL5_PD_GLOBAL_ALPHA_MODE_MASK | LCDIFV2_CTRLDESCL5_SAFETY_EN_MASK); reg |= (LCDIFV2_CTRLDESCL5_GLOBAL_ALPHA(config->globalAlpha) | LCDIFV2_CTRLDESCL5_AB_MODE(config->alphaMode) | LCDIFV2_CTRLDESCL5_PD_FACTOR_MODE(config->pdFactorMode) | LCDIFV2_CTRLDESCL5_PD_ALPHA_MODE(config->pdAlphaMode) | LCDIFV2_CTRLDESCL5_PD_COLOR_MODE(config->pdColorMode) | LCDIFV2_CTRLDESCL5_PD_GLOBAL_ALPHA_MODE(config->pdGlobalAlphaMode)); if (config->alphaMode == kLCDIFV2_AlphaDisable) { reg |= LCDIFV2_CTRLDESCL5_SAFETY_EN_MASK; } base->LAYER[layerIndex].CTRLDESCL5 = reg; } /* * brief Get the blend configuration for Porter Duff blend. * * This is the basic Porter Duff blend configuration, user still could * modify the configurations after this function. * * param mode Porter Duff blend mode. * param layer The configuration for source layer or destination layer. * param config Pointer to the configuration. * retval kStatus_Success Get the configuration successfully. * retval kStatus_InvalidArgument The argument is invalid. */ status_t LCDIFV2_GetPorterDuffConfig(lcdifv2_pd_blend_mode_t mode, lcdifv2_pd_layer_t layer, lcdifv2_blend_config_t *config) { status_t status; if ((NULL == config) || (mode >= kLCDIFV2_PD_Max) || (layer >= kLCDIFV2_PD_LayerMax)) { status = kStatus_InvalidArgument; } else { config->pdAlphaMode = kLCDIFV2_PD_AlphaStraight; config->pdColorMode = kLCDIFV2_PD_ColorWithAlpha; config->pdGlobalAlphaMode = kLCDIFV2_PD_LocalAlpha; config->pdFactorMode = s_lcdifv2PdLayerFactors[mode][(uint8_t)layer]; config->alphaMode = kLCDIFV2_AlphaPoterDuff; status = kStatus_Success; } return status; } /* * brief Get the global alpha values for multiple layer blend. * * When all layers use the global alpha, the relationship blended alpha * and global alpha of each layer is: * * Layer 7: ba7 = ga7 * Layer 6: ba6 = ga6 * (1-ga7) * Layer 5: ba5 = ga5 * (1-ga6) * (1-ga7) * Layer 4: ba4 = ga4 * (1-ga5) * (1-ga6) * (1-ga7) * Layer 3: ba3 = ga3 * (1-ga4) * (1-ga5) * (1-ga6) * (1-ga7) * Layer 2: ba2 = ga2 * (1-ga3) * (1-ga4) * (1-ga5) * (1-ga6) * (1-ga7) * Layer 1: ba1 = ga1 * (1-ga2) * (1-ga3) * (1-ga4) * (1-ga5) * (1-ga6) * (1-ga7) * Layer 0: ba0 = 1 * (1-ga1) * (1-ga2) * (1-ga3) * (1-ga4) * (1-ga5) * (1-ga6) * (1-ga7) * * Here baN is the blended alpha of layer N, gaN is the global alpha configured to layer N. * * This function calculates the global alpha based on the blended alpha. The blendedAlpha and * globalAlpha are all arrays of size layerCount. The first layer is a background layer, * so blendedAlpha[0] is useless, globalAlpha[0] is always 255. * * param blendedAlpha The desired blended alpha value, alpha range 0~255. * param globalAlpha Calculated global alpha set to each layer register. * param layerCount Total layer count. * retval kStatus_Success Get successfully. * retval kStatus_InvalidArgument The argument is invalid. */ status_t LCDIFV2_GetMultiLayerGlobalAlpha(const uint8_t blendedAlpha[], uint8_t globalAlpha[], uint8_t layerCount) { status_t status = kStatus_Success; int16_t curLayer = (int16_t)layerCount - 1; int left = 255; int tmpAlpha; assert((layerCount > 1U) && (layerCount <= (uint8_t)LCDIFV2_LAYER_COUNT)); /* * Assume the layer counter is 7, and alpha range is 0~1, define: * * left_7 = 1 * left_i = (1-ga_(i+1)) * ... * (1-ga7) * * Then: * ba_i = ga_i * left_i * left_i = left_(i+1) - ba_i * ga_i = ba_i / left_i * * Now change alpha range to 0~255, then: * * ga_i = ba_i * 255 / left_i * left_i = left_(i+1) - ba_i */ globalAlpha[0] = 255U; while (curLayer > 0) { tmpAlpha = (int)blendedAlpha[curLayer] * 255 / left; if (tmpAlpha > 255) { status = kStatus_InvalidArgument; break; } globalAlpha[curLayer] = (uint8_t)tmpAlpha; left -= (int)blendedAlpha[curLayer]; if (left <= 0) { status = kStatus_InvalidArgument; break; } curLayer--; } return status; }