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