board/karo/tx51/tx51.c

   1 /*
   2  * Copyright (C) 2011 Lothar Waßmann <LW@KARO-electronics.de>
   3  * based on: board/freescale/mx28_evk.c (C) 2010 Freescale Semiconductor, Inc.
   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  */
  19
  20 #include <common.h>
  21 #include <errno.h>
  22 #include <libfdt.h>
  23 #include <fdt_support.h>
  24 #include <lcd.h>
  25 #include <netdev.h>
  26 #include <mmc.h>
  27 #include <fsl_esdhc.h>
  28 #include <video_fb.h>
  29 #include <ipu_pixfmt.h>
  30 #include <mx2fb.h>
  31 #include <linux/fb.h>
  32 #include <asm/io.h>
  33 #include <asm/gpio.h>
  34 #include <asm/arch/iomux-mx51.h>
  35 #include <asm/arch/clock.h>
  36 #include <asm/arch/imx-regs.h>
  37 #include <asm/arch/crm_regs.h>
  38 #include <asm/arch/sys_proto.h>
  39
  40 #include "../common/karo.h"
  41
  42 #define IMX_GPIO_NR(b, o)       ((((b) - 1) << 5) | (o))
  43
  44 #define TX51_FEC_RST_GPIO       IMX_GPIO_NR(2, 14)
  45 #define TX51_FEC_PWR_GPIO       IMX_GPIO_NR(1, 3)
  46 #define TX51_FEC_INT_GPIO       IMX_GPIO_NR(3, 18)
  47 #define TX51_LED_GPIO           IMX_GPIO_NR(4, 10)
  48
  49 #define TX51_LCD_PWR_GPIO       IMX_GPIO_NR(4, 14)
  50 #define TX51_LCD_RST_GPIO       IMX_GPIO_NR(4, 13)
  51 #define TX51_LCD_BACKLIGHT_GPIO IMX_GPIO_NR(1, 2)
  52
  53 #define TX51_RESET_OUT_GPIO     IMX_GPIO_NR(2, 15)
  54
  55 DECLARE_GLOBAL_DATA_PTR;
  56
  57 #define IOMUX_SION              IOMUX_PAD(0, 0, IOMUX_CONFIG_SION, 0, 0, 0)
  58
  59 #define FEC_PAD_CTL     (PAD_CTL_DVS | PAD_CTL_DSE_HIGH | \
  60                         PAD_CTL_SRE_FAST)
  61 #define FEC_PAD_CTL2    (PAD_CTL_DVS | PAD_CTL_SRE_FAST)
  62 #define GPIO_PAD_CTL    (PAD_CTL_DVS | PAD_CTL_DSE_HIGH)
  63
  64 static iomux_v3_cfg_t tx51_pads[] = {
  65         /* NAND flash pads are set up in lowlevel_init.S */
  66
  67         /* RESET_OUT */
  68         NEW_PAD_CTRL(MX51_PAD_EIM_A21__GPIO2_15, GPIO_PAD_CTL),
  69
  70         /* UART pads */
  71 #if CONFIG_MXC_UART_BASE == UART1_BASE
  72         MX51_PAD_UART1_RXD__UART1_RXD,
  73         MX51_PAD_UART1_TXD__UART1_TXD,
  74         MX51_PAD_UART1_RTS__UART1_RTS,
  75         MX51_PAD_UART1_CTS__UART1_CTS,
  76 #endif
  77 #if CONFIG_MXC_UART_BASE == UART2_BASE
  78         MX51_PAD_UART2_RXD__UART2_RXD,
  79         MX51_PAD_UART2_TXD__UART2_TXD,
  80         MX51_PAD_EIM_D26__UART2_RTS,
  81         MX51_PAD_EIM_D25__UART2_CTS,
  82 #endif
  83 #if CONFIG_MXC_UART_BASE == UART3_BASE
  84         MX51_PAD_UART3_RXD__UART3_RXD,
  85         MX51_PAD_UART3_TXD__UART3_TXD,
  86         MX51_PAD_EIM_D18__UART3_RTS,
  87         MX51_PAD_EIM_D17__UART3_CTS,
  88 #endif
  89         /* internal I2C */
  90         MX51_PAD_I2C1_DAT__GPIO4_17 | IOMUX_SION,
  91         MX51_PAD_I2C1_CLK__GPIO4_16 | IOMUX_SION,
  92
  93         /* FEC PHY GPIO functions */
  94         NEW_PAD_CTRL(MX51_PAD_GPIO1_3__GPIO1_3, GPIO_PAD_CTL),    /* PHY POWER */
  95         NEW_PAD_CTRL(MX51_PAD_EIM_A20__GPIO2_14, GPIO_PAD_CTL),   /* PHY RESET */
  96         NEW_PAD_CTRL(MX51_PAD_NANDF_CS2__GPIO3_18, GPIO_PAD_CTL), /* PHY INT */
  97
  98         /* FEC functions */
  99         NEW_PAD_CTRL(MX51_PAD_NANDF_CS3__FEC_MDC, FEC_PAD_CTL),
 100         NEW_PAD_CTRL(MX51_PAD_EIM_EB2__FEC_MDIO, FEC_PAD_CTL),
 101         NEW_PAD_CTRL(MX51_PAD_NANDF_D11__FEC_RX_DV, FEC_PAD_CTL2),
 102         NEW_PAD_CTRL(MX51_PAD_EIM_CS4__FEC_RX_ER, FEC_PAD_CTL2),
 103         NEW_PAD_CTRL(MX51_PAD_NANDF_RDY_INT__FEC_TX_CLK, FEC_PAD_CTL2),
 104         NEW_PAD_CTRL(MX51_PAD_NANDF_CS7__FEC_TX_EN, FEC_PAD_CTL),
 105         NEW_PAD_CTRL(MX51_PAD_NANDF_D8__FEC_TDATA0, FEC_PAD_CTL),
 106         NEW_PAD_CTRL(MX51_PAD_NANDF_CS4__FEC_TDATA1, FEC_PAD_CTL),
 107         NEW_PAD_CTRL(MX51_PAD_NANDF_CS5__FEC_TDATA2, FEC_PAD_CTL),
 108         NEW_PAD_CTRL(MX51_PAD_NANDF_CS6__FEC_TDATA3, FEC_PAD_CTL),
 109
 110         /* strap pins for PHY configuration */
 111         NEW_PAD_CTRL(MX51_PAD_NANDF_RB3__GPIO3_11, GPIO_PAD_CTL), /* RX_CLK/REGOFF */
 112         NEW_PAD_CTRL(MX51_PAD_NANDF_D9__GPIO3_31, GPIO_PAD_CTL),  /* RXD0/Mode0 */
 113         NEW_PAD_CTRL(MX51_PAD_EIM_EB3__GPIO2_23, GPIO_PAD_CTL),   /* RXD1/Mode1 */
 114         NEW_PAD_CTRL(MX51_PAD_EIM_CS2__GPIO2_27, GPIO_PAD_CTL),   /* RXD2/Mode2 */
 115         NEW_PAD_CTRL(MX51_PAD_EIM_CS3__GPIO2_28, GPIO_PAD_CTL),   /* RXD3/nINTSEL */
 116         NEW_PAD_CTRL(MX51_PAD_NANDF_RB2__GPIO3_10, GPIO_PAD_CTL), /* COL/RMII/CRSDV */
 117         NEW_PAD_CTRL(MX51_PAD_EIM_CS5__GPIO2_30, GPIO_PAD_CTL),   /* CRS/PHYAD4 */
 118
 119         /* unusable pins on TX51 */
 120         MX51_PAD_GPIO1_0__GPIO1_0,
 121         MX51_PAD_GPIO1_1__GPIO1_1,
 122 };
 123
 124 static const struct gpio tx51_gpios[] = {
 125         /* RESET_OUT */
 126         { TX51_RESET_OUT_GPIO, GPIOF_OUTPUT_INIT_LOW, "RESET_OUT", },
 127
 128         /* FEC PHY control GPIOs */
 129         { TX51_FEC_PWR_GPIO, GPIOF_OUTPUT_INIT_LOW, "FEC POWER", }, /* PHY POWER */
 130         { TX51_FEC_RST_GPIO, GPIOF_OUTPUT_INIT_LOW, "FEC RESET", }, /* PHY RESET */
 131         { TX51_FEC_INT_GPIO, GPIOF_INPUT, "FEC PHY INT", },         /* PHY INT (TX_ER) */
 132
 133         /* FEC PHY strap pins */
 134         { IMX_GPIO_NR(3, 11), GPIOF_OUTPUT_INIT_LOW, "FEC PHY REGOFF", },  /* RX_CLK/REGOFF */
 135         { IMX_GPIO_NR(3, 31), GPIOF_OUTPUT_INIT_LOW, "FEC PHY MODE0", },   /* RXD0/Mode0 */
 136         { IMX_GPIO_NR(2, 23), GPIOF_OUTPUT_INIT_LOW, "FEC PHY MODE1", },   /* RXD1/Mode1 */
 137         { IMX_GPIO_NR(2, 27), GPIOF_OUTPUT_INIT_LOW, "FEC PHY MODE2", },   /* RXD2/Mode2 */
 138         { IMX_GPIO_NR(2, 28), GPIOF_OUTPUT_INIT_LOW, "FEC PHY nINTSEL", }, /* RXD3/nINTSEL */
 139         { IMX_GPIO_NR(3, 10), GPIOF_OUTPUT_INIT_LOW, "FEC PHY RMII", },    /* COL/RMII/CRSDV */
 140         { IMX_GPIO_NR(2, 30), GPIOF_OUTPUT_INIT_LOW, "FEC PHY PHYAD4", },  /* CRS/PHYAD4 */
 141
 142         /* module internal I2C bus */
 143         { IMX_GPIO_NR(4, 17), GPIOF_INPUT, "I2C1 SDA", },
 144         { IMX_GPIO_NR(4, 16), GPIOF_INPUT, "I2C1 SCL", },
 145
 146         /* Unconnected pins */
 147         { IMX_GPIO_NR(1, 0), GPIOF_OUTPUT_INIT_LOW, "N/C", },
 148         { IMX_GPIO_NR(1, 1), GPIOF_OUTPUT_INIT_LOW, "N/C", },
 149 };
 150
 151 /*
 152  * Functions
 153  */
 154 #define WRSR_POR        (1 << 4)
 155 #define WRSR_TOUT       (1 << 1)
 156 #define WRSR_SFTW       (1 << 0)
 157
 158 /* placed in section '.data' to prevent overwriting relocation info
 159  * overlayed with bss
 160  */
 161 static u32 wrsr __attribute__((section(".data")));
 162
 163 static void print_reset_cause(void)
 164 {
 165         struct src *src_regs = (struct src *)SRC_BASE_ADDR;
 166         void __iomem *wdt_base = (void __iomem *)WDOG1_BASE_ADDR;
 167         u32 srsr;
 168         char *dlm = "";
 169
 170         printf("Reset cause: ");
 171
 172         srsr = readl(&src_regs->srsr);
 173         wrsr = readw(wdt_base + 4);
 174
 175         if (wrsr & WRSR_POR) {
 176                 printf("%sPOR", dlm);
 177                 dlm = " | ";
 178         }
 179         if (srsr & 0x00004) {
 180                 printf("%sCSU", dlm);
 181                 dlm = " | ";
 182         }
 183         if (srsr & 0x00008) {
 184                 printf("%sIPP USER", dlm);
 185                 dlm = " | ";
 186         }
 187         if (srsr & 0x00010) {
 188                 if (wrsr & WRSR_SFTW) {
 189                         printf("%sSOFT", dlm);
 190                         dlm = " | ";
 191                 }
 192                 if (wrsr & WRSR_TOUT) {
 193                         printf("%sWDOG", dlm);
 194                         dlm = " | ";
 195                 }
 196         }
 197         if (srsr & 0x00020) {
 198                 printf("%sJTAG HIGH-Z", dlm);
 199                 dlm = " | ";
 200         }
 201         if (srsr & 0x00040) {
 202                 printf("%sJTAG SW", dlm);
 203                 dlm = " | ";
 204         }
 205         if (srsr & 0x10000) {
 206                 printf("%sWARM BOOT", dlm);
 207                 dlm = " | ";
 208         }
 209         if (dlm[0] == '\0')
 210                 printf("unknown");
 211
 212         printf("\n");
 213 }
 214
 215 static void print_cpuinfo(void)
 216 {
 217         u32 cpurev;
 218
 219         cpurev = get_cpu_rev();
 220
 221         printf("CPU:   Freescale i.MX51 rev%d.%d at %d MHz\n",
 222                 (cpurev & 0x000F0) >> 4,
 223                 (cpurev & 0x0000F) >> 0,
 224                 mxc_get_clock(MXC_ARM_CLK) / 1000000);
 225
 226         print_reset_cause();
 227 }
 228
 229 int board_early_init_f(void)
 230 {
 231         struct mxc_ccm_reg *ccm_regs = (struct mxc_ccm_reg *)MXC_CCM_BASE;
 232
 233 #ifdef CONFIG_CMD_BOOTCE
 234         /* WinCE fails to enable these clocks */
 235         writel(readl(&ccm_regs->CCGR2) | 0x0c000000, &ccm_regs->CCGR2); /* usboh3_ipg_ahb */
 236         writel(readl(&ccm_regs->CCGR4) | 0x30000000, &ccm_regs->CCGR4); /* srtc */
 237         writel(readl(&ccm_regs->CCGR6) | 0x00000300, &ccm_regs->CCGR6); /* emi_garb */
 238 #endif
 239         gpio_request_array(tx51_gpios, ARRAY_SIZE(tx51_gpios));
 240         mxc_iomux_v3_setup_multiple_pads(tx51_pads, ARRAY_SIZE(tx51_pads));
 241
 242         writel(0x77777777, AIPS1_BASE_ADDR + 0x00);
 243         writel(0x77777777, AIPS1_BASE_ADDR + 0x04);
 244
 245         writel(0x00000000, AIPS1_BASE_ADDR + 0x40);
 246         writel(0x00000000, AIPS1_BASE_ADDR + 0x44);
 247         writel(0x00000000, AIPS1_BASE_ADDR + 0x48);
 248         writel(0x00000000, AIPS1_BASE_ADDR + 0x4c);
 249         writel(0x00000000, AIPS1_BASE_ADDR + 0x50);
 250
 251         writel(0x77777777, AIPS2_BASE_ADDR + 0x00);
 252         writel(0x77777777, AIPS2_BASE_ADDR + 0x04);
 253
 254         writel(0x00000000, AIPS2_BASE_ADDR + 0x40);
 255         writel(0x00000000, AIPS2_BASE_ADDR + 0x44);
 256         writel(0x00000000, AIPS2_BASE_ADDR + 0x48);
 257         writel(0x00000000, AIPS2_BASE_ADDR + 0x4c);
 258         writel(0x00000000, AIPS2_BASE_ADDR + 0x50);
 259
 260         return 0;
 261 }
 262
 263 int board_init(void)
 264 {
 265         /* Address of boot parameters */
 266         gd->bd->bi_boot_params = PHYS_SDRAM_1 + 0x1000;
 267         return 0;
 268 }
 269
 270 int dram_init(void)
 271 {
 272         int ret;
 273
 274         /* dram_init must store complete ramsize in gd->ram_size */
 275         gd->ram_size = get_ram_size((void *)CONFIG_SYS_SDRAM_BASE,
 276                                 PHYS_SDRAM_1_SIZE);
 277
 278         ret = mxc_set_clock(CONFIG_SYS_MX5_HCLK,
 279                 CONFIG_SYS_SDRAM_CLK, MXC_DDR_CLK);
 280         if (ret)
 281                 printf("%s: Failed to set DDR clock to %u MHz: %d\n", __func__,
 282                         CONFIG_SYS_SDRAM_CLK, ret);
 283         else
 284                 debug("%s: DDR clock set to %u.%03u MHz (desig.: %u.000 MHz)\n",
 285                         __func__, mxc_get_clock(MXC_DDR_CLK) / 1000000,
 286                         mxc_get_clock(MXC_DDR_CLK) / 1000 % 1000,
 287                         CONFIG_SYS_SDRAM_CLK);
 288         return ret;
 289 }
 290
 291 void dram_init_banksize(void)
 292 {
 293         gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
 294         gd->bd->bi_dram[0].size = get_ram_size((void *)PHYS_SDRAM_1,
 295                         PHYS_SDRAM_1_SIZE);
 296 #if CONFIG_NR_DRAM_BANKS > 1
 297         gd->bd->bi_dram[1].start = PHYS_SDRAM_2;
 298         gd->bd->bi_dram[1].size = get_ram_size((void *)PHYS_SDRAM_2,
 299                         PHYS_SDRAM_2_SIZE);
 300 #endif
 301 }
 302
 303 #ifdef  CONFIG_CMD_MMC
 304 int board_mmc_getcd(struct mmc *mmc)
 305 {
 306         struct fsl_esdhc_cfg *cfg = mmc->priv;
 307
 308         if (cfg->cd_gpio < 0)
 309                 return cfg->cd_gpio;
 310
 311         return !gpio_get_value(cfg->cd_gpio);
 312 }
 313
 314 static struct fsl_esdhc_cfg esdhc_cfg[] = {
 315         {
 316                 .esdhc_base = (void __iomem *)MMC_SDHC1_BASE_ADDR,
 317                 .no_snoop = 1,
 318                 .cd_gpio = IMX_GPIO_NR(3, 8),
 319                 .wp_gpio = -EINVAL,
 320         },
 321         {
 322                 .esdhc_base = (void __iomem *)MMC_SDHC2_BASE_ADDR,
 323                 .no_snoop = 1,
 324                 .cd_gpio = IMX_GPIO_NR(3, 6),
 325                 .wp_gpio = -EINVAL,
 326         },
 327 };
 328
 329 static const iomux_v3_cfg_t mmc0_pads[] = {
 330         MX51_PAD_SD1_CMD__SD1_CMD,
 331         MX51_PAD_SD1_CLK__SD1_CLK,
 332         MX51_PAD_SD1_DATA0__SD1_DATA0,
 333         MX51_PAD_SD1_DATA1__SD1_DATA1,
 334         MX51_PAD_SD1_DATA2__SD1_DATA2,
 335         MX51_PAD_SD1_DATA3__SD1_DATA3,
 336         /* SD1 CD */
 337         NEW_PAD_CTRL(MX51_PAD_DISPB2_SER_RS__GPIO3_8,
 338                 PAD_CTL_PUE | PAD_CTL_PKE),
 339 };
 340
 341 static const iomux_v3_cfg_t mmc1_pads[] = {
 342         MX51_PAD_SD2_CMD__SD2_CMD,
 343         MX51_PAD_SD2_CLK__SD2_CLK,
 344         MX51_PAD_SD2_DATA0__SD2_DATA0,
 345         MX51_PAD_SD2_DATA1__SD2_DATA1,
 346         MX51_PAD_SD2_DATA2__SD2_DATA2,
 347         MX51_PAD_SD2_DATA3__SD2_DATA3,
 348         /* SD2 CD */
 349         NEW_PAD_CTRL(MX51_PAD_DISPB2_SER_DIO__GPIO3_6,
 350                 PAD_CTL_PUE | PAD_CTL_PKE),
 351 };
 352
 353 static struct {
 354         const iomux_v3_cfg_t *pads;
 355         int count;
 356 } mmc_pad_config[] = {
 357         { mmc0_pads, ARRAY_SIZE(mmc0_pads), },
 358         { mmc1_pads, ARRAY_SIZE(mmc1_pads), },
 359 };
 360
 361 int board_mmc_init(bd_t *bis)
 362 {
 363         int i;
 364
 365         for (i = 0; i < ARRAY_SIZE(esdhc_cfg); i++) {
 366                 struct mmc *mmc;
 367
 368                 if (i >= CONFIG_SYS_FSL_ESDHC_NUM)
 369                         break;
 370
 371                 mxc_iomux_v3_setup_multiple_pads(mmc_pad_config[i].pads,
 372                                                 mmc_pad_config[i].count);
 373                 fsl_esdhc_initialize(bis, &esdhc_cfg[i]);
 374
 375                 mmc = find_mmc_device(i);
 376                 if (mmc == NULL)
 377                         continue;
 378                 if (board_mmc_getcd(mmc) > 0)
 379                         mmc_init(mmc);
 380         }
 381         return 0;
 382 }
 383 #endif /* CONFIG_CMD_MMC */
 384
 385 #ifdef CONFIG_FEC_MXC
 386
 387 #ifndef ETH_ALEN
 388 #define ETH_ALEN 6
 389 #endif
 390
 391 void imx_get_mac_from_fuse(int dev_id, unsigned char *mac)
 392 {
 393         int i;
 394         struct iim_regs *iim = (struct iim_regs *)IMX_IIM_BASE;
 395         struct fuse_bank *bank = &iim->bank[1];
 396         struct fuse_bank1_regs *fuse = (struct fuse_bank1_regs *)bank->fuse_regs;
 397
 398         if (dev_id > 0)
 399                 return;
 400
 401         for (i = 0; i < ETH_ALEN; i++)
 402                 mac[ETH_ALEN - i - 1] = readl(&fuse->mac_addr[i]);
 403 }
 404
 405 static iomux_v3_cfg_t tx51_fec_pads[] = {
 406         /* reconfigure strap pins for FEC function */
 407         NEW_PAD_CTRL(MX51_PAD_NANDF_RB3__FEC_RX_CLK, FEC_PAD_CTL2),
 408         NEW_PAD_CTRL(MX51_PAD_NANDF_D9__FEC_RDATA0, FEC_PAD_CTL2),
 409         NEW_PAD_CTRL(MX51_PAD_EIM_EB3__FEC_RDATA1, FEC_PAD_CTL2),
 410         NEW_PAD_CTRL(MX51_PAD_EIM_CS2__FEC_RDATA2, FEC_PAD_CTL2),
 411         NEW_PAD_CTRL(MX51_PAD_EIM_CS3__FEC_RDATA3, FEC_PAD_CTL2),
 412         NEW_PAD_CTRL(MX51_PAD_NANDF_RB2__FEC_COL, FEC_PAD_CTL2),
 413         NEW_PAD_CTRL(MX51_PAD_EIM_CS5__FEC_CRS, FEC_PAD_CTL),
 414 };
 415
 416 /* take bit 4 of PHY address from configured PHY address or
 417  * set it to 0 if PHYADDR is -1 (probe for PHY)
 418  */
 419 #define PHYAD4 ((CONFIG_FEC_MXC_PHYADDR >> 4) & !(CONFIG_FEC_MXC_PHYADDR >> 5))
 420
 421 static struct gpio tx51_fec_gpios[] = {
 422         { TX51_FEC_PWR_GPIO, GPIOF_OUTPUT_INIT_HIGH, "FEC PHY POWER", },
 423         { IMX_GPIO_NR(3, 31), GPIOF_OUTPUT_INIT_HIGH, "FEC PHY Mode0", },       /* RXD0/Mode0 */
 424         { IMX_GPIO_NR(2, 23), GPIOF_OUTPUT_INIT_HIGH, "FEC PHY Mode1", },       /* RXD1/Mode1 */
 425         { IMX_GPIO_NR(2, 27), GPIOF_OUTPUT_INIT_HIGH, "FEC PHY Mode2", },       /* RXD2/Mode2 */
 426         { IMX_GPIO_NR(2, 28), GPIOF_OUTPUT_INIT_HIGH, "FEC PHY nINTSEL", },     /* RXD3/nINTSEL */
 427 #if PHYAD4
 428         { IMX_GPIO_NR(2, 30), GPIOF_OUTPUT_INIT_HIGH, "FEC PHY PHYAD4", }, /* CRS/PHYAD4 */
 429 #else
 430         { IMX_GPIO_NR(2, 30), GPIOF_OUTPUT_INIT_LOW, "FEC PHY PHYAD4", }, /* CRS/PHYAD4 */
 431 #endif
 432 };
 433
 434 int board_eth_init(bd_t *bis)
 435 {
 436         int ret;
 437         unsigned char mac[ETH_ALEN];
 438         char mac_str[ETH_ALEN * 3] = "";
 439
 440         /* Power up the external phy and assert strap options */
 441         gpio_request_array(tx51_fec_gpios, ARRAY_SIZE(tx51_fec_gpios));
 442
 443         /* delay at least 21ms for the PHY internal POR signal to deassert */
 444         udelay(22000);
 445
 446         /* Deassert RESET to the external phy */
 447         gpio_set_value(TX51_FEC_RST_GPIO, 1);
 448
 449         /* Without this delay the PHY won't work, though nothing in
 450          * the datasheets suggests that it should be necessary!
 451          */
 452         udelay(400);
 453         mxc_iomux_v3_setup_multiple_pads(tx51_fec_pads,
 454                                         ARRAY_SIZE(tx51_fec_pads));
 455
 456         ret = cpu_eth_init(bis);
 457         if (ret) {
 458                 printf("cpu_eth_init() failed: %d\n", ret);
 459                 return ret;
 460         }
 461
 462         imx_get_mac_from_fuse(0, mac);
 463         snprintf(mac_str, sizeof(mac_str), "%02x:%02x:%02x:%02x:%02x:%02x",
 464                 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 465         setenv("ethaddr", mac_str);
 466
 467         return ret;
 468 }
 469 #endif /* CONFIG_FEC_MXC */
 470
 471 enum {
 472         LED_STATE_INIT = -1,
 473         LED_STATE_OFF,
 474         LED_STATE_ON,
 475 };
 476
 477 void show_activity(int arg)
 478 {
 479         static int led_state = LED_STATE_INIT;
 480         static ulong last;
 481
 482         if (led_state == LED_STATE_INIT) {
 483                 last = get_timer(0);
 484                 gpio_set_value(TX51_LED_GPIO, 1);
 485                 led_state = LED_STATE_ON;
 486         } else {
 487                 if (get_timer(last) > CONFIG_SYS_HZ) {
 488                         last = get_timer(0);
 489                         if (led_state == LED_STATE_ON) {
 490                                 gpio_set_value(TX51_LED_GPIO, 0);
 491                         } else {
 492                                 gpio_set_value(TX51_LED_GPIO, 1);
 493                         }
 494                         led_state = 1 - led_state;
 495                 }
 496         }
 497 }
 498
 499 static const iomux_v3_cfg_t stk5_pads[] = {
 500         /* SW controlled LED on STK5 baseboard */
 501         MX51_PAD_CSI2_D13__GPIO4_10,
 502
 503         /* USB PHY reset */
 504         MX51_PAD_GPIO1_4__GPIO1_4,
 505         /* USBOTG OC */
 506         MX51_PAD_GPIO1_6__GPIO1_6,
 507         /* USB PHY clock enable */
 508         MX51_PAD_GPIO1_7__GPIO1_7,
 509         /* USBH1 VBUS enable */
 510         MX51_PAD_GPIO1_8__GPIO1_8,
 511         /* USBH1 OC */
 512         MX51_PAD_GPIO1_9__GPIO1_9,
 513 };
 514
 515 static const struct gpio stk5_gpios[] = {
 516         { TX51_LED_GPIO, GPIOF_OUTPUT_INIT_LOW, "HEARTBEAT LED", },
 517
 518         { IMX_GPIO_NR(1, 4), GPIOF_OUTPUT_INIT_LOW, "ULPI PHY clk enable", },
 519         { IMX_GPIO_NR(1, 6), GPIOF_INPUT, "USBOTG OC", },
 520         { IMX_GPIO_NR(1, 7), GPIOF_OUTPUT_INIT_LOW, "ULPI PHY reset", },
 521         { IMX_GPIO_NR(1, 8), GPIOF_OUTPUT_INIT_LOW, "USBH1 VBUS enable", },
 522         { IMX_GPIO_NR(1, 9), GPIOF_INPUT, "USBH1 OC", },
 523 };
 524
 525 #ifdef CONFIG_LCD
 526 vidinfo_t panel_info = {
 527         /* set to max. size supported by SoC */
 528         .vl_col = 1600,
 529         .vl_row = 1200,
 530
 531         .vl_bpix = LCD_COLOR24,    /* Bits per pixel, 0: 1bpp, 1: 2bpp, 2: 4bpp, 3: 8bpp ... */
 532 };
 533
 534 static struct fb_videomode tx51_fb_mode = {
 535         /* Standard VGA timing */
 536         .name           = "VGA",
 537         .refresh        = 60,
 538         .xres           = 640,
 539         .yres           = 480,
 540         .pixclock       = KHZ2PICOS(25175),
 541         .left_margin    = 48,
 542         .hsync_len      = 96,
 543         .right_margin   = 16,
 544         .upper_margin   = 31,
 545         .vsync_len      = 2,
 546         .lower_margin   = 12,
 547         .sync           = FB_SYNC_CLK_LAT_FALL,
 548         .vmode          = FB_VMODE_NONINTERLACED,
 549 };
 550
 551 void *lcd_base;                 /* Start of framebuffer memory  */
 552 void *lcd_console_address;      /* Start of console buffer      */
 553
 554 int lcd_line_length;
 555 int lcd_color_fg;
 556 int lcd_color_bg;
 557
 558 short console_col;
 559 short console_row;
 560
 561 void lcd_initcolregs(void)
 562 {
 563 }
 564
 565 void lcd_setcolreg(ushort regno, ushort red, ushort green, ushort blue)
 566 {
 567 }
 568
 569 static int lcd_enabled = 1;
 570
 571 void lcd_enable(void)
 572 {
 573         /* HACK ALERT:
 574          * global variable from common/lcd.c
 575          * Set to 0 here to prevent messages from going to LCD
 576          * rather than serial console
 577          */
 578         lcd_is_enabled = 0;
 579
 580         karo_load_splashimage(1);
 581         if (lcd_enabled) {
 582                 debug("Switching LCD on\n");
 583                 gpio_set_value(TX51_LCD_PWR_GPIO, 1);
 584                 udelay(100);
 585                 gpio_set_value(TX51_LCD_RST_GPIO, 1);
 586                 udelay(300000);
 587                 gpio_set_value(TX51_LCD_BACKLIGHT_GPIO, 0);
 588         }
 589 }
 590
 591 void mxcfb_disable(void);
 592
 593 void lcd_disable(void)
 594 {
 595         mxcfb_disable();
 596 }
 597
 598 void lcd_panel_disable(void)
 599 {
 600         if (lcd_enabled) {
 601                 debug("Switching LCD off\n");
 602                 gpio_set_value(TX51_LCD_BACKLIGHT_GPIO, 1);
 603                 gpio_set_value(TX51_LCD_RST_GPIO, 0);
 604                 gpio_set_value(TX51_LCD_PWR_GPIO, 0);
 605         }
 606 }
 607
 608 static const iomux_v3_cfg_t stk5_lcd_pads[] = {
 609         /* LCD RESET */
 610         MX51_PAD_CSI2_VSYNC__GPIO4_13,
 611         /* LCD POWER_ENABLE */
 612         MX51_PAD_CSI2_HSYNC__GPIO4_14,
 613         /* LCD Backlight (PWM) */
 614         MX51_PAD_GPIO1_2__GPIO1_2,
 615
 616         /* Display */
 617         MX51_PAD_DISP1_DAT0__DISP1_DAT0,
 618         MX51_PAD_DISP1_DAT1__DISP1_DAT1,
 619         MX51_PAD_DISP1_DAT2__DISP1_DAT2,
 620         MX51_PAD_DISP1_DAT3__DISP1_DAT3,
 621         MX51_PAD_DISP1_DAT4__DISP1_DAT4,
 622         MX51_PAD_DISP1_DAT5__DISP1_DAT5,
 623         MX51_PAD_DISP1_DAT6__DISP1_DAT6,
 624         MX51_PAD_DISP1_DAT7__DISP1_DAT7,
 625         MX51_PAD_DISP1_DAT8__DISP1_DAT8,
 626         MX51_PAD_DISP1_DAT9__DISP1_DAT9,
 627         MX51_PAD_DISP1_DAT10__DISP1_DAT10,
 628         MX51_PAD_DISP1_DAT11__DISP1_DAT11,
 629         MX51_PAD_DISP1_DAT12__DISP1_DAT12,
 630         MX51_PAD_DISP1_DAT13__DISP1_DAT13,
 631         MX51_PAD_DISP1_DAT14__DISP1_DAT14,
 632         MX51_PAD_DISP1_DAT15__DISP1_DAT15,
 633         MX51_PAD_DISP1_DAT16__DISP1_DAT16,
 634         MX51_PAD_DISP1_DAT17__DISP1_DAT17,
 635         MX51_PAD_DISP1_DAT18__DISP1_DAT18,
 636         MX51_PAD_DISP1_DAT19__DISP1_DAT19,
 637         MX51_PAD_DISP1_DAT20__DISP1_DAT20,
 638         MX51_PAD_DISP1_DAT21__DISP1_DAT21,
 639         MX51_PAD_DISP1_DAT22__DISP1_DAT22,
 640         MX51_PAD_DISP1_DAT23__DISP1_DAT23,
 641         MX51_PAD_DI1_PIN2__DI1_PIN2, /* HSYNC */
 642         MX51_PAD_DI1_PIN3__DI1_PIN3, /* VSYNC */
 643 };
 644
 645 static const struct gpio stk5_lcd_gpios[] = {
 646         { TX51_LCD_RST_GPIO, GPIOF_OUTPUT_INIT_LOW, "LCD RESET", },
 647         { TX51_LCD_PWR_GPIO, GPIOF_OUTPUT_INIT_LOW, "LCD POWER", },
 648         { TX51_LCD_BACKLIGHT_GPIO, GPIOF_OUTPUT_INIT_HIGH, "LCD BACKLIGHT", },
 649 };
 650
 651 void lcd_ctrl_init(void *lcdbase)
 652 {
 653         int color_depth = 24;
 654         char *vm;
 655         unsigned long val;
 656         int refresh = 60;
 657         struct fb_videomode *p = &tx51_fb_mode;
 658         int xres_set = 0, yres_set = 0, bpp_set = 0, refresh_set = 0;
 659         int pix_fmt = 0;
 660
 661         if (!lcd_enabled) {
 662                 debug("LCD disabled\n");
 663                 return;
 664         }
 665
 666         if (tstc() || (wrsr & WRSR_TOUT)) {
 667                 debug("Disabling LCD\n");
 668                 lcd_enabled = 0;
 669                 return;
 670         }
 671
 672         vm = getenv("video_mode");
 673         if (vm == NULL) {
 674                 debug("Disabling LCD\n");
 675                 lcd_enabled = 0;
 676                 return;
 677         }
 678         while (*vm != '\0') {
 679                 if (*vm >= '0' && *vm <= '9') {
 680                         char *end;
 681
 682                         val = simple_strtoul(vm, &end, 0);
 683                         if (end > vm) {
 684                                 if (!xres_set) {
 685                                         if (val > panel_info.vl_col)
 686                                                 val = panel_info.vl_col;
 687                                         p->xres = val;
 688                                         panel_info.vl_col = val;
 689                                         xres_set = 1;
 690                                 } else if (!yres_set) {
 691                                         if (val > panel_info.vl_row)
 692                                                 val = panel_info.vl_row;
 693                                         p->yres = val;
 694                                         panel_info.vl_row = val;
 695                                         yres_set = 1;
 696                                 } else if (!bpp_set) {
 697                                         switch (val) {
 698                                         case 8:
 699                                         case 16:
 700                                         case 24:
 701                                                 color_depth = val;
 702                                                 break;
 703
 704                                         default:
 705                                                 printf("Invalid color depth: '%.*s' in video_mode; using default: '%u'\n",
 706                                                         end - vm, vm, color_depth);
 707                                         }
 708                                         bpp_set = 1;
 709                                 } else if (!refresh_set) {
 710                                         refresh = val;
 711                                         refresh_set = 1;
 712                                 }
 713                         }
 714                         vm = end;
 715                 }
 716                 switch (*vm) {
 717                 case '@':
 718                         bpp_set = 1;
 719                         /* fallthru */
 720                 case '-':
 721                         yres_set = 1;
 722                         /* fallthru */
 723                 case 'x':
 724                         xres_set = 1;
 725                         /* fallthru */
 726                 case 'M':
 727                 case 'R':
 728                         vm++;
 729                         break;
 730
 731                 default:
 732                         if (!pix_fmt) {
 733                                 char *tmp;
 734
 735                                 pix_fmt = IPU_PIX_FMT_RGB24;
 736                                 tmp = strchr(vm, ':');
 737                                 if (tmp)
 738                                         vm = tmp;
 739                         }
 740                         if (*vm != '\0')
 741                                 vm++;
 742                 }
 743         }
 744         switch (color_depth) {
 745         case 8:
 746                 panel_info.vl_bpix = 3;
 747                 break;
 748
 749         case 16:
 750                 panel_info.vl_bpix = 4;
 751                 break;
 752
 753         case 24:
 754                 panel_info.vl_bpix = 5;
 755         }
 756         lcd_line_length = NBITS(panel_info.vl_bpix) / 8 * panel_info.vl_col;
 757
 758         p->pixclock = KHZ2PICOS(refresh *
 759                 (p->xres + p->left_margin + p->right_margin + p->hsync_len) *
 760                 (p->yres + p->upper_margin + p->lower_margin + p->vsync_len)
 761                 / 1000);
 762         debug("Pixel clock set to %lu.%03lu MHz\n",
 763                 PICOS2KHZ(p->pixclock) / 1000,
 764                 PICOS2KHZ(p->pixclock) % 1000);
 765
 766         gpio_request_array(stk5_lcd_gpios, ARRAY_SIZE(stk5_lcd_gpios));
 767         mxc_iomux_v3_setup_multiple_pads(stk5_lcd_pads,
 768                                         ARRAY_SIZE(stk5_lcd_pads));
 769
 770         debug("Initializing FB driver\n");
 771         if (!pix_fmt)
 772                 pix_fmt = IPU_PIX_FMT_RGB24;
 773
 774         if (karo_load_splashimage(0) == 0) {
 775                 struct mxc_ccm_reg *ccm_regs = (struct mxc_ccm_reg *)MXC_CCM_BASE;
 776                 u32 ccgr4 = readl(&ccm_regs->CCGR4);
 777
 778                 debug("Initializing LCD controller\n");
 779                 mx5_fb_init(p, 0, pix_fmt, 1 << panel_info.vl_bpix);
 780
 781                 /* MIPI HSC clock is required for initialization */
 782                 writel(ccgr4 | (3 << 12), &ccm_regs->CCGR4);
 783                 video_hw_init();
 784                 writel(ccgr4 & ~(3 << 12), &ccm_regs->CCGR4);
 785         } else {
 786                 debug("Skipping initialization of LCD controller\n");
 787         }
 788 }
 789 #else
 790 #define lcd_enabled 0
 791 #endif /* CONFIG_LCD */
 792
 793 static void stk5_board_init(void)
 794 {
 795         gpio_request_array(stk5_gpios, ARRAY_SIZE(stk5_gpios));
 796         mxc_iomux_v3_setup_multiple_pads(stk5_pads, ARRAY_SIZE(stk5_pads));
 797 }
 798
 799 static void stk5v3_board_init(void)
 800 {
 801         stk5_board_init();
 802 }
 803
 804 static void tx51_set_cpu_clock(void)
 805 {
 806         unsigned long cpu_clk = getenv_ulong("cpu_clk", 10, 0);
 807         int ret;
 808
 809         if (tstc() || (wrsr & WRSR_TOUT))
 810                 return;
 811
 812         if (cpu_clk == 0 || cpu_clk == mxc_get_clock(MXC_ARM_CLK) / 1000000)
 813                 return;
 814
 815         ret = mxc_set_clock(CONFIG_SYS_MX5_HCLK, cpu_clk, MXC_ARM_CLK);
 816         if (ret != 0) {
 817                 printf("Error: Failed to set CPU clock to %lu MHz\n", cpu_clk);
 818                 return;
 819         }
 820         printf("CPU clock set to %u.%03u MHz\n",
 821                 mxc_get_clock(MXC_ARM_CLK) / 1000000,
 822                 mxc_get_clock(MXC_ARM_CLK) / 1000 % 1000);
 823 }
 824
 825 int board_late_init(void)
 826 {
 827         int ret = 0;
 828         const char *baseboard;
 829
 830         tx51_set_cpu_clock();
 831         karo_fdt_move_fdt();
 832
 833         baseboard = getenv("baseboard");
 834         if (!baseboard)
 835                 goto exit;
 836
 837         if (strncmp(baseboard, "stk5", 4) == 0) {
 838                 printf("Baseboard: %s\n", baseboard);
 839                 if ((strlen(baseboard) == 4) ||
 840                         strcmp(baseboard, "stk5-v3") == 0) {
 841                         stk5v3_board_init();
 842                 } else if (strcmp(baseboard, "stk5-v5") == 0) {
 843                         printf("ERROR: Baseboard '%s' incompatible with TX51 module!\n",
 844                                 baseboard);
 845                         stk5v3_board_init();
 846                 } else {
 847                         printf("WARNING: Unsupported STK5 board rev.: %s\n",
 848                                 baseboard + 4);
 849                 }
 850         } else {
 851                 printf("WARNING: Unsupported baseboard: '%s'\n",
 852                         baseboard);
 853                 ret = -EINVAL;
 854         }
 855
 856 exit:
 857         gpio_set_value(TX51_RESET_OUT_GPIO, 1);
 858         return ret;
 859 }
 860
 861 int checkboard(void)
 862 {
 863         print_cpuinfo();
 864
 865         printf("Board: Ka-Ro TX51-%sxx%s\n",
 866                 TX51_MOD_PREFIX, TX51_MOD_SUFFIX);
 867
 868         return 0;
 869 }
 870
 871 #if defined(CONFIG_OF_BOARD_SETUP)
 872 #ifdef CONFIG_FDT_FIXUP_PARTITIONS
 873 #include <jffs2/jffs2.h>
 874 #include <mtd_node.h>
 875 struct node_info nodes[] = {
 876         { "fsl,imx51-nand", MTD_DEV_TYPE_NAND, },
 877 };
 878
 879 #else
 880 #define fdt_fixup_mtdparts(b,n,c) do { } while (0)
 881 #endif
 882
 883 void ft_board_setup(void *blob, bd_t *bd)
 884 {
 885         fdt_fixup_mtdparts(blob, nodes, ARRAY_SIZE(nodes));
 886         fdt_fixup_ethernet(blob);
 887
 888         karo_fdt_fixup_touchpanel(blob);
 889         karo_fdt_fixup_usb_otg(blob);
 890 }
 891 #endif