board/gw8260/gw8260.c

   1 /*
   2  * (C) Copyright 2000
   3  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   4  * Marius Groeger <mgroeger@sysgo.de>
   5  *
   6  * (C) Copyright 2001
   7  * Advent Networks, Inc. <http://www.adventnetworks.com>
   8  * Jay Monkman <jtm@smoothsmoothie.com>
   9  *
  10  * (C) Copyright 2001
  11  * Advent Networks, Inc. <http://www.adventnetworks.com>
  12  * Oliver Brown <oliverb@alumni.utexas.net>
  13  *
  14  * See file CREDITS for list of people who contributed to this
  15  * project.
  16  *
  17  * This program is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU General Public License as
  19  * published by the Free Software Foundation; either version 2 of
  20  * the License, or (at your option) any later version.
  21  *
  22  * This program is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25  * GNU General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU General Public License
  28  * along with this program; if not, write to the Free Software
  29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  30  * MA 02111-1307 USA
  31  */
  32
  33 /*********************************************************************/
  34 /* DESCRIPTION:
  35  *   This file contains the board routines for the GW8260 board.
  36  *
  37  * MODULE DEPENDENCY:
  38  *   None
  39  *
  40  * RESTRICTIONS/LIMITATIONS:
  41  *   None
  42  *
  43  * Copyright (c) 2001, Advent Networks, Inc.
  44  */
  45 /*********************************************************************/
  46
  47 #include <common.h>
  48 #include <ioports.h>
  49 #include <mpc8260.h>
  50
  51 /*
  52  * I/O Port configuration table
  53  *
  54  */
  55 const iop_conf_t iop_conf_tab[4][32] = {
  56
  57     /* Port A configuration */
  58     {   /*             conf ppar psor pdir podr pdat */
  59         /* PA31 */ {   1,   0,   0,   1,   0,   0   }, /* TP14          */
  60         /* PA30 */ {   1,   1,   1,   1,   0,   0   }, /* US_RTS        */
  61         /* PA29 */ {   1,   0,   0,   1,   0,   1   }, /* LSSI_DATA     */
  62         /* PA28 */ {   1,   0,   0,   1,   0,   1   }, /* LSSI_CLK      */
  63         /* PA27 */ {   1,   0,   0,   1,   0,   0   }, /* TP12          */
  64         /* PA26 */ {   1,   0,   0,   0,   0,   0   }, /* IO_STATUS     */
  65         /* PA25 */ {   1,   0,   0,   0,   0,   0   }, /* IO_CLOCK      */
  66         /* PA24 */ {   1,   0,   0,   0,   0,   0   }, /* IO_CONFIG     */
  67         /* PA23 */ {   1,   0,   0,   0,   0,   0   }, /* IO_DONE       */
  68         /* PA22 */ {   1,   0,   0,   0,   0,   0   }, /* IO_DATA       */
  69         /* PA21 */ {   1,   1,   0,   1,   0,   0   }, /* US_TXD3       */
  70         /* PA20 */ {   1,   1,   0,   1,   0,   0   }, /* US_TXD2       */
  71         /* PA19 */ {   1,   1,   0,   1,   0,   0   }, /* US_TXD1       */
  72         /* PA18 */ {   1,   1,   0,   1,   0,   0   }, /* US_TXD0       */
  73         /* PA17 */ {   1,   1,   0,   0,   0,   0   }, /* DS_RXD0       */
  74         /* PA16 */ {   1,   1,   0,   0,   0,   0   }, /* DS_RXD1       */
  75         /* PA15 */ {   1,   1,   0,   0,   0,   0   }, /* DS_RXD2       */
  76         /* PA14 */ {   1,   1,   0,   0,   0,   0   }, /* DS_RXD3       */
  77         /* PA13 */ {   1,   0,   0,   1,   0,   0   }, /* SPARE7        */
  78         /* PA12 */ {   1,   0,   0,   1,   0,   0   }, /* SPARE6        */
  79         /* PA11 */ {   1,   0,   0,   1,   0,   0   }, /* SPARE5        */
  80         /* PA10 */ {   1,   0,   0,   1,   0,   0   }, /* SPARE4        */
  81         /* PA9  */ {   1,   0,   0,   1,   0,   0   }, /* SPARE3        */
  82         /* PA8  */ {   1,   0,   0,   1,   0,   0   }, /* SPARE2        */
  83         /* PA7  */ {   1,   0,   0,   0,   0,   0   }, /* LSSI_IN       */
  84         /* PA6  */ {   1,   0,   0,   1,   0,   0   }, /* SPARE0        */
  85         /* PA5  */ {   1,   0,   0,   1,   0,   0   }, /* DEMOD_RESET_  */
  86         /* PA4  */ {   1,   0,   0,   1,   0,   0   }, /* MOD_RESET_    */
  87         /* PA3  */ {   1,   0,   0,   1,   0,   0   }, /* IO_RESET      */
  88         /* PA2  */ {   1,   0,   0,   1,   0,   0   }, /* TX_ENABLE     */
  89         /* PA1  */ {   1,   0,   0,   0,   0,   0   }, /* RX_LOCK       */
  90         /* PA0  */ {   1,   0,   0,   1,   0,   1   }  /* MPC_RESET_    */
  91     },
  92
  93     /* Port B configuration */
  94     {   /*             conf ppar psor pdir podr pdat */
  95         /* PB31 */ {   1,   1,   0,   1,   0,   0   }, /* FETH0_TX_ER */
  96         /* PB30 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_RX_DV */
  97         /* PB29 */ {   1,   1,   1,   1,   0,   0   }, /* FETH0_TX_EN */
  98         /* PB28 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_RX_ER */
  99         /* PB27 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_COL   */
 100         /* PB26 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_CRS   */
 101         /* PB25 */ {   1,   1,   0,   1,   0,   0   }, /* FETH0_TXD3  */
 102         /* PB24 */ {   1,   1,   0,   1,   0,   0   }, /* FETH0_TXD2  */
 103         /* PB23 */ {   1,   1,   0,   1,   0,   0   }, /* FETH0_TXD1  */
 104         /* PB22 */ {   1,   1,   0,   1,   0,   0   }, /* FETH0_TXD0  */
 105         /* PB21 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_RXD0  */
 106         /* PB20 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_RXD1  */
 107         /* PB19 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_RXD2  */
 108         /* PB18 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_RXD3  */
 109         /* PB17 */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_RX_DV */
 110         /* PB16 */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_RX_ER */
 111         /* PB15 */ {   1,   1,   0,   1,   0,   0   }, /* FETH1_TX_ER */
 112         /* PB14 */ {   1,   1,   0,   1,   0,   0   }, /* FETH1_TX_EN */
 113         /* PB13 */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_COL   */
 114         /* PB12 */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_CRS   */
 115         /* PB11 */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_RXD3  */
 116         /* PB10 */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_RXD2  */
 117         /* PB9  */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_RXD1  */
 118         /* PB8  */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_RXD0  */
 119         /* PB7  */ {   1,   1,   0,   1,   0,   0   }, /* FETH1_TXD0  */
 120         /* PB6  */ {   1,   1,   0,   1,   0,   0   }, /* FETH1_TXD1  */
 121         /* PB5  */ {   1,   1,   0,   1,   0,   0   }, /* FETH1_TXD2  */
 122         /* PB4  */ {   1,   1,   0,   1,   0,   0   }, /* FETH1_TXD3  */
 123         /* PB3  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 124         /* PB2  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 125         /* PB1  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 126         /* PB0  */ {   0,   0,   0,   0,   0,   0   }  /* pin doesn't exist */
 127     },
 128
 129     /* Port C */
 130     {   /*             conf ppar psor pdir podr pdat */
 131         /* PC31 */ {   1,   0,   0,   1,   0,   1   }, /* FAST_RESET_   */
 132         /* PC30 */ {   1,   0,   0,   1,   0,   1   }, /* FAST_PAUSE_   */
 133         /* PC29 */ {   1,   0,   0,   1,   0,   0   }, /* FAST_SLEW1    */
 134         /* PC28 */ {   1,   0,   0,   1,   0,   0   }, /* FAST_SLEW0    */
 135         /* PC27 */ {   1,   0,   0,   1,   0,   0   }, /* TP13          */
 136         /* PC26 */ {   1,   0,   0,   0,   0,   0   }, /* RXDECDFLG     */
 137         /* PC25 */ {   1,   0,   0,   0,   0,   0   }, /* RXACQFAIL     */
 138         /* PC24 */ {   1,   0,   0,   0,   0,   0   }, /* RXACQFLG      */
 139         /* PC23 */ {   1,   0,   0,   1,   0,   0   }, /* WD_TCL        */
 140         /* PC22 */ {   1,   0,   0,   1,   0,   0   }, /* WD_EN         */
 141         /* PC21 */ {   1,   0,   0,   1,   0,   0   }, /* US_TXCLK      */
 142         /* PC20 */ {   1,   0,   0,   0,   0,   0   }, /* DS_RXCLK      */
 143         /* PC19 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_RX_CLK  */
 144         /* PC18 */ {   1,   1,   0,   0,   0,   0   }, /* FETH0_TX_CLK  */
 145         /* PC17 */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_RX_CLK  */
 146         /* PC16 */ {   1,   1,   0,   0,   0,   0   }, /* FETH1_TX_CLK  */
 147         /* PC15 */ {   1,   0,   0,   1,   0,   0   }, /* TX_SHUTDOWN_  */
 148         /* PC14 */ {   1,   0,   0,   0,   0,   0   }, /* RS_232_DTR_   */
 149         /* PC13 */ {   1,   0,   0,   0,   0,   0   }, /* TXERR         */
 150         /* PC12 */ {   1,   0,   0,   1,   0,   1   }, /* FETH1_MDDIS   */
 151         /* PC11 */ {   1,   0,   0,   1,   0,   1   }, /* FETH0_MDDIS   */
 152         /* PC10 */ {   1,   0,   0,   1,   0,   0   }, /* MDC           */
 153         /* PC9  */ {   1,   0,   0,   1,   1,   1   }, /* MDIO          */
 154         /* PC8  */ {   1,   0,   0,   1,   1,   1   }, /* SER_NUM       */
 155         /* PC7  */ {   1,   1,   0,   0,   0,   0   }, /* US_CTS        */
 156         /* PC6  */ {   1,   1,   0,   0,   0,   0   }, /* DS_CD_        */
 157         /* PC5  */ {   1,   0,   0,   1,   0,   0   }, /* FETH1_PWRDWN  */
 158         /* PC4  */ {   1,   0,   0,   1,   0,   0   }, /* FETH0_PWRDWN  */
 159         /* PC3  */ {   1,   0,   0,   1,   0,   0   }, /* MPULED3       */
 160         /* PC2  */ {   1,   0,   0,   1,   0,   0   }, /* MPULED2       */
 161         /* PC1  */ {   1,   0,   0,   1,   0,   0   }, /* MPULED1       */
 162         /* PC0  */ {   1,   0,   0,   1,   0,   1   }, /* MPULED0       */
 163     },
 164
 165     /* Port D */
 166     {   /*             conf ppar psor pdir podr pdat */
 167         /* PD31 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 168         /* PD30 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 169         /* PD29 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 170         /* PD28 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 171         /* PD27 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 172         /* PD26 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 173         /* PD25 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 174         /* PD24 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 175         /* PD23 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 176         /* PD22 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 177         /* PD21 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 178         /* PD20 */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 179         /* PD19 */ {   1,   1,   1,   0,   0,   0   }, /*  not used     */
 180         /* PD18 */ {   1,   1,   1,   0,   0,   0   }, /*  not used     */
 181         /* PD17 */ {   1,   1,   1,   0,   0,   0   }, /*  not used     */
 182         /* PD16 */ {   1,   1,   1,   0,   0,   0   }, /*  not used     */
 183         /* PD15 */ {   1,   1,   1,   0,   1,   1   }, /*  SDRAM_SDA    */
 184         /* PD14 */ {   1,   1,   1,   0,   1,   1   }, /*  SDRAM_SCL    */
 185         /* PD13 */ {   1,   0,   0,   1,   0,   0   }, /*  MPULED7      */
 186         /* PD12 */ {   1,   0,   0,   1,   0,   0   }, /*  MPULED6      */
 187         /* PD11 */ {   1,   0,   0,   1,   0,   0   }, /*  MPULED5      */
 188         /* PD10 */ {   1,   0,   0,   1,   0,   0   }, /*  MPULED4      */
 189         /* PD9  */ {   1,   1,   0,   1,   0,   0   }, /*  RS232_TXD    */
 190         /* PD8  */ {   1,   1,   0,   0,   0,   0   }, /*  RD232_RXD    */
 191         /* PD7  */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 192         /* PD6  */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 193         /* PD5  */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 194         /* PD4  */ {   1,   0,   0,   0,   0,   0   }, /*  not used     */
 195         /* PD3  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 196         /* PD2  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 197         /* PD1  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 198         /* PD0  */ {   0,   0,   0,   0,   0,   0   }  /* pin doesn't exist */
 199     }
 200 };
 201
 202 /*********************************************************************/
 203 /* NAME: checkboard() -  Displays the board type and serial number   */
 204 /*                                                                   */
 205 /* OUTPUTS:                                                          */
 206 /*   Displays the board type and serial number                       */
 207 /*                                                                   */
 208 /* RETURNS:                                                          */
 209 /*   Always returns 1                                                */
 210 /*                                                                   */
 211 /* RESTRICTIONS/LIMITATIONS:                                         */
 212 /*                                                                   */
 213 /*                                                                   */
 214 /*********************************************************************/
 215 int checkboard(void)
 216 {
 217     char *str;
 218     puts ("Board: Advent Networks gw8260\n");
 219
 220     str = getenv("serial#");
 221     if (str != NULL) {
 222         printf("SN:    %s\n", str);
 223     }
 224     return 0;
 225 }
 226
 227
 228 #if defined (CFG_DRAM_TEST)
 229 /*********************************************************************/
 230 /* NAME:  move64() -  moves a double word (64-bit)                   */
 231 /*                                                                   */
 232 /* DESCRIPTION:                                                      */
 233 /*   this function performs a double word move from the data at      */
 234 /*   the source pointer to the location at the destination pointer.  */
 235 /*                                                                   */
 236 /* INPUTS:                                                           */
 237 /*   unsigned long long *src  - pointer to data to move              */
 238 /*                                                                   */
 239 /* OUTPUTS:                                                          */
 240 /*   unsigned long long *dest - pointer to locate to move data       */
 241 /*                                                                   */
 242 /* RETURNS:                                                          */
 243 /*   None                                                            */
 244 /*                                                                   */
 245 /* RESTRICTIONS/LIMITATIONS:                                         */
 246 /*   May cloober fr0.                                                */
 247 /*                                                                   */
 248 /*********************************************************************/
 249 static void move64(unsigned long long *src, unsigned long long *dest)
 250 {
 251         asm ("lfd  0, 0(3)\n\t" /* fpr0   =  *scr       */
 252          "stfd 0, 0(4)"         /* *dest  =  fpr0       */
 253          : : : "fr0" );         /* Clobbers fr0         */
 254     return;
 255 }
 256
 257
 258 #if defined (CFG_DRAM_TEST_DATA)
 259
 260 unsigned long long pattern[]= {
 261     0xaaaaaaaaaaaaaaaa,
 262     0xcccccccccccccccc,
 263     0xf0f0f0f0f0f0f0f0,
 264     0xff00ff00ff00ff00,
 265     0xffff0000ffff0000,
 266     0xffffffff00000000,
 267     0x00000000ffffffff,
 268     0x0000ffff0000ffff,
 269     0x00ff00ff00ff00ff,
 270     0x0f0f0f0f0f0f0f0f,
 271     0x3333333333333333,
 272     0x5555555555555555};
 273
 274 /*********************************************************************/
 275 /* NAME:  mem_test_data() -  test data lines for shorts and opens    */
 276 /*                                                                   */
 277 /* DESCRIPTION:                                                      */
 278 /*   Tests data lines for shorts and opens by forcing adjacent data  */
 279 /*   to opposite states. Because the data lines could be routed in   */
 280 /*   an arbitrary manner the must ensure test patterns ensure that   */
 281 /*   every case is tested. By using the following series of binary   */
 282 /*   patterns every combination of adjacent bits is test regardless  */
 283 /*   of routing.                                                     */
 284 /*                                                                   */
 285 /*     ...101010101010101010101010                                   */
 286 /*     ...110011001100110011001100                                   */
 287 /*     ...111100001111000011110000                                   */
 288 /*     ...111111110000000011111111                                   */
 289 /*                                                                   */
 290 /*   Carrying this out, gives us six hex patterns as follows:        */
 291 /*                                                                   */
 292 /*     0xaaaaaaaaaaaaaaaa                                            */
 293 /*     0xcccccccccccccccc                                            */
 294 /*     0xf0f0f0f0f0f0f0f0                                            */
 295 /*     0xff00ff00ff00ff00                                            */
 296 /*     0xffff0000ffff0000                                            */
 297 /*     0xffffffff00000000                                            */
 298 /*                                                                   */
 299 /*   The number test patterns will always be given by:               */
 300 /*                                                                   */
 301 /*   log(base 2)(number data bits) = log2 (64) = 6                   */
 302 /*                                                                   */
 303 /*   To test for short and opens to other signals on our boards. we  */
 304 /*   simply                                                          */
 305 /*   test with the 1's complemnt of the paterns as well.             */
 306 /*                                                                   */
 307 /* OUTPUTS:                                                          */
 308 /*   Displays failing test pattern                                   */
 309 /*                                                                   */
 310 /* RETURNS:                                                          */
 311 /*   0 -  Passed test                                                */
 312 /*   1 -  Failed test                                                */
 313 /*                                                                   */
 314 /* RESTRICTIONS/LIMITATIONS:                                         */
 315 /*  Assumes only one one SDRAM bank                                  */
 316 /*                                                                   */
 317 /*********************************************************************/
 318 int mem_test_data(void)
 319 {
 320     unsigned long long * pmem =
 321         (unsigned long long *)CFG_SDRAM_BASE ;
 322     unsigned long long temp64;
 323     int num_patterns = sizeof(pattern)/ sizeof(pattern[0]);
 324     int i;
 325     unsigned int hi, lo;
 326
 327     for ( i = 0; i < num_patterns; i++) {
 328         move64(&(pattern[i]), pmem);
 329         move64(pmem, &temp64);
 330
 331         /* hi = (temp64>>32) & 0xffffffff;          */
 332         /* lo = temp64 & 0xffffffff;                */
 333         /* printf("\ntemp64 = 0x%08x%08x", hi, lo); */
 334
 335         hi = (pattern[i]>>32) & 0xffffffff;
 336         lo = pattern[i] & 0xffffffff;
 337         /* printf("\npattern[%d] = 0x%08x%08x", i, hi, lo);  */
 338
 339         if (temp64 != pattern[i]){
 340             printf ("\n   Data Test Failed, pattern 0x%08x%08x", hi, lo);
 341             return 1;
 342         }
 343     }
 344
 345     return 0;
 346 }
 347 #endif /* CFG_DRAM_TEST_DATA */
 348
 349 #if defined (CFG_DRAM_TEST_ADDRESS)
 350 /*********************************************************************/
 351 /* NAME:  mem_test_address() -  test address lines                   */
 352 /*                                                                   */
 353 /* DESCRIPTION:                                                      */
 354 /*   This function performs a test to verify that each word im       */
 355 /*   memory is uniquly addressable. The test sequence is as follows: */
 356 /*                                                                   */
 357 /*   1) write the address of each word to each word.                 */
 358 /*   2) verify that each location equals its address                 */
 359 /*                                                                   */
 360 /* OUTPUTS:                                                          */
 361 /*   Displays failing test pattern and address                       */
 362 /*                                                                   */
 363 /* RETURNS:                                                          */
 364 /*   0 -  Passed test                                                */
 365 /*   1 -  Failed test                                                */
 366 /*                                                                   */
 367 /* RESTRICTIONS/LIMITATIONS:                                         */
 368 /*                                                                   */
 369 /*                                                                   */
 370 /*********************************************************************/
 371 int mem_test_address(void)
 372 {
 373     volatile unsigned int * pmem = (volatile unsigned int *)CFG_SDRAM_BASE ;
 374     const unsigned int size = (CFG_SDRAM_SIZE * 1024 * 1024)/4;
 375     unsigned int i;
 376
 377     /* write address to each location */
 378     for ( i = 0; i < size; i++) {
 379         pmem[i] = i;
 380     }
 381
 382     /* verify each loaction */
 383     for ( i = 0; i < size; i++) {
 384         if (pmem[i] != i) {
 385             printf("\n   Address Test Failed at 0x%x", i);
 386             return 1;
 387         }
 388     }
 389     return 0;
 390 }
 391 #endif /* CFG_DRAM_TEST_ADDRESS */
 392
 393 #if defined (CFG_DRAM_TEST_WALK)
 394 /*********************************************************************/
 395 /* NAME:   mem_march() -  memory march                               */
 396 /*                                                                   */
 397 /* DESCRIPTION:                                                      */
 398 /*   Marches up through memory. At each location verifies rmask if   */
 399 /*   read = 1. At each location write wmask if  write = 1. Displays  */
 400 /*   failing address and pattern.                                    */
 401 /*                                                                   */
 402 /* INPUTS:                                                           */
 403 /*   volatile unsigned long long * base - start address of test      */
 404 /*   unsigned int size - number of dwords(64-bit) to test            */
 405 /*   unsigned long long rmask - read verify mask                     */
 406 /*   unsigned long long wmask - wrtie verify mask                    */
 407 /*   short read - verifies rmask if read = 1                         */
 408 /*   short write  - writes wmask if write = 1                        */
 409 /*                                                                   */
 410 /* OUTPUTS:                                                          */
 411 /*   Displays failing test pattern and address                       */
 412 /*                                                                   */
 413 /* RETURNS:                                                          */
 414 /*   0 -  Passed test                                                */
 415 /*   1 -  Failed test                                                */
 416 /*                                                                   */
 417 /* RESTRICTIONS/LIMITATIONS:                                         */
 418 /*                                                                   */
 419 /*                                                                   */
 420 /*********************************************************************/
 421 int mem_march(volatile unsigned long long * base,
 422               unsigned int size,
 423               unsigned long long rmask,
 424               unsigned long long wmask,
 425               short read,
 426               short write)
 427 {
 428     unsigned int i;
 429     unsigned long long temp;
 430     unsigned int hitemp, lotemp, himask, lomask;
 431
 432     for (i = 0 ; i < size ; i++) {
 433         if (read != 0) {
 434             /* temp = base[i]; */
 435             move64 ((unsigned long long *)&(base[i]), &temp);
 436             if (rmask != temp) {
 437                 hitemp = (temp>>32) & 0xffffffff;
 438                 lotemp = temp & 0xffffffff;
 439                 himask = (rmask>>32) & 0xffffffff;
 440                 lomask = rmask & 0xffffffff;
 441
 442                 printf("\n Walking one's test failed: address = 0x%08x,"
 443                        "\n\texpected 0x%08x%08x, found 0x%08x%08x",
 444                        i<<3, himask, lomask, hitemp, lotemp);
 445                 return 1;
 446             }
 447         }
 448         if ( write != 0 ) {
 449            /*  base[i] = wmask; */
 450             move64 (&wmask, (unsigned long long *)&(base[i]));
 451         }
 452     }
 453     return 0;
 454 }
 455 #endif /* CFG_DRAM_TEST_WALK */
 456
 457 /*********************************************************************/
 458 /* NAME:   mem_test_walk() -  a simple walking ones test             */
 459 /*                                                                   */
 460 /* DESCRIPTION:                                                      */
 461 /*   Performs a walking ones through entire physical memory. The     */
 462 /*   test uses as series of memory marches, mem_march(), to verify   */
 463 /*   and write the test patterns to memory. The test sequence is as  */
 464 /*   follows:                                                        */
 465 /*     1) march writing 0000...0001                                  */
 466 /*     2) march verifying 0000...0001  , writing  0000...0010        */
 467 /*     3) repeat step 2 shifting masks left 1 bit each time unitl    */
 468 /*         the write mask equals 1000...0000                         */
 469 /*     4) march verifying 1000...0000                                */
 470 /*   The test fails if any of the memory marches return a failure.   */
 471 /*                                                                   */
 472 /* OUTPUTS:                                                          */
 473 /*   Displays which pass on the memory test is executing             */
 474 /*                                                                   */
 475 /* RETURNS:                                                          */
 476 /*   0 -  Passed test                                                */
 477 /*   1 -  Failed test                                                */
 478 /*                                                                   */
 479 /* RESTRICTIONS/LIMITATIONS:                                         */
 480 /*                                                                   */
 481 /*                                                                   */
 482 /*********************************************************************/
 483 int mem_test_walk(void)
 484 {
 485     unsigned long long mask;
 486     volatile unsigned long long * pmem =
 487         (volatile unsigned long long *)CFG_SDRAM_BASE ;
 488     const unsigned long size = (CFG_SDRAM_SIZE * 1024 * 1024)/8;
 489
 490     unsigned int i;
 491     mask = 0x01;
 492
 493     printf("Initial Pass");
 494     mem_march(pmem,size,0x0,0x1,0,1);
 495
 496     printf("\b\b\b\b\b\b\b\b\b\b\b\b");
 497     printf("            ");
 498     printf("\b\b\b\b\b\b\b\b\b\b\b\b");
 499
 500     for (i = 0 ; i < 63 ; i++) {
 501         printf("Pass %2d", i+2);
 502         if ( mem_march(pmem,size, mask,mask << 1, 1, 1) != 0 ){
 503             /*printf("mask: 0x%x, pass: %d, ", mask, i);*/
 504             return 1;
 505         }
 506         mask = mask<<1;
 507         printf("\b\b\b\b\b\b\b");
 508     }
 509
 510     printf("Last Pass");
 511     if (mem_march(pmem, size, 0, mask, 0, 1) != 0) {
 512         /* printf("mask: 0x%x", mask); */
 513         return 1;
 514     }
 515     printf("\b\b\b\b\b\b\b\b\b");
 516     printf("         ");
 517     printf("\b\b\b\b\b\b\b\b\b");
 518
 519     return 0;
 520 }
 521
 522 /*********************************************************************/
 523 /* NAME:    testdram() -  calls any enabled memory tests             */
 524 /*                                                                   */
 525 /* DESCRIPTION:                                                      */
 526 /*   Runs memory tests if the environment test variables are set to  */
 527 /*   'y'.                                                            */
 528 /*                                                                   */
 529 /* INPUTS:                                                           */
 530 /*   testdramdata    - If set to 'y', data test is run.              */
 531 /*   testdramaddress - If set to 'y', address test is run.           */
 532 /*   testdramwalk    - If set to 'y', walking ones test is run       */
 533 /*                                                                   */
 534 /* OUTPUTS:                                                          */
 535 /*   None                                                            */
 536 /*                                                                   */
 537 /* RETURNS:                                                          */
 538 /*   0 -  Passed test                                                */
 539 /*   1 -  Failed test                                                */
 540 /*                                                                   */
 541 /* RESTRICTIONS/LIMITATIONS:                                         */
 542 /*                                                                   */
 543 /*                                                                   */
 544 /*********************************************************************/
 545 int testdram(void)
 546 {
 547     char *s;
 548     int rundata, runaddress, runwalk;
 549
 550     s = getenv ("testdramdata");
 551     rundata = (s && (*s == 'y')) ? 1 : 0;
 552     s = getenv ("testdramaddress");
 553     runaddress = (s && (*s == 'y')) ? 1 : 0;
 554     s = getenv ("testdramwalk");
 555     runwalk = (s && (*s == 'y')) ? 1 : 0;
 556
 557     if ((rundata == 1) || (runaddress == 1) || (runwalk == 1)) {
 558         printf("Testing RAM ... ");
 559     }
 560 #ifdef CFG_DRAM_TEST_DATA
 561     if (rundata == 1) {
 562         if (mem_test_data() == 1){
 563             return 1;
 564         }
 565     }
 566 #endif
 567 #ifdef CFG_DRAM_TEST_ADDRESS
 568     if (runaddress == 1) {
 569         if (mem_test_address() == 1){
 570             return 1;
 571         }
 572     }
 573 #endif
 574 #ifdef CFG_DRAM_TEST_WALK
 575     if (runwalk == 1) {
 576         if (mem_test_walk() == 1){
 577             return 1;
 578         }
 579     }
 580 #endif
 581     if ((rundata == 1) || (runaddress == 1) || (runwalk == 1)) {
 582         printf("passed");
 583     }
 584     return 0;
 585
 586 }
 587 #endif /* CFG_DRAM_TEST */
 588
 589 /*********************************************************************/
 590 /* NAME: initdram() -  initializes SDRAM controller                  */
 591 /*                                                                   */
 592 /* DESCRIPTION:                                                      */
 593 /*   Initializes the MPC8260's SDRAM controller.                     */
 594 /*                                                                   */
 595 /* INPUTS:                                                           */
 596 /*   CFG_IMMR       -  MPC8260 Internal memory map                   */
 597 /*   CFG_SDRAM_BASE -  Physical start address of SDRAM               */
 598 /*   CFG_PSDMR -       SDRAM mode register                           */
 599 /*   CFG_MPTPR -       Memory refresh timer prescaler register       */
 600 /*   CFG_SDRAM0_SIZE - SDRAM size                                    */
 601 /*                                                                   */
 602 /* RETURNS:                                                          */
 603 /*   SDRAM size in bytes                                             */
 604 /*                                                                   */
 605 /* RESTRICTIONS/LIMITATIONS:                                         */
 606 /*                                                                   */
 607 /*                                                                   */
 608 /*********************************************************************/
 609 long int initdram(int board_type)
 610 {
 611     volatile immap_t *immap  = (immap_t *)CFG_IMMR;
 612     volatile memctl8260_t *memctl = &immap->im_memctl;
 613     volatile uchar c = 0, *ramaddr = (uchar *)(CFG_SDRAM_BASE + 0x8);
 614     ulong psdmr = CFG_PSDMR;
 615     int i;
 616
 617     /*
 618      * Quote from 8260 UM (10.4.2 SDRAM Power-On Initialization, 10-35):
 619      *
 620      * "At system reset, initialization software must set up the
 621      *  programmable parameters in the memory controller banks registers
 622      *  (ORx, BRx, P/LSDMR). After all memory parameters are configured,
 623      *  system software should execute the following initialization sequence
 624      *  for each SDRAM device.
 625      *
 626      *  1. Issue a PRECHARGE-ALL-BANKS command
 627      *  2. Issue eight CBR REFRESH commands
 628      *  3. Issue a MODE-SET command to initialize the mode register
 629      *
 630      *  The initial commands are executed by setting P/LSDMR[OP] and
 631      *  accessing the SDRAM with a single-byte transaction."
 632      *
 633      * The appropriate BRx/ORx registers have already been set when we
 634      * get here. The SDRAM can be accessed at the address CFG_SDRAM_BASE.
 635      */
 636
 637     memctl->memc_psrt = CFG_PSRT;
 638     memctl->memc_mptpr = CFG_MPTPR;
 639
 640     memctl->memc_psdmr = psdmr | PSDMR_OP_PREA;
 641     *ramaddr = c;
 642
 643     memctl->memc_psdmr = psdmr | PSDMR_OP_CBRR;
 644     for (i = 0; i < 8; i++){
 645         *ramaddr = c;
 646     }
 647     memctl->memc_psdmr = psdmr | PSDMR_OP_MRW;
 648     *ramaddr = c;
 649
 650     memctl->memc_psdmr = psdmr | PSDMR_OP_NORM | PSDMR_RFEN;
 651     *ramaddr = c;
 652
 653     /* return total ram size */
 654     return (CFG_SDRAM0_SIZE * 1024 * 1024);
 655 }
 656
 657 /*********************************************************************/
 658 /*                         End of gw8260.c                           */
 659 /*********************************************************************/