board/gateworks/gw_ventana/gw_ventana.c

   1 /*
   2  * Copyright (C) 2013 Gateworks Corporation
   3  *
   4  * Author: Tim Harvey <tharvey@gateworks.com>
   5  *
   6  * SPDX-License-Identifier: GPL-2.0+
   7  */
   8
   9 #include <common.h>
  10 #include <asm/io.h>
  11 #include <asm/arch/clock.h>
  12 #include <asm/arch/imx-regs.h>
  13 #include <asm/arch/iomux.h>
  14 #include <asm/arch/mx6-pins.h>
  15 #include <asm/arch/crm_regs.h>
  16 #include <asm/arch/sys_proto.h>
  17 #include <asm/gpio.h>
  18 #include <asm/imx-common/iomux-v3.h>
  19 #include <asm/imx-common/mxc_i2c.h>
  20 #include <asm/imx-common/boot_mode.h>
  21 #include <asm/imx-common/sata.h>
  22 #include <jffs2/load_kernel.h>
  23 #include <hwconfig.h>
  24 #include <i2c.h>
  25 #include <linux/ctype.h>
  26 #include <fdt_support.h>
  27 #include <fsl_esdhc.h>
  28 #include <miiphy.h>
  29 #include <mmc.h>
  30 #include <mtd_node.h>
  31 #include <netdev.h>
  32 #include <power/pmic.h>
  33 #include <power/pfuze100_pmic.h>
  34 #include <fdt_support.h>
  35 #include <jffs2/load_kernel.h>
  36 #include <spi_flash.h>
  37
  38 #include "gsc.h"
  39 #include "ventana_eeprom.h"
  40
  41 DECLARE_GLOBAL_DATA_PTR;
  42
  43 /* GPIO's common to all baseboards */
  44 #define GP_PHY_RST      IMX_GPIO_NR(1, 30)
  45 #define GP_USB_OTG_PWR  IMX_GPIO_NR(3, 22)
  46 #define GP_SD3_CD       IMX_GPIO_NR(7, 0)
  47 #define GP_RS232_EN     IMX_GPIO_NR(2, 11)
  48 #define GP_MSATA_SEL    IMX_GPIO_NR(2, 8)
  49
  50 /* I2C bus numbers */
  51 #define I2C_GSC         0
  52 #define I2C_PMIC        1
  53
  54 #define UART_PAD_CTRL  (PAD_CTL_PKE | PAD_CTL_PUE |             \
  55         PAD_CTL_PUS_100K_UP | PAD_CTL_SPEED_MED |               \
  56         PAD_CTL_DSE_40ohm   | PAD_CTL_SRE_FAST  | PAD_CTL_HYS)
  57
  58 #define USDHC_PAD_CTRL (PAD_CTL_PKE | PAD_CTL_PUE |             \
  59         PAD_CTL_PUS_47K_UP  | PAD_CTL_SPEED_LOW |               \
  60         PAD_CTL_DSE_80ohm   | PAD_CTL_SRE_FAST  | PAD_CTL_HYS)
  61
  62 #define ENET_PAD_CTRL  (PAD_CTL_PKE | PAD_CTL_PUE |             \
  63         PAD_CTL_PUS_100K_UP | PAD_CTL_SPEED_MED   |             \
  64         PAD_CTL_DSE_40ohm   | PAD_CTL_HYS)
  65
  66 #define SPI_PAD_CTRL (PAD_CTL_HYS |                             \
  67         PAD_CTL_PUS_100K_DOWN | PAD_CTL_SPEED_MED |             \
  68         PAD_CTL_DSE_40ohm     | PAD_CTL_SRE_FAST)
  69
  70 #define DIO_PAD_CTRL  (PAD_CTL_PKE | PAD_CTL_PUE |              \
  71         PAD_CTL_PUS_100K_UP | PAD_CTL_SPEED_MED |               \
  72         PAD_CTL_DSE_34ohm | PAD_CTL_HYS | PAD_CTL_SRE_FAST)
  73
  74 #define I2C_PAD_CTRL  (PAD_CTL_PUS_100K_UP |                    \
  75         PAD_CTL_SPEED_MED | PAD_CTL_DSE_40ohm | PAD_CTL_HYS |   \
  76         PAD_CTL_ODE | PAD_CTL_SRE_FAST)
  77
  78 /*
  79  * EEPROM board info struct populated by read_eeprom so that we only have to
  80  * read it once.
  81  */
  82 static struct ventana_board_info ventana_info;
  83
  84 enum {
  85         GW54proto, /* original GW5400-A prototype */
  86         GW51xx,
  87         GW52xx,
  88         GW53xx,
  89         GW54xx,
  90         GW_UNKNOWN,
  91 };
  92
  93 int board_type;
  94
  95 /* UART1: Function varies per baseboard */
  96 iomux_v3_cfg_t const uart1_pads[] = {
  97         MX6_PAD_SD3_DAT6__UART1_RX_DATA | MUX_PAD_CTRL(UART_PAD_CTRL),
  98         MX6_PAD_SD3_DAT7__UART1_TX_DATA | MUX_PAD_CTRL(UART_PAD_CTRL),
  99 };
 100
 101 /* UART2: Serial Console */
 102 iomux_v3_cfg_t const uart2_pads[] = {
 103         MX6_PAD_SD4_DAT7__UART2_TX_DATA | MUX_PAD_CTRL(UART_PAD_CTRL),
 104         MX6_PAD_SD4_DAT4__UART2_RX_DATA | MUX_PAD_CTRL(UART_PAD_CTRL),
 105 };
 106
 107 #define PC MUX_PAD_CTRL(I2C_PAD_CTRL)
 108
 109 /* I2C1: GSC */
 110 struct i2c_pads_info i2c_pad_info0 = {
 111         .scl = {
 112                 .i2c_mode = MX6_PAD_EIM_D21__I2C1_SCL | PC,
 113                 .gpio_mode = MX6_PAD_EIM_D21__GPIO3_IO21 | PC,
 114                 .gp = IMX_GPIO_NR(3, 21)
 115         },
 116         .sda = {
 117                 .i2c_mode = MX6_PAD_EIM_D28__I2C1_SDA | PC,
 118                 .gpio_mode = MX6_PAD_EIM_D28__GPIO3_IO28 | PC,
 119                 .gp = IMX_GPIO_NR(3, 28)
 120         }
 121 };
 122
 123 /* I2C2: PMIC/PCIe Switch/PCIe Clock/Mezz */
 124 struct i2c_pads_info i2c_pad_info1 = {
 125         .scl = {
 126                 .i2c_mode = MX6_PAD_KEY_COL3__I2C2_SCL | PC,
 127                 .gpio_mode = MX6_PAD_KEY_COL3__GPIO4_IO12 | PC,
 128                 .gp = IMX_GPIO_NR(4, 12)
 129         },
 130         .sda = {
 131                 .i2c_mode = MX6_PAD_KEY_ROW3__I2C2_SDA | PC,
 132                 .gpio_mode = MX6_PAD_KEY_ROW3__GPIO4_IO13 | PC,
 133                 .gp = IMX_GPIO_NR(4, 13)
 134         }
 135 };
 136
 137 /* I2C3: Misc/Expansion */
 138 struct i2c_pads_info i2c_pad_info2 = {
 139         .scl = {
 140                 .i2c_mode = MX6_PAD_GPIO_3__I2C3_SCL | PC,
 141                 .gpio_mode = MX6_PAD_GPIO_3__GPIO1_IO03 | PC,
 142                 .gp = IMX_GPIO_NR(1, 3)
 143         },
 144         .sda = {
 145                 .i2c_mode = MX6_PAD_GPIO_6__I2C3_SDA | PC,
 146                 .gpio_mode = MX6_PAD_GPIO_6__GPIO1_IO06 | PC,
 147                 .gp = IMX_GPIO_NR(1, 6)
 148         }
 149 };
 150
 151 /* MMC */
 152 iomux_v3_cfg_t const usdhc3_pads[] = {
 153         MX6_PAD_SD3_CLK__SD3_CLK    | MUX_PAD_CTRL(USDHC_PAD_CTRL),
 154         MX6_PAD_SD3_CMD__SD3_CMD    | MUX_PAD_CTRL(USDHC_PAD_CTRL),
 155         MX6_PAD_SD3_DAT0__SD3_DATA0 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
 156         MX6_PAD_SD3_DAT1__SD3_DATA1 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
 157         MX6_PAD_SD3_DAT2__SD3_DATA2 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
 158         MX6_PAD_SD3_DAT3__SD3_DATA3 | MUX_PAD_CTRL(USDHC_PAD_CTRL),
 159         MX6_PAD_SD3_DAT5__GPIO7_IO00  | MUX_PAD_CTRL(NO_PAD_CTRL), /* CD */
 160 };
 161
 162 /* ENET */
 163 iomux_v3_cfg_t const enet_pads[] = {
 164         MX6_PAD_ENET_MDIO__ENET_MDIO            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 165         MX6_PAD_ENET_MDC__ENET_MDC              | MUX_PAD_CTRL(ENET_PAD_CTRL),
 166         MX6_PAD_RGMII_TXC__RGMII_TXC            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 167         MX6_PAD_RGMII_TD0__RGMII_TD0            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 168         MX6_PAD_RGMII_TD1__RGMII_TD1            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 169         MX6_PAD_RGMII_TD2__RGMII_TD2            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 170         MX6_PAD_RGMII_TD3__RGMII_TD3            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 171         MX6_PAD_RGMII_TX_CTL__RGMII_TX_CTL      | MUX_PAD_CTRL(ENET_PAD_CTRL),
 172         MX6_PAD_ENET_REF_CLK__ENET_TX_CLK       | MUX_PAD_CTRL(ENET_PAD_CTRL),
 173         MX6_PAD_RGMII_RXC__RGMII_RXC            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 174         MX6_PAD_RGMII_RD0__RGMII_RD0            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 175         MX6_PAD_RGMII_RD1__RGMII_RD1            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 176         MX6_PAD_RGMII_RD2__RGMII_RD2            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 177         MX6_PAD_RGMII_RD3__RGMII_RD3            | MUX_PAD_CTRL(ENET_PAD_CTRL),
 178         MX6_PAD_RGMII_RX_CTL__RGMII_RX_CTL      | MUX_PAD_CTRL(ENET_PAD_CTRL),
 179         /* PHY nRST */
 180         MX6_PAD_ENET_TXD0__GPIO1_IO30           | MUX_PAD_CTRL(NO_PAD_CTRL),
 181 };
 182
 183 /* NAND */
 184 iomux_v3_cfg_t const nfc_pads[] = {
 185         MX6_PAD_NANDF_CLE__NAND_CLE     | MUX_PAD_CTRL(NO_PAD_CTRL),
 186         MX6_PAD_NANDF_ALE__NAND_ALE     | MUX_PAD_CTRL(NO_PAD_CTRL),
 187         MX6_PAD_NANDF_WP_B__NAND_WP_B   | MUX_PAD_CTRL(NO_PAD_CTRL),
 188         MX6_PAD_NANDF_RB0__NAND_READY_B | MUX_PAD_CTRL(NO_PAD_CTRL),
 189         MX6_PAD_NANDF_CS0__NAND_CE0_B   | MUX_PAD_CTRL(NO_PAD_CTRL),
 190         MX6_PAD_SD4_CMD__NAND_RE_B      | MUX_PAD_CTRL(NO_PAD_CTRL),
 191         MX6_PAD_SD4_CLK__NAND_WE_B      | MUX_PAD_CTRL(NO_PAD_CTRL),
 192         MX6_PAD_NANDF_D0__NAND_DATA00   | MUX_PAD_CTRL(NO_PAD_CTRL),
 193         MX6_PAD_NANDF_D1__NAND_DATA01   | MUX_PAD_CTRL(NO_PAD_CTRL),
 194         MX6_PAD_NANDF_D2__NAND_DATA02   | MUX_PAD_CTRL(NO_PAD_CTRL),
 195         MX6_PAD_NANDF_D3__NAND_DATA03   | MUX_PAD_CTRL(NO_PAD_CTRL),
 196         MX6_PAD_NANDF_D4__NAND_DATA04   | MUX_PAD_CTRL(NO_PAD_CTRL),
 197         MX6_PAD_NANDF_D5__NAND_DATA05   | MUX_PAD_CTRL(NO_PAD_CTRL),
 198         MX6_PAD_NANDF_D6__NAND_DATA06   | MUX_PAD_CTRL(NO_PAD_CTRL),
 199         MX6_PAD_NANDF_D7__NAND_DATA07   | MUX_PAD_CTRL(NO_PAD_CTRL),
 200 };
 201
 202 #ifdef CONFIG_CMD_NAND
 203 static void setup_gpmi_nand(void)
 204 {
 205         struct mxc_ccm_reg *mxc_ccm = (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 206
 207         /* config gpmi nand iomux */
 208         imx_iomux_v3_setup_multiple_pads(nfc_pads, ARRAY_SIZE(nfc_pads));
 209
 210         /* config gpmi and bch clock to 100 MHz */
 211         clrsetbits_le32(&mxc_ccm->cs2cdr,
 212                         MXC_CCM_CS2CDR_ENFC_CLK_PODF_MASK |
 213                         MXC_CCM_CS2CDR_ENFC_CLK_PRED_MASK |
 214                         MXC_CCM_CS2CDR_ENFC_CLK_SEL_MASK,
 215                         MXC_CCM_CS2CDR_ENFC_CLK_PODF(0) |
 216                         MXC_CCM_CS2CDR_ENFC_CLK_PRED(3) |
 217                         MXC_CCM_CS2CDR_ENFC_CLK_SEL(3));
 218
 219         /* enable gpmi and bch clock gating */
 220         setbits_le32(&mxc_ccm->CCGR4,
 221                      MXC_CCM_CCGR4_RAWNAND_U_BCH_INPUT_APB_MASK |
 222                      MXC_CCM_CCGR4_RAWNAND_U_GPMI_BCH_INPUT_BCH_MASK |
 223                      MXC_CCM_CCGR4_RAWNAND_U_GPMI_BCH_INPUT_GPMI_IO_MASK |
 224                      MXC_CCM_CCGR4_RAWNAND_U_GPMI_INPUT_APB_MASK |
 225                      MXC_CCM_CCGR4_PL301_MX6QPER1_BCH_OFFSET);
 226
 227         /* enable apbh clock gating */
 228         setbits_le32(&mxc_ccm->CCGR0, MXC_CCM_CCGR0_APBHDMA_MASK);
 229 }
 230 #endif
 231
 232 static void setup_iomux_enet(void)
 233 {
 234         imx_iomux_v3_setup_multiple_pads(enet_pads, ARRAY_SIZE(enet_pads));
 235
 236         /* toggle PHY_RST# */
 237         gpio_direction_output(GP_PHY_RST, 0);
 238         mdelay(2);
 239         gpio_set_value(GP_PHY_RST, 1);
 240 }
 241
 242 static void setup_iomux_uart(void)
 243 {
 244         imx_iomux_v3_setup_multiple_pads(uart1_pads, ARRAY_SIZE(uart1_pads));
 245         imx_iomux_v3_setup_multiple_pads(uart2_pads, ARRAY_SIZE(uart2_pads));
 246 }
 247
 248 #ifdef CONFIG_USB_EHCI_MX6
 249 iomux_v3_cfg_t const usb_pads[] = {
 250         MX6_PAD_GPIO_1__USB_OTG_ID   | MUX_PAD_CTRL(DIO_PAD_CTRL),
 251         MX6_PAD_KEY_COL4__USB_OTG_OC | MUX_PAD_CTRL(DIO_PAD_CTRL),
 252         MX6_PAD_EIM_D22__GPIO3_IO22  | MUX_PAD_CTRL(DIO_PAD_CTRL), /* OTG PWR */
 253 };
 254
 255 int board_ehci_hcd_init(int port)
 256 {
 257         struct ventana_board_info *info = &ventana_info;
 258
 259         imx_iomux_v3_setup_multiple_pads(usb_pads, ARRAY_SIZE(usb_pads));
 260
 261         /* Reset USB HUB (present on GW54xx/GW53xx) */
 262         switch (info->model[3]) {
 263         case '3': /* GW53xx */
 264                 imx_iomux_v3_setup_pad(MX6_PAD_GPIO_9__GPIO1_IO09|
 265                                        MUX_PAD_CTRL(NO_PAD_CTRL));
 266                 gpio_direction_output(IMX_GPIO_NR(1, 9), 0);
 267                 mdelay(2);
 268                 gpio_set_value(IMX_GPIO_NR(1, 9), 1);
 269                 break;
 270         case '4': /* GW54xx */
 271                 imx_iomux_v3_setup_pad(MX6_PAD_SD1_DAT0__GPIO1_IO16 |
 272                                        MUX_PAD_CTRL(NO_PAD_CTRL));
 273                 gpio_direction_output(IMX_GPIO_NR(1, 16), 0);
 274                 mdelay(2);
 275                 gpio_set_value(IMX_GPIO_NR(1, 16), 1);
 276                 break;
 277         }
 278
 279         return 0;
 280 }
 281
 282 int board_ehci_power(int port, int on)
 283 {
 284         if (port)
 285                 return 0;
 286         gpio_set_value(GP_USB_OTG_PWR, on);
 287         return 0;
 288 }
 289 #endif /* CONFIG_USB_EHCI_MX6 */
 290
 291 #ifdef CONFIG_FSL_ESDHC
 292 struct fsl_esdhc_cfg usdhc_cfg = { USDHC3_BASE_ADDR };
 293
 294 int board_mmc_getcd(struct mmc *mmc)
 295 {
 296         /* Card Detect */
 297         gpio_direction_input(GP_SD3_CD);
 298         return !gpio_get_value(GP_SD3_CD);
 299 }
 300
 301 int board_mmc_init(bd_t *bis)
 302 {
 303         /* Only one USDHC controller on Ventana */
 304         imx_iomux_v3_setup_multiple_pads(usdhc3_pads, ARRAY_SIZE(usdhc3_pads));
 305         usdhc_cfg.sdhc_clk = mxc_get_clock(MXC_ESDHC3_CLK);
 306         usdhc_cfg.max_bus_width = 4;
 307
 308         return fsl_esdhc_initialize(bis, &usdhc_cfg);
 309 }
 310 #endif /* CONFIG_FSL_ESDHC */
 311
 312 #ifdef CONFIG_MXC_SPI
 313 iomux_v3_cfg_t const ecspi1_pads[] = {
 314         /* SS1 */
 315         MX6_PAD_EIM_D19__GPIO3_IO19  | MUX_PAD_CTRL(SPI_PAD_CTRL),
 316         MX6_PAD_EIM_D17__ECSPI1_MISO | MUX_PAD_CTRL(SPI_PAD_CTRL),
 317         MX6_PAD_EIM_D18__ECSPI1_MOSI | MUX_PAD_CTRL(SPI_PAD_CTRL),
 318         MX6_PAD_EIM_D16__ECSPI1_SCLK | MUX_PAD_CTRL(SPI_PAD_CTRL),
 319 };
 320
 321 static void setup_spi(void)
 322 {
 323         gpio_direction_output(CONFIG_SF_DEFAULT_CS, 1);
 324         imx_iomux_v3_setup_multiple_pads(ecspi1_pads,
 325                                          ARRAY_SIZE(ecspi1_pads));
 326 }
 327 #endif
 328
 329 /* configure eth0 PHY board-specific LED behavior */
 330 int board_phy_config(struct phy_device *phydev)
 331 {
 332         unsigned short val;
 333
 334         /* Marvel 88E1510 */
 335         if (phydev->phy_id == 0x1410dd1) {
 336                 /*
 337                  * Page 3, Register 16: LED[2:0] Function Control Register
 338                  * LED[0] (SPD:Amber) R16_3.3:0 to 0111: on-GbE link
 339                  * LED[1] (LNK:Green) R16_3.7:4 to 0001: on-link, blink-activity
 340                  */
 341                 phy_write(phydev, MDIO_DEVAD_NONE, 22, 3);
 342                 val = phy_read(phydev, MDIO_DEVAD_NONE, 16);
 343                 val &= 0xff00;
 344                 val |= 0x0017;
 345                 phy_write(phydev, MDIO_DEVAD_NONE, 16, val);
 346                 phy_write(phydev, MDIO_DEVAD_NONE, 22, 0);
 347         }
 348
 349         if (phydev->drv->config)
 350                 phydev->drv->config(phydev);
 351
 352         return 0;
 353 }
 354
 355 int board_eth_init(bd_t *bis)
 356 {
 357         setup_iomux_enet();
 358
 359 #ifdef CONFIG_FEC_MXC
 360         cpu_eth_init(bis);
 361 #endif
 362
 363 #ifdef CONFIG_CI_UDC
 364         /* For otg ethernet*/
 365         usb_eth_initialize(bis);
 366 #endif
 367
 368         return 0;
 369 }
 370
 371 /* read ventana EEPROM, check for validity, and return baseboard type */
 372 static int
 373 read_eeprom(void)
 374 {
 375         int i;
 376         int chksum;
 377         char baseboard;
 378         int type;
 379         struct ventana_board_info *info = &ventana_info;
 380         unsigned char *buf = (unsigned char *)&ventana_info;
 381
 382         memset(info, 0, sizeof(ventana_info));
 383
 384         /*
 385          * On a board with a missing/depleted backup battery for GSC, the
 386          * board may be ready to probe the GSC before its firmware is
 387          * running.  We will wait here indefinately for the GSC/EEPROM.
 388          */
 389         while (1) {
 390                 if (0 == i2c_set_bus_num(I2C_GSC) &&
 391                     0 == i2c_probe(GSC_EEPROM_ADDR))
 392                         break;
 393                 mdelay(1);
 394         }
 395
 396         /* read eeprom config section */
 397         if (gsc_i2c_read(GSC_EEPROM_ADDR, 0x00, 1, buf, sizeof(ventana_info))) {
 398                 puts("EEPROM: Failed to read EEPROM\n");
 399                 info->model[0] = 0;
 400                 return GW_UNKNOWN;
 401         }
 402
 403         /* sanity checks */
 404         if (info->model[0] != 'G' || info->model[1] != 'W') {
 405                 puts("EEPROM: Invalid Model in EEPROM\n");
 406                 info->model[0] = 0;
 407                 return GW_UNKNOWN;
 408         }
 409
 410         /* validate checksum */
 411         for (chksum = 0, i = 0; i < sizeof(*info)-2; i++)
 412                 chksum += buf[i];
 413         if ((info->chksum[0] != chksum>>8) ||
 414             (info->chksum[1] != (chksum&0xff))) {
 415                 puts("EEPROM: Failed EEPROM checksum\n");
 416                 info->model[0] = 0;
 417                 return GW_UNKNOWN;
 418         }
 419
 420         /* original GW5400-A prototype */
 421         baseboard = info->model[3];
 422         if (strncasecmp((const char *)info->model, "GW5400-A", 8) == 0)
 423                 baseboard = '0';
 424
 425         switch (baseboard) {
 426         case '0': /* original GW5400-A prototype */
 427                 type = GW54proto;
 428                 break;
 429         case '1':
 430                 type = GW51xx;
 431                 break;
 432         case '2':
 433                 type = GW52xx;
 434                 break;
 435         case '3':
 436                 type = GW53xx;
 437                 break;
 438         case '4':
 439                 type = GW54xx;
 440                 break;
 441         default:
 442                 printf("EEPROM: Unknown model in EEPROM: %s\n", info->model);
 443                 type = GW_UNKNOWN;
 444                 break;
 445         }
 446         return type;
 447 }
 448
 449 /*
 450  * Baseboard specific GPIO
 451  */
 452
 453 /* common to add baseboards */
 454 static iomux_v3_cfg_t const gw_gpio_pads[] = {
 455         /* MSATA_EN */
 456         MX6_PAD_SD4_DAT0__GPIO2_IO08 | MUX_PAD_CTRL(NO_PAD_CTRL),
 457         /* RS232_EN# */
 458         MX6_PAD_SD4_DAT3__GPIO2_IO11 | MUX_PAD_CTRL(NO_PAD_CTRL),
 459 };
 460
 461 /* prototype */
 462 static iomux_v3_cfg_t const gwproto_gpio_pads[] = {
 463         /* PANLEDG# */
 464         MX6_PAD_KEY_COL0__GPIO4_IO06 | MUX_PAD_CTRL(NO_PAD_CTRL),
 465         /* PANLEDR# */
 466         MX6_PAD_KEY_ROW0__GPIO4_IO07 | MUX_PAD_CTRL(NO_PAD_CTRL),
 467         /* LOCLED# */
 468         MX6_PAD_KEY_ROW4__GPIO4_IO15 | MUX_PAD_CTRL(NO_PAD_CTRL),
 469         /* RS485_EN */
 470         MX6_PAD_SD3_DAT4__GPIO7_IO01 | MUX_PAD_CTRL(NO_PAD_CTRL),
 471         /* IOEXP_PWREN# */
 472         MX6_PAD_EIM_A19__GPIO2_IO19 | MUX_PAD_CTRL(NO_PAD_CTRL),
 473         /* IOEXP_IRQ# */
 474         MX6_PAD_EIM_A20__GPIO2_IO18 | MUX_PAD_CTRL(NO_PAD_CTRL),
 475         /* VID_EN */
 476         MX6_PAD_EIM_D31__GPIO3_IO31 | MUX_PAD_CTRL(NO_PAD_CTRL),
 477         /* DIOI2C_DIS# */
 478         MX6_PAD_GPIO_19__GPIO4_IO05 | MUX_PAD_CTRL(NO_PAD_CTRL),
 479         /* PCICK_SSON */
 480         MX6_PAD_SD1_CLK__GPIO1_IO20 | MUX_PAD_CTRL(NO_PAD_CTRL),
 481         /* PCI_RST# */
 482         MX6_PAD_ENET_TXD1__GPIO1_IO29 | MUX_PAD_CTRL(NO_PAD_CTRL),
 483 };
 484
 485 static iomux_v3_cfg_t const gw51xx_gpio_pads[] = {
 486         /* PANLEDG# */
 487         MX6_PAD_KEY_COL0__GPIO4_IO06 | MUX_PAD_CTRL(NO_PAD_CTRL),
 488         /* PANLEDR# */
 489         MX6_PAD_KEY_ROW0__GPIO4_IO07 | MUX_PAD_CTRL(NO_PAD_CTRL),
 490         /* IOEXP_PWREN# */
 491         MX6_PAD_EIM_A19__GPIO2_IO19 | MUX_PAD_CTRL(NO_PAD_CTRL),
 492         /* IOEXP_IRQ# */
 493         MX6_PAD_EIM_A20__GPIO2_IO18 | MUX_PAD_CTRL(NO_PAD_CTRL),
 494
 495         /* GPS_SHDN */
 496         MX6_PAD_GPIO_2__GPIO1_IO02 | MUX_PAD_CTRL(NO_PAD_CTRL),
 497         /* VID_PWR */
 498         MX6_PAD_CSI0_DATA_EN__GPIO5_IO20 | MUX_PAD_CTRL(NO_PAD_CTRL),
 499         /* PCI_RST# */
 500         MX6_PAD_GPIO_0__GPIO1_IO00 | MUX_PAD_CTRL(NO_PAD_CTRL),
 501 };
 502
 503 static iomux_v3_cfg_t const gw52xx_gpio_pads[] = {
 504         /* PANLEDG# */
 505         MX6_PAD_KEY_COL0__GPIO4_IO06 | MUX_PAD_CTRL(NO_PAD_CTRL),
 506         /* PANLEDR# */
 507         MX6_PAD_KEY_ROW0__GPIO4_IO07 | MUX_PAD_CTRL(NO_PAD_CTRL),
 508         /* IOEXP_PWREN# */
 509         MX6_PAD_EIM_A19__GPIO2_IO19 | MUX_PAD_CTRL(NO_PAD_CTRL),
 510         /* IOEXP_IRQ# */
 511         MX6_PAD_EIM_A20__GPIO2_IO18 | MUX_PAD_CTRL(NO_PAD_CTRL),
 512
 513         /* MX6_LOCLED# */
 514         MX6_PAD_KEY_ROW4__GPIO4_IO15 | MUX_PAD_CTRL(NO_PAD_CTRL),
 515         /* GPS_SHDN */
 516         MX6_PAD_ENET_RXD0__GPIO1_IO27 | MUX_PAD_CTRL(NO_PAD_CTRL),
 517         /* USBOTG_SEL */
 518         MX6_PAD_GPIO_2__GPIO1_IO02 | MUX_PAD_CTRL(NO_PAD_CTRL),
 519         /* VID_PWR */
 520         MX6_PAD_EIM_D31__GPIO3_IO31 | MUX_PAD_CTRL(NO_PAD_CTRL),
 521         /* PCI_RST# */
 522         MX6_PAD_ENET_TXD1__GPIO1_IO29 | MUX_PAD_CTRL(NO_PAD_CTRL),
 523 };
 524
 525 static iomux_v3_cfg_t const gw53xx_gpio_pads[] = {
 526         /* PANLEDG# */
 527         MX6_PAD_KEY_COL0__GPIO4_IO06 | MUX_PAD_CTRL(NO_PAD_CTRL),
 528         /* PANLEDR# */
 529         MX6_PAD_KEY_ROW0__GPIO4_IO07 | MUX_PAD_CTRL(NO_PAD_CTRL),
 530         /* IOEXP_PWREN# */
 531         MX6_PAD_EIM_A19__GPIO2_IO19 | MUX_PAD_CTRL(NO_PAD_CTRL),
 532         /* IOEXP_IRQ# */
 533         MX6_PAD_EIM_A20__GPIO2_IO18 | MUX_PAD_CTRL(NO_PAD_CTRL),
 534
 535         /* MX6_LOCLED# */
 536         MX6_PAD_KEY_ROW4__GPIO4_IO15 | MUX_PAD_CTRL(NO_PAD_CTRL),
 537         /* GPS_SHDN */
 538         MX6_PAD_ENET_RXD0__GPIO1_IO27 | MUX_PAD_CTRL(NO_PAD_CTRL),
 539         /* VID_EN */
 540         MX6_PAD_EIM_D31__GPIO3_IO31 | MUX_PAD_CTRL(NO_PAD_CTRL),
 541         /* PCI_RST# */
 542         MX6_PAD_ENET_TXD1__GPIO1_IO29 | MUX_PAD_CTRL(NO_PAD_CTRL),
 543 };
 544
 545 static iomux_v3_cfg_t const gw54xx_gpio_pads[] = {
 546         /* PANLEDG# */
 547         MX6_PAD_KEY_COL0__GPIO4_IO06 | MUX_PAD_CTRL(NO_PAD_CTRL),
 548         /* PANLEDR# */
 549         MX6_PAD_KEY_COL2__GPIO4_IO10 | MUX_PAD_CTRL(NO_PAD_CTRL),
 550         /* MX6_LOCLED# */
 551         MX6_PAD_KEY_ROW4__GPIO4_IO15 | MUX_PAD_CTRL(NO_PAD_CTRL),
 552         /* MIPI_DIO */
 553         MX6_PAD_SD1_DAT3__GPIO1_IO21 | MUX_PAD_CTRL(NO_PAD_CTRL),
 554         /* RS485_EN */
 555         MX6_PAD_EIM_D24__GPIO3_IO24 | MUX_PAD_CTRL(NO_PAD_CTRL),
 556         /* IOEXP_PWREN# */
 557         MX6_PAD_KEY_ROW0__GPIO4_IO07 | MUX_PAD_CTRL(NO_PAD_CTRL),
 558         /* IOEXP_IRQ# */
 559         MX6_PAD_KEY_ROW1__GPIO4_IO09 | MUX_PAD_CTRL(NO_PAD_CTRL),
 560         /* DIOI2C_DIS# */
 561         MX6_PAD_GPIO_19__GPIO4_IO05 | MUX_PAD_CTRL(NO_PAD_CTRL),
 562         /* DIOI2C_DIS# */
 563         MX6_PAD_GPIO_19__GPIO4_IO05 | MUX_PAD_CTRL(NO_PAD_CTRL),
 564         /* PCICK_SSON */
 565         MX6_PAD_SD1_CLK__GPIO1_IO20 | MUX_PAD_CTRL(NO_PAD_CTRL),
 566         /* PCI_RST# */
 567         MX6_PAD_ENET_TXD1__GPIO1_IO29 | MUX_PAD_CTRL(NO_PAD_CTRL),
 568 };
 569
 570 /*
 571  * each baseboard has 4 user configurable Digital IO lines which can
 572  * be pinmuxed as a GPIO or in some cases a PWM
 573  */
 574 struct dio_cfg {
 575         iomux_v3_cfg_t gpio_padmux;
 576         unsigned gpio_param;
 577         iomux_v3_cfg_t pwm_padmux;
 578         unsigned pwm_param;
 579 };
 580
 581 struct ventana {
 582         /* pinmux */
 583         iomux_v3_cfg_t const *gpio_pads;
 584         int num_pads;
 585         /* DIO pinmux/val */
 586         struct dio_cfg dio_cfg[4];
 587         /* various gpios (0 if non-existent) */
 588         int leds[3];
 589         int pcie_rst;
 590         int mezz_pwren;
 591         int mezz_irq;
 592         int rs485en;
 593         int gps_shdn;
 594         int vidin_en;
 595         int dioi2c_en;
 596         int pcie_sson;
 597         int usb_sel;
 598 };
 599
 600 struct ventana gpio_cfg[] = {
 601         /* GW5400proto */
 602         {
 603                 .gpio_pads = gw54xx_gpio_pads,
 604                 .num_pads = ARRAY_SIZE(gw54xx_gpio_pads),
 605                 .dio_cfg = {
 606                         { MX6_PAD_GPIO_9__GPIO1_IO09, IMX_GPIO_NR(1, 9),
 607                           MX6_PAD_GPIO_9__PWM1_OUT, 1 },
 608                         { MX6_PAD_SD1_DAT2__GPIO1_IO19, IMX_GPIO_NR(1, 19),
 609                           MX6_PAD_SD1_DAT2__PWM2_OUT, 2 },
 610                         { MX6_PAD_SD4_DAT1__GPIO2_IO09, IMX_GPIO_NR(2, 9),
 611                           MX6_PAD_SD4_DAT1__PWM3_OUT, 3 },
 612                         { MX6_PAD_SD4_DAT2__GPIO2_IO10, IMX_GPIO_NR(2, 10),
 613                           MX6_PAD_SD4_DAT2__PWM4_OUT, 4 },
 614                 },
 615                 .leds = {
 616                         IMX_GPIO_NR(4, 6),
 617                         IMX_GPIO_NR(4, 10),
 618                         IMX_GPIO_NR(4, 15),
 619                 },
 620                 .pcie_rst = IMX_GPIO_NR(1, 29),
 621                 .mezz_pwren = IMX_GPIO_NR(4, 7),
 622                 .mezz_irq = IMX_GPIO_NR(4, 9),
 623                 .rs485en = IMX_GPIO_NR(3, 24),
 624                 .dioi2c_en = IMX_GPIO_NR(4,  5),
 625                 .pcie_sson = IMX_GPIO_NR(1, 20),
 626         },
 627
 628         /* GW51xx */
 629         {
 630                 .gpio_pads = gw51xx_gpio_pads,
 631                 .num_pads = ARRAY_SIZE(gw51xx_gpio_pads),
 632                 .dio_cfg = {
 633                         { MX6_PAD_SD1_DAT0__GPIO1_IO16, IMX_GPIO_NR(1, 16),
 634                           0, 0 },
 635                         { MX6_PAD_SD1_DAT2__GPIO1_IO19, IMX_GPIO_NR(1, 19),
 636                           MX6_PAD_SD1_DAT2__PWM2_OUT, 2 },
 637                         { MX6_PAD_SD1_DAT1__GPIO1_IO17, IMX_GPIO_NR(1, 17),
 638                           MX6_PAD_SD1_DAT1__PWM3_OUT, 3 },
 639                         { MX6_PAD_SD1_CMD__GPIO1_IO18, IMX_GPIO_NR(1, 18),
 640                           MX6_PAD_SD1_CMD__PWM4_OUT, 4 },
 641                 },
 642                 .leds = {
 643                         IMX_GPIO_NR(4, 6),
 644                         IMX_GPIO_NR(4, 10),
 645                 },
 646                 .pcie_rst = IMX_GPIO_NR(1, 0),
 647                 .mezz_pwren = IMX_GPIO_NR(2, 19),
 648                 .mezz_irq = IMX_GPIO_NR(2, 18),
 649                 .gps_shdn = IMX_GPIO_NR(1, 2),
 650                 .vidin_en = IMX_GPIO_NR(5, 20),
 651         },
 652
 653         /* GW52xx */
 654         {
 655                 .gpio_pads = gw52xx_gpio_pads,
 656                 .num_pads = ARRAY_SIZE(gw52xx_gpio_pads),
 657                 .dio_cfg = {
 658                         { MX6_PAD_SD1_DAT0__GPIO1_IO16, IMX_GPIO_NR(1, 16),
 659                           0, 0 },
 660                         { MX6_PAD_SD1_DAT2__GPIO1_IO19, IMX_GPIO_NR(1, 19),
 661                           MX6_PAD_SD1_DAT2__PWM2_OUT, 2 },
 662                         { MX6_PAD_SD1_DAT1__GPIO1_IO17, IMX_GPIO_NR(1, 17),
 663                           MX6_PAD_SD1_DAT1__PWM3_OUT, 3 },
 664                         { MX6_PAD_SD1_CLK__GPIO1_IO20, IMX_GPIO_NR(1, 20),
 665                           0, 0 },
 666                 },
 667                 .leds = {
 668                         IMX_GPIO_NR(4, 6),
 669                         IMX_GPIO_NR(4, 7),
 670                         IMX_GPIO_NR(4, 15),
 671                 },
 672                 .pcie_rst = IMX_GPIO_NR(1, 29),
 673                 .mezz_pwren = IMX_GPIO_NR(2, 19),
 674                 .mezz_irq = IMX_GPIO_NR(2, 18),
 675                 .gps_shdn = IMX_GPIO_NR(1, 27),
 676                 .vidin_en = IMX_GPIO_NR(3, 31),
 677                 .usb_sel = IMX_GPIO_NR(1, 2),
 678         },
 679
 680         /* GW53xx */
 681         {
 682                 .gpio_pads = gw53xx_gpio_pads,
 683                 .num_pads = ARRAY_SIZE(gw53xx_gpio_pads),
 684                 .dio_cfg = {
 685                         { MX6_PAD_SD1_DAT0__GPIO1_IO16, IMX_GPIO_NR(1, 16),
 686                           0, 0 },
 687                         { MX6_PAD_SD1_DAT2__GPIO1_IO19, IMX_GPIO_NR(1, 19),
 688                           MX6_PAD_SD1_DAT2__PWM2_OUT, 2 },
 689                         { MX6_PAD_SD1_DAT1__GPIO1_IO17, IMX_GPIO_NR(1, 17),
 690                           MX6_PAD_SD1_DAT1__PWM3_OUT, 3 },
 691                         { MX6_PAD_SD1_CLK__GPIO1_IO20, IMX_GPIO_NR(1, 20),
 692                           0, 0 },
 693                 },
 694                 .leds = {
 695                         IMX_GPIO_NR(4, 6),
 696                         IMX_GPIO_NR(4, 7),
 697                         IMX_GPIO_NR(4, 15),
 698                 },
 699                 .pcie_rst = IMX_GPIO_NR(1, 29),
 700                 .mezz_pwren = IMX_GPIO_NR(2, 19),
 701                 .mezz_irq = IMX_GPIO_NR(2, 18),
 702                 .gps_shdn = IMX_GPIO_NR(1, 27),
 703                 .vidin_en = IMX_GPIO_NR(3, 31),
 704         },
 705
 706         /* GW54xx */
 707         {
 708                 .gpio_pads = gw54xx_gpio_pads,
 709                 .num_pads = ARRAY_SIZE(gw54xx_gpio_pads),
 710                 .dio_cfg = {
 711                         { MX6_PAD_GPIO_9__GPIO1_IO09, IMX_GPIO_NR(1, 9),
 712                           MX6_PAD_GPIO_9__PWM1_OUT, 1 },
 713                         { MX6_PAD_SD1_DAT2__GPIO1_IO19, IMX_GPIO_NR(1, 19),
 714                           MX6_PAD_SD1_DAT2__PWM2_OUT, 2 },
 715                         { MX6_PAD_SD4_DAT1__GPIO2_IO09, IMX_GPIO_NR(2, 9),
 716                           MX6_PAD_SD4_DAT1__PWM3_OUT, 3 },
 717                         { MX6_PAD_SD4_DAT2__GPIO2_IO10, IMX_GPIO_NR(2, 10),
 718                           MX6_PAD_SD4_DAT2__PWM4_OUT, 4 },
 719                 },
 720                 .leds = {
 721                         IMX_GPIO_NR(4, 6),
 722                         IMX_GPIO_NR(4, 7),
 723                         IMX_GPIO_NR(4, 15),
 724                 },
 725                 .pcie_rst = IMX_GPIO_NR(1, 29),
 726                 .mezz_pwren = IMX_GPIO_NR(2, 19),
 727                 .mezz_irq = IMX_GPIO_NR(2, 18),
 728                 .rs485en = IMX_GPIO_NR(7, 1),
 729                 .vidin_en = IMX_GPIO_NR(3, 31),
 730                 .dioi2c_en = IMX_GPIO_NR(4,  5),
 731                 .pcie_sson = IMX_GPIO_NR(1, 20),
 732         },
 733 };
 734
 735 /* setup GPIO pinmux and default configuration per baseboard */
 736 static void setup_board_gpio(int board)
 737 {
 738         struct ventana_board_info *info = &ventana_info;
 739         const char *s;
 740         char arg[10];
 741         size_t len;
 742         int i;
 743         int quiet = simple_strtol(getenv("quiet"), NULL, 10);
 744
 745         if (board >= GW_UNKNOWN)
 746                 return;
 747
 748         /* RS232_EN# */
 749         gpio_direction_output(GP_RS232_EN, (hwconfig("rs232")) ? 0 : 1);
 750
 751         /* MSATA Enable */
 752         if (is_cpu_type(MXC_CPU_MX6Q) &&
 753             test_bit(EECONFIG_SATA, info->config)) {
 754                 gpio_direction_output(GP_MSATA_SEL,
 755                                       (hwconfig("msata")) ?  1 : 0);
 756         } else {
 757                 gpio_direction_output(GP_MSATA_SEL, 0);
 758         }
 759
 760         /*
 761          * assert PCI_RST# (released by OS when clock is valid)
 762          * TODO: figure out why leaving this de-asserted from PCI scan on boot
 763          *       causes linux pcie driver to hang during enumeration
 764          */
 765         gpio_direction_output(gpio_cfg[board].pcie_rst, 0);
 766
 767         /* turn off (active-high) user LED's */
 768         for (i = 0; i < 4; i++) {
 769                 if (gpio_cfg[board].leds[i])
 770                         gpio_direction_output(gpio_cfg[board].leds[i], 1);
 771         }
 772
 773         /* Expansion Mezzanine IO */
 774         gpio_direction_output(gpio_cfg[board].mezz_pwren, 0);
 775         gpio_direction_input(gpio_cfg[board].mezz_irq);
 776
 777         /* RS485 Transmit Enable */
 778         if (gpio_cfg[board].rs485en)
 779                 gpio_direction_output(gpio_cfg[board].rs485en, 0);
 780
 781         /* GPS_SHDN */
 782         if (gpio_cfg[board].gps_shdn)
 783                 gpio_direction_output(gpio_cfg[board].gps_shdn, 1);
 784
 785         /* Analog video codec power enable */
 786         if (gpio_cfg[board].vidin_en)
 787                 gpio_direction_output(gpio_cfg[board].vidin_en, 1);
 788
 789         /* DIOI2C_DIS# */
 790         if (gpio_cfg[board].dioi2c_en)
 791                 gpio_direction_output(gpio_cfg[board].dioi2c_en, 0);
 792
 793         /* PCICK_SSON: disable spread-spectrum clock */
 794         if (gpio_cfg[board].pcie_sson)
 795                 gpio_direction_output(gpio_cfg[board].pcie_sson, 0);
 796
 797         /* USBOTG Select (PCISKT or FrontPanel) */
 798         if (gpio_cfg[board].usb_sel)
 799                 gpio_direction_output(gpio_cfg[board].usb_sel, 0);
 800
 801         /*
 802          * Configure DIO pinmux/padctl registers
 803          * see IMX6DQRM/IMX6SDLRM IOMUXC_SW_PAD_CTL_PAD_* register definitions
 804          */
 805         for (i = 0; i < 4; i++) {
 806                 struct dio_cfg *cfg = &gpio_cfg[board].dio_cfg[i];
 807                 unsigned ctrl = DIO_PAD_CTRL;
 808
 809                 sprintf(arg, "dio%d", i);
 810                 if (!hwconfig(arg))
 811                         continue;
 812                 s = hwconfig_subarg(arg, "padctrl", &len);
 813                 if (s)
 814                         ctrl = simple_strtoul(s, NULL, 16) & 0x3ffff;
 815                 if (hwconfig_subarg_cmp(arg, "mode", "gpio")) {
 816                         if (!quiet) {
 817                                 printf("DIO%d:  GPIO%d_IO%02d (gpio-%d)\n", i,
 818                                        (cfg->gpio_param/32)+1,
 819                                        cfg->gpio_param%32,
 820                                        cfg->gpio_param);
 821                         }
 822                         imx_iomux_v3_setup_pad(cfg->gpio_padmux |
 823                                                MUX_PAD_CTRL(ctrl));
 824                         gpio_direction_input(cfg->gpio_param);
 825                 } else if (hwconfig_subarg_cmp("dio2", "mode", "pwm") &&
 826                            cfg->pwm_padmux) {
 827                         if (!quiet)
 828                                 printf("DIO%d:  pwm%d\n", i, cfg->pwm_param);
 829                         imx_iomux_v3_setup_pad(cfg->pwm_padmux |
 830                                                MUX_PAD_CTRL(ctrl));
 831                 }
 832         }
 833
 834         if (!quiet) {
 835                 if (is_cpu_type(MXC_CPU_MX6Q) &&
 836                     (test_bit(EECONFIG_SATA, info->config))) {
 837                         printf("MSATA: %s\n", (hwconfig("msata") ?
 838                                "enabled" : "disabled"));
 839                 }
 840                 printf("RS232: %s\n", (hwconfig("rs232")) ?
 841                        "enabled" : "disabled");
 842         }
 843 }
 844
 845 #if defined(CONFIG_CMD_PCI)
 846 int imx6_pcie_toggle_reset(void)
 847 {
 848         if (board_type < GW_UNKNOWN) {
 849                 gpio_direction_output(gpio_cfg[board_type].pcie_rst, 0);
 850                 mdelay(50);
 851                 gpio_direction_output(gpio_cfg[board_type].pcie_rst, 1);
 852         }
 853         return 0;
 854 }
 855 #endif /* CONFIG_CMD_PCI */
 856
 857 #ifdef CONFIG_SERIAL_TAG
 858 /*
 859  * called when setting up ATAGS before booting kernel
 860  * populate serialnum from the following (in order of priority):
 861  *   serial# env var
 862  *   eeprom
 863  */
 864 void get_board_serial(struct tag_serialnr *serialnr)
 865 {
 866         char *serial = getenv("serial#");
 867
 868         if (serial) {
 869                 serialnr->high = 0;
 870                 serialnr->low = simple_strtoul(serial, NULL, 10);
 871         } else if (ventana_info.model[0]) {
 872                 serialnr->high = 0;
 873                 serialnr->low = ventana_info.serial;
 874         } else {
 875                 serialnr->high = 0;
 876                 serialnr->low = 0;
 877         }
 878 }
 879 #endif
 880
 881 /*
 882  * Board Support
 883  */
 884
 885 int board_early_init_f(void)
 886 {
 887         setup_iomux_uart();
 888         gpio_direction_output(GP_USB_OTG_PWR, 0); /* OTG power off */
 889
 890         return 0;
 891 }
 892
 893 int dram_init(void)
 894 {
 895         gd->ram_size = get_ram_size((void *)PHYS_SDRAM,
 896                                     CONFIG_DDR_MB*1024*1024);
 897
 898         return 0;
 899 }
 900
 901 int board_init(void)
 902 {
 903         struct iomuxc_base_regs *const iomuxc_regs
 904                 = (struct iomuxc_base_regs *)IOMUXC_BASE_ADDR;
 905
 906         clrsetbits_le32(&iomuxc_regs->gpr[1],
 907                         IOMUXC_GPR1_OTG_ID_MASK,
 908                         IOMUXC_GPR1_OTG_ID_GPIO1);
 909
 910         /* address of linux boot parameters */
 911         gd->bd->bi_boot_params = PHYS_SDRAM + 0x100;
 912
 913 #ifdef CONFIG_CMD_NAND
 914         setup_gpmi_nand();
 915 #endif
 916 #ifdef CONFIG_MXC_SPI
 917         setup_spi();
 918 #endif
 919         setup_i2c(0, CONFIG_SYS_I2C_SPEED, 0x7f, &i2c_pad_info0);
 920         setup_i2c(1, CONFIG_SYS_I2C_SPEED, 0x7f, &i2c_pad_info1);
 921         setup_i2c(2, CONFIG_SYS_I2C_SPEED, 0x7f, &i2c_pad_info2);
 922
 923 #ifdef CONFIG_CMD_SATA
 924         setup_sata();
 925 #endif
 926         /* read Gateworks EEPROM into global struct (used later) */
 927         board_type = read_eeprom();
 928
 929         /* board-specifc GPIO iomux */
 930         if (board_type < GW_UNKNOWN) {
 931                 imx_iomux_v3_setup_multiple_pads(gw_gpio_pads,
 932                                                  ARRAY_SIZE(gw_gpio_pads));
 933                 imx_iomux_v3_setup_multiple_pads(gpio_cfg[board_type].gpio_pads,
 934                                                  gpio_cfg[board_type].num_pads);
 935         }
 936
 937         return 0;
 938 }
 939
 940 #if defined(CONFIG_DISPLAY_BOARDINFO_LATE)
 941 /*
 942  * called during late init (after relocation and after board_init())
 943  * by virtue of CONFIG_DISPLAY_BOARDINFO_LATE as we needed i2c initialized and
 944  * EEPROM read.
 945  */
 946 int checkboard(void)
 947 {
 948         struct ventana_board_info *info = &ventana_info;
 949         unsigned char buf[4];
 950         const char *p;
 951         int quiet; /* Quiet or minimal output mode */
 952
 953         quiet = 0;
 954         p = getenv("quiet");
 955         if (p)
 956                 quiet = simple_strtol(p, NULL, 10);
 957         else
 958                 setenv("quiet", "0");
 959
 960         puts("\nGateworks Corporation Copyright 2014\n");
 961         if (info->model[0]) {
 962                 printf("Model: %s\n", info->model);
 963                 printf("MFGDate: %02x-%02x-%02x%02x\n",
 964                        info->mfgdate[0], info->mfgdate[1],
 965                        info->mfgdate[2], info->mfgdate[3]);
 966                 printf("Serial:%d\n", info->serial);
 967         } else {
 968                 puts("Invalid EEPROM - board will not function fully\n");
 969         }
 970         if (quiet)
 971                 return 0;
 972
 973         /* Display GSC firmware revision/CRC/status */
 974         i2c_set_bus_num(I2C_GSC);
 975         if (!gsc_i2c_read(GSC_SC_ADDR, GSC_SC_FWVER, 1, buf, 1)) {
 976                 printf("GSC:   v%d", buf[0]);
 977                 if (!gsc_i2c_read(GSC_SC_ADDR, GSC_SC_STATUS, 1, buf, 4)) {
 978                         printf(" 0x%04x", buf[2] | buf[3]<<8); /* CRC */
 979                         printf(" 0x%02x", buf[0]); /* irq status */
 980                 }
 981                 puts("\n");
 982         }
 983         /* Display RTC */
 984         if (!gsc_i2c_read(GSC_RTC_ADDR, 0x00, 1, buf, 4)) {
 985                 printf("RTC:   %d\n",
 986                        buf[0] | buf[1]<<8 | buf[2]<<16 | buf[3]<<24);
 987         }
 988
 989         return 0;
 990 }
 991 #endif
 992
 993 #ifdef CONFIG_CMD_BMODE
 994 /*
 995  * BOOT_CFG1, BOOT_CFG2, BOOT_CFG3, BOOT_CFG4
 996  * see Table 8-11 and Table 5-9
 997  *  BOOT_CFG1[7] = 1 (boot from NAND)
 998  *  BOOT_CFG1[5] = 0 - raw NAND
 999  *  BOOT_CFG1[4] = 0 - default pad settings
1000  *  BOOT_CFG1[3:2] = 00 - devices = 1
1001  *  BOOT_CFG1[1:0] = 00 - Row Address Cycles = 3
1002  *  BOOT_CFG2[4:3] = 00 - Boot Search Count = 2
1003  *  BOOT_CFG2[2:1] = 01 - Pages In Block = 64
1004  *  BOOT_CFG2[0] = 0 - Reset time 12ms
1005  */
1006 static const struct boot_mode board_boot_modes[] = {
1007         /* NAND: 64pages per block, 3 row addr cycles, 2 copies of FCB/DBBT */
1008         { "nand", MAKE_CFGVAL(0x80, 0x02, 0x00, 0x00) },
1009         { NULL, 0 },
1010 };
1011 #endif
1012
1013 /* late init */
1014 int misc_init_r(void)
1015 {
1016         struct ventana_board_info *info = &ventana_info;
1017         unsigned char reg;
1018
1019         /* set env vars based on EEPROM data */
1020         if (ventana_info.model[0]) {
1021                 char str[16], fdt[36];
1022                 char *p;
1023                 const char *cputype = "";
1024                 int i;
1025
1026                 /*
1027                  * FDT name will be prefixed with CPU type.  Three versions
1028                  * will be created each increasingly generic and bootloader
1029                  * env scripts will try loading each from most specific to
1030                  * least.
1031                  */
1032                 if (is_cpu_type(MXC_CPU_MX6Q))
1033                         cputype = "imx6q";
1034                 else if (is_cpu_type(MXC_CPU_MX6DL))
1035                         cputype = "imx6dl";
1036                 memset(str, 0, sizeof(str));
1037                 for (i = 0; i < (sizeof(str)-1) && info->model[i]; i++)
1038                         str[i] = tolower(info->model[i]);
1039                 if (!getenv("model"))
1040                         setenv("model", str);
1041                 if (!getenv("fdt_file")) {
1042                         sprintf(fdt, "%s-%s.dtb", cputype, str);
1043                         setenv("fdt_file", fdt);
1044                 }
1045                 p = strchr(str, '-');
1046                 if (p) {
1047                         *p++ = 0;
1048
1049                         setenv("model_base", str);
1050                         if (!getenv("fdt_file1")) {
1051                                 sprintf(fdt, "%s-%s.dtb", cputype, str);
1052                                 setenv("fdt_file1", fdt);
1053                         }
1054                         str[4] = 'x';
1055                         str[5] = 'x';
1056                         str[6] = 0;
1057                         if (!getenv("fdt_file2")) {
1058                                 sprintf(fdt, "%s-%s.dtb", cputype, str);
1059                                 setenv("fdt_file2", fdt);
1060                         }
1061                 }
1062
1063                 /* initialize env from EEPROM */
1064                 if (test_bit(EECONFIG_ETH0, info->config) &&
1065                     !getenv("ethaddr")) {
1066                         eth_setenv_enetaddr("ethaddr", info->mac0);
1067                 }
1068                 if (test_bit(EECONFIG_ETH1, info->config) &&
1069                     !getenv("eth1addr")) {
1070                         eth_setenv_enetaddr("eth1addr", info->mac1);
1071                 }
1072
1073                 /* board serial-number */
1074                 sprintf(str, "%6d", info->serial);
1075                 setenv("serial#", str);
1076         }
1077
1078         /* configure PFUZE100 PMIC (not used on all Ventana baseboards) */
1079         power_pfuze100_init(I2C_PMIC);
1080         if (board_type == GW54xx || board_type == GW54proto) {
1081                 struct pmic *p = pmic_get("PFUZE100_PMIC");
1082                 u32 reg;
1083
1084                 if (p && !pmic_probe(p)) {
1085                         pmic_reg_read(p, PFUZE100_DEVICEID, &reg);
1086                         printf("PMIC:  PFUZE100 ID=0x%02x\n", reg);
1087
1088                         /* Set VGEN1 to 1.5V and enable */
1089                         pmic_reg_read(p, PFUZE100_VGEN1VOL, &reg);
1090                         reg &= ~(LDO_VOL_MASK);
1091                         reg |= (LDOA_1_50V | LDO_EN);
1092                         pmic_reg_write(p, PFUZE100_VGEN1VOL, reg);
1093
1094                         /* Set SWBST to 5.0V and enable */
1095                         pmic_reg_read(p, PFUZE100_SWBSTCON1, &reg);
1096                         reg &= ~(SWBST_MODE_MASK | SWBST_VOL_MASK);
1097                         reg |= (SWBST_5_00V | SWBST_MODE_AUTO);
1098                         pmic_reg_write(p, PFUZE100_SWBSTCON1, reg);
1099                 }
1100         }
1101
1102         /* setup baseboard specific GPIO pinmux and config */
1103         setup_board_gpio(board_type);
1104
1105 #ifdef CONFIG_CMD_BMODE
1106         add_board_boot_modes(board_boot_modes);
1107 #endif
1108
1109         /*
1110          *  The Gateworks System Controller implements a boot
1111          *  watchdog (always enabled) as a workaround for IMX6 boot related
1112          *  errata such as:
1113          *    ERR005768 - no fix
1114          *    ERR006282 - fixed in silicon r1.3
1115          *    ERR007117 - fixed in silicon r1.3
1116          *    ERR007220 - fixed in silicon r1.3
1117          *  see http://cache.freescale.com/files/32bit/doc/errata/IMX6DQCE.pdf
1118          *
1119          * Disable the boot watchdog and display/clear the timeout flag if set
1120          */
1121         i2c_set_bus_num(I2C_GSC);
1122         if (!gsc_i2c_read(GSC_SC_ADDR, GSC_SC_CTRL1, 1, &reg, 1)) {
1123                 reg |= (1 << GSC_SC_CTRL1_WDDIS);
1124                 if (gsc_i2c_write(GSC_SC_ADDR, GSC_SC_CTRL1, 1, &reg, 1))
1125                         puts("Error: could not disable GSC Watchdog\n");
1126         } else {
1127                 puts("Error: could not disable GSC Watchdog\n");
1128         }
1129         if (!gsc_i2c_read(GSC_SC_ADDR, GSC_SC_STATUS, 1, &reg, 1)) {
1130                 if (reg & (1 << GSC_SC_IRQ_WATCHDOG)) { /* watchdog timeout */
1131                         puts("GSC boot watchdog timeout detected");
1132                         reg &= ~(1 << GSC_SC_IRQ_WATCHDOG); /* clear flag */
1133                         gsc_i2c_write(GSC_SC_ADDR, GSC_SC_STATUS, 1, &reg, 1);
1134                 }
1135         }
1136
1137         return 0;
1138 }
1139
1140 #if defined(CONFIG_OF_LIBFDT) && defined(CONFIG_OF_BOARD_SETUP)
1141
1142 /* FDT aliases associated with EEPROM config bits */
1143 const char *fdt_aliases[] = {
1144         "ethernet0",
1145         "ethernet1",
1146         "hdmi_out",
1147         "ahci0",
1148         "pcie",
1149         "ssi0",
1150         "ssi1",
1151         "lcd0",
1152         "lvds0",
1153         "lvds1",
1154         "usb0",
1155         "usb1",
1156         "mmc0",
1157         "mmc1",
1158         "mmc2",
1159         "mmc3",
1160         "uart0",
1161         "uart1",
1162         "uart2",
1163         "uart3",
1164         "uart4",
1165         "ipu0",
1166         "ipu1",
1167         "can0",
1168         "mipi_dsi",
1169         "mipi_csi",
1170         "tzasc0",
1171         "tzasc1",
1172         "i2c0",
1173         "i2c1",
1174         "i2c2",
1175         "vpu",
1176         "csi0",
1177         "csi1",
1178         "caam",
1179         NULL,
1180         NULL,
1181         NULL,
1182         NULL,
1183         NULL,
1184         "spi0",
1185         "spi1",
1186         "spi2",
1187         "spi3",
1188         "spi4",
1189         "spi5",
1190         NULL,
1191         NULL,
1192         "pps",
1193         NULL,
1194         NULL,
1195         NULL,
1196         "hdmi_in",
1197         "cvbs_out",
1198         "cvbs_in",
1199         "nand",
1200         NULL,
1201         NULL,
1202         NULL,
1203         NULL,
1204         NULL,
1205         NULL,
1206         NULL,
1207         NULL,
1208 };
1209
1210 /*
1211  * called prior to booting kernel or by 'fdt boardsetup' command
1212  *
1213  * unless 'fdt_noauto' env var is set we will update the following in the DTB:
1214  *  - mtd partitions based on mtdparts/mtdids env
1215  *  - system-serial (board serial num from EEPROM)
1216  *  - board (full model from EEPROM)
1217  *  - peripherals removed from DTB if not loaded on board (per EEPROM config)
1218  */
1219 void ft_board_setup(void *blob, bd_t *bd)
1220 {
1221         int bit;
1222         struct ventana_board_info *info = &ventana_info;
1223         struct node_info nodes[] = {
1224                 { "sst,w25q256",          MTD_DEV_TYPE_NOR, },  /* SPI flash */
1225                 { "fsl,imx6q-gpmi-nand",  MTD_DEV_TYPE_NAND, }, /* NAND flash */
1226         };
1227         const char *model = getenv("model");
1228
1229         if (getenv("fdt_noauto")) {
1230                 puts("   Skiping ft_board_setup (fdt_noauto defined)\n");
1231                 return;
1232         }
1233
1234         /* Update partition nodes using info from mtdparts env var */
1235         puts("   Updating MTD partitions...\n");
1236         fdt_fixup_mtdparts(blob, nodes, ARRAY_SIZE(nodes));
1237
1238         if (!model) {
1239                 puts("invalid board info: Leaving FDT fully enabled\n");
1240                 return;
1241         }
1242         printf("   Adjusting FDT per EEPROM for %s...\n", model);
1243
1244         /* board serial number */
1245         fdt_setprop(blob, 0, "system-serial", getenv("serial#"),
1246                     strlen(getenv("serial#") + 1));
1247
1248         /* board (model contains model from device-tree) */
1249         fdt_setprop(blob, 0, "board", info->model,
1250                     strlen((const char *)info->model) + 1);
1251
1252         /*
1253          * Peripheral Config:
1254          *  remove nodes by alias path if EEPROM config tells us the
1255          *  peripheral is not loaded on the board.
1256          */
1257         for (bit = 0; bit < 64; bit++) {
1258                 if (!test_bit(bit, info->config))
1259                         fdt_del_node_and_alias(blob, fdt_aliases[bit]);
1260         }
1261 }
1262 #endif /* defined(CONFIG_OF_FLAT_TREE) && defined(CONFIG_OF_BOARD_SETUP) */
1263