irq: Remove smp_affinity_list when unregister irq proc
[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
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", "omap_hsmmc.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", "omap_hsmmc.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", "omap_hsmmc.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 regulator_consumer_supply igep2_vpll2_supplies[] = {
489         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
490         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
491 };
492
493 static struct regulator_init_data igep2_vpll2 = {
494         .constraints = {
495                 .name                   = "VDVI",
496                 .min_uV                 = 1800000,
497                 .max_uV                 = 1800000,
498                 .apply_uV               = true,
499                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
500                                         | REGULATOR_MODE_STANDBY,
501                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
502                                         | REGULATOR_CHANGE_STATUS,
503         },
504         .num_consumer_supplies  = ARRAY_SIZE(igep2_vpll2_supplies),
505         .consumer_supplies      = igep2_vpll2_supplies,
506 };
507
508 static void __init igep2_display_init(void)
509 {
510         if (gpio_request(IGEP2_GPIO_DVI_PUP, "GPIO_DVI_PUP") &&
511             gpio_direction_output(IGEP2_GPIO_DVI_PUP, 1))
512                 pr_err("IGEP v2: Could not obtain gpio GPIO_DVI_PUP\n");
513 }
514
515 static struct platform_device *igep2_devices[] __initdata = {
516         &igep2_vwlan_device,
517 };
518
519 static void __init igep2_init_early(void)
520 {
521         omap2_init_common_infrastructure();
522         omap2_init_common_devices(m65kxxxxam_sdrc_params,
523                                   m65kxxxxam_sdrc_params);
524 }
525
526 static struct twl4030_codec_audio_data igep2_audio_data;
527
528 static struct twl4030_codec_data igep2_codec_data = {
529         .audio_mclk = 26000000,
530         .audio = &igep2_audio_data,
531 };
532
533 static int igep2_keymap[] = {
534         KEY(0, 0, KEY_LEFT),
535         KEY(0, 1, KEY_RIGHT),
536         KEY(0, 2, KEY_A),
537         KEY(0, 3, KEY_B),
538         KEY(1, 0, KEY_DOWN),
539         KEY(1, 1, KEY_UP),
540         KEY(1, 2, KEY_E),
541         KEY(1, 3, KEY_F),
542         KEY(2, 0, KEY_ENTER),
543         KEY(2, 1, KEY_I),
544         KEY(2, 2, KEY_J),
545         KEY(2, 3, KEY_K),
546         KEY(3, 0, KEY_M),
547         KEY(3, 1, KEY_N),
548         KEY(3, 2, KEY_O),
549         KEY(3, 3, KEY_P)
550 };
551
552 static struct matrix_keymap_data igep2_keymap_data = {
553         .keymap                 = igep2_keymap,
554         .keymap_size            = ARRAY_SIZE(igep2_keymap),
555 };
556
557 static struct twl4030_keypad_data igep2_keypad_pdata = {
558         .keymap_data    = &igep2_keymap_data,
559         .rows           = 4,
560         .cols           = 4,
561         .rep            = 1,
562 };
563
564 static struct twl4030_platform_data igep2_twldata = {
565         .irq_base       = TWL4030_IRQ_BASE,
566         .irq_end        = TWL4030_IRQ_END,
567
568         /* platform_data for children goes here */
569         .usb            = &igep2_usb_data,
570         .codec          = &igep2_codec_data,
571         .gpio           = &igep2_twl4030_gpio_pdata,
572         .keypad         = &igep2_keypad_pdata,
573         .vmmc1          = &igep2_vmmc1,
574         .vpll2          = &igep2_vpll2,
575         .vio            = &igep2_vio,
576 };
577
578 static struct i2c_board_info __initdata igep2_i2c1_boardinfo[] = {
579         {
580                 I2C_BOARD_INFO("twl4030", 0x48),
581                 .flags          = I2C_CLIENT_WAKE,
582                 .irq            = INT_34XX_SYS_NIRQ,
583                 .platform_data  = &igep2_twldata,
584         },
585 };
586
587 static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
588         {
589                 I2C_BOARD_INFO("eeprom", 0x50),
590         },
591 };
592
593 static void __init igep2_i2c_init(void)
594 {
595         int ret;
596
597         ret = omap_register_i2c_bus(1, 2600, igep2_i2c1_boardinfo,
598                 ARRAY_SIZE(igep2_i2c1_boardinfo));
599         if (ret)
600                 pr_warning("IGEP2: Could not register I2C1 bus (%d)\n", ret);
601
602         /*
603          * Bus 3 is attached to the DVI port where devices like the pico DLP
604          * projector don't work reliably with 400kHz
605          */
606         ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
607                 ARRAY_SIZE(igep2_i2c3_boardinfo));
608         if (ret)
609                 pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
610 }
611
612 static struct omap_musb_board_data musb_board_data = {
613         .interface_type         = MUSB_INTERFACE_ULPI,
614         .mode                   = MUSB_OTG,
615         .power                  = 100,
616 };
617
618 static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
619         .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
620         .port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
621         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
622
623         .phy_reset = true,
624         .reset_gpio_port[0] = IGEP2_GPIO_USBH_NRESET,
625         .reset_gpio_port[1] = -EINVAL,
626         .reset_gpio_port[2] = -EINVAL,
627 };
628
629 #ifdef CONFIG_OMAP_MUX
630 static struct omap_board_mux board_mux[] __initdata = {
631         { .reg_offset = OMAP_MUX_TERMINATOR },
632 };
633 #endif
634
635 #if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
636
637 static void __init igep2_wlan_bt_init(void)
638 {
639         unsigned npd, wreset, btreset;
640
641         /* GPIO's for WLAN-BT combo depends on hardware revision */
642         if (hwrev == IGEP2_BOARD_HWREV_B) {
643                 npd = IGEP2_RB_GPIO_WIFI_NPD;
644                 wreset = IGEP2_RB_GPIO_WIFI_NRESET;
645                 btreset = IGEP2_RB_GPIO_BT_NRESET;
646         } else if (hwrev == IGEP2_BOARD_HWREV_C) {
647                 npd = IGEP2_RC_GPIO_WIFI_NPD;
648                 wreset = IGEP2_RC_GPIO_WIFI_NRESET;
649                 btreset = IGEP2_RC_GPIO_BT_NRESET;
650         } else
651                 return;
652
653         /* Set GPIO's for  WLAN-BT combo module */
654         if ((gpio_request(npd, "GPIO_WIFI_NPD") == 0) &&
655             (gpio_direction_output(npd, 1) == 0)) {
656                 gpio_export(npd, 0);
657         } else
658                 pr_warning("IGEP2: Could not obtain gpio GPIO_WIFI_NPD\n");
659
660         if ((gpio_request(wreset, "GPIO_WIFI_NRESET") == 0) &&
661             (gpio_direction_output(wreset, 1) == 0)) {
662                 gpio_export(wreset, 0);
663                 gpio_set_value(wreset, 0);
664                 udelay(10);
665                 gpio_set_value(wreset, 1);
666         } else
667                 pr_warning("IGEP2: Could not obtain gpio GPIO_WIFI_NRESET\n");
668
669         if ((gpio_request(btreset, "GPIO_BT_NRESET") == 0) &&
670             (gpio_direction_output(btreset, 1) == 0)) {
671                 gpio_export(btreset, 0);
672         } else
673                 pr_warning("IGEP2: Could not obtain gpio GPIO_BT_NRESET\n");
674 }
675 #else
676 static inline void __init igep2_wlan_bt_init(void) { }
677 #endif
678
679 static void __init igep2_init(void)
680 {
681         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
682
683         /* Get IGEP2 hardware revision */
684         igep2_get_revision();
685         /* Register I2C busses and drivers */
686         igep2_i2c_init();
687         platform_add_devices(igep2_devices, ARRAY_SIZE(igep2_devices));
688         omap_display_init(&igep2_dss_data);
689         omap_serial_init();
690         usb_musb_init(&musb_board_data);
691         usbhs_init(&usbhs_bdata);
692
693         igep2_flash_init();
694         igep2_leds_init();
695         igep2_display_init();
696         igep2_init_smsc911x();
697
698         /*
699          * WLAN-BT combo module from MuRata which has a Marvell WLAN
700          * (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
701          */
702         igep2_wlan_bt_init();
703
704 }
705
706 MACHINE_START(IGEP0020, "IGEP v2 board")
707         .boot_params    = 0x80000100,
708         .reserve        = omap_reserve,
709         .map_io         = omap3_map_io,
710         .init_early     = igep2_init_early,
711         .init_irq       = omap_init_irq,
712         .init_machine   = igep2_init,
713         .timer          = &omap_timer,
714 MACHINE_END