Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/async_tx
[linux-2.6.git] / arch / arm / mach-omap2 / board-omap3pandora.c
1 /*
2  * board-omap3pandora.c (Pandora Handheld Console)
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * version 2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
16  * 02110-1301 USA
17  *
18  */
19
20 #include <linux/init.h>
21 #include <linux/kernel.h>
22 #include <linux/platform_device.h>
23
24 #include <linux/spi/spi.h>
25 #include <linux/spi/ads7846.h>
26 #include <linux/regulator/machine.h>
27 #include <linux/i2c/twl.h>
28 #include <linux/wl12xx.h>
29 #include <linux/mtd/partitions.h>
30 #include <linux/mtd/nand.h>
31 #include <linux/leds.h>
32 #include <linux/input.h>
33 #include <linux/input/matrix_keypad.h>
34 #include <linux/gpio_keys.h>
35 #include <linux/mmc/host.h>
36 #include <linux/mmc/card.h>
37 #include <linux/regulator/fixed.h>
38
39 #include <asm/mach-types.h>
40 #include <asm/mach/arch.h>
41 #include <asm/mach/map.h>
42
43 #include <plat/board.h>
44 #include <plat/common.h>
45 #include <mach/gpio.h>
46 #include <mach/hardware.h>
47 #include <plat/mcspi.h>
48 #include <plat/usb.h>
49 #include <plat/display.h>
50 #include <plat/nand.h>
51
52 #include "mux.h"
53 #include "sdram-micron-mt46h32m32lf-6.h"
54 #include "hsmmc.h"
55
56 #define PANDORA_WIFI_IRQ_GPIO           21
57 #define PANDORA_WIFI_NRESET_GPIO        23
58 #define OMAP3_PANDORA_TS_GPIO           94
59
60 #define NAND_BLOCK_SIZE                 SZ_128K
61
62 static struct mtd_partition omap3pandora_nand_partitions[] = {
63         {
64                 .name           = "xloader",
65                 .offset         = 0,
66                 .size           = 4 * NAND_BLOCK_SIZE,
67                 .mask_flags     = MTD_WRITEABLE
68         }, {
69                 .name           = "uboot",
70                 .offset         = MTDPART_OFS_APPEND,
71                 .size           = 15 * NAND_BLOCK_SIZE,
72         }, {
73                 .name           = "uboot-env",
74                 .offset         = MTDPART_OFS_APPEND,
75                 .size           = 1 * NAND_BLOCK_SIZE,
76         }, {
77                 .name           = "boot",
78                 .offset         = MTDPART_OFS_APPEND,
79                 .size           = 80 * NAND_BLOCK_SIZE,
80         }, {
81                 .name           = "rootfs",
82                 .offset         = MTDPART_OFS_APPEND,
83                 .size           = MTDPART_SIZ_FULL,
84         },
85 };
86
87 static struct omap_nand_platform_data pandora_nand_data = {
88         .cs             = 0,
89         .devsize        = 1,    /* '0' for 8-bit, '1' for 16-bit device */
90         .parts          = omap3pandora_nand_partitions,
91         .nr_parts       = ARRAY_SIZE(omap3pandora_nand_partitions),
92 };
93
94 static struct gpio_led pandora_gpio_leds[] = {
95         {
96                 .name                   = "pandora::sd1",
97                 .default_trigger        = "mmc0",
98                 .gpio                   = 128,
99         }, {
100                 .name                   = "pandora::sd2",
101                 .default_trigger        = "mmc1",
102                 .gpio                   = 129,
103         }, {
104                 .name                   = "pandora::bluetooth",
105                 .gpio                   = 158,
106         }, {
107                 .name                   = "pandora::wifi",
108                 .gpio                   = 159,
109         },
110 };
111
112 static struct gpio_led_platform_data pandora_gpio_led_data = {
113         .leds           = pandora_gpio_leds,
114         .num_leds       = ARRAY_SIZE(pandora_gpio_leds),
115 };
116
117 static struct platform_device pandora_leds_gpio = {
118         .name   = "leds-gpio",
119         .id     = -1,
120         .dev    = {
121                 .platform_data  = &pandora_gpio_led_data,
122         },
123 };
124
125 #define GPIO_BUTTON(gpio_num, ev_type, ev_code, act_low, descr) \
126 {                                                               \
127         .gpio           = gpio_num,                             \
128         .type           = ev_type,                              \
129         .code           = ev_code,                              \
130         .active_low     = act_low,                              \
131         .debounce_interval = 4,                                 \
132         .desc           = "btn " descr,                         \
133 }
134
135 #define GPIO_BUTTON_LOW(gpio_num, event_code, description)      \
136         GPIO_BUTTON(gpio_num, EV_KEY, event_code, 1, description)
137
138 static struct gpio_keys_button pandora_gpio_keys[] = {
139         GPIO_BUTTON_LOW(110,    KEY_UP,         "up"),
140         GPIO_BUTTON_LOW(103,    KEY_DOWN,       "down"),
141         GPIO_BUTTON_LOW(96,     KEY_LEFT,       "left"),
142         GPIO_BUTTON_LOW(98,     KEY_RIGHT,      "right"),
143         GPIO_BUTTON_LOW(109,    KEY_PAGEUP,     "game 1"),
144         GPIO_BUTTON_LOW(111,    KEY_END,        "game 2"),
145         GPIO_BUTTON_LOW(106,    KEY_PAGEDOWN,   "game 3"),
146         GPIO_BUTTON_LOW(101,    KEY_HOME,       "game 4"),
147         GPIO_BUTTON_LOW(102,    KEY_RIGHTSHIFT, "l"),
148         GPIO_BUTTON_LOW(97,     KEY_KPPLUS,     "l2"),
149         GPIO_BUTTON_LOW(105,    KEY_RIGHTCTRL,  "r"),
150         GPIO_BUTTON_LOW(107,    KEY_KPMINUS,    "r2"),
151         GPIO_BUTTON_LOW(104,    KEY_LEFTCTRL,   "ctrl"),
152         GPIO_BUTTON_LOW(99,     KEY_MENU,       "menu"),
153         GPIO_BUTTON_LOW(176,    KEY_COFFEE,     "hold"),
154         GPIO_BUTTON(100, EV_KEY, KEY_LEFTALT, 0, "alt"),
155         GPIO_BUTTON(108, EV_SW, SW_LID, 1, "lid"),
156 };
157
158 static struct gpio_keys_platform_data pandora_gpio_key_info = {
159         .buttons        = pandora_gpio_keys,
160         .nbuttons       = ARRAY_SIZE(pandora_gpio_keys),
161 };
162
163 static struct platform_device pandora_keys_gpio = {
164         .name   = "gpio-keys",
165         .id     = -1,
166         .dev    = {
167                 .platform_data  = &pandora_gpio_key_info,
168         },
169 };
170
171 static const uint32_t board_keymap[] = {
172         /* row, col, code */
173         KEY(0, 0, KEY_9),
174         KEY(0, 1, KEY_8),
175         KEY(0, 2, KEY_I),
176         KEY(0, 3, KEY_J),
177         KEY(0, 4, KEY_N),
178         KEY(0, 5, KEY_M),
179         KEY(1, 0, KEY_0),
180         KEY(1, 1, KEY_7),
181         KEY(1, 2, KEY_U),
182         KEY(1, 3, KEY_H),
183         KEY(1, 4, KEY_B),
184         KEY(1, 5, KEY_SPACE),
185         KEY(2, 0, KEY_BACKSPACE),
186         KEY(2, 1, KEY_6),
187         KEY(2, 2, KEY_Y),
188         KEY(2, 3, KEY_G),
189         KEY(2, 4, KEY_V),
190         KEY(2, 5, KEY_FN),
191         KEY(3, 0, KEY_O),
192         KEY(3, 1, KEY_5),
193         KEY(3, 2, KEY_T),
194         KEY(3, 3, KEY_F),
195         KEY(3, 4, KEY_C),
196         KEY(4, 0, KEY_P),
197         KEY(4, 1, KEY_4),
198         KEY(4, 2, KEY_R),
199         KEY(4, 3, KEY_D),
200         KEY(4, 4, KEY_X),
201         KEY(5, 0, KEY_K),
202         KEY(5, 1, KEY_3),
203         KEY(5, 2, KEY_E),
204         KEY(5, 3, KEY_S),
205         KEY(5, 4, KEY_Z),
206         KEY(6, 0, KEY_L),
207         KEY(6, 1, KEY_2),
208         KEY(6, 2, KEY_W),
209         KEY(6, 3, KEY_A),
210         KEY(6, 4, KEY_DOT),
211         KEY(7, 0, KEY_ENTER),
212         KEY(7, 1, KEY_1),
213         KEY(7, 2, KEY_Q),
214         KEY(7, 3, KEY_LEFTSHIFT),
215         KEY(7, 4, KEY_COMMA),
216 };
217
218 static struct matrix_keymap_data board_map_data = {
219         .keymap                 = board_keymap,
220         .keymap_size            = ARRAY_SIZE(board_keymap),
221 };
222
223 static struct twl4030_keypad_data pandora_kp_data = {
224         .keymap_data    = &board_map_data,
225         .rows           = 8,
226         .cols           = 6,
227         .rep            = 1,
228 };
229
230 static struct omap_dss_device pandora_lcd_device = {
231         .name                   = "lcd",
232         .driver_name            = "tpo_td043mtea1_panel",
233         .type                   = OMAP_DISPLAY_TYPE_DPI,
234         .phy.dpi.data_lines     = 24,
235         .reset_gpio             = 157,
236 };
237
238 static struct omap_dss_device pandora_tv_device = {
239         .name                   = "tv",
240         .driver_name            = "venc",
241         .type                   = OMAP_DISPLAY_TYPE_VENC,
242         .phy.venc.type          = OMAP_DSS_VENC_TYPE_SVIDEO,
243 };
244
245 static struct omap_dss_device *pandora_dss_devices[] = {
246         &pandora_lcd_device,
247         &pandora_tv_device,
248 };
249
250 static struct omap_dss_board_info pandora_dss_data = {
251         .num_devices    = ARRAY_SIZE(pandora_dss_devices),
252         .devices        = pandora_dss_devices,
253         .default_device = &pandora_lcd_device,
254 };
255
256 static struct platform_device pandora_dss_device = {
257         .name           = "omapdss",
258         .id             = -1,
259         .dev            = {
260                 .platform_data = &pandora_dss_data,
261         },
262 };
263
264 static void pandora_wl1251_init_card(struct mmc_card *card)
265 {
266         /*
267          * We have TI wl1251 attached to MMC3. Pass this information to
268          * SDIO core because it can't be probed by normal methods.
269          */
270         card->quirks |= MMC_QUIRK_NONSTD_SDIO;
271         card->cccr.wide_bus = 1;
272         card->cis.vendor = 0x104c;
273         card->cis.device = 0x9066;
274         card->cis.blksize = 512;
275         card->cis.max_dtr = 20000000;
276 }
277
278 static struct omap2_hsmmc_info omap3pandora_mmc[] = {
279         {
280                 .mmc            = 1,
281                 .caps           = MMC_CAP_4_BIT_DATA,
282                 .gpio_cd        = -EINVAL,
283                 .gpio_wp        = 126,
284                 .ext_clock      = 0,
285         },
286         {
287                 .mmc            = 2,
288                 .caps           = MMC_CAP_4_BIT_DATA,
289                 .gpio_cd        = -EINVAL,
290                 .gpio_wp        = 127,
291                 .ext_clock      = 1,
292                 .transceiver    = true,
293         },
294         {
295                 .mmc            = 3,
296                 .caps           = MMC_CAP_4_BIT_DATA,
297                 .gpio_cd        = -EINVAL,
298                 .gpio_wp        = -EINVAL,
299                 .init_card      = pandora_wl1251_init_card,
300         },
301         {}      /* Terminator */
302 };
303
304 static int omap3pandora_twl_gpio_setup(struct device *dev,
305                 unsigned gpio, unsigned ngpio)
306 {
307         int ret, gpio_32khz;
308
309         /* gpio + {0,1} is "mmc{0,1}_cd" (input/IRQ) */
310         omap3pandora_mmc[0].gpio_cd = gpio + 0;
311         omap3pandora_mmc[1].gpio_cd = gpio + 1;
312         omap2_hsmmc_init(omap3pandora_mmc);
313
314         /* gpio + 13 drives 32kHz buffer for wifi module */
315         gpio_32khz = gpio + 13;
316         ret = gpio_request(gpio_32khz, "wifi 32kHz");
317         if (ret < 0) {
318                 pr_err("Cannot get GPIO line %d, ret=%d\n", gpio_32khz, ret);
319                 goto fail;
320         }
321
322         ret = gpio_direction_output(gpio_32khz, 1);
323         if (ret < 0) {
324                 pr_err("Cannot set GPIO line %d, ret=%d\n", gpio_32khz, ret);
325                 goto fail_direction;
326         }
327
328         return 0;
329
330 fail_direction:
331         gpio_free(gpio_32khz);
332 fail:
333         return -ENODEV;
334 }
335
336 static struct twl4030_gpio_platform_data omap3pandora_gpio_data = {
337         .gpio_base      = OMAP_MAX_GPIO_LINES,
338         .irq_base       = TWL4030_GPIO_IRQ_BASE,
339         .irq_end        = TWL4030_GPIO_IRQ_END,
340         .setup          = omap3pandora_twl_gpio_setup,
341 };
342
343 static struct regulator_consumer_supply pandora_vmmc1_supply =
344         REGULATOR_SUPPLY("vmmc", "mmci-omap-hs.0");
345
346 static struct regulator_consumer_supply pandora_vmmc2_supply =
347         REGULATOR_SUPPLY("vmmc", "mmci-omap-hs.1");
348
349 static struct regulator_consumer_supply pandora_vmmc3_supply =
350         REGULATOR_SUPPLY("vmmc", "mmci-omap-hs.2");
351
352 static struct regulator_consumer_supply pandora_vdda_dac_supply =
353         REGULATOR_SUPPLY("vdda_dac", "omapdss");
354
355 static struct regulator_consumer_supply pandora_vdds_supplies[] = {
356         REGULATOR_SUPPLY("vdds_sdi", "omapdss"),
357         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
358 };
359
360 static struct regulator_consumer_supply pandora_vcc_lcd_supply =
361         REGULATOR_SUPPLY("vcc", "display0");
362
363 static struct regulator_consumer_supply pandora_usb_phy_supply =
364         REGULATOR_SUPPLY("hsusb0", "ehci-omap.0");
365
366 /* ads7846 on SPI and 2 nub controllers on I2C */
367 static struct regulator_consumer_supply pandora_vaux4_supplies[] = {
368         REGULATOR_SUPPLY("vcc", "spi1.0"),
369         REGULATOR_SUPPLY("vcc", "3-0066"),
370         REGULATOR_SUPPLY("vcc", "3-0067"),
371 };
372
373 static struct regulator_consumer_supply pandora_adac_supply =
374         REGULATOR_SUPPLY("vcc", "soc-audio");
375
376 /* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
377 static struct regulator_init_data pandora_vmmc1 = {
378         .constraints = {
379                 .min_uV                 = 1850000,
380                 .max_uV                 = 3150000,
381                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
382                                         | REGULATOR_MODE_STANDBY,
383                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
384                                         | REGULATOR_CHANGE_MODE
385                                         | REGULATOR_CHANGE_STATUS,
386         },
387         .num_consumer_supplies  = 1,
388         .consumer_supplies      = &pandora_vmmc1_supply,
389 };
390
391 /* VMMC2 for MMC2 pins CMD, CLK, DAT0..DAT3 (max 100 mA) */
392 static struct regulator_init_data pandora_vmmc2 = {
393         .constraints = {
394                 .min_uV                 = 1850000,
395                 .max_uV                 = 3150000,
396                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
397                                         | REGULATOR_MODE_STANDBY,
398                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
399                                         | REGULATOR_CHANGE_MODE
400                                         | REGULATOR_CHANGE_STATUS,
401         },
402         .num_consumer_supplies  = 1,
403         .consumer_supplies      = &pandora_vmmc2_supply,
404 };
405
406 /* VDAC for DSS driving S-Video */
407 static struct regulator_init_data pandora_vdac = {
408         .constraints = {
409                 .min_uV                 = 1800000,
410                 .max_uV                 = 1800000,
411                 .apply_uV               = true,
412                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
413                                         | REGULATOR_MODE_STANDBY,
414                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
415                                         | REGULATOR_CHANGE_STATUS,
416         },
417         .num_consumer_supplies  = 1,
418         .consumer_supplies      = &pandora_vdda_dac_supply,
419 };
420
421 /* VPLL2 for digital video outputs */
422 static struct regulator_init_data pandora_vpll2 = {
423         .constraints = {
424                 .min_uV                 = 1800000,
425                 .max_uV                 = 1800000,
426                 .apply_uV               = true,
427                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
428                                         | REGULATOR_MODE_STANDBY,
429                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
430                                         | REGULATOR_CHANGE_STATUS,
431         },
432         .num_consumer_supplies  = ARRAY_SIZE(pandora_vdds_supplies),
433         .consumer_supplies      = pandora_vdds_supplies,
434 };
435
436 /* VAUX1 for LCD */
437 static struct regulator_init_data pandora_vaux1 = {
438         .constraints = {
439                 .min_uV                 = 3000000,
440                 .max_uV                 = 3000000,
441                 .apply_uV               = true,
442                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
443                                         | REGULATOR_MODE_STANDBY,
444                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
445                                         | REGULATOR_CHANGE_STATUS,
446         },
447         .num_consumer_supplies  = 1,
448         .consumer_supplies      = &pandora_vcc_lcd_supply,
449 };
450
451 /* VAUX2 for USB host PHY */
452 static struct regulator_init_data pandora_vaux2 = {
453         .constraints = {
454                 .min_uV                 = 1800000,
455                 .max_uV                 = 1800000,
456                 .apply_uV               = true,
457                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
458                                         | REGULATOR_MODE_STANDBY,
459                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
460                                         | REGULATOR_CHANGE_STATUS,
461         },
462         .num_consumer_supplies  = 1,
463         .consumer_supplies      = &pandora_usb_phy_supply,
464 };
465
466 /* VAUX4 for ads7846 and nubs */
467 static struct regulator_init_data pandora_vaux4 = {
468         .constraints = {
469                 .min_uV                 = 2800000,
470                 .max_uV                 = 2800000,
471                 .apply_uV               = true,
472                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
473                                         | REGULATOR_MODE_STANDBY,
474                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
475                                         | REGULATOR_CHANGE_STATUS,
476         },
477         .num_consumer_supplies  = ARRAY_SIZE(pandora_vaux4_supplies),
478         .consumer_supplies      = pandora_vaux4_supplies,
479 };
480
481 /* VSIM for audio DAC */
482 static struct regulator_init_data pandora_vsim = {
483         .constraints = {
484                 .min_uV                 = 2800000,
485                 .max_uV                 = 2800000,
486                 .apply_uV               = true,
487                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
488                                         | REGULATOR_MODE_STANDBY,
489                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
490                                         | REGULATOR_CHANGE_STATUS,
491         },
492         .num_consumer_supplies  = 1,
493         .consumer_supplies      = &pandora_adac_supply,
494 };
495
496 /* Fixed regulator internal to Wifi module */
497 static struct regulator_init_data pandora_vmmc3 = {
498         .constraints = {
499                 .valid_ops_mask         = REGULATOR_CHANGE_STATUS,
500         },
501         .num_consumer_supplies  = 1,
502         .consumer_supplies      = &pandora_vmmc3_supply,
503 };
504
505 static struct fixed_voltage_config pandora_vwlan = {
506         .supply_name            = "vwlan",
507         .microvolts             = 1800000, /* 1.8V */
508         .gpio                   = PANDORA_WIFI_NRESET_GPIO,
509         .startup_delay          = 50000, /* 50ms */
510         .enable_high            = 1,
511         .enabled_at_boot        = 0,
512         .init_data              = &pandora_vmmc3,
513 };
514
515 static struct platform_device pandora_vwlan_device = {
516         .name           = "reg-fixed-voltage",
517         .id             = 1,
518         .dev = {
519                 .platform_data = &pandora_vwlan,
520         },
521 };
522
523 static struct twl4030_usb_data omap3pandora_usb_data = {
524         .usb_mode       = T2_USB_MODE_ULPI,
525 };
526
527 static struct twl4030_codec_audio_data omap3pandora_audio_data = {
528         .audio_mclk = 26000000,
529 };
530
531 static struct twl4030_codec_data omap3pandora_codec_data = {
532         .audio_mclk = 26000000,
533         .audio = &omap3pandora_audio_data,
534 };
535
536 static struct twl4030_bci_platform_data pandora_bci_data;
537
538 static struct twl4030_platform_data omap3pandora_twldata = {
539         .irq_base       = TWL4030_IRQ_BASE,
540         .irq_end        = TWL4030_IRQ_END,
541         .gpio           = &omap3pandora_gpio_data,
542         .usb            = &omap3pandora_usb_data,
543         .codec          = &omap3pandora_codec_data,
544         .vmmc1          = &pandora_vmmc1,
545         .vmmc2          = &pandora_vmmc2,
546         .vdac           = &pandora_vdac,
547         .vpll2          = &pandora_vpll2,
548         .vaux1          = &pandora_vaux1,
549         .vaux2          = &pandora_vaux2,
550         .vaux4          = &pandora_vaux4,
551         .vsim           = &pandora_vsim,
552         .keypad         = &pandora_kp_data,
553         .bci            = &pandora_bci_data,
554 };
555
556 static struct i2c_board_info __initdata omap3pandora_i2c_boardinfo[] = {
557         {
558                 I2C_BOARD_INFO("tps65950", 0x48),
559                 .flags = I2C_CLIENT_WAKE,
560                 .irq = INT_34XX_SYS_NIRQ,
561                 .platform_data = &omap3pandora_twldata,
562         },
563 };
564
565 static struct i2c_board_info __initdata omap3pandora_i2c3_boardinfo[] = {
566         {
567                 I2C_BOARD_INFO("bq27500", 0x55),
568                 .flags = I2C_CLIENT_WAKE,
569         },
570 };
571
572 static int __init omap3pandora_i2c_init(void)
573 {
574         omap_register_i2c_bus(1, 2600, omap3pandora_i2c_boardinfo,
575                         ARRAY_SIZE(omap3pandora_i2c_boardinfo));
576         /* i2c2 pins are not connected */
577         omap_register_i2c_bus(3, 100, omap3pandora_i2c3_boardinfo,
578                         ARRAY_SIZE(omap3pandora_i2c3_boardinfo));
579         return 0;
580 }
581
582 static void __init omap3pandora_ads7846_init(void)
583 {
584         int gpio = OMAP3_PANDORA_TS_GPIO;
585         int ret;
586
587         ret = gpio_request(gpio, "ads7846_pen_down");
588         if (ret < 0) {
589                 printk(KERN_ERR "Failed to request GPIO %d for "
590                                 "ads7846 pen down IRQ\n", gpio);
591                 return;
592         }
593
594         gpio_direction_input(gpio);
595 }
596
597 static int ads7846_get_pendown_state(void)
598 {
599         return !gpio_get_value(OMAP3_PANDORA_TS_GPIO);
600 }
601
602 static struct ads7846_platform_data ads7846_config = {
603         .x_max                  = 0x0fff,
604         .y_max                  = 0x0fff,
605         .x_plate_ohms           = 180,
606         .pressure_max           = 255,
607         .debounce_max           = 10,
608         .debounce_tol           = 3,
609         .debounce_rep           = 1,
610         .get_pendown_state      = ads7846_get_pendown_state,
611         .keep_vref_on           = 1,
612 };
613
614 static struct omap2_mcspi_device_config ads7846_mcspi_config = {
615         .turbo_mode     = 0,
616         .single_channel = 1,    /* 0: slave, 1: master */
617 };
618
619 static struct spi_board_info omap3pandora_spi_board_info[] __initdata = {
620         {
621                 .modalias               = "ads7846",
622                 .bus_num                = 1,
623                 .chip_select            = 0,
624                 .max_speed_hz           = 1500000,
625                 .controller_data        = &ads7846_mcspi_config,
626                 .irq                    = OMAP_GPIO_IRQ(OMAP3_PANDORA_TS_GPIO),
627                 .platform_data          = &ads7846_config,
628         }, {
629                 .modalias               = "tpo_td043mtea1_panel_spi",
630                 .bus_num                = 1,
631                 .chip_select            = 1,
632                 .max_speed_hz           = 375000,
633                 .platform_data          = &pandora_lcd_device,
634         }
635 };
636
637 static void __init omap3pandora_init_irq(void)
638 {
639         omap2_init_common_hw(mt46h32m32lf6_sdrc_params,
640                              mt46h32m32lf6_sdrc_params);
641         omap_init_irq();
642         omap_gpio_init();
643 }
644
645 static void pandora_wl1251_set_power(bool enable)
646 {
647         /*
648          * Keep power always on until wl1251_sdio driver learns to re-init
649          * the chip after powering it down and back up.
650          */
651 }
652
653 static struct wl12xx_platform_data pandora_wl1251_pdata = {
654         .set_power      = pandora_wl1251_set_power,
655         .use_eeprom     = true,
656 };
657
658 static struct platform_device pandora_wl1251_data = {
659         .name           = "wl1251_data",
660         .id             = -1,
661         .dev            = {
662                 .platform_data  = &pandora_wl1251_pdata,
663         },
664 };
665
666 static void pandora_wl1251_init(void)
667 {
668         int ret;
669
670         ret = gpio_request(PANDORA_WIFI_IRQ_GPIO, "wl1251 irq");
671         if (ret < 0)
672                 goto fail;
673
674         ret = gpio_direction_input(PANDORA_WIFI_IRQ_GPIO);
675         if (ret < 0)
676                 goto fail_irq;
677
678         pandora_wl1251_pdata.irq = gpio_to_irq(PANDORA_WIFI_IRQ_GPIO);
679         if (pandora_wl1251_pdata.irq < 0)
680                 goto fail_irq;
681
682         return;
683
684 fail_irq:
685         gpio_free(PANDORA_WIFI_IRQ_GPIO);
686 fail:
687         printk(KERN_ERR "wl1251 board initialisation failed\n");
688 }
689
690 static struct platform_device *omap3pandora_devices[] __initdata = {
691         &pandora_leds_gpio,
692         &pandora_keys_gpio,
693         &pandora_dss_device,
694         &pandora_wl1251_data,
695         &pandora_vwlan_device,
696 };
697
698 static const struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
699
700         .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
701         .port_mode[1] = EHCI_HCD_OMAP_MODE_UNKNOWN,
702         .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
703
704         .phy_reset  = true,
705         .reset_gpio_port[0]  = 16,
706         .reset_gpio_port[1]  = -EINVAL,
707         .reset_gpio_port[2]  = -EINVAL
708 };
709
710 #ifdef CONFIG_OMAP_MUX
711 static struct omap_board_mux board_mux[] __initdata = {
712         { .reg_offset = OMAP_MUX_TERMINATOR },
713 };
714 #else
715 #define board_mux       NULL
716 #endif
717
718 static struct omap_musb_board_data musb_board_data = {
719         .interface_type         = MUSB_INTERFACE_ULPI,
720         .mode                   = MUSB_OTG,
721         .power                  = 100,
722 };
723
724 static void __init omap3pandora_init(void)
725 {
726         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
727         omap3pandora_i2c_init();
728         pandora_wl1251_init();
729         platform_add_devices(omap3pandora_devices,
730                         ARRAY_SIZE(omap3pandora_devices));
731         omap_serial_init();
732         spi_register_board_info(omap3pandora_spi_board_info,
733                         ARRAY_SIZE(omap3pandora_spi_board_info));
734         omap3pandora_ads7846_init();
735         usb_ehci_init(&ehci_pdata);
736         usb_musb_init(&musb_board_data);
737         gpmc_nand_init(&pandora_nand_data);
738
739         /* Ensure SDRC pins are mux'd for self-refresh */
740         omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
741         omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
742 }
743
744 MACHINE_START(OMAP3_PANDORA, "Pandora Handheld Console")
745         .boot_params    = 0x80000100,
746         .map_io         = omap3_map_io,
747         .reserve        = omap_reserve,
748         .init_irq       = omap3pandora_init_irq,
749         .init_machine   = omap3pandora_init,
750         .timer          = &omap_timer,
751 MACHINE_END