ARM: OMAP3: omap3pandora: Adapt to ehci-omap changes
[firefly-linux-kernel-4.4.55.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/regulator/machine.h>
26 #include <linux/i2c/twl.h>
27 #include <linux/wl12xx.h>
28 #include <linux/mtd/partitions.h>
29 #include <linux/mtd/nand.h>
30 #include <linux/leds.h>
31 #include <linux/input.h>
32 #include <linux/input/matrix_keypad.h>
33 #include <linux/gpio.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 #include <linux/usb/phy.h>
39 #include <linux/platform_data/spi-omap2-mcspi.h>
40
41 #include <asm/mach-types.h>
42 #include <asm/mach/arch.h>
43 #include <asm/mach/map.h>
44
45 #include "common.h"
46 #include <video/omapdss.h>
47 #include <linux/platform_data/mtd-nand-omap2.h>
48
49 #include "mux.h"
50 #include "sdram-micron-mt46h32m32lf-6.h"
51 #include "hsmmc.h"
52 #include "common-board-devices.h"
53 #include "gpmc-nand.h"
54
55 #define PANDORA_WIFI_IRQ_GPIO           21
56 #define PANDORA_WIFI_NRESET_GPIO        23
57 #define OMAP3_PANDORA_TS_GPIO           94
58
59 static struct mtd_partition omap3pandora_nand_partitions[] = {
60         {
61                 .name           = "xloader",
62                 .offset         = 0,
63                 .size           = 4 * NAND_BLOCK_SIZE,
64                 .mask_flags     = MTD_WRITEABLE
65         }, {
66                 .name           = "uboot",
67                 .offset         = MTDPART_OFS_APPEND,
68                 .size           = 15 * NAND_BLOCK_SIZE,
69         }, {
70                 .name           = "uboot-env",
71                 .offset         = MTDPART_OFS_APPEND,
72                 .size           = 1 * NAND_BLOCK_SIZE,
73         }, {
74                 .name           = "boot",
75                 .offset         = MTDPART_OFS_APPEND,
76                 .size           = 80 * NAND_BLOCK_SIZE,
77         }, {
78                 .name           = "rootfs",
79                 .offset         = MTDPART_OFS_APPEND,
80                 .size           = MTDPART_SIZ_FULL,
81         },
82 };
83
84 static struct omap_nand_platform_data pandora_nand_data = {
85         .cs             = 0,
86         .devsize        = NAND_BUSWIDTH_16,
87         .xfer_type      = NAND_OMAP_PREFETCH_DMA,
88         .parts          = omap3pandora_nand_partitions,
89         .nr_parts       = ARRAY_SIZE(omap3pandora_nand_partitions),
90 };
91
92 static struct gpio_led pandora_gpio_leds[] = {
93         {
94                 .name                   = "pandora::sd1",
95                 .default_trigger        = "mmc0",
96                 .gpio                   = 128,
97         }, {
98                 .name                   = "pandora::sd2",
99                 .default_trigger        = "mmc1",
100                 .gpio                   = 129,
101         }, {
102                 .name                   = "pandora::bluetooth",
103                 .gpio                   = 158,
104         }, {
105                 .name                   = "pandora::wifi",
106                 .gpio                   = 159,
107         },
108 };
109
110 static struct gpio_led_platform_data pandora_gpio_led_data = {
111         .leds           = pandora_gpio_leds,
112         .num_leds       = ARRAY_SIZE(pandora_gpio_leds),
113 };
114
115 static struct platform_device pandora_leds_gpio = {
116         .name   = "leds-gpio",
117         .id     = -1,
118         .dev    = {
119                 .platform_data  = &pandora_gpio_led_data,
120         },
121 };
122
123 static struct platform_device pandora_backlight = {
124         .name   = "pandora-backlight",
125         .id     = -1,
126 };
127
128 #define GPIO_BUTTON(gpio_num, ev_type, ev_code, act_low, descr) \
129 {                                                               \
130         .gpio           = gpio_num,                             \
131         .type           = ev_type,                              \
132         .code           = ev_code,                              \
133         .active_low     = act_low,                              \
134         .debounce_interval = 4,                                 \
135         .desc           = "btn " descr,                         \
136 }
137
138 #define GPIO_BUTTON_LOW(gpio_num, event_code, description)      \
139         GPIO_BUTTON(gpio_num, EV_KEY, event_code, 1, description)
140
141 static struct gpio_keys_button pandora_gpio_keys[] = {
142         GPIO_BUTTON_LOW(110,    KEY_UP,         "up"),
143         GPIO_BUTTON_LOW(103,    KEY_DOWN,       "down"),
144         GPIO_BUTTON_LOW(96,     KEY_LEFT,       "left"),
145         GPIO_BUTTON_LOW(98,     KEY_RIGHT,      "right"),
146         GPIO_BUTTON_LOW(109,    KEY_PAGEUP,     "game 1"),
147         GPIO_BUTTON_LOW(111,    KEY_END,        "game 2"),
148         GPIO_BUTTON_LOW(106,    KEY_PAGEDOWN,   "game 3"),
149         GPIO_BUTTON_LOW(101,    KEY_HOME,       "game 4"),
150         GPIO_BUTTON_LOW(102,    KEY_RIGHTSHIFT, "l"),
151         GPIO_BUTTON_LOW(97,     KEY_KPPLUS,     "l2"),
152         GPIO_BUTTON_LOW(105,    KEY_RIGHTCTRL,  "r"),
153         GPIO_BUTTON_LOW(107,    KEY_KPMINUS,    "r2"),
154         GPIO_BUTTON_LOW(104,    KEY_LEFTCTRL,   "ctrl"),
155         GPIO_BUTTON_LOW(99,     KEY_MENU,       "menu"),
156         GPIO_BUTTON_LOW(176,    KEY_COFFEE,     "hold"),
157         GPIO_BUTTON(100, EV_KEY, KEY_LEFTALT, 0, "alt"),
158         GPIO_BUTTON(108, EV_SW, SW_LID, 1, "lid"),
159 };
160
161 static struct gpio_keys_platform_data pandora_gpio_key_info = {
162         .buttons        = pandora_gpio_keys,
163         .nbuttons       = ARRAY_SIZE(pandora_gpio_keys),
164 };
165
166 static struct platform_device pandora_keys_gpio = {
167         .name   = "gpio-keys",
168         .id     = -1,
169         .dev    = {
170                 .platform_data  = &pandora_gpio_key_info,
171         },
172 };
173
174 static const uint32_t board_keymap[] = {
175         /* row, col, code */
176         KEY(0, 0, KEY_9),
177         KEY(0, 1, KEY_8),
178         KEY(0, 2, KEY_I),
179         KEY(0, 3, KEY_J),
180         KEY(0, 4, KEY_N),
181         KEY(0, 5, KEY_M),
182         KEY(1, 0, KEY_0),
183         KEY(1, 1, KEY_7),
184         KEY(1, 2, KEY_U),
185         KEY(1, 3, KEY_H),
186         KEY(1, 4, KEY_B),
187         KEY(1, 5, KEY_SPACE),
188         KEY(2, 0, KEY_BACKSPACE),
189         KEY(2, 1, KEY_6),
190         KEY(2, 2, KEY_Y),
191         KEY(2, 3, KEY_G),
192         KEY(2, 4, KEY_V),
193         KEY(2, 5, KEY_FN),
194         KEY(3, 0, KEY_O),
195         KEY(3, 1, KEY_5),
196         KEY(3, 2, KEY_T),
197         KEY(3, 3, KEY_F),
198         KEY(3, 4, KEY_C),
199         KEY(4, 0, KEY_P),
200         KEY(4, 1, KEY_4),
201         KEY(4, 2, KEY_R),
202         KEY(4, 3, KEY_D),
203         KEY(4, 4, KEY_X),
204         KEY(5, 0, KEY_K),
205         KEY(5, 1, KEY_3),
206         KEY(5, 2, KEY_E),
207         KEY(5, 3, KEY_S),
208         KEY(5, 4, KEY_Z),
209         KEY(6, 0, KEY_L),
210         KEY(6, 1, KEY_2),
211         KEY(6, 2, KEY_W),
212         KEY(6, 3, KEY_A),
213         KEY(6, 4, KEY_DOT),
214         KEY(7, 0, KEY_ENTER),
215         KEY(7, 1, KEY_1),
216         KEY(7, 2, KEY_Q),
217         KEY(7, 3, KEY_LEFTSHIFT),
218         KEY(7, 4, KEY_COMMA),
219 };
220
221 static struct matrix_keymap_data board_map_data = {
222         .keymap                 = board_keymap,
223         .keymap_size            = ARRAY_SIZE(board_keymap),
224 };
225
226 static struct twl4030_keypad_data pandora_kp_data = {
227         .keymap_data    = &board_map_data,
228         .rows           = 8,
229         .cols           = 6,
230         .rep            = 1,
231 };
232
233 static struct omap_dss_device pandora_lcd_device = {
234         .name                   = "lcd",
235         .driver_name            = "tpo_td043mtea1_panel",
236         .type                   = OMAP_DISPLAY_TYPE_DPI,
237         .phy.dpi.data_lines     = 24,
238         .reset_gpio             = 157,
239 };
240
241 static struct omap_dss_device pandora_tv_device = {
242         .name                   = "tv",
243         .driver_name            = "venc",
244         .type                   = OMAP_DISPLAY_TYPE_VENC,
245         .phy.venc.type          = OMAP_DSS_VENC_TYPE_SVIDEO,
246 };
247
248 static struct omap_dss_device *pandora_dss_devices[] = {
249         &pandora_lcd_device,
250         &pandora_tv_device,
251 };
252
253 static struct omap_dss_board_info pandora_dss_data = {
254         .num_devices    = ARRAY_SIZE(pandora_dss_devices),
255         .devices        = pandora_dss_devices,
256         .default_device = &pandora_lcd_device,
257 };
258
259 static void pandora_wl1251_init_card(struct mmc_card *card)
260 {
261         /*
262          * We have TI wl1251 attached to MMC3. Pass this information to
263          * SDIO core because it can't be probed by normal methods.
264          */
265         card->quirks |= MMC_QUIRK_NONSTD_SDIO;
266         card->cccr.wide_bus = 1;
267         card->cis.vendor = 0x104c;
268         card->cis.device = 0x9066;
269         card->cis.blksize = 512;
270         card->cis.max_dtr = 20000000;
271 }
272
273 static struct omap2_hsmmc_info omap3pandora_mmc[] = {
274         {
275                 .mmc            = 1,
276                 .caps           = MMC_CAP_4_BIT_DATA,
277                 .gpio_cd        = -EINVAL,
278                 .gpio_wp        = 126,
279                 .ext_clock      = 0,
280                 .deferred       = true,
281         },
282         {
283                 .mmc            = 2,
284                 .caps           = MMC_CAP_4_BIT_DATA,
285                 .gpio_cd        = -EINVAL,
286                 .gpio_wp        = 127,
287                 .ext_clock      = 1,
288                 .transceiver    = true,
289                 .deferred       = true,
290         },
291         {
292                 .mmc            = 3,
293                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD,
294                 .gpio_cd        = -EINVAL,
295                 .gpio_wp        = -EINVAL,
296                 .init_card      = pandora_wl1251_init_card,
297         },
298         {}      /* Terminator */
299 };
300
301 static int omap3pandora_twl_gpio_setup(struct device *dev,
302                 unsigned gpio, unsigned ngpio)
303 {
304         int ret, gpio_32khz;
305
306         /* gpio + {0,1} is "mmc{0,1}_cd" (input/IRQ) */
307         omap3pandora_mmc[0].gpio_cd = gpio + 0;
308         omap3pandora_mmc[1].gpio_cd = gpio + 1;
309         omap_hsmmc_late_init(omap3pandora_mmc);
310
311         /* gpio + 13 drives 32kHz buffer for wifi module */
312         gpio_32khz = gpio + 13;
313         ret = gpio_request_one(gpio_32khz, GPIOF_OUT_INIT_HIGH, "wifi 32kHz");
314         if (ret < 0) {
315                 pr_err("Cannot get GPIO line %d, ret=%d\n", gpio_32khz, ret);
316                 return -ENODEV;
317         }
318
319         return 0;
320 }
321
322 static struct twl4030_gpio_platform_data omap3pandora_gpio_data = {
323         .setup          = omap3pandora_twl_gpio_setup,
324 };
325
326 static struct regulator_consumer_supply pandora_vmmc1_supply[] = {
327         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
328 };
329
330 static struct regulator_consumer_supply pandora_vmmc2_supply[] = {
331         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1")
332 };
333
334 static struct regulator_consumer_supply pandora_vmmc3_supply[] = {
335         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.2"),
336 };
337
338 static struct regulator_consumer_supply pandora_vdds_supplies[] = {
339         REGULATOR_SUPPLY("vdds_sdi", "omapdss"),
340         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
341         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
342 };
343
344 static struct regulator_consumer_supply pandora_vcc_lcd_supply[] = {
345         REGULATOR_SUPPLY("vcc", "display0"),
346 };
347
348 static struct regulator_consumer_supply pandora_usb_phy_supply[] = {
349         REGULATOR_SUPPLY("vcc", "nop_usb_xceiv.2"),     /* hsusb port 2 */
350 };
351
352 /* ads7846 on SPI and 2 nub controllers on I2C */
353 static struct regulator_consumer_supply pandora_vaux4_supplies[] = {
354         REGULATOR_SUPPLY("vcc", "spi1.0"),
355         REGULATOR_SUPPLY("vcc", "3-0066"),
356         REGULATOR_SUPPLY("vcc", "3-0067"),
357 };
358
359 static struct regulator_consumer_supply pandora_adac_supply[] = {
360         REGULATOR_SUPPLY("vcc", "soc-audio"),
361 };
362
363 /* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
364 static struct regulator_init_data pandora_vmmc1 = {
365         .constraints = {
366                 .min_uV                 = 1850000,
367                 .max_uV                 = 3150000,
368                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
369                                         | REGULATOR_MODE_STANDBY,
370                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
371                                         | REGULATOR_CHANGE_MODE
372                                         | REGULATOR_CHANGE_STATUS,
373         },
374         .num_consumer_supplies  = ARRAY_SIZE(pandora_vmmc1_supply),
375         .consumer_supplies      = pandora_vmmc1_supply,
376 };
377
378 /* VMMC2 for MMC2 pins CMD, CLK, DAT0..DAT3 (max 100 mA) */
379 static struct regulator_init_data pandora_vmmc2 = {
380         .constraints = {
381                 .min_uV                 = 1850000,
382                 .max_uV                 = 3150000,
383                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
384                                         | REGULATOR_MODE_STANDBY,
385                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
386                                         | REGULATOR_CHANGE_MODE
387                                         | REGULATOR_CHANGE_STATUS,
388         },
389         .num_consumer_supplies  = ARRAY_SIZE(pandora_vmmc2_supply),
390         .consumer_supplies      = pandora_vmmc2_supply,
391 };
392
393 /* VAUX1 for LCD */
394 static struct regulator_init_data pandora_vaux1 = {
395         .constraints = {
396                 .min_uV                 = 3000000,
397                 .max_uV                 = 3000000,
398                 .apply_uV               = true,
399                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
400                                         | REGULATOR_MODE_STANDBY,
401                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
402                                         | REGULATOR_CHANGE_STATUS,
403         },
404         .num_consumer_supplies  = ARRAY_SIZE(pandora_vcc_lcd_supply),
405         .consumer_supplies      = pandora_vcc_lcd_supply,
406 };
407
408 /* VAUX2 for USB host PHY */
409 static struct regulator_init_data pandora_vaux2 = {
410         .constraints = {
411                 .min_uV                 = 1800000,
412                 .max_uV                 = 1800000,
413                 .apply_uV               = true,
414                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
415                                         | REGULATOR_MODE_STANDBY,
416                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
417                                         | REGULATOR_CHANGE_STATUS,
418         },
419         .num_consumer_supplies  = ARRAY_SIZE(pandora_usb_phy_supply),
420         .consumer_supplies      = pandora_usb_phy_supply,
421 };
422
423 /* VAUX4 for ads7846 and nubs */
424 static struct regulator_init_data pandora_vaux4 = {
425         .constraints = {
426                 .min_uV                 = 2800000,
427                 .max_uV                 = 2800000,
428                 .apply_uV               = true,
429                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
430                                         | REGULATOR_MODE_STANDBY,
431                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
432                                         | REGULATOR_CHANGE_STATUS,
433         },
434         .num_consumer_supplies  = ARRAY_SIZE(pandora_vaux4_supplies),
435         .consumer_supplies      = pandora_vaux4_supplies,
436 };
437
438 /* VSIM for audio DAC */
439 static struct regulator_init_data pandora_vsim = {
440         .constraints = {
441                 .min_uV                 = 2800000,
442                 .max_uV                 = 2800000,
443                 .apply_uV               = true,
444                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
445                                         | REGULATOR_MODE_STANDBY,
446                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
447                                         | REGULATOR_CHANGE_STATUS,
448         },
449         .num_consumer_supplies  = ARRAY_SIZE(pandora_adac_supply),
450         .consumer_supplies      = pandora_adac_supply,
451 };
452
453 /* Fixed regulator internal to Wifi module */
454 static struct regulator_init_data pandora_vmmc3 = {
455         .constraints = {
456                 .valid_ops_mask         = REGULATOR_CHANGE_STATUS,
457         },
458         .num_consumer_supplies  = ARRAY_SIZE(pandora_vmmc3_supply),
459         .consumer_supplies      = pandora_vmmc3_supply,
460 };
461
462 static struct fixed_voltage_config pandora_vwlan = {
463         .supply_name            = "vwlan",
464         .microvolts             = 1800000, /* 1.8V */
465         .gpio                   = PANDORA_WIFI_NRESET_GPIO,
466         .startup_delay          = 50000, /* 50ms */
467         .enable_high            = 1,
468         .enabled_at_boot        = 0,
469         .init_data              = &pandora_vmmc3,
470 };
471
472 static struct platform_device pandora_vwlan_device = {
473         .name           = "reg-fixed-voltage",
474         .id             = 1,
475         .dev = {
476                 .platform_data = &pandora_vwlan,
477         },
478 };
479
480 static struct twl4030_bci_platform_data pandora_bci_data;
481
482 static struct twl4030_power_data pandora_power_data = {
483         .use_poweroff   = true,
484 };
485
486 static struct twl4030_platform_data omap3pandora_twldata = {
487         .gpio           = &omap3pandora_gpio_data,
488         .vmmc1          = &pandora_vmmc1,
489         .vmmc2          = &pandora_vmmc2,
490         .vaux1          = &pandora_vaux1,
491         .vaux2          = &pandora_vaux2,
492         .vaux4          = &pandora_vaux4,
493         .vsim           = &pandora_vsim,
494         .keypad         = &pandora_kp_data,
495         .bci            = &pandora_bci_data,
496         .power          = &pandora_power_data,
497 };
498
499 static struct i2c_board_info __initdata omap3pandora_i2c3_boardinfo[] = {
500         {
501                 I2C_BOARD_INFO("bq27500", 0x55),
502                 .flags = I2C_CLIENT_WAKE,
503         },
504 };
505
506 static int __init omap3pandora_i2c_init(void)
507 {
508         omap3_pmic_get_config(&omap3pandora_twldata,
509                         TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_AUDIO,
510                         TWL_COMMON_REGULATOR_VDAC | TWL_COMMON_REGULATOR_VPLL2);
511
512         omap3pandora_twldata.vdac->constraints.apply_uV = true;
513
514         omap3pandora_twldata.vpll2->constraints.apply_uV = true;
515         omap3pandora_twldata.vpll2->num_consumer_supplies =
516                                         ARRAY_SIZE(pandora_vdds_supplies);
517         omap3pandora_twldata.vpll2->consumer_supplies = pandora_vdds_supplies;
518
519         omap3_pmic_init("tps65950", &omap3pandora_twldata);
520         /* i2c2 pins are not connected */
521         omap_register_i2c_bus(3, 100, omap3pandora_i2c3_boardinfo,
522                         ARRAY_SIZE(omap3pandora_i2c3_boardinfo));
523         return 0;
524 }
525
526 static struct spi_board_info omap3pandora_spi_board_info[] __initdata = {
527         {
528                 .modalias               = "tpo_td043mtea1_panel_spi",
529                 .bus_num                = 1,
530                 .chip_select            = 1,
531                 .max_speed_hz           = 375000,
532                 .platform_data          = &pandora_lcd_device,
533         }
534 };
535
536 static void __init pandora_wl1251_init(void)
537 {
538         struct wl12xx_platform_data pandora_wl1251_pdata;
539         int ret;
540
541         memset(&pandora_wl1251_pdata, 0, sizeof(pandora_wl1251_pdata));
542
543         ret = gpio_request_one(PANDORA_WIFI_IRQ_GPIO, GPIOF_IN, "wl1251 irq");
544         if (ret < 0)
545                 goto fail;
546
547         pandora_wl1251_pdata.irq = gpio_to_irq(PANDORA_WIFI_IRQ_GPIO);
548         if (pandora_wl1251_pdata.irq < 0)
549                 goto fail_irq;
550
551         pandora_wl1251_pdata.use_eeprom = true;
552         ret = wl12xx_set_platform_data(&pandora_wl1251_pdata);
553         if (ret < 0)
554                 goto fail_irq;
555
556         return;
557
558 fail_irq:
559         gpio_free(PANDORA_WIFI_IRQ_GPIO);
560 fail:
561         printk(KERN_ERR "wl1251 board initialisation failed\n");
562 }
563
564 static struct usbhs_phy_data phy_data[] __initdata = {
565         {
566                 .port = 2,
567                 .reset_gpio = 16,
568                 .vcc_gpio = -EINVAL,
569         },
570 };
571
572 static struct platform_device *omap3pandora_devices[] __initdata = {
573         &pandora_leds_gpio,
574         &pandora_keys_gpio,
575         &pandora_vwlan_device,
576         &pandora_backlight,
577 };
578
579 static struct usbhs_omap_platform_data usbhs_bdata __initdata = {
580         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
581 };
582
583 #ifdef CONFIG_OMAP_MUX
584 static struct omap_board_mux board_mux[] __initdata = {
585         { .reg_offset = OMAP_MUX_TERMINATOR },
586 };
587 #endif
588
589 static void __init omap3pandora_init(void)
590 {
591         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
592         omap_hsmmc_init(omap3pandora_mmc);
593         omap3pandora_i2c_init();
594         pandora_wl1251_init();
595         platform_add_devices(omap3pandora_devices,
596                         ARRAY_SIZE(omap3pandora_devices));
597         omap_display_init(&pandora_dss_data);
598         omap_serial_init();
599         omap_sdrc_init(mt46h32m32lf6_sdrc_params,
600                                   mt46h32m32lf6_sdrc_params);
601         spi_register_board_info(omap3pandora_spi_board_info,
602                         ARRAY_SIZE(omap3pandora_spi_board_info));
603         omap_ads7846_init(1, OMAP3_PANDORA_TS_GPIO, 0, NULL);
604
605         usbhs_init_phys(phy_data, ARRAY_SIZE(phy_data));
606         usbhs_init(&usbhs_bdata);
607
608         usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
609         usb_musb_init(NULL);
610         gpmc_nand_init(&pandora_nand_data, NULL);
611
612         /* Ensure SDRC pins are mux'd for self-refresh */
613         omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
614         omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
615 }
616
617 MACHINE_START(OMAP3_PANDORA, "Pandora Handheld Console")
618         .atag_offset    = 0x100,
619         .reserve        = omap_reserve,
620         .map_io         = omap3_map_io,
621         .init_early     = omap35xx_init_early,
622         .init_irq       = omap3_init_irq,
623         .handle_irq     = omap3_intc_handle_irq,
624         .init_machine   = omap3pandora_init,
625         .init_late      = omap35xx_init_late,
626         .init_time      = omap3_sync32k_timer_init,
627         .restart        = omap3xxx_restart,
628 MACHINE_END