dss_dctrl.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2023 Texas Instruments Incorporated
 *
 *  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 DSS_DCTRL_H_
#define DSS_DCTRL_H_
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
/* None */
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */
 
typedef void (*Dss_DctrlSyncLostCbFxn)(uint32_t vpId, void *appData);
 
typedef struct Dss_DctrlVpSafetyCbData_t Dss_DctrlVpSafetyCbData;
 
typedef void (*Dss_DctrlSafetyErrCbFxn)(uint32_t vpId,
                                        Dss_DctrlVpSafetyCbData safetyCbData,
                                        void *appData);
 
typedef void (*Dss_DctrlLineNumCbFxn)(uint32_t vpId, void *appData);
 
/*
 *  Display controller driver IOCTLs.
 */
 
#define IOCTL_DSS_DCTRL_SET_PATH              (DSS_DCTRL_IOCTL_BASE + 0x01U)
 
#define IOCTL_DSS_DCTRL_CLEAR_PATH            (DSS_DCTRL_IOCTL_BASE + 0x02U)
 
#define IOCTL_DSS_DCTRL_SET_VP_PARAMS         (DSS_DCTRL_IOCTL_BASE + 0x03U)
 
#define IOCTL_DSS_DCTRL_SET_OVERLAY_PARAMS    (DSS_DCTRL_IOCTL_BASE + 0x04U)
 
#define IOCTL_DSS_DCTRL_SET_LAYER_PARAMS      (DSS_DCTRL_IOCTL_BASE + 0x05U)
 
#define IOCTL_DSS_DCTRL_SET_VP_CSC_COEFF      (DSS_DCTRL_IOCTL_BASE + 0x06U)
 
#define IOCTL_DSS_DCTRL_SET_ADV_VP_PARAMS     (DSS_DCTRL_IOCTL_BASE + 0x07U)
 
#define IOCTL_DSS_DCTRL_SET_LCD_BLANK_TIMING_PARAMS   \
                                              (DSS_DCTRL_IOCTL_BASE + 0x08U)
 
#define IOCTL_DSS_DCTRL_SET_VP_SAFETY_CHK_PARAMS      \
                                              (DSS_DCTRL_IOCTL_BASE + 0x09U)
 
#define IOCTL_DSS_DCTRL_GET_VP_ERROR_STATS    (DSS_DCTRL_IOCTL_BASE + 0x0AU)
 
#define IOCTL_DSS_DCTRL_SET_GLOBAL_DSS_PARAMS (DSS_DCTRL_IOCTL_BASE + 0x0BU)
 
#define IOCTL_DSS_DCTRL_STOP_VP               (DSS_DCTRL_IOCTL_BASE + 0x0CU)
 
#define IOCTL_DSS_DCTRL_REGISTER_SYNCLOST_CB  (DSS_DCTRL_IOCTL_BASE + 0x0DU)
 
#define IOCTL_DSS_DCTRL_REGISTER_LINENUM_CB  (DSS_DCTRL_IOCTL_BASE + 0x0EU)
 
#define IOCTL_DSS_DCTRL_SET_DSI_PARAMS       (DSS_DCTRL_IOCTL_BASE + 0x0FU)
 
#define IOCTL_DSS_DCTRL_IS_DP_CONNECTED      (DSS_DCTRL_IOCTL_BASE + 0x10U)
 
/* ========================================================================== */
/*                         Structure Declarations                             */
/* ========================================================================== */
 
typedef struct
{
    uint32_t numEdges;
    Fvid2_GraphEdgeInfo edgeInfo[DSS_DCTRL_MAX_EDGES];
} Dss_DctrlPathInfo;
 
typedef struct
{
    uint32_t enabled;
    uint32_t isPrimary;
    uint32_t syncVpIds[CSL_DSS_VP_ID_MAX];
    uint32_t numSyncVpIds;
} Dss_DctrlSyncOpCfg;
 
