arch/powerpc/cpu/ppc4xx/cpu.c

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