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 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 229 static struct regulator_init_data igep_vmmc1 = {
 230         .constraints = {
 231                 .min_uV                 = 1850000,
 232                 .max_uV                 = 3150000,
 233                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 234                                         | REGULATOR_MODE_STANDBY,
 235                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 236                                         | REGULATOR_CHANGE_MODE
 237                                         | REGULATOR_CHANGE_STATUS,
 238         },
 239         .num_consumer_supplies  = 1,
 240         .consumer_supplies      = &igep_vmmc1_supply,
 241 };
 242
 243 static struct regulator_consumer_supply igep_vio_supply =
 244         REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1");
 245
 246 static struct regulator_init_data igep_vio = {
 247         .constraints = {
 248                 .min_uV                 = 1800000,
 249                 .max_uV                 = 1800000,
 250                 .apply_uV               = 1,
 251                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 252                                         | REGULATOR_MODE_STANDBY,
 253                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 254                                         | REGULATOR_CHANGE_MODE
 255                                         | REGULATOR_CHANGE_STATUS,
 256         },
 257         .num_consumer_supplies  = 1,
 258         .consumer_supplies      = &igep_vio_supply,
 259 };
 260
 261 static struct regulator_consumer_supply igep_vmmc2_supply =
 262         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1");
 263
 264 static struct regulator_init_data igep_vmmc2 = {
 265         .constraints            = {
 266                 .valid_modes_mask       = REGULATOR_MODE_NORMAL,
 267                 .always_on              = 1,
 268         },
 269         .num_consumer_supplies  = 1,
 270         .consumer_supplies      = &igep_vmmc2_supply,
 271 };
 272
 273 static struct fixed_voltage_config igep_vwlan = {
 274         .supply_name            = "vwlan",
 275         .microvolts             = 3300000,
 276         .gpio                   = -EINVAL,
 277         .enabled_at_boot        = 1,
 278         .init_data              = &igep_vmmc2,
 279 };
 280
 281 static struct platform_device igep_vwlan_device = {
 282         .name           = "reg-fixed-voltage",
 283         .id             = 0,
 284         .dev = {
 285                 .platform_data  = &igep_vwlan,
 286         },
 287 };
 288
 289 static struct omap2_hsmmc_info mmc[] = {
 290         {
 291                 .mmc            = 1,
 292                 .caps           = MMC_CAP_4_BIT_DATA,
 293                 .gpio_cd        = -EINVAL,
 294                 .gpio_wp        = -EINVAL,
 295         },
 296 #if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
 297         {
 298                 .mmc            = 2,
 299                 .caps           = MMC_CAP_4_BIT_DATA,
 300                 .gpio_cd        = -EINVAL,
 301                 .gpio_wp        = -EINVAL,
 302         },
 303 #endif
 304         {}      /* Terminator */
 305 };
 306
 307 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
 308 #include <linux/leds.h>
 309
 310 static struct gpio_led igep_gpio_leds[] = {
 311         [0] = {
 312                 .name                   = "gpio-led:red:d0",
 313                 .default_trigger        = "default-off"
 314         },
 315         [1] = {
 316                 .name                   = "gpio-led:green:d0",
 317                 .default_trigger        = "default-off",
 318         },
 319         [2] = {
 320                 .name                   = "gpio-led:red:d1",
 321                 .default_trigger        = "default-off",
 322         },
 323         [3] = {
 324                 .name                   = "gpio-led:green:d1",
 325                 .default_trigger        = "heartbeat",
 326                 .gpio                   = -EINVAL, /* gets replaced */
 327                 .active_low             = 1,
 328         },
 329 };
 330
 331 static struct gpio_led_platform_data igep_led_pdata = {
 332         .leds           = igep_gpio_leds,
 333         .num_leds       = ARRAY_SIZE(igep_gpio_leds),
 334 };
 335
 336 static struct platform_device igep_led_device = {
 337          .name   = "leds-gpio",
 338          .id     = -1,
 339          .dev    = {
 340                  .platform_data  =  &igep_led_pdata,
 341         },
 342 };
 343
 344 static void __init igep_leds_init(void)
 345 {
 346         if (machine_is_igep0020()) {
 347                 igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
 348                 igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
 349                 igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
 350         } else {
 351                 igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
 352                 igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
 353                 igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
 354         }
 355
 356         platform_device_register(&igep_led_device);
 357 }
 358
 359 #else
 360 static struct gpio igep_gpio_leds[] __initdata = {
 361         { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:red:d0"   },
 362         { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:green:d0" },
 363         { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:red:d1"   },
 364 };
 365
 366 static inline void igep_leds_init(void)
 367 {
 368         int i;
 369
 370         if (machine_is_igep0020()) {
 371                 igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
 372                 igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
 373                 igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
 374         } else {
 375                 igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
 376                 igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
 377                 igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
 378         }
 379
 380         if (gpio_request_array(igep_gpio_leds, ARRAY_SIZE(igep_gpio_leds))) {
 381                 pr_warning("IGEP v2: Could not obtain leds gpios\n");
 382                 return;
 383         }
 384
 385         for (i = 0; i < ARRAY_SIZE(igep_gpio_leds); i++)
 386                 gpio_export(igep_gpio_leds[i].gpio, 0);
 387 }
 388 #endif
 389
 390 static struct gpio igep2_twl_gpios[] = {
 391         { -EINVAL, GPIOF_IN,            "GPIO_EHCI_NOC"  },
 392         { -EINVAL, GPIOF_OUT_INIT_LOW,  "GPIO_USBH_CPEN" },
 393 };
 394
 395 static int igep_twl_gpio_setup(struct device *dev,
 396                 unsigned gpio, unsigned ngpio)
 397 {
 398         int ret;
 399
 400         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
 401         mmc[0].gpio_cd = gpio + 0;
 402         omap2_hsmmc_init(mmc);
 403
 404         /* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
 405 #if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
 406         ret = gpio_request_one(gpio + TWL4030_GPIO_MAX + 1, GPIOF_OUT_INIT_HIGH,
 407                                "gpio-led:green:d1");
 408         if (ret == 0)
 409                 gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
 410         else
 411                 pr_warning("IGEP: Could not obtain gpio GPIO_LED1_GREEN\n");
 412 #else
 413         igep_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
 414 #endif
 415
 416         if (machine_is_igep0030())
 417                 return 0;
 418
 419         /*
 420          * REVISIT: need ehci-omap hooks for external VBUS
 421          * power switch and overcurrent detect
 422          */
 423         igep2_twl_gpios[0].gpio = gpio + 1;
 424
 425         /* TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN (out, active low) */
 426         igep2_twl_gpios[1].gpio = gpio + TWL4030_GPIO_MAX;
 427
 428         ret = gpio_request_array(igep2_twl_gpios, ARRAY_SIZE(igep2_twl_gpios));
 429         if (ret < 0)
 430                 pr_err("IGEP2: Could not obtain gpio for USBH_CPEN");
 431
 432         return 0;
 433 };
 434
 435 static struct twl4030_gpio_platform_data igep_twl4030_gpio_pdata = {
 436         .gpio_base      = OMAP_MAX_GPIO_LINES,
 437         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 438         .irq_end        = TWL4030_GPIO_IRQ_END,
 439         .use_leds       = true,
 440         .setup          = igep_twl_gpio_setup,
 441 };
 442
 443 static struct twl4030_usb_data igep_usb_data = {
 444         .usb_mode       = T2_USB_MODE_ULPI,
 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_generic_dpi_data dvi_panel = {
 460         .name                   = "generic",
 461         .platform_enable        = igep2_enable_dvi,
 462         .platform_disable       = igep2_disable_dvi,
 463 };
 464
 465 static struct omap_dss_device igep2_dvi_device = {
 466         .type                   = OMAP_DISPLAY_TYPE_DPI,
 467         .name                   = "dvi",
 468         .driver_name            = "generic_dpi_panel",
 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 struct regulator_consumer_supply igep2_vpll2_supplies[] = {
 484         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
 485         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
 486 };
 487
 488 static struct regulator_init_data igep2_vpll2 = {
 489         .constraints = {
 490                 .name                   = "VDVI",
 491                 .min_uV                 = 1800000,
 492                 .max_uV                 = 1800000,
 493                 .apply_uV               = true,
 494                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 495                                         | REGULATOR_MODE_STANDBY,
 496                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 497                                         | REGULATOR_CHANGE_STATUS,
 498         },
 499         .num_consumer_supplies  = ARRAY_SIZE(igep2_vpll2_supplies),
 500         .consumer_supplies      = igep2_vpll2_supplies,
 501 };
 502
 503 static void __init igep2_display_init(void)
 504 {
 505         int err = gpio_request_one(IGEP2_GPIO_DVI_PUP, GPIOF_OUT_INIT_HIGH,
 506                                    "GPIO_DVI_PUP");
 507         if (err)
 508                 pr_err("IGEP v2: Could not obtain gpio GPIO_DVI_PUP\n");
 509 }
 510
 511 static struct platform_device *igep_devices[] __initdata = {
 512         &igep_vwlan_device,
 513 };
 514
 515 static void __init igep_init_early(void)
 516 {
 517         omap2_init_common_infrastructure();
 518         omap2_init_common_devices(m65kxxxxam_sdrc_params,
 519                                   m65kxxxxam_sdrc_params);
 520 }
 521
 522 static struct twl4030_codec_audio_data igep2_audio_data;
 523
 524 static struct twl4030_codec_data igep2_codec_data = {
 525         .audio_mclk = 26000000,
 526         .audio = &igep2_audio_data,
 527 };
 528
 529 static int igep2_keymap[] = {
 530         KEY(0, 0, KEY_LEFT),
 531         KEY(0, 1, KEY_RIGHT),
 532         KEY(0, 2, KEY_A),
 533         KEY(0, 3, KEY_B),
 534         KEY(1, 0, KEY_DOWN),
 535         KEY(1, 1, KEY_UP),
 536         KEY(1, 2, KEY_E),
 537         KEY(1, 3, KEY_F),
 538         KEY(2, 0, KEY_ENTER),
 539         KEY(2, 1, KEY_I),
 540         KEY(2, 2, KEY_J),
 541         KEY(2, 3, KEY_K),
 542         KEY(3, 0, KEY_M),
 543         KEY(3, 1, KEY_N),
 544         KEY(3, 2, KEY_O),
 545         KEY(3, 3, KEY_P)
 546 };
 547
 548 static struct matrix_keymap_data igep2_keymap_data = {
 549         .keymap                 = igep2_keymap,
 550         .keymap_size            = ARRAY_SIZE(igep2_keymap),
 551 };
 552
 553 static struct twl4030_keypad_data igep2_keypad_pdata = {
 554         .keymap_data    = &igep2_keymap_data,
 555         .rows           = 4,
 556         .cols           = 4,
 557         .rep            = 1,
 558 };
 559
 560 static struct twl4030_platform_data igep_twldata = {
 561         .irq_base       = TWL4030_IRQ_BASE,
 562         .irq_end        = TWL4030_IRQ_END,
 563
 564         /* platform_data for children goes here */
 565         .usb            = &igep_usb_data,
 566         .gpio           = &igep_twl4030_gpio_pdata,
 567         .vmmc1          = &igep_vmmc1,
 568         .vio            = &igep_vio,
 569 };
 570
 571 static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
 572         {
 573                 I2C_BOARD_INFO("eeprom", 0x50),
 574         },
 575 };
 576
 577 static void __init igep_i2c_init(void)
 578 {
 579         int ret;
 580
 581         if (machine_is_igep0020()) {
 582                 /*
 583                  * Bus 3 is attached to the DVI port where devices like the
 584                  * pico DLP projector don't work reliably with 400kHz
 585                  */
 586                 ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
 587                                             ARRAY_SIZE(igep2_i2c3_boardinfo));
 588                 if (ret)
 589                         pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
 590
 591                 igep_twldata.codec      = &igep2_codec_data;
 592                 igep_twldata.keypad     = &igep2_keypad_pdata;
 593                 igep_twldata.vpll2      = &igep2_vpll2;
 594         }
 595
 596         omap3_pmic_init("twl4030", &igep_twldata);
 597 }
 598
 599 static const struct usbhs_omap_board_data igep2_usbhs_bdata __initconst = {
 600         .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
 601         .port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
 602         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 603
 604         .phy_reset = true,
 605         .reset_gpio_port[0] = IGEP2_GPIO_USBH_NRESET,
 606         .reset_gpio_port[1] = -EINVAL,
 607         .reset_gpio_port[2] = -EINVAL,
 608 };
 609
 610 static const struct usbhs_omap_board_data igep3_usbhs_bdata __initconst = {
 611         .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
 612         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
 613         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 614
 615         .phy_reset = true,
 616         .reset_gpio_port[0] = -EINVAL,
 617         .reset_gpio_port[1] = IGEP3_GPIO_USBH_NRESET,
 618         .reset_gpio_port[2] = -EINVAL,
 619 };
 620
 621 #ifdef CONFIG_OMAP_MUX
 622 static struct omap_board_mux board_mux[] __initdata = {
 623         { .reg_offset = OMAP_MUX_TERMINATOR },
 624 };
 625 #endif
 626
 627 #if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
 628 static struct gpio igep_wlan_bt_gpios[] __initdata = {
 629         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NPD"    },
 630         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NRESET" },
 631         { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_BT_NRESET"   },
 632 };
 633
 634 static void __init igep_wlan_bt_init(void)
 635 {
 636         int err;
 637
 638         /* GPIO's for WLAN-BT combo depends on hardware revision */
 639         if (hwrev == IGEP2_BOARD_HWREV_B) {
 640                 igep_wlan_bt_gpios[0].gpio = IGEP2_RB_GPIO_WIFI_NPD;
 641                 igep_wlan_bt_gpios[1].gpio = IGEP2_RB_GPIO_WIFI_NRESET;
 642                 igep_wlan_bt_gpios[2].gpio = IGEP2_RB_GPIO_BT_NRESET;
 643         } else if (hwrev == IGEP2_BOARD_HWREV_C || machine_is_igep0030()) {
 644                 igep_wlan_bt_gpios[0].gpio = IGEP2_RC_GPIO_WIFI_NPD;
 645                 igep_wlan_bt_gpios[1].gpio = IGEP2_RC_GPIO_WIFI_NRESET;
 646                 igep_wlan_bt_gpios[2].gpio = IGEP2_RC_GPIO_BT_NRESET;
 647         } else
 648                 return;
 649
 650         err = gpio_request_array(igep_wlan_bt_gpios,
 651                                  ARRAY_SIZE(igep_wlan_bt_gpios));
 652         if (err) {
 653                 pr_warning("IGEP2: Could not obtain WIFI/BT gpios\n");
 654                 return;
 655         }
 656
 657         gpio_export(igep_wlan_bt_gpios[0].gpio, 0);
 658         gpio_export(igep_wlan_bt_gpios[1].gpio, 0);
 659         gpio_export(igep_wlan_bt_gpios[2].gpio, 0);
 660
 661         gpio_set_value(igep_wlan_bt_gpios[1].gpio, 0);
 662         udelay(10);
 663         gpio_set_value(igep_wlan_bt_gpios[1].gpio, 1);
 664
 665 }
 666 #else
 667 static inline void __init igep_wlan_bt_init(void) { }
 668 #endif
 669
 670 static void __init igep_init(void)
 671 {
 672         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 673
 674         /* Get IGEP2 hardware revision */
 675         igep2_get_revision();
 676         /* Register I2C busses and drivers */
 677         igep_i2c_init();
 678         platform_add_devices(igep_devices, ARRAY_SIZE(igep_devices));
 679         omap_serial_init();
 680         usb_musb_init(NULL);
 681
 682         igep_flash_init();
 683         igep_leds_init();
 684
 685         /*
 686          * WLAN-BT combo module from MuRata which has a Marvell WLAN
 687          * (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
 688          */
 689         igep_wlan_bt_init();
 690
 691         if (machine_is_igep0020()) {
 692                 omap_display_init(&igep2_dss_data);
 693                 igep2_display_init();
 694                 igep2_init_smsc911x();
 695                 usbhs_init(&igep2_usbhs_bdata);
 696         } else {
 697                 usbhs_init(&igep3_usbhs_bdata);
 698         }
 699 }
 700
 701 MACHINE_START(IGEP0020, "IGEP v2 board")
 702         .boot_params    = 0x80000100,
 703         .reserve        = omap_reserve,
 704         .map_io         = omap3_map_io,
 705         .init_early     = igep_init_early,
 706         .init_irq       = omap_init_irq,
 707         .init_machine   = igep_init,
 708         .timer          = &omap_timer,
 709 MACHINE_END
 710
 711 MACHINE_START(IGEP0030, "IGEP OMAP3 module")
 712         .boot_params    = 0x80000100,
 713         .reserve        = omap_reserve,
 714         .map_io         = omap3_map_io,
 715         .init_early     = igep_init_early,
 716         .init_irq       = omap_init_irq,
 717         .init_machine   = igep_init,
 718         .timer          = &omap_timer,
 719 MACHINE_END