csl_dssVideoPort.h

Go to the documentation of this file.

/*
 *  Copyright (c) Texas Instruments Incorporated 2023
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef CSL_DSSVIDEOPORT_H_
#define CSL_DSSVIDEOPORT_H_
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
/* None */
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */
 
typedef CSL_dss_vp1Regs CSL_dss_vpRegs;
 
#define CSL_DSS_VP_CSC_POS_AFTER_GAMMA       \
                    ((uint32_t) CSL_DSS_VP1_CONFIG_COLORCONVPOS_VAL_AFTERGAMMA)
 
#define CSL_DSS_VP_CSC_POS_BEFORE_GAMMA      \
                    ((uint32_t) CSL_DSS_VP1_CONFIG_COLORCONVPOS_VAL_BEFOREGAMMA)
 
#define CSL_DSS_VP_TDM_UNUSED_BITS_LEVEL_LOW        \
                    ((uint32_t) CSL_DSS_VP1_CONTROL_TDMUNUSEDBITS_VAL_LOWLEVEL)
 
#define CSL_DSS_VP_TDM_UNUSED_BITS_LEVEL_HIGH       \
                    ((uint32_t) CSL_DSS_VP1_CONTROL_TDMUNUSEDBITS_VAL_HIGHLEVEL)
 
#define CSL_DSS_VP_TDM_UNUSED_BITS_LEVEL_UNCHANGED  \
                    ((uint32_t) CSL_DSS_VP1_CONTROL_TDMUNUSEDBITS_VAL_UNCHANGED)
 
#define CSL_DSS_VP_TDM_CYCLE_1PERPIXEL        \
                ((uint32_t) CSL_DSS_VP1_CONTROL_TDMCYCLEFORMAT_VAL_1CYCPERPIX)
 
#define CSL_DSS_VP_TDM_CYCLE_2PERPIXEL        \
                ((uint32_t) CSL_DSS_VP1_CONTROL_TDMCYCLEFORMAT_VAL_2CYCPERPIX)
 
#define CSL_DSS_VP_TDM_CYCLE_3PERPIXEL        \
                ((uint32_t) CSL_DSS_VP1_CONTROL_TDMCYCLEFORMAT_VAL_3CYCPERPIX)
 
#define CSL_DSS_VP_TDM_CYCLE_3PER2PIXEL       \
                ((uint32_t) CSL_DSS_VP1_CONTROL_TDMCYCLEFORMAT_VAL_3CYCPER2PIX)
 
#define CSL_DSS_VP_TDM_PARALLEL_OUTPUT_8BIT          \
                ((uint32_t) CSL_DSS_VP1_CONTROL_TDMPARALLELMODE_VAL_8BPARAINT)
 
#define CSL_DSS_VP_TDM_PARALLEL_OUTPUT_9BIT          \
                ((uint32_t) CSL_DSS_VP1_CONTROL_TDMPARALLELMODE_VAL_9BPARAINT)
 
#define CSL_DSS_VP_TDM_PARALLEL_OUTPUT_12BIT          \
                ((uint32_t) CSL_DSS_VP1_CONTROL_TDMPARALLELMODE_VAL_12BPARAINT)
 
#define CSL_DSS_VP_TDM_PARALLEL_OUTPUT_16BIT          \
                ((uint32_t) CSL_DSS_VP1_CONTROL_TDMPARALLELMODE_VAL_16BPARAINT)
 
#define CSL_DSS_VP_HVSYNC_NOT_ALIGNED              \
                    ((uint32_t) CSL_DSS_VP1_POL_FREQ_ALIGN_VAL_NOTALIGNED)
 
#define CSL_DSS_VP_HVSYNC_ALIGNED                  \
                    ((uint32_t) CSL_DSS_VP1_POL_FREQ_ALIGN_VAL_ALIGNED)
 
