target/linux/generic-2.6/files/crypto/ocf/kirkwood/mvHal/kw_family/boardEnv/mvBoardEnvLib.c

   1 /*******************************************************************************
   2 Copyright (C) Marvell International Ltd. and its affiliates
   3
   4 This software file (the "File") is owned and distributed by Marvell
   5 International Ltd. and/or its affiliates ("Marvell") under the following
   6 alternative licensing terms.  Once you have made an election to distribute the
   7 File under one of the following license alternatives, please (i) delete this
   8 introductory statement regarding license alternatives, (ii) delete the two
   9 license alternatives that you have not elected to use and (iii) preserve the
  10 Marvell copyright notice above.
  11
  12 ********************************************************************************
  13 Marvell Commercial License Option
  14
  15 If you received this File from Marvell and you have entered into a commercial
  16 license agreement (a "Commercial License") with Marvell, the File is licensed
  17 to you under the terms of the applicable Commercial License.
  18
  19 ********************************************************************************
  20 Marvell GPL License Option
  21
  22 If you received this File from Marvell, you may opt to use, redistribute and/or
  23 modify this File in accordance with the terms and conditions of the General
  24 Public License Version 2, June 1991 (the "GPL License"), a copy of which is
  25 available along with the File in the license.txt file or by writing to the Free
  26 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
  27 on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
  28
  29 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
  30 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
  31 DISCLAIMED.  The GPL License provides additional details about this warranty
  32 disclaimer.
  33 ********************************************************************************
  34 Marvell BSD License Option
  35
  36 If you received this File from Marvell, you may opt to use, redistribute and/or
  37 modify this File under the following licensing terms.
  38 Redistribution and use in source and binary forms, with or without modification,
  39 are permitted provided that the following conditions are met:
  40
  41     *   Redistributions of source code must retain the above copyright notice,
  42             this list of conditions and the following disclaimer.
  43
  44     *   Redistributions in binary form must reproduce the above copyright
  45         notice, this list of conditions and the following disclaimer in the
  46         documentation and/or other materials provided with the distribution.
  47
  48     *   Neither the name of Marvell nor the names of its contributors may be
  49         used to endorse or promote products derived from this software without
  50         specific prior written permission.
  51
  52 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  53 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  54 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  55 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  56 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  57 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  58 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  59 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  60 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  61 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  62
  63 *******************************************************************************/
  64
  65 #include "boardEnv/mvBoardEnvLib.h"
  66 #include "ctrlEnv/mvCtrlEnvLib.h"
  67 #include "ctrlEnv/sys/mvCpuIf.h"
  68 #include "cpu/mvCpu.h"
  69 #include "cntmr/mvCntmr.h"
  70 #include "gpp/mvGpp.h"
  71 #include "twsi/mvTwsi.h"
  72 #include "pex/mvPex.h"
  73 #include "device/mvDevice.h"
  74 #include "eth/gbe/mvEthRegs.h"
  75
  76 /* defines  */
  77 /* #define MV_DEBUG */
  78 #ifdef MV_DEBUG
  79         #define DB(x)   x
  80 #else
  81         #define DB(x)
  82 #endif
  83
  84 extern MV_CPU_ARM_CLK _cpuARMDDRCLK[];
  85
  86 #define CODE_IN_ROM             MV_FALSE
  87 #define CODE_IN_RAM             MV_TRUE
  88
  89 extern  MV_BOARD_INFO*  boardInfoTbl[];
  90 #define BOARD_INFO(boardId)     boardInfoTbl[boardId - BOARD_ID_BASE]
  91
  92 /* Locals */
  93 static MV_DEV_CS_INFO*  boardGetDevEntry(MV_32 devNum, MV_BOARD_DEV_CLASS devClass);
  94
  95 MV_U32 tClkRate   = -1;
  96
  97
  98 /*******************************************************************************
  99 * mvBoardEnvInit - Init board
 100 *
 101 * DESCRIPTION:
 102 *               In this function the board environment take care of device bank
 103 *               initialization.
 104 *
 105 * INPUT:
 106 *       None.
 107 *
 108 * OUTPUT:
 109 *       None.
 110 *
 111 * RETURN:
 112 *       None.
 113 *
 114 *******************************************************************************/
 115 MV_VOID mvBoardEnvInit(MV_VOID)
 116 {
 117         MV_U32 boardId= mvBoardIdGet();
 118
 119         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 120         {
 121                 mvOsPrintf("mvBoardEnvInit:Board unknown.\n");
 122                 return;
 123
 124         }
 125
 126         /* Set GPP Out value */
 127         MV_REG_WRITE(GPP_DATA_OUT_REG(0), BOARD_INFO(boardId)->gppOutValLow);
 128         MV_REG_WRITE(GPP_DATA_OUT_REG(1), BOARD_INFO(boardId)->gppOutValHigh);
 129
 130         /* set GPP polarity */
 131         mvGppPolaritySet(0, 0xFFFFFFFF, BOARD_INFO(boardId)->gppPolarityValLow);
 132         mvGppPolaritySet(1, 0xFFFFFFFF, BOARD_INFO(boardId)->gppPolarityValHigh);
 133
 134     /* Workaround for Erratum FE-MISC-70*/
 135     if(mvCtrlRevGet()==MV_88F6XXX_A0_REV)
 136     {
 137         BOARD_INFO(boardId)->gppOutEnValLow &= 0xfffffffd;
 138         BOARD_INFO(boardId)->gppOutEnValLow |= (BOARD_INFO(boardId)->gppOutEnValHigh) & 0x00000002;
 139     } /*End of WA*/
 140
 141         /* Set GPP Out Enable*/
 142         mvGppTypeSet(0, 0xFFFFFFFF, BOARD_INFO(boardId)->gppOutEnValLow);
 143         mvGppTypeSet(1, 0xFFFFFFFF, BOARD_INFO(boardId)->gppOutEnValHigh);
 144
 145         /* Nand CE */
 146         MV_REG_BIT_SET(NAND_CTRL_REG, NAND_ACTCEBOOT_BIT);
 147 }
 148
 149 /*******************************************************************************
 150 * mvBoardModelGet - Get Board model
 151 *
 152 * DESCRIPTION:
 153 *       This function returns 16bit describing board model.
 154 *       Board model is constructed of one byte major and minor numbers in the
 155 *       following manner:
 156 *
 157 * INPUT:
 158 *       None.
 159 *
 160 * OUTPUT:
 161 *       None.
 162 *
 163 * RETURN:
 164 *       String describing board model.
 165 *
 166 *******************************************************************************/
 167 MV_U16 mvBoardModelGet(MV_VOID)
 168 {
 169         return (mvBoardIdGet() >> 16);
 170 }
 171
 172 /*******************************************************************************
 173 * mbBoardRevlGet - Get Board revision
 174 *
 175 * DESCRIPTION:
 176 *       This function returns a 32bit describing the board revision.
 177 *       Board revision is constructed of 4bytes. 2bytes describes major number
 178 *       and the other 2bytes describes minor munber.
 179 *       For example for board revision 3.4 the function will return
 180 *       0x00030004.
 181 *
 182 * INPUT:
 183 *       None.
 184 *
 185 * OUTPUT:
 186 *       None.
 187 *
 188 * RETURN:
 189 *       String describing board model.
 190 *
 191 *******************************************************************************/
 192 MV_U16 mvBoardRevGet(MV_VOID)
 193 {
 194         return (mvBoardIdGet() & 0xFFFF);
 195 }
 196
 197 /*******************************************************************************
 198 * mvBoardNameGet - Get Board name
 199 *
 200 * DESCRIPTION:
 201 *       This function returns a string describing the board model and revision.
 202 *       String is extracted from board I2C EEPROM.
 203 *
 204 * INPUT:
 205 *       None.
 206 *
 207 * OUTPUT:
 208 *       pNameBuff - Buffer to contain board name string. Minimum size 32 chars.
 209 *
 210 * RETURN:
 211 *
 212 *       MV_ERROR if informantion can not be read.
 213 *******************************************************************************/
 214 MV_STATUS mvBoardNameGet(char *pNameBuff)
 215 {
 216         MV_U32 boardId= mvBoardIdGet();
 217
 218         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 219         {
 220                 mvOsSPrintf (pNameBuff, "Board unknown.\n");
 221                 return MV_ERROR;
 222
 223         }
 224
 225         mvOsSPrintf (pNameBuff, "%s",BOARD_INFO(boardId)->boardName);
 226
 227         return MV_OK;
 228 }
 229
 230 /*******************************************************************************
 231 * mvBoardIsPortInSgmii -
 232 *
 233 * DESCRIPTION:
 234 *       This routine returns MV_TRUE for port number works in SGMII or MV_FALSE
 235 *       For all other options.
 236 *
 237 * INPUT:
 238 *       ethPortNum - Ethernet port number.
 239 *
 240 * OUTPUT:
 241 *       None.
 242 *
 243 * RETURN:
 244 *       MV_TRUE - port in SGMII.
 245 *       MV_FALSE - other.
 246 *
 247 *******************************************************************************/
 248 MV_BOOL mvBoardIsPortInSgmii(MV_U32 ethPortNum)
 249 {
 250     MV_BOOL ethPortSgmiiSupport[BOARD_ETH_PORT_NUM] = MV_ETH_PORT_SGMII;
 251
 252     if(ethPortNum >= BOARD_ETH_PORT_NUM)
 253     {
 254             mvOsPrintf ("Invalid portNo=%d\n", ethPortNum);
 255                 return MV_FALSE;
 256     }
 257     return ethPortSgmiiSupport[ethPortNum];
 258 }
 259
 260 /*******************************************************************************
 261 * mvBoardIsPortInGmii -
 262 *
 263 * DESCRIPTION:
 264 *       This routine returns MV_TRUE for port number works in GMII or MV_FALSE
 265 *       For all other options.
 266 *
 267 * INPUT:
 268 *
 269 * OUTPUT:
 270 *       None.
 271 *
 272 * RETURN:
 273 *       MV_TRUE - port in GMII.
 274 *       MV_FALSE - other.
 275 *
 276 *******************************************************************************/
 277 MV_BOOL mvBoardIsPortInGmii(MV_VOID)
 278 {
 279         MV_U32 devClassId, devClass = 0;
 280         if (mvBoardMppGroupTypeGet(devClass) == MV_BOARD_AUTO)
 281         {
 282                 /* Get MPP module ID */
 283                 devClassId = mvBoarModuleTypeGet(devClass);
 284                 if (MV_BOARD_MODULE_GMII_ID == devClassId)
 285                         return MV_TRUE;
 286         }
 287         else if (mvBoardMppGroupTypeGet(devClass) == MV_BOARD_GMII)
 288                 return MV_TRUE;
 289
 290     return MV_FALSE;
 291 }
 292 /*******************************************************************************
 293 * mvBoardPhyAddrGet - Get the phy address
 294 *
 295 * DESCRIPTION:
 296 *       This routine returns the Phy address of a given ethernet port.
 297 *
 298 * INPUT:
 299 *       ethPortNum - Ethernet port number.
 300 *
 301 * OUTPUT:
 302 *       None.
 303 *
 304 * RETURN:
 305 *       32bit describing Phy address, -1 if the port number is wrong.
 306 *
 307 *******************************************************************************/
 308 MV_32 mvBoardPhyAddrGet(MV_U32 ethPortNum)
 309 {
 310         MV_U32 boardId= mvBoardIdGet();
 311
 312         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 313         {
 314                 mvOsPrintf("mvBoardPhyAddrGet: Board unknown.\n");
 315                 return MV_ERROR;
 316         }
 317
 318         return BOARD_INFO(boardId)->pBoardMacInfo[ethPortNum].boardEthSmiAddr;
 319 }
 320
 321 /*******************************************************************************
 322 * mvBoardMacSpeedGet - Get the Mac speed
 323 *
 324 * DESCRIPTION:
 325 *       This routine returns the Mac speed if pre define of a given ethernet port.
 326 *
 327 * INPUT:
 328 *       ethPortNum - Ethernet port number.
 329 *
 330 * OUTPUT:
 331 *       None.
 332 *
 333 * RETURN:
 334 *       MV_BOARD_MAC_SPEED, -1 if the port number is wrong.
 335 *
 336 *******************************************************************************/
 337 MV_BOARD_MAC_SPEED      mvBoardMacSpeedGet(MV_U32 ethPortNum)
 338 {
 339         MV_U32 boardId= mvBoardIdGet();
 340
 341         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 342         {
 343                 mvOsPrintf("mvBoardMacSpeedGet: Board unknown.\n");
 344                 return MV_ERROR;
 345         }
 346
 347         return BOARD_INFO(boardId)->pBoardMacInfo[ethPortNum].boardMacSpeed;
 348 }
 349
 350 /*******************************************************************************
 351 * mvBoardLinkStatusIrqGet - Get the IRQ number for the link status indication
 352 *
 353 * DESCRIPTION:
 354 *       This routine returns the IRQ number for the link status indication.
 355 *
 356 * INPUT:
 357 *       ethPortNum - Ethernet port number.
 358 *
 359 * OUTPUT:
 360 *       None.
 361 *
 362 * RETURN:
 363 *       the number of the IRQ for the link status indication, -1 if the port
 364 *       number is wrong or if not relevant.
 365 *
 366 *******************************************************************************/
 367 MV_32   mvBoardLinkStatusIrqGet(MV_U32 ethPortNum)
 368 {
 369         MV_U32 boardId = mvBoardIdGet();
 370
 371         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 372         {
 373                 mvOsPrintf("mvBoardLinkStatusIrqGet: Board unknown.\n");
 374                 return MV_ERROR;
 375         }
 376
 377         return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].linkStatusIrq;
 378 }
 379
 380 /*******************************************************************************
 381 * mvBoardSwitchPortGet - Get the mapping between the board connector and the
 382 * Ethernet Switch port
 383 *
 384 * DESCRIPTION:
 385 *       This routine returns the matching Switch port.
 386 *
 387 * INPUT:
 388 *       ethPortNum - Ethernet port number.
 389 *       boardPortNum - logical number of the connector on the board
 390 *
 391 * OUTPUT:
 392 *       None.
 393 *
 394 * RETURN:
 395 *       the matching Switch port, -1 if the port number is wrong or if not relevant.
 396 *
 397 *******************************************************************************/
 398 MV_32   mvBoardSwitchPortGet(MV_U32 ethPortNum, MV_U8 boardPortNum)
 399 {
 400         MV_U32 boardId = mvBoardIdGet();
 401
 402         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 403         {
 404                 mvOsPrintf("mvBoardSwitchPortGet: Board unknown.\n");
 405                 return MV_ERROR;
 406         }
 407         if (boardPortNum >= BOARD_ETH_SWITCH_PORT_NUM)
 408         {
 409                 mvOsPrintf("mvBoardSwitchPortGet: Illegal board port number.\n");
 410                 return MV_ERROR;
 411         }
 412
 413         return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].qdPort[boardPortNum];
 414 }
 415
 416 /*******************************************************************************
 417 * mvBoardSwitchCpuPortGet - Get the the Ethernet Switch CPU port
 418 *
 419 * DESCRIPTION:
 420 *       This routine returns the Switch CPU port.
 421 *
 422 * INPUT:
 423 *       ethPortNum - Ethernet port number.
 424 *
 425 * OUTPUT:
 426 *       None.
 427 *
 428 * RETURN:
 429 *       the Switch CPU port, -1 if the port number is wrong or if not relevant.
 430 *
 431 *******************************************************************************/
 432 MV_32   mvBoardSwitchCpuPortGet(MV_U32 ethPortNum)
 433 {
 434         MV_U32 boardId = mvBoardIdGet();
 435
 436         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 437         {
 438                 mvOsPrintf("mvBoardSwitchCpuPortGet: Board unknown.\n");
 439                 return MV_ERROR;
 440         }
 441
 442         return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].qdCpuPort;
 443 }
 444
 445 /*******************************************************************************
 446 * mvBoardIsSwitchConnected - Get switch connection status
 447 * DESCRIPTION:
 448 *       This routine returns port's connection status
 449 *
 450 * INPUT:
 451 *       ethPortNum - Ethernet port number.
 452 *
 453 * OUTPUT:
 454 *       None.
 455 *
 456 * RETURN:
 457 *       1 - if ethPortNum is connected to switch, 0 otherwise
 458 *
 459 *******************************************************************************/
 460 MV_32   mvBoardIsSwitchConnected(MV_U32 ethPortNum)
 461 {
 462         MV_U32 boardId = mvBoardIdGet();
 463
 464         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 465         {
 466                 mvOsPrintf("mvBoardIsSwitchConnected: Board unknown.\n");
 467                 return MV_ERROR;
 468         }
 469
 470         if(ethPortNum >= BOARD_INFO(boardId)->numBoardMacInfo)
 471         {
 472                 mvOsPrintf("mvBoardIsSwitchConnected: Illegal port number(%u)\n", ethPortNum);
 473                 return MV_ERROR;
 474         }
 475
 476         if((MV_32)(BOARD_INFO(boardId)->pSwitchInfo))
 477         return (MV_32)(BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].switchOnPort == ethPortNum);
 478         else
 479                 return 0;
 480 }
 481 /*******************************************************************************
 482 * mvBoardSmiScanModeGet - Get Switch SMI scan mode
 483 *
 484 * DESCRIPTION:
 485 *       This routine returns Switch SMI scan mode.
 486 *
 487 * INPUT:
 488 *       ethPortNum - Ethernet port number.
 489 *
 490 * OUTPUT:
 491 *       None.
 492 *
 493 * RETURN:
 494 *       1 for SMI_MANUAL_MODE, -1 if the port number is wrong or if not relevant.
 495 *
 496 *******************************************************************************/
 497 MV_32   mvBoardSmiScanModeGet(MV_U32 ethPortNum)
 498 {
 499         MV_U32 boardId = mvBoardIdGet();
 500
 501         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 502         {
 503                 mvOsPrintf("mvBoardSmiScanModeGet: Board unknown.\n");
 504                 return MV_ERROR;
 505         }
 506
 507         return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].smiScanMode;
 508 }
 509 /*******************************************************************************
 510 * mvBoardSpecInitGet -
 511 *
 512 * DESCRIPTION:
 513 *
 514 * INPUT:
 515 *
 516 * OUTPUT:
 517 *       None.
 518 *
 519 * RETURN: Return MV_TRUE and parameters in case board need spesific phy init,
 520 *         otherwise return MV_FALSE.
 521 *
 522 *
 523 *******************************************************************************/
 524
 525 MV_BOOL mvBoardSpecInitGet(MV_U32* regOff, MV_U32* data)
 526 {
 527         return MV_FALSE;
 528 }
 529
 530 /*******************************************************************************
 531 * mvBoardTclkGet - Get the board Tclk (Controller clock)
 532 *
 533 * DESCRIPTION:
 534 *       This routine extract the controller core clock.
 535 *       This function uses the controller counters to make identification.
 536 *               Note: In order to avoid interference, make sure task context switch
 537 *               and interrupts will not occure during this function operation
 538 *
 539 * INPUT:
 540 *       countNum - Counter number.
 541 *
 542 * OUTPUT:
 543 *       None.
 544 *
 545 * RETURN:
 546 *       32bit clock cycles in Hertz.
 547 *
 548 *******************************************************************************/
 549 MV_U32 mvBoardTclkGet(MV_VOID)
 550 {
 551     if(mvCtrlModelGet()==MV_6281_DEV_ID)
 552     {
 553 #if defined(TCLK_AUTO_DETECT)
 554         MV_U32 tmpTClkRate = MV_BOARD_TCLK_166MHZ;
 555
 556     tmpTClkRate = MV_REG_READ(MPP_SAMPLE_AT_RESET);
 557     tmpTClkRate &= MSAR_TCLCK_MASK;
 558
 559     switch (tmpTClkRate)
 560     {
 561     case MSAR_TCLCK_166:
 562             return MV_BOARD_TCLK_166MHZ;
 563             break;
 564     case MSAR_TCLCK_200:
 565             return MV_BOARD_TCLK_200MHZ;
 566             break;
 567     }
 568 #else
 569     return MV_BOARD_TCLK_200MHZ;
 570 #endif
 571     }
 572
 573         return MV_BOARD_TCLK_166MHZ;
 574
 575 }
 576 /*******************************************************************************
 577 * mvBoardSysClkGet - Get the board SysClk (CPU bus clock)
 578 *
 579 * DESCRIPTION:
 580 *       This routine extract the CPU bus clock.
 581 *
 582 * INPUT:
 583 *       countNum - Counter number.
 584 *
 585 * OUTPUT:
 586 *       None.
 587 *
 588 * RETURN:
 589 *       32bit clock cycles in Hertz.
 590 *
 591 *******************************************************************************/
 592 static MV_U32  mvBoard6180SysClkGet(MV_VOID)
 593 {
 594         MV_U32  sysClkRate=0;
 595         MV_CPU_ARM_CLK _cpu6180_ddr_l2_CLK[] = MV_CPU6180_DDR_L2_CLCK_TBL;
 596
 597         sysClkRate = MV_REG_READ(MPP_SAMPLE_AT_RESET);
 598         sysClkRate = sysClkRate & MSAR_CPUCLCK_MASK_6180;
 599         sysClkRate = sysClkRate >> MSAR_CPUCLCK_OFFS_6180;
 600
 601         sysClkRate = _cpu6180_ddr_l2_CLK[sysClkRate].ddrClk;
 602
 603         return sysClkRate;
 604
 605 }
 606
 607 MV_U32  mvBoardSysClkGet(MV_VOID)
 608 {
 609 #ifdef SYSCLK_AUTO_DETECT
 610         MV_U32 sysClkRate, tmp, pClkRate, indexDdrRtio;
 611         MV_U32 cpuCLK[] = MV_CPU_CLCK_TBL;
 612         MV_U32 ddrRtio[][2] = MV_DDR_CLCK_RTIO_TBL;
 613
 614         if(mvCtrlModelGet() == MV_6180_DEV_ID)
 615                 return mvBoard6180SysClkGet();
 616
 617         tmp = MV_REG_READ(MPP_SAMPLE_AT_RESET);
 618         pClkRate = MSAR_CPUCLCK_EXTRACT(tmp);
 619         pClkRate = cpuCLK[pClkRate];
 620
 621         indexDdrRtio = tmp & MSAR_DDRCLCK_RTIO_MASK;
 622         indexDdrRtio = indexDdrRtio >> MSAR_DDRCLCK_RTIO_OFFS;
 623     if(ddrRtio[indexDdrRtio][0] != 0)
 624         sysClkRate = ((pClkRate * ddrRtio[indexDdrRtio][1]) / ddrRtio[indexDdrRtio][0]);
 625     else
 626         sysClkRate = 0;
 627         return sysClkRate;
 628 #else
 629         return MV_BOARD_DEFAULT_SYSCLK;
 630 #endif
 631 }
 632
 633
 634 /*******************************************************************************
 635 * mvBoardPexBridgeIntPinGet - Get PEX to PCI bridge interrupt pin number
 636 *
 637 * DESCRIPTION:
 638 *               Multi-ported PCI Express bridges that is implemented on the board
 639 *               collapse interrupts across multiple conventional PCI/PCI-X buses.
 640 *               A dual-headed PCI Express bridge would map (or "swizzle") the
 641 *               interrupts per the following table (in accordance with the respective
 642 *               logical PCI/PCI-X bridge's Device Number), collapse the INTA#-INTD#
 643 *               signals from its two logical PCI/PCI-X bridges, collapse the
 644 *               INTA#-INTD# signals from any internal sources, and convert the
 645 *               signals to in-band PCI Express messages. 10
 646 *               This function returns the upstream interrupt as it was converted by
 647 *               the bridge, according to board configuration and the following table:
 648 *                                                       PCI dev num
 649 *                       Interrupt pin   7,      8,      9
 650 *                                       A  ->   A       D       C
 651 *                                       B  ->   B       A       D
 652 *                                       C  ->   C       B       A
 653 *                                       D  ->   D       C       B
 654 *
 655 *
 656 * INPUT:
 657 *       devNum - PCI/PCIX device number.
 658 *       intPin - PCI Int pin
 659 *
 660 * OUTPUT:
 661 *       None.
 662 *
 663 * RETURN:
 664 *       Int pin connected to the Interrupt controller
 665 *
 666 *******************************************************************************/
 667 MV_U32 mvBoardPexBridgeIntPinGet(MV_U32 devNum, MV_U32 intPin)
 668 {
 669         MV_U32 realIntPin = ((intPin + (3 - (devNum % 4))) %4 );
 670
 671         if (realIntPin == 0) return 4;
 672                 else return realIntPin;
 673
 674 }
 675
 676 /*******************************************************************************
 677 * mvBoardDebugLedNumGet - Get number of debug Leds
 678 *
 679 * DESCRIPTION:
 680 * INPUT:
 681 *       boardId
 682 *
 683 * OUTPUT:
 684 *       None.
 685 *
 686 * RETURN:
 687 *       None.
 688 *
 689 *******************************************************************************/
 690 MV_U32 mvBoardDebugLedNumGet(MV_U32 boardId)
 691 {
 692         return BOARD_INFO(boardId)->activeLedsNumber;
 693 }
 694
 695 /*******************************************************************************
 696 * mvBoardDebugLeg - Set the board debug Leds
 697 *
 698 * DESCRIPTION: turn on/off status leds.
 699 *              Note: assume MPP leds are part of group 0 only.
 700 *
 701 * INPUT:
 702 *       hexNum - Number to be displied in hex by Leds.
 703 *
 704 * OUTPUT:
 705 *       None.
 706 *
 707 * RETURN:
 708 *       None.
 709 *
 710 *******************************************************************************/
 711 MV_VOID mvBoardDebugLed(MV_U32 hexNum)
 712 {
 713     MV_U32 val = 0,totalMask, currentBitMask = 1,i;
 714     MV_U32 boardId= mvBoardIdGet();
 715
 716     if (BOARD_INFO(boardId)->pLedGppPin == NULL)
 717         return;
 718
 719     totalMask = (1 << BOARD_INFO(boardId)->activeLedsNumber) -1;
 720     hexNum &= totalMask;
 721     totalMask = 0;
 722
 723     for (i = 0 ; i < BOARD_INFO(boardId)->activeLedsNumber ; i++)
 724     {
 725         if (hexNum & currentBitMask)
 726         {
 727             val |= (1 << BOARD_INFO(boardId)->pLedGppPin[i]);
 728         }
 729
 730         totalMask |= (1 << BOARD_INFO(boardId)->pLedGppPin[i]);
 731
 732         currentBitMask = (currentBitMask << 1);
 733     }
 734
 735     if (BOARD_INFO(boardId)->ledsPolarity)
 736     {
 737         mvGppValueSet(0, totalMask, val);
 738     }
 739     else
 740     {
 741         mvGppValueSet(0, totalMask, ~val);
 742     }
 743 }
 744
 745
 746 /*******************************************************************************
 747 * mvBoarGpioPinGet - mvBoarGpioPinGet
 748 *
 749 * DESCRIPTION:
 750 *
 751 * INPUT:
 752 *               class - MV_BOARD_GPP_CLASS enum.
 753 *
 754 * OUTPUT:
 755 *               None.
 756 *
 757 * RETURN:
 758 *       GPIO pin number. The function return -1 for bad parameters.
 759 *
 760 *******************************************************************************/
 761 MV_32 mvBoarGpioPinNumGet(MV_BOARD_GPP_CLASS class, MV_U32 index)
 762 {
 763         MV_U32 boardId, i;
 764         MV_U32 indexFound = 0;
 765
 766         boardId = mvBoardIdGet();
 767
 768         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 769         {
 770                 mvOsPrintf("mvBoardRTCGpioPinGet:Board unknown.\n");
 771                 return MV_ERROR;
 772
 773         }
 774
 775         for (i = 0; i < BOARD_INFO(boardId)->numBoardGppInfo; i++)
 776                 if (BOARD_INFO(boardId)->pBoardGppInfo[i].devClass == class) {
 777                         if (indexFound == index)
 778                                 return (MV_U32)BOARD_INFO(boardId)->pBoardGppInfo[i].gppPinNum;
 779                         else
 780                                 indexFound++;
 781
 782                 }
 783
 784         return MV_ERROR;
 785 }
 786
 787
 788 /*******************************************************************************
 789 * mvBoardRTCGpioPinGet - mvBoardRTCGpioPinGet
 790 *
 791 * DESCRIPTION:
 792 *
 793 * INPUT:
 794 *               None.
 795 *
 796 * OUTPUT:
 797 *               None.
 798 *
 799 * RETURN:
 800 *       GPIO pin number. The function return -1 for bad parameters.
 801 *
 802 *******************************************************************************/
 803 MV_32 mvBoardRTCGpioPinGet(MV_VOID)
 804 {
 805         return mvBoarGpioPinNumGet(BOARD_GPP_RTC, 0);
 806 }
 807
 808
 809 /*******************************************************************************
 810 * mvBoardReset - mvBoardReset
 811 *
 812 * DESCRIPTION:
 813 *                       Reset the board
 814 * INPUT:
 815 *               None.
 816 *
 817 * OUTPUT:
 818 *               None.
 819 *
 820 * RETURN:
 821 *       None
 822 *
 823 *******************************************************************************/
 824 MV_VOID mvBoardReset(MV_VOID)
 825 {
 826         MV_32 resetPin;
 827
 828         /* Get gpp reset pin if define */
 829         resetPin = mvBoardResetGpioPinGet();
 830         if (resetPin != MV_ERROR)
 831         {
 832                 MV_REG_BIT_RESET( GPP_DATA_OUT_REG(0) ,(1 << resetPin));
 833                 MV_REG_BIT_RESET( GPP_DATA_OUT_EN_REG(0) ,(1 << resetPin));
 834
 835         }
 836         else
 837         {
 838             /* No gpp reset pin was found, try to reset ussing
 839             system reset out */
 840             MV_REG_BIT_SET( CPU_RSTOUTN_MASK_REG , BIT2);
 841             MV_REG_BIT_SET( CPU_SYS_SOFT_RST_REG , BIT0);
 842         }
 843 }
 844
 845 /*******************************************************************************
 846 * mvBoardResetGpioPinGet - mvBoardResetGpioPinGet
 847 *
 848 * DESCRIPTION:
 849 *
 850 * INPUT:
 851 *               None.
 852 *
 853 * OUTPUT:
 854 *               None.
 855 *
 856 * RETURN:
 857 *       GPIO pin number. The function return -1 for bad parameters.
 858 *
 859 *******************************************************************************/
 860 MV_32 mvBoardResetGpioPinGet(MV_VOID)
 861 {
 862         return mvBoarGpioPinNumGet(BOARD_GPP_RESET, 0);
 863 }
 864 /*******************************************************************************
 865 * mvBoardSDIOGpioPinGet - mvBoardSDIOGpioPinGet
 866 *
 867 * DESCRIPTION:
 868 *       used for hotswap detection
 869 * INPUT:
 870 *               None.
 871 *
 872 * OUTPUT:
 873 *               None.
 874 *
 875 * RETURN:
 876 *       GPIO pin number. The function return -1 for bad parameters.
 877 *
 878 *******************************************************************************/
 879 MV_32  mvBoardSDIOGpioPinGet(MV_VOID)
 880 {
 881         return mvBoarGpioPinNumGet(BOARD_GPP_SDIO_DETECT, 0);
 882 }
 883
 884 /*******************************************************************************
 885 * mvBoardUSBVbusGpioPinGet - return Vbus input GPP
 886 *
 887 * DESCRIPTION:
 888 *
 889 * INPUT:
 890 *               int  devNo.
 891 *
 892 * OUTPUT:
 893 *               None.
 894 *
 895 * RETURN:
 896 *       GPIO pin number. The function return -1 for bad parameters.
 897 *
 898 *******************************************************************************/
 899 MV_32 mvBoardUSBVbusGpioPinGet(MV_32 devId)
 900 {
 901         return mvBoarGpioPinNumGet(BOARD_GPP_USB_VBUS, devId);
 902 }
 903
 904 /*******************************************************************************
 905 * mvBoardUSBVbusEnGpioPinGet - return Vbus Enable output GPP
 906 *
 907 * DESCRIPTION:
 908 *
 909 * INPUT:
 910 *               int  devNo.
 911 *
 912 * OUTPUT:
 913 *               None.
 914 *
 915 * RETURN:
 916 *       GPIO pin number. The function return -1 for bad parameters.
 917 *
 918 *******************************************************************************/
 919 MV_32 mvBoardUSBVbusEnGpioPinGet(MV_32 devId)
 920 {
 921         return mvBoarGpioPinNumGet(BOARD_GPP_USB_VBUS_EN, devId);
 922 }
 923
 924
 925 /*******************************************************************************
 926 * mvBoardGpioIntMaskGet - Get GPIO mask for interrupt pins
 927 *
 928 * DESCRIPTION:
 929 *               This function returns a 32-bit mask of GPP pins that connected to
 930 *               interrupt generating sources on board.
 931 *               For example if UART channel A is hardwired to GPP pin 8 and
 932 *               UART channel B is hardwired to GPP pin 4 the fuinction will return
 933 *               the value 0x000000110
 934 *
 935 * INPUT:
 936 *               None.
 937 *
 938 * OUTPUT:
 939 *               None.
 940 *
 941 * RETURN:
 942 *               See description. The function return -1 if board is not identified.
 943 *
 944 *******************************************************************************/
 945 MV_32 mvBoardGpioIntMaskLowGet(MV_VOID)
 946 {
 947         MV_U32 boardId;
 948
 949         boardId = mvBoardIdGet();
 950
 951         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 952         {
 953                 mvOsPrintf("mvBoardGpioIntMaskGet:Board unknown.\n");
 954                 return MV_ERROR;
 955
 956         }
 957
 958         return BOARD_INFO(boardId)->intsGppMaskLow;
 959 }
 960 MV_32 mvBoardGpioIntMaskHighGet(MV_VOID)
 961 {
 962         MV_U32 boardId;
 963
 964         boardId = mvBoardIdGet();
 965
 966         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
 967         {
 968                 mvOsPrintf("mvBoardGpioIntMaskGet:Board unknown.\n");
 969                 return MV_ERROR;
 970
 971         }
 972
 973         return BOARD_INFO(boardId)->intsGppMaskHigh;
 974 }
 975
 976
 977 /*******************************************************************************
 978 * mvBoardMppGet - Get board dependent MPP register value
 979 *
 980 * DESCRIPTION:
 981 *               MPP settings are derived from board design.
 982 *               MPP group consist of 8 MPPs. An MPP group represent MPP
 983 *               control register.
 984 *       This function retrieves board dependend MPP register value.
 985 *
 986 * INPUT:
 987 *       mppGroupNum - MPP group number.
 988 *
 989 * OUTPUT:
 990 *       None.
 991 *
 992 * RETURN:
 993 *       32bit value describing MPP control register value.
 994 *
 995 *******************************************************************************/
 996 MV_32 mvBoardMppGet(MV_U32 mppGroupNum)
 997 {
 998         MV_U32 boardId;
 999
1000         boardId = mvBoardIdGet();
1001
1002         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1003         {
1004                 mvOsPrintf("mvBoardMppGet:Board unknown.\n");
1005                 return MV_ERROR;
1006
1007         }
1008
1009         return BOARD_INFO(boardId)->pBoardMppConfigValue[0].mppGroup[mppGroupNum];
1010 }
1011
1012
1013 /*******************************************************************************
1014 * mvBoardMppGroupId - If MPP group type is AUTO then identify it using twsi
1015 *
1016 * DESCRIPTION:
1017 *
1018 * INPUT:
1019 *
1020 * OUTPUT:
1021 *       None.
1022 *
1023 * RETURN:
1024 *
1025 *******************************************************************************/
1026 MV_VOID mvBoardMppGroupIdUpdate(MV_VOID)
1027 {
1028
1029         MV_BOARD_MPP_GROUP_CLASS devClass;
1030         MV_BOARD_MODULE_ID_CLASS devClassId;
1031         MV_BOARD_MPP_TYPE_CLASS mppGroupType;
1032         MV_U32 devId;
1033         MV_U32 maxMppGrp = 1;
1034
1035         devId = mvCtrlModelGet();
1036
1037         switch(devId){
1038                 case MV_6281_DEV_ID:
1039                         maxMppGrp = MV_6281_MPP_MAX_MODULE;
1040                         break;
1041                 case MV_6192_DEV_ID:
1042                         maxMppGrp = MV_6192_MPP_MAX_MODULE;
1043                         break;
1044         case MV_6190_DEV_ID:
1045             maxMppGrp = MV_6190_MPP_MAX_MODULE;
1046             break;
1047                 case MV_6180_DEV_ID:
1048                         maxMppGrp = MV_6180_MPP_MAX_MODULE;
1049                         break;
1050         }
1051
1052         for (devClass = 0; devClass < maxMppGrp; devClass++)
1053         {
1054                 /* If MPP group can be defined by the module connected to it */
1055                 if (mvBoardMppGroupTypeGet(devClass) == MV_BOARD_AUTO)
1056                 {
1057                         /* Get MPP module ID */
1058                         devClassId = mvBoarModuleTypeGet(devClass);
1059                         if (MV_ERROR != devClassId)
1060                         {
1061                                 switch(devClassId)
1062                                 {
1063                                 case MV_BOARD_MODULE_TDM_ID:
1064                                 case MV_BOARD_MODULE_TDM_5CHAN_ID:
1065                                         mppGroupType = MV_BOARD_TDM;
1066                                         break;
1067                                 case MV_BOARD_MODULE_AUDIO_ID:
1068                                         mppGroupType = MV_BOARD_AUDIO;
1069                                         break;
1070                                 case MV_BOARD_MODULE_RGMII_ID:
1071                                         mppGroupType = MV_BOARD_RGMII;
1072                                         break;
1073                                 case MV_BOARD_MODULE_GMII_ID:
1074                                         mppGroupType = MV_BOARD_GMII;
1075                                         break;
1076                                 case MV_BOARD_MODULE_TS_ID:
1077                                         mppGroupType = MV_BOARD_TS;
1078                                         break;
1079                                 case MV_BOARD_MODULE_MII_ID:
1080                                         mppGroupType = MV_BOARD_MII;
1081                                         break;
1082                                 default:
1083                                         mppGroupType = MV_BOARD_OTHER;
1084                                         break;
1085                                 }
1086                         }
1087                         else
1088                                 /* The module bay is empty */
1089                                 mppGroupType = MV_BOARD_OTHER;
1090
1091                         /* Update MPP group type */
1092                         mvBoardMppGroupTypeSet(devClass, mppGroupType);
1093                 }
1094
1095                 /* Update MPP output voltage for RGMII 1.8V. Set port to GMII for GMII module */
1096                 if ((mvBoardMppGroupTypeGet(devClass) == MV_BOARD_RGMII))
1097                         MV_REG_BIT_SET(MPP_OUTPUT_DRIVE_REG,MPP_1_8_RGMII1_OUTPUT_DRIVE | MPP_1_8_RGMII0_OUTPUT_DRIVE);
1098                 else
1099                 {
1100                         if ((mvBoardMppGroupTypeGet(devClass) == MV_BOARD_GMII))
1101                         {
1102                                 MV_REG_BIT_RESET(MPP_OUTPUT_DRIVE_REG, BIT7 | BIT15);
1103                                 MV_REG_BIT_RESET(ETH_PORT_SERIAL_CTRL_1_REG(0),BIT3);
1104                                 MV_REG_BIT_RESET(ETH_PORT_SERIAL_CTRL_1_REG(1),BIT3);
1105                         }
1106                         else if ((mvBoardMppGroupTypeGet(devClass) == MV_BOARD_MII))
1107                         {
1108                                 /* Assumption that the MDC & MDIO should be 3.3V */
1109                                 MV_REG_BIT_RESET(MPP_OUTPUT_DRIVE_REG, BIT7 | BIT15);
1110                                 /* Assumption that only ETH1 can be MII when using modules on DB */
1111                                 MV_REG_BIT_RESET(ETH_PORT_SERIAL_CTRL_1_REG(1),BIT3);
1112                         }
1113                 }
1114         }
1115 }
1116
1117 /*******************************************************************************
1118 * mvBoardMppGroupTypeGet
1119 *
1120 * DESCRIPTION:
1121 *
1122 * INPUT:
1123 *       mppGroupClass - MPP group number 0  for MPP[35:20] or 1 for MPP[49:36].
1124 *
1125 * OUTPUT:
1126 *       None.
1127 *
1128 * RETURN:
1129 *
1130 *******************************************************************************/
1131 MV_BOARD_MPP_TYPE_CLASS mvBoardMppGroupTypeGet(MV_BOARD_MPP_GROUP_CLASS mppGroupClass)
1132 {
1133         MV_U32 boardId;
1134
1135         boardId = mvBoardIdGet();
1136
1137         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1138         {
1139                 mvOsPrintf("mvBoardMppGet:Board unknown.\n");
1140                 return MV_ERROR;
1141
1142         }
1143
1144         if (mppGroupClass == MV_BOARD_MPP_GROUP_1)
1145                 return BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup1;
1146         else
1147                 return BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup2;
1148 }
1149
1150 /*******************************************************************************
1151 * mvBoardMppGroupTypeSet
1152 *
1153 * DESCRIPTION:
1154 *
1155 * INPUT:
1156 *       mppGroupClass - MPP group number 0  for MPP[35:20] or 1 for MPP[49:36].
1157 *       mppGroupType - MPP group type for MPP[35:20] or for MPP[49:36].
1158 *
1159 * OUTPUT:
1160 *       None.
1161 *
1162 * RETURN:
1163 *
1164 *******************************************************************************/
1165 MV_VOID mvBoardMppGroupTypeSet(MV_BOARD_MPP_GROUP_CLASS mppGroupClass,
1166                                                 MV_BOARD_MPP_TYPE_CLASS mppGroupType)
1167 {
1168         MV_U32 boardId;
1169
1170         boardId = mvBoardIdGet();
1171
1172         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1173         {
1174                 mvOsPrintf("mvBoardMppGet:Board unknown.\n");
1175         }
1176
1177         if (mppGroupClass == MV_BOARD_MPP_GROUP_1)
1178                 BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup1 = mppGroupType;
1179         else
1180                 BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup2 = mppGroupType;
1181
1182 }
1183
1184 /*******************************************************************************
1185 * mvBoardMppMuxSet - Update MPP mux
1186 *
1187 * DESCRIPTION:
1188 *
1189 * INPUT:
1190 *
1191 * OUTPUT:
1192 *       None.
1193 *
1194 * RETURN:
1195 *
1196 *******************************************************************************/
1197 MV_VOID mvBoardMppMuxSet(MV_VOID)
1198 {
1199
1200         MV_BOARD_MPP_GROUP_CLASS devClass;
1201         MV_BOARD_MPP_TYPE_CLASS mppGroupType;
1202         MV_U32 devId;
1203         MV_U8 muxVal = 0xf;
1204         MV_U32 maxMppGrp = 1;
1205     MV_TWSI_SLAVE twsiSlave;
1206         MV_TWSI_ADDR slave;
1207
1208         devId = mvCtrlModelGet();
1209
1210         switch(devId){
1211                 case MV_6281_DEV_ID:
1212                         maxMppGrp = MV_6281_MPP_MAX_MODULE;
1213                         break;
1214                 case MV_6192_DEV_ID:
1215                         maxMppGrp = MV_6192_MPP_MAX_MODULE;
1216                         break;
1217         case MV_6190_DEV_ID:
1218             maxMppGrp = MV_6190_MPP_MAX_MODULE;
1219             break;
1220                 case MV_6180_DEV_ID:
1221                         maxMppGrp = MV_6180_MPP_MAX_MODULE;
1222                         break;
1223         }
1224
1225         for (devClass = 0; devClass < maxMppGrp; devClass++)
1226         {
1227                 mppGroupType = mvBoardMppGroupTypeGet(devClass);
1228
1229                 switch(mppGroupType)
1230                 {
1231                         case MV_BOARD_TDM:
1232                                 muxVal &= ~(devClass ? (0x2 << (devClass * 2)):0x0);
1233                                 break;
1234                         case MV_BOARD_AUDIO:
1235                                  muxVal &= ~(devClass ? 0x7 : 0x0); /*old Z0 value 0xd:0x0*/
1236                                 break;
1237                         case MV_BOARD_TS:
1238                                  muxVal &= ~(devClass ? (0x2 << (devClass * 2)):0x0);
1239                                 break;
1240                         default:
1241                                 muxVal |= (devClass ? 0xf : 0);
1242                                 break;
1243                 }
1244         }
1245
1246         /* TWSI init */
1247         slave.type = ADDR7_BIT;
1248         slave.address = 0;
1249         mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
1250
1251         /* Read MPP module ID */
1252         DB(mvOsPrintf("Board: twsi exp set\n"));
1253         twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(MV_BOARD_MUX_I2C_ADDR_ENTRY);
1254         twsiSlave.slaveAddr.type = mvBoardTwsiExpAddrTypeGet(MV_BOARD_MUX_I2C_ADDR_ENTRY);
1255         twsiSlave.validOffset = MV_TRUE;
1256         /* Offset is the first command after the address which indicate the register number to be read
1257            in next operation */
1258         twsiSlave.offset = 2;
1259         twsiSlave.moreThen256 = MV_FALSE;
1260
1261
1262
1263         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1264         {
1265                 DB(mvOsPrintf("Board: twsi exp out val fail\n"));
1266                 return;
1267         }
1268         DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1269
1270         /* Change twsi exp to output */
1271         twsiSlave.offset = 6;
1272         muxVal = 0;
1273         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1274         {
1275                 DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
1276                 return;
1277         }
1278         DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
1279
1280 }
1281
1282 /*******************************************************************************
1283 * mvBoardTdmMppSet - set MPPs in TDM module
1284 *
1285 * DESCRIPTION:
1286 *
1287 * INPUT: type of second telephony device
1288 *
1289 * OUTPUT:
1290 *       None.
1291 *
1292 * RETURN:
1293 *
1294 *******************************************************************************/
1295 MV_VOID mvBoardTdmMppSet(MV_32 chType)
1296 {
1297
1298         MV_BOARD_MPP_GROUP_CLASS devClass;
1299         MV_BOARD_MPP_TYPE_CLASS mppGroupType;
1300         MV_U32 devId;
1301         MV_U8 muxVal = 1;
1302         MV_U8 muxValMask = 1;
1303         MV_U8 twsiVal;
1304         MV_U32 maxMppGrp = 1;
1305         MV_TWSI_SLAVE twsiSlave;
1306         MV_TWSI_ADDR slave;
1307
1308         devId = mvCtrlModelGet();
1309
1310         switch(devId){
1311                 case MV_6281_DEV_ID:
1312                         maxMppGrp = MV_6281_MPP_MAX_MODULE;
1313                         break;
1314                 case MV_6192_DEV_ID:
1315                         maxMppGrp = MV_6192_MPP_MAX_MODULE;
1316                         break;
1317         case MV_6190_DEV_ID:
1318             maxMppGrp = MV_6190_MPP_MAX_MODULE;
1319             break;
1320                 case MV_6180_DEV_ID:
1321                         maxMppGrp = MV_6180_MPP_MAX_MODULE;
1322                         break;
1323         }
1324
1325         for (devClass = 0; devClass < maxMppGrp; devClass++)
1326         {
1327                 mppGroupType = mvBoardMppGroupTypeGet(devClass);
1328                 if(mppGroupType == MV_BOARD_TDM)
1329                         break;
1330         }
1331
1332         if(devClass == maxMppGrp)
1333                 return;         /* TDM module not found */
1334
1335         /* TWSI init */
1336         slave.type = ADDR7_BIT;
1337         slave.address = 0;
1338         mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
1339
1340         /* Read MPP module ID */
1341         DB(mvOsPrintf("Board: twsi exp set\n"));
1342         twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(devClass);
1343         twsiSlave.slaveAddr.type = ADDR7_BIT;
1344         twsiSlave.validOffset = MV_TRUE;
1345         /* Offset is the first command after the address which indicate the register number to be read
1346            in next operation */
1347         twsiSlave.offset = 3;
1348         twsiSlave.moreThen256 = MV_FALSE;
1349
1350         if(mvBoardIdGet() == RD_88F6281A_ID)
1351         {
1352                 muxVal = 0xc;
1353                 muxValMask = 0xf3;
1354         }
1355
1356         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1357         muxVal = (twsiVal & muxValMask) | muxVal;
1358
1359         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1360         {
1361                 mvOsPrintf("Board: twsi exp out val fail\n");
1362                 return;
1363         }
1364         DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1365
1366         /* Change twsi exp to output */
1367         twsiSlave.offset = 7;
1368         muxVal = 0xfe;
1369         if(mvBoardIdGet() == RD_88F6281A_ID)
1370                 muxVal = 0xf3;
1371
1372         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1373         muxVal = (twsiVal & muxVal);
1374
1375         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1376         {
1377                 mvOsPrintf("Board: twsi exp change to out fail\n");
1378                 return;
1379         }
1380         DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
1381         /* reset the line to 0 */
1382         twsiSlave.offset = 3;
1383         muxVal = 0;
1384         muxValMask = 1;
1385
1386         if(mvBoardIdGet() == RD_88F6281A_ID) {
1387                 muxVal = 0x0;
1388                 muxValMask = 0xf3;
1389         }
1390
1391         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1392         muxVal = (twsiVal & muxValMask) | muxVal;
1393
1394         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1395         {
1396                 mvOsPrintf("Board: twsi exp out val fail\n");
1397                 return;
1398         }
1399         DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1400
1401         mvOsDelay(20);
1402
1403         /* set the line to 1 */
1404         twsiSlave.offset = 3;
1405         muxVal = 1;
1406         muxValMask = 1;
1407
1408         if(mvBoardIdGet() == RD_88F6281A_ID)
1409         {
1410                 muxVal = 0xc;
1411                 muxValMask = 0xf3;
1412                 if(chType) /* FXS - issue reset properly */
1413                 {
1414                         MV_REG_BIT_SET(GPP_DATA_OUT_REG(1), MV_GPP12);
1415                         mvOsDelay(50);
1416                         MV_REG_BIT_RESET(GPP_DATA_OUT_REG(1), MV_GPP12);
1417                 }
1418                 else /* FXO - issue reset via TDM_CODEC_RST*/
1419                 {
1420                    /* change MPP44 type to TDM_CODEC_RST(0x2) */
1421                    MV_REG_WRITE(MPP_CONTROL_REG5, ((MV_REG_READ(MPP_CONTROL_REG5) & 0xFFF0FFFF)  | BIT17));
1422                 }
1423         }
1424
1425         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1426         muxVal = (twsiVal & muxValMask) | muxVal;
1427
1428         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1429         {
1430                 mvOsPrintf("Board: twsi exp out val fail\n");
1431                 return;
1432         }
1433
1434         /* TBD - 5 channels */
1435 #if defined(MV_TDM_5CHANNELS)
1436         /* change MPP38 type to GPIO(0x0) & polarity for TDM_STROBE */
1437         MV_REG_WRITE(MPP_CONTROL_REG4, (MV_REG_READ(MPP_CONTROL_REG4) & 0xF0FFFFFF));
1438         mvGppPolaritySet(1, MV_GPP6, 0);
1439
1440         twsiSlave.offset = 6;
1441         twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(2);
1442
1443         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1444         muxVal = (twsiVal & ~BIT2);
1445
1446         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1447         {
1448                 mvOsPrintf("Board: twsi exp change to out fail\n");
1449                 return;
1450         }
1451
1452
1453         twsiSlave.offset = 2;
1454
1455         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1456         muxVal = (twsiVal & ~BIT2);
1457
1458         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1459         {
1460                 mvOsPrintf("Board: twsi exp change to out fail\n");
1461                 return;
1462         }
1463 #endif
1464         DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1465
1466
1467 }
1468 /*******************************************************************************
1469 * mvBoardVoiceConnModeGet - return SLIC/DAA connection & interrupt modes
1470 *
1471 * DESCRIPTION:
1472 *
1473 * INPUT:
1474 *
1475 * OUTPUT:
1476 *       None.
1477 *
1478 * RETURN:
1479 *
1480 *******************************************************************************/
1481
1482 MV_VOID mvBoardVoiceConnModeGet(MV_32* connMode, MV_32* irqMode)
1483 {
1484         switch(mvBoardIdGet())
1485         {
1486                 case RD_88F6281A_ID:
1487                         *connMode = DAISY_CHAIN_MODE;
1488                         *irqMode = INTERRUPT_TO_TDM;
1489                         break;
1490                 case DB_88F6281A_BP_ID:
1491                          *connMode = DUAL_CHIP_SELECT_MODE;
1492                          *irqMode = INTERRUPT_TO_TDM;
1493                         break;
1494                 case RD_88F6192A_ID:
1495                         *connMode = DUAL_CHIP_SELECT_MODE;
1496                         *irqMode = INTERRUPT_TO_TDM;
1497                         break;
1498                 case DB_88F6192A_BP_ID:
1499                          *connMode = DUAL_CHIP_SELECT_MODE;
1500                          *irqMode = INTERRUPT_TO_TDM;
1501                         break;
1502                 default:
1503                         *connMode = *irqMode = -1;
1504                         mvOsPrintf("mvBoardVoiceAssembleModeGet: TDM not supported(boardId=0x%x)\n",mvBoardIdGet());
1505         }
1506                 return;
1507
1508 }
1509
1510 /*******************************************************************************
1511 * mvBoardMppModuleTypePrint - print module detect
1512 *
1513 * DESCRIPTION:
1514 *
1515 * INPUT:
1516 *
1517 * OUTPUT:
1518 *       None.
1519 *
1520 * RETURN:
1521 *
1522 *******************************************************************************/
1523 MV_VOID mvBoardMppModuleTypePrint(MV_VOID)
1524 {
1525
1526         MV_BOARD_MPP_GROUP_CLASS devClass;
1527         MV_BOARD_MPP_TYPE_CLASS mppGroupType;
1528         MV_U32 devId;
1529         MV_U32 maxMppGrp = 1;
1530
1531         devId = mvCtrlModelGet();
1532
1533         switch(devId){
1534                 case MV_6281_DEV_ID:
1535                         maxMppGrp = MV_6281_MPP_MAX_MODULE;
1536                         break;
1537                 case MV_6192_DEV_ID:
1538                         maxMppGrp = MV_6192_MPP_MAX_MODULE;
1539                         break;
1540         case MV_6190_DEV_ID:
1541             maxMppGrp = MV_6190_MPP_MAX_MODULE;
1542             break;
1543                 case MV_6180_DEV_ID:
1544                         maxMppGrp = MV_6180_MPP_MAX_MODULE;
1545                         break;
1546         }
1547
1548         for (devClass = 0; devClass < maxMppGrp; devClass++)
1549         {
1550                 mppGroupType = mvBoardMppGroupTypeGet(devClass);
1551
1552                 switch(mppGroupType)
1553                 {
1554                         case MV_BOARD_TDM:
1555                 if(devId != MV_6190_DEV_ID)
1556                     mvOsPrintf("Module %d is TDM\n", devClass);
1557                                 break;
1558                         case MV_BOARD_AUDIO:
1559                 if(devId != MV_6190_DEV_ID)
1560                     mvOsPrintf("Module %d is AUDIO\n", devClass);
1561                                 break;
1562             case MV_BOARD_RGMII:
1563                 if(devId != MV_6190_DEV_ID)
1564                     mvOsPrintf("Module %d is RGMII\n", devClass);
1565                                 break;
1566                         case MV_BOARD_GMII:
1567                 if(devId != MV_6190_DEV_ID)
1568                     mvOsPrintf("Module %d is GMII\n", devClass);
1569                                 break;
1570                         case MV_BOARD_TS:
1571                 if(devId != MV_6190_DEV_ID)
1572                     mvOsPrintf("Module %d is TS\n", devClass);
1573                                 break;
1574                         default:
1575                                 break;
1576                 }
1577         }
1578 }
1579
1580 /* Board devices API managments */
1581
1582 /*******************************************************************************
1583 * mvBoardGetDeviceNumber - Get number of device of some type on the board
1584 *
1585 * DESCRIPTION:
1586 *
1587 * INPUT:
1588 *               devType - The device type ( Flash,RTC , etc .. )
1589 *
1590 * OUTPUT:
1591 *       None.
1592 *
1593 * RETURN:
1594 *       If the device is found on the board the then the functions returns the
1595 *               number of those devices else the function returns 0
1596 *
1597 *
1598 *******************************************************************************/
1599 MV_32 mvBoardGetDevicesNumber(MV_BOARD_DEV_CLASS devClass)
1600 {
1601         MV_U32  foundIndex=0,devNum;
1602         MV_U32 boardId= mvBoardIdGet();
1603
1604         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1605         {
1606                 mvOsPrintf("mvBoardGetDeviceNumber:Board unknown.\n");
1607                 return 0xFFFFFFFF;
1608
1609         }
1610
1611         for (devNum = START_DEV_CS; devNum < BOARD_INFO(boardId)->numBoardDeviceIf; devNum++)
1612         {
1613                 if (BOARD_INFO(boardId)->pDevCsInfo[devNum].devClass == devClass)
1614                 {
1615                         foundIndex++;
1616                 }
1617         }
1618
1619     return foundIndex;
1620
1621 }
1622
1623 /*******************************************************************************
1624 * mvBoardGetDeviceBaseAddr - Get base address of a device existing on the board
1625 *
1626 * DESCRIPTION:
1627 *
1628 * INPUT:
1629 *       devIndex - The device sequential number on the board
1630 *               devType - The device type ( Flash,RTC , etc .. )
1631 *
1632 * OUTPUT:
1633 *       None.
1634 *
1635 * RETURN:
1636 *       If the device is found on the board the then the functions returns the
1637 *               Base address else the function returns 0xffffffff
1638 *
1639 *
1640 *******************************************************************************/
1641 MV_32 mvBoardGetDeviceBaseAddr(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1642 {
1643         MV_DEV_CS_INFO* devEntry;
1644         devEntry = boardGetDevEntry(devNum,devClass);
1645         if (devEntry != NULL)
1646         {
1647                 return mvCpuIfTargetWinBaseLowGet(DEV_TO_TARGET(devEntry->deviceCS));
1648
1649         }
1650
1651         return 0xFFFFFFFF;
1652 }
1653
1654 /*******************************************************************************
1655 * mvBoardGetDeviceBusWidth - Get Bus width of a device existing on the board
1656 *
1657 * DESCRIPTION:
1658 *
1659 * INPUT:
1660 *       devIndex - The device sequential number on the board
1661 *               devType - The device type ( Flash,RTC , etc .. )
1662 *
1663 * OUTPUT:
1664 *       None.
1665 *
1666 * RETURN:
1667 *       If the device is found on the board the then the functions returns the
1668 *               Bus width else the function returns 0xffffffff
1669 *
1670 *
1671 *******************************************************************************/
1672 MV_32 mvBoardGetDeviceBusWidth(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1673 {
1674         MV_DEV_CS_INFO* devEntry;
1675
1676         devEntry = boardGetDevEntry(devNum,devClass);
1677         if (devEntry != NULL)
1678         {
1679                 return 8;
1680         }
1681
1682         return 0xFFFFFFFF;
1683
1684 }
1685
1686 /*******************************************************************************
1687 * mvBoardGetDeviceWidth - Get dev width of a device existing on the board
1688 *
1689 * DESCRIPTION:
1690 *
1691 * INPUT:
1692 *       devIndex - The device sequential number on the board
1693 *               devType - The device type ( Flash,RTC , etc .. )
1694 *
1695 * OUTPUT:
1696 *       None.
1697 *
1698 * RETURN:
1699 *       If the device is found on the board the then the functions returns the
1700 *               dev width else the function returns 0xffffffff
1701 *
1702 *
1703 *******************************************************************************/
1704 MV_32 mvBoardGetDeviceWidth(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1705 {
1706         MV_DEV_CS_INFO* devEntry;
1707         MV_U32 boardId= mvBoardIdGet();
1708
1709         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1710         {
1711                 mvOsPrintf("Board unknown.\n");
1712                 return 0xFFFFFFFF;
1713         }
1714
1715         devEntry = boardGetDevEntry(devNum,devClass);
1716         if (devEntry != NULL)
1717                 return devEntry->devWidth;
1718
1719         return MV_ERROR;
1720
1721 }
1722
1723 /*******************************************************************************
1724 * mvBoardGetDeviceWinSize - Get the window size of a device existing on the board
1725 *
1726 * DESCRIPTION:
1727 *
1728 * INPUT:
1729 *       devIndex - The device sequential number on the board
1730 *               devType - The device type ( Flash,RTC , etc .. )
1731 *
1732 * OUTPUT:
1733 *       None.
1734 *
1735 * RETURN:
1736 *       If the device is found on the board the then the functions returns the
1737 *               window size else the function returns 0xffffffff
1738 *
1739 *
1740 *******************************************************************************/
1741 MV_32 mvBoardGetDeviceWinSize(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1742 {
1743         MV_DEV_CS_INFO* devEntry;
1744         MV_U32 boardId = mvBoardIdGet();
1745
1746         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1747         {
1748                 mvOsPrintf("Board unknown.\n");
1749                 return 0xFFFFFFFF;
1750         }
1751
1752         devEntry = boardGetDevEntry(devNum,devClass);
1753         if (devEntry != NULL)
1754         {
1755                 return mvCpuIfTargetWinSizeGet(DEV_TO_TARGET(devEntry->deviceCS));
1756         }
1757
1758         return 0xFFFFFFFF;
1759 }
1760
1761
1762 /*******************************************************************************
1763 * boardGetDevEntry - returns the entry pointer of a device on the board
1764 *
1765 * DESCRIPTION:
1766 *
1767 * INPUT:
1768 *       devIndex - The device sequential number on the board
1769 *               devType - The device type ( Flash,RTC , etc .. )
1770 *
1771 * OUTPUT:
1772 *       None.
1773 *
1774 * RETURN:
1775 *       If the device is found on the board the then the functions returns the
1776 *               dev number else the function returns 0x0
1777 *
1778 *
1779 *******************************************************************************/
1780 static MV_DEV_CS_INFO*  boardGetDevEntry(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1781 {
1782         MV_U32  foundIndex=0,devIndex;
1783         MV_U32 boardId= mvBoardIdGet();
1784
1785         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1786         {
1787                 mvOsPrintf("boardGetDevEntry: Board unknown.\n");
1788                 return NULL;
1789
1790         }
1791
1792         for (devIndex = START_DEV_CS; devIndex < BOARD_INFO(boardId)->numBoardDeviceIf; devIndex++)
1793         {
1794                 /* TBR */
1795                 /*if (BOARD_INFO(boardId)->pDevCsInfo[devIndex].deviceCS == MV_BOOTDEVICE_INDEX)
1796                      continue;*/
1797
1798                 if (BOARD_INFO(boardId)->pDevCsInfo[devIndex].devClass == devClass)
1799                 {
1800                         if (foundIndex == devNum)
1801                         {
1802                                 return &(BOARD_INFO(boardId)->pDevCsInfo[devIndex]);
1803                         }
1804                         foundIndex++;
1805                 }
1806         }
1807
1808         /* device not found */
1809         return NULL;
1810 }
1811
1812 /* Get device CS number */
1813
1814 MV_U32 boardGetDevCSNum(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1815 {
1816         MV_DEV_CS_INFO* devEntry;
1817         MV_U32 boardId= mvBoardIdGet();
1818
1819         if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1820         {
1821                 mvOsPrintf("Board unknown.\n");
1822                 return 0xFFFFFFFF;
1823
1824         }
1825
1826
1827         devEntry = boardGetDevEntry(devNum,devClass);
1828         if (devEntry != NULL)
1829                 return devEntry->deviceCS;
1830
1831         return 0xFFFFFFFF;
1832
1833 }
1834
1835 /*******************************************************************************
1836 * mvBoardRtcTwsiAddrTypeGet -
1837 *
1838 * DESCRIPTION:
1839 *
1840 * INPUT:
1841 *
1842 * OUTPUT:
1843 *       None.
1844 *
1845 * RETURN:
1846 *
1847 *
1848 *******************************************************************************/
1849 MV_U8 mvBoardRtcTwsiAddrTypeGet()
1850 {
1851         int i;
1852         MV_U32 boardId= mvBoardIdGet();
1853
1854         for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
1855                 if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_TWSI_RTC)
1856                         return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
1857         return (MV_ERROR);
1858 }
1859
1860 /*******************************************************************************
1861 * mvBoardRtcTwsiAddrGet -
1862 *
1863 * DESCRIPTION:
1864 *
1865 * INPUT:
1866 *
1867 * OUTPUT:
1868 *       None.
1869 *
1870 * RETURN:
1871 *
1872 *
1873 *******************************************************************************/
1874 MV_U8 mvBoardRtcTwsiAddrGet()
1875 {
1876         int i;
1877         MV_U32 boardId= mvBoardIdGet();
1878
1879         for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
1880                 if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_TWSI_RTC)
1881                         return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
1882         return (0xFF);
1883 }
1884
1885 /*******************************************************************************
1886 * mvBoardA2DTwsiAddrTypeGet -
1887 *
1888 * DESCRIPTION:
1889 *
1890 * INPUT:
1891 *
1892 * OUTPUT:
1893 *       None.
1894 *
1895 * RETURN:
1896 *
1897 *
1898 *******************************************************************************/
1899 MV_U8 mvBoardA2DTwsiAddrTypeGet()
1900 {
1901         int i;
1902         MV_U32 boardId= mvBoardIdGet();
1903
1904         for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
1905                 if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_TWSI_AUDIO_DEC)
1906                         return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
1907         return (MV_ERROR);
1908 }
1909
1910 /*******************************************************************************
1911 * mvBoardA2DTwsiAddrGet -
1912 *
1913 * DESCRIPTION:
1914 *
1915 * INPUT:
1916 *
1917 * OUTPUT:
1918 *       None.
1919 *
1920 * RETURN:
1921 *
1922 *
1923 *******************************************************************************/
1924 MV_U8 mvBoardA2DTwsiAddrGet()
1925 {
1926         int i;
1927         MV_U32 boardId= mvBoardIdGet();
1928
1929         for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
1930                 if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_TWSI_AUDIO_DEC)
1931                         return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
1932         return (0xFF);
1933 }
1934
1935 /*******************************************************************************
1936 * mvBoardTwsiExpAddrTypeGet -
1937 *
1938 * DESCRIPTION:
1939 *
1940 * INPUT:
1941 *
1942 * OUTPUT:
1943 *       None.
1944 *
1945 * RETURN:
1946 *
1947 *
1948 *******************************************************************************/
1949 MV_U8 mvBoardTwsiExpAddrTypeGet(MV_U32 index)
1950 {
1951         int i;
1952         MV_U32 indexFound = 0;
1953         MV_U32 boardId= mvBoardIdGet();
1954
1955         for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
1956                 if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_EXP)
1957                 {
1958                         if (indexFound == index)
1959                                 return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
1960                         else
1961                                 indexFound++;
1962                 }
1963
1964         return (MV_ERROR);
1965 }
1966
1967 /*******************************************************************************
1968 * mvBoardTwsiExpAddrGet -
1969 *
1970 * DESCRIPTION:
1971 *
1972 * INPUT:
1973 *
1974 * OUTPUT:
1975 *       None.
1976 *
1977 * RETURN:
1978 *
1979 *
1980 *******************************************************************************/
1981 MV_U8 mvBoardTwsiExpAddrGet(MV_U32 index)
1982 {
1983         int i;
1984         MV_U32 indexFound = 0;
1985         MV_U32 boardId= mvBoardIdGet();
1986
1987         for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
1988                 if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_EXP)
1989                 {
1990                         if (indexFound == index)
1991                                 return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
1992                         else
1993                                 indexFound++;
1994                 }
1995
1996         return (0xFF);
1997 }
1998
1999
2000 /*******************************************************************************
2001 * mvBoardTwsiSatRAddrTypeGet -
2002 *
2003 * DESCRIPTION:
2004 *
2005 * INPUT:
2006 *
2007 * OUTPUT:
2008 *       None.
2009 *
2010 * RETURN:
2011 *
2012 *
2013 *******************************************************************************/
2014 MV_U8 mvBoardTwsiSatRAddrTypeGet(MV_U32 index)
2015 {
2016         int i;
2017         MV_U32 indexFound = 0;
2018         MV_U32 boardId= mvBoardIdGet();
2019
2020         for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
2021                 if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_SATR)
2022                 {
2023                         if (indexFound == index)
2024                                 return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
2025                         else
2026                                 indexFound++;
2027                 }
2028
2029         return (MV_ERROR);
2030 }
2031
2032 /*******************************************************************************
2033 * mvBoardTwsiSatRAddrGet -
2034 *
2035 * DESCRIPTION:
2036 *
2037 * INPUT:
2038 *
2039 * OUTPUT:
2040 *       None.
2041 *
2042 * RETURN:
2043 *
2044 *
2045 *******************************************************************************/
2046 MV_U8 mvBoardTwsiSatRAddrGet(MV_U32 index)
2047 {
2048         int i;
2049         MV_U32 indexFound = 0;
2050         MV_U32 boardId= mvBoardIdGet();
2051
2052         for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
2053                 if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_SATR)
2054                 {
2055                         if (indexFound == index)
2056                                 return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
2057                         else
2058                                 indexFound++;
2059                 }
2060
2061         return (0xFF);
2062 }
2063
2064 /*******************************************************************************
2065 * mvBoardNandWidthGet -
2066 *
2067 * DESCRIPTION: Get the width of the first NAND device in byte.
2068 *
2069 * INPUT:
2070 *
2071 * OUTPUT:
2072 *       None.
2073 *
2074 * RETURN: 1, 2, 4 or MV_ERROR
2075 *
2076 *
2077 *******************************************************************************/
2078 /*  */
2079 MV_32 mvBoardNandWidthGet(void)
2080 {
2081         MV_U32 devNum;
2082         MV_U32 devWidth;
2083         MV_U32 boardId= mvBoardIdGet();
2084
2085         for (devNum = START_DEV_CS; devNum < BOARD_INFO(boardId)->numBoardDeviceIf; devNum++)
2086         {
2087                 devWidth = mvBoardGetDeviceWidth(devNum, BOARD_DEV_NAND_FLASH);
2088                 if (devWidth != MV_ERROR)
2089                         return (devWidth / 8);
2090         }
2091
2092         /* NAND wasn't found */
2093         return MV_ERROR;
2094 }
2095
2096 MV_U32 gBoardId = -1;
2097
2098 /*******************************************************************************
2099 * mvBoardIdGet - Get Board model
2100 *
2101 * DESCRIPTION:
2102 *       This function returns board ID.
2103 *       Board ID is 32bit word constructed of board model (16bit) and
2104 *       board revision (16bit) in the following way: 0xMMMMRRRR.
2105 *
2106 * INPUT:
2107 *       None.
2108 *
2109 * OUTPUT:
2110 *       None.
2111 *
2112 * RETURN:
2113 *       32bit board ID number, '-1' if board is undefined.
2114 *
2115 *******************************************************************************/
2116 MV_U32 mvBoardIdGet(MV_VOID)
2117 {
2118         MV_U32 tmpBoardId = -1;
2119
2120         if(gBoardId == -1)
2121         {
2122                 #if defined(DB_88F6281A)
2123                 tmpBoardId = DB_88F6281A_BP_ID;
2124                 #elif defined(RD_88F6281A)
2125                 tmpBoardId = RD_88F6281A_ID;
2126                 #elif defined(DB_88F6192A)
2127                 tmpBoardId = DB_88F6192A_BP_ID;
2128                 #elif defined(DB_88F6190A)
2129                 tmpBoardId = DB_88F6190A_BP_ID;
2130                 #elif defined(RD_88F6192A)
2131                 tmpBoardId = RD_88F6192A_ID;
2132                 #elif defined(RD_88F6190A)
2133                 tmpBoardId = RD_88F6190A_ID;
2134                 #elif defined(DB_88F6180A)
2135                 tmpBoardId = DB_88F6180A_BP_ID;
2136                 #elif defined(RD_88F6281A_PCAC)
2137                 tmpBoardId = RD_88F6281A_PCAC_ID;
2138                 #elif defined(RD_88F6281A_SHEEVA_PLUG)
2139                 tmpBoardId = SHEEVA_PLUG_ID;
2140                 #elif defined(DB_CUSTOMER)
2141                 tmpBoardId = DB_CUSTOMER_ID;
2142                 #endif
2143                 gBoardId = tmpBoardId;
2144         }
2145
2146         return gBoardId;
2147 }
2148
2149
2150 /*******************************************************************************
2151 * mvBoarModuleTypeGet - mvBoarModuleTypeGet
2152 *
2153 * DESCRIPTION:
2154 *
2155 * INPUT:
2156 *               group num - MV_BOARD_MPP_GROUP_CLASS enum
2157 *
2158 * OUTPUT:
2159 *               None.
2160 *
2161 * RETURN:
2162 *               module num - MV_BOARD_MODULE_CLASS enum
2163 *
2164 *******************************************************************************/
2165 MV_BOARD_MODULE_ID_CLASS mvBoarModuleTypeGet(MV_BOARD_MPP_GROUP_CLASS devClass)
2166 {
2167         MV_TWSI_SLAVE twsiSlave;
2168         MV_TWSI_ADDR slave;
2169         MV_U8 data;
2170
2171         /* TWSI init */
2172         slave.type = ADDR7_BIT;
2173         slave.address = 0;
2174         mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2175
2176         /* Read MPP module ID */
2177         DB(mvOsPrintf("Board: Read MPP module ID\n"));
2178         twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(devClass);
2179         twsiSlave.slaveAddr.type = mvBoardTwsiExpAddrTypeGet(devClass);
2180         twsiSlave.validOffset = MV_TRUE;
2181         /* Offset is the first command after the address which indicate the register number to be read
2182            in next operation */
2183         twsiSlave.offset = 0;
2184         twsiSlave.moreThen256 = MV_FALSE;
2185
2186
2187
2188         if( MV_OK != mvTwsiRead (0, &twsiSlave, &data, 1) )
2189         {
2190                 DB(mvOsPrintf("Board: Read MPP module ID fail\n"));
2191                 return MV_ERROR;
2192         }
2193         DB(mvOsPrintf("Board: Read MPP module ID succeded\n"));
2194
2195         return data;
2196 }
2197
2198 /*******************************************************************************
2199 * mvBoarTwsiSatRGet -
2200 *
2201 * DESCRIPTION:
2202 *
2203 * INPUT:
2204 *               device num - one of three devices
2205 *               reg num - 0 or 1
2206 *
2207 * OUTPUT:
2208 *               None.
2209 *
2210 * RETURN:
2211 *               reg value
2212 *
2213 *******************************************************************************/
2214 MV_U8 mvBoarTwsiSatRGet(MV_U8 devNum, MV_U8 regNum)
2215 {
2216         MV_TWSI_SLAVE twsiSlave;
2217         MV_TWSI_ADDR slave;
2218         MV_U8 data;
2219
2220         /* TWSI init */
2221         slave.type = ADDR7_BIT;
2222         slave.address = 0;
2223         mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2224
2225         /* Read MPP module ID */
2226         DB(mvOsPrintf("Board: Read S@R device read\n"));
2227         twsiSlave.slaveAddr.address = mvBoardTwsiSatRAddrGet(devNum);
2228         twsiSlave.slaveAddr.type = mvBoardTwsiSatRAddrTypeGet(devNum);
2229         twsiSlave.validOffset = MV_TRUE;
2230         /* Use offset as command */
2231         twsiSlave.offset = regNum;
2232         twsiSlave.moreThen256 = MV_FALSE;
2233
2234         if( MV_OK != mvTwsiRead (0, &twsiSlave, &data, 1) )
2235         {
2236                 DB(mvOsPrintf("Board: Read S@R fail\n"));
2237                 return MV_ERROR;
2238         }
2239         DB(mvOsPrintf("Board: Read S@R succeded\n"));
2240
2241         return data;
2242 }
2243
2244 /*******************************************************************************
2245 * mvBoarTwsiSatRSet -
2246 *
2247 * DESCRIPTION:
2248 *
2249 * INPUT:
2250 *               devNum - one of three devices
2251 *               regNum - 0 or 1
2252 *               regVal - value
2253 *
2254 *
2255 * OUTPUT:
2256 *               None.
2257 *
2258 * RETURN:
2259 *               reg value
2260 *
2261 *******************************************************************************/
2262 MV_STATUS mvBoarTwsiSatRSet(MV_U8 devNum, MV_U8 regNum, MV_U8 regVal)
2263 {
2264         MV_TWSI_SLAVE twsiSlave;
2265         MV_TWSI_ADDR slave;
2266
2267         /* TWSI init */
2268         slave.type = ADDR7_BIT;
2269         slave.address = 0;
2270         mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2271
2272         /* Read MPP module ID */
2273         twsiSlave.slaveAddr.address = mvBoardTwsiSatRAddrGet(devNum);
2274         twsiSlave.slaveAddr.type = mvBoardTwsiSatRAddrTypeGet(devNum);
2275         twsiSlave.validOffset = MV_TRUE;
2276         DB(mvOsPrintf("Board: Write S@R device addr %x, type %x, data %x\n", twsiSlave.slaveAddr.address,\
2277                                                                 twsiSlave.slaveAddr.type, regVal));
2278         /* Use offset as command */
2279         twsiSlave.offset = regNum;
2280         twsiSlave.moreThen256 = MV_FALSE;
2281         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &regVal, 1) )
2282         {
2283                 DB(mvOsPrintf("Board: Write S@R fail\n"));
2284                 return MV_ERROR;
2285         }
2286         DB(mvOsPrintf("Board: Write S@R succeded\n"));
2287
2288         return MV_OK;
2289 }
2290
2291 /*******************************************************************************
2292 * mvBoardSlicGpioPinGet -
2293 *
2294 * DESCRIPTION:
2295 *
2296 * INPUT:
2297 *
2298 * OUTPUT:
2299 *       None.
2300 *
2301 * RETURN:
2302 *
2303 *
2304 *******************************************************************************/
2305 MV_32 mvBoardSlicGpioPinGet(MV_U32 slicNum)
2306 {
2307         MV_U32 boardId;
2308         boardId = mvBoardIdGet();
2309
2310         switch (boardId)
2311         {
2312         case DB_88F6281A_BP_ID:
2313         case RD_88F6281A_ID:
2314         default:
2315                 return MV_ERROR;
2316                 break;
2317
2318         }
2319 }
2320
2321 /*******************************************************************************
2322 * mvBoardFanPowerControl - Turn on/off the fan power control on the RD-6281A
2323 *
2324 * DESCRIPTION:
2325 *
2326 * INPUT:
2327 *        mode - MV_TRUE = on ; MV_FALSE = off
2328 *
2329 * OUTPUT:
2330 *       MV_STATUS - MV_OK , MV_ERROR.
2331 *
2332 * RETURN:
2333 *
2334 *******************************************************************************/
2335 MV_STATUS mvBoardFanPowerControl(MV_BOOL mode)
2336 {
2337
2338         MV_U8 val = 1, twsiVal;
2339         MV_TWSI_SLAVE twsiSlave;
2340         MV_TWSI_ADDR slave;
2341
2342         if(mvBoardIdGet() != RD_88F6281A_ID)
2343         return MV_ERROR;
2344
2345         /* TWSI init */
2346         slave.type = ADDR7_BIT;
2347         slave.address = 0;
2348         mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2349
2350         /* Read MPP module ID */
2351         DB(mvOsPrintf("Board: twsi exp set\n"));
2352         twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(1);
2353         twsiSlave.slaveAddr.type = ADDR7_BIT;
2354         twsiSlave.validOffset = MV_TRUE;
2355         /* Offset is the first command after the address which indicate the register number to be read
2356            in next operation */
2357         twsiSlave.offset = 3;
2358         twsiSlave.moreThen256 = MV_FALSE;
2359         if(mode == MV_TRUE)
2360             val = 0x1;
2361         else
2362             val = 0;
2363         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
2364         val = (twsiVal & 0xfe) | val;
2365
2366         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
2367         {
2368                 DB(mvOsPrintf("Board: twsi exp out val fail\n"));
2369                 return MV_ERROR;
2370         }
2371         DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
2372
2373         /* Change twsi exp to output */
2374         twsiSlave.offset = 7;
2375         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
2376         val = (twsiVal & 0xfe);
2377         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
2378         {
2379                 DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
2380                 return MV_ERROR;
2381         }
2382         DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
2383         return MV_OK;
2384 }
2385
2386 /*******************************************************************************
2387 * mvBoardHDDPowerControl - Turn on/off the HDD power control on the RD-6281A
2388 *
2389 * DESCRIPTION:
2390 *
2391 * INPUT:
2392 *        mode - MV_TRUE = on ; MV_FALSE = off
2393 *
2394 * OUTPUT:
2395 *       MV_STATUS - MV_OK , MV_ERROR.
2396 *
2397 * RETURN:
2398 *
2399 *******************************************************************************/
2400 MV_STATUS mvBoardHDDPowerControl(MV_BOOL mode)
2401 {
2402
2403         MV_U8 val = 1, twsiVal;
2404         MV_TWSI_SLAVE twsiSlave;
2405         MV_TWSI_ADDR slave;
2406
2407         if(mvBoardIdGet() != RD_88F6281A_ID)
2408         return MV_ERROR;
2409
2410         /* TWSI init */
2411         slave.type = ADDR7_BIT;
2412         slave.address = 0;
2413         mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2414
2415         /* Read MPP module ID */
2416         DB(mvOsPrintf("Board: twsi exp set\n"));
2417         twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(1);
2418         twsiSlave.slaveAddr.type = ADDR7_BIT;
2419         twsiSlave.validOffset = MV_TRUE;
2420         /* Offset is the first command after the address which indicate the register number to be read
2421            in next operation */
2422         twsiSlave.offset = 3;
2423         twsiSlave.moreThen256 = MV_FALSE;
2424         if(mode == MV_TRUE)
2425             val = 0x2;
2426         else
2427             val = 0;
2428         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
2429         val = (twsiVal & 0xfd) | val;
2430         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
2431         {
2432                 DB(mvOsPrintf("Board: twsi exp out val fail\n"));
2433                 return MV_ERROR;
2434         }
2435         DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
2436
2437         /* Change twsi exp to output */
2438         twsiSlave.offset = 7;
2439         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
2440         val = (twsiVal & 0xfd);
2441         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
2442         {
2443                 DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
2444                 return MV_ERROR;
2445         }
2446         DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
2447         return MV_OK;
2448 }
2449
2450 /*******************************************************************************
2451 * mvBoardSDioWPControl - Turn on/off the SDIO WP on the RD-6281A
2452 *
2453 * DESCRIPTION:
2454 *
2455 * INPUT:
2456 *        mode - MV_TRUE = on ; MV_FALSE = off
2457 *
2458 * OUTPUT:
2459 *       MV_STATUS - MV_OK , MV_ERROR.
2460 *
2461 * RETURN:
2462 *
2463 *******************************************************************************/
2464 MV_STATUS mvBoardSDioWPControl(MV_BOOL mode)
2465 {
2466
2467         MV_U8 val = 1, twsiVal;
2468         MV_TWSI_SLAVE twsiSlave;
2469         MV_TWSI_ADDR slave;
2470
2471         if(mvBoardIdGet() != RD_88F6281A_ID)
2472         return MV_ERROR;
2473
2474         /* TWSI init */
2475         slave.type = ADDR7_BIT;
2476         slave.address = 0;
2477         mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2478
2479         /* Read MPP module ID */
2480         DB(mvOsPrintf("Board: twsi exp set\n"));
2481         twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(0);
2482         twsiSlave.slaveAddr.type = ADDR7_BIT;
2483         twsiSlave.validOffset = MV_TRUE;
2484         /* Offset is the first command after the address which indicate the register number to be read
2485            in next operation */
2486         twsiSlave.offset = 3;
2487         twsiSlave.moreThen256 = MV_FALSE;
2488         if(mode == MV_TRUE)
2489             val = 0x10;
2490         else
2491             val = 0;
2492         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
2493         val = (twsiVal & 0xef) | val;
2494         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
2495         {
2496                 DB(mvOsPrintf("Board: twsi exp out val fail\n"));
2497                 return MV_ERROR;
2498         }
2499         DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
2500
2501         /* Change twsi exp to output */
2502         twsiSlave.offset = 7;
2503         mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
2504         val = (twsiVal & 0xef);
2505         if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
2506         {
2507                 DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
2508                 return MV_ERROR;
2509         }
2510         DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
2511         return MV_OK;
2512 }
2513