csl_dssVideoPipe.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_DSSVIDEOPIPE_H_
#define CSL_DSSVIDEOPIPE_H_
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
/* None */
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */
 
typedef CSL_dss_vidRegs CSL_dss_pipeRegs;
 
#define CSL_DSS_VID_PIPE_YUV_ALIGN_LSB              \
        ((uint32_t) CSL_DSS_VID_ATTRIBUTES2_YUV_ALIGN_VAL_LSB)
 
#define CSL_DSS_VID_PIPE_YUV_ALIGN_MSB              \
        ((uint32_t) CSL_DSS_VID_ATTRIBUTES2_YUV_ALIGN_VAL_MSB)
 
#define CSL_DSS_VID_PIPE_SC_DISABLED              \
        ((uint32_t) CSL_DSS_VID_ATTRIBUTES_RESIZEENABLE_VAL_RESIZEPROC)
 
#define CSL_DSS_VID_PIPE_SC_ENABLED_H             \
        ((uint32_t) CSL_DSS_VID_ATTRIBUTES_RESIZEENABLE_VAL_HRESIZE)
 
#define CSL_DSS_VID_PIPE_SC_ENABLED_V             \
        ((uint32_t) CSL_DSS_VID_ATTRIBUTES_RESIZEENABLE_VAL_VRESIZE)
 
#define CSL_DSS_VID_PIPE_SC_ENABLED_HV            \
        ((uint32_t) CSL_DSS_VID_ATTRIBUTES_RESIZEENABLE_VAL_HVRESIZE)
 
#define CSL_DSS_VID_PIPE_PRELOAD_CONTROL_SW             \
                    ((uint32_t) CSL_DSS_VID_ATTRIBUTES_BUFPRELOAD_VAL_DEFVAL)
 
#define CSL_DSS_VID_PIPE_PRELOAD_CONTROL_HW             \
                    ((uint32_t) CSL_DSS_VID_ATTRIBUTES_BUFPRELOAD_VAL_HIGHTHRES)
 
#define CSL_DSS_VID_PIPE_PRIORITY_NORMAL       \
                  ((uint32_t) CSL_DSS_VID_ATTRIBUTES_ARBITRATION_VAL_NORMALPRIO)
 
#define CSL_DSS_VID_PIPE_PRIORITY_HIGH         \
                  ((uint32_t) CSL_DSS_VID_ATTRIBUTES_ARBITRATION_VAL_HIGHPRIO)
 
#define CSL_DSS_VID_PIPE_REFRESH_CONTROL_SW       \
      ((uint32_t) CSL_DSS_VID_ATTRIBUTES_SELFREFRESHAUTO_VAL_SELFREFRESHAUTODIS)
 
#define CSL_DSS_VID_PIPE_REFRESH_CONTROL_HW       \
      ((uint32_t) CSL_DSS_VID_ATTRIBUTES_SELFREFRESHAUTO_VAL_SELFREFRESHAUTOEN)
 
/* ========================================================================== */
/*                         Structure Declarations                             */
/* ========================================================================== */
 
typedef struct
{
    uint32_t pipeType;
    Fvid2_Format inFmt;
    uint32_t pixelInc;
    uint32_t yuvAlign;
    uint32_t outWidth;
    uint32_t outHeight;
    uint32_t scEnable;
    uint32_t cscRange;
    CSL_DssCscCoeff custCscCoeff;
    uint32_t flipType;
    uint32_t clutData[CSL_DSS_NUM_LUT_ENTRIES];
    uint32_t nibbleModeEnable;
    uint32_t gammaEnable;
} CSL_DssVidPipeCfg;
 
typedef struct
{
    uint32_t bufPreloadControl;
    uint32_t preloadVal;
    uint32_t bufLowThreshold;
    uint32_t bufHighThreshold;
    uint32_t selfRefreshControl;
    uint32_t selfRefreshEnable;
    uint32_t arbitration;
} CSL_DssVidPipeDmaCfg;
 
typedef struct
{
    uint32_t lumaKeyEnable;
    uint32_t lumaKeyMinVal;
    uint32_t lumaKeyMaxVal;
} CSL_DssVidPipeLumaCfg;
 
typedef struct
{
    uint32_t globalAlpha;
    uint32_t preMultiplyAlpha;
} CSL_DssVidPipeAlphaCfg;
 
typedef struct
{
    uint32_t vc1Enable;
    uint32_t rangeY;
    uint32_t rangeUV;
} CSL_DssVidPipeVC1Cfg;
 
typedef struct
{
    uint32_t thresholdLow;
    uint32_t thresholdHigh;
} CSL_DssVidPipeMFlagCfg;
 
/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */
 
int32_t CSL_dssVidPipeSetConfig(CSL_dss_pipeRegs *pipeRegs,
                                const CSL_DssVidPipeCfg *pipeCfg,
                                const CSL_DssVidPipeVC1Cfg *vc1Cfg);
 
void CSL_dssVidPipeSetDmaConfig(CSL_dss_pipeRegs *pipeRegs,
                                const CSL_DssVidPipeDmaCfg *dmaCfg);
 
void CSL_dssVidPipeEnableTransparency(CSL_dss_pipeRegs *pipeRegs,
                                      const CSL_DssVidPipeLumaCfg *lumaCfg);
 
void CSL_dssVidPipeSetAlphaConfig(CSL_dss_pipeRegs *pipeRegs,
                                  const CSL_DssVidPipeAlphaCfg *alphaCfg);
 
void CSL_dssVidPipeSetCSCCoeff(CSL_dss_pipeRegs *pipeRegs,
                               const CSL_DssCscCoeff *coeff);
 
