board/esd/du440/du440.c

   1 /*
   2  * (C) Copyright 2008
   3  * Matthias Fuchs, esd gmbh, matthias.fuchs@esd-electronics.com
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  18  * MA 02111-1307 USA
  19  */
  20
  21 #include <common.h>
  22 #include <asm/processor.h>
  23 #include <asm/io.h>
  24 #include <asm/bitops.h>
  25 #include <command.h>
  26 #include <i2c.h>
  27 #include <ppc440.h>
  28 #include "du440.h"
  29
  30 DECLARE_GLOBAL_DATA_PTR;
  31
  32 extern flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
  33 extern ulong flash_get_size (ulong base, int banknum);
  34
  35 int usbhub_init(void);
  36 int dvi_init(void);
  37 int eeprom_write_enable (unsigned dev_addr, int state);
  38 int board_revision(void);
  39
  40 static int du440_post_errors;
  41
  42 int board_early_init_f(void)
  43 {
  44         u32 sdr0_cust0;
  45         u32 sdr0_pfc1, sdr0_pfc2;
  46         u32 reg;
  47
  48         mtdcr(EBC0_CFGADDR, EBC0_CFG);
  49         mtdcr(EBC0_CFGDATA, 0xb8400000);
  50
  51         /*
  52          * Setup the GPIO pins
  53          */
  54         out_be32((void*)GPIO0_OR, 0x00000000 | CONFIG_SYS_GPIO0_EP_EEP);
  55         out_be32((void*)GPIO0_TCR, 0x0000001f | CONFIG_SYS_GPIO0_EP_EEP);
  56         out_be32((void*)GPIO0_OSRL, 0x50055400);
  57         out_be32((void*)GPIO0_OSRH, 0x55005000);
  58         out_be32((void*)GPIO0_TSRL, 0x50055400);
  59         out_be32((void*)GPIO0_TSRH, 0x55005000);
  60         out_be32((void*)GPIO0_ISR1L, 0x50000000);
  61         out_be32((void*)GPIO0_ISR1H, 0x00000000);
  62         out_be32((void*)GPIO0_ISR2L, 0x00000000);
  63         out_be32((void*)GPIO0_ISR2H, 0x00000000);
  64         out_be32((void*)GPIO0_ISR3L, 0x00000000);
  65         out_be32((void*)GPIO0_ISR3H, 0x00000000);
  66
  67         out_be32((void*)GPIO1_OR, 0x00000000);
  68         out_be32((void*)GPIO1_TCR, 0xc2000000 |
  69                  CONFIG_SYS_GPIO1_IORSTN |
  70                  CONFIG_SYS_GPIO1_IORST2N |
  71                  CONFIG_SYS_GPIO1_LEDUSR1 |
  72                  CONFIG_SYS_GPIO1_LEDUSR2 |
  73                  CONFIG_SYS_GPIO1_LEDPOST |
  74                  CONFIG_SYS_GPIO1_LEDDU);
  75         out_be32((void*)GPIO1_ODR, CONFIG_SYS_GPIO1_LEDDU);
  76         out_be32((void*)GPIO1_OSRL, 0x0c280000);
  77         out_be32((void*)GPIO1_OSRH, 0x00000000);
  78         out_be32((void*)GPIO1_TSRL, 0xcc000000);
  79         out_be32((void*)GPIO1_TSRH, 0x00000000);
  80         out_be32((void*)GPIO1_ISR1L, 0x00005550);
  81         out_be32((void*)GPIO1_ISR1H, 0x00000000);
  82         out_be32((void*)GPIO1_ISR2L, 0x00050000);
  83         out_be32((void*)GPIO1_ISR2H, 0x00000000);
  84         out_be32((void*)GPIO1_ISR3L, 0x01400000);
  85         out_be32((void*)GPIO1_ISR3H, 0x00000000);
  86
  87         /*
  88          * Setup the interrupt controller polarities, triggers, etc.
  89          */
  90         mtdcr(UIC0SR, 0xffffffff);      /* clear all */
  91         mtdcr(UIC0ER, 0x00000000);      /* disable all */
  92         mtdcr(UIC0CR, 0x00000005);      /* ATI & UIC1 crit are critical */
  93         mtdcr(UIC0PR, 0xfffff7ff);      /* per ref-board manual */
  94         mtdcr(UIC0TR, 0x00000000);      /* per ref-board manual */
  95         mtdcr(UIC0VR, 0x00000000);      /* int31 highest, base=0x000 */
  96         mtdcr(UIC0SR, 0xffffffff);      /* clear all */
  97
  98         /*
  99          * UIC1:
 100          *  bit30: ext. Irq 1: PLD : int 32+30
 101          */
 102         mtdcr(UIC1SR, 0xffffffff);      /* clear all */
 103         mtdcr(UIC1ER, 0x00000000);      /* disable all */
 104         mtdcr(UIC1CR, 0x00000000);      /* all non-critical */
 105         mtdcr(UIC1PR, 0xfffffffd);
 106         mtdcr(UIC1TR, 0x00000000);
 107         mtdcr(UIC1VR, 0x00000000);      /* int31 highest, base=0x000 */
 108         mtdcr(UIC1SR, 0xffffffff);      /* clear all */
 109
 110         /*
 111          * UIC2
 112          *  bit3: ext. Irq 2: DCF77 : int 64+3
 113          */
 114         mtdcr(UIC2SR, 0xffffffff);      /* clear all */
 115         mtdcr(UIC2ER, 0x00000000);      /* disable all */
 116         mtdcr(UIC2CR, 0x00000000);      /* all non-critical */
 117         mtdcr(UIC2PR, 0xffffffff);      /* per ref-board manual */
 118         mtdcr(UIC2TR, 0x00000000);      /* per ref-board manual */
 119         mtdcr(UIC2VR, 0x00000000);      /* int31 highest, base=0x000 */
 120         mtdcr(UIC2SR, 0xffffffff);      /* clear all */
 121
 122         /* select Ethernet pins */
 123         mfsdr(SDR0_PFC1, sdr0_pfc1);
 124         mfsdr(SDR0_PFC2, sdr0_pfc2);
 125
 126         /* setup EMAC bridge interface */
 127         if (board_revision() == 0) {
 128                 /* 1 x MII */
 129                 sdr0_pfc1 = (sdr0_pfc1 & ~SDR0_PFC1_SELECT_MASK) |
 130                         SDR0_PFC1_SELECT_CONFIG_1_2;
 131                 sdr0_pfc2 = (sdr0_pfc2 & ~SDR0_PFC2_SELECT_MASK) |
 132                         SDR0_PFC2_SELECT_CONFIG_1_2;
 133         } else {
 134                 /* 2 x SMII */
 135                 sdr0_pfc1 = (sdr0_pfc1 & ~SDR0_PFC1_SELECT_MASK) |
 136                         SDR0_PFC1_SELECT_CONFIG_6;
 137                 sdr0_pfc2 = (sdr0_pfc2 & ~SDR0_PFC2_SELECT_MASK) |
 138                         SDR0_PFC2_SELECT_CONFIG_6;
 139         }
 140
 141         /* enable 2nd IIC */
 142         sdr0_pfc1 = (sdr0_pfc1 & ~SDR0_PFC1_SIS_MASK) | SDR0_PFC1_SIS_IIC1_SEL;
 143
 144         mtsdr(SDR0_PFC2, sdr0_pfc2);
 145         mtsdr(SDR0_PFC1, sdr0_pfc1);
 146
 147         /* PCI arbiter enabled */
 148         mfsdr(SDR0_PCI0, reg);
 149         mtsdr(SDR0_PCI0, 0x80000000 | reg);
 150
 151         /* setup NAND FLASH */
 152         mfsdr(SDR0_CUST0, sdr0_cust0);
 153         sdr0_cust0 = SDR0_CUST0_MUX_NDFC_SEL    |
 154                 SDR0_CUST0_NDFC_ENABLE          |
 155                 SDR0_CUST0_NDFC_BW_8_BIT        |
 156                 SDR0_CUST0_NDFC_ARE_MASK        |
 157                 (0x80000000 >> (28 + CONFIG_SYS_NAND0_CS)) |
 158                 (0x80000000 >> (28 + CONFIG_SYS_NAND1_CS));
 159         mtsdr(SDR0_CUST0, sdr0_cust0);
 160
 161         return 0;
 162 }
 163
 164 int misc_init_r(void)
 165 {
 166         uint pbcr;
 167         int size_val = 0;
 168         u32 reg;
 169         unsigned long usb2d0cr = 0;
 170         unsigned long usb2phy0cr, usb2h0cr = 0;
 171         unsigned long sdr0_pfc1;
 172         unsigned long sdr0_srst0, sdr0_srst1;
 173         int i, j;
 174
 175         /* adjust flash start and offset */
 176         gd->bd->bi_flashstart = 0 - gd->bd->bi_flashsize;
 177         gd->bd->bi_flashoffset = 0;
 178
 179         mtdcr(EBC0_CFGADDR, PB0CR);
 180         pbcr = mfdcr(EBC0_CFGDATA);
 181         size_val = ffs(gd->bd->bi_flashsize) - 21;
 182         pbcr = (pbcr & 0x0001ffff) | gd->bd->bi_flashstart | (size_val << 17);
 183         mtdcr(EBC0_CFGADDR, PB0CR);
 184         mtdcr(EBC0_CFGDATA, pbcr);
 185
 186         /*
 187          * Re-check to get correct base address
 188          */
 189         flash_get_size(gd->bd->bi_flashstart, 0);
 190
 191         /*
 192          * USB suff...
 193          */
 194         /* SDR Setting */
 195         mfsdr(SDR0_PFC1, sdr0_pfc1);
 196         mfsdr(SDR0_USB0, usb2d0cr);
 197         mfsdr(SDR0_USB2PHY0CR, usb2phy0cr);
 198         mfsdr(SDR0_USB2H0CR, usb2h0cr);
 199
 200         usb2phy0cr = usb2phy0cr &~SDR0_USB2PHY0CR_XOCLK_MASK;
 201         usb2phy0cr = usb2phy0cr | SDR0_USB2PHY0CR_XOCLK_EXTERNAL;
 202         usb2phy0cr = usb2phy0cr &~SDR0_USB2PHY0CR_WDINT_MASK;
 203         usb2phy0cr = usb2phy0cr | SDR0_USB2PHY0CR_WDINT_16BIT_30MHZ;
 204         usb2phy0cr = usb2phy0cr &~SDR0_USB2PHY0CR_DVBUS_MASK;
 205         usb2phy0cr = usb2phy0cr | SDR0_USB2PHY0CR_DVBUS_PURDIS;
 206         usb2phy0cr = usb2phy0cr &~SDR0_USB2PHY0CR_DWNSTR_MASK;
 207         usb2phy0cr = usb2phy0cr | SDR0_USB2PHY0CR_DWNSTR_HOST;
 208         usb2phy0cr = usb2phy0cr &~SDR0_USB2PHY0CR_UTMICN_MASK;
 209         usb2phy0cr = usb2phy0cr | SDR0_USB2PHY0CR_UTMICN_HOST;
 210
 211         /* An 8-bit/60MHz interface is the only possible alternative
 212            when connecting the Device to the PHY */
 213         usb2h0cr   = usb2h0cr &~SDR0_USB2H0CR_WDINT_MASK;
 214         usb2h0cr   = usb2h0cr | SDR0_USB2H0CR_WDINT_16BIT_30MHZ;
 215
 216         /* To enable the USB 2.0 Device function through the UTMI interface */
 217         usb2d0cr = usb2d0cr &~SDR0_USB2D0CR_USB2DEV_EBC_SEL_MASK;
 218
 219         sdr0_pfc1 = sdr0_pfc1 &~SDR0_PFC1_UES_MASK;
 220         sdr0_pfc1 = sdr0_pfc1 | SDR0_PFC1_UES_EBCHR_SEL;
 221
 222         mtsdr(SDR0_PFC1, sdr0_pfc1);
 223         mtsdr(SDR0_USB0, usb2d0cr);
 224         mtsdr(SDR0_USB2PHY0CR, usb2phy0cr);
 225         mtsdr(SDR0_USB2H0CR, usb2h0cr);
 226
 227         /*
 228          * Take USB out of reset:
 229          * -Initial status = all cores are in reset
 230          * -deassert reset to OPB1, P4OPB0, OPB2, PLB42OPB1 OPB2PLB40 cores
 231          * -wait 1 ms
 232          * -deassert reset to PHY
 233          * -wait 1 ms
 234          * -deassert  reset to HOST
 235          * -wait 4 ms
 236          * -deassert all other resets
 237          */
 238         mfsdr(SDR0_SRST1, sdr0_srst1);
 239         sdr0_srst1 &= ~(SDR0_SRST1_OPBA1 |              \
 240                         SDR0_SRST1_P4OPB0 |             \
 241                         SDR0_SRST1_OPBA2 |              \
 242                         SDR0_SRST1_PLB42OPB1 |          \
 243                         SDR0_SRST1_OPB2PLB40);
 244         mtsdr(SDR0_SRST1, sdr0_srst1);
 245         udelay(1000);
 246
 247         mfsdr(SDR0_SRST1, sdr0_srst1);
 248         sdr0_srst1 &= ~SDR0_SRST1_USB20PHY;
 249         mtsdr(SDR0_SRST1, sdr0_srst1);
 250         udelay(1000);
 251
 252         mfsdr(SDR0_SRST0, sdr0_srst0);
 253         sdr0_srst0 &= ~SDR0_SRST0_USB2H;
 254         mtsdr(SDR0_SRST0, sdr0_srst0);
 255         udelay(4000);
 256
 257         /* finally all the other resets */
 258         mtsdr(SDR0_SRST1, 0x00000000);
 259         mtsdr(SDR0_SRST0, 0x00000000);
 260
 261         printf("USB:   Host(int phy)\n");
 262
 263         /*
 264          * Clear PLB4A0_ACR[WRP]
 265          * This fix will make the MAL burst disabling patch for the Linux
 266          * EMAC driver obsolete.
 267          */
 268         reg = mfdcr(PLB4_ACR) & ~PLB4_ACR_WRP;
 269         mtdcr(PLB4_ACR, reg);
 270
 271         /*
 272          * release IO-RST#
 273          * We have to wait at least 560ms until we may call usbhub_init
 274          */
 275         out_be32((void*)GPIO1_OR, in_be32((void*)GPIO1_OR) |
 276                  CONFIG_SYS_GPIO1_IORSTN | CONFIG_SYS_GPIO1_IORST2N);
 277
 278         /*
 279          * flash USR1/2 LEDs (600ms)
 280          * This results in the necessary delay from IORST# until
 281          * calling usbhub_init will succeed
 282          */
 283         for (j = 0; j < 3; j++) {
 284                 out_be32((void*)GPIO1_OR,
 285                          (in_be32((void*)GPIO1_OR) & ~CONFIG_SYS_GPIO1_LEDUSR2) |
 286                          CONFIG_SYS_GPIO1_LEDUSR1);
 287
 288                 for (i = 0; i < 100; i++)
 289                         udelay(1000);
 290
 291                 out_be32((void*)GPIO1_OR,
 292                          (in_be32((void*)GPIO1_OR) & ~CONFIG_SYS_GPIO1_LEDUSR1) |
 293                          CONFIG_SYS_GPIO1_LEDUSR2);
 294
 295                 for (i = 0; i < 100; i++)
 296                         udelay(1000);
 297         }
 298
 299         out_be32((void*)GPIO1_OR, in_be32((void*)GPIO1_OR) &
 300                  ~(CONFIG_SYS_GPIO1_LEDUSR1 | CONFIG_SYS_GPIO1_LEDUSR2));
 301
 302         if (usbhub_init())
 303                 du440_post_errors++;
 304
 305         if (dvi_init())
 306                 du440_post_errors++;
 307
 308         return 0;
 309 }
 310
 311 int pld_revision(void)
 312 {
 313         out_8((void *)CONFIG_SYS_CPLD_BASE, 0x00);
 314         return (int)(in_8((void *)CONFIG_SYS_CPLD_BASE) & CPLD_VERSION_MASK);
 315 }
 316
 317 int board_revision(void)
 318 {
 319         int rpins = (int)((in_be32((void*)GPIO1_IR) & CONFIG_SYS_GPIO1_HWVER_MASK)
 320                           >> CONFIG_SYS_GPIO1_HWVER_SHIFT);
 321
 322         return ((rpins & 1) << 3) | ((rpins & 2) << 1) |
 323                 ((rpins & 4) >> 1) | ((rpins & 8) >> 3);
 324 }
 325
 326 #if defined(CONFIG_SHOW_ACTIVITY)
 327 void board_show_activity (ulong timestamp)
 328 {
 329         if ((timestamp % 100) == 0)
 330                 out_be32((void*)GPIO1_OR,
 331                          in_be32((void*)GPIO1_OR) ^ CONFIG_SYS_GPIO1_LEDUSR1);
 332 }
 333
 334 void show_activity(int arg)
 335 {
 336 }
 337 #endif /* CONFIG_SHOW_ACTIVITY */
 338
 339 int du440_phy_addr(int devnum)
 340 {
 341         if (board_revision() == 0)
 342                 return devnum;
 343
 344         return devnum + 1;
 345 }
 346
 347 int checkboard(void)
 348 {
 349         char serno[32];
 350
 351         puts("Board: DU440");
 352
 353         if (getenv_r("serial#", serno, sizeof(serno)) > 0) {
 354                 puts(", serial# ");
 355                 puts(serno);
 356         }
 357
 358         printf(", HW-Rev. 1.%d, CPLD-Rev. 1.%d\n",
 359                board_revision(), pld_revision());
 360         return (0);
 361 }
 362
 363 /*
 364  * pci_pre_init
 365  *
 366  * This routine is called just prior to registering the hose and gives
 367  * the board the opportunity to check things. Returning a value of zero
 368  * indicates that things are bad & PCI initialization should be aborted.
 369  *
 370  * Different boards may wish to customize the pci controller structure
 371  * (add regions, override default access routines, etc) or perform
 372  * certain pre-initialization actions.
 373  */
 374 #if defined(CONFIG_PCI)
 375 int pci_pre_init(struct pci_controller *hose)
 376 {
 377         unsigned long addr;
 378
 379         /*
 380          * Set priority for all PLB3 devices to 0.
 381          * Set PLB3 arbiter to fair mode.
 382          */
 383         mfsdr(SD0_AMP1, addr);
 384         mtsdr(SD0_AMP1, (addr & 0x000000FF) | 0x0000FF00);
 385         addr = mfdcr(PLB3_ACR);
 386         mtdcr(PLB3_ACR, addr | 0x80000000);
 387
 388         /*
 389          * Set priority for all PLB4 devices to 0.
 390          */
 391         mfsdr(SD0_AMP0, addr);
 392         mtsdr(SD0_AMP0, (addr & 0x000000FF) | 0x0000FF00);
 393         addr = mfdcr(PLB4_ACR) | 0xa0000000; /* Was 0x8---- */
 394         mtdcr(PLB4_ACR, addr);
 395
 396         /*
 397          * Set Nebula PLB4 arbiter to fair mode.
 398          */
 399         /* Segment0 */
 400         addr = (mfdcr(PLB0_ACR) & ~PLB0_ACR_PPM_MASK) | PLB0_ACR_PPM_FAIR;
 401         addr = (addr & ~PLB0_ACR_HBU_MASK) | PLB0_ACR_HBU_ENABLED;
 402         addr = (addr & ~PLB0_ACR_RDP_MASK) | PLB0_ACR_RDP_4DEEP;
 403         addr = (addr & ~PLB0_ACR_WRP_MASK) | PLB0_ACR_WRP_2DEEP;
 404         mtdcr(PLB0_ACR, addr);
 405
 406         /* Segment1 */
 407         addr = (mfdcr(PLB1_ACR) & ~PLB1_ACR_PPM_MASK) | PLB1_ACR_PPM_FAIR;
 408         addr = (addr & ~PLB1_ACR_HBU_MASK) | PLB1_ACR_HBU_ENABLED;
 409         addr = (addr & ~PLB1_ACR_RDP_MASK) | PLB1_ACR_RDP_4DEEP;
 410         addr = (addr & ~PLB1_ACR_WRP_MASK) | PLB1_ACR_WRP_2DEEP;
 411         mtdcr(PLB1_ACR, addr);
 412
 413         return 1;
 414 }
 415 #endif /* defined(CONFIG_PCI) */
 416
 417 /*
 418  * pci_target_init
 419  *
 420  * The bootstrap configuration provides default settings for the pci
 421  * inbound map (PIM). But the bootstrap config choices are limited and
 422  * may not be sufficient for a given board.
 423  */
 424 #if defined(CONFIG_PCI) && defined(CONFIG_SYS_PCI_TARGET_INIT)
 425 void pci_target_init(struct pci_controller *hose)
 426 {
 427         /*
 428          * Set up Direct MMIO registers
 429          */
 430         /*
 431          * PowerPC440EPX PCI Master configuration.
 432          * Map one 1Gig range of PLB/processor addresses to PCI memory space.
 433          * PLB address 0xA0000000-0xDFFFFFFF
 434          *     ==> PCI address 0xA0000000-0xDFFFFFFF
 435          * Use byte reversed out routines to handle endianess.
 436          * Make this region non-prefetchable.
 437          */
 438         out32r(PCIL0_PMM0MA, 0x00000000);       /* PMM0 Mask/Attribute */
 439                                                 /* - disabled b4 setting */
 440         out32r(PCIL0_PMM0LA, CONFIG_SYS_PCI_MEMBASE);   /* PMM0 Local Address */
 441         out32r(PCIL0_PMM0PCILA, CONFIG_SYS_PCI_MEMBASE); /* PMM0 PCI Low Address */
 442         out32r(PCIL0_PMM0PCIHA, 0x00000000);    /* PMM0 PCI High Address */
 443         out32r(PCIL0_PMM0MA, 0xE0000001);       /* 512M + No prefetching, */
 444                                                 /* and enable region */
 445
 446         out32r(PCIL0_PMM1MA, 0x00000000);       /* PMM0 Mask/Attribute */
 447                                                 /* - disabled b4 setting */
 448         out32r(PCIL0_PMM1LA, CONFIG_SYS_PCI_MEMBASE2); /* PMM0 Local Address */
 449         out32r(PCIL0_PMM1PCILA, CONFIG_SYS_PCI_MEMBASE2); /* PMM0 PCI Low Address */
 450         out32r(PCIL0_PMM1PCIHA, 0x00000000);    /* PMM0 PCI High Address */
 451         out32r(PCIL0_PMM1MA, 0xE0000001);       /* 512M + No prefetching, */
 452                                                 /* and enable region */
 453
 454         out32r(PCIL0_PTM1MS, 0x00000001);       /* Memory Size/Attribute */
 455         out32r(PCIL0_PTM1LA, 0);                /* Local Addr. Reg */
 456         out32r(PCIL0_PTM2MS, 0);                /* Memory Size/Attribute */
 457         out32r(PCIL0_PTM2LA, 0);                /* Local Addr. Reg */
 458
 459         /*
 460          * Set up Configuration registers
 461          */
 462
 463         /* Program the board's subsystem id/vendor id */
 464         pci_write_config_word(0, PCI_SUBSYSTEM_VENDOR_ID,
 465                               PCI_VENDOR_ID_ESDGMBH);
 466         pci_write_config_word(0, PCI_SUBSYSTEM_ID, PCI_DEVICE_ID_DU440);
 467
 468         pci_write_config_word(0, PCI_CLASS_SUB_CODE, PCI_CLASS_BRIDGE_HOST);
 469
 470         /* Configure command register as bus master */
 471         pci_write_config_word(0, PCI_COMMAND, PCI_COMMAND_MASTER);
 472
 473         /* 240nS PCI clock */
 474         pci_write_config_word(0, PCI_LATENCY_TIMER, 1);
 475
 476         /* No error reporting */
 477         pci_write_config_word(0, PCI_ERREN, 0);
 478
 479         pci_write_config_dword(0, PCI_BRDGOPT2, 0x00000101);
 480
 481 }
 482 #endif /* defined(CONFIG_PCI) && defined(CONFIG_SYS_PCI_TARGET_INIT) */
 483
 484 #if defined(CONFIG_PCI) && defined(CONFIG_SYS_PCI_MASTER_INIT)
 485 void pci_master_init(struct pci_controller *hose)
 486 {
 487         unsigned short temp_short;
 488
 489         /*
 490          * Write the PowerPC440 EP PCI Configuration regs.
 491          * Enable PowerPC440 EP to be a master on the PCI bus (PMM).
 492          * Enable PowerPC440 EP to act as a PCI memory target (PTM).
 493          */
 494         pci_read_config_word(0, PCI_COMMAND, &temp_short);
 495         pci_write_config_word(0, PCI_COMMAND,
 496                               temp_short | PCI_COMMAND_MASTER |
 497                               PCI_COMMAND_MEMORY);
 498 }
 499 #endif /* defined(CONFIG_PCI) && defined(CONFIG_SYS_PCI_MASTER_INIT) */
 500
 501 int last_stage_init(void)
 502 {
 503         int e, i;
 504
 505         /* everyting is ok: turn on POST-LED */
 506         out_be32((void*)GPIO1_OR, in_be32((void*)GPIO1_OR) | CONFIG_SYS_GPIO1_LEDPOST);
 507
 508         /* slowly blink on errors and finally keep LED off */
 509         for (e = 0; e < du440_post_errors; e++) {
 510                 out_be32((void*)GPIO1_OR,
 511                          in_be32((void*)GPIO1_OR) | CONFIG_SYS_GPIO1_LEDPOST);
 512
 513                 for (i = 0; i < 500; i++)
 514                         udelay(1000);
 515
 516                 out_be32((void*)GPIO1_OR,
 517                          in_be32((void*)GPIO1_OR) & ~CONFIG_SYS_GPIO1_LEDPOST);
 518
 519                 for (i = 0; i < 500; i++)
 520                         udelay(1000);
 521         }
 522
 523         return 0;
 524 }
 525
 526 #if defined(CONFIG_I2C_MULTI_BUS)
 527 /*
 528  * read field strength from I2C ADC
 529  */
 530 int dcf77_status(void)
 531 {
 532         unsigned int oldbus;
 533         uchar u[2];
 534         int mv;
 535
 536         oldbus = I2C_GET_BUS();
 537         I2C_SET_BUS(1);
 538
 539         if (i2c_read (IIC1_MCP3021_ADDR, 0, 0, u, 2)) {
 540                 I2C_SET_BUS(oldbus);
 541                 return -1;
 542         }
 543
 544         mv = (int)(((u[0] << 8) | u[1]) >> 2) * 3300 / 1024;
 545
 546         I2C_SET_BUS(oldbus);
 547         return mv;
 548 }
 549
 550 int do_dcf77(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 551 {
 552         int mv;
 553         u32 pin, pinold;
 554         unsigned long long t1, t2;
 555         bd_t *bd = gd->bd;
 556
 557         printf("DCF77: ");
 558         mv = dcf77_status();
 559         if (mv > 0)
 560                 printf("signal=%d mV\n", mv);
 561         else
 562                 printf("ERROR - no signal\n");
 563
 564         t1 = t2 = 0;
 565         pinold = in_be32((void*)GPIO1_IR) & CONFIG_SYS_GPIO1_DCF77;
 566         while (!ctrlc()) {
 567                 pin = in_be32((void*)GPIO1_IR) & CONFIG_SYS_GPIO1_DCF77;
 568                 if (pin && !pinold) { /* bit start */
 569                         t1 = get_ticks();
 570                         if (t2 && ((unsigned int)(t1 - t2) /
 571                                    (bd->bi_procfreq / 1000) >= 1800))
 572                                 printf("Start of minute\n");
 573
 574                         t2 = t1;
 575                 }
 576                 if (t1 && !pin && pinold) { /* bit end */
 577                         printf("%5d\n", (unsigned int)(get_ticks() - t1) /
 578                                (bd->bi_procfreq / 1000));
 579                 }
 580                 pinold = pin;
 581         }
 582
 583         printf("Abort\n");
 584         return 0;
 585 }
 586 U_BOOT_CMD(
 587         dcf77, 1, 1, do_dcf77,
 588         "Check DCF77 receiver",
 589         ""
 590 );
 591
 592 /*
 593  * initialize USB hub via I2C1
 594  */
 595 int usbhub_init(void)
 596 {
 597         int reg;
 598         int ret = 0;
 599         unsigned int oldbus;
 600         uchar u[] = {0x04, 0x24, 0x04, 0x07, 0x25, 0x00, 0x00, 0xd3,
 601                      0x18, 0xe0, 0x00, 0x00, 0x01, 0x64, 0x01, 0x64,
 602                      0x32};
 603         uchar stcd;
 604
 605         printf("Hub:   ");
 606
 607         oldbus = I2C_GET_BUS();
 608         I2C_SET_BUS(1);
 609
 610         for (reg = 0; reg < sizeof(u); reg++)
 611                 if (i2c_write (IIC1_USB2507_ADDR, reg, 1, &u[reg], 1)) {
 612                         ret = -1;
 613                         break;
 614                 }
 615
 616         if (ret == 0) {
 617                 stcd = 0x03;
 618                 if (i2c_write (IIC1_USB2507_ADDR, 0, 1, &stcd, 1))
 619                         ret = -1;
 620         }
 621
 622         if (ret == 0)
 623                 printf("initialized\n");
 624         else
 625                 printf("failed - cannot initialize USB hub\n");
 626
 627         I2C_SET_BUS(oldbus);
 628         return ret;
 629 }
 630
 631 int do_hubinit(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 632 {
 633         usbhub_init();
 634         return 0;
 635 }
 636 U_BOOT_CMD(
 637         hubinit, 1, 1, do_hubinit,
 638         "Initialize USB hub",
 639         ""
 640 );
 641 #endif /* CONFIG_I2C_MULTI_BUS */
 642
 643 #define CONFIG_SYS_BOOT_EEPROM_PAGE_WRITE_BITS 3
 644 int boot_eeprom_write (unsigned dev_addr,
 645                        unsigned offset,
 646                        uchar *buffer,
 647                        unsigned cnt)
 648 {
 649         unsigned end = offset + cnt;
 650         unsigned blk_off;
 651         int rcode = 0;
 652
 653 #if defined(CONFIG_SYS_EEPROM_WREN)
 654         eeprom_write_enable(dev_addr, 1);
 655 #endif
 656         /*
 657          * Write data until done or would cross a write page boundary.
 658          * We must write the address again when changing pages
 659          * because the address counter only increments within a page.
 660          */
 661
 662         while (offset < end) {
 663                 unsigned alen, len;
 664                 unsigned maxlen;
 665
 666                 uchar addr[2];
 667
 668                 blk_off = offset & 0xFF;        /* block offset */
 669
 670                 addr[0] = offset >> 8;          /* block number */
 671                 addr[1] = blk_off;              /* block offset */
 672                 alen = 2;
 673                 addr[0] |= dev_addr;            /* insert device address */
 674
 675                 len = end - offset;
 676
 677                 /*
 678                  * For a FRAM device there is no limit on the number of the
 679                  * bytes that can be ccessed with the single read or write
 680                  * operation.
 681                  */
 682 #if defined(CONFIG_SYS_BOOT_EEPROM_PAGE_WRITE_BITS)
 683
 684 #define BOOT_EEPROM_PAGE_SIZE (1 << CONFIG_SYS_BOOT_EEPROM_PAGE_WRITE_BITS)
 685 #define BOOT_EEPROM_PAGE_OFFSET(x) ((x) & (BOOT_EEPROM_PAGE_SIZE - 1))
 686
 687                 maxlen = BOOT_EEPROM_PAGE_SIZE -
 688                         BOOT_EEPROM_PAGE_OFFSET(blk_off);
 689 #else
 690                 maxlen = 0x100 - blk_off;
 691 #endif
 692                 if (maxlen > I2C_RXTX_LEN)
 693                         maxlen = I2C_RXTX_LEN;
 694
 695                 if (len > maxlen)
 696                         len = maxlen;
 697
 698                 if (i2c_write (addr[0], offset, alen - 1, buffer, len) != 0)
 699                         rcode = 1;
 700
 701                 buffer += len;
 702                 offset += len;
 703
 704 #if defined(CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS)
 705                 udelay(CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS * 1000);
 706 #endif
 707         }
 708 #if defined(CONFIG_SYS_EEPROM_WREN)
 709         eeprom_write_enable(dev_addr, 0);
 710 #endif
 711         return rcode;
 712 }
 713
 714 int do_setup_boot_eeprom(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 715 {
 716         ulong sdsdp[4];
 717
 718         if (argc > 1) {
 719                 if (!strcmp(argv[1], "533")) {
 720                         printf("Bootstrapping for 533MHz\n");
 721                         sdsdp[0] = 0x87788252;
 722                         /* PLB-PCI-divider = 3 : sync PCI clock=44MHz */
 723                         sdsdp[1] = 0x095fa030;
 724                         sdsdp[2] = 0x40082350;
 725                         sdsdp[3] = 0x0d050000;
 726                 } else if (!strcmp(argv[1], "533-66")) {
 727                         printf("Bootstrapping for 533MHz (66MHz PCI)\n");
 728                         sdsdp[0] = 0x87788252;
 729                         /* PLB-PCI-divider = 2 : sync PCI clock=66MHz */
 730                         sdsdp[1] = 0x0957a030;
 731                         sdsdp[2] = 0x40082350;
 732                         sdsdp[3] = 0x0d050000;
 733                 } else if (!strcmp(argv[1], "667")) {
 734                         printf("Bootstrapping for 667MHz\n");
 735                         sdsdp[0] = 0x8778a256;
 736                         /* PLB-PCI-divider = 4 : sync PCI clock=33MHz */
 737                         sdsdp[1] = 0x0947a030;
 738                         /* PLB-PCI-divider = 3 : sync PCI clock=44MHz
 739                          * -> not working when overclocking 533MHz chips
 740                          * -> untested on 667MHz chips */
 741                         /* sdsdp[1]=0x095fa030; */
 742                         sdsdp[2] = 0x40082350;
 743                         sdsdp[3] = 0x0d050000;
 744                 } else if (!strcmp(argv[1], "667-166")) {
 745                         printf("Bootstrapping for 667-166MHz\n");
 746                         sdsdp[0] = 0x8778a252;
 747                         sdsdp[1] = 0x09d7a030;
 748                         sdsdp[2] = 0x40082350;
 749                         sdsdp[3] = 0x0d050000;
 750                 }
 751         } else {
 752                 printf("Bootstrapping for 533MHz (default)\n");
 753                 sdsdp[0] = 0x87788252;
 754                 /* PLB-PCI-divider = 3 : sync PCI clock=44MHz */
 755                 sdsdp[1] = 0x095fa030;
 756                 sdsdp[2] = 0x40082350;
 757                 sdsdp[3] = 0x0d050000;
 758         }
 759
 760         printf("Writing boot EEPROM ...\n");
 761         if (boot_eeprom_write(CONFIG_SYS_I2C_BOOT_EEPROM_ADDR,
 762                               0, (uchar*)sdsdp, 16) != 0)
 763                 printf("boot_eeprom_write failed\n");
 764         else
 765                 printf("done (dump via 'i2c md 52 0.1 10')\n");
 766
 767         return 0;
 768 }
 769 U_BOOT_CMD(
 770         sbe, 2, 0, do_setup_boot_eeprom,
 771         "setup boot eeprom",
 772         ""
 773 );
 774
 775 #if defined(CONFIG_SYS_EEPROM_WREN)
 776 /*
 777  * Input: <dev_addr>  I2C address of EEPROM device to enable.
 778  *         <state>     -1: deliver current state
 779  *                      0: disable write
 780  *                      1: enable write
 781  * Returns:            -1: wrong device address
 782  *                      0: dis-/en- able done
 783  *                    0/1: current state if <state> was -1.
 784  */
 785 int eeprom_write_enable (unsigned dev_addr, int state)
 786 {
 787         if ((CONFIG_SYS_I2C_EEPROM_ADDR != dev_addr) &&
 788             (CONFIG_SYS_I2C_BOOT_EEPROM_ADDR != dev_addr))
 789                 return -1;
 790         else {
 791                 switch (state) {
 792                 case 1:
 793                         /* Enable write access, clear bit GPIO_SINT2. */
 794                         out_be32((void*)GPIO0_OR,
 795                                  in_be32((void*)GPIO0_OR) & ~CONFIG_SYS_GPIO0_EP_EEP);
 796                         state = 0;
 797                         break;
 798                 case 0:
 799                         /* Disable write access, set bit GPIO_SINT2. */
 800                         out_be32((void*)GPIO0_OR,
 801                                  in_be32((void*)GPIO0_OR) | CONFIG_SYS_GPIO0_EP_EEP);
 802                         state = 0;
 803                         break;
 804                 default:
 805                         /* Read current status back. */
 806                         state = (0 == (in_be32((void*)GPIO0_OR) &
 807                                        CONFIG_SYS_GPIO0_EP_EEP));
 808                         break;
 809                 }
 810         }
 811         return state;
 812 }
 813
 814 int do_eep_wren (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 815 {
 816         int query = argc == 1;
 817         int state = 0;
 818
 819         if (query) {
 820                 /* Query write access state. */
 821                 state = eeprom_write_enable(CONFIG_SYS_I2C_EEPROM_ADDR, -1);
 822                 if (state < 0)
 823                         puts ("Query of write access state failed.\n");
 824                 else {
 825                         printf ("Write access for device 0x%0x is %sabled.\n",
 826                                 CONFIG_SYS_I2C_EEPROM_ADDR, state ? "en" : "dis");
 827                         state = 0;
 828                 }
 829         } else {
 830                 if ('0' == argv[1][0]) {
 831                         /* Disable write access. */
 832                         state = eeprom_write_enable(CONFIG_SYS_I2C_EEPROM_ADDR, 0);
 833                 } else {
 834                         /* Enable write access. */
 835                         state = eeprom_write_enable(CONFIG_SYS_I2C_EEPROM_ADDR, 1);
 836                 }
 837                 if (state < 0)
 838                         puts ("Setup of write access state failed.\n");
 839         }
 840
 841         return state;
 842 }
 843
 844 U_BOOT_CMD(eepwren, 2, 0, do_eep_wren,
 845         "Enable / disable / query EEPROM write access",
 846         ""
 847 );
 848 #endif /* #if defined(CONFIG_SYS_EEPROM_WREN) */
 849
 850 static int got_pldirq;
 851
 852 static int pld_interrupt(u32 arg)
 853 {
 854         int rc = -1; /* not for us */
 855         u8 status = in_8((void *)CONFIG_SYS_CPLD_BASE);
 856
 857         /* check for PLD interrupt */
 858         if (status & PWR_INT_FLAG) {
 859                 /* reset this int */
 860                 out_8((void *)CONFIG_SYS_CPLD_BASE, 0);
 861                 rc = 0;
 862                 got_pldirq = 1; /* trigger backend */
 863         }
 864
 865         return rc;
 866 }
 867
 868 int do_waitpwrirq(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 869 {
 870         got_pldirq = 0;
 871
 872         /* clear any pending interrupt */
 873         out_8((void *)CONFIG_SYS_CPLD_BASE, 0);
 874
 875         irq_install_handler(CPLD_IRQ,
 876                             (interrupt_handler_t *)pld_interrupt, 0);
 877
 878         printf("Waiting ...\n");
 879         while(!got_pldirq) {
 880                 /* Abort if ctrl-c was pressed */
 881                 if (ctrlc()) {
 882                         puts("\nAbort\n");
 883                         break;
 884                 }
 885         }
 886         if (got_pldirq) {
 887                 printf("Got interrupt!\n");
 888                 printf("Power %sready!\n",
 889                        in_8((void *)CONFIG_SYS_CPLD_BASE) &
 890                        PWR_RDY ? "":"NOT ");
 891         }
 892
 893         irq_free_handler(CPLD_IRQ);
 894         return 0;
 895 }
 896 U_BOOT_CMD(
 897         wpi,    1,      1,      do_waitpwrirq,
 898         "Wait for power change interrupt",
 899         ""
 900 );
 901
 902 /*
 903  * initialize DVI panellink transmitter
 904  */
 905 int dvi_init(void)
 906 {
 907         int i;
 908         int ret = 0;
 909         unsigned int oldbus;
 910         uchar u[] = {0x08, 0x34,
 911                      0x09, 0x20,
 912                      0x0a, 0x90,
 913                      0x0c, 0x89,
 914                      0x08, 0x35};
 915
 916         printf("DVI:   ");
 917
 918         oldbus = I2C_GET_BUS();
 919         I2C_SET_BUS(0);
 920
 921         for (i = 0; i < sizeof(u); i += 2)
 922                 if (i2c_write (0x38, u[i], 1, &u[i + 1], 1)) {
 923                         ret = -1;
 924                         break;
 925                 }
 926
 927         if (ret == 0)
 928                 printf("initialized\n");
 929         else
 930                 printf("failed - cannot initialize DVI transmitter\n");
 931
 932         I2C_SET_BUS(oldbus);
 933         return ret;
 934 }
 935
 936 int do_dviinit(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 937 {
 938         dvi_init();
 939         return 0;
 940 }
 941 U_BOOT_CMD(
 942         dviinit, 1, 1, do_dviinit,
 943         "Initialize DVI Panellink transmitter",
 944         ""
 945 );
 946
 947 /*
 948  * TODO: 'time' command might be useful for others as well.
 949  *       Move to 'common' directory.
 950  */
 951 int do_time(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 952 {
 953         unsigned long long start, end;
 954         char c, cmd[CONFIG_SYS_CBSIZE];
 955         char *p, *d = cmd;
 956         int ret, i;
 957         ulong us;
 958
 959         for (i = 1; i < argc; i++) {
 960                 p = argv[i];
 961
 962                 if (i > 1)
 963                         *d++ = ' ';
 964
 965                 while ((c = *p++) != '\0') {
 966                         *d++ = c;
 967                 }
 968         }
 969         *d = '\0';
 970
 971         start = get_ticks();
 972         ret = run_command (cmd, 0);
 973         end = get_ticks();
 974
 975         printf("ticks=%ld\n", (ulong)(end - start));
 976         us = (ulong)((1000L * (end - start)) / (get_tbclk() / 1000));
 977         printf("usec=%ld\n", us);
 978
 979         return ret;
 980 }
 981 U_BOOT_CMD(
 982         time,   CONFIG_SYS_MAXARGS,     1,      do_time,
 983         "run command and output execution time",
 984         ""
 985 );
 986
 987 extern void video_hw_rectfill (
 988         unsigned int bpp,               /* bytes per pixel */
 989         unsigned int dst_x,             /* dest pos x */
 990         unsigned int dst_y,             /* dest pos y */
 991         unsigned int dim_x,             /* frame width */
 992         unsigned int dim_y,             /* frame height */
 993         unsigned int color              /* fill color */
 994         );
 995
 996 /*
 997  * graphics demo
 998  * draw rectangles using pseudorandom number generator
 999  * (see http://www.embedded.com/columns/technicalinsights/20900500)
1000  */
1001 unsigned int rprime = 9972;
1002 static unsigned int r;
1003 static unsigned int Y;
1004
1005 unsigned int prng(unsigned int max)
1006 {
1007         if (r == 0 || r == 1 || r == -1)
1008                 r = rprime; /* keep from getting stuck */
1009
1010         r = (9973 * ~r) + ((Y) % 701); /* the actual algorithm */
1011         Y = (r >> 16) % max; /* choose upper bits and reduce */
1012         return Y;
1013 }
1014
1015 int do_gfxdemo(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
1016 {
1017         unsigned int color;
1018         unsigned int x, y, dx, dy;
1019
1020         while (!ctrlc()) {
1021                 x = prng(1280 - 1);
1022                 y = prng(1024 - 1);
1023                 dx = prng(1280- x - 1);
1024                 dy = prng(1024 - y - 1);
1025                 color = prng(0x10000);
1026                 video_hw_rectfill(2, x, y, dx, dy, color);
1027         }
1028
1029         return 0;
1030 }
1031 U_BOOT_CMD(
1032         gfxdemo,        CONFIG_SYS_MAXARGS,     1,      do_gfxdemo,
1033         "demo",
1034         ""
1035 );