#define CSL_DSS_VP_HVCLK_CONTROL_OFF            \
                    ((uint32_t) CSL_DSS_VP1_POL_FREQ_ONOFF_VAL_DOPEDPCK)
 
#define CSL_DSS_VP_HVCLK_CONTROL_ON             \
                    ((uint32_t) CSL_DSS_VP1_POL_FREQ_ONOFF_VAL_DBIT16)
 
#define CSL_DSS_VP_LPP_DELTA_ZERO                 \
                    ((uint32_t) CSL_DSS_VP1_SIZE_SCREEN_DELTA_LPP_VAL_SAME)
 
#define CSL_DSS_VP_LPP_DELTA_PLUSONE              \
                    ((uint32_t) CSL_DSS_VP1_SIZE_SCREEN_DELTA_LPP_VAL_PLUSONE)
 
#define CSL_DSS_VP_LPP_DELTA_MINUSONE              \
                    ((uint32_t) CSL_DSS_VP1_SIZE_SCREEN_DELTA_LPP_VAL_MINUSONE)
 
#define CSL_DSS_VP_FID_FIRST_EVEN             \
                    ((uint32_t) CSL_DSS_VP1_CONFIG_FIDFIRST_VAL_EVEN)
 
#define CSL_DSS_VP_FID_FIRST_ODD              \
                    ((uint32_t) CSL_DSS_VP1_CONFIG_FIDFIRST_VAL_ODD)
 
#define CSL_DSS_VP_SAFETY_REGION_0                     ((uint32_t) 0x0U)
 
#define CSL_DSS_VP_SAFETY_REGION_1                     ((uint32_t) 0x1U)
 
#define CSL_DSS_VP_SAFETY_REGION_2                     ((uint32_t) 0x2U)
 
#define CSL_DSS_VP_SAFETY_REGION_3                     ((uint32_t) 0x3U)
 
#define CSL_DSS_VP_SAFETY_REGION_MAX                   ((uint32_t) 0x4U)
 
#define CSL_DSS_VP_SAFETY_REGION_INVALID               ((uint32_t) 0xFFU)
 
#define CSL_DSS_VP_OLDI_MAP_TYPE_A             \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_MAP_VAL_TYPE_A)
 
#define CSL_DSS_VP_OLDI_MAP_TYPE_B             \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_MAP_VAL_TYPE_B)
 
#define CSL_DSS_VP_OLDI_MAP_TYPE_C             \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_MAP_VAL_TYPE_C)
 
#define CSL_DSS_VP_OLDI_MAP_TYPE_D             \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_MAP_VAL_TYPE_D)
 
#define CSL_DSS_VP_OLDI_MAP_TYPE_E             \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_MAP_VAL_TYPE_E)
 
#define CSL_DSS_VP_OLDI_MAP_TYPE_F             \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_MAP_VAL_TYPE_F)
 
#define CSL_DSS_VP_OLDI_BIT_DEPTH_18_BITS             \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_MSB_VAL_18B)
 
#define CSL_DSS_VP_OLDI_BIT_DEPTH_24_BITS             \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_MSB_VAL_24B)
 
#define CSL_DSS_VP_OLDI_DUALMODESYNC_ENABLE            \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_DUALMODESYNC_VAL_ENABLE)
 
#define CSL_DSS_VP_OLDI_DUALMODESYNC_DISABLE            \
                    ((uint32_t) CSL_DSS_VP1_DSS_OLDI_CFG_DUALMODESYNC_VAL_DISABLE)
 
/* ========================================================================== */
/*                         Structure Declarations                             */
/* ========================================================================== */
 
typedef struct
{
    uint32_t gammaEnable;
    uint32_t gammaData[CSL_DSS_NUM_LUT_ENTRIES];
} CSL_DssVpGammaCfg;
 
