cpu/ppc4xx/cpu.c

   1 /*
   2  * (C) Copyright 2000-2006
   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 #if !defined(CONFIG_405)
  41 DECLARE_GLOBAL_DATA_PTR;
  42 #endif
  43
  44 #if defined(CONFIG_BOARD_RESET)
  45 void board_reset(void);
  46 #endif
  47
  48 #if defined(CONFIG_440)
  49 #define FREQ_EBC                (sys_info.freqEPB)
  50 #elif defined(CONFIG_405EZ)
  51 #define FREQ_EBC                ((CONFIG_SYS_CLK_FREQ * sys_info.pllFbkDiv) / \
  52                                  sys_info.pllExtBusDiv)
  53 #else
  54 #define FREQ_EBC                (sys_info.freqPLB / sys_info.pllExtBusDiv)
  55 #endif
  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 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         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) && !defined(CONFIG_405)
  80 int pci_arbiter_enabled(void)
  81 {
  82 #if defined(CONFIG_405GP)
  83         return (mfdcr(strap) & PSR_PCI_ARBIT_EN);
  84 #endif
  85
  86 #if defined(CONFIG_405EP)
  87         return (mfdcr(cpc0_pci) & CPC0_PCI_ARBIT_EN);
  88 #endif
  89
  90 #if defined(CONFIG_440GP)
  91         return (mfdcr(cpc0_strp1) & CPC0_STRP1_PAE_MASK);
  92 #endif
  93
  94 #if defined(CONFIG_440GX) || defined(CONFIG_440SP) || defined(CONFIG_440SPE)
  95         unsigned long val;
  96
  97         mfsdr(sdr_xcr, val);
  98         return (val & 0x80000000);
  99 #endif
 100 #if defined(CONFIG_440EP) || defined(CONFIG_440GR) || \
 101     defined(CONFIG_440EPX) || defined(CONFIG_440GRX)
 102         unsigned long val;
 103
 104         mfsdr(sdr_pci0, val);
 105         return (val & 0x80000000);
 106 #endif
 107 }
 108 #endif
 109
 110 #if defined(CONFIG_405EP) || defined(CONFIG_440GX) || \
 111     defined(CONFIG_440EP) || defined(CONFIG_440GR) || \
 112     defined(CONFIG_440EPX) || defined(CONFIG_440GRX) || \
 113     defined(CONFIG_440SP) || defined(CONFIG_440SPE)
 114
 115 #define I2C_BOOTROM
 116
 117 int i2c_bootrom_enabled(void)
 118 {
 119 #if defined(CONFIG_405EP)
 120         return (mfdcr(cpc0_boot) & CPC0_BOOT_SEP);
 121 #else
 122         unsigned long val;
 123
 124         mfsdr(sdr_sdcs, val);
 125         return (val & SDR0_SDCS_SDD);
 126 #endif
 127 }
 128 #endif
 129
 130 #if defined(CONFIG_440GX)
 131 #define SDR0_PINSTP_SHIFT       29
 132 static char *bootstrap_str[] = {
 133         "EBC (16 bits)",
 134         "EBC (8 bits)",
 135         "EBC (32 bits)",
 136         "EBC (8 bits)",
 137         "PCI",
 138         "I2C (Addr 0x54)",
 139         "Reserved",
 140         "I2C (Addr 0x50)",
 141 };
 142 static char bootstrap_char[] = { 'A', 'B', 'C', 'B', 'D', 'E', 'x', 'F' };
 143 #endif
 144
 145 #if defined(CONFIG_440SP) || defined(CONFIG_440SPE)
 146 #define SDR0_PINSTP_SHIFT       30
 147 static char *bootstrap_str[] = {
 148         "EBC (8 bits)",
 149         "PCI",
 150         "I2C (Addr 0x54)",
 151         "I2C (Addr 0x50)",
 152 };
 153 static char bootstrap_char[] = { 'A', 'B', 'C', 'D'};
 154 #endif
 155
 156 #if defined(CONFIG_440EP) || defined(CONFIG_440GR)
 157 #define SDR0_PINSTP_SHIFT       29
 158 static char *bootstrap_str[] = {
 159         "EBC (8 bits)",
 160         "PCI",
 161         "NAND (8 bits)",
 162         "EBC (16 bits)",
 163         "EBC (16 bits)",
 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_440EPX) || defined(CONFIG_440GRX)
 172 #define SDR0_PINSTP_SHIFT       29
 173 static char *bootstrap_str[] = {
 174         "EBC (8 bits)",
 175         "EBC (16 bits)",
 176         "EBC (16 bits)",
 177         "NAND (8 bits)",
 178         "PCI",
 179         "I2C (Addr 0x54)",
 180         "PCI",
 181         "I2C (Addr 0x52)",
 182 };
 183 static char bootstrap_char[] = { 'A', 'B', 'C', 'D', 'E', 'G', 'F', 'H' };
 184 #endif
 185
 186 #if defined(CONFIG_405EZ)
 187 #define SDR0_PINSTP_SHIFT       28
 188 static char *bootstrap_str[] = {
 189         "EBC (8 bits)",
 190         "SPI (fast)",
 191         "NAND (512 page, 4 addr cycle)",
 192         "I2C (Addr 0x50)",
 193         "EBC (32 bits)",
 194         "I2C (Addr 0x50)",
 195         "NAND (2K page, 5 addr cycle)",
 196         "I2C (Addr 0x50)",
 197         "EBC (16 bits)",
 198         "Reserved",
 199         "NAND (2K page, 4 addr cycle)",
 200         "I2C (Addr 0x50)",
 201         "NAND (512 page, 3 addr cycle)",
 202         "I2C (Addr 0x50)",
 203         "SPI (slow)",
 204         "I2C (Addr 0x50)",
 205 };
 206 static char bootstrap_char[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', \
 207                                  'I', 'x', 'K', 'L', 'M', 'N', 'O', 'P' };
 208 #endif
 209
 210 #if defined(SDR0_PINSTP_SHIFT)
 211 static int bootstrap_option(void)
 212 {
 213         unsigned long val;
 214
 215         mfsdr(SDR_PINSTP, val);
 216         return ((val & 0xf0000000) >> SDR0_PINSTP_SHIFT);
 217 }
 218 #endif /* SDR0_PINSTP_SHIFT */
 219
 220
 221 #if defined(CONFIG_440)
 222 static int do_chip_reset(unsigned long sys0, unsigned long sys1);
 223 #endif
 224
 225
 226 int checkcpu (void)
 227 {
 228 #if !defined(CONFIG_405)        /* not used on Xilinx 405 FPGA implementations */
 229         uint pvr = get_pvr();
 230         ulong clock = gd->cpu_clk;
 231         char buf[32];
 232
 233 #if !defined(CONFIG_IOP480)
 234         char addstr[64] = "";
 235         sys_info_t sys_info;
 236
 237         puts ("CPU:   ");
 238
 239         get_sys_info(&sys_info);
 240
 241         puts("AMCC PowerPC 4");
 242
 243 #if defined(CONFIG_405GP) || defined(CONFIG_405CR) || \
 244     defined(CONFIG_405EP) || defined(CONFIG_405EZ)
 245         puts("05");
 246 #endif
 247 #if defined(CONFIG_440)
 248         puts("40");
 249 #endif
 250
 251         switch (pvr) {
 252         case PVR_405GP_RB:
 253                 puts("GP Rev. B");
 254                 break;
 255
 256         case PVR_405GP_RC:
 257                 puts("GP Rev. C");
 258                 break;
 259
 260         case PVR_405GP_RD:
 261                 puts("GP Rev. D");
 262                 break;
 263
 264 #ifdef CONFIG_405GP
 265         case PVR_405GP_RE: /* 405GP rev E and 405CR rev C have same PVR */
 266                 puts("GP Rev. E");
 267                 break;
 268 #endif
 269
 270         case PVR_405CR_RA:
 271                 puts("CR Rev. A");
 272                 break;
 273
 274         case PVR_405CR_RB:
 275                 puts("CR Rev. B");
 276                 break;
 277
 278 #ifdef CONFIG_405CR
 279         case PVR_405CR_RC: /* 405GP rev E and 405CR rev C have same PVR */
 280                 puts("CR Rev. C");
 281                 break;
 282 #endif
 283
 284         case PVR_405GPR_RB:
 285                 puts("GPr Rev. B");
 286                 break;
 287
 288         case PVR_405EP_RB:
 289                 puts("EP Rev. B");
 290                 break;
 291
 292         case PVR_405EZ_RA:
 293                 puts("EZ Rev. A");
 294                 break;
 295
 296 #if defined(CONFIG_440)
 297         case PVR_440GP_RB:
 298                 puts("GP Rev. B");
 299                 /* See errata 1.12: CHIP_4 */
 300                 if ((mfdcr(cpc0_sys0) != mfdcr(cpc0_strp0)) ||
 301                     (mfdcr(cpc0_sys1) != mfdcr(cpc0_strp1)) ){
 302                         puts (  "\n\t CPC0_SYSx DCRs corrupted. "
 303                                 "Resetting chip ...\n");
 304                         udelay( 1000 * 1000 ); /* Give time for serial buf to clear */
 305                         do_chip_reset ( mfdcr(cpc0_strp0),
 306                                         mfdcr(cpc0_strp1) );
 307                 }
 308                 break;
 309
 310         case PVR_440GP_RC:
 311                 puts("GP Rev. C");
 312                 break;
 313
 314         case PVR_440GX_RA:
 315                 puts("GX Rev. A");
 316                 break;
 317
 318         case PVR_440GX_RB:
 319                 puts("GX Rev. B");
 320                 break;
 321
 322         case PVR_440GX_RC:
 323                 puts("GX Rev. C");
 324                 break;
 325
 326         case PVR_440GX_RF:
 327                 puts("GX Rev. F");
 328                 break;
 329
 330         case PVR_440EP_RA:
 331                 puts("EP Rev. A");
 332                 break;
 333
 334 #ifdef CONFIG_440EP
 335         case PVR_440EP_RB: /* 440EP rev B and 440GR rev A have same PVR */
 336                 puts("EP Rev. B");
 337                 break;
 338
 339         case PVR_440EP_RC: /* 440EP rev C and 440GR rev B have same PVR */
 340                 puts("EP Rev. C");
 341                 break;
 342 #endif /*  CONFIG_440EP */
 343
 344 #ifdef CONFIG_440GR
 345         case PVR_440GR_RA: /* 440EP rev B and 440GR rev A have same PVR */
 346                 puts("GR Rev. A");
 347                 break;
 348
 349         case PVR_440GR_RB: /* 440EP rev C and 440GR rev B have same PVR */
 350                 puts("GR Rev. B");
 351                 break;
 352 #endif /* CONFIG_440GR */
 353 #endif /* CONFIG_440 */
 354
 355 #ifdef CONFIG_440EPX
 356         case PVR_440EPX1_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 357                 puts("EPx Rev. A");
 358                 strcpy(addstr, "Security/Kasumi support");
 359                 break;
 360
 361         case PVR_440EPX2_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 362                 puts("EPx Rev. A");
 363                 strcpy(addstr, "No Security/Kasumi support");
 364                 break;
 365 #endif /* CONFIG_440EPX */
 366
 367 #ifdef CONFIG_440GRX
 368         case PVR_440GRX1_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 369                 puts("GRx Rev. A");
 370                 strcpy(addstr, "Security/Kasumi support");
 371                 break;
 372
 373         case PVR_440GRX2_RA: /* 440EPx rev A and 440GRx rev A have same PVR */
 374                 puts("GRx Rev. A");
 375                 strcpy(addstr, "No Security/Kasumi support");
 376                 break;
 377 #endif /* CONFIG_440GRX */
 378
 379         case PVR_440SP_6_RAB:
 380                 puts("SP Rev. A/B");
 381                 strcpy(addstr, "RAID 6 support");
 382                 break;
 383
 384         case PVR_440SP_RAB:
 385                 puts("SP Rev. A/B");
 386                 strcpy(addstr, "No RAID 6 support");
 387                 break;
 388
 389         case PVR_440SP_6_RC:
 390                 puts("SP Rev. C");
 391                 strcpy(addstr, "RAID 6 support");
 392                 break;
 393
 394         case PVR_440SP_RC:
 395                 puts("SP Rev. C");
 396                 strcpy(addstr, "No RAID 6 support");
 397                 break;
 398
 399         case PVR_440SPe_6_RA:
 400                 puts("SPe Rev. A");
 401                 strcpy(addstr, "RAID 6 support");
 402                 break;
 403
 404         case PVR_440SPe_RA:
 405                 puts("SPe Rev. A");
 406                 strcpy(addstr, "No RAID 6 support");
 407                 break;
 408
 409         case PVR_440SPe_6_RB:
 410                 puts("SPe Rev. B");
 411                 strcpy(addstr, "RAID 6 support");
 412                 break;
 413
 414         case PVR_440SPe_RB:
 415                 puts("SPe Rev. B");
 416                 strcpy(addstr, "No RAID 6 support");
 417                 break;
 418
 419         default:
 420                 printf (" UNKNOWN (PVR=%08x)", pvr);
 421                 break;
 422         }
 423
 424         printf (" at %s MHz (PLB=%lu, OPB=%lu, EBC=%lu MHz)\n", strmhz(buf, clock),
 425                 sys_info.freqPLB / 1000000,
 426                 get_OPB_freq() / 1000000,
 427                 FREQ_EBC / 1000000);
 428
 429         if (addstr[0] != 0)
 430                 printf("       %s\n", addstr);
 431
 432 #if defined(I2C_BOOTROM)
 433         printf ("       I2C boot EEPROM %sabled\n", i2c_bootrom_enabled() ? "en" : "dis");
 434 #endif  /* I2C_BOOTROM */
 435 #if defined(SDR0_PINSTP_SHIFT)
 436         printf ("       Bootstrap Option %c - ", bootstrap_char[bootstrap_option()]);
 437         printf ("Boot ROM Location %s\n", bootstrap_str[bootstrap_option()]);
 438 #endif  /* SDR0_PINSTP_SHIFT */
 439
 440 #if defined(CONFIG_PCI)
 441         printf ("       Internal PCI arbiter %sabled", pci_arbiter_enabled() ? "en" : "dis");
 442 #endif
 443
 444 #if defined(PCI_ASYNC)
 445         if (pci_async_enabled()) {
 446                 printf (", PCI async ext clock used");
 447         } else {
 448                 printf (", PCI sync clock at %lu MHz",
 449                        sys_info.freqPLB / sys_info.pllPciDiv / 1000000);
 450         }
 451 #endif
 452
 453 #if defined(CONFIG_PCI)
 454         putc('\n');
 455 #endif
 456
 457 #if defined(CONFIG_405EP) || defined(CONFIG_405EZ)
 458         printf ("       16 kB I-Cache 16 kB D-Cache");
 459 #elif defined(CONFIG_440)
 460         printf ("       32 kB I-Cache 32 kB D-Cache");
 461 #else
 462         printf ("       16 kB I-Cache %d kB D-Cache",
 463                 ((pvr | 0x00000001) == PVR_405GPR_RB) ? 16 : 8);
 464 #endif
 465 #endif /* !defined(CONFIG_IOP480) */
 466
 467 #if defined(CONFIG_IOP480)
 468         printf ("PLX IOP480 (PVR=%08x)", pvr);
 469         printf (" at %s MHz:", strmhz(buf, clock));
 470         printf (" %u kB I-Cache", 4);
 471         printf (" %u kB D-Cache", 2);
 472 #endif
 473
 474 #endif /* !defined(CONFIG_405) */
 475
 476         putc ('\n');
 477
 478         return 0;
 479 }
 480
 481 #if defined (CONFIG_440SPE)
 482 int ppc440spe_revB() {
 483         unsigned int pvr;
 484
 485         pvr = get_pvr();
 486         if ((pvr == PVR_440SPe_6_RB) || (pvr == PVR_440SPe_RB))
 487                 return 1;
 488         else
 489                 return 0;
 490 }
 491 #endif
 492
 493 /* ------------------------------------------------------------------------- */
 494
 495 int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 496 {
 497 #if defined(CONFIG_BOARD_RESET)
 498         board_reset();
 499 #else
 500 #if defined(CFG_4xx_RESET_TYPE)
 501         mtspr(dbcr0, CFG_4xx_RESET_TYPE << 28);
 502 #else
 503         /*
 504          * Initiate system reset in debug control register DBCR
 505          */
 506         mtspr(dbcr0, 0x30000000);
 507 #endif /* defined(CFG_4xx_RESET_TYPE) */
 508 #endif /* defined(CONFIG_BOARD_RESET) */
 509
 510         return 1;
 511 }
 512
 513 #if defined(CONFIG_440)
 514 static int do_chip_reset (unsigned long sys0, unsigned long sys1)
 515 {
 516         /* Changes to cpc0_sys0 and cpc0_sys1 require chip
 517          * reset.
 518          */
 519         mtdcr (cntrl0, mfdcr (cntrl0) | 0x80000000);    /* Set SWE */
 520         mtdcr (cpc0_sys0, sys0);
 521         mtdcr (cpc0_sys1, sys1);
 522         mtdcr (cntrl0, mfdcr (cntrl0) & ~0x80000000);   /* Clr SWE */
 523         mtspr (dbcr0, 0x20000000);      /* Reset the chip */
 524
 525         return 1;
 526 }
 527 #endif
 528
 529
 530 /*
 531  * Get timebase clock frequency
 532  */
 533 unsigned long get_tbclk (void)
 534 {
 535 #if !defined(CONFIG_IOP480)
 536         sys_info_t  sys_info;
 537
 538         get_sys_info(&sys_info);
 539         return (sys_info.freqProcessor);
 540 #else
 541         return (66000000);
 542 #endif
 543
 544 }
 545
 546
 547 #if defined(CONFIG_WATCHDOG)
 548 void
 549 watchdog_reset(void)
 550 {
 551         int re_enable = disable_interrupts();
 552         reset_4xx_watchdog();
 553         if (re_enable) enable_interrupts();
 554 }
 555
 556 void
 557 reset_4xx_watchdog(void)
 558 {
 559         /*
 560          * Clear TSR(WIS) bit
 561          */
 562         mtspr(tsr, 0x40000000);
 563 }
 564 #endif  /* CONFIG_WATCHDOG */