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