typedef struct
{
    uint32_t tdmEnable;
    uint32_t tdmUnusedBitsLevel;
    uint32_t tdmCycleFormat;
    uint32_t tdmParallelMode;
    uint32_t numBitsPixel1Cycle0;
    uint32_t numBitsPixel1Cycle1;
    uint32_t numBitsPixel1Cycle2;
    uint32_t bitAlignPixel1Cycle0;
    uint32_t bitAlignPixel1Cycle1;
    uint32_t bitAlignPixel1Cycle2;
    uint32_t numBitsPixel2Cycle0;
    uint32_t numBitsPixel2Cycle1;
    uint32_t numBitsPixel2Cycle2;
    uint32_t bitAlignPixel2Cycle0;
    uint32_t bitAlignPixel2Cycle1;
    uint32_t bitAlignPixel2Cycle2;
} CSL_DssVpLcdTdmCfg;
 
typedef struct
{
    uint32_t actVidPolarity;
    uint32_t pixelClkPolarity;
    uint32_t hsPolarity;
    uint32_t vsPolarity;
} CSL_DssVpLcdSignalPolarityCfg;
 
typedef struct
{
    uint32_t hVAlign;
    uint32_t hVClkControl;
    uint32_t hVClkRiseFall;
    uint32_t acBI;
    uint32_t acB;
    uint32_t vSyncGated;
    uint32_t hSyncGated;
    uint32_t pixelClockGated;
    uint32_t pixelDataGated;
    uint32_t pixelGated;
} CSL_DssVpLcdAdvSignalCfg;
 
typedef struct
{
    Fvid2_ModeInfo mInfo;
    uint32_t dvoFormat;
    uint32_t cscRange;
    uint32_t videoIfWidth;
    uint32_t deltaLinesPerPanel;
    uint32_t fidFirst;
} CSL_DssVpLcdOpTimingCfg;
 
typedef struct
{
    uint32_t hFrontPorch;
    uint32_t hBackPorch;
    uint32_t hSyncLen;
    uint32_t vFrontPorch;
    uint32_t vBackPorch;
    uint32_t vSyncLen;
} CSL_DssVpLcdBlankTimingCfg;
 
typedef struct
{
    uint32_t oldiMapType;
    uint32_t dataEnablePolarity;
    uint32_t dssBitDepth;
    uint32_t dualModeSync;
} CSL_DssVpOldiCfg;
 
/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */
 
void CSL_dssVpEnable(CSL_dss_vpRegs *vpRegs, uint32_t enable);
 
void CSL_dssVpSetGoBit(CSL_dss_vpRegs *vpRegs);
 
void CSL_dssVpSetLcdTdmConfig(CSL_dss_vpRegs *vpRegs,
                              const CSL_DssVpLcdTdmCfg *lcdTdmCfg);
 
void CSL_dssVpSetLcdLineNum(CSL_dss_vpRegs *vpRegs,
                            uint32_t lineNum);
 
int32_t CSL_dssVpSetLcdOpTimingConfig(CSL_dss_vpRegs *vpRegs,
                                      const CSL_DssVpLcdOpTimingCfg *lcdCfg);
 
int32_t CSL_dssVpSetLcdBlankTiming(CSL_dss_vpRegs *vpRegs,
                                   const CSL_DssVpLcdBlankTimingCfg *blankCfg,
                                   uint32_t dvoFormat,
                                   uint32_t scanFormat,
                                   uint32_t isCustomTiming);
 
void CSL_dssVpSetLcdAdvSignalConfig(
                            CSL_dss_vpRegs *vpRegs,
                            const CSL_DssVpLcdAdvSignalCfg *advSignalCfg);
 
void CSL_dssVpSetLcdSignalPolarityConfig(
                            CSL_dss_vpRegs *vpRegs,
                            const CSL_DssVpLcdSignalPolarityCfg *polarityCfg);
 
void CSL_dssVpEnableTvGamma(CSL_dss_vpRegs *vpRegs,
                            const CSL_DssVpGammaCfg *gammaCfg);
 
