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