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