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 ");
 307 #else
 308         puts("AMCC PowerPC ");
 309 #endif
 310
 311         switch (pvr) {
 312
 313 #if !defined(CONFIG_440)
 314         case PVR_405GP_RB:
 315                 puts("405GP Rev. B");
 316                 break;
 317
 318         case PVR_405GP_RC:
 319                 puts("405GP Rev. C");
 320                 break;
 321
 322         case PVR_405GP_RD:
 323                 puts("405GP Rev. D");
 324                 break;
 325
 326 #ifdef CONFIG_405GP
 327         case PVR_405GP_RE: /* 405GP rev E and 405CR rev C have same PVR */
 328                 puts("405GP Rev. E");
 329                 break;
 330 #endif
 331
 332         case PVR_405CR_RA:
 333                 puts("405CR Rev. A");
 334                 break;
 335
 336         case PVR_405CR_RB:
 337                 puts("405CR Rev. B");
 338                 break;
 339
 340 #ifdef CONFIG_405CR
 341         case PVR_405CR_RC: /* 405GP rev E and 405CR rev C have same PVR */
 342                 puts("405CR Rev. C");
 343                 break;
 344 #endif
 345
 346         case PVR_405GPR_RB:
 347                 puts("405GPr Rev. B");
 348                 break;
 349
 350         case PVR_405EP_RB:
 351                 puts("405EP Rev. B");
 352                 break;
 353
 354         case PVR_405EZ_RA:
 355                 puts("405EZ Rev. A");
 356                 break;
 357
 358         case PVR_405EX1_RA:
 359                 puts("405EX Rev. A");
 360                 strcpy(addstr, "Security support");
 361                 break;
 362
 363         case PVR_405EXR2_RA:
 364                 puts("405EXr Rev. A");
 365                 strcpy(addstr, "No Security support");
 366                 break;
 367
 368         case PVR_405EX1_RC:
 369                 puts("405EX Rev. C");
 370                 strcpy(addstr, "Security support");
 371                 break;
 372
 373         case PVR_405EX2_RC:
 374                 puts("405EX Rev. C");
 375                 strcpy(addstr, "No Security support");
 376                 break;
 377
 378         case PVR_405EXR1_RC:
 379                 puts("405EXr Rev. C");
 380                 strcpy(addstr, "Security support");
 381                 break;
 382
 383         case PVR_405EXR2_RC:
 384                 puts("405EXr Rev. C");
 385                 strcpy(addstr, "No Security support");
 386                 break;
 387
 388         case PVR_405EX1_RD:
 389                 puts("405EX Rev. D");
 390                 strcpy(addstr, "Security support");
 391                 break;
 392
 393         case PVR_405EX2_RD:
 394                 puts("405EX Rev. D");
 395                 strcpy(addstr, "No Security support");
 396                 break;
 397
 398         case PVR_405EXR1_RD:
 399                 puts("405EXr Rev. D");
 400                 strcpy(addstr, "Security support");
 401                 break;
 402
 403         case PVR_405EXR2_RD:
 404                 puts("405EXr Rev. D");
 405                 strcpy(addstr, "No Security support");
 406                 break;
 407
 408 #else /* CONFIG_440 */
 409
 410 #if defined(CONFIG_440GP)
 411         case PVR_440GP_RB:
 412                 puts("440GP Rev. B");
 413                 /* See errata 1.12: CHIP_4 */
 414                 if ((mfdcr(CPC0_SYS0) != mfdcr(CPC0_STRP0)) ||
 415                     (mfdcr(CPC0_SYS1) != mfdcr(CPC0_STRP1)) ){
 416                         puts (  "\n\t CPC0_SYSx DCRs corrupted. "
 417                                 "Resetting chip ...\n");
 418                         udelay( 1000 * 1000 ); /* Give time for serial buf to clear */
 419                         do_chip_reset ( mfdcr(CPC0_STRP0),
 420                                         mfdcr(CPC0_STRP1) );
 421                 }
 422                 break;
 423
 424         case PVR_440GP_RC:
 425                 puts("440GP Rev. C");
 426                 break;
 427 #endif /* CONFIG_440GP */
 428
 429         case PVR_440GX_RA:
 430                 puts("440GX Rev. A");
 431                 break;
 432
 433         case PVR_440GX_RB:
 434                 puts("440GX Rev. B");
 435                 break;
 436
 437         case PVR_440GX_RC:
 438                 puts("440GX Rev. C");
 439                 break;
 440
 441         case PVR_440GX_RF:
 442                 puts("440GX Rev. F");
 443                 break;
 444
 445         case PVR_440EP_RA:
 446                 puts("440EP Rev. A");
 447                 break;
 448
 449 #ifdef CONFIG_440EP
 450         case PVR_440EP_RB: /* 440EP rev B and 440GR rev A have same PVR */
 451                 puts("440EP Rev. B");
 452                 break;
 453
 454         case PVR_440EP_RC: /* 440EP rev C and 440GR rev B have same PVR */
 455                 puts("440EP Rev. C");
 456                 break;
 457 #endif /*  CONFIG_440EP */
 458
 459 #ifdef CONFIG_440GR
 460         case PVR_440GR_RA: /* 440EP rev B and 440GR rev A have same PVR */
 461                 puts("440GR Rev. A");
 462                 break;
 463
 464         case PVR_440GR_RB: /* 440EP rev C and 440GR rev B have same PVR */
 465                 puts("440GR Rev. B");
 466                 break;
 467 #endif /* CONFIG_440GR */
 468
 469 #ifdef CONFIG_440EPX
 470         case PVR_440EPX1_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 471                 puts("440EPx Rev. A");
 472                 strcpy(addstr, "Security/Kasumi support");
 473                 break;
 474
 475         case PVR_440EPX2_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 476                 puts("440EPx Rev. A");
 477                 strcpy(addstr, "No Security/Kasumi support");
 478                 break;
 479 #endif /* CONFIG_440EPX */
 480
 481 #ifdef CONFIG_440GRX
 482         case PVR_440GRX1_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 483                 puts("440GRx Rev. A");
 484                 strcpy(addstr, "Security/Kasumi support");
 485                 break;
 486
 487         case PVR_440GRX2_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 488                 puts("440GRx Rev. A");
 489                 strcpy(addstr, "No Security/Kasumi support");
 490                 break;
 491 #endif /* CONFIG_440GRX */
 492
 493         case PVR_440SP_6_RAB:
 494                 puts("440SP Rev. A/B");
 495                 strcpy(addstr, "RAID 6 support");
 496                 break;
 497
 498         case PVR_440SP_RAB:
 499                 puts("440SP Rev. A/B");
 500                 strcpy(addstr, "No RAID 6 support");
 501                 break;
 502
 503         case PVR_440SP_6_RC:
 504                 puts("440SP Rev. C");
 505                 strcpy(addstr, "RAID 6 support");
 506                 break;
 507
 508         case PVR_440SP_RC:
 509                 puts("440SP Rev. C");
 510                 strcpy(addstr, "No RAID 6 support");
 511                 break;
 512
 513         case PVR_440SPe_6_RA:
 514                 puts("440SPe Rev. A");
 515                 strcpy(addstr, "RAID 6 support");
 516                 break;
 517
 518         case PVR_440SPe_RA:
 519                 puts("440SPe Rev. A");
 520                 strcpy(addstr, "No RAID 6 support");
 521                 break;
 522
 523         case PVR_440SPe_6_RB:
 524                 puts("440SPe Rev. B");
 525                 strcpy(addstr, "RAID 6 support");
 526                 break;
 527
 528         case PVR_440SPe_RB:
 529                 puts("440SPe Rev. B");
 530                 strcpy(addstr, "No RAID 6 support");
 531                 break;
 532
 533 #if defined(CONFIG_460EX) || defined(CONFIG_460GT)
 534         case PVR_460EX_RA:
 535                 puts("460EX Rev. A");
 536                 strcpy(addstr, "No Security/Kasumi support");
 537                 break;
 538
 539         case PVR_460EX_SE_RA:
 540                 puts("460EX Rev. A");
 541                 strcpy(addstr, "Security/Kasumi support");
 542                 break;
 543
 544         case PVR_460EX_RB:
 545                 puts("460EX Rev. B");
 546                 mfsdr(SDR0_ECID3, reg);
 547                 if (reg & 0x00100000)
 548                         strcpy(addstr, "No Security/Kasumi support");
 549                 else
 550                         strcpy(addstr, "Security/Kasumi support");
 551                 break;
 552
 553         case PVR_460GT_RA:
 554                 puts("460GT Rev. A");
 555                 strcpy(addstr, "No Security/Kasumi support");
 556                 break;
 557
 558         case PVR_460GT_SE_RA:
 559                 puts("460GT Rev. A");
 560                 strcpy(addstr, "Security/Kasumi support");
 561                 break;
 562
 563         case PVR_460GT_RB:
 564                 puts("460GT Rev. B");
 565                 mfsdr(SDR0_ECID3, reg);
 566                 if (reg & 0x00100000)
 567                         strcpy(addstr, "No Security/Kasumi support");
 568                 else
 569                         strcpy(addstr, "Security/Kasumi support");
 570                 break;
 571 #endif
 572
 573         case PVR_460SX_RA:
 574                 puts("460SX Rev. A");
 575                 strcpy(addstr, "Security support");
 576                 break;
 577
 578         case PVR_460SX_RA_V1:
 579                 puts("460SX Rev. A");
 580                 strcpy(addstr, "No Security support");
 581                 break;
 582
 583         case PVR_460GX_RA:
 584                 puts("460GX Rev. A");
 585                 strcpy(addstr, "Security support");
 586                 break;
 587
 588         case PVR_460GX_RA_V1:
 589                 puts("460GX Rev. A");
 590                 strcpy(addstr, "No Security support");
 591                 break;
 592
 593         case PVR_VIRTEX5:
 594                 puts("440x5 VIRTEX5");
 595                 break;
 596 #endif /* CONFIG_440 */
 597
 598         default:
 599                 printf (" UNKNOWN (PVR=%08x)", pvr);
 600                 break;
 601         }
 602
 603         printf (" at %s MHz (PLB=%lu OPB=%lu EBC=%lu",
 604                 strmhz(buf, clock),
 605                 sys_info.freqPLB / 1000000,
 606                 get_OPB_freq() / 1000000,
 607                 sys_info.freqEBC / 1000000);
 608 #if defined(CONFIG_PCI) && \
 609         (defined(CONFIG_440EP) || defined(CONFIG_440EPX) || \
 610          defined(CONFIG_440GR) || defined(CONFIG_440GRX))
 611         printf(" PCI=%lu MHz", sys_info.freqPCI / 1000000);
 612 #endif
 613         printf(")\n");
 614
 615         if (addstr[0] != 0)
 616                 printf("       %s\n", addstr);
 617
 618 #if defined(I2C_BOOTROM)
 619         printf ("       I2C boot EEPROM %sabled\n", i2c_bootrom_enabled() ? "en" : "dis");
 620 #endif  /* I2C_BOOTROM */
 621 #if defined(SDR0_PINSTP_SHIFT)
 622         printf ("       Bootstrap Option %c - ", bootstrap_char[bootstrap_option()]);
 623         printf ("Boot ROM Location %s", bootstrap_str[bootstrap_option()]);
 624 #ifdef CONFIG_NAND_U_BOOT
 625         puts(", booting from NAND");
 626 #endif /* CONFIG_NAND_U_BOOT */
 627         putc('\n');
 628 #endif  /* SDR0_PINSTP_SHIFT */
 629
 630 #if defined(CONFIG_PCI) && !defined(CONFIG_405EX)
 631         printf ("       Internal PCI arbiter %sabled", pci_arbiter_enabled() ? "en" : "dis");
 632 #endif
 633
 634 #if defined(CONFIG_PCI) && defined(PCI_ASYNC)
 635         if (pci_async_enabled()) {
 636                 printf (", PCI async ext clock used");
 637         } else {
 638                 printf (", PCI sync clock at %lu MHz",
 639                        sys_info.freqPLB / sys_info.pllPciDiv / 1000000);
 640         }
 641 #endif
 642
 643 #if defined(CONFIG_PCI) && !defined(CONFIG_405EX)
 644         putc('\n');
 645 #endif
 646
 647 #if defined(CONFIG_405EP) || defined(CONFIG_405EZ) || defined(CONFIG_405EX)
 648         printf ("       16 kB I-Cache 16 kB D-Cache");
 649 #elif defined(CONFIG_440)
 650         printf ("       32 kB I-Cache 32 kB D-Cache");
 651 #else
 652         printf ("       16 kB I-Cache %d kB D-Cache",
 653                 ((pvr | 0x00000001) == PVR_405GPR_RB) ? 16 : 8);
 654 #endif
 655 #endif /* !defined(CONFIG_IOP480) */
 656
 657 #if defined(CONFIG_IOP480)
 658         printf ("PLX IOP480 (PVR=%08x)", pvr);
 659         printf (" at %s MHz:", strmhz(buf, clock));
 660         printf (" %u kB I-Cache", 4);
 661         printf (" %u kB D-Cache", 2);
 662 #endif
 663
 664 #endif /* !defined(CONFIG_405) */
 665
 666         putc ('\n');
 667
 668         return 0;
 669 }
 670
 671 int ppc440spe_revB() {
 672         unsigned int pvr;
 673
 674         pvr = get_pvr();
 675         if ((pvr == PVR_440SPe_6_RB) || (pvr == PVR_440SPe_RB))
 676                 return 1;
 677         else
 678                 return 0;
 679 }
 680
 681 /* ------------------------------------------------------------------------- */
 682
 683 int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 684 {
 685 #if defined(CONFIG_BOARD_RESET)
 686         board_reset();
 687 #else
 688 #if defined(CONFIG_SYS_4xx_RESET_TYPE)
 689         mtspr(SPRN_DBCR0, CONFIG_SYS_4xx_RESET_TYPE << 28);
 690 #else
 691         /*
 692          * Initiate system reset in debug control register DBCR
 693          */
 694         mtspr(SPRN_DBCR0, 0x30000000);
 695 #endif /* defined(CONFIG_SYS_4xx_RESET_TYPE) */
 696 #endif /* defined(CONFIG_BOARD_RESET) */
 697
 698         return 1;
 699 }
 700
 701
 702 /*
 703  * Get timebase clock frequency
 704  */
 705 unsigned long get_tbclk (void)
 706 {
 707 #if !defined(CONFIG_IOP480)
 708         sys_info_t  sys_info;
 709
 710         get_sys_info(&sys_info);
 711         return (sys_info.freqProcessor);
 712 #else
 713         return (66000000);
 714 #endif
 715
 716 }
 717
 718
 719 #if defined(CONFIG_WATCHDOG)
 720 void watchdog_reset(void)
 721 {
 722         int re_enable = disable_interrupts();
 723         reset_4xx_watchdog();
 724         if (re_enable) enable_interrupts();
 725 }
 726
 727 void reset_4xx_watchdog(void)
 728 {
 729         /*
 730          * Clear TSR(WIS) bit
 731          */
 732         mtspr(SPRN_TSR, 0x40000000);
 733 }
 734 #endif  /* CONFIG_WATCHDOG */
 735
 736 /*
 737  * Initializes on-chip ethernet controllers.
 738  * to override, implement board_eth_init()
 739  */
 740 int cpu_eth_init(bd_t *bis)
 741 {
 742 #if defined(CONFIG_PPC4xx_EMAC)
 743         ppc_4xx_eth_initialize(bis);
 744 #endif
 745         return 0;
 746 }