void CSL_dssVpSetCSCCoeff(CSL_dss_vpRegs *vpRegs,
                          const CSL_DssCscCoeff *cscCoeff,
                          uint32_t cscPos,
                          uint32_t cscEnable);
 
void CSL_dssVpSetSafetySignSeedVal(CSL_dss_vpRegs *vpRegs,
                                   uint32_t signSeedVal);
 
void CSL_dssVpSetSafetyReferenceSign(CSL_dss_vpRegs *vpRegs,
                                     uint32_t referenceSign,
                                     uint32_t regionId);
 
void CSL_dssVpSetSafetyChkConfig(CSL_dss_vpRegs *vpRegs,
                                 const CSL_DssSafetyChkCfg *safetyCfg,
                                 uint32_t regionId);
 
uint32_t CSL_dssVpGetSafetySign(const CSL_dss_vpRegs *vpRegs,
                                uint32_t regionId);
 
void CSL_dssVpOldiReset(const CSL_dss_vpRegs *vpRegs);
 
void CSL_dssVpSetOldiConfig(CSL_dss_vpRegs *vpRegs,
                            const CSL_DssVpOldiCfg *oldiCfg);
 
void CSL_dssVpOldiEnable(CSL_dss_vpRegs *vpRegs, uint32_t enable);
 
/* ========================================================================== */
/*                      Static Function Declarations                          */
/* ========================================================================== */
 
static inline void CSL_dssVpGammaCfgInit(
    CSL_DssVpGammaCfg *gammaCfg);
 
static inline void CSL_dssVpLcdTdmCfgInit(
    CSL_DssVpLcdTdmCfg *tdmCfg);
 
static inline void CSL_dssVpLcdSignalPolarityCfgInit(
    CSL_DssVpLcdSignalPolarityCfg *polarityCfg);
 
static inline void CSL_dssVpLcdAdvSignalCfgInit(
    CSL_DssVpLcdAdvSignalCfg *advSignalCfg);
 
static inline void CSL_dssVpLcdOpTimingCfgInit(
    CSL_DssVpLcdOpTimingCfg *lcdCfg);
 
static inline void CSL_dssVpLcdBlankTimingCfgInit(
    CSL_DssVpLcdBlankTimingCfg *blankCfg);
 
static inline void CSL_dssVpOldiCfgInit(CSL_DssVpOldiCfg *oldiCfg);
 
/* ========================================================================== */
/*                       Static Function Definitions                          */
/* ========================================================================== */
 
static inline void CSL_dssVpGammaCfgInit(
    CSL_DssVpGammaCfg *gammaCfg)
{
    uint32_t i;
    if(NULL != gammaCfg)
    {
        gammaCfg->gammaEnable = FALSE;
        for(i=0U; i<CSL_DSS_NUM_LUT_ENTRIES; i++)
        {
            gammaCfg->gammaData[i] = 0U;
        }
    }
}
 
static inline void CSL_dssVpLcdTdmCfgInit(
    CSL_DssVpLcdTdmCfg *tdmCfg)
{
    if(NULL != tdmCfg)
    {
        tdmCfg->tdmEnable = FALSE;
        tdmCfg->tdmUnusedBitsLevel = CSL_DSS_VP_TDM_UNUSED_BITS_LEVEL_LOW;
        tdmCfg->tdmCycleFormat = CSL_DSS_VP_TDM_CYCLE_1PERPIXEL;
        tdmCfg->tdmParallelMode = CSL_DSS_VP_TDM_PARALLEL_OUTPUT_8BIT;
        tdmCfg->numBitsPixel1Cycle0 = 0x0U;
        tdmCfg->numBitsPixel1Cycle1 = 0x0U;
        tdmCfg->numBitsPixel1Cycle2 = 0x0U;
        tdmCfg->bitAlignPixel1Cycle0 = 0x0U;
        tdmCfg->bitAlignPixel1Cycle1 = 0x0U;
        tdmCfg->bitAlignPixel1Cycle2 = 0x0U;
        tdmCfg->numBitsPixel2Cycle0 = 0x0U;
        tdmCfg->numBitsPixel2Cycle1 = 0x0U;
        tdmCfg->numBitsPixel2Cycle2 = 0x0U;
        tdmCfg->bitAlignPixel2Cycle0 = 0x0U;
        tdmCfg->bitAlignPixel2Cycle1 = 0x0U;
        tdmCfg->bitAlignPixel2Cycle2 = 0x0U;
    }
}
 
