packages/ti/board/src/devices/fpd/ds90ub941.c

   1 /******************************************************************************\r
   2  * Copyright (c) 2019 Texas Instruments Incorporated - http://www.ti.com\r
   3  *\r
   4  *  Redistribution and use in source and binary forms, with or without\r
   5  *  modification, are permitted provided that the following conditions\r
   6  *  are met:\r
   7  *\r
   8  *    Redistributions of source code must retain the above copyright\r
   9  *    notice, this list of conditions and the following disclaimer.\r
  10  *\r
  11  *    Redistributions in binary form must reproduce the above copyright\r
  12  *    notice, this list of conditions and the following disclaimer in the\r
  13  *    documentation and/or other materials provided with the\r
  14  *    distribution.\r
  15  *\r
  16  *    Neither the name of Texas Instruments Incorporated nor the names of\r
  17  *    its contributors may be used to endorse or promote products derived\r
  18  *    from this software without specific prior written permission.\r
  19  *\r
  20  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
  21  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
  22  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
  23  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
  24  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
  25  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
  26  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
  27  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
  28  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
  29  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  30  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  31  *\r
  32  *****************************************************************************/\r
  33 \r
  34 /**\r
  35  * \file    ds90ub941.c\r
  36  *\r
  37  * This file contains the default API's for initializing the\r
  38  * FPD module for the communicating with the remote slave device.\r
  39  *\r
  40  */\r
  41 \r
  42 #include "ds90ub941.h"\r
  43 \r
  44 /**\r
  45  * \brief  DSI Reset mode control\r
  46  *\r
  47  * This function is used for configuring the analog (or)\r
  48  * digital DSI reset mode.\r
  49  *\r
  50  * \param   handle        [IN]   Low level driver handle\r
  51  * \param   fpdModParams  [IN]   FPD module params\r
  52  * \param   cfgMode       [IN]   Config mode - Normal operation (or) Reset\r
  53  *\r
  54  * \return  Board_STATUS in case of success or appropriate error code.\r
  55  *\r
  56  */\r
  57 Board_STATUS Board_fpdUb941SetResetModeCtrl(void *handle,\r
  58                                             Board_FpdModuleObj *fpdModParams,\r
  59                                             uint8_t cfgMode)\r
  60 {\r
  61     Board_STATUS ret = BOARD_SOK;\r
  62     uint8_t regData = 0;\r
  63 \r
  64     if(handle == NULL)\r
  65     {\r
  66         return BOARD_INVALID_PARAM;\r
  67     }\r
  68 \r
  69     ret = Board_i2c8BitRegRd(handle,\r
  70                              fpdModParams->serSlvAddr,\r
  71                              BOARD_FPD_UB941_RESET_CTL_REG_ADDR,\r
  72                              &regData,\r
  73                              1U,\r
  74                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
  75     if(ret != 0)\r
  76     {\r
  77         return BOARD_I2C_TRANSFER_FAIL;\r
  78     }\r
  79 \r
  80     regData &= ~(BOARD_FPD_UB941_DISABLE_DSI_BIT_MASK);\r
  81     regData |= (cfgMode << BOARD_FPD_UB941_DISABLE_DSI_SHIFT_CNT);\r
  82 \r
  83     ret = Board_i2c8BitRegWr(handle,\r
  84                              fpdModParams->serSlvAddr,\r
  85                              BOARD_FPD_UB941_RESET_CTL_REG_ADDR,\r
  86                              &regData,\r
  87                              1U,\r
  88                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
  89     if(ret != 0)\r
  90     {\r
  91         return BOARD_I2C_TRANSFER_FAIL;\r
  92     }\r
  93 \r
  94     return BOARD_SOK;\r
  95         \r
  96 }\r
  97 \r
  98 /**\r
  99  * \brief Digital reset1 mode control\r
 100  *\r
 101  * This function is used for configuring the operational\r
 102  * mode of Digital RESET1.\r
 103  *\r
 104  * \param   handle        [IN]   Low level driver handle\r
 105  * \param   fpdModParams  [IN]   FPD module params\r
 106  * \param   cfgMode       [IN]   Config mode - Normal operation (or) Reset\r
 107  *\r
 108  * \return  Board_STATUS in case of success or appropriate error code.\r
 109  *\r
 110  */\r
 111 Board_STATUS Board_fpdUb941SetDigtialRst1ModeCtrl(void *handle,\r
 112                                                   Board_FpdModuleObj *fpdModParams,\r
 113                                                   uint8_t cfgMode)\r
 114 {\r
 115     Board_STATUS ret = BOARD_SOK;\r
 116     uint8_t regData = 0;\r
 117 \r
 118     if(handle == NULL)\r
 119     {\r
 120         return BOARD_INVALID_PARAM;\r
 121     }\r
 122 \r
 123     ret = Board_i2c8BitRegRd(handle,\r
 124                              fpdModParams->serSlvAddr,\r
 125                              BOARD_FPD_UB941_RESET_CTL_REG_ADDR,\r
 126                              &regData,\r
 127                              1U,\r
 128                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 129     if(ret != 0)\r
 130     {\r
 131         return BOARD_I2C_TRANSFER_FAIL;\r
 132     }\r
 133 \r
 134     regData &= ~(BOARD_FPD_UB941_DIGITAL_RESET1_BIT_MASK);\r
 135     regData |= (cfgMode << BOARD_FPD_UB941_DIGITAL_RESET1_SHIFT_CNT);\r
 136 \r
 137     ret = Board_i2c8BitRegWr(handle,\r
 138                              fpdModParams->serSlvAddr,\r
 139                              BOARD_FPD_UB941_RESET_CTL_REG_ADDR,\r
 140                              &regData,\r
 141                              1U,\r
 142                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 143     if(ret != 0)\r
 144     {\r
 145         return BOARD_I2C_TRANSFER_FAIL;\r
 146     }\r
 147 \r
 148     return BOARD_SOK;\r
 149         \r
 150 }\r
 151 \r
 152 /**\r
 153  * \brief Digital reset0 mode control\r
 154  *\r
 155  * This function is used for configuring the operational\r
 156  * mode of Digital RESET0.\r
 157  *\r
 158  * \param   handle        [IN]   Low level driver handle\r
 159  * \param   fpdModParams  [IN]   FPD module params\r
 160  * \param   cfgMode       [IN]   Config mode - Normal operation (or) Reset\r
 161  *\r
 162  * \return  Board_STATUS in case of success or appropriate error code.\r
 163  *\r
 164  */\r
 165 Board_STATUS Board_fpdUb941SetDigtialRst0ModeCtrl(void *handle,\r
 166                                                   Board_FpdModuleObj *fpdModParams,\r
 167                                                   uint8_t cfgMode)\r
 168 {\r
 169     Board_STATUS ret = BOARD_SOK;\r
 170     uint8_t regData = 0;\r
 171 \r
 172     if(handle == NULL)\r
 173     {\r
 174         return BOARD_INVALID_PARAM;\r
 175     }\r
 176 \r
 177     ret = Board_i2c8BitRegRd(handle,\r
 178                              fpdModParams->serSlvAddr,\r
 179                              BOARD_FPD_UB941_RESET_CTL_REG_ADDR,\r
 180                              &regData,\r
 181                              1U,\r
 182                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 183     if(ret != 0)\r
 184     {\r
 185         return BOARD_I2C_TRANSFER_FAIL;\r
 186     }\r
 187 \r
 188     regData &= ~(BOARD_FPD_UB941_DIGITAL_RESET0_BIT_MASK);\r
 189     regData |= (cfgMode << BOARD_FPD_UB941_DIGITAL_RESET0_SHIFT_CNT);\r
 190 \r
 191     ret = Board_i2c8BitRegWr(handle,\r
 192                              fpdModParams->serSlvAddr,\r
 193                              BOARD_FPD_UB941_RESET_CTL_REG_ADDR,\r
 194                              &regData,\r
 195                              1U,\r
 196                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 197     if(ret != 0)\r
 198     {\r
 199         return BOARD_I2C_TRANSFER_FAIL;\r
 200     }\r
 201 \r
 202     return BOARD_SOK;\r
 203 \r
 204 }\r
 205 \r
 206 /**\r
 207  * \brief DSI1 clock lane pin order select\r
 208  *\r
 209  * This function is used to select the DSI1 clock lane pin order.\r
 210  *\r
 211  * \param   handle        [IN]   Low level driver handle\r
 212  * \param   fpdModParams  [IN]   FPD module params\r
 213  * \param   operMode      [IN]   Operational mode to be configured\r
 214  *                               BOARD_FPD_UB941_CLK_LANE_PN_MAINTIAN - DSI Port1\r
 215  *                               Clock Lane P inputs mapped to P, N inputs\r
 216  *                               mapped to N\r
 217  *                               BOARD_FPD_UB941_CLK_LANE_PN_SWAP - DSI Port1\r
 218  *                               Clock Lane P inputs mapped to P, N inputs\r
 219  *                               mapped to P\r
 220  *\r
 221  * \return  Board_STATUS in case of success or appropriate error code.\r
 222  *\r
 223  */\r
 224 Board_STATUS Board_fpdUb941SetDsi1ClkPinOrd(void *handle,\r
 225                                             Board_FpdModuleObj *fpdModParams,\r
 226                                             uint8_t operMode)\r
 227 {\r
 228     Board_STATUS ret = BOARD_SOK;\r
 229     uint8_t regData = 0;\r
 230 \r
 231     if(handle == NULL)\r
 232     {\r
 233         return BOARD_INVALID_PARAM;\r
 234     }\r
 235 \r
 236     ret = Board_i2c8BitRegRd(handle,\r
 237                              fpdModParams->serSlvAddr,\r
 238                              BOARD_FPD_UB941_DEVICE_CFG_REG_ADDR,\r
 239                              &regData,\r
 240                              1U,\r
 241                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 242     if(ret != 0)\r
 243     {\r
 244         return BOARD_I2C_TRANSFER_FAIL;\r
 245     }\r
 246 \r
 247     regData &= ~(BOARD_FPD_UB941_DSI1_CLK_PN_SWAP_BIT_MASK);\r
 248     regData |= (operMode << BOARD_FPD_UB941_DSI1_CLK_PN_SWAP_SHIFT_CNT);\r
 249 \r
 250     ret = Board_i2c8BitRegWr(handle,\r
 251                              fpdModParams->serSlvAddr,\r
 252                              BOARD_FPD_UB941_DEVICE_CFG_REG_ADDR,\r
 253                              &regData,\r
 254                              1U,\r
 255                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 256     if(ret != 0)\r
 257     {\r
 258         return BOARD_I2C_TRANSFER_FAIL;\r
 259     }\r
 260 \r
 261     return BOARD_SOK;\r
 262 \r
 263 }\r
 264 \r
 265 /**\r
 266  * \brief DSI1 data lane pin order select\r
 267  *\r
 268  * This function is used to select the DSI1 data lane pin order.\r
 269  *\r
 270  * \param   handle        [IN]   Low level driver handle\r
 271  * \param   fpdModParams  [IN]   FPD module params\r
 272  * \param   operMode      [IN]   Operational mode to be configured\r
 273  *                               BOARD_FPD_UB941_DATA_LANE_PN_MAINTIAN - DSI Port1\r
 274  *                               Data Lane P inputs mapped to P, N\r
 275  *                               input smapped to N\r
 276  *                               BOARD_FPD_UB941_DATA_LANE_PN_SWAP     - DSI Port1\r
 277  *                               Data Lane P inputs mapped to P, N\r
 278  *                               inputs mapped to P\r
 279  *\r
 280  * \return  Board_STATUS in case of success or appropriate error code.\r
 281  *\r
 282  */\r
 283 Board_STATUS Board_fpdUb941SelDsi1DataPinOrd(void *handle,\r
 284                                              Board_FpdModuleObj *fpdModParams,\r
 285                                              uint8_t operMode)\r
 286 {\r
 287     Board_STATUS ret = BOARD_SOK;\r
 288     uint8_t regData = 0;\r
 289 \r
 290     if(handle == NULL)\r
 291     {\r
 292         return BOARD_INVALID_PARAM;\r
 293     }\r
 294 \r
 295     ret = Board_i2c8BitRegRd(handle,\r
 296                              fpdModParams->serSlvAddr,\r
 297                              BOARD_FPD_UB941_DEVICE_CFG_REG_ADDR,\r
 298                              &regData,\r
 299                              1U,\r
 300                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 301     if(ret != 0)\r
 302     {\r
 303         return BOARD_I2C_TRANSFER_FAIL;\r
 304     }\r
 305 \r
 306     regData &= ~(BOARD_FPD_UB941_DSI1_DATA_PN_SWAP_BIT_MASK);\r
 307     regData |= (operMode << BOARD_FPD_UB941_DSI1_DATA_PN_SWAP_SHIFT_CNT);\r
 308 \r
 309     ret = Board_i2c8BitRegWr(handle,\r
 310                              fpdModParams->serSlvAddr,\r
 311                              BOARD_FPD_UB941_DEVICE_CFG_REG_ADDR,\r
 312                              &regData,\r
 313                              1U,\r
 314                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 315     if(ret != 0)\r
 316     {\r
 317         return BOARD_I2C_TRANSFER_FAIL;\r
 318     }\r
 319 \r
 320     return BOARD_SOK;\r
 321 \r
 322 }\r
 323 \r
 324 /**\r
 325  * \brief DSI0 clock lane pin order select\r
 326  *\r
 327  * This function is used to select the DSI0 clock lane pin order.\r
 328  *\r
 329  * \param   handle        [IN]   Low level driver handle\r
 330  * \param   fpdModParams  [IN]   FPD module params\r
 331  * \param   operMode      [IN]   Operational mode to be configured\r
 332  *                               BOARD_FPD_UB941_CLK_LANE_PN_MAINTIAN - DSI Port0\r
 333  *                               Clock Lane P inputs mapped to P, N inputs\r
 334  *                               mapped to N\r
 335  *                               BOARD_FPD_UB941_CLK_LANE_PN_SWAP - DSI Port0\r
 336  *                               Clock Lane P inputs mapped to P, N inputs\r
 337  *                               mapped to P\r
 338  *\r
 339  * \return  Board_STATUS in case of success or appropriate error code.\r
 340  *\r
 341  */\r
 342 Board_STATUS Board_fpdUb941SelDsi0ClkPinOrd(void *handle,\r
 343                                             Board_FpdModuleObj *fpdModParams,\r
 344                                             uint8_t operMode)\r
 345 {\r
 346     Board_STATUS ret = BOARD_SOK;\r
 347     uint8_t regData = 0;\r
 348 \r
 349     if(handle == NULL)\r
 350     {\r
 351         return BOARD_INVALID_PARAM;\r
 352     }\r
 353 \r
 354     ret = Board_i2c8BitRegRd(handle,\r
 355                              fpdModParams->serSlvAddr,\r
 356                              BOARD_FPD_UB941_DEVICE_CFG_REG_ADDR,\r
 357                              &regData,\r
 358                              1U,\r
 359                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 360     if(ret != 0)\r
 361     {\r
 362         return BOARD_I2C_TRANSFER_FAIL;\r
 363     }\r
 364 \r
 365     regData &= ~(BOARD_FPD_UB941_DSI0_CLK_PN_SWAP_BIT_MASK);\r
 366     regData |= (operMode << BOARD_FPD_UB941_DSI0_CLK_PN_SWAP_SHIFT_CNT);\r
 367 \r
 368     ret = Board_i2c8BitRegWr(handle,\r
 369                              fpdModParams->serSlvAddr,\r
 370                              BOARD_FPD_UB941_DEVICE_CFG_REG_ADDR,\r
 371                              &regData,\r
 372                              1U,\r
 373                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 374     if(ret != 0)\r
 375     {\r
 376         return BOARD_I2C_TRANSFER_FAIL;\r
 377     }\r
 378 \r
 379     return BOARD_SOK;\r
 380 \r
 381 }\r
 382 \r
 383 /**\r
 384  * \brief DSI0 data lane pin order select\r
 385  *\r
 386  * This function is used to select the DSI0 data lane pin order.\r
 387  *\r
 388  * \param   handle        [IN]   Low level driver handle\r
 389  * \param   fpdModParams  [IN]   FPD module params\r
 390  * \param   operMode      [IN]   Operational mode to be configured\r
 391  *                               BOARD_FPD_UB941_DATA_LANE_PN_MAINTIAN - DSI Port0\r
 392  *                               Data Lane P inputs mapped to P, N\r
 393  *                               input smapped to N\r
 394  *                               BOARD_FPD_UB941_DATA_LANE_PN_SWAP     - DSI Port0\r
 395  *                               Data Lane P inputs mapped to P, N\r
 396  *                               inputs mapped to P\r
 397  *\r
 398  * \return  Board_STATUS in case of success or appropriate error code.\r
 399  *\r
 400  */\r
 401 Board_STATUS Board_fpdUb941SelDsi0DataPinOrd(void *handle,\r
 402                                              Board_FpdModuleObj *fpdModParams,\r
 403                                              uint8_t operMode)\r
 404 {\r
 405     Board_STATUS ret = BOARD_SOK;\r
 406     uint8_t regData = 0;\r
 407 \r
 408     if(handle == NULL)\r
 409     {\r
 410         return BOARD_INVALID_PARAM;\r
 411     }\r
 412 \r
 413     ret = Board_i2c8BitRegRd(handle,\r
 414                              fpdModParams->serSlvAddr,\r
 415                              BOARD_FPD_UB941_DEVICE_CFG_REG_ADDR,\r
 416                              &regData,\r
 417                              1U,\r
 418                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 419     if(ret != 0)\r
 420     {\r
 421         return BOARD_I2C_TRANSFER_FAIL;\r
 422     }\r
 423 \r
 424     regData &= ~(BOARD_FPD_UB941_DSI0_DATA_PN_SWAP_BIT_MASK);\r
 425     regData |= (operMode << BOARD_FPD_UB941_DSI0_DATA_PN_SWAP_SHIFT_CNT);\r
 426 \r
 427     ret = Board_i2c8BitRegWr(handle,\r
 428                              fpdModParams->serSlvAddr,\r
 429                              BOARD_FPD_UB941_DEVICE_CFG_REG_ADDR,\r
 430                              &regData,\r
 431                              1U,\r
 432                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 433     if(ret != 0)\r
 434     {\r
 435         return BOARD_I2C_TRANSFER_FAIL;\r
 436     }\r
 437 \r
 438     return BOARD_SOK;\r
 439 \r
 440 }\r
 441 \r
 442 /**\r
 443  * \brief Set deserializer device Id\r
 444  *\r
 445  * This function is used for setting the user configurable\r
 446  * device ID for remote deserializer connected to serializer.\r
 447  *\r
 448  * \param   handle        [IN]   Low level driver handle\r
 449  * \param   fpdModParams  [IN]   FPD module params\r
 450  * \param   serSlvAddr    [IN]   Deserailizer device ID.\r
 451  *\r
 452  *\r
 453  * \return  Board_STATUS in case of success or appropriate error code.\r
 454  *\r
 455  */\r
 456 Board_STATUS Board_fpdUb941DevIdCfg(void *handle,\r
 457                                     Board_FpdModuleObj *fpdModParams,\r
 458                                     uint8_t serSlvAddr)\r
 459 {\r
 460     Board_STATUS ret = BOARD_SOK;\r
 461 \r
 462     if(handle == NULL)\r
 463     {\r
 464         return BOARD_INVALID_PARAM;\r
 465     }\r
 466 \r
 467 \r
 468     serSlvAddr = ((serSlvAddr << 1) | BOARD_FPD_UB941_FREEZE_DEV_ID_BIT_MASK);\r
 469 \r
 470     ret = Board_i2c8BitRegWr(handle,\r
 471                              fpdModParams->serSlvAddr,\r
 472                              BOARD_FPD_UB941_DES_ID_REG_ADDR,\r
 473                              &serSlvAddr,\r
 474                              1U,\r
 475                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 476     if(ret != 0)\r
 477     {\r
 478         return BOARD_I2C_TRANSFER_FAIL;\r
 479     }\r
 480 \r
 481     return BOARD_SOK;\r
 482 \r
 483 }\r
 484 \r
 485 /**\r
 486  * \brief Get DSI general error status\r
 487  *\r
 488  * This function is used to read the general status of different err fileds.\r
 489  *\r
 490  * \param   handle         [IN]      Low level driver handle\r
 491  * \param   fpdModParams   [IN]      FPD module params\r
 492  * \param   errStatus      [IN/OUT]  Buffer to hold the error status\r
 493  *\r
 494  * \return   Board_STATUS in case of success or appropriate error code.\r
 495  *\r
 496  */\r
 497 Board_STATUS Board_fpdUb941GetDsiGenSts(void *handle,\r
 498                                         Board_FpdModuleObj *fpdModParams,\r
 499                                         uint8_t *errStatus)\r
 500 {\r
 501     Board_STATUS ret = BOARD_SOK;\r
 502     uint8_t rdData = 0;\r
 503 \r
 504     if(handle == NULL)\r
 505     {\r
 506         return BOARD_INVALID_PARAM;\r
 507     }\r
 508 \r
 509     ret = Board_i2c8BitRegRd(handle,\r
 510                              fpdModParams->serSlvAddr,\r
 511                              BOARD_FPD_UB941_GENERAL_STS_REG_ADDR,\r
 512                              &rdData,\r
 513                              1U,\r
 514                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 515     if(ret != 0)\r
 516     {\r
 517         return BOARD_I2C_TRANSFER_FAIL;\r
 518     }\r
 519 \r
 520     *errStatus = rdData;\r
 521     BOARD_DEBUG_LOG("errStatus = %d\n\r",errStatus);\r
 522 \r
 523     return BOARD_SOK;\r
 524 \r
 525 }\r
 526 \r
 527 /**\r
 528  * \brief I2C pass all mode control\r
 529  *\r
 530  * This function is used to Enable/Disable the I2C Pass All mode.\r
 531  *\r
 532  * \param   handle        [IN]   Low level driver handle\r
 533  * \param   fpdModParams  [IN]   FPD module params\r
 534  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
 535  *\r
 536  * \return   Board_STATUS in case of success or appropriate error code.\r
 537  *\r
 538  */\r
 539 Board_STATUS Board_fpdUb941SetI2CPassAllModeCtrl(void *handle,\r
 540                                                  Board_FpdModuleObj *fpdModParams,\r
 541                                                  uint8_t cfgMode)\r
 542 {\r
 543     Board_STATUS ret = BOARD_SOK;\r
 544     uint8_t regData = 0;\r
 545 \r
 546     if(handle == NULL)\r
 547     {\r
 548         return BOARD_INVALID_PARAM;\r
 549     }\r
 550 \r
 551     ret = Board_i2c8BitRegRd(handle,\r
 552                              fpdModParams->serSlvAddr,\r
 553                              BOARD_FPD_UB941_I2C_CONTROL_REG_ADDR,\r
 554                              &regData,\r
 555                              1U,\r
 556                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 557     if(ret != 0)\r
 558     {\r
 559         return BOARD_I2C_TRANSFER_FAIL;\r
 560     }\r
 561 \r
 562     regData &= ~(BOARD_FPD_UB941_I2C_PASS_ALL_BIT_MASK);\r
 563     regData |= (cfgMode << BOARD_FPD_UB941_I2C_PASS_ALL_SHIFT_CNT);\r
 564 \r
 565     ret = Board_i2c8BitRegWr(handle,\r
 566                              fpdModParams->serSlvAddr,\r
 567                              BOARD_FPD_UB941_I2C_CONTROL_REG_ADDR,\r
 568                              &regData,\r
 569                              1U,\r
 570                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 571     if(ret != 0)\r
 572     {\r
 573         return BOARD_I2C_TRANSFER_FAIL;\r
 574     }\r
 575 \r
 576     return BOARD_SOK;\r
 577 \r
 578 }\r
 579 \r
 580 /**\r
 581  * \brief Select I2C Access port\r
 582  *\r
 583  * This function is used to selects Port for register access from\r
 584  * primary I2C address\r
 585  *\r
 586  * \param   handle        [IN]   Low level driver handle\r
 587  * \param   fpdModParams  [IN]   FPD module params\r
 588  * \param   portSel       [IN]   Port to be selected\r
 589  *                               BOARD_FPD_UB941_PORT0_SEL    - Port0 selected\r
 590  *                               BOARD_FPD_UB941_PORT1_SEL    - Port1 selected\r
 591  *                               BOARD_FPD_UB941_PORT1_I2C_EN - Enables the secondary\r
 592  *                               I2C address\r
 593  *\r
 594  * \return   Board_STATUS in case of success or appropriate error code.\r
 595  *\r
 596  */\r
 597 Board_STATUS Board_fpdUb941SelI2CAccessPort(void *handle,\r
 598                                             Board_FpdModuleObj *fpdModParams,\r
 599                                             uint8_t portSel)\r
 600 {\r
 601     Board_STATUS ret = BOARD_SOK;\r
 602     uint8_t regData = 0;\r
 603 \r
 604     if(handle == NULL)\r
 605     {\r
 606         return BOARD_INVALID_PARAM;\r
 607     }\r
 608 \r
 609     ret = Board_i2c8BitRegRd(handle,\r
 610                              fpdModParams->serSlvAddr,\r
 611                              BOARD_FPD_UB941_TX_PORT_SEL_REG_ADDR,\r
 612                              &regData,\r
 613                              1U,\r
 614                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 615     if(ret != 0)\r
 616     {\r
 617         return BOARD_I2C_TRANSFER_FAIL;\r
 618     }\r
 619 \r
 620     regData &= ~(BOARD_FPD_UB941_I2C_ACCESS_PORT_MASK);\r
 621     regData |= portSel;\r
 622 \r
 623 \r
 624     ret = Board_i2c8BitRegWr(handle,\r
 625                              fpdModParams->serSlvAddr,\r
 626                              BOARD_FPD_UB941_TX_PORT_SEL_REG_ADDR,\r
 627                              &regData,\r
 628                              1U,\r
 629                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 630     if(ret != 0)\r
 631     {\r
 632         return BOARD_I2C_TRANSFER_FAIL;\r
 633     }\r
 634 \r
 635     return BOARD_SOK;\r
 636 \r
 637 }\r
 638 \r
 639 /**\r
 640  * \brief Indirect register acces block select\r
 641  *\r
 642  * This function is used to select indirect register access block.\r
 643  *\r
 644  * \param   handle        [IN]   Low level driver handle\r
 645  * \param   fpdModParams  [IN]   FPD module params\r
 646  * \param   regBlk        [IN]   Register block to be selected\r
 647  *                               BOARD_FPD_UB941_DSI_PORT0_REG\r
 648  *                                    - DSI/D-PHY Port 0 Digital Registers\r
 649  *\r
 650  *                               BOARD_FPD_UB941_DSI_PORT1_REG\r
 651  *                                    - DSI/D-PHY Port 1 Digital Registers\r
 652  *\r
 653  *                               BOARD_FPD_UB941_DSI_ANALOG_PLL_CNTRL_REG     \r
 654  *                                    - DSI Analog and PLL Control Registers\r
 655  *\r
 656  *                               BOARD_FPD_UB941_FPD_LINK_III_PORT0_REG       \r
 657  *                                    - FPD-Link III TX Port 0 Registers\r
 658  *\r
 659  *                               BOARD_FPD_UB941_FPD_LINK_III_PORT1_REG       \r
 660  *                                    - FPD-Link III TX Port 1 Registers\r
 661  *\r
 662  *                               BOARD_FPD_UB941_FPD_LINK_III_PORT0_PORT1_REG \r
 663  *                                    - Simultaneous access to FPD-Link III\r
 664  *                                      TX Port 0/1 Registers\r
 665  *\r
 666  * \return   Board_STATUS in case of success or appropriate error code.\r
 667  *\r
 668  */\r
 669 Board_STATUS Board_fpdUb941IndirRegAccBlkSel(void *handle,\r
 670                                              Board_FpdModuleObj *fpdModParams,\r
 671                                              uint8_t regBlk)\r
 672 {\r
 673     Board_STATUS ret = BOARD_SOK;\r
 674     uint8_t regData = 0;\r
 675 \r
 676     if(handle == NULL)\r
 677     {\r
 678         return BOARD_INVALID_PARAM;\r
 679     }\r
 680 \r
 681     ret = Board_i2c8BitRegRd(handle,\r
 682                              fpdModParams->serSlvAddr,\r
 683                              BOARD_FPD_UB941_IND_ACC_CTL_REG_ADDR,\r
 684                              &regData,\r
 685                              1U,\r
 686                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 687     if(ret != 0)\r
 688     {\r
 689         return BOARD_I2C_TRANSFER_FAIL;\r
 690     }\r
 691 \r
 692     regData &= ~(BOARD_FPD_UB941_IND_ACC_SEL_BIT_MASK);\r
 693     regData |= (regBlk << BOARD_FPD_UB941_IND_ACC_SEL_SHIFT_CNT);\r
 694 \r
 695     ret = Board_i2c8BitRegWr(handle,\r
 696                              fpdModParams->serSlvAddr,\r
 697                              BOARD_FPD_UB941_IND_ACC_CTL_REG_ADDR,\r
 698                              &regData,\r
 699                              1U,\r
 700                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 701     if(ret != 0)\r
 702     {\r
 703         return BOARD_I2C_TRANSFER_FAIL;\r
 704     }\r
 705 \r
 706     return BOARD_SOK;\r
 707 \r
 708 }\r
 709 \r
 710 /**\r
 711  * \brief Indirect register access mode select\r
 712  *\r
 713  * This function is used to select indirect register access mode.\r
 714  *\r
 715  * \param   handle        [IN]   Low level driver handle\r
 716  * \param   fpdModParams  [IN]   FPD module params\r
 717  * \param   accessMode    [IN]   Indirect access mode to be selected.\r
 718  *                               READ_ACCESS  - Read Access selected\r
 719  *                               WRITE_ACCESS - Write Access selected.\r
 720  *\r
 721  * \return   Board_STATUS in case of success or appropriate error code.\r
 722  *\r
 723  */\r
 724 Board_STATUS Board_fpdUb941InDirRegAccModeSel(void *handle,\r
 725                                               Board_FpdModuleObj *fpdModParams,\r
 726                                               uint8_t accessMode)\r
 727 {\r
 728     Board_STATUS ret = BOARD_SOK;\r
 729     uint8_t regData = 0;\r
 730 \r
 731     if(handle == NULL)\r
 732     {\r
 733         return BOARD_INVALID_PARAM;\r
 734     }\r
 735 \r
 736     ret = Board_i2c8BitRegRd(handle,\r
 737                              fpdModParams->serSlvAddr,\r
 738                              BOARD_FPD_UB941_IND_ACC_CTL_REG_ADDR,\r
 739                              &regData,\r
 740                              1U,\r
 741                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 742     if(ret != 0)\r
 743     {\r
 744         return BOARD_I2C_TRANSFER_FAIL;\r
 745     }\r
 746 \r
 747     regData &= ~(BOARD_FPD_UB941_IND_ACC_READ_BIT_MASK);\r
 748     regData |= (accessMode << BOARD_FPD_UB941_IND_ACC_READ_SHIFT_CNT);\r
 749 \r
 750     ret = Board_i2c8BitRegWr(handle,\r
 751                              fpdModParams->serSlvAddr,\r
 752                              BOARD_FPD_UB941_IND_ACC_CTL_REG_ADDR,\r
 753                              &regData,\r
 754                              1U,\r
 755                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 756     if(ret != 0)\r
 757     {\r
 758         return BOARD_I2C_TRANSFER_FAIL;\r
 759     }\r
 760 \r
 761     return BOARD_SOK;\r
 762 \r
 763 }\r
 764 \r
 765 /**\r
 766  * \brief Receive CRC checker enable\r
 767  *\r
 768  * This function is used to enable/disable CRC Checker.\r
 769  *\r
 770  * \param   handle        [IN]   Low level driver handle\r
 771  * \param   fpdModParams  [IN]   FPD module params\r
 772  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
 773  *\r
 774  * \return  Board_STATUS in case of success or appropriate error code.\r
 775  *\r
 776  */\r
 777 Board_STATUS Board_fpdUb941SetRxCRCCheckerEn(void *handle,\r
 778                                              Board_FpdModuleObj *fpdModParams,\r
 779                                              uint8_t cfgMode)\r
 780 {\r
 781     Board_STATUS ret = BOARD_SOK;\r
 782     uint8_t regData = 0;\r
 783 \r
 784     if(handle == NULL)\r
 785     {\r
 786         return BOARD_INVALID_PARAM;\r
 787     }\r
 788 \r
 789     ret = Board_i2c8BitRegRd(handle,\r
 790                              fpdModParams->serSlvAddr,\r
 791                              BOARD_FPD_UB941_GENERAL_CFG_REG_ADDR,\r
 792                              &regData,\r
 793                              1U,\r
 794                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 795     if(ret != 0)\r
 796     {\r
 797         return BOARD_I2C_TRANSFER_FAIL;\r
 798     }\r
 799 \r
 800     regData &= ~(BOARD_FPD_UB941_RX_CRC_CHECKER_ENABLE_BIT_MASK);\r
 801     regData |= (cfgMode << BOARD_FPD_UB941_RX_CRC_CHECKER_ENABLE_SHIFT_CNT);\r
 802 \r
 803     ret = Board_i2c8BitRegWr(handle,\r
 804                              fpdModParams->serSlvAddr,\r
 805                              BOARD_FPD_UB941_GENERAL_CFG_REG_ADDR,\r
 806                              &regData,\r
 807                              1U,\r
 808                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 809     if(ret != 0)\r
 810     {\r
 811         return BOARD_I2C_TRANSFER_FAIL;\r
 812     }\r
 813 \r
 814     return BOARD_SOK;\r
 815     \r
 816 }\r
 817 \r
 818 /**\r
 819  * \brief Set filter enable\r
 820  *\r
 821  * This function is used to enable/disable filter.\r
 822  *\r
 823  * \param   handle        [IN]   Low level driver handle\r
 824  * \param   fpdModParams  [IN]   FPD module params\r
 825  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
 826  *\r
 827  * \return   Board_STATUS in case of success or appropriate error code.\r
 828  *\r
 829  */\r
 830 Board_STATUS Board_fpdUb941SetFilterEn(void *handle,\r
 831                                        Board_FpdModuleObj *fpdModParams,\r
 832                                        uint8_t cfgMode)\r
 833 {\r
 834     Board_STATUS ret = BOARD_SOK;\r
 835     uint8_t regData = 0;\r
 836 \r
 837     if(handle == NULL)\r
 838     {\r
 839         return BOARD_INVALID_PARAM;\r
 840     }\r
 841 \r
 842     ret = Board_i2c8BitRegRd(handle,\r
 843                              fpdModParams->serSlvAddr,\r
 844                              BOARD_FPD_UB941_GENERAL_CFG_REG_ADDR,\r
 845                              &regData,\r
 846                              1U,\r
 847                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 848     if(ret != 0)\r
 849     {\r
 850         return BOARD_I2C_TRANSFER_FAIL;\r
 851     }\r
 852 \r
 853     regData &= ~(BOARD_FPD_UB941_FILTER_ENABLE_BIT_MASK);\r
 854     regData |= (cfgMode << BOARD_FPD_UB941_FILTER_ENABLE_SHIFT_CNT);\r
 855 \r
 856     ret = Board_i2c8BitRegWr(handle,\r
 857                              fpdModParams->serSlvAddr,\r
 858                              BOARD_FPD_UB941_GENERAL_CFG_REG_ADDR,\r
 859                              &regData,\r
 860                              1U,\r
 861                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 862     if(ret != 0)\r
 863     {\r
 864         return BOARD_I2C_TRANSFER_FAIL;\r
 865     }\r
 866 \r
 867     return BOARD_SOK;\r
 868     \r
 869 }\r
 870 \r
 871 /**\r
 872  * \brief  configure I2C pass through mode\r
 873  *\r
 874  * This function is used to enable/disable pass through mode\r
 875  *\r
 876  * \param   handle        [IN]   Low level driver handle\r
 877  * \param   fpdModParams  [IN]   FPD module params\r
 878  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
 879  *\r
 880  * \return   Board_STATUS in case of success or appropriate error code.\r
 881  *\r
 882  */\r
 883 Board_STATUS Board_fpdUb941SetI2CPassThrModeCfg(void *handle,\r
 884                                                 Board_FpdModuleObj *fpdModParams,\r
 885                                                 uint8_t cfgMode)\r
 886 {\r
 887     Board_STATUS ret = BOARD_SOK;\r
 888     uint8_t regData = 0;\r
 889 \r
 890     if(handle == NULL)\r
 891     {\r
 892         return BOARD_INVALID_PARAM;\r
 893     }\r
 894 \r
 895     ret = Board_i2c8BitRegRd(handle,\r
 896                              fpdModParams->serSlvAddr,\r
 897                              BOARD_FPD_UB941_GENERAL_CFG_REG_ADDR,\r
 898                              &regData,\r
 899                              1U,\r
 900                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 901     if(ret != 0)\r
 902     {\r
 903         return BOARD_I2C_TRANSFER_FAIL;\r
 904     }\r
 905 \r
 906     regData &= ~(BOARD_FPD_UB941_I2C_PASS_THROUGH_BIT_MASK);\r
 907     regData |= (cfgMode << BOARD_FPD_UB941_I2C_PASS_THROUGH_SHIFT_CNT);\r
 908 \r
 909     ret = Board_i2c8BitRegWr(handle,\r
 910                              fpdModParams->serSlvAddr,\r
 911                              BOARD_FPD_UB941_GENERAL_CFG_REG_ADDR,\r
 912                              &regData,\r
 913                              1U,\r
 914                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 915     if(ret != 0)\r
 916     {\r
 917         return BOARD_I2C_TRANSFER_FAIL;\r
 918     }\r
 919 \r
 920     return BOARD_SOK;\r
 921     \r
 922 }\r
 923 \r
 924 /**\r
 925  * \brief  configure PCLK auto enable mode\r
 926  *\r
 927  * This function is used to enable/disable PCLK AUTO mode\r
 928  *\r
 929  * \param   handle        [IN]   Low level driver handle\r
 930  * \param   fpdModParams  [IN]   FPD module params\r
 931  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
 932  *\r
 933  * \return   Board_STATUS in case of success or appropriate error code.\r
 934  *\r
 935  */\r
 936 Board_STATUS Board_fpdUb941SetPCLKAutoEnModeCfg(void *handle,\r
 937                                                 Board_FpdModuleObj *fpdModParams,\r
 938                                                 uint8_t cfgMode)\r
 939 {\r
 940     Board_STATUS ret = BOARD_SOK;\r
 941     uint8_t regData = 0;\r
 942 \r
 943     if(handle == NULL)\r
 944     {\r
 945         return BOARD_INVALID_PARAM;\r
 946     }\r
 947 \r
 948     ret = Board_i2c8BitRegRd(handle,\r
 949                              fpdModParams->serSlvAddr,\r
 950                              BOARD_FPD_UB941_GENERAL_CFG_REG_ADDR,\r
 951                              &regData,\r
 952                              1U,\r
 953                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 954     if(ret != 0)\r
 955     {\r
 956         return BOARD_I2C_TRANSFER_FAIL;\r
 957     }\r
 958 \r
 959     regData &= ~(BOARD_FPD_UB941_PCLK_AUTO_BIT_MASK);\r
 960     regData |= (cfgMode << BOARD_FPD_UB941_PCLK_AUTO_SHIFT_CNT);\r
 961 \r
 962     ret = Board_i2c8BitRegWr(handle,\r
 963                              fpdModParams->serSlvAddr,\r
 964                              BOARD_FPD_UB941_GENERAL_CFG_REG_ADDR,\r
 965                              &regData,\r
 966                              1U,\r
 967                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
 968     if(ret != 0)\r
 969     {\r
 970         return BOARD_I2C_TRANSFER_FAIL;\r
 971     }\r
 972 \r
 973     return BOARD_SOK;\r
 974     \r
 975 }\r
 976 \r
 977 /**\r
 978  * \brief  DSI indirect register write\r
 979  *\r
 980  * This function is used to write to the DSI indirect registers\r
 981  *\r
 982  * \param  handle        [IN]  Low level driver handle\r
 983  * \param  fpdModParams  [IN]   FPD module params\r
 984  * \param  regBlkType    [IN]  Indirect register block type\r
 985  *                             BOARD_FPD_UB941_DSI_PORT_INDIRECT_ACCESS\r
 986  *                                 - To enable DSI port register access\r
 987  *                             PATTERN_GEN_INDIRECT_ACESS\r
 988  *                                 - To enable Pattern Gen register access\r
 989  * \param  cfgRegAddr   [IN]   Register address to be accessed \r
 990  * \param  cfgRegData   [IN]   Register data to be programmed\r
 991  *\r
 992  * \return Board_STATUS in case of success or appropriate error code.\r
 993  *\r
 994  */\r
 995 Board_STATUS Board_fpdUb941DsiIndirRegWr(void *handle,\r
 996                                          Board_FpdModuleObj *fpdModParams,\r
 997                                          uint8_t regBlkType,\r
 998                                          uint8_t cfgRegAddr,\r
 999                                          uint8_t cfgRegData)\r
1000 {\r
1001     Board_STATUS ret = BOARD_SOK;\r
1002     uint8_t addrReg;\r
1003     uint8_t dataReg;\r
1004 \r
1005     if(handle == NULL)\r
1006     {\r
1007         return BOARD_INVALID_PARAM;\r
1008     }\r
1009 \r
1010 \r
1011     if(regBlkType == BOARD_FPD_UB941_DSI_PORT_INDIRECT_ACCESS)\r
1012     {\r
1013         addrReg = BOARD_FPD_UB941_IND_ACC_ADDR_REG_ADDR;\r
1014         dataReg = BOARD_FPD_UB941_IND_ADD_DATA_REG_ADDR;\r
1015     }\r
1016     else if(regBlkType == BOARD_FPD_UB941_PATTERN_GEN_INDIRECT_ACESS)\r
1017     {\r
1018         addrReg = BOARD_FPD_UB941_PGIA_PGIA_P1_REG_ADDR;\r
1019         dataReg = BOARD_FPD_UB941_PGID_PGID_P1_REG_ADDR;\r
1020     }\r
1021     else\r
1022     {\r
1023         return BOARD_INVALID_PARAM;\r
1024     }\r
1025 \r
1026     ret = Board_i2c8BitRegWr(handle,\r
1027                              fpdModParams->serSlvAddr,\r
1028                              addrReg,\r
1029                              &cfgRegAddr,\r
1030                              1U,\r
1031                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1032     if(ret != 0)\r
1033     {\r
1034         return BOARD_I2C_TRANSFER_FAIL;\r
1035     }\r
1036 \r
1037     ret = Board_i2c8BitRegWr(handle,\r
1038                              fpdModParams->serSlvAddr,\r
1039                              dataReg,\r
1040                              &cfgRegData,\r
1041                              1U,\r
1042                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1043     if(ret != 0)\r
1044     {\r
1045         return BOARD_I2C_TRANSFER_FAIL;\r
1046     }\r
1047     \r
1048     return BOARD_SOK;\r
1049 \r
1050 }\r
1051 \r
1052 /**\r
1053  * \brief  Set DSI bytes per pixel\r
1054  *\r
1055  * This function is used to configure the DSI bytes per pixel\r
1056  *\r
1057  * \param  handle          [IN]  Low level driver handle\r
1058  * \param  fpdModParams    [IN]   FPD module params\r
1059  * \param  bytesPerPixel   [IN]  Number of DSI Bytes Per Pixel\r
1060  *\r
1061  * \return   Board_STATUS in case of success or appropriate error code.\r
1062  *\r
1063  */\r
1064 Board_STATUS Board_fpdUb941SetPixelBytes(void *handle,\r
1065                                          Board_FpdModuleObj *fpdModParams,\r
1066                                          uint8_t bytesPerPixel)\r
1067 {\r
1068     Board_STATUS ret = BOARD_SOK;\r
1069     uint8_t regData = 0;\r
1070 \r
1071     if(handle == NULL)\r
1072     {\r
1073         return BOARD_INVALID_PARAM;\r
1074     }\r
1075 \r
1076     ret = Board_i2c8BitRegRd(handle,\r
1077                              fpdModParams->serSlvAddr,\r
1078                              BOARD_FPD_UB941_BRIDGE_CFG_REG_ADDR,\r
1079                              &regData,\r
1080                              1U,\r
1081                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1082     if(ret != 0)\r
1083     {\r
1084         return BOARD_I2C_TRANSFER_FAIL;\r
1085     }\r
1086 \r
1087     regData &= ~(BOARD_FPD_UB941_DSI_BYTES_PER_PIXEL_BIT_MASK);\r
1088     regData |= (bytesPerPixel << BOARD_FPD_UB941_DSI_BYTES_PER_PIXEL_SHIFT_CNT);\r
1089 \r
1090     ret = Board_i2c8BitRegWr(handle,\r
1091                              fpdModParams->serSlvAddr,\r
1092                              BOARD_FPD_UB941_BRIDGE_CFG_REG_ADDR,\r
1093                              &regData,\r
1094                              1U,\r
1095                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1096     if(ret != 0)\r
1097     {\r
1098         return BOARD_I2C_TRANSFER_FAIL;\r
1099     }\r
1100 \r
1101     return BOARD_SOK;\r
1102     \r
1103 }                                             \r
1104                                              \r
1105 \r
1106 /**\r
1107  * \brief  Set frequency stability threshold\r
1108  *\r
1109  * This function is used to configure the frequency stability threshold\r
1110  *\r
1111  * \param   handle        [IN]   Low level driver handle\r
1112  * \param   fpdModParams  [IN]   FPD module params\r
1113  * \param   freqStblThr   [IN]   Frequency Stability Threshold\r
1114  *                               BOARD_FPD_UB941_FREQ_STBL_40   - 40 micro sec\r
1115  *                               BOARD_FPD_UB941_FREQ_STBL_80   - 80 micro sec\r
1116  *                               BOARD_FPD_UB941_FREQ_STBL_320  - 320 micro sec\r
1117  *                               BOARD_FPD_UB941_FREQ_STBL_1280 - 1280 micro sec\r
1118  *\r
1119  * \return  Board_STATUS in case of success or appropriate error code.\r
1120  *\r
1121  */\r
1122 Board_STATUS Board_fpdUb941SetFreqStblThr(void *handle,\r
1123                                           Board_FpdModuleObj *fpdModParams,\r
1124                                           uint8_t freqStblThr)\r
1125 {\r
1126     Board_STATUS ret = BOARD_SOK;\r
1127     uint8_t regData = 0;\r
1128 \r
1129     if(handle == NULL)\r
1130     {\r
1131         return BOARD_INVALID_PARAM;\r
1132     }\r
1133 \r
1134     ret = Board_i2c8BitRegRd(handle,\r
1135                              fpdModParams->serSlvAddr,\r
1136                              BOARD_FPD_UB941_DUAL_CTL2_REG_ADDR,\r
1137                              &regData,\r
1138                              1U,\r
1139                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1140     if(ret != 0)\r
1141     {\r
1142         return BOARD_I2C_TRANSFER_FAIL;\r
1143     }\r
1144 \r
1145     regData &= ~(BOARD_FPD_UB941_FREQ_STBL_THR_BIT_MASK);\r
1146     regData |= (freqStblThr << BOARD_FPD_UB941_FREQ_STBL_THR_SHIFT_CNT);\r
1147 \r
1148     ret = Board_i2c8BitRegWr(handle,\r
1149                              fpdModParams->serSlvAddr,\r
1150                              BOARD_FPD_UB941_DUAL_CTL2_REG_ADDR,\r
1151                              &regData,\r
1152                              1U,\r
1153                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1154     if(ret != 0)\r
1155     {\r
1156         return BOARD_I2C_TRANSFER_FAIL;\r
1157     }\r
1158 \r
1159     return BOARD_SOK;\r
1160 \r
1161 }\r
1162 \r
1163 /**\r
1164  * \brief  Get FPD Link-III link ready status\r
1165  *\r
1166  * This function is used to get the FPD Link-III ready status\r
1167  *\r
1168  * \param  handle        [IN]      Low level driver handle\r
1169  * \param  fpdModParams  [IN]      FPD module params\r
1170  * \param  stsFlag       [IN/OUT]  FPD LinkIII ready status\r
1171  *                                 False - FPD Link III module ready\r
1172  *                                 True  - FPD Link III module not ready\r
1173  *\r
1174  * \return Board_STATUS in case of success or appropriate error code.\r
1175  *\r
1176  */\r
1177 Board_STATUS Board_fpdUb941GetFpd3LinkRdySts(void *handle,\r
1178                                              Board_FpdModuleObj *fpdModParams,\r
1179                                              bool *stsFlag)\r
1180 {\r
1181     Board_STATUS ret = BOARD_SOK;\r
1182     uint8_t regData = 0;\r
1183 \r
1184     if(handle == NULL)\r
1185     {\r
1186         return BOARD_INVALID_PARAM;\r
1187     }\r
1188 \r
1189     ret = Board_i2c8BitRegRd(handle,\r
1190                              fpdModParams->serSlvAddr,\r
1191                              BOARD_FPD_UB941_DUAL_STS_DUAL_STS_P1_REG_ADDR,\r
1192                              &regData,\r
1193                              1U,\r
1194                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1195     if(ret != 0)\r
1196     {\r
1197         return BOARD_I2C_TRANSFER_FAIL;\r
1198     }\r
1199 \r
1200     *stsFlag = (((regData & BOARD_FPD_UB941_FPD3_LINK_RDY_BIT_MASK) >> BOARD_FPD_UB941_FPD3_LINK_RDY_SHIFT_CNT) == 1) ?  true : false;\r
1201     BOARD_DEBUG_LOG("stsFlag = %d\n\r",stsFlag);\r
1202 \r
1203     return BOARD_SOK;\r
1204 \r
1205 }\r
1206 \r
1207 /**\r
1208  * \brief  Get FPD Link-III transmit status\r
1209  *\r
1210  * This function is used to get the FPD LinkIII transmit status.\r
1211  *\r
1212  * \param  handle        [IN]      Low level driver handle\r
1213  * \param  fpdModParams  [IN]      FPD module params\r
1214  * \param  stsFlag       [IN/OUT]  FPD LinkIII transmit status\r
1215  *                                 False - FPD Link III transmit unsuccessful\r
1216  *                                 True  - FPD Link III transmit successful\r
1217  *\r
1218  * \return   Board_STATUS in case of success or appropriate error code.\r
1219  *\r
1220  */\r
1221 Board_STATUS Board_fpdUb941GetFpd3LinkTxSts(void *handle,\r
1222                                             Board_FpdModuleObj *fpdModParams,\r
1223                                             bool *stsFlag)\r
1224 {\r
1225     Board_STATUS ret = BOARD_SOK;\r
1226     uint8_t regData = 0;\r
1227 \r
1228     if(handle == NULL)\r
1229     {\r
1230         return BOARD_INVALID_PARAM;\r
1231     }\r
1232 \r
1233     ret = Board_i2c8BitRegRd(handle,\r
1234                              fpdModParams->serSlvAddr,\r
1235                              BOARD_FPD_UB941_DUAL_STS_DUAL_STS_P1_REG_ADDR,\r
1236                              &regData,\r
1237                              1U,\r
1238                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1239     if(ret != 0)\r
1240     {\r
1241         return BOARD_I2C_TRANSFER_FAIL;\r
1242     }\r
1243 \r
1244     *stsFlag = (((regData & BOARD_FPD_UB941_FPD3_TX_STS_BIT_MASK) >> BOARD_FPD_UB941_FPD3_TX_STS_SHIFT_CNT) == 1) ?  true : false;\r
1245     BOARD_DEBUG_LOG("stsFlag = %d\n\r",stsFlag);\r
1246 \r
1247     return BOARD_SOK;\r
1248 \r
1249 }\r
1250 \r
1251 /**\r
1252  * \brief  Get DSI clock detect status\r
1253  *\r
1254  * This function is used to get DSI clock detect status.\r
1255  *\r
1256  * \param  handle        [IN]      Low level driver handle\r
1257  * \param  fpdModParams  [IN]      FPD module params\r
1258  * \param  stsFlag       [IN/OUT]  DSI clock detection status\r
1259  *                                 False - DSI clock detection failed\r
1260  *                                 True  - DSI clock detection successful\r
1261  *\r
1262  * \return   Board_STATUS in case of success or appropriate error code.\r
1263  *\r
1264  */\r
1265 Board_STATUS Board_fpdUb941GetDsiClkDetSts(void *handle,\r
1266                                            Board_FpdModuleObj *fpdModParams,\r
1267                                            bool *stsFlag)\r
1268 {\r
1269     Board_STATUS ret = BOARD_SOK;\r
1270     uint8_t regData = 0;\r
1271 \r
1272     if(handle == NULL)\r
1273     {\r
1274         return BOARD_INVALID_PARAM;\r
1275     }\r
1276 \r
1277     ret = Board_i2c8BitRegRd(handle,\r
1278                              fpdModParams->serSlvAddr,\r
1279                              BOARD_FPD_UB941_DUAL_STS_DUAL_STS_P1_REG_ADDR,\r
1280                              &regData,\r
1281                              1U,\r
1282                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1283     if(ret != 0)\r
1284     {\r
1285         return BOARD_I2C_TRANSFER_FAIL;\r
1286     }\r
1287 \r
1288     *stsFlag = (((regData & BOARD_FPD_UB941_DSI_CLK_DET_BIT_MASK) >> BOARD_FPD_UB941_DSI_CLK_DET_SHIFT_CNT) == 1) ?  true : false;\r
1289     BOARD_DEBUG_LOG("stsFlag = %d\n\r",stsFlag);\r
1290 \r
1291     return BOARD_SOK;\r
1292 \r
1293 }\r
1294 \r
1295 /**\r
1296  * \brief  Get selected port DSI clock detect status\r
1297  *\r
1298  *  This function is used to get DSI clock detect status \r
1299  *  of selected port.\r
1300  *\r
1301  * \param  handle        [IN]      Low level driver handle\r
1302  * \param  fpdModParams  [IN]      FPD module params\r
1303  * \param  stsFlag       [IN/OUT]  DSI clock detection status of selected port\r
1304  *                                 False - DSI clock detection failed\r
1305  *                                 True  - DSI clock detection successful\r
1306  *\r
1307  * \return   Board_STATUS in case of success or appropriate error code.\r
1308  *\r
1309  */\r
1310 Board_STATUS Board_fpdUb941GetSelPortDsiClkDetSts(void *handle,\r
1311                                                   Board_FpdModuleObj *fpdModParams,\r
1312                                                   bool *stsFlag)\r
1313 {\r
1314     Board_STATUS ret = BOARD_SOK;\r
1315     uint8_t regData = 0;\r
1316 \r
1317     if(handle == NULL)\r
1318     {\r
1319         return BOARD_INVALID_PARAM;\r
1320     }\r
1321 \r
1322     ret = Board_i2c8BitRegRd(handle,\r
1323                             fpdModParams->serSlvAddr,\r
1324                             BOARD_FPD_UB941_DUAL_STS_DUAL_STS_P1_REG_ADDR,\r
1325                             &regData,\r
1326                             1U,\r
1327                             BOARD_I2C_TRANSACTION_TIMEOUT);\r
1328     if(ret != 0)\r
1329     {\r
1330         return BOARD_I2C_TRANSFER_FAIL;\r
1331     }\r
1332 \r
1333     *stsFlag = (((regData & BOARD_FPD_UB941_NO_DSI_CLK_BIT_MASK) >> BOARD_FPD_UB941_NO_DSI_CLK_SHIFT_CNT) == 1) ?  true : false;\r
1334     BOARD_DEBUG_LOG("stsFlag = %d\n\r",stsFlag);\r
1335 \r
1336     return BOARD_SOK;\r
1337 \r
1338 }\r
1339 \r
1340 /**\r
1341  * \brief  Get frequency stability status\r
1342  *\r
1343  * This function is used to get DSI frequency stability status\r
1344  *\r
1345  * \param  handle        [IN]       Low level driver handle\r
1346  * \param  fpdModParams  [IN]       FPD module params\r
1347  * \param  stsFlag       [IN/OUT]   Ferquency stability status\r
1348  *                                  False - Frequency status failed\r
1349  *                                  True  - Frequency status successful\r
1350  *\r
1351  * \return   Board_STATUS in case of success or appropriate error code.\r
1352  *\r
1353  */\r
1354 Board_STATUS Board_fpdUb941GetFreqStabilitySts(void *handle,\r
1355                                                Board_FpdModuleObj *fpdModParams,\r
1356                                                bool *stsFlag)\r
1357 {\r
1358     Board_STATUS ret = BOARD_SOK;\r
1359     uint8_t regData = 0;\r
1360 \r
1361     if(handle == NULL)\r
1362     {\r
1363         return BOARD_INVALID_PARAM;\r
1364     }\r
1365 \r
1366     ret = Board_i2c8BitRegRd(handle,\r
1367                              fpdModParams->serSlvAddr,\r
1368                              BOARD_FPD_UB941_DUAL_STS_DUAL_STS_P1_REG_ADDR,\r
1369                              &regData,\r
1370                              1U,\r
1371                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1372     if(ret != 0)\r
1373     {\r
1374         return BOARD_I2C_TRANSFER_FAIL;\r
1375     }\r
1376 \r
1377     *stsFlag = (((regData & BOARD_FPD_UB941_FREQ_STABLE_BIT_MASK) >> BOARD_FPD_UB941_FREQ_STABLE_SHIFT_CNT) == 1) ?  true : false;\r
1378     BOARD_DEBUG_LOG("stsFlag = %d\n\r",stsFlag);\r
1379 \r
1380     return BOARD_SOK;\r
1381 \r
1382 }\r
1383 \r
1384 /**\r
1385  * \brief  configure indirect register read enable mode\r
1386  *\r
1387  * This function is used to enable/disable PCLK AUTO mode\r
1388  *\r
1389  * \param   handle        [IN]   Low level driver handle\r
1390  * \param   fpdModParams  [IN]   FPD module params\r
1391  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
1392  *\r
1393  * \return   Board_STATUS in case of success or appropriate error code.\r
1394  *\r
1395  */\r
1396 Board_STATUS Board_fpdUb941SetIndirRegRdEn(void *handle,\r
1397                                            Board_FpdModuleObj *fpdModParams,\r
1398                                            uint8_t cfgMode)\r
1399 {\r
1400     Board_STATUS ret = BOARD_SOK;\r
1401     uint8_t regData = 0;\r
1402 \r
1403     if(handle == NULL)\r
1404     {\r
1405         return BOARD_INVALID_PARAM;\r
1406     }\r
1407 \r
1408     ret = Board_i2c8BitRegRd(handle,\r
1409                              fpdModParams->serSlvAddr,\r
1410                              BOARD_FPD_UB941_IND_ACC_CTL_REG_ADDR,\r
1411                              &regData,\r
1412                              1U,\r
1413                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1414     if(ret != 0)\r
1415     {\r
1416         return BOARD_I2C_TRANSFER_FAIL;\r
1417     }\r
1418 \r
1419     regData &= ~(BOARD_FPD_UB941_IND_ACC_CTL_READ_WRITE_BIT_MASK);\r
1420     regData |= cfgMode;\r
1421 \r
1422     ret = Board_i2c8BitRegWr(handle,\r
1423                              fpdModParams->serSlvAddr,\r
1424                              BOARD_FPD_UB941_IND_ACC_CTL_REG_ADDR,\r
1425                              &regData,\r
1426                              1U,\r
1427                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1428     if(ret != 0)\r
1429     {\r
1430         return BOARD_I2C_TRANSFER_FAIL;\r
1431     }\r
1432 \r
1433     return BOARD_SOK;\r
1434 }\r
1435 \r
1436 /**\r
1437  * \brief  configure transmit mode\r
1438  *\r
1439  * This function is used to confiure the transmit mode\r
1440  *\r
1441  * \param   handle        [IN]   Low level driver handle\r
1442  * \param   fpdModParams  [IN]   FPD module params\r
1443  * \param   operMode      [IN]   operMode - BOARD_FPD_UB941_AUTO_DETECT_FPD3_MODE \r
1444  *                                          BOARD_FPD_UB941_FORCED_SINGLE_FPD3_TRANSMITTER_MODE\r
1445  *                                          BOARD_FPD_UB941_FORCED_DUAL_FPD3_TRANSMITTER_MODE\r
1446  *                                          BOARD_FPD_UB941_AUTO_DETECT_FPD3_SINGLE_MODE\r
1447  *                                          BOARD_FPD_UB941_FORCED_INDEPENDENT_2_2_MODE\r
1448  *                                          BOARD_FPD_UB941_FORCED_SPLITTER_MODE\r
1449  *\r
1450  * \return   Board_STATUS in case of success or appropriate error code.\r
1451  *\r
1452  */\r
1453 Board_STATUS Board_fpdUb941Tx_Mode(void *handle,\r
1454                                    Board_FpdModuleObj *fpdModParams,\r
1455                                    uint8_t operMode)\r
1456 {\r
1457     Board_STATUS ret = BOARD_SOK;\r
1458     uint8_t regData = 0;\r
1459 \r
1460     if(handle == NULL)\r
1461     {\r
1462         return BOARD_INVALID_PARAM;\r
1463     }\r
1464 \r
1465     ret = Board_i2c8BitRegRd(handle,\r
1466                              fpdModParams->serSlvAddr,\r
1467                              BOARD_FPD_UB941_DUAL_CTL1_REG_ADDR,\r
1468                              &regData,\r
1469                              1U,\r
1470                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1471     if(ret != 0)\r
1472     {\r
1473         return BOARD_I2C_TRANSFER_FAIL;\r
1474     }\r
1475 \r
1476     regData &= ~(BOARD_FPD_UB941_FPD3_TX_MODE_BIT_MASK);\r
1477     regData |= operMode;\r
1478 \r
1479     ret = Board_i2c8BitRegWr(handle,\r
1480                              fpdModParams->serSlvAddr,\r
1481                              BOARD_FPD_UB941_DUAL_CTL1_REG_ADDR,\r
1482                              &regData,\r
1483                              1U,\r
1484                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1485     if(ret != 0)\r
1486     {\r
1487         return BOARD_I2C_TRANSFER_FAIL;\r
1488     }\r
1489 \r
1490     return BOARD_SOK;\r
1491     \r
1492 }\r
1493 \r
1494 /**\r
1495  * \brief  configure serializer clock mode control mode\r
1496  *\r
1497  * This function is used to enable/disable PCLK AUTO mode\r
1498  *\r
1499  * \param   handle        [IN]   Low level driver handle\r
1500  * \param   fpdModParams  [IN]   FPD module params\r
1501  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
1502  *\r
1503  * \return   Board_STATUS in case of success or appropriate error code.\r
1504  *\r
1505  */\r
1506 Board_STATUS Board_fpdUb941SetSerClkModeCtrl(void *handle,\r
1507                                              Board_FpdModuleObj *fpdModParams,\r
1508                                              uint8_t cfgMode)\r
1509 {\r
1510     Board_STATUS ret = BOARD_SOK;\r
1511     uint8_t regData = 0;\r
1512 \r
1513     if(handle == NULL)\r
1514     {\r
1515         return BOARD_INVALID_PARAM;\r
1516     }\r
1517 \r
1518     ret = Board_i2c8BitRegRd(handle,\r
1519                              fpdModParams->serSlvAddr,\r
1520                              BOARD_FPD_UB941_BRIDGE_CTL_REG_ADDR,\r
1521                              &regData,\r
1522                              1U,\r
1523                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1524     if(ret != 0)\r
1525     {\r
1526         return BOARD_I2C_TRANSFER_FAIL;\r
1527     }\r
1528 \r
1529     regData &= ~(BOARD_FPD_UB941_DSI_CONTINUOUS_CLK_BIT_MASK);\r
1530     regData |= (cfgMode << BOARD_FPD_UB941_DSI_CONTINUOUS_CLK_SHIFT_CNT);\r
1531 \r
1532     ret = Board_i2c8BitRegWr(handle,\r
1533                              fpdModParams->serSlvAddr,\r
1534                              BOARD_FPD_UB941_BRIDGE_CTL_REG_ADDR,\r
1535                              &regData,\r
1536                              1U,\r
1537                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1538     if(ret != 0)\r
1539     {\r
1540         return BOARD_I2C_TRANSFER_FAIL;\r
1541     }\r
1542 \r
1543     return BOARD_SOK;\r
1544 }\r
1545 \r
1546 /**\r
1547  * \brief  configure clock lane mode control mode\r
1548  *\r
1549  * This function is used to enable/disable PCLK AUTO mode\r
1550  *\r
1551  * \param   handle        [IN]   Low level driver handle\r
1552  * \param   fpdModParams  [IN]   FPD module params\r
1553  * \param   laneMode       [IN]   ----todo---------\r
1554  *\r
1555  * \return   Board_STATUS in case of success or appropriate error code.\r
1556  *\r
1557  */\r
1558 Board_STATUS Board_fpdUb941SetDsiLaneModeCtrl(void *handle,\r
1559                                               Board_FpdModuleObj *fpdModParams,\r
1560                                               uint8_t laneMode)\r
1561 {\r
1562     Board_STATUS ret = BOARD_SOK;\r
1563     uint8_t regData = 0;\r
1564 \r
1565     if(handle == NULL)\r
1566     {\r
1567         return BOARD_INVALID_PARAM;\r
1568     }\r
1569 \r
1570     ret = Board_i2c8BitRegRd(handle,\r
1571                              fpdModParams->serSlvAddr,\r
1572                              BOARD_FPD_UB941_BRIDGE_CTL_REG_ADDR,\r
1573                              &regData,\r
1574                              1U,\r
1575                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1576     if(ret != 0)\r
1577     {\r
1578         return BOARD_I2C_TRANSFER_FAIL;\r
1579     }\r
1580 \r
1581     regData &= ~(BOARD_FPD_UB941_BRIDGE_LANE_MODE_BIT_MASK);\r
1582     regData |= (laneMode << BOARD_FPD_UB941_BRIDGE_LANE_MODE_SHIFT_CNT);\r
1583 \r
1584     ret = Board_i2c8BitRegWr(handle,\r
1585                              fpdModParams->serSlvAddr,\r
1586                              BOARD_FPD_UB941_BRIDGE_CTL_REG_ADDR,\r
1587                              &regData,\r
1588                              1U,\r
1589                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1590     if(ret != 0)\r
1591     {\r
1592         return BOARD_I2C_TRANSFER_FAIL;\r
1593     }\r
1594 \r
1595     return BOARD_SOK;\r
1596 }\r
1597 \r
1598 /**\r
1599  * \brief  Digital Reset mode control\r
1600  *\r
1601  * Resets the entire digital block including registers\r
1602  *\r
1603  * \param   handle        [IN]   Low level driver handle\r
1604  * \param   fpdModParams  [IN]   FPD module params\r
1605  * \param   cfgMode       [IN]   Config mode - Normal operation (or) Reset\r
1606  *\r
1607  * \return  Board_STATUS in case of success or appropriate error code.\r
1608  *\r
1609  */\r
1610 Board_STATUS Board_fpdUb941SetDigitalRst1ModeCtrl(void *handle,\r
1611                                                   Board_FpdModuleObj *fpdModParams,\r
1612                                                   uint8_t cfgMode)\r
1613 {\r
1614     Board_STATUS ret = BOARD_SOK;\r
1615     uint8_t regData = 0;\r
1616 \r
1617     if(handle == NULL)\r
1618     {\r
1619         return BOARD_INVALID_PARAM;\r
1620     }\r
1621 \r
1622     ret = Board_i2c8BitRegRd(handle,\r
1623                              fpdModParams->serSlvAddr,\r
1624                              BOARD_FPD_UB941_RESET_CTL_REG_ADDR,\r
1625                              &regData,\r
1626                              1U,\r
1627                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1628     if(ret != 0)\r
1629     {\r
1630         return BOARD_I2C_TRANSFER_FAIL;\r
1631     }\r
1632 \r
1633     regData &= ~(BOARD_FPD_UB941_DIGITAL_RESET1_BIT_MASK);\r
1634     regData |= (cfgMode << BOARD_FPD_UB941_DIGITAL_RESET1_SHIFT_CNT);\r
1635 \r
1636     ret = Board_i2c8BitRegWr(handle,\r
1637                              fpdModParams->serSlvAddr,\r
1638                              BOARD_FPD_UB941_RESET_CTL_REG_ADDR,\r
1639                              &regData,\r
1640                              1U,\r
1641                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1642     if(ret != 0)\r
1643     {\r
1644         return BOARD_I2C_TRANSFER_FAIL;\r
1645     }\r
1646 \r
1647     return BOARD_SOK;\r
1648         \r
1649 }\r
1650 \r
1651 /**\r
1652  * \brief  I2C bus frequency set\r
1653  *\r
1654  * This function is used for setting the deserializer I2C bus frequency\r
1655  *\r
1656  * \param   handle        [IN]   Low level driver handle\r
1657  * \param   fpdModParams  [IN]   FPD module params\r
1658  * \param   cfgBitRate    [IN]   Indicates I2C serial clock frequency\r
1659  *                               config modes\r
1660  *                               BOARD_FPD_KBPS_100 - 100 KBPS\r
1661  *                               BOARD_FPD_KBPS_400 - 400 KBPS\r
1662  *\r
1663  * \return  BOARD_SOK in case of success or appropriate error code.\r
1664  *\r
1665  */\r
1666 Board_STATUS Board_fpdUb941SetI2CBusFreq(void *handle,\r
1667                                          Board_FpdModuleObj *fpdModParams,\r
1668                                          uint8_t cfgBitRate)\r
1669 {\r
1670     Board_STATUS ret = BOARD_SOK;\r
1671     uint8_t regAddr;\r
1672 \r
1673     if(handle == NULL)\r
1674     {\r
1675         return BOARD_INVALID_PARAM;\r
1676     }\r
1677 \r
1678     regAddr = BOARD_FPD_UB941_SCL_HIGH_TIME_REG_ADDR;\r
1679     /* Configures the I2C Bit rate to 400kbit/sec */\r
1680     /* Configures the SCL High time */\r
1681     ret = Board_i2c8BitRegWr(handle,\r
1682                              fpdModParams->desSlvAddr,\r
1683                              regAddr,\r
1684                              &cfgBitRate,\r
1685                              1U,\r
1686                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1687 \r
1688     if(ret != 0)\r
1689     {\r
1690         return BOARD_I2C_TRANSFER_FAIL;\r
1691     }\r
1692 \r
1693     regAddr = BOARD_FPD_UB941_SCL_LOW_TIME_REG_ADDR;\r
1694     /* Configures the SCL High time */\r
1695     ret = Board_i2c8BitRegWr(handle,\r
1696                              fpdModParams->desSlvAddr,\r
1697                              regAddr,\r
1698                              &cfgBitRate,\r
1699                              1U,\r
1700                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1701 \r
1702     if(ret != 0)\r
1703     {\r
1704         return BOARD_I2C_TRANSFER_FAIL;\r
1705     }\r
1706     \r
1707     return BOARD_SOK;\r
1708 }\r
1709 \r
1710 /**\r
1711  * \brief  Remote deserializer slave device id config\r
1712  *\r
1713  * This function is used for configuring the remote deserializer slave device ID\r
1714  *\r
1715  * \param   handle        [IN]   Low level driver handle\r
1716  * \param   fpdModParams  [IN]   FPD module params\r
1717  * \param   fpdRmtParams  [IN]   Remote device module params\r
1718  *\r
1719  * \return  BOARD_SOK in case of success or appropriate error code.\r
1720  *\r
1721  */\r
1722 Board_STATUS Board_fpdUb941RmtDesAliasCfg(void *handle,\r
1723                                           Board_FpdModuleObj *fpdModParams,\r
1724                                           Board_FpdRmtDevObj *fpdRmtParams)\r
1725 {\r
1726     Board_STATUS ret = BOARD_SOK;\r
1727 \r
1728     uint8_t i = 0,i2cDeviceData = 0, i2cAliasData= 0;\r
1729     uint8_t i2cDeviceAddr[8] = {BOARD_FPD_UB941_SLAVE_ID0_REG_ADDR,\r
1730                                 BOARD_FPD_UB941_SLAVE_ID1_REG_ADDR,\r
1731                                 BOARD_FPD_UB941_SLAVE_ID2_REG_ADDR,\r
1732                                 BOARD_FPD_UB941_SLAVE_ID3_REG_ADDR,\r
1733                                 BOARD_FPD_UB941_SLAVE_ID4_REG_ADDR,\r
1734                                 BOARD_FPD_UB941_SLAVE_ID5_REG_ADDR,\r
1735                                 BOARD_FPD_UB941_SLAVE_ID6_REG_ADDR,\r
1736                                 BOARD_FPD_UB941_SLAVE_ID7_REG_ADDR};\r
1737     \r
1738     uint8_t i2cAliasAddr[8] = {BOARD_FPD_UB941_SLAVE_ALIAS_0_REG_ADDR,\r
1739                                BOARD_FPD_UB941_SLAVE_ALIAS_1_REG_ADDR,\r
1740                                BOARD_FPD_UB941_SLAVE_ALIAS_2_REG_ADDR,\r
1741                                BOARD_FPD_UB941_SLAVE_ALIAS_3_REG_ADDR,\r
1742                                BOARD_FPD_UB941_SLAVE_ALIAS_4_REG_ADDR,\r
1743                                BOARD_FPD_UB941_SLAVE_ALIAS_5_REG_ADDR,\r
1744                                BOARD_FPD_UB941_SLAVE_ALIAS_6_REG_ADDR,\r
1745                                BOARD_FPD_UB941_SLAVE_ALIAS_7_REG_ADDR};\r
1746     if(handle == NULL)\r
1747     {\r
1748         return BOARD_INVALID_PARAM;\r
1749     }\r
1750     while((fpdRmtParams[i].i2cDevAddr != 0x00) && (i<8))\r
1751     {\r
1752         i2cDeviceData = (fpdRmtParams[i].i2cDevAddr << 1);\r
1753         ret = Board_i2c8BitRegWr(handle,\r
1754                                  fpdModParams->serSlvAddr,\r
1755                                  i2cDeviceAddr[i],\r
1756                                  &i2cDeviceData,\r
1757                                  1U,\r
1758                                  BOARD_I2C_TRANSACTION_TIMEOUT);\r
1759 \r
1760         if(ret != 0)\r
1761         {\r
1762             return BOARD_I2C_TRANSFER_FAIL;\r
1763         }\r
1764         \r
1765         i2cAliasData = (fpdRmtParams[i].i2cDevAliasAddr << 1);\r
1766         ret = Board_i2c8BitRegWr(handle,\r
1767                                  fpdModParams->serSlvAddr,\r
1768                                  i2cAliasAddr[i],\r
1769                                  &i2cAliasData,\r
1770                                  1U,\r
1771                                  BOARD_I2C_TRANSACTION_TIMEOUT);\r
1772 \r
1773         if(ret != 0)\r
1774         {\r
1775             return BOARD_I2C_TRANSFER_FAIL;\r
1776         }\r
1777         i++;\r
1778     }\r
1779     return BOARD_SOK;\r
1780 }\r
1781 \r
1782 /**\r
1783  * \brief  Inverted color pattern select\r
1784  *\r
1785  * This function is used to initialize the ub941 DSI module.\r
1786  *\r
1787  * \param   handle         [IN]  Low level driver handle\r
1788  * \param   fpdModParams   [IN]  FPD module params\r
1789  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
1790  *\r
1791  * \return  Board_STATUS in case of success or appropriate error code.\r
1792  *\r
1793  */\r
1794 Board_STATUS Board_fpdUb941SetInvtdClrPattEn(void *handle,\r
1795                                              Board_FpdModuleObj *fpdModParams,\r
1796                                              uint8_t cfgMode)\r
1797 {\r
1798     Board_STATUS ret = BOARD_SOK;\r
1799     uint8_t regData = 0;\r
1800 \r
1801     if(handle == NULL)\r
1802     {\r
1803         return BOARD_INVALID_PARAM;\r
1804     }\r
1805 \r
1806     ret = Board_i2c8BitRegRd(handle,\r
1807                              fpdModParams->serSlvAddr,\r
1808                              BOARD_FPD_UB941_PGCFG_PGCFG_P1_REG_ADDR,\r
1809                              &regData,\r
1810                              1U,\r
1811                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1812     if(ret != 0)\r
1813     {\r
1814         return BOARD_I2C_TRANSFER_FAIL;\r
1815     }\r
1816 \r
1817     regData &= ~(BOARD_FPD_UB941_INVERTED_COLOR_PATTERN_BIT_MASK);\r
1818     regData |= (cfgMode << BOARD_FPD_UB941_INVERTED_COLOR_PATTERN_SHIFT_CNT);\r
1819 \r
1820     ret = Board_i2c8BitRegWr(handle,\r
1821                              fpdModParams->serSlvAddr,\r
1822                              BOARD_FPD_UB941_PGCFG_PGCFG_P1_REG_ADDR,\r
1823                              &regData,\r
1824                              1U,\r
1825                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1826     if(ret != 0)\r
1827     {\r
1828         return BOARD_I2C_TRANSFER_FAIL;\r
1829     }\r
1830 \r
1831     return BOARD_SOK;\r
1832 }\r
1833 \r
1834 /**\r
1835  * \brief  configure auto scroll for pattern\r
1836  *\r
1837  * This function is used to enable/disable pass through mode\r
1838  *\r
1839  * \param   handle        [IN]   Low level driver handle\r
1840  * \param   fpdModParams  [IN]   FPD module params\r
1841  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
1842  *\r
1843  * \return   Board_STATUS in case of success or appropriate error code.\r
1844  *\r
1845  */\r
1846 Board_STATUS Board_fpdUb941SetAutoScrollPattEn(void *handle,\r
1847                                                Board_FpdModuleObj *fpdModParams,\r
1848                                                uint8_t cfgMode)\r
1849 {\r
1850     Board_STATUS ret = BOARD_SOK;\r
1851     uint8_t regData = 0;\r
1852 \r
1853     if(handle == NULL)\r
1854     {\r
1855         return BOARD_INVALID_PARAM;\r
1856     }\r
1857 \r
1858     ret = Board_i2c8BitRegRd(handle,\r
1859                              fpdModParams->serSlvAddr,\r
1860                              BOARD_FPD_UB941_PGCFG_PGCFG_P1_REG_ADDR,\r
1861                              &regData,\r
1862                              1U,\r
1863                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1864     if(ret != 0)\r
1865     {\r
1866         return BOARD_I2C_TRANSFER_FAIL;\r
1867     }\r
1868 \r
1869     regData &= ~(BOARD_FPD_UB941_AUTO_SCROLL_PATTERN_BIT_MASK);\r
1870     regData |= cfgMode;\r
1871 \r
1872     ret = Board_i2c8BitRegWr(handle,\r
1873                              fpdModParams->serSlvAddr,\r
1874                              BOARD_FPD_UB941_PGCFG_PGCFG_P1_REG_ADDR,\r
1875                              &regData,\r
1876                              1U,\r
1877                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1878     if(ret != 0)\r
1879     {\r
1880         return BOARD_I2C_TRANSFER_FAIL;\r
1881     }\r
1882 \r
1883     return BOARD_SOK;\r
1884 }\r
1885 \r
1886 /**\r
1887  * \brief  configure color bars\r
1888  *\r
1889  * This function is used to enable/disable pass through mode\r
1890  *\r
1891  * \param   handle        [IN]   Low level driver handle\r
1892  * \param   fpdModParams  [IN]   FPD module params\r
1893  * \param   patternSel    [IN]   Indicates the pattern to be displayed:\r
1894  *                                BOARD_FPD_UB941_PATTERN_CHECKERBOARD\r
1895  *                                BOARD_FPD_UB941_PATTERN_WHITE_BLACK\r
1896  *                                BOARD_FPD_UB941_PATTERN_BLACK_WHITE\r
1897  *                                BOARD_FPD_UB941_PATTERN_RED_CYAN\r
1898  *                                BOARD_FPD_UB941_PATTERN_GREEN_MAGNETA\r
1899  *                                BOARD_FPD_UB941_PATTERN_BLUE_YELLOW\r
1900  *                                BOARD_FPD_UB941_PATTERN_HORIZONTALLY_SCALE_BLK2WHT_WHT2BLK\r
1901  *                                BOARD_FPD_UB941_PATTERN_HORIZONTALLY_SCALE_BLK2RED_WHT2CYN\r
1902  *                                BOARD_FPD_UB941_PATTERN_HORIZONTALLY_SCALE_BLK2GRN_WHT2MAG\r
1903  *                                BOARD_FPD_UB941_PATTERN_HORIZONTALLY_SCALE_BLK2BLU_WHT2YEL\r
1904  *                                BOARD_FPD_UB941_PATTERN_VERTICALLY_SCALE_BLK2WHT_WHT2BLK\r
1905  *                                BOARD_FPD_UB941_PATTERN_VERTICALLY_SCALE_BLK2RED_WHT2CYN\r
1906  *                                BOARD_FPD_UB941_PATTERN_VERTICALLY_SCALE_BLK2GRN_WHT2MAG\r
1907  *                                BOARD_FPD_UB941_PATTERN_VERTICALLY_SCALE_BLK2BLU_WHT2YEL\r
1908  *                                BOARD_FPD_UB941_PATTERN_CUSTOM_COLORS\r
1909  *                                BOARD_FPD_UB941_PATTERN_VCOM\r
1910  * \return   Board_STATUS in case of success or appropriate error code.\r
1911  *\r
1912  */\r
1913 Board_STATUS Board_fpdUb941SelPatt(void *handle,\r
1914                                    Board_FpdModuleObj *fpdModParams,\r
1915                                    uint8_t patternSel)\r
1916 {\r
1917     Board_STATUS ret = BOARD_SOK;\r
1918     uint8_t regData = 0;\r
1919 \r
1920     if(handle == NULL)\r
1921     {\r
1922         return BOARD_INVALID_PARAM;\r
1923     }\r
1924 \r
1925     ret = Board_i2c8BitRegRd(handle,\r
1926                              fpdModParams->serSlvAddr,\r
1927                              BOARD_FPD_UB941_PGCTL_PGCTL_P1_REG_ADDR,\r
1928                              &regData,\r
1929                              1U,\r
1930                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1931     if(ret != 0)\r
1932     {\r
1933         return BOARD_I2C_TRANSFER_FAIL;\r
1934     }\r
1935 \r
1936     regData &= ~(BOARD_FPD_UB941_PATTERN_SEL_BIT_MASK);\r
1937     regData |= (patternSel << BOARD_FPD_UB941_PATTERN_SEL_SHIFT_CNT);\r
1938 \r
1939     ret = Board_i2c8BitRegWr(handle,\r
1940                              fpdModParams->serSlvAddr,\r
1941                              BOARD_FPD_UB941_PGCTL_PGCTL_P1_REG_ADDR,\r
1942                              &regData,\r
1943                              1U,\r
1944                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1945     if(ret != 0)\r
1946     {\r
1947         return BOARD_I2C_TRANSFER_FAIL;\r
1948     }\r
1949     \r
1950     /*enabling colors bars*/\r
1951     ret = Board_fpdUb941ColorBarEn(handle,\r
1952                                    fpdModParams,\r
1953                                    BOARD_FPD_MODE_ENABLE);\r
1954     if(ret != 0)\r
1955     {\r
1956         BOARD_DEBUG_LOG("Enabling Color Bars failed\n");\r
1957         return -1;\r
1958     } \r
1959 \r
1960     return BOARD_SOK;\r
1961 }\r
1962 \r
1963 /**\r
1964  * \brief  configure pattern display\r
1965  *\r
1966  * This function is used to enable/disable pass through mode\r
1967  *\r
1968  * \param   handle        [IN]   Low level driver handle\r
1969  * \param   fpdModParams  [IN]   FPD module params\r
1970  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
1971  *\r
1972  * \return   Board_STATUS in case of success or appropriate error code.\r
1973  *\r
1974  */\r
1975 Board_STATUS Board_fpdUb941PattGenEn(void *handle,\r
1976                                      Board_FpdModuleObj *fpdModParams,\r
1977                                      uint8_t cfgMode)\r
1978 {\r
1979     Board_STATUS ret = BOARD_SOK;\r
1980     uint8_t regData = 0;\r
1981 \r
1982     if(handle == NULL)\r
1983     {\r
1984         return BOARD_INVALID_PARAM;\r
1985     }\r
1986 \r
1987     ret = Board_i2c8BitRegRd(handle,\r
1988                              fpdModParams->serSlvAddr,\r
1989                              BOARD_FPD_UB941_PGCTL_PGCTL_P1_REG_ADDR,\r
1990                              &regData,\r
1991                              1U,\r
1992                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
1993     if(ret != 0)\r
1994     {\r
1995         return BOARD_I2C_TRANSFER_FAIL;\r
1996     }\r
1997 \r
1998     regData &= ~(BOARD_FPD_UB941_PATTERN_GENERATOR_BIT_MASK);\r
1999     regData |= cfgMode;\r
2000 \r
2001     ret = Board_i2c8BitRegWr(handle,\r
2002                              fpdModParams->serSlvAddr,\r
2003                              BOARD_FPD_UB941_PGCTL_PGCTL_P1_REG_ADDR,\r
2004                              &regData,\r
2005                              1U,\r
2006                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
2007     if(ret != 0)\r
2008     {\r
2009         return BOARD_I2C_TRANSFER_FAIL;\r
2010     }\r
2011 \r
2012     return BOARD_SOK;\r
2013 }\r
2014 /**\r
2015  * \brief  configure color bars\r
2016  *\r
2017  * This function is used to enable/disable pass through mode\r
2018  *\r
2019  * \param   handle        [IN]   Low level driver handle\r
2020  * \param   fpdModParams  [IN]   FPD module params\r
2021  * \param   cfgMode       [IN]   Config mode - Indicates Enable or Disable\r
2022  *\r
2023  * \return   Board_STATUS in case of success or appropriate error code.\r
2024  *\r
2025  */\r
2026 Board_STATUS Board_fpdUb941ColorBarEn(void *handle,\r
2027                                       Board_FpdModuleObj *fpdModParams,\r
2028                                       uint8_t cfgMode)\r
2029 {\r
2030     Board_STATUS ret = BOARD_SOK;\r
2031     uint8_t regData = 0;\r
2032 \r
2033     if(handle == NULL)\r
2034     {\r
2035         return BOARD_INVALID_PARAM;\r
2036     }\r
2037     \r
2038     ret = Board_i2c8BitRegRd(handle,\r
2039                              fpdModParams->serSlvAddr,\r
2040                              BOARD_FPD_UB941_PGCTL_PGCTL_P1_REG_ADDR,\r
2041                              &regData,\r
2042                              1U,\r
2043                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
2044     if(ret != 0)\r
2045     {\r
2046         return BOARD_I2C_TRANSFER_FAIL;\r
2047     }\r
2048 \r
2049     regData &= ~(BOARD_FPD_UB941_COLORS_BAR_PATTERN_SEL_BIT_MASK);\r
2050     regData |= (cfgMode << BOARD_FPD_UB941_COLORS_BAR_PATTERN_SEL_SHIFT_CNT);\r
2051 \r
2052     ret = Board_i2c8BitRegWr(handle,\r
2053                              fpdModParams->serSlvAddr,\r
2054                              BOARD_FPD_UB941_PGCTL_PGCTL_P1_REG_ADDR,\r
2055                              &regData,\r
2056                              1U,\r
2057                              BOARD_I2C_TRANSACTION_TIMEOUT);\r
2058     if(ret != 0)\r
2059     {\r
2060         return BOARD_I2C_TRANSFER_FAIL;\r
2061     }\r
2062 \r
2063     return BOARD_SOK;\r
2064 }\r
2065 \r
2066 /**\r
2067  * \brief  Get ub941 i2c address.\r
2068  *\r
2069  * This function is used to get the I2C address and\r
2070  * channel details of UB960 module.\r
2071  *\r
2072  * \param   domain    [IN]  I2C instance domain\r
2073  * \param   chNum     [IN]  buffer to hold i2c channel number\r
2074  * \param   i2cAddr   [IN]  buffer to hold i2c address\r
2075  *\r
2076  * \return  BOARD_SOK in case of success or appropriate error code.\r
2077  */\r
2078 void Board_fpdUb941GetI2CAddr(uint8_t *domain,\r
2079                               uint8_t *chNum,\r
2080                               uint8_t *i2cAddr)\r
2081 {\r
2082     *domain = BOARD_SOC_DOMAIN_MAIN;\r
2083     *chNum = 1U;\r
2084     *i2cAddr = 0x16;\r
2085 }\r
2086 \r
2087 \r
2088 \r