Merge branches 'core-fixes-for-linus' and 'irq-fixes-for-linus' of git://git.kernel...
[linux-2.6.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 <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