git.sur5r.net Git - u-boot/blob - cpu/mpc83xx/cpu.c

   1 /*
   2  * Copyright (C) 2004-2007 Freescale Semiconductor, Inc.
   3  *
   4  * See file CREDITS for list of people who contributed to this
   5  * project.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of
  10  * the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  20  * MA 02111-1307 USA
  21  */
  22
  23 /*
  24  * CPU specific code for the MPC83xx family.
  25  *
  26  * Derived from the MPC8260 and MPC85xx.
  27  */
  28
  29 #include <common.h>
  30 #include <watchdog.h>
  31 #include <command.h>
  32 #include <mpc83xx.h>
  33 #include <asm/processor.h>
  34 #if defined(CONFIG_OF_FLAT_TREE)
  35 #include <ft_build.h>
  36 #elif defined(CONFIG_OF_LIBFDT)
  37 #include <libfdt.h>
  38 #include <fdt_support.h>
  39 #endif
  40
  41 DECLARE_GLOBAL_DATA_PTR;
  42
  43 int checkcpu(void)
  44 {
  45         volatile immap_t *immr;
  46         ulong clock = gd->cpu_clk;
  47         u32 pvr = get_pvr();
  48         u32 spridr;
  49         char buf[32];
  50
  51         immr = (immap_t *)CFG_IMMR;
  52
  53         puts("CPU:   ");
  54
  55         switch (pvr & 0xffff0000) {
  56                 case PVR_E300C1:
  57                         printf("e300c1, ");
  58                         break;
  59
  60                 case PVR_E300C2:
  61                         printf("e300c2, ");
  62                         break;
  63
  64                 case PVR_E300C3:
  65                         printf("e300c3, ");
  66                         break;
  67
  68                 case PVR_E300C4:
  69                         printf("e300c4, ");
  70                         break;
  71
  72                 default:
  73                         printf("Unknown core, ");
  74         }
  75
  76         spridr = immr->sysconf.spridr;
  77         switch(spridr) {
  78         case SPR_8349E_REV10:
  79         case SPR_8349E_REV11:
  80         case SPR_8349E_REV31:
  81                 puts("MPC8349E, ");
  82                 break;
  83         case SPR_8349_REV10:
  84         case SPR_8349_REV11:
  85         case SPR_8349_REV31:
  86                 puts("MPC8349, ");
  87                 break;
  88         case SPR_8347E_REV10_TBGA:
  89         case SPR_8347E_REV11_TBGA:
  90         case SPR_8347E_REV31_TBGA:
  91         case SPR_8347E_REV10_PBGA:
  92         case SPR_8347E_REV11_PBGA:
  93         case SPR_8347E_REV31_PBGA:
  94                 puts("MPC8347E, ");
  95                 break;
  96         case SPR_8347_REV10_TBGA:
  97         case SPR_8347_REV11_TBGA:
  98         case SPR_8347_REV31_TBGA:
  99         case SPR_8347_REV10_PBGA:
 100         case SPR_8347_REV11_PBGA:
 101         case SPR_8347_REV31_PBGA:
 102                 puts("MPC8347, ");
 103                 break;
 104         case SPR_8343E_REV10:
 105         case SPR_8343E_REV11:
 106         case SPR_8343E_REV31:
 107                 puts("MPC8343E, ");
 108                 break;
 109         case SPR_8343_REV10:
 110         case SPR_8343_REV11:
 111         case SPR_8343_REV31:
 112                 puts("MPC8343, ");
 113                 break;
 114         case SPR_8360E_REV10:
 115         case SPR_8360E_REV11:
 116         case SPR_8360E_REV12:
 117         case SPR_8360E_REV20:
 118         case SPR_8360E_REV21:
 119                 puts("MPC8360E, ");
 120                 break;
 121         case SPR_8360_REV10:
 122         case SPR_8360_REV11:
 123         case SPR_8360_REV12:
 124         case SPR_8360_REV20:
 125         case SPR_8360_REV21:
 126                 puts("MPC8360, ");
 127                 break;
 128         case SPR_8323E_REV10:
 129         case SPR_8323E_REV11:
 130                 puts("MPC8323E, ");
 131                 break;
 132         case SPR_8323_REV10:
 133         case SPR_8323_REV11:
 134                 puts("MPC8323, ");
 135                 break;
 136         case SPR_8321E_REV10:
 137         case SPR_8321E_REV11:
 138                 puts("MPC8321E, ");
 139                 break;
 140         case SPR_8321_REV10:
 141         case SPR_8321_REV11:
 142                 puts("MPC8321, ");
 143                 break;
 144         case SPR_8311_REV10:
 145                 puts("MPC8311, ");
 146                 break;
 147         case SPR_8311E_REV10:
 148                 puts("MPC8311E, ");
 149                 break;
 150         case SPR_8313_REV10:
 151                 puts("MPC8313, ");
 152                 break;
 153         case SPR_8313E_REV10:
 154                 puts("MPC8313E, ");
 155                 break;
 156         case SPR_8379E_REV10:
 157                 puts("MPC8379E, ");
 158                 break;
 159         case SPR_8379_REV10:
 160                 puts("MPC8379, ");
 161                 break;
 162         case SPR_8378E_REV10:
 163                 puts("MPC8378E, ");
 164                 break;
 165         case SPR_8378_REV10:
 166                 puts("MPC8378, ");
 167                 break;
 168         case SPR_8377E_REV10:
 169                 puts("MPC8377E, ");
 170                 break;
 171         case SPR_8377_REV10:
 172                 puts("MPC8377, ");
 173                 break;
 174         default:
 175                 printf("Rev: Unknown revision number:%08x\n"
 176                         "Warning: Unsupported cpu revision!\n",spridr);
 177                 return 0;
 178         }
 179
 180 #if defined(CONFIG_MPC834X)
 181         /* Multiple revisons of 834x processors may have the same SPRIDR value.
 182          * So use PVR to identify the revision number.
 183          */
 184         printf("Rev: %02x at %s MHz", PVR_MAJ(pvr)<<4 | PVR_MIN(pvr), strmhz(buf, clock));
 185 #else
 186         printf("Rev: %02x at %s MHz", spridr & 0x0000FFFF, strmhz(buf, clock));
 187 #endif
 188         printf(", CSB: %4d MHz\n", gd->csb_clk / 1000000);
 189
 190         return 0;
 191 }
 192
 193
 194 /*
 195  * Program a UPM with the code supplied in the table.
 196  *
 197  * The 'dummy' variable is used to increment the MAD. 'dummy' is
 198  * supposed to be a pointer to the memory of the device being
 199  * programmed by the UPM.  The data in the MDR is written into
 200  * memory and the MAD is incremented every time there's a read
 201  * from 'dummy'. Unfortunately, the current prototype for this
 202  * function doesn't allow for passing the address of this
 203  * device, and changing the prototype will break a number lots
 204  * of other code, so we need to use a round-about way of finding
 205  * the value for 'dummy'.
 206  *
 207  * The value can be extracted from the base address bits of the
 208  * Base Register (BR) associated with the specific UPM.  To find
 209  * that BR, we need to scan all 8 BRs until we find the one that
 210  * has its MSEL bits matching the UPM we want.  Once we know the
 211  * right BR, we can extract the base address bits from it.
 212  *
 213  * The MxMR and the BR and OR of the chosen bank should all be
 214  * configured before calling this function.
 215  *
 216  * Parameters:
 217  * upm: 0=UPMA, 1=UPMB, 2=UPMC
 218  * table: Pointer to an array of values to program
 219  * size: Number of elements in the array.  Must be 64 or less.
 220  */
 221 void upmconfig (uint upm, uint *table, uint size)
 222 {
 223 #if defined(CONFIG_MPC834X)
 224         volatile immap_t *immap = (immap_t *) CFG_IMMR;
 225         volatile lbus83xx_t *lbus = &immap->lbus;
 226         volatile uchar *dummy = NULL;
 227         const u32 msel = (upm + 4) << BR_MSEL_SHIFT;    /* What the MSEL field in BRn should be */
 228         volatile u32 *mxmr = &lbus->mamr + upm; /* Pointer to mamr, mbmr, or mcmr */
 229         uint i;
 230
 231         /* Scan all the banks to determine the base address of the device */
 232         for (i = 0; i < 8; i++) {
 233                 if ((lbus->bank[i].br & BR_MSEL) == msel) {
 234                         dummy = (uchar *) (lbus->bank[i].br & BR_BA);
 235                         break;
 236                 }
 237         }
 238
 239         if (!dummy) {
 240                 printf("Error: %s() could not find matching BR\n", __FUNCTION__);
 241                 hang();
 242         }
 243
 244         /* Set the OP field in the MxMR to "write" and the MAD field to 000000 */
 245         *mxmr = (*mxmr & 0xCFFFFFC0) | 0x10000000;
 246
 247         for (i = 0; i < size; i++) {
 248                 lbus->mdr = table[i];
 249                 __asm__ __volatile__ ("sync");
 250                 *dummy; /* Write the value to memory and increment MAD */
 251                 __asm__ __volatile__ ("sync");
 252         }
 253
 254         /* Set the OP field in the MxMR to "normal" and the MAD field to 000000 */
 255         *mxmr &= 0xCFFFFFC0;
 256 #else
 257         printf("Error: %s() not defined for this configuration.\n", __FUNCTION__);
 258         hang();
 259 #endif
 260 }
 261
 262
 263 int
 264 do_reset (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
 265 {
 266         ulong msr;
 267 #ifndef MPC83xx_RESET
 268         ulong addr;
 269 #endif
 270
 271         volatile immap_t *immap = (immap_t *) CFG_IMMR;
 272
 273 #ifdef MPC83xx_RESET
 274         /* Interrupts and MMU off */
 275         __asm__ __volatile__ ("mfmsr    %0":"=r" (msr):);
 276
 277         msr &= ~( MSR_EE | MSR_IR | MSR_DR);
 278         __asm__ __volatile__ ("mtmsr    %0"::"r" (msr));
 279
 280         /* enable Reset Control Reg */
 281         immap->reset.rpr = 0x52535445;
 282         __asm__ __volatile__ ("sync");
 283         __asm__ __volatile__ ("isync");
 284
 285         /* confirm Reset Control Reg is enabled */
 286         while(!((immap->reset.rcer) & RCER_CRE));
 287
 288         printf("Resetting the board.");
 289         printf("\n");
 290
 291         udelay(200);
 292
 293         /* perform reset, only one bit */
 294         immap->reset.rcr = RCR_SWHR;
 295
 296 #else   /* ! MPC83xx_RESET */
 297
 298         immap->reset.rmr = RMR_CSRE;    /* Checkstop Reset enable */
 299
 300         /* Interrupts and MMU off */
 301         __asm__ __volatile__ ("mfmsr    %0":"=r" (msr):);
 302
 303         msr &= ~(MSR_ME | MSR_EE | MSR_IR | MSR_DR);
 304         __asm__ __volatile__ ("mtmsr    %0"::"r" (msr));
 305
 306         /*
 307          * Trying to execute the next instruction at a non-existing address
 308          * should cause a machine check, resulting in reset
 309          */
 310         addr = CFG_RESET_ADDRESS;
 311
 312         printf("resetting the board.");
 313         printf("\n");
 314         ((void (*)(void)) addr) ();
 315 #endif  /* MPC83xx_RESET */
 316
 317         return 1;
 318 }
 319
 320
 321 /*
 322  * Get timebase clock frequency (like cpu_clk in Hz)
 323  */
 324
 325 unsigned long get_tbclk(void)
 326 {
 327         ulong tbclk;
 328
 329         tbclk = (gd->bus_clk + 3L) / 4L;
 330
 331         return tbclk;
 332 }
 333
 334
 335 #if defined(CONFIG_WATCHDOG)
 336 void watchdog_reset (void)
 337 {
 338         int re_enable = disable_interrupts();
 339
 340         /* Reset the 83xx watchdog */
 341         volatile immap_t *immr = (immap_t *) CFG_IMMR;
 342         immr->wdt.swsrr = 0x556c;
 343         immr->wdt.swsrr = 0xaa39;
 344
 345         if (re_enable)
 346                 enable_interrupts ();
 347 }
 348 #endif
 349
 350 #if defined(CONFIG_OF_LIBFDT)
 351
 352 /*
 353  * "Setter" functions used to add/modify FDT entries.
 354  */
 355 static int fdt_set_eth0(void *blob, int nodeoffset, const char *name, bd_t *bd)
 356 {
 357         /* Fix it up if it exists, don't create it if it doesn't exist */
 358         if (fdt_get_property(blob, nodeoffset, name, 0)) {
 359                 return fdt_setprop(blob, nodeoffset, name, bd->bi_enetaddr, 6);
 360         }
 361         return 0;
 362 }
 363 #ifdef CONFIG_HAS_ETH1
 364 /* second onboard ethernet port */
 365 static int fdt_set_eth1(void *blob, int nodeoffset, const char *name, bd_t *bd)
 366 {
 367         /* Fix it up if it exists, don't create it if it doesn't exist */
 368         if (fdt_get_property(blob, nodeoffset, name, 0)) {
 369                 return fdt_setprop(blob, nodeoffset, name, bd->bi_enet1addr, 6);
 370         }
 371         return 0;
 372 }
 373 #endif
 374 #ifdef CONFIG_HAS_ETH2
 375 /* third onboard ethernet port */
 376 static int fdt_set_eth2(void *blob, int nodeoffset, const char *name, bd_t *bd)
 377 {
 378         /* Fix it up if it exists, don't create it if it doesn't exist */
 379         if (fdt_get_property(blob, nodeoffset, name, 0)) {
 380                 return fdt_setprop(blob, nodeoffset, name, bd->bi_enet2addr, 6);
 381         }
 382         return 0;
 383 }
 384 #endif
 385 #ifdef CONFIG_HAS_ETH3
 386 /* fourth onboard ethernet port */
 387 static int fdt_set_eth3(void *blob, int nodeoffset, const char *name, bd_t *bd)
 388 {
 389         /* Fix it up if it exists, don't create it if it doesn't exist */
 390         if (fdt_get_property(blob, nodeoffset, name, 0)) {
 391                 return fdt_setprop(blob, nodeoffset, name, bd->bi_enet3addr, 6);
 392         }
 393         return 0;
 394 }
 395 #endif
 396
 397 static int fdt_set_busfreq(void *blob, int nodeoffset, const char *name, bd_t *bd)
 398 {
 399         u32  tmp;
 400         /* Create or update the property */
 401         tmp = cpu_to_be32(bd->bi_busfreq);
 402         return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp));
 403 }
 404
 405 static int fdt_set_tbfreq(void *blob, int nodeoffset, const char *name, bd_t *bd)
 406 {
 407         u32  tmp;
 408         /* Create or update the property */
 409         tmp = cpu_to_be32(OF_TBCLK);
 410         return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp));
 411 }
 412
 413
 414 static int fdt_set_clockfreq(void *blob, int nodeoffset, const char *name, bd_t *bd)
 415 {
 416         u32  tmp;
 417         /* Create or update the property */
 418         tmp = cpu_to_be32(gd->core_clk);
 419         return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp));
 420 }
 421
 422 #ifdef CONFIG_QE
 423 static int fdt_set_qe_busfreq(void *blob, int nodeoffset, const char *name, bd_t *bd)
 424 {
 425         u32  tmp;
 426         /* Create or update the property */
 427         tmp = cpu_to_be32(gd->qe_clk);
 428         return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp));
 429 }
 430
 431 static int fdt_set_qe_brgfreq(void *blob, int nodeoffset, const char *name, bd_t *bd)
 432 {
 433         u32  tmp;
 434         /* Create or update the property */
 435         tmp = cpu_to_be32(gd->brg_clk);
 436         return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp));
 437 }
 438 #endif
 439
 440 /*
 441  * Fixups to the fdt.
 442  */
 443 static const struct {
 444         char *node;
 445         char *prop;
 446         int (*set_fn)(void *blob, int nodeoffset, const char *name, bd_t *bd);
 447 } fixup_props[] = {
 448         {       "/cpus/" OF_CPU,
 449                 "timebase-frequency",
 450                 fdt_set_tbfreq
 451         },
 452         {       "/cpus/" OF_CPU,
 453                 "bus-frequency",
 454                 fdt_set_busfreq
 455         },
 456         {       "/cpus/" OF_CPU,
 457                 "clock-frequency",
 458                 fdt_set_clockfreq
 459         },
 460         {       "/" OF_SOC,
 461                 "bus-frequency",
 462                 fdt_set_busfreq
 463         },
 464         {       "/" OF_SOC "/serial@4500",
 465                 "clock-frequency",
 466                 fdt_set_busfreq
 467         },
 468         {       "/" OF_SOC "/serial@4600",
 469                 "clock-frequency",
 470                 fdt_set_busfreq
 471         },
 472 #ifdef CONFIG_TSEC1
 473         {       "/" OF_SOC "/ethernet@24000",
 474                 "mac-address",
 475                 fdt_set_eth0
 476         },
 477         {       "/" OF_SOC "/ethernet@24000",
 478                 "local-mac-address",
 479                 fdt_set_eth0
 480         },
 481 #endif
 482 #ifdef CONFIG_TSEC2
 483         {       "/" OF_SOC "/ethernet@25000",
 484                 "mac-address",
 485                 fdt_set_eth1
 486         },
 487         {       "/" OF_SOC "/ethernet@25000",
 488                 "local-mac-address",
 489                 fdt_set_eth1
 490         },
 491 #endif
 492 #ifdef CONFIG_QE
 493         {       "/" OF_QE,
 494                 "brg-frequency",
 495                 fdt_set_qe_brgfreq
 496         },
 497         {       "/" OF_QE,
 498                 "bus-frequency",
 499                 fdt_set_qe_busfreq
 500         },
 501 #ifdef CONFIG_UEC_ETH1
 502 #if CFG_UEC1_UCC_NUM == 0  /* UCC1 */
 503         {       "/" OF_QE "/ucc@2000",
 504                 "mac-address",
 505                 fdt_set_eth0
 506         },
 507         {       "/" OF_QE "/ucc@2000",
 508                 "local-mac-address",
 509                 fdt_set_eth0
 510         },
 511 #elif CFG_UEC1_UCC_NUM == 2  /* UCC3 */
 512         {       "/" OF_QE "/ucc@2200",
 513                 "mac-address",
 514                 fdt_set_eth0
 515         },
 516         {       "/" OF_QE "/ucc@2200",
 517                 "local-mac-address",
 518                 fdt_set_eth0
 519         },
 520 #endif
 521 #endif /* CONFIG_UEC_ETH1 */
 522 #ifdef CONFIG_UEC_ETH2
 523 #if CFG_UEC2_UCC_NUM == 1  /* UCC2 */
 524         {       "/" OF_QE "/ucc@3000",
 525                 "mac-address",
 526                 fdt_set_eth1
 527         },
 528         {       "/" OF_QE "/ucc@3000",
 529                 "local-mac-address",
 530                 fdt_set_eth1
 531         },
 532 #elif CFG_UEC2_UCC_NUM == 3  /* UCC4 */
 533         {       "/" OF_QE "/ucc@3200",
 534                 "mac-address",
 535                 fdt_set_eth1
 536         },
 537         {       "/" OF_QE "/ucc@3200",
 538                 "local-mac-address",
 539                 fdt_set_eth1
 540         },
 541 #endif
 542 #endif /* CONFIG_UEC_ETH2 */
 543 #endif /* CONFIG_QE */
 544 };
 545
 546 void
 547 ft_cpu_setup(void *blob, bd_t *bd)
 548 {
 549         int nodeoffset;
 550         int err;
 551         int j;
 552
 553         for (j = 0; j < (sizeof(fixup_props) / sizeof(fixup_props[0])); j++) {
 554                 nodeoffset = fdt_path_offset(blob, fixup_props[j].node);
 555                 if (nodeoffset >= 0) {
 556                         err = fixup_props[j].set_fn(blob, nodeoffset,
 557                                                     fixup_props[j].prop, bd);
 558                         if (err < 0)
 559                                 debug("Problem setting %s = %s: %s\n",
 560                                       fixup_props[j].node, fixup_props[j].prop,
 561                                       fdt_strerror(err));
 562                 } else {
 563                         debug("Couldn't find %s: %s\n",
 564                               fixup_props[j].node, fdt_strerror(nodeoffset));
 565                 }
 566         }
 567
 568         fdt_fixup_memory(blob, (u64)bd->bi_memstart, (u64)bd->bi_memsize);
 569 }
 570 #elif defined(CONFIG_OF_FLAT_TREE)
 571 void
 572 ft_cpu_setup(void *blob, bd_t *bd)
 573 {
 574         u32 *p;
 575         int len;
 576         ulong clock;
 577
 578         clock = bd->bi_busfreq;
 579         p = ft_get_prop(blob, "/cpus/" OF_CPU "/bus-frequency", &len);
 580         if (p != NULL)
 581                 *p = cpu_to_be32(clock);
 582
 583         p = ft_get_prop(blob, "/" OF_SOC "/bus-frequency", &len);
 584         if (p != NULL)
 585                 *p = cpu_to_be32(clock);
 586
 587         p = ft_get_prop(blob, "/" OF_SOC "/serial@4500/clock-frequency", &len);
 588         if (p != NULL)
 589                 *p = cpu_to_be32(clock);
 590
 591         p = ft_get_prop(blob, "/" OF_SOC "/serial@4600/clock-frequency", &len);
 592         if (p != NULL)
 593                 *p = cpu_to_be32(clock);
 594
 595 #ifdef CONFIG_TSEC1
 596         p = ft_get_prop(blob, "/" OF_SOC "/ethernet@24000/mac-address", &len);
 597         if (p != NULL)
 598                 memcpy(p, bd->bi_enetaddr, 6);
 599
 600         p = ft_get_prop(blob, "/" OF_SOC "/ethernet@24000/local-mac-address", &len);
 601         if (p != NULL)
 602                 memcpy(p, bd->bi_enetaddr, 6);
 603 #endif
 604
 605 #ifdef CONFIG_TSEC2
 606         p = ft_get_prop(blob, "/" OF_SOC "/ethernet@25000/mac-address", &len);
 607         if (p != NULL)
 608                 memcpy(p, bd->bi_enet1addr, 6);
 609
 610         p = ft_get_prop(blob, "/" OF_SOC "/ethernet@25000/local-mac-address", &len);
 611         if (p != NULL)
 612                 memcpy(p, bd->bi_enet1addr, 6);
 613 #endif
 614
 615 #ifdef CONFIG_UEC_ETH1
 616 #if CFG_UEC1_UCC_NUM == 0  /* UCC1 */
 617         p = ft_get_prop(blob, "/" OF_QE "/ucc@2000/mac-address", &len);
 618         if (p != NULL)
 619                 memcpy(p, bd->bi_enetaddr, 6);
 620
 621         p = ft_get_prop(blob, "/" OF_QE "/ucc@2000/local-mac-address", &len);
 622         if (p != NULL)
 623                 memcpy(p, bd->bi_enetaddr, 6);
 624 #elif CFG_UEC1_UCC_NUM == 2  /* UCC3 */
 625         p = ft_get_prop(blob, "/" OF_QE "/ucc@2200/mac-address", &len);
 626         if (p != NULL)
 627                 memcpy(p, bd->bi_enetaddr, 6);
 628
 629         p = ft_get_prop(blob, "/" OF_QE "/ucc@2200/local-mac-address", &len);
 630         if (p != NULL)
 631                 memcpy(p, bd->bi_enetaddr, 6);
 632 #endif
 633 #endif
 634
 635 #ifdef CONFIG_UEC_ETH2
 636 #if CFG_UEC2_UCC_NUM == 1  /* UCC2 */
 637         p = ft_get_prop(blob, "/" OF_QE "/ucc@3000/mac-address", &len);
 638         if (p != NULL)
 639                 memcpy(p, bd->bi_enet1addr, 6);
 640
 641         p = ft_get_prop(blob, "/" OF_QE "/ucc@3000/local-mac-address", &len);
 642         if (p != NULL)
 643                 memcpy(p, bd->bi_enet1addr, 6);
 644 #elif CFG_UEC2_UCC_NUM == 3  /* UCC4 */
 645         p = ft_get_prop(blob, "/" OF_QE "/ucc@3200/mac-address", &len);
 646         if (p != NULL)
 647                 memcpy(p, bd->bi_enet1addr, 6);
 648
 649         p = ft_get_prop(blob, "/" OF_QE "/ucc@3200/local-mac-address", &len);
 650         if (p != NULL)
 651                 memcpy(p, bd->bi_enet1addr, 6);
 652 #endif
 653 #endif
 654 }
 655 #endif
 656
 657 #if defined(CONFIG_DDR_ECC)
 658 void dma_init(void)
 659 {
 660         volatile immap_t *immap = (immap_t *)CFG_IMMR;
 661         volatile dma83xx_t *dma = &immap->dma;
 662         volatile u32 status = swab32(dma->dmasr0);
 663         volatile u32 dmamr0 = swab32(dma->dmamr0);
 664
 665         debug("DMA-init\n");
 666
 667         /* initialize DMASARn, DMADAR and DMAABCRn */
 668         dma->dmadar0 = (u32)0;
 669         dma->dmasar0 = (u32)0;
 670         dma->dmabcr0 = 0;
 671
 672         __asm__ __volatile__ ("sync");
 673         __asm__ __volatile__ ("isync");
 674
 675         /* clear CS bit */
 676         dmamr0 &= ~DMA_CHANNEL_START;
 677         dma->dmamr0 = swab32(dmamr0);
 678         __asm__ __volatile__ ("sync");
 679         __asm__ __volatile__ ("isync");
 680
 681         /* while the channel is busy, spin */
 682         while(status & DMA_CHANNEL_BUSY) {
 683                 status = swab32(dma->dmasr0);
 684         }
 685
 686         debug("DMA-init end\n");
 687 }
 688
 689 uint dma_check(void)
 690 {
 691         volatile immap_t *immap = (immap_t *)CFG_IMMR;
 692         volatile dma83xx_t *dma = &immap->dma;
 693         volatile u32 status = swab32(dma->dmasr0);
 694         volatile u32 byte_count = swab32(dma->dmabcr0);
 695
 696         /* while the channel is busy, spin */
 697         while (status & DMA_CHANNEL_BUSY) {
 698                 status = swab32(dma->dmasr0);
 699         }
 700
 701         if (status & DMA_CHANNEL_TRANSFER_ERROR) {
 702                 printf ("DMA Error: status = %x @ %d\n", status, byte_count);
 703         }
 704
 705         return status;
 706 }
 707
 708 int dma_xfer(void *dest, u32 count, void *src)
 709 {
 710         volatile immap_t *immap = (immap_t *)CFG_IMMR;
 711         volatile dma83xx_t *dma = &immap->dma;
 712         volatile u32 dmamr0;
 713
 714         /* initialize DMASARn, DMADAR and DMAABCRn */
 715         dma->dmadar0 = swab32((u32)dest);
 716         dma->dmasar0 = swab32((u32)src);
 717         dma->dmabcr0 = swab32(count);
 718
 719         __asm__ __volatile__ ("sync");
 720         __asm__ __volatile__ ("isync");
 721
 722         /* init direct transfer, clear CS bit */
 723         dmamr0 = (DMA_CHANNEL_TRANSFER_MODE_DIRECT |
 724                         DMA_CHANNEL_SOURCE_ADDRESS_HOLD_8B |
 725                         DMA_CHANNEL_SOURCE_ADRESSS_HOLD_EN);
 726
 727         dma->dmamr0 = swab32(dmamr0);
 728
 729         __asm__ __volatile__ ("sync");
 730         __asm__ __volatile__ ("isync");
 731
 732         /* set CS to start DMA transfer */
 733         dmamr0 |= DMA_CHANNEL_START;
 734         dma->dmamr0 = swab32(dmamr0);
 735         __asm__ __volatile__ ("sync");
 736         __asm__ __volatile__ ("isync");
 737
 738         return ((int)dma_check());
 739 }
 740 #endif /*CONFIG_DDR_ECC*/