typedef struct
{
    uint32_t vpId;
    CSL_DssVpLcdOpTimingCfg lcdOpTimingCfg;
    CSL_DssVpLcdSignalPolarityCfg lcdPolarityCfg;
    CSL_DssVpLcdTdmCfg lcdTdmCfg;
    Dss_DctrlSyncOpCfg syncOpCfg;
} Dss_DctrlVpParams;
 
typedef struct
{
    uint32_t overlayId;
    uint32_t colorbarEnable;
    CSL_DssOverlayCfg overlayCfg;
} Dss_DctrlOverlayParams;
 
typedef struct
{
    uint32_t overlayId;
    uint32_t pipeLayerNum[CSL_DSS_VID_PIPE_ID_MAX];
} Dss_DctrlOverlayLayerParams;
 
typedef struct
{
    uint32_t vpId;
    uint32_t cscPos;
    CSL_DssCscCoeff cscCoeff;
} Dss_DctrlVpCscCoeff;
 
typedef struct
{
    uint32_t vpId;
    CSL_DssVpLcdAdvSignalCfg lcdAdvSignalCfg;
} Dss_DctrlAdvVpParams;
 
typedef struct
{
    uint32_t vpId;
    uint32_t dvoFormat;
    CSL_DssVpLcdBlankTimingCfg lcdBlankTimingCfg;
} Dss_DctrlLcdBlankTimingParams;
 
typedef struct
{
    uint32_t regionId;
    uint32_t referenceSign;
    CSL_DssSafetyChkCfg safetyChkCfg;
} Dss_DctrlRegionSafetyChkCfg;
 
struct Dss_DctrlVpSafetyCbData_t
{
    uint32_t regionId;
    uint32_t capturedSign;
};
 
typedef struct
{
    uint32_t vpId;
    uint32_t safetySignSeedVal;
    Dss_DctrlRegionSafetyChkCfg regionSafetyChkCfg;
    Dss_DctrlSafetyErrCbFxn safetyErrCbFxn;
    Dss_DctrlVpSafetyCbData safetyCbData;
    void *appData;
} Dss_DctrlVpSafetyChkParams;
 
typedef struct
{
    uint32_t vpId;
    uint32_t syncLost;
    uint32_t safetyViolation[CSL_DSS_VP_SAFETY_REGION_MAX];
    uint32_t securityViolation;
} Dss_DctrlVpErrorStats;
 
typedef struct
{
    CSL_DssGlobalMFlagCfg globalMflagCfg;
    CSL_DssCbaCfg cbaCfg;
} Dss_DctrlGlobalDssParams;
 
typedef struct
{
    uint32_t vpId;
    Dss_DctrlSyncLostCbFxn syncLostCbFxn;
    void *appData;
} Dss_DctrlSyncLostCbParams;
 
typedef struct
{
    uint32_t vpId;
    Dss_DctrlLineNumCbFxn lineNumCbFxn;
    void *appData;
} Dss_DctrlLineNumCbParams;
 
typedef struct
{
    uint32_t instId;
    uint32_t numOfLanes;
    uint32_t laneSpeedInKbps;
} Dss_DctrlDsiParams;
 
/* ========================================================================== */
/*                  Internal/Private Function Declarations                    */
/* ========================================================================== */
 
static inline void Dss_dctrlPathInfoInit(Dss_DctrlPathInfo *pathInfo);
 
static inline void Dss_dctrlVpParamsInit(Dss_DctrlVpParams *vpParams);
 
static inline void Dss_dctrlOverlayParamsInit(
    Dss_DctrlOverlayParams *overlayParams);
 
static inline void Dss_dctrlOverlayLayerParamsInit(
    Dss_DctrlOverlayLayerParams *layerParams);
 
static inline void Dss_dctrlAdvVpParamsInit(Dss_DctrlAdvVpParams *advVpParams);
 
static inline void Dss_dctrlLcdBlankTimingParamsInit(
    Dss_DctrlLcdBlankTimingParams *lcdBlankTimingParams);
 