static inline void CSL_dssVpLcdSignalPolarityCfgInit(
    CSL_DssVpLcdSignalPolarityCfg *polarityCfg)
{
    if(NULL != polarityCfg)
    {
        polarityCfg->actVidPolarity = FVID2_POL_HIGH;
        polarityCfg->pixelClkPolarity = FVID2_EDGE_POL_RISING;
        polarityCfg->hsPolarity = FVID2_POL_HIGH;
        polarityCfg->vsPolarity = FVID2_POL_HIGH;
    }
}
 
static inline void CSL_dssVpLcdAdvSignalCfgInit(
    CSL_DssVpLcdAdvSignalCfg *advSignalCfg)
{
    if(NULL != advSignalCfg)
    {
        advSignalCfg->hVAlign = CSL_DSS_VP_HVSYNC_NOT_ALIGNED;
        advSignalCfg->hVClkControl = CSL_DSS_VP_HVCLK_CONTROL_OFF;
        advSignalCfg->hVClkRiseFall = FVID2_EDGE_POL_FALLING;
        advSignalCfg->acBI = 0x0U;
        advSignalCfg->acB = 0x0U;
        advSignalCfg->vSyncGated = FALSE;
        advSignalCfg->hSyncGated = FALSE;
        advSignalCfg->pixelClockGated = FALSE;
        advSignalCfg->pixelDataGated = FALSE;
        advSignalCfg->pixelGated = FALSE;
    }
}
 
static inline void CSL_dssVpLcdOpTimingCfgInit(
    CSL_DssVpLcdOpTimingCfg *lcdCfg)
{
    if(NULL != lcdCfg)
    {
        Fvid2ModeInfo_init(&(lcdCfg->mInfo));
        lcdCfg->dvoFormat = FVID2_DV_GENERIC_DISCSYNC;
        lcdCfg->cscRange = CSL_DSS_CSC_RANGE_FULL;
        lcdCfg->videoIfWidth = FVID2_VIFW_12BIT;
        lcdCfg->deltaLinesPerPanel = CSL_DSS_VP_LPP_DELTA_ZERO;
        lcdCfg->fidFirst = CSL_DSS_VP_FID_FIRST_EVEN;
    }
}
 
static inline void CSL_dssVpLcdBlankTimingCfgInit(
    CSL_DssVpLcdBlankTimingCfg *blankCfg)
{
    if(NULL != blankCfg)
    {
        blankCfg->hFrontPorch = 0x0U;
        blankCfg->hBackPorch = 0x0U;
        blankCfg->hSyncLen = 0x0U;
        blankCfg->vFrontPorch = 0x0U;
        blankCfg->vBackPorch = 0x0U;
        blankCfg->vSyncLen = 0x0U;
    }
}
 
static inline void CSL_dssVpOldiCfgInit(CSL_DssVpOldiCfg *oldiCfg)
{
    if(NULL != oldiCfg)
    {
        oldiCfg->oldiMapType = CSL_DSS_VP_OLDI_MAP_TYPE_C;
        oldiCfg->dataEnablePolarity = FVID2_POL_HIGH;
        oldiCfg->dssBitDepth = CSL_DSS_VP_OLDI_BIT_DEPTH_24_BITS;
        oldiCfg->dualModeSync = CSL_DSS_VP_OLDI_DUALMODESYNC_DISABLE;
    }
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* #ifndef CSL_DSSVIDEOPORT_H_ */