arch/powerpc/cpu/ppc4xx/cpu.c

   1 /*
   2  * (C) Copyright 2000-2007
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 /*
  25  * CPU specific code
  26  *
  27  * written or collected and sometimes rewritten by
  28  * Magnus Damm <damm@bitsmart.com>
  29  *
  30  * minor modifications by
  31  * Wolfgang Denk <wd@denx.de>
  32  */
  33
  34 #include <common.h>
  35 #include <watchdog.h>
  36 #include <command.h>
  37 #include <asm/cache.h>
  38 #include <asm/ppc4xx.h>
  39 #include <netdev.h>
  40
  41 DECLARE_GLOBAL_DATA_PTR;
  42
  43 void board_reset(void);
  44
  45 /*
  46  * To provide an interface to detect CPU number for boards that support
  47  * more then one CPU, we implement the "weak" default functions here.
  48  *
  49  * Returns CPU number
  50  */
  51 int __get_cpu_num(void)
  52 {
  53         return NA_OR_UNKNOWN_CPU;
  54 }
  55 int get_cpu_num(void) __attribute__((weak, alias("__get_cpu_num")));
  56
  57 #if defined(CONFIG_PCI)
  58 #if defined(CONFIG_405GP) || \
  59     defined(CONFIG_440EP) || defined(CONFIG_440GR) || \
  60     defined(CONFIG_440EPX) || defined(CONFIG_440GRX)
  61
  62 #define PCI_ASYNC
  63
  64 static int pci_async_enabled(void)
  65 {
  66 #if defined(CONFIG_405GP)
  67         return (mfdcr(CPC0_PSR) & PSR_PCI_ASYNC_EN);
  68 #endif
  69
  70 #if defined(CONFIG_440EP) || defined(CONFIG_440GR) || \
  71     defined(CONFIG_440EPX) || defined(CONFIG_440GRX) || \
  72     defined(CONFIG_460EX) || defined(CONFIG_460GT)
  73         unsigned long val;
  74
  75         mfsdr(SDR0_SDSTP1, val);
  76         return (val & SDR0_SDSTP1_PAME_MASK);
  77 #endif
  78 }
  79 #endif
  80 #endif /* CONFIG_PCI */
  81
  82 #if defined(CONFIG_PCI) && !defined(CONFIG_IOP480) && \
  83     !defined(CONFIG_405) && !defined(CONFIG_405EX)
  84 int pci_arbiter_enabled(void)
  85 {
  86 #if defined(CONFIG_405GP)
  87         return (mfdcr(CPC0_PSR) & PSR_PCI_ARBIT_EN);
  88 #endif
  89
  90 #if defined(CONFIG_405EP)
  91         return (mfdcr(CPC0_PCI) & CPC0_PCI_ARBIT_EN);
  92 #endif
  93
  94 #if defined(CONFIG_440GP)
  95         return (mfdcr(CPC0_STRP1) & CPC0_STRP1_PAE_MASK);
  96 #endif
  97
  98 #if defined(CONFIG_440GX) || defined(CONFIG_440SP) || defined(CONFIG_440SPE)
  99         unsigned long val;
 100
 101         mfsdr(SDR0_XCR0, val);
 102         return (val & SDR0_XCR0_PAE_MASK);
 103 #endif
 104 #if defined(CONFIG_440EP) || defined(CONFIG_440GR) || \
 105     defined(CONFIG_440EPX) || defined(CONFIG_440GRX) || \
 106     defined(CONFIG_460EX) || defined(CONFIG_460GT)
 107         unsigned long val;
 108
 109         mfsdr(SDR0_PCI0, val);
 110         return (val & SDR0_PCI0_PAE_MASK);
 111 #endif
 112 }
 113 #endif
 114
 115 #if defined(CONFIG_405EP)
 116 #define I2C_BOOTROM
 117
 118 static int i2c_bootrom_enabled(void)
 119 {
 120 #if defined(CONFIG_405EP)
 121         return (mfdcr(CPC0_BOOT) & CPC0_BOOT_SEP);
 122 #else
 123         unsigned long val;
 124
 125         mfsdr(SDR0_SDCS0, val);
 126         return (val & SDR0_SDCS_SDD);
 127 #endif
 128 }
 129 #endif
 130
 131 #if defined(CONFIG_440GX)
 132 #define SDR0_PINSTP_SHIFT       29
 133 static char *bootstrap_str[] = {
 134         "EBC (16 bits)",
 135         "EBC (8 bits)",
 136         "EBC (32 bits)",
 137         "EBC (8 bits)",
 138         "PCI",
 139         "I2C (Addr 0x54)",
 140         "Reserved",
 141         "I2C (Addr 0x50)",
 142 };
 143 static char bootstrap_char[] = { 'A', 'B', 'C', 'B', 'D', 'E', 'x', 'F' };
 144 #endif
 145
 146 #if defined(CONFIG_440SP) || defined(CONFIG_440SPE)
 147 #define SDR0_PINSTP_SHIFT       30
 148 static char *bootstrap_str[] = {
 149         "EBC (8 bits)",
 150         "PCI",
 151         "I2C (Addr 0x54)",
 152         "I2C (Addr 0x50)",
 153 };
 154 static char bootstrap_char[] = { 'A', 'B', 'C', 'D'};
 155 #endif
 156
 157 #if defined(CONFIG_440EP) || defined(CONFIG_440GR)
 158 #define SDR0_PINSTP_SHIFT       29
 159 static char *bootstrap_str[] = {
 160         "EBC (8 bits)",
 161         "PCI",
 162         "NAND (8 bits)",
 163         "EBC (16 bits)",
 164         "EBC (16 bits)",
 165         "I2C (Addr 0x54)",
 166         "PCI",
 167         "I2C (Addr 0x52)",
 168 };
 169 static char bootstrap_char[] = { 'A', 'B', 'C', 'D', 'E', 'G', 'F', 'H' };
 170 #endif
 171
 172 #if defined(CONFIG_440EPX) || defined(CONFIG_440GRX)
 173 #define SDR0_PINSTP_SHIFT       29
 174 static char *bootstrap_str[] = {
 175         "EBC (8 bits)",
 176         "EBC (16 bits)",
 177         "EBC (16 bits)",
 178         "NAND (8 bits)",
 179         "PCI",
 180         "I2C (Addr 0x54)",
 181         "PCI",
 182         "I2C (Addr 0x52)",
 183 };
 184 static char bootstrap_char[] = { 'A', 'B', 'C', 'D', 'E', 'G', 'F', 'H' };
 185 #endif
 186
 187 #if defined(CONFIG_460EX) || defined(CONFIG_460GT)
 188 #define SDR0_PINSTP_SHIFT       29
 189 static char *bootstrap_str[] = {
 190         "EBC (8 bits)",
 191         "EBC (16 bits)",
 192         "PCI",
 193         "PCI",
 194         "EBC (16 bits)",
 195         "NAND (8 bits)",
 196         "I2C (Addr 0x54)",      /* A8 */
 197         "I2C (Addr 0x52)",      /* A4 */
 198 };
 199 static char bootstrap_char[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
 200 #endif
 201
 202 #if defined(CONFIG_460SX)
 203 #define SDR0_PINSTP_SHIFT       29
 204 static char *bootstrap_str[] = {
 205         "EBC (8 bits)",
 206         "EBC (16 bits)",
 207         "EBC (32 bits)",
 208         "NAND (8 bits)",
 209         "I2C (Addr 0x54)",      /* A8 */
 210         "I2C (Addr 0x52)",      /* A4 */
 211 };
 212 static char bootstrap_char[] = { 'A', 'B', 'C', 'D', 'E', 'G' };
 213 #endif
 214
 215 #if defined(CONFIG_405EZ)
 216 #define SDR0_PINSTP_SHIFT       28
 217 static char *bootstrap_str[] = {
 218         "EBC (8 bits)",
 219         "SPI (fast)",
 220         "NAND (512 page, 4 addr cycle)",
 221         "I2C (Addr 0x50)",
 222         "EBC (32 bits)",
 223         "I2C (Addr 0x50)",
 224         "NAND (2K page, 5 addr cycle)",
 225         "I2C (Addr 0x50)",
 226         "EBC (16 bits)",
 227         "Reserved",
 228         "NAND (2K page, 4 addr cycle)",
 229         "I2C (Addr 0x50)",
 230         "NAND (512 page, 3 addr cycle)",
 231         "I2C (Addr 0x50)",
 232         "SPI (slow)",
 233         "I2C (Addr 0x50)",
 234 };
 235 static char bootstrap_char[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', \
 236                                  'I', 'x', 'K', 'L', 'M', 'N', 'O', 'P' };
 237 #endif
 238
 239 #if defined(CONFIG_405EX)
 240 #define SDR0_PINSTP_SHIFT       29
 241 static char *bootstrap_str[] = {
 242         "EBC (8 bits)",
 243         "EBC (16 bits)",
 244         "EBC (16 bits)",
 245         "NAND (8 bits)",
 246         "NAND (8 bits)",
 247         "I2C (Addr 0x54)",
 248         "EBC (8 bits)",
 249         "I2C (Addr 0x52)",
 250 };
 251 static char bootstrap_char[] = { 'A', 'B', 'C', 'D', 'E', 'G', 'F', 'H' };
 252 #endif
 253
 254 #if defined(SDR0_PINSTP_SHIFT)
 255 static int bootstrap_option(void)
 256 {
 257         unsigned long val;
 258
 259         mfsdr(SDR0_PINSTP, val);
 260         return ((val & 0xf0000000) >> SDR0_PINSTP_SHIFT);
 261 }
 262 #endif /* SDR0_PINSTP_SHIFT */
 263
 264
 265 #if defined(CONFIG_440GP)
 266 static int do_chip_reset (unsigned long sys0, unsigned long sys1)
 267 {
 268         /* Changes to CPC0_SYS0 and CPC0_SYS1 require chip
 269          * reset.
 270          */
 271         mtdcr (CPC0_CR0, mfdcr (CPC0_CR0) | 0x80000000);        /* Set SWE */
 272         mtdcr (CPC0_SYS0, sys0);
 273         mtdcr (CPC0_SYS1, sys1);
 274         mtdcr (CPC0_CR0, mfdcr (CPC0_CR0) & ~0x80000000);       /* Clr SWE */
 275         mtspr (SPRN_DBCR0, 0x20000000); /* Reset the chip */
 276
 277         return 1;
 278 }
 279 #endif /* CONFIG_440GP */
 280
 281
 282 int checkcpu (void)
 283 {
 284 #if !defined(CONFIG_405)        /* not used on Xilinx 405 FPGA implementations */
 285         uint pvr = get_pvr();
 286         ulong clock = gd->cpu_clk;
 287         char buf[32];
 288 #if defined(CONFIG_460EX) || defined(CONFIG_460GT)
 289         u32 reg;
 290 #endif
 291
 292 #if !defined(CONFIG_IOP480)
 293         char addstr[64] = "";
 294         sys_info_t sys_info;
 295         int cpu_num;
 296
 297         cpu_num = get_cpu_num();
 298         if (cpu_num >= 0)
 299                 printf("CPU%d:  ", cpu_num);
 300         else
 301                 puts("CPU:   ");
 302
 303         get_sys_info(&sys_info);
 304
 305 #if defined(CONFIG_XILINX_440)
 306         puts("IBM PowerPC 4");
 307 #else
 308         puts("AMCC PowerPC 4");
 309 #endif
 310
 311 #if defined(CONFIG_405GP) || defined(CONFIG_405CR) || \
 312     defined(CONFIG_405EP) || defined(CONFIG_405EZ) || \
 313     defined(CONFIG_405EX)
 314         puts("05");
 315 #endif
 316 #if defined(CONFIG_440)
 317 #if defined(CONFIG_460EX) || defined(CONFIG_460GT)
 318         puts("60");
 319 #else
 320         puts("40");
 321 #endif
 322 #endif
 323
 324         switch (pvr) {
 325         case PVR_405GP_RB:
 326                 puts("GP Rev. B");
 327                 break;
 328
 329         case PVR_405GP_RC:
 330                 puts("GP Rev. C");
 331                 break;
 332
 333         case PVR_405GP_RD:
 334                 puts("GP Rev. D");
 335                 break;
 336
 337 #ifdef CONFIG_405GP
 338         case PVR_405GP_RE: /* 405GP rev E and 405CR rev C have same PVR */
 339                 puts("GP Rev. E");
 340                 break;
 341 #endif
 342
 343         case PVR_405CR_RA:
 344                 puts("CR Rev. A");
 345                 break;
 346
 347         case PVR_405CR_RB:
 348                 puts("CR Rev. B");
 349                 break;
 350
 351 #ifdef CONFIG_405CR
 352         case PVR_405CR_RC: /* 405GP rev E and 405CR rev C have same PVR */
 353                 puts("CR Rev. C");
 354                 break;
 355 #endif
 356
 357         case PVR_405GPR_RB:
 358                 puts("GPr Rev. B");
 359                 break;
 360
 361         case PVR_405EP_RB:
 362                 puts("EP Rev. B");
 363                 break;
 364
 365         case PVR_405EZ_RA:
 366                 puts("EZ Rev. A");
 367                 break;
 368
 369         case PVR_405EX1_RA:
 370                 puts("EX Rev. A");
 371                 strcpy(addstr, "Security support");
 372                 break;
 373
 374         case PVR_405EXR2_RA:
 375                 puts("EXr Rev. A");
 376                 strcpy(addstr, "No Security support");
 377                 break;
 378
 379         case PVR_405EX1_RC:
 380                 puts("EX Rev. C");
 381                 strcpy(addstr, "Security support");
 382                 break;
 383
 384         case PVR_405EX2_RC:
 385                 puts("EX Rev. C");
 386                 strcpy(addstr, "No Security support");
 387                 break;
 388
 389         case PVR_405EXR1_RC:
 390                 puts("EXr Rev. C");
 391                 strcpy(addstr, "Security support");
 392                 break;
 393
 394         case PVR_405EXR2_RC:
 395                 puts("EXr Rev. C");
 396                 strcpy(addstr, "No Security support");
 397                 break;
 398
 399         case PVR_405EX1_RD:
 400                 puts("EX Rev. D");
 401                 strcpy(addstr, "Security support");
 402                 break;
 403
 404         case PVR_405EX2_RD:
 405                 puts("EX Rev. D");
 406                 strcpy(addstr, "No Security support");
 407                 break;
 408
 409         case PVR_405EXR1_RD:
 410                 puts("EXr Rev. D");
 411                 strcpy(addstr, "Security support");
 412                 break;
 413
 414         case PVR_405EXR2_RD:
 415                 puts("EXr Rev. D");
 416                 strcpy(addstr, "No Security support");
 417                 break;
 418
 419 #if defined(CONFIG_440)
 420 #if defined(CONFIG_440GP)
 421         case PVR_440GP_RB:
 422                 puts("GP Rev. B");
 423                 /* See errata 1.12: CHIP_4 */
 424                 if ((mfdcr(CPC0_SYS0) != mfdcr(CPC0_STRP0)) ||
 425                     (mfdcr(CPC0_SYS1) != mfdcr(CPC0_STRP1)) ){
 426                         puts (  "\n\t CPC0_SYSx DCRs corrupted. "
 427                                 "Resetting chip ...\n");
 428                         udelay( 1000 * 1000 ); /* Give time for serial buf to clear */
 429                         do_chip_reset ( mfdcr(CPC0_STRP0),
 430                                         mfdcr(CPC0_STRP1) );
 431                 }
 432                 break;
 433
 434         case PVR_440GP_RC:
 435                 puts("GP Rev. C");
 436                 break;
 437 #endif /* CONFIG_440GP */
 438
 439         case PVR_440GX_RA:
 440                 puts("GX Rev. A");
 441                 break;
 442
 443         case PVR_440GX_RB:
 444                 puts("GX Rev. B");
 445                 break;
 446
 447         case PVR_440GX_RC:
 448                 puts("GX Rev. C");
 449                 break;
 450
 451         case PVR_440GX_RF:
 452                 puts("GX Rev. F");
 453                 break;
 454
 455         case PVR_440EP_RA:
 456                 puts("EP Rev. A");
 457                 break;
 458
 459 #ifdef CONFIG_440EP
 460         case PVR_440EP_RB: /* 440EP rev B and 440GR rev A have same PVR */
 461                 puts("EP Rev. B");
 462                 break;
 463
 464         case PVR_440EP_RC: /* 440EP rev C and 440GR rev B have same PVR */
 465                 puts("EP Rev. C");
 466                 break;
 467 #endif /*  CONFIG_440EP */
 468
 469 #ifdef CONFIG_440GR
 470         case PVR_440GR_RA: /* 440EP rev B and 440GR rev A have same PVR */
 471                 puts("GR Rev. A");
 472                 break;
 473
 474         case PVR_440GR_RB: /* 440EP rev C and 440GR rev B have same PVR */
 475                 puts("GR Rev. B");
 476                 break;
 477 #endif /* CONFIG_440GR */
 478 #endif /* CONFIG_440 */
 479
 480 #ifdef CONFIG_440EPX
 481         case PVR_440EPX1_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 482                 puts("EPx Rev. A");
 483                 strcpy(addstr, "Security/Kasumi support");
 484                 break;
 485
 486         case PVR_440EPX2_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 487                 puts("EPx Rev. A");
 488                 strcpy(addstr, "No Security/Kasumi support");
 489                 break;
 490 #endif /* CONFIG_440EPX */
 491
 492 #ifdef CONFIG_440GRX
 493         case PVR_440GRX1_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 494                 puts("GRx Rev. A");
 495                 strcpy(addstr, "Security/Kasumi support");
 496                 break;
 497
 498         case PVR_440GRX2_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 499                 puts("GRx Rev. A");
 500                 strcpy(addstr, "No Security/Kasumi support");
 501                 break;
 502 #endif /* CONFIG_440GRX */
 503
 504         case PVR_440SP_6_RAB:
 505                 puts("SP Rev. A/B");
 506                 strcpy(addstr, "RAID 6 support");
 507                 break;
 508
 509         case PVR_440SP_RAB:
 510                 puts("SP Rev. A/B");
 511                 strcpy(addstr, "No RAID 6 support");
 512                 break;
 513
 514         case PVR_440SP_6_RC:
 515                 puts("SP Rev. C");
 516                 strcpy(addstr, "RAID 6 support");
 517                 break;
 518
 519         case PVR_440SP_RC:
 520                 puts("SP Rev. C");
 521                 strcpy(addstr, "No RAID 6 support");
 522                 break;
 523
 524         case PVR_440SPe_6_RA:
 525                 puts("SPe Rev. A");
 526                 strcpy(addstr, "RAID 6 support");
 527                 break;
 528
 529         case PVR_440SPe_RA:
 530                 puts("SPe Rev. A");
 531                 strcpy(addstr, "No RAID 6 support");
 532                 break;
 533
 534         case PVR_440SPe_6_RB:
 535                 puts("SPe Rev. B");
 536                 strcpy(addstr, "RAID 6 support");
 537                 break;
 538
 539         case PVR_440SPe_RB:
 540                 puts("SPe Rev. B");
 541                 strcpy(addstr, "No RAID 6 support");
 542                 break;
 543
 544 #if defined(CONFIG_460EX) || defined(CONFIG_460GT)
 545         case PVR_460EX_RA:
 546                 puts("EX Rev. A");
 547                 strcpy(addstr, "No Security/Kasumi support");
 548                 break;
 549
 550         case PVR_460EX_SE_RA:
 551                 puts("EX Rev. A");
 552                 strcpy(addstr, "Security/Kasumi support");
 553                 break;
 554
 555         case PVR_460EX_RB:
 556                 puts("EX Rev. B");
 557                 mfsdr(SDR0_ECID3, reg);
 558                 if (reg & 0x00100000)
 559                         strcpy(addstr, "No Security/Kasumi support");
 560                 else
 561                         strcpy(addstr, "Security/Kasumi support");
 562                 break;
 563
 564         case PVR_460GT_RA:
 565                 puts("GT Rev. A");
 566                 strcpy(addstr, "No Security/Kasumi support");
 567                 break;
 568
 569         case PVR_460GT_SE_RA:
 570                 puts("GT Rev. A");
 571                 strcpy(addstr, "Security/Kasumi support");
 572                 break;
 573
 574         case PVR_460GT_RB:
 575                 puts("GT Rev. B");
 576                 mfsdr(SDR0_ECID3, reg);
 577                 if (reg & 0x00100000)
 578                         strcpy(addstr, "No Security/Kasumi support");
 579                 else
 580                         strcpy(addstr, "Security/Kasumi support");
 581                 break;
 582 #endif
 583
 584         case PVR_460SX_RA:
 585                 puts("SX Rev. A");
 586                 strcpy(addstr, "Security support");
 587                 break;
 588
 589         case PVR_460SX_RA_V1:
 590                 puts("SX Rev. A");
 591                 strcpy(addstr, "No Security support");
 592                 break;
 593
 594         case PVR_460GX_RA:
 595                 puts("GX Rev. A");
 596                 strcpy(addstr, "Security support");
 597                 break;
 598
 599         case PVR_460GX_RA_V1:
 600                 puts("GX Rev. A");
 601                 strcpy(addstr, "No Security support");
 602                 break;
 603
 604         case PVR_VIRTEX5:
 605                 puts("x5 VIRTEX5");
 606                 break;
 607
 608         default:
 609                 printf (" UNKNOWN (PVR=%08x)", pvr);
 610                 break;
 611         }
 612
 613         printf (" at %s MHz (PLB=%lu OPB=%lu EBC=%lu",
 614                 strmhz(buf, clock),
 615                 sys_info.freqPLB / 1000000,
 616                 get_OPB_freq() / 1000000,
 617                 sys_info.freqEBC / 1000000);
 618 #if defined(CONFIG_PCI) && \
 619         (defined(CONFIG_440EP) || defined(CONFIG_440EPX) || \
 620          defined(CONFIG_440GR) || defined(CONFIG_440GRX))
 621         printf(" PCI=%lu MHz", sys_info.freqPCI / 1000000);
 622 #endif
 623         printf(")\n");
 624
 625         if (addstr[0] != 0)
 626                 printf("       %s\n", addstr);
 627
 628 #if defined(I2C_BOOTROM)
 629         printf ("       I2C boot EEPROM %sabled\n", i2c_bootrom_enabled() ? "en" : "dis");
 630 #endif  /* I2C_BOOTROM */
 631 #if defined(SDR0_PINSTP_SHIFT)
 632         printf ("       Bootstrap Option %c - ", bootstrap_char[bootstrap_option()]);
 633         printf ("Boot ROM Location %s", bootstrap_str[bootstrap_option()]);
 634 #ifdef CONFIG_NAND_U_BOOT
 635         puts(", booting from NAND");
 636 #endif /* CONFIG_NAND_U_BOOT */
 637         putc('\n');
 638 #endif  /* SDR0_PINSTP_SHIFT */
 639
 640 #if defined(CONFIG_PCI) && !defined(CONFIG_405EX)
 641         printf ("       Internal PCI arbiter %sabled", pci_arbiter_enabled() ? "en" : "dis");
 642 #endif
 643
 644 #if defined(CONFIG_PCI) && defined(PCI_ASYNC)
 645         if (pci_async_enabled()) {
 646                 printf (", PCI async ext clock used");
 647         } else {
 648                 printf (", PCI sync clock at %lu MHz",
 649                        sys_info.freqPLB / sys_info.pllPciDiv / 1000000);
 650         }
 651 #endif
 652
 653 #if defined(CONFIG_PCI) && !defined(CONFIG_405EX)
 654         putc('\n');
 655 #endif
 656
 657 #if defined(CONFIG_405EP) || defined(CONFIG_405EZ) || defined(CONFIG_405EX)
 658         printf ("       16 kB I-Cache 16 kB D-Cache");
 659 #elif defined(CONFIG_440)
 660         printf ("       32 kB I-Cache 32 kB D-Cache");
 661 #else
 662         printf ("       16 kB I-Cache %d kB D-Cache",
 663                 ((pvr | 0x00000001) == PVR_405GPR_RB) ? 16 : 8);
 664 #endif
 665 #endif /* !defined(CONFIG_IOP480) */
 666
 667 #if defined(CONFIG_IOP480)
 668         printf ("PLX IOP480 (PVR=%08x)", pvr);
 669         printf (" at %s MHz:", strmhz(buf, clock));
 670         printf (" %u kB I-Cache", 4);
 671         printf (" %u kB D-Cache", 2);
 672 #endif
 673
 674 #endif /* !defined(CONFIG_405) */
 675
 676         putc ('\n');
 677
 678         return 0;
 679 }
 680
 681 int ppc440spe_revB() {
 682         unsigned int pvr;
 683
 684         pvr = get_pvr();
 685         if ((pvr == PVR_440SPe_6_RB) || (pvr == PVR_440SPe_RB))
 686                 return 1;
 687         else
 688                 return 0;
 689 }
 690
 691 /* ------------------------------------------------------------------------- */
 692
 693 int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 694 {
 695 #if defined(CONFIG_BOARD_RESET)
 696         board_reset();
 697 #else
 698 #if defined(CONFIG_SYS_4xx_RESET_TYPE)
 699         mtspr(SPRN_DBCR0, CONFIG_SYS_4xx_RESET_TYPE << 28);
 700 #else
 701         /*
 702          * Initiate system reset in debug control register DBCR
 703          */
 704         mtspr(SPRN_DBCR0, 0x30000000);
 705 #endif /* defined(CONFIG_SYS_4xx_RESET_TYPE) */
 706 #endif /* defined(CONFIG_BOARD_RESET) */
 707
 708         return 1;
 709 }
 710
 711
 712 /*
 713  * Get timebase clock frequency
 714  */
 715 unsigned long get_tbclk (void)
 716 {
 717 #if !defined(CONFIG_IOP480)
 718         sys_info_t  sys_info;
 719
 720         get_sys_info(&sys_info);
 721         return (sys_info.freqProcessor);
 722 #else
 723         return (66000000);
 724 #endif
 725
 726 }
 727
 728
 729 #if defined(CONFIG_WATCHDOG)
 730 void watchdog_reset(void)
 731 {
 732         int re_enable = disable_interrupts();
 733         reset_4xx_watchdog();
 734         if (re_enable) enable_interrupts();
 735 }
 736
 737 void reset_4xx_watchdog(void)
 738 {
 739         /*
 740          * Clear TSR(WIS) bit
 741          */
 742         mtspr(SPRN_TSR, 0x40000000);
 743 }
 744 #endif  /* CONFIG_WATCHDOG */
 745
 746 /*
 747  * Initializes on-chip ethernet controllers.
 748  * to override, implement board_eth_init()
 749  */
 750 int cpu_eth_init(bd_t *bis)
 751 {
 752 #if defined(CONFIG_PPC4xx_EMAC)
 753         ppc_4xx_eth_initialize(bis);
 754 #endif
 755         return 0;
 756 }