static inline void Dss_dctrlRegionSafetyChkCfgInit(
    Dss_DctrlRegionSafetyChkCfg *regionSafetyChkCfg);
 
static inline void Dss_dctrlVpSafetyCbDataInit(
    Dss_DctrlVpSafetyCbData *safetyCbData);
 
static inline void Dss_dctrlVpSafetyChkParamsInit(
    Dss_DctrlVpSafetyChkParams *vpSafetyChkParams);
 
static inline void Dss_dctrlVpErrorStatsInit(
    Dss_DctrlVpErrorStats *vpErrorStats);
 
static inline void Dss_dctrlGlobalDssParamsInit(
    Dss_DctrlGlobalDssParams *globalDssParams);
 
static inline void Dss_dctrlSyncLostCbParamsInit(
    Dss_DctrlSyncLostCbParams *syncLostCbParams);
 
static inline void Dss_dctrlLineNumCbParamsInit(
    Dss_DctrlLineNumCbParams *lineNumCbParams);
 
/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */
 
/* None */
 
/* ========================================================================== */
/*                       Static Function Definitions                          */
/* ========================================================================== */
 
static inline void Dss_dctrlPathInfoInit(Dss_DctrlPathInfo *pathInfo)
{
    uint32_t i;
    if(NULL != pathInfo)
    {
        pathInfo->numEdges = 0U;
        for(i=0U; i<DSS_DCTRL_MAX_EDGES; i++)
        {
            pathInfo->edgeInfo[i].startNode = 0U;
            pathInfo->edgeInfo[i].endNode = 0U;
        }
    }
}
 
static inline void Dss_DctrlSyncOpCfgInit(Dss_DctrlSyncOpCfg *syncOpCfg)
{
    uint32_t i;
 
    if(NULL != syncOpCfg)
    {
        syncOpCfg->enabled = FALSE;
        syncOpCfg->isPrimary = TRUE;
        for(i = 0; i < CSL_DSS_VP_ID_MAX; i++)
        {
            syncOpCfg->syncVpIds[i] = CSL_DSS_VP_ID_1;
        }
        syncOpCfg->numSyncVpIds = 0;
    }
}
 
static inline void Dss_dctrlVpParamsInit(Dss_DctrlVpParams *vpParams)
{
    if(NULL != vpParams)
    {
        vpParams->vpId = CSL_DSS_VP_ID_1;
        CSL_dssVpLcdOpTimingCfgInit(&(vpParams->lcdOpTimingCfg));
        CSL_dssVpLcdSignalPolarityCfgInit(&(vpParams->lcdPolarityCfg));
        CSL_dssVpLcdTdmCfgInit(&(vpParams->lcdTdmCfg));
        Dss_DctrlSyncOpCfgInit(&(vpParams->syncOpCfg));
    }
}
 
static inline void Dss_dctrlOverlayParamsInit(
    Dss_DctrlOverlayParams *overlayParams)
{
    if(NULL != overlayParams)
    {
        overlayParams->overlayId = CSL_DSS_OVERLAY_ID_1;
        overlayParams->colorbarEnable = FALSE;
        CSL_dssOverlayCfgInit(&(overlayParams->overlayCfg));
    }
}
 
static inline void Dss_dctrlOverlayLayerParamsInit(
    Dss_DctrlOverlayLayerParams *layerParams)
{
    uint32_t i;
    if(NULL != layerParams)
    {
        layerParams->overlayId = CSL_DSS_OVERLAY_ID_1;
        for(i=0U; i<CSL_DSS_VID_PIPE_ID_MAX; i++)
        {
            layerParams->pipeLayerNum[i] = CSL_DSS_OVERLAY_LAYER_INVALID;
        }
    }
}
 
static inline void Dss_dctrlAdvVpParamsInit(Dss_DctrlAdvVpParams *advVpParams)
{
    if(NULL != advVpParams)
    {
        advVpParams->vpId = CSL_DSS_VP_ID_1;
        CSL_dssVpLcdAdvSignalCfgInit(&(advVpParams->lcdAdvSignalCfg));
    }
}
 
