packages/ti/drv/dss/src/drv/dctrl/dss_dctrlApi.c

   1 /*
   2  *  Copyright (c) Texas Instruments Incorporated 2018
   3  *  All rights reserved.
   4  *
   5  *  Redistribution and use in source and binary forms, with or without
   6  *  modification, are permitted provided that the following conditions
   7  *  are met:
   8  *
   9  *    Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  *    Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  *    Neither the name of Texas Instruments Incorporated nor the names of
  18  *    its contributors may be used to endorse or promote products derived
  19  *    from this software without specific prior written permission.
  20  *
  21  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 /**
  35  *  \file dss_dctrlApi.c
  36  *
  37  *  \brief File containing the DSS Controller driver implementation.
  38  *
  39  */
  40
  41 /* ========================================================================== */
  42 /*                             Include Files                                  */
  43 /* ========================================================================== */
  44
  45 #include <ti/drv/dss/dss.h>
  46 #include <ti/drv/dss/src/drv/common/dss_evtMgr.h>
  47 #include <ti/drv/dss/src/drv/dctrl/dss_dctrlDrv.h>
  48 #include <ti/drv/dss/src/drv/dctrl/dss_dctrlIntr.h>
  49 #include <ti/drv/dss/src/drv/dctrl/dss_dctrlPriv.h>
  50 #include <dss_soc_priv.h>
  51
  52 /* ========================================================================== */
  53 /*                           Macros & Typedefs                                */
  54 /* ========================================================================== */
  55
  56 /* None */
  57
  58 /* ========================================================================== */
  59 /*                         Structure Declarations                             */
  60 /* ========================================================================== */
  61
  62 /* None */
  63
  64 /* ========================================================================== */
  65 /*                          Function Declarations                             */
  66 /* ========================================================================== */
  67
  68 /**
  69  *  Below ifdef __cplusplus is added so that C++ build passes without
  70  *  typecasting. This is because the prototype is build as C type
  71  *  whereas this file is build as CPP file. Hence we get C++ build error.
  72  *  Also if typecasting is used, then we get MisraC error Rule 11.1.
  73  */
  74 #ifdef __cplusplus
  75 extern "C" {
  76 #endif
  77 /*
  78  * Display Controller APIs
  79  */
  80 static Fdrv_Handle Dss_dctrlDrvCreate(uint32_t drvId,
  81                                       uint32_t instId,
  82                                       void *createArgs,
  83                                       void *createStatusArgs,
  84                                       const Fvid2_DrvCbParams *fdmCbParams);
  85 static int32_t Dss_dctrlDrvDelete(Fdrv_Handle handle, void *reserved);
  86 static int32_t Dss_dctrlDrvControl(Fdrv_Handle handle,
  87                                    uint32_t cmd,
  88                                    void *cmdArgs,
  89                                    void *cmdStatusArgs);
  90 #ifdef __cplusplus
  91 }
  92 #endif
  93
  94 /* ========================================================================== */
  95 /*                            Global Variables                                */
  96 /* ========================================================================== */
  97
  98 Dss_DctrlDrvCommonObj gDss_DctrlDrvCommonObj;
  99 Dss_DctrlDrvInstObj   gDss_DctrlDrvInstObj;
 100
 101 Dss_DctrlDrvGraphObj gDss_DctrlDrvGraphObj;
 102 Dss_DctrlDrvInfo gDss_DctrlDrvInfo;
 103 Dss_EvtMgrClientInfo gDss_DctrlEvtMgrClientInfo[DSS_DCTRL_EVT_MGR_MAX_CLIENTS];
 104
 105 /* ========================================================================== */
 106 /*                  Internal/Private Function Declarations                    */
 107 /* ========================================================================== */
 108
 109 static int32_t Dss_dctrlDrvSetPathIoctl(Dss_DctrlDrvInstObj *instObj,
 110                                         const Dss_DctrlPathInfo *pathInfo);
 111 static int32_t Dss_dctrlDrvClearPathIoctl(Dss_DctrlDrvInstObj *instObj,
 112                                           const Dss_DctrlPathInfo *pathInfo);
 113 static int32_t Dss_dctrlDrvSetVpParamsIoctl(
 114                             Dss_DctrlDrvInstObj *instObj,
 115                             const Dss_DctrlVpParams *vpParams);
 116 static int32_t Dss_dctrlDrvSetOverlayParamsIoctl(
 117                             Dss_DctrlDrvInstObj *instObj,
 118                             const Dss_DctrlOverlayParams *overlayParams);
 119 static int32_t Dss_dctrlDrvSetLayerParamsIoctl(
 120                             Dss_DctrlDrvInstObj *instObj,
 121                             const Dss_DctrlOverlayLayerParams *layerParams);
 122 static int32_t Dss_dctrlDrvSetVpCscCoeffIoctl(
 123                             Dss_DctrlDrvInstObj *instObj,
 124                             const Dss_DctrlVpCscCoeff *vpCscCoeff);
 125 static int32_t Dss_dctrlDrvSetAdvVpParamsIoctl(
 126                             Dss_DctrlDrvInstObj *instObj,
 127                             const Dss_DctrlAdvVpParams *advVpParams);
 128 static int32_t Dss_dctrlDrvSetLcdBlankTimingIoctl(
 129                             Dss_DctrlDrvInstObj *instObj,
 130                             const Dss_DctrlLcdBlankTimingParams *timingParams);
 131 static int32_t Dss_dctrlDrvSetVpSafetyChkParamsIoctl(
 132                             Dss_DctrlDrvInstObj *instObj,
 133                             const Dss_DctrlVpSafetyChkParams *safetyChkParams);
 134 static int32_t Dss_dctrlDrvGetErrorStatsIoctl(
 135                             Dss_DctrlDrvInstObj *instObj,
 136                             Dss_DctrlVpErrorStats *vpErrStats);
 137 static int32_t Dss_dctrlDrvSetGlobalDssParamsIoctl(
 138                             Dss_DctrlDrvInstObj *instObj,
 139                             const Dss_DctrlGlobalDssParams *globalDssParams);
 140 static int32_t Dss_dctrlDrvStopVpIoctl(Dss_DctrlDrvInstObj *instObj,
 141                                        const Dss_DctrlVpParams *vpParams);
 142 static int32_t Dss_dctrlDrvSetSyncLostCbParamsIoctl(
 143                             Dss_DctrlDrvInstObj *instObj,
 144                             const Dss_DctrlSyncLostCbParams *syncLostCbParams);
 145 static int32_t Dss_dctrlDrvSetLineNumCbParamsIoctl(
 146                             Dss_DctrlDrvInstObj *instObj,
 147                             const Dss_DctrlLineNumCbParams *lineNumCbParams);
 148 static void Dss_dctrlFuncCbFxn(const uint32_t *event,
 149                                uint32_t numEvents,
 150                                void *arg);
 151 static void Dss_dctrlErrCbFxn(const uint32_t *event,
 152                               uint32_t numEvents,
 153                               void *arg);
 154 static void Dss_dctrlSafetyErrCbFxn(const uint32_t *event,
 155                                     uint32_t numEvents,
 156                                     void *arg);
 157 static int32_t Dss_dctrlConnectNodes(uint32_t inputNode, uint32_t outNode);
 158
 159 #if defined (SOC_AM65XX)
 160 static int32_t Dss_dctrlDrvSetOldiParamsIoctl(
 161                             Dss_DctrlDrvInstObj *instObj,
 162                             const Dss_DctrlOldiParams *oldiParams);
 163 #endif
 164 #if defined (SOC_J721E)
 165 static uint32_t Dss_dctrlDrvIsOutputDP(uint32_t vpId);
 166 static int32_t Dss_dctrlDrvSetDpHpdCbParamsIoctl(
 167                             Dss_DctrlDrvInstObj *instObj,
 168                             const Dss_DctrlDpHpdCbParams *dpHpdCbParams);
 169 static int32_t Dss_dctrlDrvProcessDpHpdIoctl(
 170                             Dss_DctrlDrvInstObj *instObj,
 171                             const uint32_t *dpProcessHpdParams);
 172 #endif
 173
 174 static void Dss_dctrlVpSetGoBit(uint32_t vpId);
 175 static void Dss_dctrlVpReset(uint32_t vpId);
 176 static void Dss_dctrlVpEnable(uint32_t vpId, uint32_t enable);
 177
 178 /* ========================================================================== */
 179 /*                          Function Definitions                              */
 180 /* ========================================================================== */
 181
 182 int32_t Dss_dctrlDrvInit(const Dss_DctrlDrvInitParams *drvInitParams)
 183 {
 184     int32_t retVal = FVID2_SOK;
 185     uint32_t i, cnt, eventGroup, vpId, numHandle, numEvents, evtMgrId;
 186     uint32_t enabledEvents[DSS_EVT_MGR_MAX_CLIENT_EVENTS];
 187     Dss_DctrlDrvInfo *pDrvInfo;
 188     Dss_DctrlDrvCommonObj *pObj;
 189     Dss_DctrlDrvGraphObj *pGraphObj;
 190     Dss_DctrlDrvInstObj *pDrvInstObj;
 191     Dss_EvtMgrClientInfo *pClientInfo;
 192     SemaphoreP_Params semParams;
 193
 194     pDrvInfo = &gDss_DctrlDrvInfo;
 195     pObj = &gDss_DctrlDrvCommonObj;
 196     pGraphObj = &gDss_DctrlDrvGraphObj;
 197     pDrvInstObj = &gDss_DctrlDrvInstObj;
 198
 199     Fvid2Utils_memset(pObj, 0U, sizeof (Dss_DctrlDrvCommonObj));
 200     Fvid2Utils_memset(pGraphObj, 0U, sizeof (Dss_DctrlDrvGraphObj));
 201     Fvid2Utils_memset(pDrvInfo, 0U, sizeof (Dss_DctrlDrvInfo));
 202     Fvid2Utils_memset(pDrvInstObj, 0U, sizeof (Dss_DctrlDrvInstObj));
 203
 204     for(i=0U; i<DSS_DCTRL_EVT_MGR_MAX_CLIENTS; i++)
 205     {
 206         pClientInfo = &gDss_DctrlEvtMgrClientInfo[i];
 207         Fvid2Utils_memset(pClientInfo, 0U, sizeof (Dss_EvtMgrClientInfo));
 208     }
 209     /* Initialize instance object members */
 210     pObj->instObj = &gDss_DctrlDrvInstObj;
 211     pObj->instObj->drvInstId = drvInitParams->drvInstId;
 212
 213     /* Initialize graph object */
 214     (void) Dss_dctrlDrvGraphInit(pGraphObj);
 215
 216     if(FVID2_SOK == retVal)
 217     {
 218         /* Allocate instance semaphore */
 219         SemaphoreP_Params_init(&semParams);
 220         semParams.mode = SemaphoreP_Mode_BINARY;
 221         pObj->instObj->lockSem = SemaphoreP_create(1U, &semParams);
 222         if(NULL == pObj->instObj->lockSem)
 223         {
 224             GT_0trace(DssTrace,
 225                     GT_ERR,
 226                     "Instance semaphore create failed!!\r\n");
 227             retVal = FVID2_EALLOC;
 228         }
 229
 230         for(i=0U; i<CSL_DSS_VID_PIPE_ID_MAX; i++)
 231         {
 232             /* Allocate instance semaphore */
 233             pDrvInfo->pipeInfo[i].stopSem = SemaphoreP_create(0U, &semParams);
 234             if(NULL == pDrvInfo->pipeInfo[i].stopSem)
 235             {
 236                 GT_0trace(DssTrace,
 237                         GT_ERR,
 238                         "Sync Stop semaphore create failed!!\r\n");
 239                 retVal = FVID2_EALLOC;
 240             }
 241         }
 242
 243         for(i=0U; i<CSL_DSS_VP_ID_MAX; i++)
 244         {
 245             pDrvInfo->vpState[i] = DSS_DCTRL_VP_IDLE;
 246         }
 247
 248         pObj->instObj->drvState.isInit = TRUE;
 249         pObj->instObj->drvState.isOpened = FALSE;
 250         pObj->instObj->drvState.isStarted = FALSE;
 251     }
 252
 253     if(FVID2_SOK == retVal)
 254     {
 255         /* Register for Video Port events */
 256         for(cnt=0U; cnt<drvInitParams->numAvailablePorts; cnt++)
 257         {
 258             vpId = drvInitParams->availablePortId[cnt];
 259             Dss_convModuletoEventGroup(&eventGroup,
 260                                        vpId,
 261                                        DSS_EVENT_GROUP_TYPE_VP);
 262             GT_assert(DssTrace, (DSS_EVENT_GROUP_INVALID != eventGroup));
 263
 264             /* Register functional events */
 265             Dss_getEnabledVpFuncEvents(&enabledEvents[0U], &numEvents);
 266             numHandle = pObj->instObj->numRegEvtHandle;
 267             evtMgrId = Dss_getEvtMgrFuncIntrId();
 268             pObj->instObj->evtGroupHandle[pObj->instObj->numRegEvtHandle] =
 269                             Dss_evtMgrRegister(
 270                                 evtMgrId,
 271                                 eventGroup,
 272                                 (const uint32_t *)&enabledEvents[0U],
 273                                 numEvents,
 274                                 Dss_dctrlFuncCbFxn,
 275                                 (void *)&gDss_DctrlEvtMgrClientInfo[numHandle]);
 276             pObj->instObj->numRegEvtHandle++;
 277
 278             /* Register error events */
 279             Dss_getEnabledVpErrEvents(&enabledEvents[0U], &numEvents);
 280             numHandle = pObj->instObj->numRegEvtHandle;
 281             pObj->instObj->evtGroupHandle[pObj->instObj->numRegEvtHandle] =
 282                             Dss_evtMgrRegister(
 283                                 evtMgrId,
 284                                 eventGroup,
 285                                 (const uint32_t *)&enabledEvents[0U],
 286                                 numEvents,
 287                                 Dss_dctrlErrCbFxn,
 288                                 (void *)&gDss_DctrlEvtMgrClientInfo[numHandle]);
 289             pObj->instObj->numRegEvtHandle++;
 290         }
 291     }
 292
 293 #if defined (SOC_J721E)
 294     if((FVID2_SOK == retVal) &&
 295     (TRUE == drvInitParams->dpInitParams.isAvailable))
 296     {
 297         retVal = Dss_dctrlDrvInitDp(drvInitParams->dpInitParams.isHpdSupported);
 298     }
 299 #endif
 300
 301     if(FVID2_SOK == retVal)
 302     {
 303         /* Initialize Driver operations */
 304         Fvid2DrvOps_init(&pObj->fvidDrvOps);
 305
 306         pObj->fvidDrvOps.drvId = DSS_DCTRL_DRV_ID;
 307         pObj->fvidDrvOps.createFxn = &Dss_dctrlDrvCreate;
 308         pObj->fvidDrvOps.deleteFxn = &Dss_dctrlDrvDelete;
 309         pObj->fvidDrvOps.controlFxn = &Dss_dctrlDrvControl;
 310
 311         retVal = Fvid2_registerDriver(&pObj->fvidDrvOps);
 312         if(FVID2_SOK != retVal)
 313         {
 314             GT_0trace(DssTrace,
 315                       GT_ERR,
 316                       "Registering to FVID2 driver manager failed\r\n");
 317         }
 318         else
 319         {
 320             /* Init successful */
 321             pObj->isRegistered = TRUE;
 322         }
 323     }
 324
 325     return (retVal);
 326 }
 327
 328 int32_t Dss_dctrlDrvDeInit(void)
 329 {
 330     int32_t retVal = FVID2_SOK;
 331     uint32_t cnt, numRegEvtHandle, i, vpFound = FALSE;;
 332     Dss_DctrlDrvCommonObj *pObj;
 333     Dss_DctrlDrvInstObj *instObj;
 334     Dss_DctrlDrvGraphObj *pGraphObj;
 335     Dss_DctrlDrvInfo *pDrvInfo;
 336     pObj = &gDss_DctrlDrvCommonObj;
 337     pGraphObj = &gDss_DctrlDrvGraphObj;
 338     pDrvInfo = &gDss_DctrlDrvInfo;
 339     if(NULL != pObj->instObj)
 340     {
 341         instObj = pObj->instObj;
 342         if(instObj->drvState.isOpened == TRUE)
 343         {
 344             GT_0trace(DssTrace,
 345                       GT_ERR,
 346                       "Can't de-initialize when an instance is active\r\n");
 347             retVal = FVID2_EFAIL;
 348         }
 349
 350         for(i=0U; i<CSL_DSS_VP_ID_MAX; i++)
 351         {
 352             if(DSS_DCTRL_VP_IDLE != pDrvInfo->vpState[i])
 353             {
 354                 vpFound = TRUE;
 355                 break;
 356             }
 357         }
 358         if(TRUE == vpFound)
 359         {
 360             GT_0trace(DssTrace,
 361                     GT_ERR,
 362                     "Can't de-initialize when a VP is running\r\n");
 363             retVal = FVID2_EFAIL;
 364         }
 365
 366         /* Delete the graph object */
 367         Dss_dctrlDrvGraphDeInit((void *) pGraphObj);
 368
 369         numRegEvtHandle = instObj->numRegEvtHandle;
 370         /* Unregister event groups and delete object */
 371         for(cnt=0U; cnt<numRegEvtHandle; cnt++)
 372         {
 373             (void) Dss_evtMgrUnRegister(instObj->evtGroupHandle[cnt]);
 374             instObj->numRegEvtHandle--;
 375         }
 376
 377         /* Delete the instance semaphore */
 378         if(NULL != instObj->lockSem)
 379         {
 380             (void) SemaphoreP_delete(instObj->lockSem);
 381             instObj->lockSem = NULL;
 382         }
 383
 384         for(i=0U; i<CSL_DSS_VID_PIPE_ID_MAX; i++)
 385         {
 386             /* Delete instance semaphore */
 387             if(NULL != pDrvInfo->pipeInfo[i].stopSem)
 388             {
 389                 (void) SemaphoreP_delete(pDrvInfo->pipeInfo[i].stopSem);
 390                 pDrvInfo->pipeInfo[i].stopSem = NULL;
 391             }
 392         }
 393
 394         instObj->drvState.isInit = FALSE;
 395         pObj->instObj = NULL;
 396     }
 397
 398     if(TRUE == pObj->isRegistered)
 399     {
 400         /* Unregister from driver manager */
 401         retVal = Fvid2_unRegisterDriver(&pObj->fvidDrvOps);
 402         if(FVID2_SOK != retVal)
 403         {
 404             GT_0trace(DssTrace,
 405                       GT_ERR,
 406                       "Unregistering from FVID2 driver manager failed\r\n");
 407         }
 408         pObj->isRegistered = FALSE;
 409     }
 410
 411     return (retVal);
 412 }
 413
 414 DssDctrlDrvClientHandle Dss_dctrlDrvRegisterClient(
 415                                     uint32_t nodeId,
 416                                     const Dss_DctrlDrvClientInfo *clientInfo)
 417 {
 418     uint32_t i;
 419     DssDctrlDrvClientHandle clientHandle = NULL;
 420     GT_assert(DssTrace, (NULL != clientInfo));
 421     GT_assert(DssTrace,
 422               (gDss_DctrlDrvInfo.numValidPipes <= CSL_DSS_VID_PIPE_ID_MAX));
 423
 424     for(i=0U; i<gDss_DctrlDrvInfo.numValidPipes; i++)
 425     {
 426         if(gDss_DctrlDrvInfo.pipeInfo[i].pipeNodeId == nodeId)
 427         {
 428             gDss_DctrlDrvInfo.pipeInfo[i].gClientInfo.cbFxn = clientInfo->cbFxn;
 429             gDss_DctrlDrvInfo.pipeInfo[i].gClientInfo.arg = clientInfo->arg;
 430             gDss_DctrlDrvInfo.pipeInfo[i].pipeState = DSS_DCTRL_PIPE_OPENED;
 431             clientHandle = &gDss_DctrlDrvInfo.pipeInfo[i];
 432             break;
 433         }
 434     }
 435
 436     return clientHandle;
 437 }
 438
 439 int32_t Dss_dctrlDrvUnRegisterClient(DssDctrlDrvClientHandle handle)
 440 {
 441     int32_t retVal = FVID2_SOK;
 442     Dss_DctrlDrvPipeInfo *pipeInfo;
 443     GT_assert(DssTrace, (NULL != handle));
 444
 445     pipeInfo = (Dss_DctrlDrvPipeInfo *) handle;
 446     pipeInfo->gClientInfo.cbFxn = NULL;
 447     pipeInfo->gClientInfo.arg = NULL;
 448     pipeInfo->pipeState = DSS_DCTRL_PIPE_IDLE;
 449
 450     return retVal;
 451 }
 452
 453 int32_t Dss_dctrlDrvStartClient(DssDctrlDrvClientHandle handle,
 454                                 uint32_t dummyStart)
 455 {
 456     int32_t retVal = FVID2_SOK;
 457     uint32_t cookie;
 458     Dss_DctrlDrvPipeInfo *pipeInfo;
 459     GT_assert(DssTrace, (NULL != handle));
 460
 461     cookie = HwiP_disable();
 462
 463     pipeInfo = (Dss_DctrlDrvPipeInfo *) handle;
 464     if(TRUE == dummyStart)
 465     {
 466         pipeInfo->pipeState = DSS_DCTRL_PIPE_STARTING;
 467     }
 468     else
 469     {
 470         pipeInfo->pipeState = DSS_DCTRL_PIPE_STARTED;
 471     }
 472
 473     if(FALSE == dummyStart)
 474     {
 475         retVal = Dss_dctrlDrvSetGoBit(handle);
 476     }
 477
 478     HwiP_restore(cookie);
 479
 480     return retVal;
 481 }
 482
 483 int32_t Dss_dctrlDrvStopClient(DssDctrlDrvClientHandle handle,
 484                                uint32_t syncStop)
 485 {
 486     int32_t retVal = FVID2_SOK;
 487     uint32_t cookie;
 488     Dss_DctrlDrvPipeInfo *pipeInfo;
 489     GT_assert(DssTrace, (NULL != handle));
 490
 491     cookie = HwiP_disable();
 492     pipeInfo = (Dss_DctrlDrvPipeInfo *) handle;
 493     if(TRUE == syncStop)
 494     {
 495         pipeInfo->pipeState = DSS_DCTRL_PIPE_STOPPING;
 496     }
 497     else
 498     {
 499         pipeInfo->pipeState = DSS_DCTRL_PIPE_STOPPED;
 500     }
 501
 502     if(FALSE == syncStop)
 503     {
 504         retVal = Dss_dctrlDrvSetGoBit(handle);
 505     }
 506
 507     HwiP_restore(cookie);
 508
 509     /* Take the stop semaphore */
 510     (void) SemaphoreP_pend(pipeInfo->stopSem, SemaphoreP_WAIT_FOREVER);
 511     return retVal;
 512 }
 513
 514 int32_t Dss_dctrlDrvGetVpParams(DssDctrlDrvClientHandle handle,
 515                                 Dss_DctrlVpParams *vpParams)
 516 {
 517     int32_t retVal = FVID2_SOK;
 518     uint32_t i;
 519     Dss_DctrlDrvPipeInfo *pipeInfo;
 520     Dss_DctrlDrvInstObj *instObj;
 521     Dss_DctrlDrvCommonObj *pObj = &gDss_DctrlDrvCommonObj;
 522     GT_assert(DssTrace, (NULL != handle));
 523
 524     instObj = pObj->instObj;
 525
 526     /* Take the instance semaphore */
 527     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
 528
 529     /* Get VP Params */
 530     pipeInfo = (Dss_DctrlDrvPipeInfo *) handle;
 531     for(i=0U; i<CSL_DSS_VP_ID_MAX; i++)
 532     {
 533         if(pipeInfo->vpId == gDss_DctrlDrvInfo.vpParams[i].vpId)
 534         {
 535             vpParams->lcdOpTimingCfg.mInfo.scanFormat =
 536                     gDss_DctrlDrvInfo.vpParams[i].lcdOpTimingCfg.mInfo.scanFormat;
 537             vpParams->lcdOpTimingCfg.mInfo.standard =
 538                     gDss_DctrlDrvInfo.vpParams[i].lcdOpTimingCfg.mInfo.standard;
 539             vpParams->lcdOpTimingCfg.mInfo.width =
 540                     gDss_DctrlDrvInfo.vpParams[i].lcdOpTimingCfg.mInfo.width;
 541             vpParams->lcdOpTimingCfg.mInfo.height =
 542                     gDss_DctrlDrvInfo.vpParams[i].lcdOpTimingCfg.mInfo.height;
 543             vpParams->vpId = gDss_DctrlDrvInfo.vpParams[i].vpId;
 544             break;
 545         }
 546     }
 547
 548     /* Post the instance semaphore */
 549     (void) SemaphoreP_post(instObj->lockSem);
 550
 551     return retVal;
 552 }
 553
 554 int32_t Dss_dctrlDrvSetGoBit(DssDctrlDrvClientHandle handle)
 555 {
 556     int32_t retVal = FVID2_SOK;
 557     Dss_DctrlDrvPipeInfo *pipeInfo;
 558     GT_assert(DssTrace, (NULL != handle));
 559
 560     pipeInfo = (Dss_DctrlDrvPipeInfo *) handle;
 561
 562     /* Set Go Bit */
 563     Dss_dctrlVpSetGoBit(pipeInfo->vpId);
 564
 565     return (retVal);
 566 }
 567
 568 uint32_t Dss_dctrlDrvIsSafeToPush(DssDctrlDrvClientHandle handle)
 569 {
 570     uint32_t retVal = FALSE, cookie;
 571     Dss_DctrlDrvPipeInfo *pipeInfo;
 572     GT_assert(DssTrace, (NULL != handle));
 573
 574     pipeInfo = (Dss_DctrlDrvPipeInfo *) handle;
 575     cookie = HwiP_disable();
 576     retVal = gDss_DctrlDrvInfo.isPushSafe[pipeInfo->vpId];
 577     HwiP_restore(cookie);
 578
 579     return retVal;
 580 }
 581
 582 Dss_DctrlDrvPipeInfo *Dss_dctrlDrvGetPipeInfo(DssDctrlDrvClientHandle handle)
 583 {
 584     uint32_t i;
 585     Dss_DctrlDrvPipeInfo *pipeInfo;
 586     GT_assert(DssTrace, (NULL != handle));
 587
 588     pipeInfo = (Dss_DctrlDrvPipeInfo *) handle;
 589     for(i=0U; i<gDss_DctrlDrvInfo.numValidPipes; i++)
 590     {
 591         if((gDss_DctrlDrvInfo.pipeInfo[i].pipeId == pipeInfo->pipeId) &&
 592            ((gDss_DctrlDrvInfo.pipeInfo[i].pipeState ==
 593                                             DSS_DCTRL_PIPE_OPENED)   ||
 594             (gDss_DctrlDrvInfo.pipeInfo[i].pipeState ==
 595                                             DSS_DCTRL_PIPE_STARTING) ||
 596             (gDss_DctrlDrvInfo.pipeInfo[i].pipeState ==
 597                                             DSS_DCTRL_PIPE_STARTED)  ||
 598             (gDss_DctrlDrvInfo.pipeInfo[i].pipeState ==
 599                                             DSS_DCTRL_PIPE_RUNNING)  ||
 600             (gDss_DctrlDrvInfo.pipeInfo[i].pipeState ==
 601                                             DSS_DCTRL_PIPE_STOPPING) ||
 602             (gDss_DctrlDrvInfo.pipeInfo[i].pipeState ==
 603                                             DSS_DCTRL_PIPE_STOPPED)))
 604         {
 605             break;
 606         }
 607     }
 608     return &gDss_DctrlDrvInfo.pipeInfo[i];
 609 }
 610
 611 /* ========================================================================== */
 612 /*                       Static Function Definitions                          */
 613 /* ========================================================================== */
 614
 615 static Fdrv_Handle Dss_dctrlDrvCreate(uint32_t drvId,
 616                                       uint32_t instId,
 617                                       void *createArgs,
 618                                       void *createStatusArgs,
 619                                       const Fvid2_DrvCbParams *fdmCbParams)
 620 {
 621     int32_t retVal = FVID2_SOK;
 622     Fdrv_Handle drvHandle = NULL;
 623     Dss_DctrlDrvInstObj *instObj = NULL;
 624     Dss_DctrlDrvCommonObj *pObj;
 625
 626     pObj = &gDss_DctrlDrvCommonObj;
 627
 628     GT_assert(DssTrace, (NULL != pObj));
 629     GT_assert(DssTrace, (NULL != pObj->instObj));
 630
 631     instObj = pObj->instObj;
 632
 633     if(NULL == instObj)
 634     {
 635         GT_0trace(DssTrace, GT_ERR, "Invalid instance ID\r\n");
 636         retVal = FVID2_EINVALID_PARAMS;
 637     }
 638
 639     if(NULL != instObj)
 640     {
 641         /* Take the instance semaphore */
 642         (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
 643     }
 644
 645     if(FVID2_SOK == retVal)
 646     {
 647         /* Initialize instance variables */
 648         if(0U == instObj->numOpenDrvHandle)
 649         {
 650             instObj->drvState.isOpened = TRUE;
 651         }
 652         instObj->numOpenDrvHandle++;
 653         drvHandle = instObj;
 654     }
 655
 656     if(NULL != instObj)
 657     {
 658         /* Post the instance semaphore */
 659         (void) SemaphoreP_post(instObj->lockSem);
 660     }
 661
 662     return (drvHandle);
 663 }
 664
 665 static int32_t Dss_dctrlDrvDelete(Fdrv_Handle handle, void *reserved)
 666 {
 667     int32_t retVal = FVID2_SOK;
 668
 669     Dss_DctrlDrvInstObj *instObj = NULL, *pInstObj = NULL;
 670     Dss_DctrlDrvCommonObj *pObj;
 671
 672     /* Check for NULL pointers and invalid arguments */
 673     if(NULL == handle)
 674     {
 675         GT_0trace(DssTrace, GT_ERR, "Invalid arguments\r\n");
 676         retVal = FVID2_EBADARGS;
 677     }
 678     else
 679     {
 680         instObj = (Dss_DctrlDrvInstObj *) handle;
 681         pObj = &gDss_DctrlDrvCommonObj;
 682         pInstObj = pObj->instObj;
 683     }
 684
 685     if(instObj != pInstObj)
 686     {
 687         GT_0trace(DssTrace, GT_ERR, "Invalid arguments\r\n");
 688         retVal = FVID2_EBADARGS;
 689     }
 690
 691     if((NULL != instObj) && (FVID2_SOK == retVal))
 692     {
 693         /* Take the instance semaphore */
 694         (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
 695
 696         /* Check if already opened. */
 697         if(TRUE != instObj->drvState.isOpened)
 698         {
 699             GT_0trace(DssTrace, GT_ERR, "ERROR: Driver not opened\r\n");
 700             retVal = FVID2_EFAIL;
 701         }
 702     }
 703
 704     if(FVID2_SOK == retVal)
 705     {
 706         /* Reset other variables */
 707         instObj->numOpenDrvHandle--;
 708         if(0U == instObj->numOpenDrvHandle)
 709         {
 710             instObj->drvState.isOpened  = FALSE;
 711             instObj->drvState.isStarted = FALSE;
 712         }
 713     }
 714
 715     if(NULL != instObj)
 716     {
 717         /* Post the instance semaphore */
 718         (void) SemaphoreP_post(instObj->lockSem);
 719     }
 720
 721     return (retVal);
 722 }
 723
 724 static int32_t Dss_dctrlDrvControl(Fdrv_Handle handle,
 725                                    uint32_t cmd,
 726                                    void *cmdArgs,
 727                                    void *cmdStatusArgs)
 728 {
 729     int32_t retVal = FVID2_SOK;
 730     Dss_DctrlDrvInstObj *instObj;
 731
 732     /* Check for NULL pointers */
 733     if((NULL == handle) || (NULL == cmdArgs))
 734     {
 735         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
 736         retVal = FVID2_EBADARGS;
 737     }
 738
 739     if(FVID2_SOK == retVal)
 740     {
 741         instObj = (Dss_DctrlDrvInstObj *) handle;
 742         switch (cmd)
 743         {
 744             case IOCTL_DSS_DCTRL_SET_PATH:
 745                 retVal = Dss_dctrlDrvSetPathIoctl(
 746                     instObj,
 747                     (const Dss_DctrlPathInfo*) cmdArgs);
 748                 break;
 749             case IOCTL_DSS_DCTRL_CLEAR_PATH:
 750                 retVal = Dss_dctrlDrvClearPathIoctl(
 751                     instObj,
 752                     (const Dss_DctrlPathInfo*) cmdArgs);
 753                 break;
 754             case IOCTL_DSS_DCTRL_SET_VP_PARAMS:
 755                 retVal = Dss_dctrlDrvSetVpParamsIoctl(
 756                     instObj,
 757                     (const Dss_DctrlVpParams*) cmdArgs);
 758                 break;
 759             case IOCTL_DSS_DCTRL_SET_OVERLAY_PARAMS:
 760                 retVal = Dss_dctrlDrvSetOverlayParamsIoctl(
 761                     instObj,
 762                     (const Dss_DctrlOverlayParams*) cmdArgs);
 763                 break;
 764             case IOCTL_DSS_DCTRL_SET_LAYER_PARAMS:
 765                 retVal = Dss_dctrlDrvSetLayerParamsIoctl(
 766                     instObj,
 767                     (const Dss_DctrlOverlayLayerParams*) cmdArgs);
 768                 break;
 769             case IOCTL_DSS_DCTRL_SET_VP_CSC_COEFF:
 770                 retVal = Dss_dctrlDrvSetVpCscCoeffIoctl(
 771                     instObj,
 772                     (const Dss_DctrlVpCscCoeff*) cmdArgs);
 773                 break;
 774             case IOCTL_DSS_DCTRL_SET_ADV_VP_PARAMS:
 775                 retVal = Dss_dctrlDrvSetAdvVpParamsIoctl(
 776                     instObj,
 777                     (const Dss_DctrlAdvVpParams*) cmdArgs);
 778                 break;
 779             case IOCTL_DSS_DCTRL_SET_LCD_BLANK_TIMING_PARAMS:
 780                 retVal = Dss_dctrlDrvSetLcdBlankTimingIoctl(
 781                     instObj,
 782                     (const Dss_DctrlLcdBlankTimingParams*) cmdArgs);
 783                 break;
 784             case IOCTL_DSS_DCTRL_SET_VP_SAFETY_CHK_PARAMS:
 785                 retVal = Dss_dctrlDrvSetVpSafetyChkParamsIoctl(
 786                     instObj,
 787                     (const Dss_DctrlVpSafetyChkParams*) cmdArgs);
 788                 break;
 789             case IOCTL_DSS_DCTRL_GET_VP_ERROR_STATS:
 790                 retVal = Dss_dctrlDrvGetErrorStatsIoctl(
 791                     instObj,
 792                     (Dss_DctrlVpErrorStats*) cmdArgs);
 793                 break;
 794             case IOCTL_DSS_DCTRL_SET_GLOBAL_DSS_PARAMS:
 795                 retVal = Dss_dctrlDrvSetGlobalDssParamsIoctl(
 796                     instObj,
 797                     (const Dss_DctrlGlobalDssParams*) cmdArgs);
 798                 break;
 799             case IOCTL_DSS_DCTRL_STOP_VP:
 800                 retVal = Dss_dctrlDrvStopVpIoctl(
 801                     instObj,
 802                     (const Dss_DctrlVpParams*) cmdArgs);
 803                 break;
 804             case IOCTL_DSS_DCTRL_REGISTER_SYNCLOST_CB:
 805                 retVal = Dss_dctrlDrvSetSyncLostCbParamsIoctl(
 806                     instObj,
 807                     (const Dss_DctrlSyncLostCbParams*) cmdArgs);
 808                 break;
 809             case IOCTL_DSS_DCTRL_REGISTER_LINENUM_CB:
 810                 retVal = Dss_dctrlDrvSetLineNumCbParamsIoctl(
 811                     instObj,
 812                     (const Dss_DctrlLineNumCbParams*) cmdArgs);
 813                 break;
 814 #if defined (SOC_AM65XX)
 815             case IOCTL_DSS_DCTRL_SET_OLDI_PARAMS:
 816                 retVal = Dss_dctrlDrvSetOldiParamsIoctl(
 817                     instObj,
 818                     (const Dss_DctrlOldiParams*) cmdArgs);
 819                 break;
 820 #endif
 821 #if defined (SOC_J721E)
 822             case IOCTL_DSS_DCTRL_PROCESS_DP_HPD:
 823                 retVal = Dss_dctrlDrvProcessDpHpdIoctl(
 824                     instObj,
 825                     (const uint32_t*) cmdArgs);
 826                 break;
 827             case IOCTL_DSS_DCTRL_REGISTER_DP_HPD_CB:
 828                 retVal = Dss_dctrlDrvSetDpHpdCbParamsIoctl(
 829                     instObj,
 830                     (const Dss_DctrlDpHpdCbParams*) cmdArgs);
 831                 break;
 832 #endif
 833             default:
 834                 GT_0trace(DssTrace,
 835                           GT_ERR,
 836                           "UNSUPPORTED_CMD: IOCTL not supported\r\n");
 837                 retVal = FVID2_EUNSUPPORTED_CMD;
 838                 break;
 839         }
 840     }
 841
 842     return (retVal);
 843 }
 844
 845 static int32_t Dss_dctrlDrvSetPathIoctl(Dss_DctrlDrvInstObj *instObj,
 846                                         const Dss_DctrlPathInfo *pathInfo)
 847 {
 848     int32_t retVal = FVID2_SOK;
 849     uint32_t i, j, k, moduleId, currPipeNum;
 850     Fvid2_GraphEdgeInfo *currEdge, *vpEdge, *outEdge;
 851     Dss_DctrlDrvPipeInfo *pPipeInfo;
 852
 853     /* Check for NULL pointers */
 854     GT_assert(DssTrace, (NULL != instObj));
 855     GT_assert(DssTrace, (NULL != pathInfo));
 856
 857     /* Take the instance semaphore */
 858     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
 859
 860     gDss_DctrlDrvInfo.numValidPipes = 0;
 861
 862     if(0U != pathInfo->numEdges)
 863     {
 864         retVal = Dss_dctrlDrvCreateEdgeList(&gDss_DctrlDrvGraphObj,
 865                                    pathInfo);
 866     }
 867
 868     if((FVID2_SOK == retVal) && (0U != pathInfo->numEdges))
 869     {
 870         for(i=0U; i<gDss_DctrlDrvGraphObj.dctrlEdgeList.numEdges; i++)
 871         {
 872             currEdge = &gDss_DctrlDrvGraphObj.dctrlEdgeList.list[i];
 873
 874             if(TRUE == Dss_dctrlIsPipeNode(currEdge->startNode))
 875             {
 876                 /* Start graph construction from pipe */
 877                 currPipeNum = gDss_DctrlDrvInfo.numValidPipes;
 878                 pPipeInfo = &gDss_DctrlDrvInfo.pipeInfo[currPipeNum];
 879                 GT_assert(DssTrace, (currPipeNum <= CSL_DSS_VID_PIPE_ID_MAX));
 880                 pPipeInfo->pipeNodeId = currEdge->startNode;
 881                 /* Get Pipe Id */
 882                 retVal = Dss_convNodetoModule(currEdge->startNode, &moduleId);
 883                 GT_assert(DssTrace,
 884                           ((CSL_DSS_MODULE_INVALID != moduleId) ||
 885                            (FVID2_SOK == retVal)));
 886                 pPipeInfo->pipeId = moduleId;
 887                 pPipeInfo->pipeState = DSS_DCTRL_PIPE_IDLE;
 888                 /* Assign overlay node & overlay id */
 889                 pPipeInfo->overlayNodeId = currEdge->endNode;
 890                 retVal = Dss_convNodetoModule(currEdge->endNode, &moduleId);
 891                 GT_assert(DssTrace,
 892                           ((CSL_DSS_MODULE_INVALID != moduleId) ||
 893                            (FVID2_SOK == retVal)));
 894                 pPipeInfo->overlayId = moduleId;
 895                 retVal = Dss_dctrlConnectNodes(pPipeInfo->pipeNodeId,
 896                                                pPipeInfo->overlayNodeId);
 897                 GT_assert(DssTrace, (FVID2_SOK == retVal));
 898
 899                 /* Find video port connected to overlay */
 900                 for(j=0U; j<gDss_DctrlDrvGraphObj.dctrlEdgeList.numEdges; j++)
 901                 {
 902                     vpEdge = &gDss_DctrlDrvGraphObj.dctrlEdgeList.list[j];
 903                     if(vpEdge->startNode == currEdge->endNode)
 904                     {
 905                         /* Assign video port node and video port id */
 906                         pPipeInfo->vpNodeId = vpEdge->endNode;
 907                         retVal = Dss_convNodetoModule(vpEdge->endNode,
 908                                                       &moduleId);
 909                         GT_assert(DssTrace,
 910                                   ((CSL_DSS_MODULE_INVALID != moduleId) ||
 911                                    (FVID2_SOK == retVal)));
 912                         pPipeInfo->vpId = moduleId;
 913                         retVal = Dss_dctrlConnectNodes(pPipeInfo->overlayNodeId,
 914                                                        pPipeInfo->vpNodeId);
 915                         GT_assert(DssTrace, (FVID2_SOK == retVal));
 916
 917                         /* Find output node connected to video port */
 918                         for(k=0U; k<gDss_DctrlDrvGraphObj.dctrlEdgeList.numEdges; k++)
 919                         {
 920                             /* Assign output node */
 921                             outEdge = &gDss_DctrlDrvGraphObj.dctrlEdgeList.list[k];
 922                             if(outEdge->startNode == vpEdge->endNode)
 923                             {
 924                                 pPipeInfo->outNodeId = outEdge->endNode;
 925                                 retVal = Dss_dctrlConnectNodes(
 926                                                         pPipeInfo->vpNodeId,
 927                                                         pPipeInfo->outNodeId);
 928                                 GT_assert(DssTrace, (FVID2_SOK == retVal));
 929                             }
 930                         }
 931                     }
 932                 }
 933                 gDss_DctrlDrvInfo.numValidPipes++;
 934             }
 935         }
 936     }
 937
 938     if(FVID2_SOK != retVal)
 939     {
 940         GT_0trace(DssTrace, GT_ERR, "Set Path IOCTL failed\r\n");
 941     }
 942
 943     /* Post the instance semaphore */
 944     (void) SemaphoreP_post(instObj->lockSem);
 945
 946     return retVal;
 947 }
 948
 949 static int32_t Dss_dctrlDrvClearPathIoctl(Dss_DctrlDrvInstObj *instObj,
 950                                           const Dss_DctrlPathInfo *pathInfo)
 951 {
 952     int32_t retVal = FVID2_SOK;
 953
 954     /* Check for NULL pointers */
 955     GT_assert(DssTrace, (NULL != instObj));
 956     GT_assert(DssTrace, (NULL != pathInfo));
 957
 958     /* Take the instance semaphore */
 959     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
 960
 961     Dss_dctrlDrvFreeEdgeList(&gDss_DctrlDrvGraphObj);
 962
 963     if(FVID2_SOK != retVal)
 964     {
 965         GT_0trace(DssTrace, GT_ERR, "Clear Path IOCTL failed\r\n");
 966     }
 967
 968     /* Post the instance semaphore */
 969     (void) SemaphoreP_post(instObj->lockSem);
 970
 971     return retVal;
 972 }
 973
 974 static int32_t Dss_dctrlDrvSetVpParamsIoctl(
 975                             Dss_DctrlDrvInstObj *instObj,
 976                             const Dss_DctrlVpParams *vpParams)
 977 {
 978     int32_t retVal = FVID2_SOK;
 979     uint32_t i, vpId, syncVpId, vpFound = FALSE;
 980     CSL_dss_vpRegs *vpRegs;
 981     const Dss_SocInfo *socInfo;
 982     const CSL_DssVpLcdOpTimingCfg *lcdOpTimingCfg;
 983     const CSL_DssVpLcdSignalPolarityCfg *lcdPolarityCfg;
 984     const CSL_DssVpLcdTdmCfg *lcdTdmCfg;
 985     const Dss_DctrlSyncOpCfg *syncOpCfg;
 986     Dss_DctrlVpParams *pVpParams;
 987     Dss_DctrlDrvInfo *pDrvInfo;
 988
 989     pDrvInfo = &gDss_DctrlDrvInfo;
 990
 991     /* Check for NULL pointers */
 992     GT_assert(DssTrace, (NULL != instObj));
 993     GT_assert(DssTrace, (NULL != vpParams));
 994
 995     /* Check for wrong inputs */
 996     if(vpParams->vpId >= CSL_DSS_VP_ID_MAX)
 997     {
 998         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
 999         retVal = FVID2_EBADARGS;
1000     }
1001
1002     /* Take the instance semaphore */
1003     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1004
1005     if(FVID2_SOK == retVal)
1006     {
1007         /* Check if VP was already running */
1008         vpId = vpParams->vpId;
1009         for(i = 0U; i < CSL_DSS_VP_ID_MAX; i++)
1010         {
1011             if((gDss_DctrlDrvInfo.vpParams[i].vpId == vpId) &&
1012             (DSS_DCTRL_VP_IDLE != gDss_DctrlDrvInfo.vpState[vpId]))
1013             {
1014                 retVal = FVID2_EDEVICE_INUSE;
1015                 GT_0trace(DssTrace, GT_ERR, "VP is already in use!!\r\n");
1016                 break;
1017             }
1018         }
1019     }
1020
1021     if(FVID2_SOK == retVal)
1022     {
1023         /* Assign input parameters */
1024         lcdOpTimingCfg = &vpParams->lcdOpTimingCfg;
1025         lcdPolarityCfg = &vpParams->lcdPolarityCfg;
1026         lcdTdmCfg = &vpParams->lcdTdmCfg;
1027         syncOpCfg = &vpParams->syncOpCfg;
1028         pVpParams = &gDss_DctrlDrvInfo.vpParams[vpId];
1029
1030         pVpParams->syncOpCfg.enabled = syncOpCfg->enabled;
1031         pVpParams->syncOpCfg.isPrimary = syncOpCfg->isPrimary;
1032         pVpParams->syncOpCfg.numSyncVpIds = syncOpCfg->numSyncVpIds;
1033         for(i = 0; i < syncOpCfg->numSyncVpIds; i++)
1034         {
1035             pVpParams->syncOpCfg.syncVpIds[i] = syncOpCfg->syncVpIds[i];
1036         }
1037
1038         pVpParams->lcdOpTimingCfg.mInfo.scanFormat =
1039                                             lcdOpTimingCfg->mInfo.scanFormat;
1040         pVpParams->lcdOpTimingCfg.mInfo.standard =
1041                                             lcdOpTimingCfg->mInfo.standard;
1042         pVpParams->lcdOpTimingCfg.mInfo.height =
1043                                             lcdOpTimingCfg->mInfo.height;
1044         pVpParams->lcdOpTimingCfg.mInfo.width =
1045                                             lcdOpTimingCfg->mInfo.width;
1046         pVpParams->vpId = vpId;
1047     }
1048
1049     if((FVID2_SOK == retVal) &&
1050     (TRUE == vpParams->syncOpCfg.enabled) &&
1051     (TRUE == vpParams->syncOpCfg.isPrimary))
1052     {
1053         syncOpCfg = &vpParams->syncOpCfg;
1054
1055         for(i = 0; i < syncOpCfg->numSyncVpIds; i++)
1056         {
1057             syncVpId = syncOpCfg->syncVpIds[i];
1058
1059             if(DSS_DCTRL_VP_STARTING != pDrvInfo->vpState[syncVpId])
1060             {
1061                 vpFound = TRUE;
1062                 break;
1063             }
1064         }
1065         if(TRUE == vpFound)
1066         {
1067             retVal = FVID2_EBADARGS;
1068             GT_0trace(DssTrace, GT_ERR, "Secondary sync VPs not started!!\r\n");
1069         }
1070     }
1071
1072     if(FVID2_SOK == retVal)
1073     {
1074         /* Get video port registers */
1075         socInfo = Dss_getSocInfo();
1076         vpRegs = socInfo->vpRegs[vpId];
1077         GT_assert(DssTrace, (NULL != vpRegs));
1078
1079         /* Not safe to push */
1080         gDss_DctrlDrvInfo.isPushSafe[vpId] = FALSE;
1081
1082         /* Call CSL APIs */
1083         CSL_dssVpSetLcdSignalPolarityConfig(vpRegs, lcdPolarityCfg);
1084         CSL_dssVpSetLcdTdmConfig(vpRegs, lcdTdmCfg);
1085         retVal = CSL_dssVpSetLcdOpTimingConfig(vpRegs, lcdOpTimingCfg);
1086
1087         if(FVID2_SOK != retVal)
1088         {
1089             GT_assert(DssTrace, FALSE);
1090         }
1091
1092         if(lcdOpTimingCfg->mInfo.height > 5U)
1093         {
1094             CSL_dssVpSetLcdLineNum(vpRegs, lcdOpTimingCfg->mInfo.height - 5U);
1095         }
1096
1097         Dss_dctrlVpEnable(vpId, TRUE);
1098     }
1099
1100 #if defined (SOC_J721E)
1101     if((FVID2_SOK == retVal) &&
1102     (TRUE == Dss_dctrlDrvIsOutputDP(vpId)))
1103     {
1104         retVal = Dss_dctrlDrvEnableVideoDP(&lcdOpTimingCfg->mInfo,
1105                                            lcdPolarityCfg->hsPolarity,
1106                                            lcdPolarityCfg->vsPolarity);
1107     }
1108 #endif
1109
1110     if(FVID2_SOK != retVal)
1111     {
1112         GT_0trace(DssTrace, GT_ERR, "Set VP parameters IOCTL failed\r\n");
1113     }
1114
1115     /* Post the instance semaphore */
1116     (void) SemaphoreP_post(instObj->lockSem);
1117
1118     return retVal;
1119 }
1120
1121 #if defined (SOC_J721E)
1122 static int32_t Dss_dctrlDrvProcessDpHpdIoctl(
1123                             Dss_DctrlDrvInstObj *instObj,
1124                             const uint32_t *dpProcessHpdParams)
1125 {
1126     int32_t retVal = FVID2_SOK;
1127     uint32_t hpdState;
1128
1129     /* Check for NULL pointers */
1130     GT_assert(DssTrace, (NULL != instObj));
1131     GT_assert(DssTrace, (NULL != dpProcessHpdParams));
1132
1133     hpdState = *dpProcessHpdParams;
1134
1135     if(FVID2_SOK == retVal)
1136     {
1137         retVal = Dss_dctrlDrvProcessHpdDp(hpdState);
1138     }
1139
1140     return retVal;
1141 }
1142
1143 static int32_t Dss_dctrlDrvSetDpHpdCbParamsIoctl(
1144                             Dss_DctrlDrvInstObj *instObj,
1145                             const Dss_DctrlDpHpdCbParams *dpHpdCbParams)
1146 {
1147     int32_t retVal = FVID2_SOK;
1148
1149     /* Check for NULL pointers */
1150     GT_assert(DssTrace, (NULL != instObj));
1151     GT_assert(DssTrace, (NULL != dpHpdCbParams));
1152
1153     if(FVID2_SOK == retVal)
1154     {
1155         retVal = Dss_dctrlDrvRegisterHpdCb(dpHpdCbParams);
1156     }
1157
1158     if(FVID2_SOK != retVal)
1159     {
1160         GT_0trace(DssTrace,
1161                   GT_ERR,
1162                   "Register Display port HPD CB Params IOCTL failed\r\n");
1163     }
1164
1165     return retVal;
1166 }
1167
1168 static uint32_t Dss_dctrlDrvIsOutputDP(uint32_t vpId)
1169 {
1170     int32_t retVal;
1171     uint32_t i;
1172     uint32_t nodeId, vpFound = FALSE;
1173     Fvid2_GraphEdgeInfo *currEdge;
1174
1175     retVal = Dss_convModuletoNode(&nodeId, vpId, DSS_DCTRL_NODE_TYPE_VP);
1176     GT_assert(DssTrace,
1177             ((DSS_DCTRL_NODE_INVALID != nodeId) ||
1178              (FVID2_SOK == retVal)));
1179
1180     for(i=0U; i<gDss_DctrlDrvGraphObj.dctrlEdgeList.numEdges; i++)
1181     {
1182         currEdge = &gDss_DctrlDrvGraphObj.dctrlEdgeList.list[i];
1183         if((DSS_DCTRL_NODE_EDP_DPI0 == currEdge->endNode) &&
1184                 (nodeId == currEdge->startNode))
1185         {
1186             vpFound = TRUE;
1187             break;
1188         }
1189     }
1190
1191     return vpFound;
1192 }
1193 #endif
1194
1195
1196 static int32_t Dss_dctrlDrvSetOverlayParamsIoctl(
1197                             Dss_DctrlDrvInstObj *instObj,
1198                             const Dss_DctrlOverlayParams *overlayParams)
1199 {
1200     int32_t retVal = FVID2_SOK;
1201     uint32_t vpId, overlayId = overlayParams->overlayId;
1202     CSL_dss_overlayRegs *overlayRegs;
1203     const Dss_SocInfo *socInfo;
1204     const CSL_DssOverlayCfg *overlayCfg;
1205
1206     /* Check for NULL pointers */
1207     GT_assert(DssTrace, (NULL != instObj));
1208     GT_assert(DssTrace, (NULL != overlayParams));
1209
1210     /* Check for wrong inputs */
1211     if(overlayId >= CSL_DSS_OVERLAY_ID_MAX)
1212     {
1213         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
1214         retVal = FVID2_EBADARGS;
1215     }
1216
1217     /* Take the instance semaphore */
1218     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1219
1220     if(FVID2_SOK == retVal)
1221     {
1222         /* Get overlay registers */
1223         socInfo = Dss_getSocInfo();
1224         overlayRegs = socInfo->overlayRegs[overlayId];
1225         GT_assert(DssTrace, (NULL != overlayRegs));
1226
1227         /* Get video port registers */
1228         vpId = Dss_getVpConnId(overlayId);
1229         GT_assert(DssTrace, (CSL_DSS_MODULE_INVALID != vpId));
1230
1231         /* Assign input parameters */
1232         overlayCfg = &overlayParams->overlayCfg;
1233
1234         /* Call CSL APIs */
1235         if(FALSE == overlayParams->colorbarEnable)
1236         {
1237             CSL_dssOverlayColorBarEnable(overlayRegs, FALSE);
1238             CSL_dssOverlaySetConfig(overlayRegs, overlayCfg);
1239         }
1240         else
1241         {
1242             CSL_dssOverlayColorBarEnable(overlayRegs, TRUE);
1243             Dss_dctrlVpSetGoBit(vpId);
1244         }
1245     }
1246
1247     if(FVID2_SOK != retVal)
1248     {
1249         GT_0trace(DssTrace, GT_ERR, "Set overlay parameters IOCTL failed\r\n");
1250     }
1251
1252     /* Post the instance semaphore */
1253     (void) SemaphoreP_post(instObj->lockSem);
1254
1255     return retVal;
1256 }
1257
1258 static int32_t Dss_dctrlDrvSetLayerParamsIoctl(
1259                             Dss_DctrlDrvInstObj *instObj,
1260                             const Dss_DctrlOverlayLayerParams *layerParams)
1261 {
1262     int32_t retVal = FVID2_SOK;
1263     uint32_t i, overlayId = layerParams->overlayId;
1264     CSL_dss_overlayRegs *overlayRegs;
1265     const Dss_SocInfo *socInfo;
1266     CSL_DssOverlayLayerCfg layerCfg;
1267
1268     /* Check for NULL pointers */
1269     GT_assert(DssTrace, (NULL != instObj));
1270     GT_assert(DssTrace, (NULL != layerParams));
1271
1272     /* Check for wrong inputs */
1273     if(overlayId >= CSL_DSS_OVERLAY_ID_MAX)
1274     {
1275         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
1276         retVal = FVID2_EBADARGS;
1277     }
1278
1279     /* Take the instance semaphore */
1280     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1281
1282     if(FVID2_SOK == retVal)
1283     {
1284         /* Initialize layer configuration */
1285         CSL_dssOverlayLayerCfgInit(&layerCfg);
1286
1287         /* Get overlay registers */
1288         socInfo = Dss_getSocInfo();
1289         overlayRegs = socInfo->overlayRegs[overlayId];
1290         GT_assert(DssTrace, (NULL != overlayRegs));
1291
1292         /* Call CSL APIs */
1293         for(i=0U; i<CSL_DSS_VID_PIPE_ID_MAX; i++)
1294         {
1295             if(CSL_DSS_OVERLAY_LAYER_INVALID != layerParams->pipeLayerNum[i])
1296             {
1297                 layerCfg.layerEnable = TRUE;
1298                 layerCfg.layerNum = layerParams->pipeLayerNum[i];
1299                 layerCfg.inputPipe = i;
1300                 CSL_dssOverlaySetLayerConfig(
1301                                     overlayRegs,
1302                                     (const CSL_DssOverlayLayerCfg *) &layerCfg);
1303             }
1304         }
1305     }
1306
1307     if(FVID2_SOK != retVal)
1308     {
1309         GT_0trace(DssTrace, GT_ERR, "Set layer parameters IOCTL failed\r\n");
1310     }
1311
1312     /* Post the instance semaphore */
1313     (void) SemaphoreP_post(instObj->lockSem);
1314
1315     return retVal;
1316 }
1317
1318 static int32_t Dss_dctrlDrvSetVpCscCoeffIoctl(
1319                             Dss_DctrlDrvInstObj *instObj,
1320                             const Dss_DctrlVpCscCoeff *vpCscCoeff)
1321 {
1322     int32_t retVal = FVID2_SOK;
1323     uint32_t cscPos, vpId;
1324     CSL_dss_vpRegs *vpRegs;
1325     const Dss_SocInfo *socInfo;
1326     const CSL_DssCscCoeff *cscCoeff;
1327
1328     /* Check for NULL pointers */
1329     GT_assert(DssTrace, (NULL != instObj));
1330     GT_assert(DssTrace, (NULL != vpCscCoeff));
1331
1332     /* Take the instance semaphore */
1333     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1334
1335     /* Get video port registers */
1336     vpId = vpCscCoeff->vpId;
1337     socInfo = Dss_getSocInfo();
1338     vpRegs = socInfo->vpRegs[vpId];
1339     GT_assert(DssTrace, (NULL != vpRegs));
1340
1341     /* Assign input parameters */
1342     cscPos = vpCscCoeff->cscPos;
1343     cscCoeff = &vpCscCoeff->cscCoeff;
1344
1345     /* Call CSL API */
1346     if(FVID2_SOK == retVal)
1347     {
1348         CSL_dssVpSetCSCCoeff(vpRegs, cscCoeff, cscPos, TRUE);
1349     }
1350
1351     if(FVID2_SOK != retVal)
1352     {
1353         GT_0trace(DssTrace, GT_ERR, "Set VP CSC coefficients IOCTL failed\r\n");
1354     }
1355
1356     /* Post the instance semaphore */
1357     (void) SemaphoreP_post(instObj->lockSem);
1358
1359     return retVal;
1360 }
1361
1362 static int32_t Dss_dctrlDrvSetAdvVpParamsIoctl(
1363                             Dss_DctrlDrvInstObj *instObj,
1364                             const Dss_DctrlAdvVpParams *advVpParams)
1365 {
1366     int32_t retVal = FVID2_SOK;
1367     CSL_dss_vpRegs *vpRegs;
1368     const Dss_SocInfo *socInfo;
1369     const CSL_DssVpLcdAdvSignalCfg *lcdAdvSignalCfg;
1370
1371     /* Check for NULL pointers */
1372     GT_assert(DssTrace, (NULL != instObj));
1373     GT_assert(DssTrace, (NULL != advVpParams));
1374
1375     /* Check for wrong inputs */
1376     if(advVpParams->vpId >= CSL_DSS_VP_ID_MAX)
1377     {
1378         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
1379         retVal = FVID2_EBADARGS;
1380     }
1381
1382     /* Take the instance semaphore */
1383     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1384
1385     if(FVID2_SOK == retVal)
1386     {
1387         /* Get video port registers */
1388         socInfo = Dss_getSocInfo();
1389         vpRegs = socInfo->vpRegs[advVpParams->vpId];
1390         GT_assert(DssTrace, (NULL != vpRegs));
1391
1392         /* Assign input parameters */
1393         lcdAdvSignalCfg = &advVpParams->lcdAdvSignalCfg;
1394
1395         /* Call CSL APIs */
1396         CSL_dssVpSetLcdAdvSignalConfig(vpRegs, lcdAdvSignalCfg);
1397     }
1398
1399     if(FVID2_SOK != retVal)
1400     {
1401         GT_0trace(DssTrace,
1402                   GT_ERR,
1403                   "Set advance VP parameters IOCTL failed\r\n");
1404     }
1405
1406     /* Post the instance semaphore */
1407     (void) SemaphoreP_post(instObj->lockSem);
1408
1409     return retVal;
1410 }
1411
1412 static int32_t Dss_dctrlDrvSetLcdBlankTimingIoctl(
1413                             Dss_DctrlDrvInstObj *instObj,
1414                             const Dss_DctrlLcdBlankTimingParams *timingParams)
1415 {
1416     int32_t retVal = FVID2_SOK;
1417     uint32_t vpId, scanFormat;
1418     CSL_dss_vpRegs *vpRegs;
1419     const Dss_SocInfo *socInfo;
1420     const CSL_DssVpLcdBlankTimingCfg *lcdBlankTimingCfg;
1421
1422     /* Check for NULL pointers */
1423     GT_assert(DssTrace, (NULL != instObj));
1424     GT_assert(DssTrace, (NULL != timingParams));
1425
1426     /* Check for wrong inputs */
1427     if(timingParams->vpId >= CSL_DSS_VP_ID_MAX)
1428     {
1429         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
1430         retVal = FVID2_EBADARGS;
1431     }
1432
1433     /* Take the instance semaphore */
1434     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1435
1436     if(FVID2_SOK == retVal)
1437     {
1438         /* Assign input parameters */
1439         vpId = timingParams->vpId;
1440         lcdBlankTimingCfg = &timingParams->lcdBlankTimingCfg;
1441
1442         /* Get scan format */
1443         scanFormat = gDss_DctrlDrvInfo.vpParams[vpId].lcdOpTimingCfg.mInfo.scanFormat;
1444
1445         /* Get video port registers */
1446         socInfo = Dss_getSocInfo();
1447         vpRegs = socInfo->vpRegs[vpId];
1448         GT_assert(DssTrace, (NULL != vpRegs));
1449
1450         /* Call CSL APIs */
1451         retVal = CSL_dssVpSetLcdBlankTiming(
1452                         vpRegs,
1453                         lcdBlankTimingCfg,
1454                         timingParams->dvoFormat,
1455                         scanFormat,
1456                         TRUE);
1457     }
1458
1459     if(FVID2_SOK != retVal)
1460     {
1461         GT_0trace(DssTrace, GT_ERR, "Set LCD blank timing IOCTL failed\r\n");
1462     }
1463
1464     /* Post the instance semaphore */
1465     (void) SemaphoreP_post(instObj->lockSem);
1466
1467     return retVal;
1468 }
1469
1470 static int32_t Dss_dctrlDrvSetVpSafetyChkParamsIoctl(
1471                             Dss_DctrlDrvInstObj *instObj,
1472                             const Dss_DctrlVpSafetyChkParams *safetyChkParams)
1473 {
1474     int32_t retVal = FVID2_SOK;
1475     uint32_t vpId, regionId, eventGroup, numHandle, evtMgrId, safetyEvt;
1476     Dss_DctrlDrvCommonObj *pObj;
1477     CSL_dss_vpRegs *vpRegs;
1478     const Dss_SocInfo *socInfo;
1479     const CSL_DssSafetyChkCfg *safetyChkCfg;
1480
1481     /* Check for NULL pointers */
1482     GT_assert(DssTrace, (NULL != instObj));
1483     GT_assert(DssTrace, (NULL != safetyChkParams));
1484
1485     /* Assign inputs */
1486     pObj = &gDss_DctrlDrvCommonObj;
1487     vpId = safetyChkParams->vpId;
1488     regionId = safetyChkParams->regionSafetyChkCfg.regionId;
1489     /* Check for wrong inputs */
1490     if((vpId >= CSL_DSS_VP_ID_MAX)||(regionId >= CSL_DSS_VP_SAFETY_REGION_MAX))
1491     {
1492         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
1493         retVal = FVID2_EBADARGS;
1494     }
1495     else
1496     {
1497         /* Get video port registers */
1498         socInfo = Dss_getSocInfo();
1499         vpRegs = socInfo->vpRegs[vpId];
1500         GT_assert(DssTrace, (NULL != vpRegs));
1501     }
1502
1503     /* Take the instance semaphore */
1504     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1505
1506     if(FVID2_SOK == retVal)
1507     {
1508         Fvid2Utils_memcpy(
1509                     &gDss_DctrlDrvInfo.safetyChkParams[regionId][vpId],
1510                     safetyChkParams,
1511                     sizeof (Dss_DctrlVpSafetyChkParams));
1512
1513         /* Register for Safety Error Events */
1514         Dss_convModuletoEventGroup(&eventGroup,
1515                                    vpId,
1516                                    DSS_EVENT_GROUP_TYPE_VP);
1517         GT_assert(DssTrace, (DSS_EVENT_GROUP_INVALID != eventGroup));
1518         numHandle = pObj->instObj->numRegEvtHandle;
1519         evtMgrId = Dss_getEvtMgrSafetyIntrId();
1520         safetyEvt = Dss_dctrlGetVpSafetyEvtId(regionId);
1521         GT_assert(DssTrace, (DSS_VP_EVENT_INVALID != safetyEvt));
1522         pObj->instObj->evtGroupHandle[pObj->instObj->numRegEvtHandle] =
1523                             Dss_evtMgrRegister(
1524                                 evtMgrId,
1525                                 eventGroup,
1526                                 (const uint32_t *)(&safetyEvt),
1527                                 1U,
1528                                 Dss_dctrlSafetyErrCbFxn,
1529                                 (void *)&gDss_DctrlEvtMgrClientInfo[numHandle]);
1530         pObj->instObj->numRegEvtHandle++;
1531
1532         /* Call CSL APIs */
1533         if(0U != safetyChkParams->safetySignSeedVal)
1534         {
1535             CSL_dssVpSetSafetySignSeedVal(vpRegs,
1536                                           safetyChkParams->safetySignSeedVal);
1537         }
1538         if(CSL_DSS_SAFETY_CHK_DATA_INTEGRITY ==
1539                 safetyChkParams->regionSafetyChkCfg.safetyChkCfg.safetyChkMode)
1540         {
1541             CSL_dssVpSetSafetyReferenceSign(
1542                             vpRegs,
1543                             safetyChkParams->regionSafetyChkCfg.referenceSign,
1544                             regionId);
1545         }
1546         safetyChkCfg = &safetyChkParams->regionSafetyChkCfg.safetyChkCfg;
1547         CSL_dssVpSetSafetyChkConfig(vpRegs, safetyChkCfg, regionId);
1548     }
1549
1550     if(FVID2_SOK != retVal)
1551     {
1552         GT_0trace(DssTrace,
1553                   GT_ERR,
1554                   "Register Safety Error Cb Params IOCTL failed\r\n");
1555     }
1556
1557     /* Post the instance semaphore */
1558     (void) SemaphoreP_post(instObj->lockSem);
1559
1560     return retVal;
1561 }
1562
1563 static int32_t Dss_dctrlDrvGetErrorStatsIoctl(
1564                             Dss_DctrlDrvInstObj *instObj,
1565                             Dss_DctrlVpErrorStats *vpErrStats)
1566 {
1567     int32_t retVal = FVID2_SOK;
1568     uint32_t i, vpFound = FALSE;
1569
1570     /* Check for NULL pointers */
1571     GT_assert(DssTrace, (NULL != instObj));
1572     GT_assert(DssTrace, (NULL != vpErrStats));
1573
1574     /* Check for wrong inputs */
1575     if(vpErrStats->vpId >= CSL_DSS_VP_ID_MAX)
1576     {
1577         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
1578         retVal = FVID2_EBADARGS;
1579     }
1580
1581     /* Take the instance semaphore */
1582     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1583
1584     if(FVID2_SOK == retVal)
1585     {
1586         /* Check if Video Port is valid */
1587         for(i=0U; i<CSL_DSS_VP_ID_MAX; i++)
1588         {
1589             if(gDss_DctrlDrvInfo.vpParams[i].vpId == vpErrStats->vpId)
1590             {
1591                 vpFound = TRUE;
1592                 break;
1593             }
1594         }
1595
1596         if(TRUE == vpFound)
1597         {
1598             retVal = FVID2_SOK;
1599             vpErrStats->syncLost =
1600                     gDss_DctrlDrvInfo.errorCnt.vpsyncLost[vpErrStats->vpId];
1601             for(i=0U; i<CSL_DSS_VP_SAFETY_REGION_MAX; i++)
1602             {
1603                 vpErrStats->safetyViolation[i] =
1604                     gDss_DctrlDrvInfo.errorCnt.vpSafetyViolation[i][vpErrStats->vpId];
1605             }
1606
1607             vpErrStats->securityViolation =
1608                     gDss_DctrlDrvInfo.errorCnt.vpSecurityViolation[vpErrStats->vpId];
1609         }
1610     }
1611
1612     if(FVID2_SOK != retVal)
1613     {
1614         GT_0trace(DssTrace, GT_ERR, "GET VP error stat IOCTL failed\r\n");
1615     }
1616
1617     /* Post the instance semaphore */
1618     (void) SemaphoreP_post(instObj->lockSem);
1619
1620     return retVal;
1621 }
1622
1623 static int32_t Dss_dctrlDrvSetGlobalDssParamsIoctl(
1624                             Dss_DctrlDrvInstObj *instObj,
1625                             const Dss_DctrlGlobalDssParams *globalDssParams)
1626 {
1627     int32_t retVal = FVID2_SOK;
1628     CSL_dss_commRegs *commRegs;
1629     const Dss_SocInfo *socInfo;
1630     const CSL_DssGlobalMFlagCfg *globalMflagCfg;
1631     const CSL_DssCbaCfg *cbaCfg;
1632
1633     /* Check for NULL pointers */
1634     GT_assert(DssTrace, (NULL != instObj));
1635     GT_assert(DssTrace, (NULL != globalDssParams));
1636
1637     /* Take the instance semaphore */
1638     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1639
1640     /* Get common registers */
1641     socInfo = Dss_getSocInfo();
1642     commRegs = socInfo->commRegs[CSL_DSS_COMM_REG_ID_0];
1643     GT_assert(DssTrace, (NULL != commRegs));
1644
1645     /* Assign input parameters */
1646     globalMflagCfg = &globalDssParams->globalMflagCfg;
1647     cbaCfg = &globalDssParams->cbaCfg;
1648
1649     /* Call CSL APIs */
1650     if(FVID2_SOK == retVal)
1651     {
1652         CSL_dssSetGlobalMflagConfig(commRegs, globalMflagCfg);
1653         CSL_dssSetCbaConfig(commRegs, cbaCfg);
1654     }
1655
1656     if(FVID2_SOK != retVal)
1657     {
1658         GT_0trace(DssTrace, GT_ERR, "Set global parameters IOCTL failed\r\n");
1659     }
1660
1661     /* Post the instance semaphore */
1662     (void) SemaphoreP_post(instObj->lockSem);
1663
1664     return retVal;
1665 }
1666
1667 #if defined (SOC_AM65XX)
1668 static int32_t Dss_dctrlDrvSetOldiParamsIoctl(
1669                             Dss_DctrlDrvInstObj *instObj,
1670                             const Dss_DctrlOldiParams *oldiParams)
1671 {
1672     int32_t retVal = FVID2_SOK;
1673     uint32_t resetOldi = FALSE;
1674     CSL_dss_commRegs *commRegs;
1675     CSL_dss_vpRegs *vpRegs;
1676     const Dss_SocInfo *socInfo;
1677     const CSL_DssVpOldiCfg *oldiCfg;
1678
1679     /* Check for NULL pointers */
1680     GT_assert(DssTrace, (NULL != instObj));
1681     GT_assert(DssTrace, (NULL != oldiParams));
1682
1683     /* Take the instance semaphore */
1684     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1685
1686     /* Get video port registers */
1687     socInfo = Dss_getSocInfo();
1688     vpRegs = socInfo->vpRegs[oldiParams->vpId];
1689     GT_assert(DssTrace, (NULL != vpRegs));
1690
1691     /* Get common registers */
1692     commRegs = socInfo->commRegs[CSL_DSS_COMM_REG_ID_0];
1693     GT_assert(DssTrace, (NULL != commRegs));
1694
1695     /* Assign input parameters */
1696     oldiCfg = &oldiParams->oldiCfg;
1697
1698     /* Call CSL APIs */
1699     CSL_dssVpOldiReset(vpRegs);
1700     do
1701     {
1702         resetOldi = CSL_dssIsOldiResetDone(commRegs);
1703     } while (TRUE != resetOldi);
1704
1705     CSL_dssVpSetOldiConfig(vpRegs, oldiCfg);
1706     CSL_dssVpOldiEnable(vpRegs, TRUE);
1707
1708     if(FVID2_SOK != retVal)
1709     {
1710         GT_0trace(DssTrace, GT_ERR, "Set OLDI parameters IOCTL failed\r\n");
1711     }
1712
1713     /* Post the instance semaphore */
1714     (void) SemaphoreP_post(instObj->lockSem);
1715
1716     return retVal;
1717 }
1718 #endif
1719
1720 static int32_t Dss_dctrlDrvStopVpIoctl(Dss_DctrlDrvInstObj *instObj,
1721                                        const Dss_DctrlVpParams *vpParams)
1722 {
1723     int32_t retVal = FVID2_SOK;
1724     uint32_t i, vpId, syncVpId;
1725     uint32_t vpFound = FALSE;
1726     uint32_t cookie;
1727     Dss_DctrlVpParams *sVpParams = NULL;
1728
1729     /* Check for NULL pointers */
1730     GT_assert(DssTrace, (NULL != instObj));
1731     GT_assert(DssTrace, (NULL != vpParams));
1732     GT_assert(DssTrace, (vpParams->vpId < CSL_DSS_VP_ID_MAX));
1733
1734     vpId = vpParams->vpId;
1735     sVpParams = &gDss_DctrlDrvInfo.vpParams[vpId];
1736
1737     /* Check for wrong inputs */
1738     if(vpParams->vpId >= CSL_DSS_VP_ID_MAX)
1739     {
1740         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
1741         retVal = FVID2_EBADARGS;
1742     }
1743
1744     /* Take the instance semaphore */
1745     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1746
1747     if(FVID2_SOK == retVal)
1748     {
1749         if((DSS_DCTRL_VP_RUNNING != gDss_DctrlDrvInfo.vpState[vpId]) &&
1750         (DSS_DCTRL_VP_STARTING != gDss_DctrlDrvInfo.vpState[vpId]))
1751         {
1752             GT_0trace(DssTrace, GT_ERR, "VP not started!!\r\n");
1753             retVal = FVID2_EBADARGS;
1754         }
1755     }
1756
1757     if((FVID2_SOK == retVal) &&
1758     (TRUE == sVpParams->syncOpCfg.enabled) &&
1759     (TRUE == sVpParams->syncOpCfg.isPrimary))
1760     {
1761         for(i = 0; i < sVpParams->syncOpCfg.numSyncVpIds; i++)
1762         {
1763             syncVpId = sVpParams->syncOpCfg.syncVpIds[i];
1764
1765             if(DSS_DCTRL_VP_STOPPING != gDss_DctrlDrvInfo.vpState[syncVpId])
1766             {
1767                 vpFound = TRUE;
1768             }
1769         }
1770
1771         if(TRUE == vpFound)
1772         {
1773             GT_0trace(DssTrace, GT_ERR, "Secondary sync VPs not stopped!!\r\n");
1774             retVal = FVID2_EBADARGS;
1775         }
1776     }
1777
1778 #if defined (SOC_J721E)
1779     if((FVID2_SOK == retVal) && (TRUE == Dss_dctrlDrvIsOutputDP(vpId)))
1780     {
1781         retVal = Dss_dctrlDrvDisableVideoDP();
1782     }
1783 #endif
1784
1785     if(FVID2_SOK == retVal)
1786     {
1787         cookie = HwiP_disable();
1788         Dss_dctrlVpEnable(vpId, FALSE);
1789         HwiP_restore(cookie);
1790
1791         Dss_dctrlVpReset(vpId);
1792
1793         if((TRUE == sVpParams->syncOpCfg.enabled) &&
1794         (TRUE == sVpParams->syncOpCfg.isPrimary))
1795         {
1796             for(i = 0; i < sVpParams->syncOpCfg.numSyncVpIds; i++)
1797             {
1798                 syncVpId = sVpParams->syncOpCfg.syncVpIds[i];
1799                 Dss_dctrlVpReset(syncVpId);
1800             }
1801         }
1802     }
1803
1804     if(FVID2_SOK != retVal)
1805     {
1806         GT_0trace(DssTrace, GT_ERR, "Stop VP IOCTL failed\r\n");
1807     }
1808
1809     /* Post the instance semaphore */
1810     (void) SemaphoreP_post(instObj->lockSem);
1811
1812     return retVal;
1813 }
1814
1815 static int32_t Dss_dctrlDrvSetSyncLostCbParamsIoctl(
1816                             Dss_DctrlDrvInstObj *instObj,
1817                             const Dss_DctrlSyncLostCbParams *syncLostCbParams)
1818 {
1819     int32_t retVal = FVID2_SOK;
1820     uint32_t vpId;
1821
1822     /* Check for NULL pointers */
1823     GT_assert(DssTrace, (NULL != instObj));
1824     GT_assert(DssTrace, (NULL != syncLostCbParams));
1825
1826     /* Check for wrong inputs */
1827     if(syncLostCbParams->vpId >= CSL_DSS_VP_ID_MAX)
1828     {
1829         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
1830         retVal = FVID2_EBADARGS;
1831     }
1832
1833     /* Take the instance semaphore */
1834     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1835
1836     if(FVID2_SOK == retVal)
1837     {
1838         vpId = syncLostCbParams->vpId;
1839         Fvid2Utils_memcpy(&gDss_DctrlDrvInfo.syncLostCbParams[vpId],
1840                           syncLostCbParams,
1841                           sizeof (Dss_DctrlSyncLostCbParams));
1842     }
1843
1844     if(FVID2_SOK != retVal)
1845     {
1846         GT_0trace(DssTrace,
1847                   GT_ERR,
1848                   "Register Sync Lost Cb Params IOCTL failed\r\n");
1849     }
1850
1851     /* Post the instance semaphore */
1852     (void) SemaphoreP_post(instObj->lockSem);
1853
1854     return retVal;
1855 }
1856
1857 static int32_t Dss_dctrlDrvSetLineNumCbParamsIoctl(
1858                             Dss_DctrlDrvInstObj *instObj,
1859                             const Dss_DctrlLineNumCbParams *lineNumCbParams)
1860 {
1861     int32_t retVal = FVID2_SOK;
1862     uint32_t vpId = lineNumCbParams->vpId;
1863
1864     /* Check for NULL pointers */
1865     GT_assert(DssTrace, (NULL != instObj));
1866     GT_assert(DssTrace, (NULL != lineNumCbParams));
1867
1868     /* Check for wrong inputs */
1869     if(vpId >= CSL_DSS_VP_ID_MAX)
1870     {
1871         GT_0trace(DssTrace, GT_ERR, "Invalid argument!!\r\n");
1872         retVal = FVID2_EBADARGS;
1873     }
1874
1875     /* Take the instance semaphore */
1876     (void) SemaphoreP_pend(instObj->lockSem, SemaphoreP_WAIT_FOREVER);
1877
1878     if(FVID2_SOK == retVal)
1879     {
1880         Fvid2Utils_memcpy(&gDss_DctrlDrvInfo.lineNumCbParams[vpId],
1881                           lineNumCbParams,
1882                           sizeof (Dss_DctrlLineNumCbParams));
1883     }
1884
1885     if(FVID2_SOK != retVal)
1886     {
1887         GT_0trace(DssTrace,
1888                   GT_ERR,
1889                   "Register Line Num Cb Params IOCTL failed\r\n");
1890     }
1891
1892     /* Post the instance semaphore */
1893     (void) SemaphoreP_post(instObj->lockSem);
1894
1895     return retVal;
1896 }
1897
1898 static void Dss_dctrlFuncCbFxn(const uint32_t *event,
1899                                uint32_t numEvents,
1900                                void *arg)
1901 {
1902     uint32_t  i, j, currEvent, vpId = 0U, activePipeNum;
1903     Dss_EvtMgrClientInfo *pClientObj = (Dss_EvtMgrClientInfo *)arg;
1904
1905     GT_assert(DssTrace,
1906               (gDss_DctrlDrvInfo.numValidPipes <= CSL_DSS_VID_PIPE_ID_MAX));
1907
1908     uint32_t eventGroup = pClientObj->eventGroup;
1909     Dss_convEventGrouptoModule(eventGroup, &vpId);
1910     GT_assert(DssTrace, (CSL_DSS_MODULE_INVALID != vpId));
1911
1912     for(i=0U; i<numEvents; i++)
1913     {
1914         currEvent = event[i];
1915         if(DSS_VP_EVENT_LINE_NUM == currEvent)
1916         {
1917             gDss_DctrlDrvInfo.isPushSafe[vpId] = FALSE;
1918             if(NULL != gDss_DctrlDrvInfo.lineNumCbParams[vpId].lineNumCbFxn)
1919             {
1920                 gDss_DctrlDrvInfo.lineNumCbParams[vpId].lineNumCbFxn(
1921                             vpId,
1922                             gDss_DctrlDrvInfo.lineNumCbParams[vpId].appData);
1923             }
1924         }
1925         else if(DSS_VP_EVENT_VSYNC == currEvent)
1926         {
1927             activePipeNum = 0U;
1928             for(j=0U; j<gDss_DctrlDrvInfo.numValidPipes; j++)
1929             {
1930                 if(gDss_DctrlDrvInfo.pipeInfo[j].vpId == vpId)
1931                 {
1932                     if((gDss_DctrlDrvInfo.pipeInfo[j].pipeState ==
1933                                                 DSS_DCTRL_PIPE_STARTING)     ||
1934                        (gDss_DctrlDrvInfo.pipeInfo[j].pipeState ==
1935                                                 DSS_DCTRL_PIPE_STARTED)      ||
1936                        (gDss_DctrlDrvInfo.pipeInfo[j].pipeState ==
1937                                                 DSS_DCTRL_PIPE_RUNNING)      ||
1938                        (gDss_DctrlDrvInfo.pipeInfo[j].pipeState ==
1939                                                 DSS_DCTRL_PIPE_STOPPING))
1940                     {
1941                         activePipeNum++;
1942                         if(gDss_DctrlDrvInfo.pipeInfo[j].pipeState ==
1943                                                     DSS_DCTRL_PIPE_STARTING)
1944                         {
1945                             /* This is the first VSync for dummy start i.e.
1946                              * either start is synchronous or start was called
1947                              * close to VSYNC */
1948                             gDss_DctrlDrvInfo.pipeInfo[j].pipeState =
1949                                                         DSS_DCTRL_PIPE_STARTED;
1950                         }
1951                         if(gDss_DctrlDrvInfo.pipeInfo[j].pipeState ==
1952                                                     DSS_DCTRL_PIPE_STARTED)
1953                         {
1954                             /* This is the first actual VSync where the buffer
1955                              * B1's display has started */
1956                             gDss_DctrlDrvInfo.pipeInfo[j].pipeState =
1957                                                         DSS_DCTRL_PIPE_RUNNING;
1958                         }
1959                         if(gDss_DctrlDrvInfo.pipeInfo[j].pipeState ==
1960                                                     DSS_DCTRL_PIPE_STOPPING)
1961                         {
1962                             /* This is the VSYNC before synchronous stop */
1963                             gDss_DctrlDrvInfo.pipeInfo[j].pipeState =
1964                                                         DSS_DCTRL_PIPE_STOPPED;
1965                         }
1966                         gDss_DctrlDrvInfo.isPushSafe[vpId] = TRUE;
1967                         GT_assert(DssTrace,
1968                                   (NULL !=
1969                                    gDss_DctrlDrvInfo.pipeInfo[j].gClientInfo.cbFxn));
1970                         gDss_DctrlDrvInfo.pipeInfo[j].gClientInfo.cbFxn(
1971                             gDss_DctrlDrvInfo.pipeInfo[j].gClientInfo.arg);
1972                     }
1973                     else if(gDss_DctrlDrvInfo.pipeInfo[j].pipeState ==
1974                                                     DSS_DCTRL_PIPE_STOPPED)
1975                     {
1976                         /* This is the actual stop */
1977                         gDss_DctrlDrvInfo.pipeInfo[j].pipeState =
1978                                                         DSS_DCTRL_PIPE_OPENED;
1979                         (void) SemaphoreP_post(gDss_DctrlDrvInfo.pipeInfo[j].stopSem);
1980                     }
1981                     else {
1982                         /* To fix MISRAC issue - this is a valid else - do nothing */
1983                     }
1984                 }
1985             }
1986
1987             if(activePipeNum > 0U)
1988             {
1989                 Dss_dctrlVpSetGoBit(vpId);
1990             }
1991         }
1992         else
1993         {
1994             GT_assert(DssTrace, FALSE);
1995         }
1996     }
1997
1998     return;
1999 }
2000
2001 static void Dss_dctrlErrCbFxn(const uint32_t *event,
2002                               uint32_t numEvents,
2003                               void *arg)
2004 {
2005     uint32_t  i, currEvent, vpId = 0U;
2006     Dss_EvtMgrClientInfo *pClientObj = (Dss_EvtMgrClientInfo *)arg;
2007     uint32_t eventGroup = pClientObj->eventGroup;
2008     Dss_DctrlDrvErrorCount *pErrorCnt;
2009
2010     pErrorCnt = &gDss_DctrlDrvInfo.errorCnt;
2011     Dss_convEventGrouptoModule(eventGroup, &vpId);
2012     GT_assert(DssTrace, (CSL_DSS_MODULE_INVALID != vpId));
2013
2014     for(i=0U; i<numEvents; i++)
2015     {
2016         currEvent = event[i];
2017         if(DSS_VP_EVENT_SYNC_LOST == currEvent)
2018         {
2019            pErrorCnt->vpsyncLost[vpId]++;
2020            if(NULL != gDss_DctrlDrvInfo.syncLostCbParams[vpId].syncLostCbFxn)
2021            {
2022                gDss_DctrlDrvInfo.syncLostCbParams[vpId].syncLostCbFxn(
2023                             vpId,
2024                             gDss_DctrlDrvInfo.syncLostCbParams[vpId].appData);
2025            }
2026         }
2027         else
2028         {
2029             GT_assert(DssTrace, FALSE);
2030         }
2031     }
2032
2033     return;
2034 }
2035
2036 static void Dss_dctrlSafetyErrCbFxn(const uint32_t *event,
2037                                     uint32_t numEvents,
2038                                     void *arg)
2039 {
2040     uint32_t  i, currEvent, vpId = 0U, regionId;
2041     Dss_EvtMgrClientInfo *pClientObj = (Dss_EvtMgrClientInfo *)arg;
2042     uint32_t eventGroup = pClientObj->eventGroup;
2043     Dss_DctrlDrvErrorCount *pErrorCnt;
2044     Dss_DctrlVpSafetyChkParams *pSafetyChkParams;
2045     CSL_dss_vpRegs *vpRegs;
2046     const Dss_SocInfo *socInfo;
2047
2048     pErrorCnt = &gDss_DctrlDrvInfo.errorCnt;
2049     Dss_convEventGrouptoModule(eventGroup, &vpId);
2050     GT_assert(DssTrace, (CSL_DSS_MODULE_INVALID != vpId));
2051
2052     /* Get video port registers */
2053     socInfo = Dss_getSocInfo();
2054     vpRegs = socInfo->vpRegs[vpId];
2055     GT_assert(DssTrace, (NULL != vpRegs));
2056
2057     for(i=0U; i<numEvents; i++)
2058     {
2059         currEvent = event[i];
2060         if(TRUE == Dss_dctrlIsSafetyEvent(currEvent))
2061         {
2062             regionId = Dss_dctrlGetVpSafetyRegionId(currEvent);
2063             GT_assert(DssTrace, (CSL_DSS_VP_SAFETY_REGION_INVALID != regionId));
2064             pErrorCnt->vpSafetyViolation[regionId][vpId]++;
2065             pSafetyChkParams = &gDss_DctrlDrvInfo.safetyChkParams[regionId][vpId];
2066             pSafetyChkParams->safetyCbData.regionId = regionId;
2067             if(CSL_DSS_SAFETY_CHK_DATA_INTEGRITY ==
2068                 pSafetyChkParams->regionSafetyChkCfg.safetyChkCfg.safetyChkMode)
2069             {
2070                 pSafetyChkParams->safetyCbData.capturedSign =
2071                                     CSL_dssVpGetSafetySign(vpRegs, regionId);
2072             }
2073
2074             if(NULL != pSafetyChkParams->safetyErrCbFxn)
2075             {
2076                 pSafetyChkParams->safetyErrCbFxn(vpId,
2077                                                  pSafetyChkParams->safetyCbData,
2078                                                  pSafetyChkParams->appData);
2079             }
2080         }
2081         else
2082         {
2083             GT_assert(DssTrace, FALSE);
2084         }
2085     }
2086
2087     return;
2088 }
2089
2090 static int32_t Dss_dctrlConnectNodes(uint32_t inputNode, uint32_t outNode)
2091 {
2092     int32_t retVal = FVID2_SOK;
2093
2094     if((FALSE == Dss_dctrlIsValidNode(inputNode)) ||
2095        (FALSE == Dss_dctrlIsValidNode(outNode)))
2096     {
2097         retVal = FVID2_EBADARGS;
2098     }
2099
2100     if(TRUE == Dss_dctrlIsVideoMuxNeeded(inputNode, outNode))
2101     {
2102         retVal = Dss_dctrlProgramVideoMux(inputNode,
2103                                           outNode);
2104         GT_assert(DssTrace, (FVID2_SOK == retVal));
2105     }
2106
2107     return (retVal);
2108 }
2109
2110 static void Dss_dctrlVpSetGoBit(uint32_t vpId)
2111 {
2112     CSL_dss_vpRegs *vpRegs;
2113     CSL_dss_commRegs *commRegs;
2114     const Dss_SocInfo *socInfo;
2115     const Dss_DctrlVpParams *vpParams;
2116     uint32_t syncVpId;
2117     uint32_t vpMask;
2118     uint32_t i;
2119
2120     socInfo = Dss_getSocInfo();
2121
2122     /* Get video port registers */
2123     vpRegs = socInfo->vpRegs[vpId];
2124     GT_assert(DssTrace, (NULL != vpRegs));
2125
2126     /* Get DSS common_m / common_0 registers */
2127     /* XXX if common_0/m is not enabled in rmInfo? */
2128     commRegs = socInfo->commRegs[0U];
2129     GT_assert(DssTrace, (NULL != commRegs));
2130
2131     vpParams = &gDss_DctrlDrvInfo.vpParams[vpId];
2132
2133     if(TRUE == vpParams->syncOpCfg.enabled)
2134     {
2135         if(TRUE == vpParams->syncOpCfg.isPrimary)
2136         {
2137             vpMask = (uint32_t)(1U << vpId);
2138             for(i = 0U; i < vpParams->syncOpCfg.numSyncVpIds; i++)
2139             {
2140                 syncVpId = vpParams->syncOpCfg.syncVpIds[i];
2141                 vpMask |= (uint32_t)(1U << syncVpId);
2142             }
2143
2144             CSL_dssGlobalVpGoBitEnable(commRegs, vpMask);
2145         }
2146     }
2147     else
2148     {
2149         CSL_dssVpSetGoBit(vpRegs);
2150     }
2151 }
2152
2153 static void Dss_dctrlVpReset(uint32_t vpId)
2154 {
2155     CSL_dss_vpRegs *vpRegs;
2156     const Dss_SocInfo *socInfo;
2157     CSL_DssVpLcdSignalPolarityCfg lcdPolarityCfg;
2158     CSL_DssVpLcdOpTimingCfg lcdOpTimingCfg;
2159     CSL_DssVpLcdTdmCfg lcdTdmCfg;
2160
2161     socInfo = Dss_getSocInfo();
2162
2163     /* Get video port registers */
2164     vpRegs = socInfo->vpRegs[vpId];
2165     GT_assert(DssTrace, (NULL != vpRegs));
2166
2167     CSL_dssVpLcdTdmCfgInit(&lcdTdmCfg);
2168     CSL_dssVpLcdSignalPolarityCfgInit(&lcdPolarityCfg);
2169     CSL_dssVpLcdOpTimingCfgInit(&lcdOpTimingCfg);
2170
2171     CSL_dssVpSetLcdSignalPolarityConfig(
2172         vpRegs,
2173         (const CSL_DssVpLcdSignalPolarityCfg *)(&lcdPolarityCfg));
2174     CSL_dssVpSetLcdTdmConfig(
2175         vpRegs,
2176         (const CSL_DssVpLcdTdmCfg *)(&lcdTdmCfg));
2177
2178     /* There is no point in checking the result here. We are resetting */
2179     (void) CSL_dssVpSetLcdOpTimingConfig(vpRegs, &lcdOpTimingCfg);
2180 }
2181
2182 static void Dss_dctrlVpEnable(uint32_t vpId, uint32_t enable)
2183 {
2184     CSL_dss_vpRegs *vpRegs;
2185     CSL_dss_commRegs *commRegs;
2186     const Dss_SocInfo *socInfo;
2187     const Dss_DctrlVpParams *vpParams;
2188     uint32_t syncVpId;
2189     uint32_t vpMask;
2190     uint32_t i;
2191
2192     socInfo = Dss_getSocInfo();
2193
2194     /* Get video port registers */
2195     vpRegs = socInfo->vpRegs[vpId];
2196     GT_assert(DssTrace, (NULL != vpRegs));
2197
2198     /* Get DSS common_m / common_0 registers */
2199     /* XXX if common_0/m is not enabled in rmInfo? */
2200     commRegs = socInfo->commRegs[0U];
2201     GT_assert(DssTrace, (NULL != commRegs));
2202
2203     vpParams = &gDss_DctrlDrvInfo.vpParams[vpId];
2204
2205     if(TRUE == vpParams->syncOpCfg.enabled)
2206     {
2207         if(TRUE == vpParams->syncOpCfg.isPrimary)
2208         {
2209             vpMask = (uint32_t)(1U << vpId);
2210             for(i = 0U; i < vpParams->syncOpCfg.numSyncVpIds; i++)
2211             {
2212                 syncVpId = vpParams->syncOpCfg.syncVpIds[i];
2213                 vpMask |= (uint32_t)(1U << syncVpId);
2214             }
2215
2216             CSL_dssGlobalVpEnable(commRegs, vpMask, enable);
2217
2218             if(TRUE == enable)
2219             {
2220                 gDss_DctrlDrvInfo.vpState[vpId] = DSS_DCTRL_VP_RUNNING;
2221             }
2222             else
2223             {
2224                 gDss_DctrlDrvInfo.vpState[vpId] = DSS_DCTRL_VP_IDLE;
2225             }
2226
2227             for(i = 0U; i < vpParams->syncOpCfg.numSyncVpIds; i++)
2228             {
2229                 syncVpId = vpParams->syncOpCfg.syncVpIds[i];
2230                 if(TRUE == enable)
2231                 {
2232                     gDss_DctrlDrvInfo.vpState[syncVpId] = DSS_DCTRL_VP_RUNNING;
2233                 }
2234                 else
2235                 {
2236                     gDss_DctrlDrvInfo.vpState[syncVpId] = DSS_DCTRL_VP_IDLE;
2237                 }
2238             }
2239         }
2240         else
2241         {
2242             if(TRUE == enable)
2243             {
2244                 gDss_DctrlDrvInfo.vpState[vpId] = DSS_DCTRL_VP_STARTING;
2245             }
2246             else
2247             {
2248                 gDss_DctrlDrvInfo.vpState[vpId] = DSS_DCTRL_VP_STOPPING;
2249             }
2250         }
2251     }
2252     else
2253     {
2254         CSL_dssVpEnable(vpRegs, enable);
2255         if(TRUE == enable)
2256         {
2257             gDss_DctrlDrvInfo.vpState[vpId] = DSS_DCTRL_VP_RUNNING;
2258         }
2259         else
2260         {
2261             gDss_DctrlDrvInfo.vpState[vpId] = DSS_DCTRL_VP_IDLE;
2262         }
2263     }
2264 }