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