arch/powerpc/cpu/mpc8xx/cpu.c

   1 /*
   2  * (C) Copyright 2000-2002
   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  * m8xx.c
  26  *
  27  * CPU specific code
  28  *
  29  * written or collected and sometimes rewritten by
  30  * Magnus Damm <damm@bitsmart.com>
  31  *
  32  * minor modifications by
  33  * Wolfgang Denk <wd@denx.de>
  34  */
  35
  36 #include <common.h>
  37 #include <watchdog.h>
  38 #include <command.h>
  39 #include <mpc8xx.h>
  40 #include <commproc.h>
  41 #include <netdev.h>
  42 #include <asm/cache.h>
  43 #include <linux/compiler.h>
  44 #include <asm/io.h>
  45
  46 #if defined(CONFIG_OF_LIBFDT)
  47 #include <libfdt.h>
  48 #include <fdt_support.h>
  49 #endif
  50
  51 DECLARE_GLOBAL_DATA_PTR;
  52
  53 static char *cpu_warning = "\n         " \
  54         "*** Warning: CPU Core has Silicon Bugs -- Check the Errata ***";
  55
  56 #if ((defined(CONFIG_MPC86x) || defined(CONFIG_MPC855)) && \
  57      !defined(CONFIG_MPC862))
  58
  59 static int check_CPU (long clock, uint pvr, uint immr)
  60 {
  61         char *id_str =
  62 # if defined(CONFIG_MPC855)
  63         "PC855";
  64 # elif defined(CONFIG_MPC860P)
  65         "PC860P";
  66 # else
  67         NULL;
  68 # endif
  69         volatile immap_t *immap = (immap_t *) (immr & 0xFFFF0000);
  70         uint k, m;
  71         char buf[32];
  72         char pre = 'X';
  73         char *mid = "xx";
  74         char *suf;
  75
  76         /* the highest 16 bits should be 0x0050 for a 860 */
  77
  78         if ((pvr >> 16) != 0x0050)
  79                 return -1;
  80
  81         k = (immr << 16) |
  82                 immap->im_cpm.cp_dparam16[PROFF_REVNUM / sizeof(u16)];
  83         m = 0;
  84         suf = "";
  85
  86         /*
  87          * Some boards use sockets so different CPUs can be used.
  88          * We have to check chip version in run time.
  89          */
  90         switch (k) {
  91         case 0x00020001: pre = 'P'; break;
  92         case 0x00030001: break;
  93         case 0x00120003: suf = "A"; break;
  94         case 0x00130003: suf = "A3"; break;
  95
  96         case 0x00200004: suf = "B"; break;
  97
  98         case 0x00300004: suf = "C"; break;
  99         case 0x00310004: suf = "C1"; m = 1; break;
 100
 101         case 0x00200064: mid = "SR"; suf = "B"; break;
 102         case 0x00300065: mid = "SR"; suf = "C"; break;
 103         case 0x00310065: mid = "SR"; suf = "C1"; m = 1; break;
 104         case 0x05010000: suf = "D3"; m = 1; break;
 105         case 0x05020000: suf = "D4"; m = 1; break;
 106                 /* this value is not documented anywhere */
 107         case 0x40000000: pre = 'P'; suf = "D"; m = 1; break;
 108                 /* MPC866P/MPC866T/MPC859T/MPC859DSL/MPC852T */
 109         case 0x08010004:                /* Rev. A.0 */
 110                 suf = "A";
 111                 /* fall through */
 112         case 0x08000003:                /* Rev. 0.3 */
 113                 pre = 'M'; m = 1;
 114                 if (id_str == NULL)
 115                         id_str =
 116 # if defined(CONFIG_MPC852T)
 117                 "PC852T";
 118 # elif defined(CONFIG_MPC859T)
 119                 "PC859T";
 120 # elif defined(CONFIG_MPC859DSL)
 121                 "PC859DSL";
 122 # elif defined(CONFIG_MPC866T)
 123                 "PC866T";
 124 # else
 125                 "PC866x"; /* Unknown chip from MPC866 family */
 126 # endif
 127                 break;
 128         case 0x09000000: pre = 'M'; mid = suf = ""; m = 1;
 129                 if (id_str == NULL)
 130                         id_str = "PC885"; /* 870/875/880/885 */
 131                 break;
 132
 133         default: suf = NULL; break;
 134         }
 135
 136         if (id_str == NULL)
 137                 id_str = "PC86x";       /* Unknown 86x chip */
 138         if (suf)
 139                 printf ("%c%s%sZPnn%s", pre, id_str, mid, suf);
 140         else
 141                 printf ("unknown M%s (0x%08x)", id_str, k);
 142
 143
 144 #if defined(CONFIG_SYS_8xx_CPUCLK_MIN) && defined(CONFIG_SYS_8xx_CPUCLK_MAX)
 145         printf (" at %s MHz [%d.%d...%d.%d MHz]\n       ",
 146                 strmhz (buf, clock),
 147                 CONFIG_SYS_8xx_CPUCLK_MIN / 1000000,
 148                 ((CONFIG_SYS_8xx_CPUCLK_MIN % 1000000) + 50000) / 100000,
 149                 CONFIG_SYS_8xx_CPUCLK_MAX / 1000000,
 150                 ((CONFIG_SYS_8xx_CPUCLK_MAX % 1000000) + 50000) / 100000
 151         );
 152 #else
 153         printf (" at %s MHz: ", strmhz (buf, clock));
 154 #endif
 155         printf ("%u kB I-Cache %u kB D-Cache",
 156                 checkicache () >> 10,
 157                 checkdcache () >> 10
 158         );
 159
 160         /* do we have a FEC (860T/P or 852/859/866/885)? */
 161
 162         immap->im_cpm.cp_fec.fec_addr_low = 0x12345678;
 163         if (immap->im_cpm.cp_fec.fec_addr_low == 0x12345678) {
 164                 printf (" FEC present");
 165         }
 166
 167         if (!m) {
 168                 puts (cpu_warning);
 169         }
 170
 171         putc ('\n');
 172
 173 #ifdef DEBUG
 174         if(clock != measure_gclk()) {
 175             printf ("clock %ldHz != %dHz\n", clock, measure_gclk());
 176         }
 177 #endif
 178
 179         return 0;
 180 }
 181
 182 #elif defined(CONFIG_MPC862)
 183
 184 static int check_CPU (long clock, uint pvr, uint immr)
 185 {
 186         volatile immap_t *immap = (immap_t *) (immr & 0xFFFF0000);
 187         uint k, m;
 188         char buf[32];
 189         char pre = 'X';
 190         __maybe_unused char *mid = "xx";
 191         char *suf;
 192
 193         /* the highest 16 bits should be 0x0050 for a 8xx */
 194
 195         if ((pvr >> 16) != 0x0050)
 196                 return -1;
 197
 198         k = (immr << 16) |
 199                 immap->im_cpm.cp_dparam16[PROFF_REVNUM / sizeof(u16)];
 200         m = 0;
 201
 202         switch (k) {
 203
 204                 /* this value is not documented anywhere */
 205         case 0x06000000: mid = "P"; suf = "0"; break;
 206         case 0x06010001: mid = "P"; suf = "A"; m = 1; break;
 207         case 0x07000003: mid = "P"; suf = "B"; m = 1; break;
 208         default: suf = NULL; break;
 209         }
 210
 211 #ifndef CONFIG_MPC857
 212         if (suf)
 213                 printf ("%cPC862%sZPnn%s", pre, mid, suf);
 214         else
 215                 printf ("unknown MPC862 (0x%08x)", k);
 216 #else
 217         if (suf)
 218                 printf ("%cPC857TZPnn%s", pre, suf); /* only 857T tested right now! */
 219         else
 220                 printf ("unknown MPC857 (0x%08x)", k);
 221 #endif
 222
 223         printf (" at %s MHz:", strmhz (buf, clock));
 224
 225         printf (" %u kB I-Cache", checkicache () >> 10);
 226         printf (" %u kB D-Cache", checkdcache () >> 10);
 227
 228         /* lets check and see if we're running on a 862T (or P?) */
 229
 230         immap->im_cpm.cp_fec.fec_addr_low = 0x12345678;
 231         if (immap->im_cpm.cp_fec.fec_addr_low == 0x12345678) {
 232                 printf (" FEC present");
 233         }
 234
 235         if (!m) {
 236                 puts (cpu_warning);
 237         }
 238
 239         putc ('\n');
 240
 241         return 0;
 242 }
 243
 244 #elif defined(CONFIG_MPC823)
 245
 246 static int check_CPU (long clock, uint pvr, uint immr)
 247 {
 248         volatile immap_t *immap = (immap_t *) (immr & 0xFFFF0000);
 249         uint k, m;
 250         char buf[32];
 251         char *suf;
 252
 253         /* the highest 16 bits should be 0x0050 for a 8xx */
 254
 255         if ((pvr >> 16) != 0x0050)
 256                 return -1;
 257
 258         k = (immr << 16) |
 259                 in_be16(&immap->im_cpm.cp_dparam16[PROFF_REVNUM / sizeof(u16)]);
 260         m = 0;
 261
 262         switch (k) {
 263                 /* MPC823 */
 264         case 0x20000000: suf = "0"; break;
 265         case 0x20010000: suf = "0.1"; break;
 266         case 0x20020000: suf = "Z2/3"; break;
 267         case 0x20020001: suf = "Z3"; break;
 268         case 0x21000000: suf = "A"; break;
 269         case 0x21010000: suf = "B"; m = 1; break;
 270         case 0x21010001: suf = "B2"; m = 1; break;
 271                 /* MPC823E */
 272         case 0x24010000: suf = NULL;
 273                         puts ("PPC823EZTnnB2");
 274                         m = 1;
 275                         break;
 276         default:
 277                         suf = NULL;
 278                         printf ("unknown MPC823 (0x%08x)", k);
 279                         break;
 280         }
 281         if (suf)
 282                 printf ("PPC823ZTnn%s", suf);
 283
 284         printf (" at %s MHz:", strmhz (buf, clock));
 285
 286         printf (" %u kB I-Cache", checkicache () >> 10);
 287         printf (" %u kB D-Cache", checkdcache () >> 10);
 288
 289         /* lets check and see if we're running on a 860T (or P?) */
 290
 291         immap->im_cpm.cp_fec.fec_addr_low = 0x12345678;
 292         if (immap->im_cpm.cp_fec.fec_addr_low == 0x12345678) {
 293                 puts (" FEC present");
 294         }
 295
 296         if (!m) {
 297                 puts (cpu_warning);
 298         }
 299
 300         putc ('\n');
 301
 302         return 0;
 303 }
 304
 305 #elif defined(CONFIG_MPC850)
 306
 307 static int check_CPU (long clock, uint pvr, uint immr)
 308 {
 309         volatile immap_t *immap = (immap_t *) (immr & 0xFFFF0000);
 310         uint k, m;
 311         char buf[32];
 312
 313         /* the highest 16 bits should be 0x0050 for a 8xx */
 314
 315         if ((pvr >> 16) != 0x0050)
 316                 return -1;
 317
 318         k = (immr << 16) |
 319                 immap->im_cpm.cp_dparam16[PROFF_REVNUM / sizeof(u16)];
 320         m = 0;
 321
 322         switch (k) {
 323         case 0x20020001:
 324                 printf ("XPC850xxZT");
 325                 break;
 326         case 0x21000065:
 327                 printf ("XPC850xxZTA");
 328                 break;
 329         case 0x21010067:
 330                 printf ("XPC850xxZTB");
 331                 m = 1;
 332                 break;
 333         case 0x21020068:
 334                 printf ("XPC850xxZTC");
 335                 m = 1;
 336                 break;
 337         default:
 338                 printf ("unknown MPC850 (0x%08x)", k);
 339         }
 340         printf (" at %s MHz:", strmhz (buf, clock));
 341
 342         printf (" %u kB I-Cache", checkicache () >> 10);
 343         printf (" %u kB D-Cache", checkdcache () >> 10);
 344
 345         /* lets check and see if we're running on a 850T (or P?) */
 346
 347         immap->im_cpm.cp_fec.fec_addr_low = 0x12345678;
 348         if (immap->im_cpm.cp_fec.fec_addr_low == 0x12345678) {
 349                 printf (" FEC present");
 350         }
 351
 352         if (!m) {
 353                 puts (cpu_warning);
 354         }
 355
 356         putc ('\n');
 357
 358         return 0;
 359 }
 360 #else
 361 #error CPU undefined
 362 #endif
 363 /* ------------------------------------------------------------------------- */
 364
 365 int checkcpu (void)
 366 {
 367         ulong clock = gd->cpu_clk;
 368         uint immr = get_immr (0);       /* Return full IMMR contents */
 369         uint pvr = get_pvr ();
 370
 371         puts ("CPU:   ");
 372
 373         /* 850 has PARTNUM 20 */
 374         /* 801 has PARTNUM 10 */
 375         return check_CPU (clock, pvr, immr);
 376 }
 377
 378 /* ------------------------------------------------------------------------- */
 379 /* L1 i-cache                                                                */
 380 /* the standard 860 has 128 sets of 16 bytes in 2 ways (= 4 kB)              */
 381 /* the 860 P (plus) has 256 sets of 16 bytes in 4 ways (= 16 kB)             */
 382
 383 int checkicache (void)
 384 {
 385         volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
 386         volatile memctl8xx_t *memctl = &immap->im_memctl;
 387         u32 cacheon = rd_ic_cst () & IDC_ENABLED;
 388
 389 #ifdef CONFIG_IP86x
 390         u32 k = memctl->memc_br1 & ~0x00007fff; /* probe in flash memoryarea */
 391 #else
 392         u32 k = memctl->memc_br0 & ~0x00007fff; /* probe in flash memoryarea */
 393 #endif
 394         u32 m;
 395         u32 lines = -1;
 396
 397         wr_ic_cst (IDC_UNALL);
 398         wr_ic_cst (IDC_INVALL);
 399         wr_ic_cst (IDC_DISABLE);
 400         __asm__ volatile ("isync");
 401
 402         while (!((m = rd_ic_cst ()) & IDC_CERR2)) {
 403                 wr_ic_adr (k);
 404                 wr_ic_cst (IDC_LDLCK);
 405                 __asm__ volatile ("isync");
 406
 407                 lines++;
 408                 k += 0x10;                              /* the number of bytes in a cacheline */
 409         }
 410
 411         wr_ic_cst (IDC_UNALL);
 412         wr_ic_cst (IDC_INVALL);
 413
 414         if (cacheon)
 415                 wr_ic_cst (IDC_ENABLE);
 416         else
 417                 wr_ic_cst (IDC_DISABLE);
 418
 419         __asm__ volatile ("isync");
 420
 421         return lines << 4;
 422 };
 423
 424 /* ------------------------------------------------------------------------- */
 425 /* L1 d-cache                                                                */
 426 /* the standard 860 has 128 sets of 16 bytes in 2 ways (= 4 kB)              */
 427 /* the 860 P (plus) has 256 sets of 16 bytes in 2 ways (= 8 kB)              */
 428 /* call with cache disabled                                                  */
 429
 430 int checkdcache (void)
 431 {
 432         volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
 433         volatile memctl8xx_t *memctl = &immap->im_memctl;
 434         u32 cacheon = rd_dc_cst () & IDC_ENABLED;
 435
 436 #ifdef CONFIG_IP86x
 437         u32 k = memctl->memc_br1 & ~0x00007fff; /* probe in flash memoryarea */
 438 #else
 439         u32 k = memctl->memc_br0 & ~0x00007fff; /* probe in flash memoryarea */
 440 #endif
 441         u32 m;
 442         u32 lines = -1;
 443
 444         wr_dc_cst (IDC_UNALL);
 445         wr_dc_cst (IDC_INVALL);
 446         wr_dc_cst (IDC_DISABLE);
 447
 448         while (!((m = rd_dc_cst ()) & IDC_CERR2)) {
 449                 wr_dc_adr (k);
 450                 wr_dc_cst (IDC_LDLCK);
 451                 lines++;
 452                 k += 0x10;      /* the number of bytes in a cacheline */
 453         }
 454
 455         wr_dc_cst (IDC_UNALL);
 456         wr_dc_cst (IDC_INVALL);
 457
 458         if (cacheon)
 459                 wr_dc_cst (IDC_ENABLE);
 460         else
 461                 wr_dc_cst (IDC_DISABLE);
 462
 463         return lines << 4;
 464 };
 465
 466 /* ------------------------------------------------------------------------- */
 467
 468 void upmconfig (uint upm, uint * table, uint size)
 469 {
 470         uint i;
 471         uint addr = 0;
 472         volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
 473         volatile memctl8xx_t *memctl = &immap->im_memctl;
 474
 475         for (i = 0; i < size; i++) {
 476                 memctl->memc_mdr = table[i];    /* (16-15) */
 477                 memctl->memc_mcr = addr | upm;  /* (16-16) */
 478                 addr++;
 479         }
 480 }
 481
 482 /* ------------------------------------------------------------------------- */
 483
 484 #ifndef CONFIG_LWMON
 485
 486 int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 487 {
 488         ulong msr, addr;
 489
 490         volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
 491
 492         immap->im_clkrst.car_plprcr |= PLPRCR_CSR;      /* Checkstop Reset enable */
 493
 494         /* Interrupts and MMU off */
 495         __asm__ volatile ("mtspr    81, 0");
 496         __asm__ volatile ("mfmsr    %0":"=r" (msr));
 497
 498         msr &= ~0x1030;
 499         __asm__ volatile ("mtmsr    %0"::"r" (msr));
 500
 501         /*
 502          * Trying to execute the next instruction at a non-existing address
 503          * should cause a machine check, resulting in reset
 504          */
 505 #ifdef CONFIG_SYS_RESET_ADDRESS
 506         addr = CONFIG_SYS_RESET_ADDRESS;
 507 #else
 508         /*
 509          * note: when CONFIG_SYS_MONITOR_BASE points to a RAM address, CONFIG_SYS_MONITOR_BASE
 510          * - sizeof (ulong) is usually a valid address. Better pick an address
 511          * known to be invalid on your system and assign it to CONFIG_SYS_RESET_ADDRESS.
 512          * "(ulong)-1" used to be a good choice for many systems...
 513          */
 514         addr = CONFIG_SYS_MONITOR_BASE - sizeof (ulong);
 515 #endif
 516         ((void (*)(void)) addr) ();
 517         return 1;
 518 }
 519
 520 #else   /* CONFIG_LWMON */
 521
 522 /*
 523  * On the LWMON board, the MCLR reset input of the PIC's on the board
 524  * uses a 47K/1n RC combination which has a 47us time  constant.  The
 525  * low  signal on the HRESET pin of the CPU is only 512 clocks = 8 us
 526  * and thus too short to reset the external hardware. So we  use  the
 527  * watchdog to reset the board.
 528  */
 529 int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 530 {
 531         /* prevent triggering the watchdog */
 532         disable_interrupts ();
 533
 534         /* make sure the watchdog is running */
 535         reset_8xx_watchdog ((immap_t *) CONFIG_SYS_IMMR);
 536
 537         /* wait for watchdog reset */
 538         while (1) {};
 539
 540         /* NOTREACHED */
 541         return 1;
 542 }
 543
 544 #endif  /* CONFIG_LWMON */
 545
 546 /* ------------------------------------------------------------------------- */
 547
 548 /*
 549  * Get timebase clock frequency (like cpu_clk in Hz)
 550  *
 551  * See sections 14.2 and 14.6 of the User's Manual
 552  */
 553 unsigned long get_tbclk (void)
 554 {
 555         uint immr = get_immr (0);       /* Return full IMMR contents */
 556         volatile immap_t *immap = (volatile immap_t *)(immr & 0xFFFF0000);
 557         ulong oscclk, factor, pll;
 558
 559         if (immap->im_clkrst.car_sccr & SCCR_TBS) {
 560                 return (gd->cpu_clk / 16);
 561         }
 562
 563         pll = immap->im_clkrst.car_plprcr;
 564
 565 #define PLPRCR_val(a) ((pll & PLPRCR_ ## a ## _MSK) >> PLPRCR_ ## a ## _SHIFT)
 566
 567         /*
 568          * For newer PQ1 chips (MPC866/87x/88x families), PLL multiplication
 569          * factor is calculated as follows:
 570          *
 571          *                   MFN
 572          *           MFI + -------
 573          *                 MFD + 1
 574          * factor =  -----------------
 575          *           (PDF + 1) * 2^S
 576          *
 577          * For older chips, it's just MF field of PLPRCR plus one.
 578          */
 579         if ((immr & 0x0FFF) >= MPC8xx_NEW_CLK) { /* MPC866/87x/88x series */
 580                 factor = (PLPRCR_val(MFI) + PLPRCR_val(MFN)/(PLPRCR_val(MFD)+1))/
 581                         (PLPRCR_val(PDF)+1) / (1<<PLPRCR_val(S));
 582         } else {
 583                 factor = PLPRCR_val(MF)+1;
 584         }
 585
 586         oscclk = gd->cpu_clk / factor;
 587
 588         if ((immap->im_clkrst.car_sccr & SCCR_RTSEL) == 0 || factor > 2) {
 589                 return (oscclk / 4);
 590         }
 591         return (oscclk / 16);
 592 }
 593
 594 /* ------------------------------------------------------------------------- */
 595
 596 #if defined(CONFIG_WATCHDOG)
 597 void watchdog_reset (void)
 598 {
 599         int re_enable = disable_interrupts ();
 600
 601         reset_8xx_watchdog ((immap_t *) CONFIG_SYS_IMMR);
 602         if (re_enable)
 603                 enable_interrupts ();
 604 }
 605 #endif /* CONFIG_WATCHDOG */
 606
 607 #if defined(CONFIG_WATCHDOG) || defined(CONFIG_LWMON)
 608
 609 void reset_8xx_watchdog (volatile immap_t * immr)
 610 {
 611 # if defined(CONFIG_LWMON)
 612         /*
 613          * The LWMON board uses a MAX6301 Watchdog
 614          * with the trigger pin connected to port PA.7
 615          *
 616          * (The old board version used a MAX706TESA Watchdog, which
 617          * had to be handled exactly the same.)
 618          */
 619 # define WATCHDOG_BIT   0x0100
 620         immr->im_ioport.iop_papar &= ~(WATCHDOG_BIT);   /* GPIO     */
 621         immr->im_ioport.iop_padir |= WATCHDOG_BIT;      /* Output   */
 622         immr->im_ioport.iop_paodr &= ~(WATCHDOG_BIT);   /* active output */
 623
 624         immr->im_ioport.iop_padat ^= WATCHDOG_BIT;      /* Toggle WDI   */
 625 # elif defined(CONFIG_KUP4K) || defined(CONFIG_KUP4X)
 626         /*
 627          * The KUP4 boards uses a TPS3705 Watchdog
 628          * with the trigger pin connected to port PA.5
 629          */
 630 # define WATCHDOG_BIT   0x0400
 631         immr->im_ioport.iop_papar &= ~(WATCHDOG_BIT);   /* GPIO     */
 632         immr->im_ioport.iop_padir |= WATCHDOG_BIT;      /* Output   */
 633         immr->im_ioport.iop_paodr &= ~(WATCHDOG_BIT);   /* active output */
 634
 635         immr->im_ioport.iop_padat ^= WATCHDOG_BIT;      /* Toggle WDI   */
 636 # else
 637         /*
 638          * All other boards use the MPC8xx Internal Watchdog
 639          */
 640         immr->im_siu_conf.sc_swsr = 0x556c;     /* write magic1 */
 641         immr->im_siu_conf.sc_swsr = 0xaa39;     /* write magic2 */
 642 # endif /* CONFIG_LWMON */
 643 }
 644 #endif /* CONFIG_WATCHDOG */
 645
 646 /*
 647  * Initializes on-chip ethernet controllers.
 648  * to override, implement board_eth_init()
 649  */
 650 int cpu_eth_init(bd_t *bis)
 651 {
 652 #if defined(SCC_ENET) && defined(CONFIG_CMD_NET)
 653         scc_initialize(bis);
 654 #endif
 655 #if defined(FEC_ENET)
 656         fec_initialize(bis);
 657 #endif
 658         return 0;
 659 }