src/device/c66x/c66x.c

   1 /*
   2  *
   3  * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
   4  *
   5  *
   6  *  Redistribution and use in source and binary forms, with or without
   7  *  modification, are permitted provided that the following conditions
   8  *  are met:
   9  *
  10  *    Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  *    Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  *    Neither the name of Texas Instruments Incorporated nor the names of
  19  *    its contributors may be used to endorse or promote products derived
  20  *    from this software without specific prior written permission.
  21  *
  22  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  *
  34 */
  35
  36
  37
  38 /************************************************************************************
  39  * FILE PURPOSE: C66x Device Specific functions
  40  ************************************************************************************
  41  * FILE NAME: c66x.c
  42  *
  43  * DESCRIPTION: Implements the device specific functions for the IBL
  44  *
  45  * @file c66x.c
  46  *
  47  * @brief
  48  *  This file implements the device specific functions for the IBL
  49  *
  50  ************************************************************************************/
  51 #include "ibl.h"
  52 #include "iblloc.h"
  53 #include "iblcfg.h"
  54 #include "device.h"
  55 #include "pllapi.h"
  56 #include "emif31api.h"
  57 #include "pscapi.h"
  58 #include "gpio.h"
  59 #include "qm_api.h"
  60 #include "cpdma_api.h"
  61 #include "pa_api.h"
  62 #include "serdes_api.h"
  63 #include "net.h"
  64 #include "nandhwapi.h"
  65 #include "nor_api.h"
  66 #include "spi_api.h"
  67 #include <string.h>
  68 #include <stdint.h>
  69 #include "evmc66x_uart.h"
  70
  71 #define PLL_DDR_INIT_LOOPMAX 10
  72 #define IBL_RESULT_CODE_STR_LEN 20
  73 #define IBL_RESULT_CODE_LOC 17
  74
  75 extern cregister unsigned int DNUM;
  76 #define DDR3_TEST_ENABLE
  77
  78 #ifdef DDR3_TEST_ENABLE
  79 /**
  80  *  @brief Simple DDR3 test
  81  *
  82  *  @details
  83  *      This function performs a simple DDR3 test for a memory range
  84  *      specified below and returns -1 for failure and 0 for success.
  85  */
  86
  87 #define DDR3_TEST_START_ADDRESS 0x80000000
  88
  89 #define DDR3_TEST_END_ADDRESS   (DDR3_TEST_START_ADDRESS + (128 *1024))
  90
  91 static int32_t ddr3_memory_test (void)
  92 {
  93         uint32_t index, value;
  94
  95         /* Write a pattern */
  96         for (index = DDR3_TEST_START_ADDRESS; index < DDR3_TEST_END_ADDRESS; index += 4) {
  97                 *(volatile uint32_t *) index = (uint32_t)index;
  98         }
  99
 100         /* Read and check the pattern */
 101         for (index = DDR3_TEST_START_ADDRESS; index < DDR3_TEST_END_ADDRESS; index += 4) {
 102
 103                 value = *(uint32_t *) index;
 104
 105                 if (value  != index) {
 106                         return -1;
 107                 }
 108         }
 109
 110         /* Write a pattern for complementary values */
 111         for (index = DDR3_TEST_START_ADDRESS; index < DDR3_TEST_END_ADDRESS; index += 4) {
 112                 *(volatile uint32_t *) index = (uint32_t)~index;
 113         }
 114
 115         /* Read and check the pattern */
 116         for (index = DDR3_TEST_START_ADDRESS; index < DDR3_TEST_END_ADDRESS; index += 4) {
 117
 118                 value = *(uint32_t *) index;
 119
 120                 if (value  != ~index) {
 121                         return -1;
 122                 }
 123         }
 124
 125         return 0;
 126 }
 127
 128 #endif
 129
 130 /**
 131  *  @brief Determine if an address is local
 132  *
 133  *  @details
 134  *    Examines an input address to determine if it is a local address. Using the largest
 135  *    L2 size on the C6670.
 136  */
 137 bool address_is_local (Uint32 addr)
 138 {
 139     /* L2 */
 140     if ((addr >= 0x00800000) && (addr < 0x00900000))
 141         return (TRUE);
 142
 143     /* L1P */
 144     if ((addr >= 0x00e00000) && (addr < 0x00e08000))
 145         return (TRUE);
 146
 147     /* L2D */
 148     if ((addr >= 0x00f00000) && (addr < 0x00f08000))
 149         return (TRUE);
 150
 151     return (FALSE);
 152
 153 }
 154
 155
 156 /**
 157  * @brief  Convert a local l1d, l1p or l2 address to a global address
 158  *
 159  * @details
 160  *  The global address is formed. If the address is not local then
 161  *  the input address is returned
 162  */
 163 Uint32 deviceLocalAddrToGlobal (Uint32 addr)
 164 {
 165
 166     if (address_is_local (addr))
 167         addr = (1 << 28) | (DNUM << 24) | addr;
 168
 169     return (addr);
 170
 171 }
 172
 173
 174 /**
 175  * @brief
 176  *   Enable the DDR
 177  *
 178  * @details
 179  *   The DDR controller on the c66x is an emif 4.0. The controller is
 180  *   initialized directly with the supplied values
 181  */
 182 void deviceDdrConfig (void)
 183 {
 184     uint32 loopcount=0;
 185     int8  ddr_result_code_str[IBL_RESULT_CODE_STR_LEN] = "IBL Result code 0";
 186     /* The emif registers must be made visible. MPAX mapping 2 is used */
 187     DEVICE_REG_XMPAX_L(2) =  0x10000000 | 0xff;     /* replacement addr + perm*/
 188     DEVICE_REG_XMPAX_H(2) =  0x2100000B;         /* base addr + seg size (64KB)*/
 189
 190     for (loopcount = 0; loopcount < PLL_DDR_INIT_LOOPMAX; loopcount++)
 191     {
 192         if(loopcount !=0) /*Do not call PLL sequence for the first time */
 193         {
 194         /* Calling MAIN, PA, DDR PLL init  */
 195             if (ibl.pllConfig[ibl_MAIN_PLL].doEnable == TRUE)
 196                 hwPllSetPll (MAIN_PLL,
 197                              ibl.pllConfig[ibl_MAIN_PLL].prediv,
 198                                  ibl.pllConfig[ibl_MAIN_PLL].mult,
 199                                  ibl.pllConfig[ibl_MAIN_PLL].postdiv);
 200
 201             if (ibl.pllConfig[ibl_NET_PLL].doEnable == TRUE)
 202                 hwPllSetCfgPll (DEVICE_PLL_BASE(NET_PLL),
 203                                 ibl.pllConfig[ibl_NET_PLL].prediv,
 204                                 ibl.pllConfig[ibl_NET_PLL].mult,
 205                                 ibl.pllConfig[ibl_NET_PLL].postdiv,
 206                                 ibl.pllConfig[ibl_MAIN_PLL].pllOutFreqMhz,
 207                                 ibl.pllConfig[ibl_NET_PLL].pllOutFreqMhz);
 208
 209             if (ibl.pllConfig[ibl_DDR_PLL].doEnable == TRUE)
 210                 hwPllSetCfg2Pll (DEVICE_PLL_BASE(DDR_PLL),
 211                                  ibl.pllConfig[ibl_DDR_PLL].prediv,
 212                                  ibl.pllConfig[ibl_DDR_PLL].mult,
 213                                  ibl.pllConfig[ibl_DDR_PLL].postdiv,
 214                                  ibl.pllConfig[ibl_MAIN_PLL].pllOutFreqMhz,
 215                                  ibl.pllConfig[ibl_DDR_PLL].pllOutFreqMhz);
 216           }
 217
 218         if (ibl.ddrConfig.configDdr != 0)
 219             hwEmif4p0Enable (&ibl.ddrConfig.uEmif.emif4p0);
 220         /* Init UART */
 221          uart_init();
 222 #ifdef DDR3_TEST_ENABLE
 223         if (ddr3_memory_test() == 0)
 224         {
 225             break;
 226         }
 227 #endif
 228
 229     }
 230     if (loopcount < 10)
 231     {
 232         ddr_result_code_str[IBL_RESULT_CODE_LOC] = loopcount + '0';
 233     }
 234     else if ((loopcount >= 10) && (loopcount < 35))
 235     {
 236         ddr_result_code_str[IBL_RESULT_CODE_LOC] =   loopcount + 'A';
 237     }
 238     else
 239     {
 240         ddr_result_code_str[IBL_RESULT_CODE_LOC] =   loopcount + 'Z';
 241     }
 242
 243     if (loopcount == PLL_DDR_INIT_LOOPMAX)
 244     {
 245         uart_write_string("IBL: DDR INITIALIZATION FAILED",0);
 246     }
 247     else
 248     {
 249         uart_write_string("IBL: PLL and DDR Initialization Complete",0);
 250     }
 251     uart_write_string(ddr_result_code_str,0);
 252
 253 }
 254
 255
 256
 257 /**
 258  *  @brief  Enable EMIF25 or SPI interface to the NAND
 259  *
 260  */
 261 int32 deviceConfigureForNand(void)
 262 {
 263
 264     return (0);
 265
 266 }
 267
 268 /**
 269  *  @brief
 270  *      Return the base memory address for emif25 in a given chip select space
 271  */
 272 uint32 deviceEmif25MemBase (int32 cs)
 273 {
 274     switch (cs)  {
 275
 276         case 2:  return (TARGET_MEM_NAND_CS_2);
 277
 278         case 3:  return (TARGET_MEM_NAND_CS_3);
 279
 280         case 4:  return (TARGET_MEM_NAND_CS_4);
 281
 282         case 5:  return (TARGET_MEM_NAND_CS_5);
 283
 284     }
 285
 286     return (0xffffffff);
 287
 288 }
 289
 290
 291 /**
 292  *  @brief
 293  *      Return the PSC number for NAND/NOR through emif. Only 6678 has the emif
 294  */
 295 Int32 deviceEmifPscNum (void)
 296 {
 297     Uint32 v;
 298
 299     v = *((Uint32 *)DEVICE_JTAG_ID_REG);
 300     v &= DEVICE_JTAG_ID_MASK;
 301     if (v == DEVICE_C6678_JTAG_ID_VAL)
 302         return (TARGET_PWR_EMIF_C6678);
 303
 304     /* Return a negative number to indicate no PSC module is associated with NAND */
 305     return (-1);
 306
 307 }
 308
 309
 310
 311 /**
 312  *  @brief
 313  *    The e-fuse mac address is loaded
 314  */
 315 void deviceLoadDefaultEthAddress (uint8 *maddr)
 316 {
 317     uint32 macA, macB;
 318
 319     /* Read the e-fuse mac address */
 320     macA = *((uint32 *)0x2620110);
 321     macB = *((uint32 *)0x2620114);
 322
 323     maddr[0] = (macB >>  8) & 0xff;
 324     maddr[1] = (macB >>  0) & 0xff;
 325     maddr[2] = (macA >> 24) & 0xff;
 326     maddr[3] = (macA >> 16) & 0xff;
 327     maddr[4] = (macA >>  8) & 0xff;
 328     maddr[5] = (macA >>  0) & 0xff;
 329 }
 330
 331
 332 /**
 333  *  @brief
 334  *    Compile time queue manager information
 335  */
 336 #define DEVICE_NUM_RX_CPPIS     1
 337 #define DEVICE_NUM_TX_CPPIS     1
 338 #define DEVICE_NUM_CPPIS        (DEVICE_NUM_RX_CPPIS + DEVICE_NUM_TX_CPPIS)
 339
 340 /* The linking RAM */
 341 #pragma DATA_SECTION(qm_linkram_buf, ".linkram")
 342 #pragma DATA_ALIGN(qm_linkram_buf, 16)
 343 uint8 qm_linkram_buf[DEVICE_NUM_CPPIS * 2 * (sizeof(uint32)/sizeof(uint8))];
 344
 345
 346 /* The CPPI RAM */
 347 #pragma DATA_SECTION(qm_cppi_buf, ".cppi")
 348 #pragma DATA_ALIGN(qm_cppi_buf, 16)
 349 uint8 qm_cppi_buf[QM_DESC_SIZE_BYTES * DEVICE_NUM_CPPIS];
 350
 351
 352 /* The rx data buffers */
 353 #pragma DATA_SECTION(qm_buffer, ".mac_buffer")
 354 #pragma DATA_ALIGN(qm_buffer, 16)
 355 uint8 qm_buffer[MAX_SIZE_STREAM_BUFFER * DEVICE_NUM_RX_CPPIS];
 356
 357 const qmConfig_t qmConfig =  {
 358     (UINT32) qm_linkram_buf,
 359     sizeof  (qm_cppi_buf),
 360     (UINT32) qm_cppi_buf,
 361
 362     DEVICE_NUM_CPPIS,
 363     DEVICE_QM_FREE_Q
 364 };
 365
 366 /**
 367  *  @brief
 368  *      Return the queue manager memory configuration information
 369  */
 370 void *targetGetQmConfig (void)
 371 {
 372     return ((void *)&qmConfig);
 373 }
 374
 375 /**
 376  *  @brief
 377  *      Attach a packet buffer to each descriptor and push onto the linked buffer queue
 378  */
 379 void targetInitQs (void)
 380 {
 381     int32 i;
 382     qmHostDesc_t *hd;
 383
 384     for (i = 0; i < DEVICE_NUM_RX_CPPIS; i++)  {
 385
 386         hd                = hwQmQueuePop (DEVICE_QM_FREE_Q);
 387         hd->buffLen       = sizeof (qm_buffer) / DEVICE_NUM_CPPIS;
 388         hd->buffPtr       = (UINT32) &(qm_buffer[MAX_SIZE_STREAM_BUFFER * i]);
 389         hd->nextBDPtr     = 0;
 390         hd->origBufferLen = MAX_SIZE_STREAM_BUFFER;
 391         hd->origBuffPtr   = hd->buffPtr;
 392
 393         hwQmQueuePush (hd, DEVICE_QM_LNK_BUF_Q, QM_DESC_SIZE_BYTES);
 394
 395     }
 396
 397
 398     for (i = 0; i < DEVICE_NUM_TX_CPPIS; i++)  {
 399
 400         hd                = hwQmQueuePop (DEVICE_QM_FREE_Q);
 401         hd->buffLen       = 0;
 402         hd->buffPtr       = 0;
 403         hd->nextBDPtr     = 0;
 404         hd->origBufferLen = 0;
 405         hd->origBuffPtr   = 0;
 406
 407         hwQmQueuePush (hd, DEVICE_QM_TX_Q, QM_DESC_SIZE_BYTES);
 408
 409     }
 410
 411
 412 }
 413
 414
 415
 416 const cpdmaRxCfg_t cpdmaEthRxCfg =  {
 417
 418     DEVICE_PA_CDMA_RX_CHAN_CFG_BASE,    /* Base address of PA CPDMA rx config registers */
 419     DEVICE_PA_CDMA_RX_NUM_CHANNELS,     /* Number of rx channels */
 420
 421     DEVICE_PA_CDMA_RX_FLOW_CFG_BASE,    /* Base address of PA CPDMA rx flow registers */
 422     DEVICE_PA_CDMA_RX_NUM_FLOWS,        /* Number of rx flows */
 423
 424     0,                                  /* Queue manager for descriptor / buffer for received packets */
 425     DEVICE_QM_LNK_BUF_Q,                /* Queue of descriptors /buffers for received packets */
 426
 427     0,                                  /* Queue manager for received packets */
 428     DEVICE_QM_RCV_Q,                    /* Queue for received packets (overridden by PA)  */
 429
 430     DEVICE_RX_CDMA_TIMEOUT_COUNT        /* Teardown maximum loop wait */
 431 };
 432
 433
 434 /**
 435  *  @brief
 436  *      Return the cpdma configuration information
 437  */
 438 void *targetGetCpdmaRxConfig (void)
 439 {
 440     return ((void *)&cpdmaEthRxCfg);
 441
 442 }
 443
 444
 445 const cpdmaTxCfg_t cpdmaEthTxCfg = {
 446
 447     DEVICE_PA_CDMA_GLOBAL_CFG_BASE,     /* Base address of global config registers      */
 448     DEVICE_PA_CDMA_TX_CHAN_CFG_BASE,    /* Base address of PA CPDMA tx config registers */
 449     DEVICE_PA_CDMA_TX_NUM_CHANNELS      /* Number of tx channels */
 450
 451 };
 452
 453
 454 /**
 455  *  @brief
 456  *      return the tx cpdma configuration information
 457  */
 458 void *targetGetCpdmaTxConfig (void)
 459 {
 460     return ((void *)&cpdmaEthTxCfg);
 461
 462 }
 463
 464 /**
 465  *  @brief
 466  *     Configure the PA
 467  */
 468 void targetPaConfig (uint8 *macAddr)
 469 {
 470     paConfig_t     paCfg;
 471     qmHostDesc_t  *hd;
 472     SINT16         ret;
 473
 474     /* Filter everything except the desired mac address and the broadcast mac */
 475     paCfg.mac0ms = ((uint32)macAddr[0] << 24) | ((uint32)macAddr[1] << 16) | ((uint32)macAddr[2] << 8) | (uint32)(macAddr[3]);
 476     paCfg.mac0ls = ((uint32)macAddr[4] << 24) | ((uint32)macAddr[5] << 16);
 477
 478     paCfg.mac1ms = 0xffffffff;
 479     paCfg.mac1ls = 0xffff0000;
 480
 481     paCfg.rxQnum = DEVICE_QM_RCV_Q;
 482
 483     /* Form the configuration command in a buffer linked to a descriptor */
 484     hd = hwQmQueuePop (DEVICE_QM_LNK_BUF_Q);
 485     paCfg.cmdBuf = (uint8 *)hd->origBuffPtr;
 486
 487     ret = hwPaEnable (&paCfg);
 488     if (ret != 0)  {
 489         iblStatus.iblFail = ibl_FAIL_CODE_PA;
 490         return;
 491     }
 492
 493
 494     /* Send the command to the PA through the QM */
 495     hd->softwareInfo0 = PA_MAGIC_ID;
 496     hd->buffLen = 16;
 497     QM_DESC_DESCINFO_SET_PKT_LEN(hd->descInfo, 16);
 498
 499     /* Set the return Queue */
 500     QM_DESC_PINFO_SET_QM    (hd->packetInfo, 0);
 501     QM_DESC_PINFO_SET_QUEUE (hd->packetInfo, DEVICE_QM_LNK_BUF_Q);
 502
 503     hwQmQueuePush (hd, DEVICE_QM_PA_CFG_Q, QM_DESC_SIZE_BYTES);
 504
 505
 506 }
 507
 508 /**
 509  *  @brief
 510  *      Chip level SGMII serdes configuration
 511  *
 512  *  @details
 513  *      Both lanes are always setup, regardless of the port value
 514  */
 515 void targetSgmiiSerdesConfig (int32 port, void *viblSgmii)
 516 {
 517   serdesConfig_t scfg;
 518   iblSgmii_t     *sgmii = (iblSgmii_t *)viblSgmii;
 519
 520   scfg.cfg      = sgmii->auxConfig;
 521   scfg.nLanes   = 2;
 522   scfg.rxCfg[0] = scfg.rxCfg[1] = sgmii->rxConfig;
 523   scfg.txCfg[0] = scfg.txCfg[1] = sgmii->txConfig;
 524
 525   hwSerdesConfig (TARGET_SGMII_SERDES_BASE, &scfg);
 526
 527   hwSerdesWaitLock (TARGET_SGMII_SERDES_STATUS_BASE);
 528
 529 }
 530
 531
 532 Int32 targetMacSend (void *vptr_device, Uint8* buffer, int num_bytes)
 533 {
 534     qmHostDesc_t   *hd;
 535     NET_DRV_DEVICE *ptr_device = (NET_DRV_DEVICE *)vptr_device;
 536     int             i;
 537
 538
 539     /* Must always setup the descriptor to have the minimum packet length */
 540     if (num_bytes < 64)
 541         num_bytes = 64;
 542
 543
 544     for (i = 0, hd = NULL; hd == NULL; i++, chipDelay32 (1000))
 545         hd = hwQmQueuePop (DEVICE_QM_TX_Q);
 546
 547     if (hd == NULL)
 548         return (-1);
 549
 550     QM_DESC_DESCINFO_SET_PKT_LEN(hd->descInfo, num_bytes);
 551
 552     hd->buffLen       = num_bytes;
 553     hd->origBufferLen = num_bytes;
 554
 555     hd->buffPtr     = deviceLocalAddrToGlobal((UINT32)buffer);
 556     hd->origBuffPtr = deviceLocalAddrToGlobal((UINT32)buffer);
 557
 558
 559     /* Return the descriptor back to the transmit queue */
 560     QM_DESC_PINFO_SET_QM(hd->packetInfo, 0);
 561     QM_DESC_PINFO_SET_QUEUE(hd->packetInfo, DEVICE_QM_TX_Q);
 562
 563     hwQmQueuePush (hd, DEVICE_QM_ETH_TX_Q, QM_DESC_SIZE_BYTES);
 564
 565     return (0);
 566
 567 }
 568
 569
 570 Int32 targetMacRcv (void *vptr_device, UINT8 *buffer)
 571 {
 572     Int32           pktSizeBytes;
 573     qmHostDesc_t   *hd;
 574     NET_DRV_DEVICE *ptr_device = (NET_DRV_DEVICE *)vptr_device;
 575
 576     hd = hwQmQueuePop (DEVICE_QM_RCV_Q);
 577     if (hd == NULL)
 578         return (0);
 579
 580     pktSizeBytes = QM_DESC_DESCINFO_GET_PKT_LEN(hd->descInfo);
 581     iblMemcpy ((void *)buffer, (void *)hd->buffPtr, pktSizeBytes);
 582
 583     hd->buffLen = hd->origBufferLen;
 584     hd->buffPtr = hd->origBuffPtr;
 585
 586     hwQmQueuePush (hd, DEVICE_QM_LNK_BUF_Q, QM_DESC_SIZE_BYTES);
 587
 588     return (pktSizeBytes);
 589
 590 }
 591
 592 void targetFreeQs (void)
 593 {
 594     qmHostDesc_t   *hd;
 595
 596     do  {
 597
 598         hd = hwQmQueuePop (DEVICE_QM_FREE_Q);
 599
 600     } while (hd != NULL);
 601
 602     do  {
 603
 604         hd = hwQmQueuePop (DEVICE_QM_LNK_BUF_Q);
 605
 606     } while (hd != NULL);
 607
 608     do  {
 609
 610         hd = hwQmQueuePop (DEVICE_QM_RCV_Q);
 611
 612     } while (hd != NULL);
 613
 614     do  {
 615
 616         hd = hwQmQueuePop (DEVICE_QM_TX_Q);
 617
 618     } while (hd != NULL);
 619
 620 }
 621
 622 extern nandCtbl_t nandEmifCtbl;
 623 /**
 624  *  @brief Return the NAND interface (GPIO, EMIF25 or SPI) used based on the value
 625  *         of interface
 626  */
 627 #ifndef EXCLUDE_NAND_GPIO
 628 nandCtbl_t nandGpioCtbl =  {
 629
 630     nandHwGpioDriverInit,
 631     nandHwGpioDriverReadBytes,
 632     nandHwGpioDriverReadPage,
 633     nandHwGpioDriverClose
 634
 635 };
 636 #endif
 637
 638 #ifndef EXCLUDE_NAND_EMIF
 639 extern Int32 nandHwEmifDriverInit (int32 cs, void *vdevInfo);
 640 extern Int32 nandHwEmifDriverReadBytes (Uint32 block, Uint32 page, Uint32 byte, Uint32 nbytes, Uint8 *data);
 641 extern Int32 nandHwEmifDriverReadPage (Uint32 block, Uint32 page, Uint8 *data);
 642 extern Int32 nandHwEmifDriverClose (void);
 643
 644 nandCtbl_t nandEmifCtbl =  {
 645
 646     nandHwEmifDriverInit,
 647     nandHwEmifDriverReadBytes,
 648     nandHwEmifDriverReadPage,
 649     nandHwEmifDriverClose
 650
 651 };
 652 #endif
 653
 654 #ifndef EXCLUDE_NAND_SPI
 655 nandCtbl_t nandSpiCtbl =  {
 656
 657
 658     nandHwSpiDriverInit,
 659     nandHwSpiDriverReadBytes,
 660     nandHwSpiDriverReadPage,
 661     nandHwSpiDriverClose
 662
 663 };
 664 #endif
 665
 666 nandCtbl_t *deviceGetNandCtbl (int32 interface)
 667 {
 668 #ifndef EXCLUDE_NAND_GPIO
 669
 670     if (interface == ibl_PMEM_IF_GPIO)
 671         return (&nandGpioCtbl);
 672
 673 #endif
 674
 675 #ifndef EXCLUDE_NAND_SPI
 676
 677     if (interface == ibl_PMEM_IF_SPI)
 678         return (&nandSpiCtbl);
 679
 680 #endif
 681
 682 #ifndef EXCLUDE_NAND_EMIF
 683
 684     if ((interface >= ibl_PMEM_IF_CHIPSEL_2) && (interface <= ibl_PMEM_IF_CHIPSEL_5))
 685         return (&nandEmifCtbl);
 686
 687 #endif
 688
 689     return (NULL);
 690
 691 }
 692
 693
 694 /**
 695  * @brief
 696  *      Get the nor call table for the specified nor interface
 697  */
 698
 699 #ifndef EXCLUDE_NOR_EMIF
 700 norCtbl_t norEmifCtbl = {
 701
 702     norHwEmifDriverInit,
 703     norHwEmifDriverReadBytes,
 704     norHwEmifDriverClose
 705
 706 };
 707
 708 #endif
 709
 710 #ifndef EXCLUDE_NOR_SPI
 711
 712 norCtbl_t norSpiCtbl = {
 713
 714     norHwSpiDriverInit,
 715     norHwSpiDriverReadBytes,
 716     norHwSpiDriverClose
 717
 718 };
 719
 720 #endif
 721
 722 norCtbl_t *deviceGetNorCtbl (int32 interface)
 723 {
 724
 725 #ifndef EXCLUDE_NOR_SPI
 726
 727     if (interface == ibl_PMEM_IF_SPI)
 728         return (&norSpiCtbl);
 729
 730 #endif
 731
 732 #ifndef EXCLUDE_NOR_EMIF
 733
 734     if ((interface >= ibl_PMEM_IF_CHIPSEL_2) && (interface <= ibl_PMEM_IF_CHIPSEL_5))
 735         return (&norEmifCtbl);
 736
 737 #endif
 738
 739     return (NULL);
 740
 741 }
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760