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-tfp410.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 struct tfp410_platform_data dvi_panel = {
 448         .i2c_bus_num            = 3,
 449         .power_down_gpio        = IGEP2_GPIO_DVI_PUP,
 450 };
 451
 452 static struct omap_dss_device igep2_dvi_device = {
 453         .type                   = OMAP_DISPLAY_TYPE_DPI,
 454         .name                   = "dvi",
 455         .driver_name            = "tfp410",
 456         .data                   = &dvi_panel,
 457         .phy.dpi.data_lines     = 24,
 458 };
 459
 460 static struct omap_dss_device *igep2_dss_devices[] = {
 461         &igep2_dvi_device
 462 };
 463
 464 static struct omap_dss_board_info igep2_dss_data = {
 465         .num_devices    = ARRAY_SIZE(igep2_dss_devices),
 466         .devices        = igep2_dss_devices,
 467         .default_device = &igep2_dvi_device,
 468 };
 469
 470 static struct platform_device *igep_devices[] __initdata = {
 471         &igep_vwlan_device,
 472 };
 473
 474 static int igep2_keymap[] = {
 475         KEY(0, 0, KEY_LEFT),
 476         KEY(0, 1, KEY_RIGHT),
 477         KEY(0, 2, KEY_A),
 478         KEY(0, 3, KEY_B),
 479         KEY(1, 0, KEY_DOWN),
 480         KEY(1, 1, KEY_UP),
 481         KEY(1, 2, KEY_E),
 482         KEY(1, 3, KEY_F),
 483         KEY(2, 0, KEY_ENTER),
 484         KEY(2, 1, KEY_I),
 485         KEY(2, 2, KEY_J),
 486         KEY(2, 3, KEY_K),
 487         KEY(3, 0, KEY_M),
 488         KEY(3, 1, KEY_N),
 489         KEY(3, 2, KEY_O),
 490         KEY(3, 3, KEY_P)
 491 };
 492
 493 static struct matrix_keymap_data igep2_keymap_data = {
 494         .keymap                 = igep2_keymap,
 495         .keymap_size            = ARRAY_SIZE(igep2_keymap),
 496 };
 497
 498 static struct twl4030_keypad_data igep2_keypad_pdata = {
 499         .keymap_data    = &igep2_keymap_data,
 500         .rows           = 4,
 501         .cols           = 4,
 502         .rep            = 1,
 503 };
 504
 505 static struct twl4030_platform_data igep_twldata = {
 506         /* platform_data for children goes here */
 507         .gpio           = &igep_twl4030_gpio_pdata,
 508         .vmmc1          = &igep_vmmc1,
 509         .vio            = &igep_vio,
 510 };
 511
 512 static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
 513         {
 514                 I2C_BOARD_INFO("eeprom", 0x50),
 515         },
 516 };
 517
 518 static void __init igep_i2c_init(void)
 519 {
 520         int ret;
 521
 522         omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_USB,
 523                               TWL_COMMON_REGULATOR_VPLL2);
 524         igep_twldata.vpll2->constraints.apply_uV = true;
 525         igep_twldata.vpll2->constraints.name = "VDVI";
 526
 527         if (machine_is_igep0020()) {
 528                 /*
 529                  * Bus 3 is attached to the DVI port where devices like the
 530                  * pico DLP projector don't work reliably with 400kHz
 531                  */
 532                 ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
 533                                             ARRAY_SIZE(igep2_i2c3_boardinfo));
 534                 if (ret)
 535                         pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
 536
 537                 igep_twldata.keypad     = &igep2_keypad_pdata;
 538                 /* Get common pmic data */
 539                 omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_AUDIO, 0);
 540         }
 541
 542         omap3_pmic_init("twl4030", &igep_twldata);
 543 }
 544
 545 static const struct usbhs_omap_board_data igep2_usbhs_bdata __initconst = {
 546         .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
 547         .port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
 548         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 549
 550         .phy_reset = true,
 551         .reset_gpio_port[0] = IGEP2_GPIO_USBH_NRESET,
 552         .reset_gpio_port[1] = -EINVAL,
 553         .reset_gpio_port[2] = -EINVAL,
 554 };
 555
 556 static const struct usbhs_omap_board_data igep3_usbhs_bdata __initconst = {
 557         .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
 558         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
 559         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 560
 561         .phy_reset = true,
 562         .reset_gpio_port[0] = -EINVAL,
 563         .reset_gpio_port[1] = IGEP3_GPIO_USBH_NRESET,
 564         .reset_gpio_port[2] = -EINVAL,
 565 };
 566
 567 #ifdef CONFIG_OMAP_MUX
 568 static struct omap_board_mux board_mux[] __initdata = {
 569         { .reg_offset = OMAP_MUX_TERMINATOR },
 570 };
 571 #endif
 572
 573 #if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
 574 static struct gpio igep_wlan_bt_gpios[] __initdata = {
 575         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NPD"    },
 576         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NRESET" },
 577         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_BT_NRESET"   },
 578 };
 579
 580 static void __init igep_wlan_bt_init(void)
 581 {
 582         int err;
 583
 584         /* GPIO's for WLAN-BT combo depends on hardware revision */
 585         if (hwrev == IGEP2_BOARD_HWREV_B) {
 586                 igep_wlan_bt_gpios[0].gpio = IGEP2_RB_GPIO_WIFI_NPD;
 587                 igep_wlan_bt_gpios[1].gpio = IGEP2_RB_GPIO_WIFI_NRESET;
 588                 igep_wlan_bt_gpios[2].gpio = IGEP2_RB_GPIO_BT_NRESET;
 589         } else if (hwrev == IGEP2_BOARD_HWREV_C || machine_is_igep0030()) {
 590                 igep_wlan_bt_gpios[0].gpio = IGEP2_RC_GPIO_WIFI_NPD;
 591                 igep_wlan_bt_gpios[1].gpio = IGEP2_RC_GPIO_WIFI_NRESET;
 592                 igep_wlan_bt_gpios[2].gpio = IGEP2_RC_GPIO_BT_NRESET;
 593         } else
 594                 return;
 595
 596         err = gpio_request_array(igep_wlan_bt_gpios,
 597                                  ARRAY_SIZE(igep_wlan_bt_gpios));
 598         if (err) {
 599                 pr_warning("IGEP2: Could not obtain WIFI/BT gpios\n");
 600                 return;
 601         }
 602
 603         gpio_export(igep_wlan_bt_gpios[0].gpio, 0);
 604         gpio_export(igep_wlan_bt_gpios[1].gpio, 0);
 605         gpio_export(igep_wlan_bt_gpios[2].gpio, 0);
 606
 607         gpio_set_value(igep_wlan_bt_gpios[1].gpio, 0);
 608         udelay(10);
 609         gpio_set_value(igep_wlan_bt_gpios[1].gpio, 1);
 610
 611 }
 612 #else
 613 static inline void __init igep_wlan_bt_init(void) { }
 614 #endif
 615
 616 static struct regulator_consumer_supply dummy_supplies[] = {
 617         REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
 618         REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
 619 };
 620
 621 static void __init igep_init(void)
 622 {
 623         regulator_register_fixed(1, dummy_supplies, ARRAY_SIZE(dummy_supplies));
 624         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 625
 626         /* Get IGEP2 hardware revision */
 627         igep2_get_revision();
 628
 629         omap_hsmmc_init(mmc);
 630
 631         /* Register I2C busses and drivers */
 632         igep_i2c_init();
 633         platform_add_devices(igep_devices, ARRAY_SIZE(igep_devices));
 634         omap_serial_init();
 635         omap_sdrc_init(m65kxxxxam_sdrc_params,
 636                                   m65kxxxxam_sdrc_params);
 637         usb_musb_init(NULL);
 638
 639         igep_flash_init();
 640         igep_leds_init();
 641
 642         /*
 643          * WLAN-BT combo module from MuRata which has a Marvell WLAN
 644          * (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
 645          */
 646         igep_wlan_bt_init();
 647
 648         if (machine_is_igep0020()) {
 649                 omap_display_init(&igep2_dss_data);
 650                 igep2_init_smsc911x();
 651                 usbhs_init(&igep2_usbhs_bdata);
 652         } else {
 653                 usbhs_init(&igep3_usbhs_bdata);
 654         }
 655 }
 656
 657 MACHINE_START(IGEP0020, "IGEP v2 board")
 658         .atag_offset    = 0x100,
 659         .reserve        = omap_reserve,
 660         .map_io         = omap3_map_io,
 661         .init_early     = omap35xx_init_early,
 662         .init_irq       = omap3_init_irq,
 663         .handle_irq     = omap3_intc_handle_irq,
 664         .init_machine   = igep_init,
 665         .timer          = &omap3_timer,
 666         .restart        = omap_prcm_restart,
 667 MACHINE_END
 668
 669 MACHINE_START(IGEP0030, "IGEP OMAP3 module")
 670         .atag_offset    = 0x100,
 671         .reserve        = omap_reserve,
 672         .map_io         = omap3_map_io,
 673         .init_early     = omap35xx_init_early,
 674         .init_irq       = omap3_init_irq,
 675         .handle_irq     = omap3_intc_handle_irq,
 676         .init_machine   = igep_init,
 677         .timer          = &omap3_timer,
 678         .restart        = omap_prcm_restart,
 679 MACHINE_END