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) && \
  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 #if defined(CONFIG_APM821XX)
 254 #define SDR0_PINSTP_SHIFT       29
 255 static char *bootstrap_str[] = {
 256         "RESERVED",
 257         "RESERVED",
 258         "RESERVED",
 259         "NAND (8 bits)",
 260         "NOR  (8 bits)",
 261         "NOR  (8 bits) w/PLL Bypassed",
 262         "I2C (Addr 0x54)",
 263         "I2C (Addr 0x52)",
 264 };
 265 static char bootstrap_char[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
 266 #endif
 267
 268 #if defined(SDR0_PINSTP_SHIFT)
 269 static int bootstrap_option(void)
 270 {
 271         unsigned long val;
 272
 273         mfsdr(SDR0_PINSTP, val);
 274         return ((val & 0xf0000000) >> SDR0_PINSTP_SHIFT);
 275 }
 276 #endif /* SDR0_PINSTP_SHIFT */
 277
 278
 279 #if defined(CONFIG_440GP)
 280 static int do_chip_reset (unsigned long sys0, unsigned long sys1)
 281 {
 282         /* Changes to CPC0_SYS0 and CPC0_SYS1 require chip
 283          * reset.
 284          */
 285         mtdcr (CPC0_CR0, mfdcr (CPC0_CR0) | 0x80000000);        /* Set SWE */
 286         mtdcr (CPC0_SYS0, sys0);
 287         mtdcr (CPC0_SYS1, sys1);
 288         mtdcr (CPC0_CR0, mfdcr (CPC0_CR0) & ~0x80000000);       /* Clr SWE */
 289         mtspr (SPRN_DBCR0, 0x20000000); /* Reset the chip */
 290
 291         return 1;
 292 }
 293 #endif /* CONFIG_440GP */
 294
 295
 296 int checkcpu (void)
 297 {
 298 #if !defined(CONFIG_405)        /* not used on Xilinx 405 FPGA implementations */
 299         uint pvr = get_pvr();
 300         ulong clock = gd->cpu_clk;
 301         char buf[32];
 302 #if defined(CONFIG_460EX) || defined(CONFIG_460GT)
 303         u32 reg;
 304 #endif
 305
 306         char addstr[64] = "";
 307         sys_info_t sys_info;
 308         int cpu_num;
 309
 310         cpu_num = get_cpu_num();
 311         if (cpu_num >= 0)
 312                 printf("CPU%d:  ", cpu_num);
 313         else
 314                 puts("CPU:   ");
 315
 316         get_sys_info(&sys_info);
 317
 318 #if defined(CONFIG_XILINX_440)
 319         puts("IBM PowerPC ");
 320 #else
 321         puts("AMCC PowerPC ");
 322 #endif
 323
 324         switch (pvr) {
 325
 326 #if !defined(CONFIG_440)
 327         case PVR_405GP_RB:
 328                 puts("405GP Rev. B");
 329                 break;
 330
 331         case PVR_405GP_RC:
 332                 puts("405GP Rev. C");
 333                 break;
 334
 335         case PVR_405GP_RD:
 336                 puts("405GP Rev. D");
 337                 break;
 338
 339 #ifdef CONFIG_405GP
 340         case PVR_405GP_RE: /* 405GP rev E and 405CR rev C have same PVR */
 341                 puts("405GP Rev. E");
 342                 break;
 343 #endif
 344
 345         case PVR_405CR_RA:
 346                 puts("405CR Rev. A");
 347                 break;
 348
 349         case PVR_405CR_RB:
 350                 puts("405CR Rev. B");
 351                 break;
 352
 353 #ifdef CONFIG_405CR
 354         case PVR_405CR_RC: /* 405GP rev E and 405CR rev C have same PVR */
 355                 puts("405CR Rev. C");
 356                 break;
 357 #endif
 358
 359         case PVR_405GPR_RB:
 360                 puts("405GPr Rev. B");
 361                 break;
 362
 363         case PVR_405EP_RB:
 364                 puts("405EP Rev. B");
 365                 break;
 366
 367         case PVR_405EZ_RA:
 368                 puts("405EZ Rev. A");
 369                 break;
 370
 371         case PVR_405EX1_RA:
 372                 puts("405EX Rev. A");
 373                 strcpy(addstr, "Security support");
 374                 break;
 375
 376         case PVR_405EXR2_RA:
 377                 puts("405EXr Rev. A");
 378                 strcpy(addstr, "No Security support");
 379                 break;
 380
 381         case PVR_405EX1_RC:
 382                 puts("405EX Rev. C");
 383                 strcpy(addstr, "Security support");
 384                 break;
 385
 386         case PVR_405EX2_RC:
 387                 puts("405EX Rev. C");
 388                 strcpy(addstr, "No Security support");
 389                 break;
 390
 391         case PVR_405EXR1_RC:
 392                 puts("405EXr Rev. C");
 393                 strcpy(addstr, "Security support");
 394                 break;
 395
 396         case PVR_405EXR2_RC:
 397                 puts("405EXr Rev. C");
 398                 strcpy(addstr, "No Security support");
 399                 break;
 400
 401         case PVR_405EX1_RD:
 402                 puts("405EX Rev. D");
 403                 strcpy(addstr, "Security support");
 404                 break;
 405
 406         case PVR_405EX2_RD:
 407                 puts("405EX Rev. D");
 408                 strcpy(addstr, "No Security support");
 409                 break;
 410
 411         case PVR_405EXR1_RD:
 412                 puts("405EXr Rev. D");
 413                 strcpy(addstr, "Security support");
 414                 break;
 415
 416         case PVR_405EXR2_RD:
 417                 puts("405EXr Rev. D");
 418                 strcpy(addstr, "No Security support");
 419                 break;
 420
 421 #else /* CONFIG_440 */
 422
 423 #if defined(CONFIG_440GP)
 424         case PVR_440GP_RB:
 425                 puts("440GP Rev. B");
 426                 /* See errata 1.12: CHIP_4 */
 427                 if ((mfdcr(CPC0_SYS0) != mfdcr(CPC0_STRP0)) ||
 428                     (mfdcr(CPC0_SYS1) != mfdcr(CPC0_STRP1)) ){
 429                         puts (  "\n\t CPC0_SYSx DCRs corrupted. "
 430                                 "Resetting chip ...\n");
 431                         udelay( 1000 * 1000 ); /* Give time for serial buf to clear */
 432                         do_chip_reset ( mfdcr(CPC0_STRP0),
 433                                         mfdcr(CPC0_STRP1) );
 434                 }
 435                 break;
 436
 437         case PVR_440GP_RC:
 438                 puts("440GP Rev. C");
 439                 break;
 440 #endif /* CONFIG_440GP */
 441
 442         case PVR_440GX_RA:
 443                 puts("440GX Rev. A");
 444                 break;
 445
 446         case PVR_440GX_RB:
 447                 puts("440GX Rev. B");
 448                 break;
 449
 450         case PVR_440GX_RC:
 451                 puts("440GX Rev. C");
 452                 break;
 453
 454         case PVR_440GX_RF:
 455                 puts("440GX Rev. F");
 456                 break;
 457
 458         case PVR_440EP_RA:
 459                 puts("440EP Rev. A");
 460                 break;
 461
 462 #ifdef CONFIG_440EP
 463         case PVR_440EP_RB: /* 440EP rev B and 440GR rev A have same PVR */
 464                 puts("440EP Rev. B");
 465                 break;
 466
 467         case PVR_440EP_RC: /* 440EP rev C and 440GR rev B have same PVR */
 468                 puts("440EP Rev. C");
 469                 break;
 470 #endif /*  CONFIG_440EP */
 471
 472 #ifdef CONFIG_440GR
 473         case PVR_440GR_RA: /* 440EP rev B and 440GR rev A have same PVR */
 474                 puts("440GR Rev. A");
 475                 break;
 476
 477         case PVR_440GR_RB: /* 440EP rev C and 440GR rev B have same PVR */
 478                 puts("440GR Rev. B");
 479                 break;
 480 #endif /* CONFIG_440GR */
 481
 482 #ifdef CONFIG_440EPX
 483         case PVR_440EPX1_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 484                 puts("440EPx Rev. A");
 485                 strcpy(addstr, "Security/Kasumi support");
 486                 break;
 487
 488         case PVR_440EPX2_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 489                 puts("440EPx Rev. A");
 490                 strcpy(addstr, "No Security/Kasumi support");
 491                 break;
 492 #endif /* CONFIG_440EPX */
 493
 494 #ifdef CONFIG_440GRX
 495         case PVR_440GRX1_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 496                 puts("440GRx Rev. A");
 497                 strcpy(addstr, "Security/Kasumi support");
 498                 break;
 499
 500         case PVR_440GRX2_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 501                 puts("440GRx Rev. A");
 502                 strcpy(addstr, "No Security/Kasumi support");
 503                 break;
 504 #endif /* CONFIG_440GRX */
 505
 506         case PVR_440SP_6_RAB:
 507                 puts("440SP Rev. A/B");
 508                 strcpy(addstr, "RAID 6 support");
 509                 break;
 510
 511         case PVR_440SP_RAB:
 512                 puts("440SP Rev. A/B");
 513                 strcpy(addstr, "No RAID 6 support");
 514                 break;
 515
 516         case PVR_440SP_6_RC:
 517                 puts("440SP Rev. C");
 518                 strcpy(addstr, "RAID 6 support");
 519                 break;
 520
 521         case PVR_440SP_RC:
 522                 puts("440SP Rev. C");
 523                 strcpy(addstr, "No RAID 6 support");
 524                 break;
 525
 526         case PVR_440SPe_6_RA:
 527                 puts("440SPe Rev. A");
 528                 strcpy(addstr, "RAID 6 support");
 529                 break;
 530
 531         case PVR_440SPe_RA:
 532                 puts("440SPe Rev. A");
 533                 strcpy(addstr, "No RAID 6 support");
 534                 break;
 535
 536         case PVR_440SPe_6_RB:
 537                 puts("440SPe Rev. B");
 538                 strcpy(addstr, "RAID 6 support");
 539                 break;
 540
 541         case PVR_440SPe_RB:
 542                 puts("440SPe Rev. B");
 543                 strcpy(addstr, "No RAID 6 support");
 544                 break;
 545
 546 #if defined(CONFIG_460EX) || defined(CONFIG_460GT)
 547         case PVR_460EX_RA:
 548                 puts("460EX Rev. A");
 549                 strcpy(addstr, "No Security/Kasumi support");
 550                 break;
 551
 552         case PVR_460EX_SE_RA:
 553                 puts("460EX Rev. A");
 554                 strcpy(addstr, "Security/Kasumi support");
 555                 break;
 556
 557         case PVR_460EX_RB:
 558                 puts("460EX Rev. B");
 559                 mfsdr(SDR0_ECID3, reg);
 560                 if (reg & 0x00100000)
 561                         strcpy(addstr, "No Security/Kasumi support");
 562                 else
 563                         strcpy(addstr, "Security/Kasumi support");
 564                 break;
 565
 566         case PVR_460GT_RA:
 567                 puts("460GT Rev. A");
 568                 strcpy(addstr, "No Security/Kasumi support");
 569                 break;
 570
 571         case PVR_460GT_SE_RA:
 572                 puts("460GT Rev. A");
 573                 strcpy(addstr, "Security/Kasumi support");
 574                 break;
 575
 576         case PVR_460GT_RB:
 577                 puts("460GT Rev. B");
 578                 mfsdr(SDR0_ECID3, reg);
 579                 if (reg & 0x00100000)
 580                         strcpy(addstr, "No Security/Kasumi support");
 581                 else
 582                         strcpy(addstr, "Security/Kasumi support");
 583                 break;
 584 #endif
 585
 586         case PVR_460SX_RA:
 587                 puts("460SX Rev. A");
 588                 strcpy(addstr, "Security support");
 589                 break;
 590
 591         case PVR_460SX_RA_V1:
 592                 puts("460SX Rev. A");
 593                 strcpy(addstr, "No Security support");
 594                 break;
 595
 596         case PVR_460GX_RA:
 597                 puts("460GX Rev. A");
 598                 strcpy(addstr, "Security support");
 599                 break;
 600
 601         case PVR_460GX_RA_V1:
 602                 puts("460GX Rev. A");
 603                 strcpy(addstr, "No Security support");
 604                 break;
 605
 606         case PVR_APM821XX_RA:
 607                 puts("APM821XX Rev. A");
 608                 strcpy(addstr, "Security support");
 609                 break;
 610
 611         case PVR_VIRTEX5:
 612                 puts("440x5 VIRTEX5");
 613                 break;
 614 #endif /* CONFIG_440 */
 615
 616         default:
 617                 printf (" UNKNOWN (PVR=%08x)", pvr);
 618                 break;
 619         }
 620
 621         printf (" at %s MHz (PLB=%lu OPB=%lu EBC=%lu",
 622                 strmhz(buf, clock),
 623                 sys_info.freqPLB / 1000000,
 624                 get_OPB_freq() / 1000000,
 625                 sys_info.freqEBC / 1000000);
 626 #if defined(CONFIG_PCI) && \
 627         (defined(CONFIG_440EP) || defined(CONFIG_440EPX) || \
 628          defined(CONFIG_440GR) || defined(CONFIG_440GRX))
 629         printf(" PCI=%lu MHz", sys_info.freqPCI / 1000000);
 630 #endif
 631         printf(")\n");
 632
 633         if (addstr[0] != 0)
 634                 printf("       %s\n", addstr);
 635
 636 #if defined(I2C_BOOTROM)
 637         printf ("       I2C boot EEPROM %sabled\n", i2c_bootrom_enabled() ? "en" : "dis");
 638 #endif  /* I2C_BOOTROM */
 639 #if defined(SDR0_PINSTP_SHIFT)
 640         printf ("       Bootstrap Option %c - ", bootstrap_char[bootstrap_option()]);
 641         printf ("Boot ROM Location %s", bootstrap_str[bootstrap_option()]);
 642 #ifdef CONFIG_NAND_U_BOOT
 643         puts(", booting from NAND");
 644 #endif /* CONFIG_NAND_U_BOOT */
 645         putc('\n');
 646 #endif  /* SDR0_PINSTP_SHIFT */
 647
 648 #if defined(CONFIG_PCI) && !defined(CONFIG_405EX)
 649         printf ("       Internal PCI arbiter %sabled", pci_arbiter_enabled() ? "en" : "dis");
 650 #endif
 651
 652 #if defined(CONFIG_PCI) && defined(PCI_ASYNC)
 653         if (pci_async_enabled()) {
 654                 printf (", PCI async ext clock used");
 655         } else {
 656                 printf (", PCI sync clock at %lu MHz",
 657                        sys_info.freqPLB / sys_info.pllPciDiv / 1000000);
 658         }
 659 #endif
 660
 661 #if defined(CONFIG_PCI) && !defined(CONFIG_405EX)
 662         putc('\n');
 663 #endif
 664
 665 #if defined(CONFIG_405EP) || defined(CONFIG_405EZ) || defined(CONFIG_405EX)
 666         printf ("       16 kB I-Cache 16 kB D-Cache");
 667 #elif defined(CONFIG_440)
 668         printf ("       32 kB I-Cache 32 kB D-Cache");
 669 #else
 670         printf ("       16 kB I-Cache %d kB D-Cache",
 671                 ((pvr | 0x00000001) == PVR_405GPR_RB) ? 16 : 8);
 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         sys_info_t  sys_info;
 718
 719         get_sys_info(&sys_info);
 720         return (sys_info.freqProcessor);
 721 }
 722
 723
 724 #if defined(CONFIG_WATCHDOG)
 725 void watchdog_reset(void)
 726 {
 727         int re_enable = disable_interrupts();
 728         reset_4xx_watchdog();
 729         if (re_enable) enable_interrupts();
 730 }
 731
 732 void reset_4xx_watchdog(void)
 733 {
 734         /*
 735          * Clear TSR(WIS) bit
 736          */
 737         mtspr(SPRN_TSR, 0x40000000);
 738 }
 739 #endif  /* CONFIG_WATCHDOG */
 740
 741 /*
 742  * Initializes on-chip ethernet controllers.
 743  * to override, implement board_eth_init()
 744  */
 745 int cpu_eth_init(bd_t *bis)
 746 {
 747 #if defined(CONFIG_PPC4xx_EMAC)
 748         ppc_4xx_eth_initialize(bis);
 749 #endif
 750         return 0;
 751 }