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