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