cpu/mpc83xx/cpu.c

   1 /*
   2  * Copyright (C) 2004-2006 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 #endif
  37 #if defined(CONFIG_OF_LIBFDT)
  38 #include <libfdt.h>
  39 #include <libfdt_env.h>
  40 #endif
  41
  42 DECLARE_GLOBAL_DATA_PTR;
  43
  44
  45 int checkcpu(void)
  46 {
  47         volatile immap_t *immr;
  48         ulong clock = gd->cpu_clk;
  49         u32 pvr = get_pvr();
  50         u32 spridr;
  51         char buf[32];
  52
  53         immr = (immap_t *)CFG_IMMR;
  54
  55         if ((pvr & 0xFFFF0000) != PVR_83xx) {
  56                 puts("Not MPC83xx Family!!!\n");
  57                 return -1;
  58         }
  59
  60         spridr = immr->sysconf.spridr;
  61         puts("CPU: ");
  62         switch(spridr) {
  63         case SPR_8349E_REV10:
  64         case SPR_8349E_REV11:
  65         case SPR_8349E_REV31:
  66                 puts("MPC8349E, ");
  67                 break;
  68         case SPR_8349_REV10:
  69         case SPR_8349_REV11:
  70         case SPR_8349_REV31:
  71                 puts("MPC8349, ");
  72                 break;
  73         case SPR_8347E_REV10_TBGA:
  74         case SPR_8347E_REV11_TBGA:
  75         case SPR_8347E_REV31_TBGA:
  76         case SPR_8347E_REV10_PBGA:
  77         case SPR_8347E_REV11_PBGA:
  78         case SPR_8347E_REV31_PBGA:
  79                 puts("MPC8347E, ");
  80                 break;
  81         case SPR_8347_REV10_TBGA:
  82         case SPR_8347_REV11_TBGA:
  83         case SPR_8347_REV31_TBGA:
  84         case SPR_8347_REV10_PBGA:
  85         case SPR_8347_REV11_PBGA:
  86         case SPR_8347_REV31_PBGA:
  87                 puts("MPC8347, ");
  88                 break;
  89         case SPR_8343E_REV10:
  90         case SPR_8343E_REV11:
  91         case SPR_8343E_REV31:
  92                 puts("MPC8343E, ");
  93                 break;
  94         case SPR_8343_REV10:
  95         case SPR_8343_REV11:
  96         case SPR_8343_REV31:
  97                 puts("MPC8343, ");
  98                 break;
  99         case SPR_8360E_REV10:
 100         case SPR_8360E_REV11:
 101         case SPR_8360E_REV12:
 102         case SPR_8360E_REV20:
 103                 puts("MPC8360E, ");
 104                 break;
 105         case SPR_8360_REV10:
 106         case SPR_8360_REV11:
 107         case SPR_8360_REV12:
 108         case SPR_8360_REV20:
 109                 puts("MPC8360, ");
 110                 break;
 111         case SPR_8323E_REV10:
 112         case SPR_8323E_REV11:
 113                 puts("MPC8323E, ");
 114                 break;
 115         case SPR_8323_REV10:
 116         case SPR_8323_REV11:
 117                 puts("MPC8323, ");
 118                 break;
 119         case SPR_8321E_REV10:
 120         case SPR_8321E_REV11:
 121                 puts("MPC8321E, ");
 122                 break;
 123         case SPR_8321_REV10:
 124         case SPR_8321_REV11:
 125                 puts("MPC8321, ");
 126                 break;
 127         default:
 128                 puts("Rev: Unknown revision number.\nWarning: Unsupported cpu revision!\n");
 129                 return 0;
 130         }
 131
 132 #if defined(CONFIG_MPC834X)
 133         /* Multiple revisons of 834x processors may have the same SPRIDR value.
 134          * So use PVR to identify the revision number.
 135          */
 136         printf("Rev: %02x at %s MHz\n", PVR_MAJ(pvr)<<4 | PVR_MIN(pvr), strmhz(buf, clock));
 137 #else
 138         printf("Rev: %02x at %s MHz\n", spridr & 0x0000FFFF, strmhz(buf, clock));
 139 #endif
 140         return 0;
 141 }
 142
 143
 144 /*
 145  * Program a UPM with the code supplied in the table.
 146  *
 147  * The 'dummy' variable is used to increment the MAD. 'dummy' is
 148  * supposed to be a pointer to the memory of the device being
 149  * programmed by the UPM.  The data in the MDR is written into
 150  * memory and the MAD is incremented every time there's a read
 151  * from 'dummy'. Unfortunately, the current prototype for this
 152  * function doesn't allow for passing the address of this
 153  * device, and changing the prototype will break a number lots
 154  * of other code, so we need to use a round-about way of finding
 155  * the value for 'dummy'.
 156  *
 157  * The value can be extracted from the base address bits of the
 158  * Base Register (BR) associated with the specific UPM.  To find
 159  * that BR, we need to scan all 8 BRs until we find the one that
 160  * has its MSEL bits matching the UPM we want.  Once we know the
 161  * right BR, we can extract the base address bits from it.
 162  *
 163  * The MxMR and the BR and OR of the chosen bank should all be
 164  * configured before calling this function.
 165  *
 166  * Parameters:
 167  * upm: 0=UPMA, 1=UPMB, 2=UPMC
 168  * table: Pointer to an array of values to program
 169  * size: Number of elements in the array.  Must be 64 or less.
 170  */
 171 void upmconfig (uint upm, uint *table, uint size)
 172 {
 173 #if defined(CONFIG_MPC834X)
 174         volatile immap_t *immap = (immap_t *) CFG_IMMR;
 175         volatile lbus83xx_t *lbus = &immap->lbus;
 176         volatile uchar *dummy = NULL;
 177         const u32 msel = (upm + 4) << BR_MSEL_SHIFT;    /* What the MSEL field in BRn should be */
 178         volatile u32 *mxmr = &lbus->mamr + upm; /* Pointer to mamr, mbmr, or mcmr */
 179         uint i;
 180
 181         /* Scan all the banks to determine the base address of the device */
 182         for (i = 0; i < 8; i++) {
 183                 if ((lbus->bank[i].br & BR_MSEL) == msel) {
 184                         dummy = (uchar *) (lbus->bank[i].br & BR_BA);
 185                         break;
 186                 }
 187         }
 188
 189         if (!dummy) {
 190                 printf("Error: %s() could not find matching BR\n", __FUNCTION__);
 191                 hang();
 192         }
 193
 194         /* Set the OP field in the MxMR to "write" and the MAD field to 000000 */
 195         *mxmr = (*mxmr & 0xCFFFFFC0) | 0x10000000;
 196
 197         for (i = 0; i < size; i++) {
 198                 lbus->mdr = table[i];
 199                 __asm__ __volatile__ ("sync");
 200                 *dummy; /* Write the value to memory and increment MAD */
 201                 __asm__ __volatile__ ("sync");
 202         }
 203
 204         /* Set the OP field in the MxMR to "normal" and the MAD field to 000000 */
 205         *mxmr &= 0xCFFFFFC0;
 206 #else
 207         printf("Error: %s() not defined for this configuration.\n", __FUNCTION__);
 208         hang();
 209 #endif
 210 }
 211
 212
 213 int
 214 do_reset (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
 215 {
 216         ulong msr;
 217 #ifndef MPC83xx_RESET
 218         ulong addr;
 219 #endif
 220
 221         volatile immap_t *immap = (immap_t *) CFG_IMMR;
 222
 223 #ifdef MPC83xx_RESET
 224         /* Interrupts and MMU off */
 225         __asm__ __volatile__ ("mfmsr    %0":"=r" (msr):);
 226
 227         msr &= ~( MSR_EE | MSR_IR | MSR_DR);
 228         __asm__ __volatile__ ("mtmsr    %0"::"r" (msr));
 229
 230         /* enable Reset Control Reg */
 231         immap->reset.rpr = 0x52535445;
 232         __asm__ __volatile__ ("sync");
 233         __asm__ __volatile__ ("isync");
 234
 235         /* confirm Reset Control Reg is enabled */
 236         while(!((immap->reset.rcer) & RCER_CRE));
 237
 238         printf("Resetting the board.");
 239         printf("\n");
 240
 241         udelay(200);
 242
 243         /* perform reset, only one bit */
 244         immap->reset.rcr = RCR_SWHR;
 245
 246 #else   /* ! MPC83xx_RESET */
 247
 248         immap->reset.rmr = RMR_CSRE;    /* Checkstop Reset enable */
 249
 250         /* Interrupts and MMU off */
 251         __asm__ __volatile__ ("mfmsr    %0":"=r" (msr):);
 252
 253         msr &= ~(MSR_ME | MSR_EE | MSR_IR | MSR_DR);
 254         __asm__ __volatile__ ("mtmsr    %0"::"r" (msr));
 255
 256         /*
 257          * Trying to execute the next instruction at a non-existing address
 258          * should cause a machine check, resulting in reset
 259          */
 260         addr = CFG_RESET_ADDRESS;
 261
 262         printf("resetting the board.");
 263         printf("\n");
 264         ((void (*)(void)) addr) ();
 265 #endif  /* MPC83xx_RESET */
 266
 267         return 1;
 268 }
 269
 270
 271 /*
 272  * Get timebase clock frequency (like cpu_clk in Hz)
 273  */
 274
 275 unsigned long get_tbclk(void)
 276 {
 277         ulong tbclk;
 278
 279         tbclk = (gd->bus_clk + 3L) / 4L;
 280
 281         return tbclk;
 282 }
 283
 284
 285 #if defined(CONFIG_WATCHDOG)
 286 void watchdog_reset (void)
 287 {
 288         int re_enable = disable_interrupts();
 289
 290         /* Reset the 83xx watchdog */
 291         volatile immap_t *immr = (immap_t *) CFG_IMMR;
 292         immr->wdt.swsrr = 0x556c;
 293         immr->wdt.swsrr = 0xaa39;
 294
 295         if (re_enable)
 296                 enable_interrupts ();
 297 }
 298 #endif
 299
 300 #if defined(CONFIG_OF_LIBFDT)
 301
 302 /*
 303  * Fixups to the fdt.  If "create" is TRUE, the node is created
 304  * unconditionally.  If "create" is FALSE, the node is updated
 305  * only if it already exists.
 306  */
 307 #define FT_UPDATE       0x00000000              /* update existing property only */
 308 #define FT_CREATE       0x00000001              /* create property if it doesn't exist */
 309 #define FT_BUSFREQ      0x00000002              /* source is bd->bi_busfreq */
 310 #define FT_ENETADDR     0x00000004              /* source is bd->bi_enetaddr */
 311 static const struct {
 312         int  createflags;
 313         char *node;
 314         char *prop;
 315 } fixup_props[] = {
 316         {       FT_CREATE | FT_BUSFREQ,
 317                 "/cpus/" OF_CPU,
 318                  "bus-frequency",
 319         },
 320         {       FT_CREATE | FT_BUSFREQ,
 321                 "/cpus/" OF_SOC,
 322                 "bus-frequency"
 323         },
 324         {       FT_CREATE | FT_BUSFREQ,
 325                 "/" OF_SOC "/serial@4500/",
 326                 "clock-frequency"
 327         },
 328         {       FT_CREATE | FT_BUSFREQ,
 329                 "/" OF_SOC "/serial@4600/",
 330                 "clock-frequency"
 331         },
 332 #ifdef CONFIG_MPC83XX_TSEC1
 333         {       FT_UPDATE | FT_ENETADDR,
 334                 "/" OF_SOC "/ethernet@24000,
 335                 "mac-address",
 336         },
 337         {       FT_UPDATE | FT_ENETADDR,
 338                 "/" OF_SOC "/ethernet@24000,
 339                 "local-mac-address",
 340         },
 341 #endif
 342 #ifdef CONFIG_MPC83XX_TSEC2
 343         {       FT_UPDATE | FT_ENETADDR,
 344                 "/" OF_SOC "/ethernet@25000,
 345                 "mac-address",
 346         },
 347         {       FT_UPDATE | FT_ENETADDR,
 348                 "/" OF_SOC "/ethernet@25000,
 349                 "local-mac-address",
 350         },
 351 #endif
 352 };
 353
 354 void
 355 ft_cpu_setup(void *blob, bd_t *bd)
 356 {
 357         int   nodeoffset;
 358         int   err;
 359         int j;
 360
 361         for (j = 0; j < (sizeof(fixup_props) / sizeof(fixup_props[0])); j++) {
 362                 nodeoffset = fdt_path_offset (fdt, fixup_props[j].node);
 363                 if (nodeoffset >= 0) {
 364                         /*
 365                          * If unconditional create or the property already exists...
 366                          */
 367                         err = 0;
 368                         if ((fixup_props[j].createflags & FT_CREATE) ||
 369                                 (fdt_get_property(fdt, nodeoffset, fixup_props[j].prop, 0))) {
 370                                 if (fixup_props[j].createflags & FT_BUSFREQ) {
 371                                         u32   tmp;
 372
 373                                         tmp = cpu_to_be32(bd->bi_busfreq);
 374                                         err = fdt_setprop(fdt, nodeoffset,
 375                                                         fixup_props[j].prop, &tmp, sizeof(tmp));
 376                                 } else if (fixup_props[j].createflags & FT_ENETADDR) {
 377                                         err = fdt_setprop(fdt, nodeoffset,
 378                                                         fixup_props[j].prop, bd->bi_enetaddr, 6);
 379                                 } else {
 380                                         printf("ft_cpu_setup: %s %s has no flag for the value to set\n",
 381                                                 fixup_props[j].node,
 382                                                 fixup_props[j].prop);
 383                                 }
 384                                 if (err < 0)
 385                                         printf("libfdt: %s %s returned %s\n",
 386                                                 fixup_props[j].node,
 387                                                 fixup_props[j].prop,
 388                                                 fdt_strerror(err));
 389                         }
 390                 }
 391         }
 392 }
 393 #endif
 394
 395 #if defined(CONFIG_OF_FLAT_TREE)
 396 void
 397 ft_cpu_setup(void *blob, bd_t *bd)
 398 {
 399         u32 *p;
 400         int len;
 401         ulong clock;
 402
 403         clock = bd->bi_busfreq;
 404         p = ft_get_prop(blob, "/cpus/" OF_CPU "/bus-frequency", &len);
 405         if (p != NULL)
 406                 *p = cpu_to_be32(clock);
 407
 408         p = ft_get_prop(blob, "/" OF_SOC "/bus-frequency", &len);
 409         if (p != NULL)
 410                 *p = cpu_to_be32(clock);
 411
 412         p = ft_get_prop(blob, "/" OF_SOC "/serial@4500/clock-frequency", &len);
 413         if (p != NULL)
 414                 *p = cpu_to_be32(clock);
 415
 416         p = ft_get_prop(blob, "/" OF_SOC "/serial@4600/clock-frequency", &len);
 417         if (p != NULL)
 418                 *p = cpu_to_be32(clock);
 419
 420 #ifdef CONFIG_MPC83XX_TSEC1
 421         p = ft_get_prop(blob, "/" OF_SOC "/ethernet@24000/mac-address", &len);
 422         if (p != NULL)
 423                 memcpy(p, bd->bi_enetaddr, 6);
 424
 425         p = ft_get_prop(blob, "/" OF_SOC "/ethernet@24000/local-mac-address", &len);
 426         if (p != NULL)
 427                 memcpy(p, bd->bi_enetaddr, 6);
 428 #endif
 429
 430 #ifdef CONFIG_MPC83XX_TSEC2
 431         p = ft_get_prop(blob, "/" OF_SOC "/ethernet@25000/mac-address", &len);
 432         if (p != NULL)
 433                 memcpy(p, bd->bi_enet1addr, 6);
 434
 435         p = ft_get_prop(blob, "/" OF_SOC "/ethernet@25000/local-mac-address", &len);
 436         if (p != NULL)
 437                 memcpy(p, bd->bi_enet1addr, 6);
 438 #endif
 439
 440 #ifdef CONFIG_UEC_ETH1
 441 #if CFG_UEC1_UCC_NUM == 0  /* UCC1 */
 442         p = ft_get_prop(blob, "/" OF_QE "/ucc@2000/mac-address", &len);
 443         if (p != NULL)
 444                 memcpy(p, bd->bi_enetaddr, 6);
 445
 446         p = ft_get_prop(blob, "/" OF_QE "/ucc@2000/local-mac-address", &len);
 447         if (p != NULL)
 448                 memcpy(p, bd->bi_enetaddr, 6);
 449 #elif CFG_UEC1_UCC_NUM == 2  /* UCC3 */
 450         p = ft_get_prop(blob, "/" OF_QE "/ucc@2200/mac-address", &len);
 451         if (p != NULL)
 452                 memcpy(p, bd->bi_enetaddr, 6);
 453
 454         p = ft_get_prop(blob, "/" OF_QE "/ucc@2200/local-mac-address", &len);
 455         if (p != NULL)
 456                 memcpy(p, bd->bi_enetaddr, 6);
 457 #endif
 458 #endif
 459
 460 #ifdef CONFIG_UEC_ETH2
 461 #if CFG_UEC2_UCC_NUM == 1  /* UCC2 */
 462         p = ft_get_prop(blob, "/" OF_QE "/ucc@3000/mac-address", &len);
 463         if (p != NULL)
 464                 memcpy(p, bd->bi_enet1addr, 6);
 465
 466         p = ft_get_prop(blob, "/" OF_QE "/ucc@3000/local-mac-address", &len);
 467         if (p != NULL)
 468                 memcpy(p, bd->bi_enet1addr, 6);
 469 #elif CFG_UEC2_UCC_NUM == 3  /* UCC4 */
 470         p = ft_get_prop(blob, "/" OF_QE "/ucc@3200/mac-address", &len);
 471         if (p != NULL)
 472                 memcpy(p, bd->bi_enet1addr, 6);
 473
 474         p = ft_get_prop(blob, "/" OF_QE "/ucc@3200/local-mac-address", &len);
 475         if (p != NULL)
 476                 memcpy(p, bd->bi_enet1addr, 6);
 477 #endif
 478 #endif
 479 }
 480 #endif
 481
 482 #if defined(CONFIG_DDR_ECC)
 483 void dma_init(void)
 484 {
 485         volatile immap_t *immap = (immap_t *)CFG_IMMR;
 486         volatile dma83xx_t *dma = &immap->dma;
 487         volatile u32 status = swab32(dma->dmasr0);
 488         volatile u32 dmamr0 = swab32(dma->dmamr0);
 489
 490         debug("DMA-init\n");
 491
 492         /* initialize DMASARn, DMADAR and DMAABCRn */
 493         dma->dmadar0 = (u32)0;
 494         dma->dmasar0 = (u32)0;
 495         dma->dmabcr0 = 0;
 496
 497         __asm__ __volatile__ ("sync");
 498         __asm__ __volatile__ ("isync");
 499
 500         /* clear CS bit */
 501         dmamr0 &= ~DMA_CHANNEL_START;
 502         dma->dmamr0 = swab32(dmamr0);
 503         __asm__ __volatile__ ("sync");
 504         __asm__ __volatile__ ("isync");
 505
 506         /* while the channel is busy, spin */
 507         while(status & DMA_CHANNEL_BUSY) {
 508                 status = swab32(dma->dmasr0);
 509         }
 510
 511         debug("DMA-init end\n");
 512 }
 513
 514 uint dma_check(void)
 515 {
 516         volatile immap_t *immap = (immap_t *)CFG_IMMR;
 517         volatile dma83xx_t *dma = &immap->dma;
 518         volatile u32 status = swab32(dma->dmasr0);
 519         volatile u32 byte_count = swab32(dma->dmabcr0);
 520
 521         /* while the channel is busy, spin */
 522         while (status & DMA_CHANNEL_BUSY) {
 523                 status = swab32(dma->dmasr0);
 524         }
 525
 526         if (status & DMA_CHANNEL_TRANSFER_ERROR) {
 527                 printf ("DMA Error: status = %x @ %d\n", status, byte_count);
 528         }
 529
 530         return status;
 531 }
 532
 533 int dma_xfer(void *dest, u32 count, void *src)
 534 {
 535         volatile immap_t *immap = (immap_t *)CFG_IMMR;
 536         volatile dma83xx_t *dma = &immap->dma;
 537         volatile u32 dmamr0;
 538
 539         /* initialize DMASARn, DMADAR and DMAABCRn */
 540         dma->dmadar0 = swab32((u32)dest);
 541         dma->dmasar0 = swab32((u32)src);
 542         dma->dmabcr0 = swab32(count);
 543
 544         __asm__ __volatile__ ("sync");
 545         __asm__ __volatile__ ("isync");
 546
 547         /* init direct transfer, clear CS bit */
 548         dmamr0 = (DMA_CHANNEL_TRANSFER_MODE_DIRECT |
 549                         DMA_CHANNEL_SOURCE_ADDRESS_HOLD_8B |
 550                         DMA_CHANNEL_SOURCE_ADRESSS_HOLD_EN);
 551
 552         dma->dmamr0 = swab32(dmamr0);
 553
 554         __asm__ __volatile__ ("sync");
 555         __asm__ __volatile__ ("isync");
 556
 557         /* set CS to start DMA transfer */
 558         dmamr0 |= DMA_CHANNEL_START;
 559         dma->dmamr0 = swab32(dmamr0);
 560         __asm__ __volatile__ ("sync");
 561         __asm__ __volatile__ ("isync");
 562
 563         return ((int)dma_check());
 564 }
 565 #endif /*CONFIG_DDR_ECC*/