void CSL_dssVidPipeSetBuffAddr(CSL_dss_pipeRegs *pipeRegs,
                               uint32_t field,
                               uint64_t baseAddrRGBY,
                               uint64_t baseAddrUV);
 
void CSL_dssVidPipeEnable(CSL_dss_pipeRegs *pipeRegs, uint32_t enable);
 
void CSL_dssVidPipeSetSafetySignSeedVal(CSL_dss_pipeRegs *pipeRegs,
                                        uint32_t signSeedVal);
 
void CSL_dssVidPipeSetSafetyReferenceSign(CSL_dss_pipeRegs *pipeRegs,
                                          uint32_t referenceSign);
 
void CSL_dssVidPipeSetSafetyChkConfig(CSL_dss_pipeRegs *pipeRegs,
                                      const CSL_DssSafetyChkCfg *safetyCfg);
 
uint32_t CSL_dssVidPipeGetSafetySign(const CSL_dss_pipeRegs *pipeRegs);
 
void CSL_dssVidPipeSetMflagConfig(CSL_dss_pipeRegs *pipeRegs,
                                  const CSL_DssVidPipeMFlagCfg *mflagCfg);
 
/* ========================================================================== */
/*                      Static Function Declarations                          */
/* ========================================================================== */
 
static inline void CSL_dssVidPipeCfgInit(
    CSL_DssVidPipeCfg *pipeCfg);
 
static inline void CSL_dssVidPipeDmaCfgInit(
    CSL_DssVidPipeDmaCfg *dmaCfg);
 
static inline void CSL_dssVidPipeLumaCfgInit(
    CSL_DssVidPipeLumaCfg *lumaCfg);
 
static inline void CSL_dssVidPipeAlphaCfgInit(
    CSL_DssVidPipeAlphaCfg *alphaCfg);
 
static inline void CSL_dssVidPipeVC1CfgInit(
    CSL_DssVidPipeVC1Cfg *vc1Cfg);
 
static inline void CSL_dssVidPipeMFlagCfgInit(
    CSL_DssVidPipeMFlagCfg *mflagCfg);
 
/* ========================================================================== */
/*                       Static Function Definitions                          */
/* ========================================================================== */
 
static inline void CSL_dssVidPipeCfgInit(
    CSL_DssVidPipeCfg *pipeCfg)
{
    uint32_t i;
    if(NULL != pipeCfg)
    {
        Fvid2Format_init(&pipeCfg->inFmt);
        pipeCfg->pipeType         = CSL_DSS_VID_PIPE_TYPE_VID;
        pipeCfg->pixelInc         = 1U;
        pipeCfg->yuvAlign         = CSL_DSS_VID_PIPE_YUV_ALIGN_LSB;
        pipeCfg->outWidth         = 800U;
        pipeCfg->outHeight        = 480U;
        pipeCfg->scEnable         = CSL_DSS_VID_PIPE_SC_DISABLED;
        pipeCfg->cscRange         = CSL_DSS_CSC_RANGE_FULL;
        CSL_dssCscCoeffInit(&pipeCfg->custCscCoeff);
        pipeCfg->custCscCoeff.cscRange = CSL_DSS_CSC_RANGE_CUSTOM;
        pipeCfg->flipType         = FVID2_FLIP_TYPE_NONE;
        for(i=0U; i<CSL_DSS_NUM_LUT_ENTRIES; i++)
        {
            pipeCfg->clutData[i] = 0x0U;
        }
        pipeCfg->nibbleModeEnable = FALSE;
        pipeCfg->gammaEnable      = FALSE;
    }
}
 
static inline void CSL_dssVidPipeDmaCfgInit(
    CSL_DssVidPipeDmaCfg *dmaCfg)
{
    if(NULL != dmaCfg)
    {
        dmaCfg->bufPreloadControl  = CSL_DSS_VID_PIPE_PRELOAD_CONTROL_HW;
        dmaCfg->bufLowThreshold    = 0x09FFU;
        dmaCfg->bufHighThreshold   = 0x09F8U;
        dmaCfg->selfRefreshControl = CSL_DSS_VID_PIPE_REFRESH_CONTROL_SW;
        dmaCfg->selfRefreshEnable  = FALSE;
        dmaCfg->arbitration        = CSL_DSS_VID_PIPE_PRIORITY_NORMAL;
    }
}
 
static inline void CSL_dssVidPipeLumaCfgInit(
    CSL_DssVidPipeLumaCfg *lumaCfg)
{
    if(NULL != lumaCfg)
    {
        lumaCfg->lumaKeyEnable = FALSE;
        lumaCfg->lumaKeyMinVal = 0U;
        lumaCfg->lumaKeyMaxVal = 0U;
    }
}
 
static inline void CSL_dssVidPipeAlphaCfgInit(
    CSL_DssVidPipeAlphaCfg *alphaCfg)
{
    if(NULL != alphaCfg)
    {
        alphaCfg->globalAlpha      = 0xFFU;
        alphaCfg->preMultiplyAlpha = FALSE;
    }
}
 
static inline void CSL_dssVidPipeVC1CfgInit(
    CSL_DssVidPipeVC1Cfg *vc1Cfg)
{
    if(NULL != vc1Cfg)
    {
        vc1Cfg->vc1Enable = FALSE;
        vc1Cfg->rangeY    = 0U;
        vc1Cfg->rangeUV   = 0U;
    }
}
 
static inline void CSL_dssVidPipeMFlagCfgInit(
    CSL_DssVidPipeMFlagCfg *mflagCfg)
{
    if(NULL != mflagCfg)
    {
        mflagCfg->thresholdLow  = 0U;
        mflagCfg->thresholdHigh = 0U;
    }
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* #ifndef CSL_DSSVIDEOPIPE_H_ */