static inline void Dss_dctrlLcdBlankTimingParamsInit(
    Dss_DctrlLcdBlankTimingParams *lcdBlankTimingParams)
{
    if(NULL != lcdBlankTimingParams)
    {
        lcdBlankTimingParams->vpId = CSL_DSS_VP_ID_1;
        CSL_dssVpLcdBlankTimingCfgInit(&(lcdBlankTimingParams->lcdBlankTimingCfg));
    }
}
 
static inline void Dss_dctrlRegionSafetyChkCfgInit(
    Dss_DctrlRegionSafetyChkCfg *regionSafetyChkCfg)
{
    if(NULL != regionSafetyChkCfg)
    {
        regionSafetyChkCfg->regionId = CSL_DSS_VP_SAFETY_REGION_0;
        regionSafetyChkCfg->referenceSign = 0U;
        CSL_dssSafetyChkCfgInit(&(regionSafetyChkCfg->safetyChkCfg));
    }
}
 
static inline void Dss_dctrlVpSafetyCbDataInit(
    Dss_DctrlVpSafetyCbData *safetyCbData)
{
    if(NULL != safetyCbData)
    {
        safetyCbData->regionId = CSL_DSS_VP_SAFETY_REGION_0;
        safetyCbData->capturedSign = 0U;
    }
}
 
static inline void Dss_dctrlVpSafetyChkParamsInit(
    Dss_DctrlVpSafetyChkParams *vpSafetyChkParams)
{
    if(NULL != vpSafetyChkParams)
    {
        vpSafetyChkParams->vpId = CSL_DSS_VP_ID_1;
        vpSafetyChkParams->safetySignSeedVal = 0U;
        Dss_dctrlRegionSafetyChkCfgInit(&(vpSafetyChkParams->regionSafetyChkCfg));
        vpSafetyChkParams->safetyErrCbFxn = NULL;
        Dss_dctrlVpSafetyCbDataInit(&(vpSafetyChkParams->safetyCbData));
        vpSafetyChkParams->appData = NULL;
    }
}
 
static inline void Dss_dctrlVpErrorStatsInit(Dss_DctrlVpErrorStats *vpErrorStats)
{
     uint32_t i;
    if(NULL != vpErrorStats)
    {
        vpErrorStats->vpId = CSL_DSS_VP_ID_1;
        vpErrorStats->syncLost = 0U;
        for(i=0U; i<CSL_DSS_VP_SAFETY_REGION_MAX; i++)
        {
            vpErrorStats->safetyViolation[i] = 0U;
        }
        vpErrorStats->securityViolation = 0U;
    }
}
 
static inline void Dss_dctrlGlobalDssParamsInit(
    Dss_DctrlGlobalDssParams *globalDssParams)
{
    if(NULL != globalDssParams)
    {
        CSL_dssGlobalMFlagCfgInit(&(globalDssParams->globalMflagCfg));
        CSL_dssCbaCfgInit(&(globalDssParams->cbaCfg));
    }
}
 
static inline void Dss_dctrlSyncLostCbParamsInit(
    Dss_DctrlSyncLostCbParams *syncLostCbParams)
{
    if(NULL != syncLostCbParams)
    {
        syncLostCbParams->vpId = CSL_DSS_VP_ID_1;
        syncLostCbParams->syncLostCbFxn = NULL;
        syncLostCbParams->appData = NULL;
    }
}
 
static inline void Dss_dctrlLineNumCbParamsInit(
    Dss_DctrlLineNumCbParams *lineNumCbParams)
{
    if(NULL != lineNumCbParams)
    {
        lineNumCbParams->vpId = CSL_DSS_VP_ID_1;
        lineNumCbParams->lineNumCbFxn = NULL;
        lineNumCbParams->appData = NULL;
    }
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* #ifndef DSS_DCTRL_H_ */