arch/arm/mach-omap2/board-igep0020.c

   1 /*
   2  * Copyright (C) 2009 Integration Software and Electronic Engineering.
   3  *
   4  * Modified from mach-omap2/board-generic.c
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/delay.h>
  15 #include <linux/err.h>
  16 #include <linux/clk.h>
  17 #include <linux/io.h>
  18 #include <linux/gpio.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/input.h>
  21
  22 #include <linux/regulator/machine.h>
  23 #include <linux/regulator/fixed.h>
  24 #include <linux/i2c/twl.h>
  25 #include <linux/mmc/host.h>
  26
  27 #include <asm/mach-types.h>
  28 #include <asm/mach/arch.h>
  29
  30 #include <plat/board.h>
  31 #include "common.h"
  32 #include <plat/gpmc.h>
  33 #include <plat/usb.h>
  34 #include <video/omapdss.h>
  35 #include <video/omap-panel-dvi.h>
  36 #include <plat/onenand.h>
  37
  38 #include "mux.h"
  39 #include "hsmmc.h"
  40 #include "sdram-numonyx-m65kxxxxam.h"
  41 #include "common-board-devices.h"
  42
  43 #define IGEP2_SMSC911X_CS       5
  44 #define IGEP2_SMSC911X_GPIO     176
  45 #define IGEP2_GPIO_USBH_NRESET  24
  46 #define IGEP2_GPIO_LED0_GREEN   26
  47 #define IGEP2_GPIO_LED0_RED     27
  48 #define IGEP2_GPIO_LED1_RED     28
  49 #define IGEP2_GPIO_DVI_PUP      170
  50
  51 #define IGEP2_RB_GPIO_WIFI_NPD     94
  52 #define IGEP2_RB_GPIO_WIFI_NRESET  95
  53 #define IGEP2_RB_GPIO_BT_NRESET    137
  54 #define IGEP2_RC_GPIO_WIFI_NPD     138
  55 #define IGEP2_RC_GPIO_WIFI_NRESET  139
  56 #define IGEP2_RC_GPIO_BT_NRESET    137
  57
  58 #define IGEP3_GPIO_LED0_GREEN   54
  59 #define IGEP3_GPIO_LED0_RED     53
  60 #define IGEP3_GPIO_LED1_RED     16
  61 #define IGEP3_GPIO_USBH_NRESET  183
  62
  63 /*
  64  * IGEP2 Hardware Revision Table
  65  *
  66  *  --------------------------------------------------------------------------
  67  * | Id. | Hw Rev.            | HW0 (28) | WIFI_NPD | WIFI_NRESET | BT_NRESET |
  68  *  --------------------------------------------------------------------------
  69  * |  0  | B                  |   high   |  gpio94  |   gpio95    |     -     |
  70  * |  0  | B/C (B-compatible) |   high   |  gpio94  |   gpio95    |  gpio137  |
  71  * |  1  | C                  |   low    |  gpio138 |   gpio139   |  gpio137  |
  72  *  --------------------------------------------------------------------------
  73  */
  74
  75 #define IGEP2_BOARD_HWREV_B     0
  76 #define IGEP2_BOARD_HWREV_C     1
  77 #define IGEP3_BOARD_HWREV       2
  78
  79 static u8 hwrev;
  80
  81 static void __init igep2_get_revision(void)
  82 {
  83         u8 ret;
  84
  85         if (machine_is_igep0030()) {
  86                 hwrev = IGEP3_BOARD_HWREV;
  87                 return;
  88         }
  89
  90         omap_mux_init_gpio(IGEP2_GPIO_LED1_RED, OMAP_PIN_INPUT);
  91
  92         if (gpio_request_one(IGEP2_GPIO_LED1_RED, GPIOF_IN, "GPIO_HW0_REV")) {
  93                 pr_warning("IGEP2: Could not obtain gpio GPIO_HW0_REV\n");
  94                 pr_err("IGEP2: Unknown Hardware Revision\n");
  95                 return;
  96         }
  97
  98         ret = gpio_get_value(IGEP2_GPIO_LED1_RED);
  99         if (ret == 0) {
 100                 pr_info("IGEP2: Hardware Revision C (B-NON compatible)\n");
 101                 hwrev = IGEP2_BOARD_HWREV_C;
 102         } else if (ret ==  1) {
 103                 pr_info("IGEP2: Hardware Revision B/C (B compatible)\n");
 104                 hwrev = IGEP2_BOARD_HWREV_B;
 105         } else {
 106                 pr_err("IGEP2: Unknown Hardware Revision\n");
 107                 hwrev = -1;
 108         }
 109
 110         gpio_free(IGEP2_GPIO_LED1_RED);
 111 }
 112
 113 #if defined(CONFIG_MTD_ONENAND_OMAP2) || \
 114         defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)
 115
 116 #define ONENAND_MAP             0x20000000
 117
 118 /* NAND04GR4E1A ( x2 Flash built-in COMBO POP MEMORY )
 119  * Since the device is equipped with two DataRAMs, and two-plane NAND
 120  * Flash memory array, these two component enables simultaneous program
 121  * of 4KiB. Plane1 has only even blocks such as block0, block2, block4
 122  * while Plane2 has only odd blocks such as block1, block3, block5.
 123  * So MTD regards it as 4KiB page size and 256KiB block size 64*(2*2048)
 124  */
 125
 126 static struct mtd_partition igep_onenand_partitions[] = {
 127         {
 128                 .name           = "X-Loader",
 129                 .offset         = 0,
 130                 .size           = 2 * (64*(2*2048))
 131         },
 132         {
 133                 .name           = "U-Boot",
 134                 .offset         = MTDPART_OFS_APPEND,
 135                 .size           = 6 * (64*(2*2048)),
 136         },
 137         {
 138                 .name           = "Environment",
 139                 .offset         = MTDPART_OFS_APPEND,
 140                 .size           = 2 * (64*(2*2048)),
 141         },
 142         {
 143                 .name           = "Kernel",
 144                 .offset         = MTDPART_OFS_APPEND,
 145                 .size           = 12 * (64*(2*2048)),
 146         },
 147         {
 148                 .name           = "File System",
 149                 .offset         = MTDPART_OFS_APPEND,
 150                 .size           = MTDPART_SIZ_FULL,
 151         },
 152 };
 153
 154 static struct omap_onenand_platform_data igep_onenand_data = {
 155         .parts = igep_onenand_partitions,
 156         .nr_parts = ARRAY_SIZE(igep_onenand_partitions),
 157         .dma_channel    = -1,   /* disable DMA in OMAP OneNAND driver */
 158 };
 159
 160 static struct platform_device igep_onenand_device = {
 161         .name           = "omap2-onenand",
 162         .id             = -1,
 163         .dev = {
 164                 .platform_data = &igep_onenand_data,
 165         },
 166 };
 167
 168 static void __init igep_flash_init(void)
 169 {
 170         u8 cs = 0;
 171         u8 onenandcs = GPMC_CS_NUM + 1;
 172
 173         for (cs = 0; cs < GPMC_CS_NUM; cs++) {
 174                 u32 ret;
 175                 ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
 176
 177                 /* Check if NAND/oneNAND is configured */
 178                 if ((ret & 0xC00) == 0x800)
 179                         /* NAND found */
 180                         pr_err("IGEP: Unsupported NAND found\n");
 181                 else {
 182                         ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
 183                         if ((ret & 0x3F) == (ONENAND_MAP >> 24))
 184                                 /* ONENAND found */
 185                                 onenandcs = cs;
 186                 }
 187         }
 188
 189         if (onenandcs > GPMC_CS_NUM) {
 190                 pr_err("IGEP: Unable to find configuration in GPMC\n");
 191                 return;
 192         }
 193
 194         igep_onenand_data.cs = onenandcs;
 195
 196         if (platform_device_register(&igep_onenand_device) < 0)
 197                 pr_err("IGEP: Unable to register OneNAND device\n");
 198 }
 199
 200 #else
 201 static void __init igep_flash_init(void) {}
 202 #endif
 203
 204 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
 205
 206 #include <linux/smsc911x.h>
 207 #include <plat/gpmc-smsc911x.h>
 208
 209 static struct omap_smsc911x_platform_data smsc911x_cfg = {
 210         .cs             = IGEP2_SMSC911X_CS,
 211         .gpio_irq       = IGEP2_SMSC911X_GPIO,
 212         .gpio_reset     = -EINVAL,
 213         .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
 214 };
 215
 216 static inline void __init igep2_init_smsc911x(void)
 217 {
 218         gpmc_smsc911x_init(&smsc911x_cfg);
 219 }
 220
 221 #else
 222 static inline void __init igep2_init_smsc911x(void) { }
 223 #endif
 224
 225 static struct regulator_consumer_supply igep_vmmc1_supply[] = {
 226         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
 227 };
 228
 229 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 230 static struct regulator_init_data igep_vmmc1 = {
 231         .constraints = {
 232                 .min_uV                 = 1850000,
 233                 .max_uV                 = 3150000,
 234                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 235                                         | REGULATOR_MODE_STANDBY,
 236                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 237                                         | REGULATOR_CHANGE_MODE
 238                                         | REGULATOR_CHANGE_STATUS,
 239         },
 240         .num_consumer_supplies  = ARRAY_SIZE(igep_vmmc1_supply),
 241         .consumer_supplies      = igep_vmmc1_supply,
 242 };
 243
 244 static struct regulator_consumer_supply igep_vio_supply[] = {
 245         REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1"),
 246 };
 247
 248 static struct regulator_init_data igep_vio = {
 249         .constraints = {
 250                 .min_uV                 = 1800000,
 251                 .max_uV                 = 1800000,
 252                 .apply_uV               = 1,
 253                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 254                                         | REGULATOR_MODE_STANDBY,
 255                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 256                                         | REGULATOR_CHANGE_MODE
 257                                         | REGULATOR_CHANGE_STATUS,
 258         },
 259         .num_consumer_supplies  = ARRAY_SIZE(igep_vio_supply),
 260         .consumer_supplies      = igep_vio_supply,
 261 };
 262
 263 static struct regulator_consumer_supply igep_vmmc2_supply[] = {
 264         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
 265 };
 266
 267 static struct regulator_init_data igep_vmmc2 = {
 268         .constraints            = {
 269                 .valid_modes_mask       = REGULATOR_MODE_NORMAL,
 270                 .always_on              = 1,
 271         },
 272         .num_consumer_supplies  = ARRAY_SIZE(igep_vmmc2_supply),
 273         .consumer_supplies      = igep_vmmc2_supply,
 274 };
 275
 276 static struct fixed_voltage_config igep_vwlan = {
 277         .supply_name            = "vwlan",
 278         .microvolts             = 3300000,
 279         .gpio                   = -EINVAL,
 280         .enabled_at_boot        = 1,
 281         .init_data              = &igep_vmmc2,
 282 };
 283
 284 static struct platform_device igep_vwlan_device = {
 285         .name           = "reg-fixed-voltage",
 286         .id             = 0,
 287         .dev = {
 288                 .platform_data  = &igep_vwlan,
 289         },
 290 };
 291
 292 static struct omap2_hsmmc_info mmc[] = {
 293         {
 294                 .mmc            = 1,
 295                 .caps           = MMC_CAP_4_BIT_DATA,
 296                 .gpio_cd        = -EINVAL,
 297                 .gpio_wp        = -EINVAL,
 298                 .deferred       = true,
 299         },
 300 #if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
 301         {
 302                 .mmc            = 2,
 303                 .caps           = MMC_CAP_4_BIT_DATA,
 304                 .gpio_cd        = -EINVAL,
 305                 .gpio_wp        = -EINVAL,
 306         },
 307 #endif
 308         {}      /* Terminator */
 309 };
 310
 311 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
 312 #include <linux/leds.h>
 313
 314 static struct gpio_led igep_gpio_leds[] = {
 315         [0] = {
 316                 .name                   = "gpio-led:red:d0",
 317                 .default_trigger        = "default-off"
 318         },
 319         [1] = {
 320                 .name                   = "gpio-led:green:d0",
 321                 .default_trigger        = "default-off",
 322         },
 323         [2] = {
 324                 .name                   = "gpio-led:red:d1",
 325                 .default_trigger        = "default-off",
 326         },
 327         [3] = {
 328                 .name                   = "gpio-led:green:d1",
 329                 .default_trigger        = "heartbeat",
 330                 .gpio                   = -EINVAL, /* gets replaced */
 331                 .active_low             = 1,
 332         },
 333 };
 334
 335 static struct gpio_led_platform_data igep_led_pdata = {
 336         .leds           = igep_gpio_leds,
 337         .num_leds       = ARRAY_SIZE(igep_gpio_leds),
 338 };
 339
 340 static struct platform_device igep_led_device = {
 341          .name   = "leds-gpio",
 342          .id     = -1,
 343          .dev    = {
 344                  .platform_data  =  &igep_led_pdata,
 345         },
 346 };
 347
 348 static void __init igep_leds_init(void)
 349 {
 350         if (machine_is_igep0020()) {
 351                 igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
 352                 igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
 353                 igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
 354         } else {
 355                 igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
 356                 igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
 357                 igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
 358         }
 359
 360         platform_device_register(&igep_led_device);
 361 }
 362
 363 #else
 364 static struct gpio igep_gpio_leds[] __initdata = {
 365         { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:red:d0"   },
 366         { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:green:d0" },
 367         { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:red:d1"   },
 368 };
 369
 370 static inline void igep_leds_init(void)
 371 {
 372         int i;
 373
 374         if (machine_is_igep0020()) {
 375                 igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
 376                 igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
 377                 igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
 378         } else {
 379                 igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
 380                 igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
 381                 igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
 382         }
 383
 384         if (gpio_request_array(igep_gpio_leds, ARRAY_SIZE(igep_gpio_leds))) {
 385                 pr_warning("IGEP v2: Could not obtain leds gpios\n");
 386                 return;
 387         }
 388
 389         for (i = 0; i < ARRAY_SIZE(igep_gpio_leds); i++)
 390                 gpio_export(igep_gpio_leds[i].gpio, 0);
 391 }
 392 #endif
 393
 394 static struct gpio igep2_twl_gpios[] = {
 395         { -EINVAL, GPIOF_IN,            "GPIO_EHCI_NOC"  },
 396         { -EINVAL, GPIOF_OUT_INIT_LOW,  "GPIO_USBH_CPEN" },
 397 };
 398
 399 static int igep_twl_gpio_setup(struct device *dev,
 400                 unsigned gpio, unsigned ngpio)
 401 {
 402         int ret;
 403
 404         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
 405         mmc[0].gpio_cd = gpio + 0;
 406         omap_hsmmc_late_init(mmc);
 407
 408         /* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
 409 #if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
 410         ret = gpio_request_one(gpio + TWL4030_GPIO_MAX + 1, GPIOF_OUT_INIT_HIGH,
 411                                "gpio-led:green:d1");
 412         if (ret == 0)
 413                 gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
 414         else
 415                 pr_warning("IGEP: Could not obtain gpio GPIO_LED1_GREEN\n");
 416 #else
 417         igep_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
 418 #endif
 419
 420         if (machine_is_igep0030())
 421                 return 0;
 422
 423         /*
 424          * REVISIT: need ehci-omap hooks for external VBUS
 425          * power switch and overcurrent detect
 426          */
 427         igep2_twl_gpios[0].gpio = gpio + 1;
 428
 429         /* TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN (out, active low) */
 430         igep2_twl_gpios[1].gpio = gpio + TWL4030_GPIO_MAX;
 431
 432         ret = gpio_request_array(igep2_twl_gpios, ARRAY_SIZE(igep2_twl_gpios));
 433         if (ret < 0)
 434                 pr_err("IGEP2: Could not obtain gpio for USBH_CPEN");
 435
 436         return 0;
 437 };
 438
 439 static struct twl4030_gpio_platform_data igep_twl4030_gpio_pdata = {
 440         .gpio_base      = OMAP_MAX_GPIO_LINES,
 441         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 442         .irq_end        = TWL4030_GPIO_IRQ_END,
 443         .use_leds       = true,
 444         .setup          = igep_twl_gpio_setup,
 445 };
 446
 447 static int igep2_enable_dvi(struct omap_dss_device *dssdev)
 448 {
 449         gpio_direction_output(IGEP2_GPIO_DVI_PUP, 1);
 450
 451         return 0;
 452 }
 453
 454 static void igep2_disable_dvi(struct omap_dss_device *dssdev)
 455 {
 456         gpio_direction_output(IGEP2_GPIO_DVI_PUP, 0);
 457 }
 458
 459 static struct panel_dvi_platform_data dvi_panel = {
 460         .platform_enable        = igep2_enable_dvi,
 461         .platform_disable       = igep2_disable_dvi,
 462         .i2c_bus_num = 3,
 463 };
 464
 465 static struct omap_dss_device igep2_dvi_device = {
 466         .type                   = OMAP_DISPLAY_TYPE_DPI,
 467         .name                   = "dvi",
 468         .driver_name            = "dvi",
 469         .data                   = &dvi_panel,
 470         .phy.dpi.data_lines     = 24,
 471 };
 472
 473 static struct omap_dss_device *igep2_dss_devices[] = {
 474         &igep2_dvi_device
 475 };
 476
 477 static struct omap_dss_board_info igep2_dss_data = {
 478         .num_devices    = ARRAY_SIZE(igep2_dss_devices),
 479         .devices        = igep2_dss_devices,
 480         .default_device = &igep2_dvi_device,
 481 };
 482
 483 static void __init igep2_display_init(void)
 484 {
 485         int err = gpio_request_one(IGEP2_GPIO_DVI_PUP, GPIOF_OUT_INIT_HIGH,
 486                                    "GPIO_DVI_PUP");
 487         if (err)
 488                 pr_err("IGEP v2: Could not obtain gpio GPIO_DVI_PUP\n");
 489 }
 490
 491 static struct platform_device *igep_devices[] __initdata = {
 492         &igep_vwlan_device,
 493 };
 494
 495 static int igep2_keymap[] = {
 496         KEY(0, 0, KEY_LEFT),
 497         KEY(0, 1, KEY_RIGHT),
 498         KEY(0, 2, KEY_A),
 499         KEY(0, 3, KEY_B),
 500         KEY(1, 0, KEY_DOWN),
 501         KEY(1, 1, KEY_UP),
 502         KEY(1, 2, KEY_E),
 503         KEY(1, 3, KEY_F),
 504         KEY(2, 0, KEY_ENTER),
 505         KEY(2, 1, KEY_I),
 506         KEY(2, 2, KEY_J),
 507         KEY(2, 3, KEY_K),
 508         KEY(3, 0, KEY_M),
 509         KEY(3, 1, KEY_N),
 510         KEY(3, 2, KEY_O),
 511         KEY(3, 3, KEY_P)
 512 };
 513
 514 static struct matrix_keymap_data igep2_keymap_data = {
 515         .keymap                 = igep2_keymap,
 516         .keymap_size            = ARRAY_SIZE(igep2_keymap),
 517 };
 518
 519 static struct twl4030_keypad_data igep2_keypad_pdata = {
 520         .keymap_data    = &igep2_keymap_data,
 521         .rows           = 4,
 522         .cols           = 4,
 523         .rep            = 1,
 524 };
 525
 526 static struct twl4030_platform_data igep_twldata = {
 527         /* platform_data for children goes here */
 528         .gpio           = &igep_twl4030_gpio_pdata,
 529         .vmmc1          = &igep_vmmc1,
 530         .vio            = &igep_vio,
 531 };
 532
 533 static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
 534         {
 535                 I2C_BOARD_INFO("eeprom", 0x50),
 536         },
 537 };
 538
 539 static void __init igep_i2c_init(void)
 540 {
 541         int ret;
 542
 543         omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_USB, 0);
 544
 545         if (machine_is_igep0020()) {
 546                 /*
 547                  * Bus 3 is attached to the DVI port where devices like the
 548                  * pico DLP projector don't work reliably with 400kHz
 549                  */
 550                 ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
 551                                             ARRAY_SIZE(igep2_i2c3_boardinfo));
 552                 if (ret)
 553                         pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
 554
 555                 igep_twldata.keypad     = &igep2_keypad_pdata;
 556                 /* Get common pmic data */
 557                 omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_AUDIO,
 558                                       TWL_COMMON_REGULATOR_VPLL2);
 559                 igep_twldata.vpll2->constraints.apply_uV = true;
 560                 igep_twldata.vpll2->constraints.name = "VDVI";
 561         }
 562
 563         omap3_pmic_init("twl4030", &igep_twldata);
 564 }
 565
 566 static const struct usbhs_omap_board_data igep2_usbhs_bdata __initconst = {
 567         .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
 568         .port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
 569         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 570
 571         .phy_reset = true,
 572         .reset_gpio_port[0] = IGEP2_GPIO_USBH_NRESET,
 573         .reset_gpio_port[1] = -EINVAL,
 574         .reset_gpio_port[2] = -EINVAL,
 575 };
 576
 577 static const struct usbhs_omap_board_data igep3_usbhs_bdata __initconst = {
 578         .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
 579         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
 580         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 581
 582         .phy_reset = true,
 583         .reset_gpio_port[0] = -EINVAL,
 584         .reset_gpio_port[1] = IGEP3_GPIO_USBH_NRESET,
 585         .reset_gpio_port[2] = -EINVAL,
 586 };
 587
 588 #ifdef CONFIG_OMAP_MUX
 589 static struct omap_board_mux board_mux[] __initdata = {
 590         { .reg_offset = OMAP_MUX_TERMINATOR },
 591 };
 592 #endif
 593
 594 #if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
 595 static struct gpio igep_wlan_bt_gpios[] __initdata = {
 596         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NPD"    },
 597         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NRESET" },
 598         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_BT_NRESET"   },
 599 };
 600
 601 static void __init igep_wlan_bt_init(void)
 602 {
 603         int err;
 604
 605         /* GPIO's for WLAN-BT combo depends on hardware revision */
 606         if (hwrev == IGEP2_BOARD_HWREV_B) {
 607                 igep_wlan_bt_gpios[0].gpio = IGEP2_RB_GPIO_WIFI_NPD;
 608                 igep_wlan_bt_gpios[1].gpio = IGEP2_RB_GPIO_WIFI_NRESET;
 609                 igep_wlan_bt_gpios[2].gpio = IGEP2_RB_GPIO_BT_NRESET;
 610         } else if (hwrev == IGEP2_BOARD_HWREV_C || machine_is_igep0030()) {
 611                 igep_wlan_bt_gpios[0].gpio = IGEP2_RC_GPIO_WIFI_NPD;
 612                 igep_wlan_bt_gpios[1].gpio = IGEP2_RC_GPIO_WIFI_NRESET;
 613                 igep_wlan_bt_gpios[2].gpio = IGEP2_RC_GPIO_BT_NRESET;
 614         } else
 615                 return;
 616
 617         err = gpio_request_array(igep_wlan_bt_gpios,
 618                                  ARRAY_SIZE(igep_wlan_bt_gpios));
 619         if (err) {
 620                 pr_warning("IGEP2: Could not obtain WIFI/BT gpios\n");
 621                 return;
 622         }
 623
 624         gpio_export(igep_wlan_bt_gpios[0].gpio, 0);
 625         gpio_export(igep_wlan_bt_gpios[1].gpio, 0);
 626         gpio_export(igep_wlan_bt_gpios[2].gpio, 0);
 627
 628         gpio_set_value(igep_wlan_bt_gpios[1].gpio, 0);
 629         udelay(10);
 630         gpio_set_value(igep_wlan_bt_gpios[1].gpio, 1);
 631
 632 }
 633 #else
 634 static inline void __init igep_wlan_bt_init(void) { }
 635 #endif
 636
 637 static struct regulator_consumer_supply dummy_supplies[] = {
 638         REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
 639         REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
 640 };
 641
 642 static void __init igep_init(void)
 643 {
 644         regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies));
 645         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 646
 647         /* Get IGEP2 hardware revision */
 648         igep2_get_revision();
 649
 650         omap_hsmmc_init(mmc);
 651
 652         /* Register I2C busses and drivers */
 653         igep_i2c_init();
 654         platform_add_devices(igep_devices, ARRAY_SIZE(igep_devices));
 655         omap_serial_init();
 656         omap_sdrc_init(m65kxxxxam_sdrc_params,
 657                                   m65kxxxxam_sdrc_params);
 658         usb_musb_init(NULL);
 659
 660         igep_flash_init();
 661         igep_leds_init();
 662
 663         /*
 664          * WLAN-BT combo module from MuRata which has a Marvell WLAN
 665          * (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
 666          */
 667         igep_wlan_bt_init();
 668
 669         if (machine_is_igep0020()) {
 670                 omap_display_init(&igep2_dss_data);
 671                 igep2_display_init();
 672                 igep2_init_smsc911x();
 673                 usbhs_init(&igep2_usbhs_bdata);
 674         } else {
 675                 usbhs_init(&igep3_usbhs_bdata);
 676         }
 677 }
 678
 679 MACHINE_START(IGEP0020, "IGEP v2 board")
 680         .atag_offset    = 0x100,
 681         .reserve        = omap_reserve,
 682         .map_io         = omap3_map_io,
 683         .init_early     = omap35xx_init_early,
 684         .init_irq       = omap3_init_irq,
 685         .handle_irq     = omap3_intc_handle_irq,
 686         .init_machine   = igep_init,
 687         .timer          = &omap3_timer,
 688         .restart        = omap_prcm_restart,
 689 MACHINE_END
 690
 691 MACHINE_START(IGEP0030, "IGEP OMAP3 module")
 692         .atag_offset    = 0x100,
 693         .reserve        = omap_reserve,
 694         .map_io         = omap3_map_io,
 695         .init_early     = omap35xx_init_early,
 696         .init_irq       = omap3_init_irq,
 697         .handle_irq     = omap3_intc_handle_irq,
 698         .init_machine   = igep_init,
 699         .timer          = &omap3_timer,
 700         .restart        = omap_prcm_restart,
 701 MACHINE_END