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 <video/omapdss.h>
  35 #include <video/omap-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 #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         },
 299 #if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
 300         {
 301                 .mmc            = 2,
 302                 .caps           = MMC_CAP_4_BIT_DATA,
 303                 .gpio_cd        = -EINVAL,
 304                 .gpio_wp        = -EINVAL,
 305         },
 306 #endif
 307         {}      /* Terminator */
 308 };
 309
 310 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
 311 #include <linux/leds.h>
 312
 313 static struct gpio_led igep_gpio_leds[] = {
 314         [0] = {
 315                 .name                   = "gpio-led:red:d0",
 316                 .default_trigger        = "default-off"
 317         },
 318         [1] = {
 319                 .name                   = "gpio-led:green:d0",
 320                 .default_trigger        = "default-off",
 321         },
 322         [2] = {
 323                 .name                   = "gpio-led:red:d1",
 324                 .default_trigger        = "default-off",
 325         },
 326         [3] = {
 327                 .name                   = "gpio-led:green:d1",
 328                 .default_trigger        = "heartbeat",
 329                 .gpio                   = -EINVAL, /* gets replaced */
 330                 .active_low             = 1,
 331         },
 332 };
 333
 334 static struct gpio_led_platform_data igep_led_pdata = {
 335         .leds           = igep_gpio_leds,
 336         .num_leds       = ARRAY_SIZE(igep_gpio_leds),
 337 };
 338
 339 static struct platform_device igep_led_device = {
 340          .name   = "leds-gpio",
 341          .id     = -1,
 342          .dev    = {
 343                  .platform_data  =  &igep_led_pdata,
 344         },
 345 };
 346
 347 static void __init igep_leds_init(void)
 348 {
 349         if (machine_is_igep0020()) {
 350                 igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
 351                 igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
 352                 igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
 353         } else {
 354                 igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
 355                 igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
 356                 igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
 357         }
 358
 359         platform_device_register(&igep_led_device);
 360 }
 361
 362 #else
 363 static struct gpio igep_gpio_leds[] __initdata = {
 364         { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:red:d0"   },
 365         { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:green:d0" },
 366         { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:red:d1"   },
 367 };
 368
 369 static inline void igep_leds_init(void)
 370 {
 371         int i;
 372
 373         if (machine_is_igep0020()) {
 374                 igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
 375                 igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
 376                 igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
 377         } else {
 378                 igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
 379                 igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
 380                 igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
 381         }
 382
 383         if (gpio_request_array(igep_gpio_leds, ARRAY_SIZE(igep_gpio_leds))) {
 384                 pr_warning("IGEP v2: Could not obtain leds gpios\n");
 385                 return;
 386         }
 387
 388         for (i = 0; i < ARRAY_SIZE(igep_gpio_leds); i++)
 389                 gpio_export(igep_gpio_leds[i].gpio, 0);
 390 }
 391 #endif
 392
 393 static struct gpio igep2_twl_gpios[] = {
 394         { -EINVAL, GPIOF_IN,            "GPIO_EHCI_NOC"  },
 395         { -EINVAL, GPIOF_OUT_INIT_LOW,  "GPIO_USBH_CPEN" },
 396 };
 397
 398 static int igep_twl_gpio_setup(struct device *dev,
 399                 unsigned gpio, unsigned ngpio)
 400 {
 401         int ret;
 402
 403         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
 404         mmc[0].gpio_cd = gpio + 0;
 405         omap2_hsmmc_init(mmc);
 406
 407         /* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
 408 #if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
 409         ret = gpio_request_one(gpio + TWL4030_GPIO_MAX + 1, GPIOF_OUT_INIT_HIGH,
 410                                "gpio-led:green:d1");
 411         if (ret == 0)
 412                 gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
 413         else
 414                 pr_warning("IGEP: Could not obtain gpio GPIO_LED1_GREEN\n");
 415 #else
 416         igep_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
 417 #endif
 418
 419         if (machine_is_igep0030())
 420                 return 0;
 421
 422         /*
 423          * REVISIT: need ehci-omap hooks for external VBUS
 424          * power switch and overcurrent detect
 425          */
 426         igep2_twl_gpios[0].gpio = gpio + 1;
 427
 428         /* TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN (out, active low) */
 429         igep2_twl_gpios[1].gpio = gpio + TWL4030_GPIO_MAX;
 430
 431         ret = gpio_request_array(igep2_twl_gpios, ARRAY_SIZE(igep2_twl_gpios));
 432         if (ret < 0)
 433                 pr_err("IGEP2: Could not obtain gpio for USBH_CPEN");
 434
 435         return 0;
 436 };
 437
 438 static struct twl4030_gpio_platform_data igep_twl4030_gpio_pdata = {
 439         .gpio_base      = OMAP_MAX_GPIO_LINES,
 440         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 441         .irq_end        = TWL4030_GPIO_IRQ_END,
 442         .use_leds       = true,
 443         .setup          = igep_twl_gpio_setup,
 444 };
 445
 446 static int igep2_enable_dvi(struct omap_dss_device *dssdev)
 447 {
 448         gpio_direction_output(IGEP2_GPIO_DVI_PUP, 1);
 449
 450         return 0;
 451 }
 452
 453 static void igep2_disable_dvi(struct omap_dss_device *dssdev)
 454 {
 455         gpio_direction_output(IGEP2_GPIO_DVI_PUP, 0);
 456 }
 457
 458 static struct panel_generic_dpi_data dvi_panel = {
 459         .name                   = "generic",
 460         .platform_enable        = igep2_enable_dvi,
 461         .platform_disable       = igep2_disable_dvi,
 462 };
 463
 464 static struct omap_dss_device igep2_dvi_device = {
 465         .type                   = OMAP_DISPLAY_TYPE_DPI,
 466         .name                   = "dvi",
 467         .driver_name            = "generic_dpi_panel",
 468         .data                   = &dvi_panel,
 469         .phy.dpi.data_lines     = 24,
 470 };
 471
 472 static struct omap_dss_device *igep2_dss_devices[] = {
 473         &igep2_dvi_device
 474 };
 475
 476 static struct omap_dss_board_info igep2_dss_data = {
 477         .num_devices    = ARRAY_SIZE(igep2_dss_devices),
 478         .devices        = igep2_dss_devices,
 479         .default_device = &igep2_dvi_device,
 480 };
 481
 482 static void __init igep2_display_init(void)
 483 {
 484         int err = gpio_request_one(IGEP2_GPIO_DVI_PUP, GPIOF_OUT_INIT_HIGH,
 485                                    "GPIO_DVI_PUP");
 486         if (err)
 487                 pr_err("IGEP v2: Could not obtain gpio GPIO_DVI_PUP\n");
 488 }
 489
 490 static struct platform_device *igep_devices[] __initdata = {
 491         &igep_vwlan_device,
 492 };
 493
 494 static void __init igep_init_early(void)
 495 {
 496         omap2_init_common_infrastructure();
 497         omap2_init_common_devices(m65kxxxxam_sdrc_params,
 498                                   m65kxxxxam_sdrc_params);
 499 }
 500
 501 static int igep2_keymap[] = {
 502         KEY(0, 0, KEY_LEFT),
 503         KEY(0, 1, KEY_RIGHT),
 504         KEY(0, 2, KEY_A),
 505         KEY(0, 3, KEY_B),
 506         KEY(1, 0, KEY_DOWN),
 507         KEY(1, 1, KEY_UP),
 508         KEY(1, 2, KEY_E),
 509         KEY(1, 3, KEY_F),
 510         KEY(2, 0, KEY_ENTER),
 511         KEY(2, 1, KEY_I),
 512         KEY(2, 2, KEY_J),
 513         KEY(2, 3, KEY_K),
 514         KEY(3, 0, KEY_M),
 515         KEY(3, 1, KEY_N),
 516         KEY(3, 2, KEY_O),
 517         KEY(3, 3, KEY_P)
 518 };
 519
 520 static struct matrix_keymap_data igep2_keymap_data = {
 521         .keymap                 = igep2_keymap,
 522         .keymap_size            = ARRAY_SIZE(igep2_keymap),
 523 };
 524
 525 static struct twl4030_keypad_data igep2_keypad_pdata = {
 526         .keymap_data    = &igep2_keymap_data,
 527         .rows           = 4,
 528         .cols           = 4,
 529         .rep            = 1,
 530 };
 531
 532 static struct twl4030_platform_data igep_twldata = {
 533         /* platform_data for children goes here */
 534         .gpio           = &igep_twl4030_gpio_pdata,
 535         .vmmc1          = &igep_vmmc1,
 536         .vio            = &igep_vio,
 537 };
 538
 539 static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
 540         {
 541                 I2C_BOARD_INFO("eeprom", 0x50),
 542         },
 543 };
 544
 545 static void __init igep_i2c_init(void)
 546 {
 547         int ret;
 548
 549         omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_USB, 0);
 550
 551         if (machine_is_igep0020()) {
 552                 /*
 553                  * Bus 3 is attached to the DVI port where devices like the
 554                  * pico DLP projector don't work reliably with 400kHz
 555                  */
 556                 ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
 557                                             ARRAY_SIZE(igep2_i2c3_boardinfo));
 558                 if (ret)
 559                         pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
 560
 561                 igep_twldata.keypad     = &igep2_keypad_pdata;
 562                 /* Get common pmic data */
 563                 omap3_pmic_get_config(&igep_twldata, TWL_COMMON_PDATA_AUDIO,
 564                                       TWL_COMMON_REGULATOR_VPLL2);
 565                 igep_twldata.vpll2->constraints.apply_uV = true;
 566                 igep_twldata.vpll2->constraints.name = "VDVI";
 567         }
 568
 569         omap3_pmic_init("twl4030", &igep_twldata);
 570 }
 571
 572 static const struct usbhs_omap_board_data igep2_usbhs_bdata __initconst = {
 573         .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
 574         .port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
 575         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 576
 577         .phy_reset = true,
 578         .reset_gpio_port[0] = IGEP2_GPIO_USBH_NRESET,
 579         .reset_gpio_port[1] = -EINVAL,
 580         .reset_gpio_port[2] = -EINVAL,
 581 };
 582
 583 static const struct usbhs_omap_board_data igep3_usbhs_bdata __initconst = {
 584         .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
 585         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
 586         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 587
 588         .phy_reset = true,
 589         .reset_gpio_port[0] = -EINVAL,
 590         .reset_gpio_port[1] = IGEP3_GPIO_USBH_NRESET,
 591         .reset_gpio_port[2] = -EINVAL,
 592 };
 593
 594 #ifdef CONFIG_OMAP_MUX
 595 static struct omap_board_mux board_mux[] __initdata = {
 596         { .reg_offset = OMAP_MUX_TERMINATOR },
 597 };
 598 #endif
 599
 600 #if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
 601 static struct gpio igep_wlan_bt_gpios[] __initdata = {
 602         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NPD"    },
 603         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NRESET" },
 604         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_BT_NRESET"   },
 605 };
 606
 607 static void __init igep_wlan_bt_init(void)
 608 {
 609         int err;
 610
 611         /* GPIO's for WLAN-BT combo depends on hardware revision */
 612         if (hwrev == IGEP2_BOARD_HWREV_B) {
 613                 igep_wlan_bt_gpios[0].gpio = IGEP2_RB_GPIO_WIFI_NPD;
 614                 igep_wlan_bt_gpios[1].gpio = IGEP2_RB_GPIO_WIFI_NRESET;
 615                 igep_wlan_bt_gpios[2].gpio = IGEP2_RB_GPIO_BT_NRESET;
 616         } else if (hwrev == IGEP2_BOARD_HWREV_C || machine_is_igep0030()) {
 617                 igep_wlan_bt_gpios[0].gpio = IGEP2_RC_GPIO_WIFI_NPD;
 618                 igep_wlan_bt_gpios[1].gpio = IGEP2_RC_GPIO_WIFI_NRESET;
 619                 igep_wlan_bt_gpios[2].gpio = IGEP2_RC_GPIO_BT_NRESET;
 620         } else
 621                 return;
 622
 623         err = gpio_request_array(igep_wlan_bt_gpios,
 624                                  ARRAY_SIZE(igep_wlan_bt_gpios));
 625         if (err) {
 626                 pr_warning("IGEP2: Could not obtain WIFI/BT gpios\n");
 627                 return;
 628         }
 629
 630         gpio_export(igep_wlan_bt_gpios[0].gpio, 0);
 631         gpio_export(igep_wlan_bt_gpios[1].gpio, 0);
 632         gpio_export(igep_wlan_bt_gpios[2].gpio, 0);
 633
 634         gpio_set_value(igep_wlan_bt_gpios[1].gpio, 0);
 635         udelay(10);
 636         gpio_set_value(igep_wlan_bt_gpios[1].gpio, 1);
 637
 638 }
 639 #else
 640 static inline void __init igep_wlan_bt_init(void) { }
 641 #endif
 642
 643 static void __init igep_init(void)
 644 {
 645         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 646
 647         /* Get IGEP2 hardware revision */
 648         igep2_get_revision();
 649         /* Register I2C busses and drivers */
 650         igep_i2c_init();
 651         platform_add_devices(igep_devices, ARRAY_SIZE(igep_devices));
 652         omap_serial_init();
 653         usb_musb_init(NULL);
 654
 655         igep_flash_init();
 656         igep_leds_init();
 657
 658         /*
 659          * WLAN-BT combo module from MuRata which has a Marvell WLAN
 660          * (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
 661          */
 662         igep_wlan_bt_init();
 663
 664         if (machine_is_igep0020()) {
 665                 omap_display_init(&igep2_dss_data);
 666                 igep2_display_init();
 667                 igep2_init_smsc911x();
 668                 usbhs_init(&igep2_usbhs_bdata);
 669         } else {
 670                 usbhs_init(&igep3_usbhs_bdata);
 671         }
 672 }
 673
 674 MACHINE_START(IGEP0020, "IGEP v2 board")
 675         .boot_params    = 0x80000100,
 676         .reserve        = omap_reserve,
 677         .map_io         = omap3_map_io,
 678         .init_early     = igep_init_early,
 679         .init_irq       = omap3_init_irq,
 680         .init_machine   = igep_init,
 681         .timer          = &omap3_timer,
 682 MACHINE_END
 683
 684 MACHINE_START(IGEP0030, "IGEP OMAP3 module")
 685         .boot_params    = 0x80000100,
 686         .reserve        = omap_reserve,
 687         .map_io         = omap3_map_io,
 688         .init_early     = igep_init_early,
 689         .init_irq       = omap3_init_irq,
 690         .init_machine   = igep_init,
 691         .timer          = &omap3_timer,
 692 MACHINE_END