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