OMAP: mux: Add support for control module split in several partitions
[linux-2.6.git] / arch / arm / mach-omap2 / board-rx51-peripherals.c
1 /*
2  * linux/arch/arm/mach-omap2/board-rx51-peripherals.c
3  *
4  * Copyright (C) 2008-2009 Nokia
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/input.h>
15 #include <linux/input/matrix_keypad.h>
16 #include <linux/spi/spi.h>
17 #include <linux/wl12xx.h>
18 #include <linux/i2c.h>
19 #include <linux/i2c/twl.h>
20 #include <linux/clk.h>
21 #include <linux/delay.h>
22 #include <linux/regulator/machine.h>
23 #include <linux/gpio.h>
24 #include <linux/gpio_keys.h>
25 #include <linux/mmc/host.h>
26 #include <sound/tlv320aic3x.h>
27
28 #include <plat/mcspi.h>
29 #include <plat/board.h>
30 #include <plat/common.h>
31 #include <plat/dma.h>
32 #include <plat/gpmc.h>
33 #include <plat/onenand.h>
34 #include <plat/gpmc-smc91x.h>
35
36 #include <mach/board-rx51.h>
37
38 #include <sound/tlv320aic3x.h>
39 #include <sound/tpa6130a2-plat.h>
40
41 #include <../drivers/staging/iio/light/tsl2563.h>
42
43 #include "mux.h"
44 #include "hsmmc.h"
45
46 #define SYSTEM_REV_B_USES_VAUX3 0x1699
47 #define SYSTEM_REV_S_USES_VAUX3 0x8
48
49 #define RX51_WL1251_POWER_GPIO          87
50 #define RX51_WL1251_IRQ_GPIO            42
51
52 /* list all spi devices here */
53 enum {
54         RX51_SPI_WL1251,
55         RX51_SPI_MIPID,         /* LCD panel */
56         RX51_SPI_TSC2005,       /* Touch Controller */
57 };
58
59 static struct wl12xx_platform_data wl1251_pdata;
60
61 #if defined(CONFIG_SENSORS_TSL2563) || defined(CONFIG_SENSORS_TSL2563_MODULE)
62 static struct tsl2563_platform_data rx51_tsl2563_platform_data = {
63         .cover_comp_gain = 16,
64 };
65 #endif
66
67 static struct omap2_mcspi_device_config wl1251_mcspi_config = {
68         .turbo_mode     = 0,
69         .single_channel = 1,
70 };
71
72 static struct omap2_mcspi_device_config mipid_mcspi_config = {
73         .turbo_mode     = 0,
74         .single_channel = 1,
75 };
76
77 static struct omap2_mcspi_device_config tsc2005_mcspi_config = {
78         .turbo_mode     = 0,
79         .single_channel = 1,
80 };
81
82 static struct spi_board_info rx51_peripherals_spi_board_info[] __initdata = {
83         [RX51_SPI_WL1251] = {
84                 .modalias               = "wl1251",
85                 .bus_num                = 4,
86                 .chip_select            = 0,
87                 .max_speed_hz           = 48000000,
88                 .mode                   = SPI_MODE_3,
89                 .controller_data        = &wl1251_mcspi_config,
90                 .platform_data          = &wl1251_pdata,
91         },
92         [RX51_SPI_MIPID] = {
93                 .modalias               = "acx565akm",
94                 .bus_num                = 1,
95                 .chip_select            = 2,
96                 .max_speed_hz           = 6000000,
97                 .controller_data        = &mipid_mcspi_config,
98         },
99         [RX51_SPI_TSC2005] = {
100                 .modalias               = "tsc2005",
101                 .bus_num                = 1,
102                 .chip_select            = 0,
103                 /* .irq = OMAP_GPIO_IRQ(RX51_TSC2005_IRQ_GPIO),*/
104                 .max_speed_hz           = 6000000,
105                 .controller_data        = &tsc2005_mcspi_config,
106                 /* .platform_data = &tsc2005_config,*/
107         },
108 };
109
110 static struct platform_device rx51_charger_device = {
111         .name = "isp1704_charger",
112 };
113
114 #if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)
115
116 #define RX51_GPIO_CAMERA_LENS_COVER     110
117 #define RX51_GPIO_CAMERA_FOCUS          68
118 #define RX51_GPIO_CAMERA_CAPTURE        69
119 #define RX51_GPIO_KEYPAD_SLIDE          71
120 #define RX51_GPIO_LOCK_BUTTON           113
121 #define RX51_GPIO_PROXIMITY             89
122
123 #define RX51_GPIO_DEBOUNCE_TIMEOUT      10
124
125 static struct gpio_keys_button rx51_gpio_keys[] = {
126         {
127                 .desc                   = "Camera Lens Cover",
128                 .type                   = EV_SW,
129                 .code                   = SW_CAMERA_LENS_COVER,
130                 .gpio                   = RX51_GPIO_CAMERA_LENS_COVER,
131                 .active_low             = 1,
132                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
133         }, {
134                 .desc                   = "Camera Focus",
135                 .type                   = EV_KEY,
136                 .code                   = KEY_CAMERA_FOCUS,
137                 .gpio                   = RX51_GPIO_CAMERA_FOCUS,
138                 .active_low             = 1,
139                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
140         }, {
141                 .desc                   = "Camera Capture",
142                 .type                   = EV_KEY,
143                 .code                   = KEY_CAMERA,
144                 .gpio                   = RX51_GPIO_CAMERA_CAPTURE,
145                 .active_low             = 1,
146                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
147         }, {
148                 .desc                   = "Lock Button",
149                 .type                   = EV_KEY,
150                 .code                   = KEY_SCREENLOCK,
151                 .gpio                   = RX51_GPIO_LOCK_BUTTON,
152                 .active_low             = 1,
153                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
154         }, {
155                 .desc                   = "Keypad Slide",
156                 .type                   = EV_SW,
157                 .code                   = SW_KEYPAD_SLIDE,
158                 .gpio                   = RX51_GPIO_KEYPAD_SLIDE,
159                 .active_low             = 1,
160                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
161         }, {
162                 .desc                   = "Proximity Sensor",
163                 .type                   = EV_SW,
164                 .code                   = SW_FRONT_PROXIMITY,
165                 .gpio                   = RX51_GPIO_PROXIMITY,
166                 .active_low             = 0,
167                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
168         }
169 };
170
171 static struct gpio_keys_platform_data rx51_gpio_keys_data = {
172         .buttons        = rx51_gpio_keys,
173         .nbuttons       = ARRAY_SIZE(rx51_gpio_keys),
174 };
175
176 static struct platform_device rx51_gpio_keys_device = {
177         .name   = "gpio-keys",
178         .id     = -1,
179         .dev    = {
180                 .platform_data  = &rx51_gpio_keys_data,
181         },
182 };
183
184 static void __init rx51_add_gpio_keys(void)
185 {
186         platform_device_register(&rx51_gpio_keys_device);
187 }
188 #else
189 static void __init rx51_add_gpio_keys(void)
190 {
191 }
192 #endif /* CONFIG_KEYBOARD_GPIO || CONFIG_KEYBOARD_GPIO_MODULE */
193
194 static uint32_t board_keymap[] = {
195         /*
196          * Note that KEY(x, 8, KEY_XXX) entries represent "entrire row
197          * connected to the ground" matrix state.
198          */
199         KEY(0, 0, KEY_Q),
200         KEY(0, 1, KEY_O),
201         KEY(0, 2, KEY_P),
202         KEY(0, 3, KEY_COMMA),
203         KEY(0, 4, KEY_BACKSPACE),
204         KEY(0, 6, KEY_A),
205         KEY(0, 7, KEY_S),
206
207         KEY(1, 0, KEY_W),
208         KEY(1, 1, KEY_D),
209         KEY(1, 2, KEY_F),
210         KEY(1, 3, KEY_G),
211         KEY(1, 4, KEY_H),
212         KEY(1, 5, KEY_J),
213         KEY(1, 6, KEY_K),
214         KEY(1, 7, KEY_L),
215
216         KEY(2, 0, KEY_E),
217         KEY(2, 1, KEY_DOT),
218         KEY(2, 2, KEY_UP),
219         KEY(2, 3, KEY_ENTER),
220         KEY(2, 5, KEY_Z),
221         KEY(2, 6, KEY_X),
222         KEY(2, 7, KEY_C),
223         KEY(2, 8, KEY_F9),
224
225         KEY(3, 0, KEY_R),
226         KEY(3, 1, KEY_V),
227         KEY(3, 2, KEY_B),
228         KEY(3, 3, KEY_N),
229         KEY(3, 4, KEY_M),
230         KEY(3, 5, KEY_SPACE),
231         KEY(3, 6, KEY_SPACE),
232         KEY(3, 7, KEY_LEFT),
233
234         KEY(4, 0, KEY_T),
235         KEY(4, 1, KEY_DOWN),
236         KEY(4, 2, KEY_RIGHT),
237         KEY(4, 4, KEY_LEFTCTRL),
238         KEY(4, 5, KEY_RIGHTALT),
239         KEY(4, 6, KEY_LEFTSHIFT),
240         KEY(4, 8, KEY_F10),
241
242         KEY(5, 0, KEY_Y),
243         KEY(5, 8, KEY_F11),
244
245         KEY(6, 0, KEY_U),
246
247         KEY(7, 0, KEY_I),
248         KEY(7, 1, KEY_F7),
249         KEY(7, 2, KEY_F8),
250 };
251
252 static struct matrix_keymap_data board_map_data = {
253         .keymap                 = board_keymap,
254         .keymap_size            = ARRAY_SIZE(board_keymap),
255 };
256
257 static struct twl4030_keypad_data rx51_kp_data = {
258         .keymap_data    = &board_map_data,
259         .rows           = 8,
260         .cols           = 8,
261         .rep            = 1,
262 };
263
264 static struct twl4030_madc_platform_data rx51_madc_data = {
265         .irq_line               = 1,
266 };
267
268 /* Enable input logic and pull all lines up when eMMC is on. */
269 static struct omap_board_mux rx51_mmc2_on_mux[] = {
270         OMAP3_MUX(SDMMC2_CMD, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
271         OMAP3_MUX(SDMMC2_DAT0, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
272         OMAP3_MUX(SDMMC2_DAT1, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
273         OMAP3_MUX(SDMMC2_DAT2, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
274         OMAP3_MUX(SDMMC2_DAT3, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
275         OMAP3_MUX(SDMMC2_DAT4, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
276         OMAP3_MUX(SDMMC2_DAT5, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
277         OMAP3_MUX(SDMMC2_DAT6, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
278         OMAP3_MUX(SDMMC2_DAT7, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
279         { .reg_offset = OMAP_MUX_TERMINATOR },
280 };
281
282 /* Disable input logic and pull all lines down when eMMC is off. */
283 static struct omap_board_mux rx51_mmc2_off_mux[] = {
284         OMAP3_MUX(SDMMC2_CMD, OMAP_PULL_ENA | OMAP_MUX_MODE0),
285         OMAP3_MUX(SDMMC2_DAT0, OMAP_PULL_ENA | OMAP_MUX_MODE0),
286         OMAP3_MUX(SDMMC2_DAT1, OMAP_PULL_ENA | OMAP_MUX_MODE0),
287         OMAP3_MUX(SDMMC2_DAT2, OMAP_PULL_ENA | OMAP_MUX_MODE0),
288         OMAP3_MUX(SDMMC2_DAT3, OMAP_PULL_ENA | OMAP_MUX_MODE0),
289         OMAP3_MUX(SDMMC2_DAT4, OMAP_PULL_ENA | OMAP_MUX_MODE0),
290         OMAP3_MUX(SDMMC2_DAT5, OMAP_PULL_ENA | OMAP_MUX_MODE0),
291         OMAP3_MUX(SDMMC2_DAT6, OMAP_PULL_ENA | OMAP_MUX_MODE0),
292         OMAP3_MUX(SDMMC2_DAT7, OMAP_PULL_ENA | OMAP_MUX_MODE0),
293         { .reg_offset = OMAP_MUX_TERMINATOR },
294 };
295
296 static struct omap_mux_partition *partition;
297
298 /*
299  * Current flows to eMMC when eMMC is off and the data lines are pulled up,
300  * so pull them down. N.B. we pull 8 lines because we are using 8 lines.
301  */
302 static void rx51_mmc2_remux(struct device *dev, int slot, int power_on)
303 {
304         if (power_on)
305                 omap_mux_write_array(partition, rx51_mmc2_on_mux);
306         else
307                 omap_mux_write_array(partition, rx51_mmc2_off_mux);
308 }
309
310 static struct omap2_hsmmc_info mmc[] __initdata = {
311         {
312                 .name           = "external",
313                 .mmc            = 1,
314                 .caps           = MMC_CAP_4_BIT_DATA,
315                 .cover_only     = true,
316                 .gpio_cd        = 160,
317                 .gpio_wp        = -EINVAL,
318                 .power_saving   = true,
319         },
320         {
321                 .name           = "internal",
322                 .mmc            = 2,
323                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
324                                                 /* See also rx51_mmc2_remux */
325                 .gpio_cd        = -EINVAL,
326                 .gpio_wp        = -EINVAL,
327                 .nonremovable   = true,
328                 .power_saving   = true,
329                 .remux          = rx51_mmc2_remux,
330         },
331         {}      /* Terminator */
332 };
333
334 static struct regulator_consumer_supply rx51_vmmc1_supply =
335         REGULATOR_SUPPLY("vmmc", "mmci-omap-hs.0");
336
337 static struct regulator_consumer_supply rx51_vaux3_supply =
338         REGULATOR_SUPPLY("vmmc", "mmci-omap-hs.1");
339
340 static struct regulator_consumer_supply rx51_vsim_supply =
341         REGULATOR_SUPPLY("vmmc_aux", "mmci-omap-hs.1");
342
343 static struct regulator_consumer_supply rx51_vmmc2_supplies[] = {
344         /* tlv320aic3x analog supplies */
345         REGULATOR_SUPPLY("AVDD", "2-0018"),
346         REGULATOR_SUPPLY("DRVDD", "2-0018"),
347         /* tpa6130a2 */
348         REGULATOR_SUPPLY("Vdd", "2-0060"),
349         /* Keep vmmc as last item. It is not iterated for newer boards */
350         REGULATOR_SUPPLY("vmmc", "mmci-omap-hs.1"),
351 };
352
353 static struct regulator_consumer_supply rx51_vio_supplies[] = {
354         /* tlv320aic3x digital supplies */
355         REGULATOR_SUPPLY("IOVDD", "2-0018"),
356         REGULATOR_SUPPLY("DVDD", "2-0018"),
357 };
358
359 #if defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE)
360 extern struct platform_device rx51_display_device;
361 #endif
362
363 static struct regulator_consumer_supply rx51_vaux1_consumers[] = {
364 #if defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE)
365         {
366                 .supply = "vdds_sdi",
367                 .dev    = &rx51_display_device.dev,
368         },
369 #endif
370 };
371
372 static struct regulator_init_data rx51_vaux1 = {
373         .constraints = {
374                 .name                   = "V28",
375                 .min_uV                 = 2800000,
376                 .max_uV                 = 2800000,
377                 .always_on              = true, /* due battery cover sensor */
378                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
379                                         | REGULATOR_MODE_STANDBY,
380                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
381                                         | REGULATOR_CHANGE_STATUS,
382         },
383         .num_consumer_supplies  = ARRAY_SIZE(rx51_vaux1_consumers),
384         .consumer_supplies      = rx51_vaux1_consumers,
385 };
386
387 static struct regulator_init_data rx51_vaux2 = {
388         .constraints = {
389                 .name                   = "VCSI",
390                 .min_uV                 = 1800000,
391                 .max_uV                 = 1800000,
392                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
393                                         | REGULATOR_MODE_STANDBY,
394                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
395                                         | REGULATOR_CHANGE_STATUS,
396         },
397 };
398
399 /* VAUX3 - adds more power to VIO_18 rail */
400 static struct regulator_init_data rx51_vaux3_cam = {
401         .constraints = {
402                 .name                   = "VCAM_DIG_18",
403                 .min_uV                 = 1800000,
404                 .max_uV                 = 1800000,
405                 .apply_uV               = true,
406                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
407                                         | REGULATOR_MODE_STANDBY,
408                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
409                                         | REGULATOR_CHANGE_STATUS,
410         },
411 };
412
413 static struct regulator_init_data rx51_vaux3_mmc = {
414         .constraints = {
415                 .name                   = "VMMC2_30",
416                 .min_uV                 = 2800000,
417                 .max_uV                 = 3000000,
418                 .apply_uV               = true,
419                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
420                                         | REGULATOR_MODE_STANDBY,
421                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
422                                         | REGULATOR_CHANGE_MODE
423                                         | REGULATOR_CHANGE_STATUS,
424         },
425         .num_consumer_supplies  = 1,
426         .consumer_supplies      = &rx51_vaux3_supply,
427 };
428
429 static struct regulator_init_data rx51_vaux4 = {
430         .constraints = {
431                 .name                   = "VCAM_ANA_28",
432                 .min_uV                 = 2800000,
433                 .max_uV                 = 2800000,
434                 .apply_uV               = true,
435                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
436                                         | REGULATOR_MODE_STANDBY,
437                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
438                                         | REGULATOR_CHANGE_STATUS,
439         },
440 };
441
442 static struct regulator_init_data rx51_vmmc1 = {
443         .constraints = {
444                 .min_uV                 = 1850000,
445                 .max_uV                 = 3150000,
446                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
447                                         | REGULATOR_MODE_STANDBY,
448                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
449                                         | REGULATOR_CHANGE_MODE
450                                         | REGULATOR_CHANGE_STATUS,
451         },
452         .num_consumer_supplies  = 1,
453         .consumer_supplies      = &rx51_vmmc1_supply,
454 };
455
456 static struct regulator_init_data rx51_vmmc2 = {
457         .constraints = {
458                 .name                   = "V28_A",
459                 .min_uV                 = 2800000,
460                 .max_uV                 = 3000000,
461                 .apply_uV               = true,
462                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
463                                         | REGULATOR_MODE_STANDBY,
464                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
465                                         | REGULATOR_CHANGE_MODE
466                                         | REGULATOR_CHANGE_STATUS,
467         },
468         .num_consumer_supplies  = ARRAY_SIZE(rx51_vmmc2_supplies),
469         .consumer_supplies      = rx51_vmmc2_supplies,
470 };
471
472 static struct regulator_init_data rx51_vsim = {
473         .constraints = {
474                 .name                   = "VMMC2_IO_18",
475                 .min_uV                 = 1800000,
476                 .max_uV                 = 1800000,
477                 .apply_uV               = true,
478                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
479                                         | REGULATOR_MODE_STANDBY,
480                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
481                                         | REGULATOR_CHANGE_STATUS,
482         },
483         .num_consumer_supplies  = 1,
484         .consumer_supplies      = &rx51_vsim_supply,
485 };
486
487 static struct regulator_init_data rx51_vdac = {
488         .constraints = {
489                 .min_uV                 = 1800000,
490                 .max_uV                 = 1800000,
491                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
492                                         | REGULATOR_MODE_STANDBY,
493                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
494                                         | REGULATOR_CHANGE_MODE
495                                         | REGULATOR_CHANGE_STATUS,
496         },
497 };
498
499 static struct regulator_init_data rx51_vio = {
500         .constraints = {
501                 .min_uV                 = 1800000,
502                 .max_uV                 = 1800000,
503                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
504                                         | REGULATOR_MODE_STANDBY,
505                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
506                                         | REGULATOR_CHANGE_MODE
507                                         | REGULATOR_CHANGE_STATUS,
508         },
509         .num_consumer_supplies  = ARRAY_SIZE(rx51_vio_supplies),
510         .consumer_supplies      = rx51_vio_supplies,
511 };
512
513 static int rx51_twlgpio_setup(struct device *dev, unsigned gpio, unsigned n)
514 {
515         /* FIXME this gpio setup is just a placeholder for now */
516         gpio_request(gpio + 6, "backlight_pwm");
517         gpio_direction_output(gpio + 6, 0);
518         gpio_request(gpio + 7, "speaker_en");
519         gpio_direction_output(gpio + 7, 1);
520
521         return 0;
522 }
523
524 static struct twl4030_gpio_platform_data rx51_gpio_data = {
525         .gpio_base              = OMAP_MAX_GPIO_LINES,
526         .irq_base               = TWL4030_GPIO_IRQ_BASE,
527         .irq_end                = TWL4030_GPIO_IRQ_END,
528         .pulldowns              = BIT(0) | BIT(1) | BIT(2) | BIT(3)
529                                 | BIT(4) | BIT(5)
530                                 | BIT(8) | BIT(9) | BIT(10) | BIT(11)
531                                 | BIT(12) | BIT(13) | BIT(14) | BIT(15)
532                                 | BIT(16) | BIT(17) ,
533         .setup                  = rx51_twlgpio_setup,
534 };
535
536 static struct twl4030_usb_data rx51_usb_data = {
537         .usb_mode               = T2_USB_MODE_ULPI,
538 };
539
540 static struct twl4030_ins sleep_on_seq[] __initdata = {
541 /*
542  * Turn off everything
543  */
544         {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_ALL, 1, 0, RES_STATE_SLEEP), 2},
545 };
546
547 static struct twl4030_script sleep_on_script __initdata = {
548         .script = sleep_on_seq,
549         .size   = ARRAY_SIZE(sleep_on_seq),
550         .flags  = TWL4030_SLEEP_SCRIPT,
551 };
552
553 static struct twl4030_ins wakeup_seq[] __initdata = {
554 /*
555  * Reenable everything
556  */
557         {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_ALL, 1, 0, RES_STATE_ACTIVE), 2},
558 };
559
560 static struct twl4030_script wakeup_script __initdata = {
561         .script = wakeup_seq,
562         .size   = ARRAY_SIZE(wakeup_seq),
563         .flags  = TWL4030_WAKEUP12_SCRIPT,
564 };
565
566 static struct twl4030_ins wakeup_p3_seq[] __initdata = {
567 /*
568  * Reenable everything
569  */
570         {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_ALL, 1, 0, RES_STATE_ACTIVE), 2},
571 };
572
573 static struct twl4030_script wakeup_p3_script __initdata = {
574         .script = wakeup_p3_seq,
575         .size   = ARRAY_SIZE(wakeup_p3_seq),
576         .flags  = TWL4030_WAKEUP3_SCRIPT,
577 };
578
579 static struct twl4030_ins wrst_seq[] __initdata = {
580 /*
581  * Reset twl4030.
582  * Reset VDD1 regulator.
583  * Reset VDD2 regulator.
584  * Reset VPLL1 regulator.
585  * Enable sysclk output.
586  * Reenable twl4030.
587  */
588         {MSG_SINGULAR(DEV_GRP_NULL, RES_RESET, RES_STATE_OFF), 2},
589         {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_ALL, 0, 1, RES_STATE_ACTIVE),
590                 0x13},
591         {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_PP, 0, 3, RES_STATE_OFF), 0x13},
592         {MSG_SINGULAR(DEV_GRP_NULL, RES_VDD1, RES_STATE_WRST), 0x13},
593         {MSG_SINGULAR(DEV_GRP_NULL, RES_VDD2, RES_STATE_WRST), 0x13},
594         {MSG_SINGULAR(DEV_GRP_NULL, RES_VPLL1, RES_STATE_WRST), 0x35},
595         {MSG_SINGULAR(DEV_GRP_P3, RES_HFCLKOUT, RES_STATE_ACTIVE), 2},
596         {MSG_SINGULAR(DEV_GRP_NULL, RES_RESET, RES_STATE_ACTIVE), 2},
597 };
598
599 static struct twl4030_script wrst_script __initdata = {
600         .script = wrst_seq,
601         .size   = ARRAY_SIZE(wrst_seq),
602         .flags  = TWL4030_WRST_SCRIPT,
603 };
604
605 static struct twl4030_script *twl4030_scripts[] __initdata = {
606         /* wakeup12 script should be loaded before sleep script, otherwise a
607            board might hit retention before loading of wakeup script is
608            completed. This can cause boot failures depending on timing issues.
609         */
610         &wakeup_script,
611         &sleep_on_script,
612         &wakeup_p3_script,
613         &wrst_script,
614 };
615
616 static struct twl4030_resconfig twl4030_rconfig[] __initdata = {
617         { .resource = RES_VDD1, .devgroup = -1,
618           .type = 1, .type2 = -1, .remap_off = RES_STATE_OFF,
619           .remap_sleep = RES_STATE_OFF
620         },
621         { .resource = RES_VDD2, .devgroup = -1,
622           .type = 1, .type2 = -1, .remap_off = RES_STATE_OFF,
623           .remap_sleep = RES_STATE_OFF
624         },
625         { .resource = RES_VPLL1, .devgroup = -1,
626           .type = 1, .type2 = -1, .remap_off = RES_STATE_OFF,
627           .remap_sleep = RES_STATE_OFF
628         },
629         { .resource = RES_VPLL2, .devgroup = -1,
630           .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
631         },
632         { .resource = RES_VAUX1, .devgroup = -1,
633           .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
634         },
635         { .resource = RES_VAUX2, .devgroup = -1,
636           .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
637         },
638         { .resource = RES_VAUX3, .devgroup = -1,
639           .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
640         },
641         { .resource = RES_VAUX4, .devgroup = -1,
642           .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
643         },
644         { .resource = RES_VMMC1, .devgroup = -1,
645           .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
646         },
647         { .resource = RES_VMMC2, .devgroup = -1,
648           .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
649         },
650         { .resource = RES_VDAC, .devgroup = -1,
651           .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
652         },
653         { .resource = RES_VSIM, .devgroup = -1,
654           .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
655         },
656         { .resource = RES_VINTANA1, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
657           .type = -1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
658         },
659         { .resource = RES_VINTANA2, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
660           .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
661         },
662         { .resource = RES_VINTDIG, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
663           .type = -1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
664         },
665         { .resource = RES_VIO, .devgroup = DEV_GRP_P3,
666           .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
667         },
668         { .resource = RES_CLKEN, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
669           .type = 1, .type2 = -1 , .remap_off = -1, .remap_sleep = -1
670         },
671         { .resource = RES_REGEN, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
672           .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
673         },
674         { .resource = RES_NRES_PWRON, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
675           .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
676         },
677         { .resource = RES_SYSEN, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
678           .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
679         },
680         { .resource = RES_HFCLKOUT, .devgroup = DEV_GRP_P3,
681           .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
682         },
683         { .resource = RES_32KCLKOUT, .devgroup = -1,
684           .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
685         },
686         { .resource = RES_RESET, .devgroup = -1,
687           .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
688         },
689         { .resource = RES_Main_Ref, .devgroup = -1,
690           .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
691         },
692         { 0, 0},
693 };
694
695 static struct twl4030_power_data rx51_t2scripts_data __initdata = {
696         .scripts        = twl4030_scripts,
697         .num = ARRAY_SIZE(twl4030_scripts),
698         .resource_config = twl4030_rconfig,
699 };
700
701
702 static struct twl4030_platform_data rx51_twldata __initdata = {
703         .irq_base               = TWL4030_IRQ_BASE,
704         .irq_end                = TWL4030_IRQ_END,
705
706         /* platform_data for children goes here */
707         .gpio                   = &rx51_gpio_data,
708         .keypad                 = &rx51_kp_data,
709         .madc                   = &rx51_madc_data,
710         .usb                    = &rx51_usb_data,
711         .power                  = &rx51_t2scripts_data,
712
713         .vaux1                  = &rx51_vaux1,
714         .vaux2                  = &rx51_vaux2,
715         .vaux4                  = &rx51_vaux4,
716         .vmmc1                  = &rx51_vmmc1,
717         .vsim                   = &rx51_vsim,
718         .vdac                   = &rx51_vdac,
719         .vio                    = &rx51_vio,
720 };
721
722 static struct tpa6130a2_platform_data rx51_tpa6130a2_data __initdata = {
723         .id                     = TPA6130A2,
724         .power_gpio             = 98,
725 };
726
727 static struct i2c_board_info __initdata rx51_peripherals_i2c_board_info_1[] = {
728         {
729                 I2C_BOARD_INFO("twl5030", 0x48),
730                 .flags = I2C_CLIENT_WAKE,
731                 .irq = INT_34XX_SYS_NIRQ,
732                 .platform_data = &rx51_twldata,
733         },
734 };
735
736 /* Audio setup data */
737 static struct aic3x_setup_data rx51_aic34_setup = {
738         .gpio_func[0] = AIC3X_GPIO1_FUNC_DISABLED,
739         .gpio_func[1] = AIC3X_GPIO2_FUNC_DIGITAL_MIC_INPUT,
740 };
741
742 static struct aic3x_pdata rx51_aic3x_data = {
743         .setup = &rx51_aic34_setup,
744         .gpio_reset = 60,
745 };
746
747 static struct i2c_board_info __initdata rx51_peripherals_i2c_board_info_2[] = {
748         {
749                 I2C_BOARD_INFO("tlv320aic3x", 0x18),
750                 .platform_data = &rx51_aic3x_data,
751         },
752 #if defined(CONFIG_SENSORS_TSL2563) || defined(CONFIG_SENSORS_TSL2563_MODULE)
753         {
754                 I2C_BOARD_INFO("tsl2563", 0x29),
755                 .platform_data = &rx51_tsl2563_platform_data,
756         },
757 #endif
758         {
759                 I2C_BOARD_INFO("tpa6130a2", 0x60),
760                 .platform_data = &rx51_tpa6130a2_data,
761         }
762 };
763
764 static int __init rx51_i2c_init(void)
765 {
766         if ((system_rev >= SYSTEM_REV_S_USES_VAUX3 && system_rev < 0x100) ||
767             system_rev >= SYSTEM_REV_B_USES_VAUX3) {
768                 rx51_twldata.vaux3 = &rx51_vaux3_mmc;
769                 /* Only older boards use VMMC2 for internal MMC */
770                 rx51_vmmc2.num_consumer_supplies--;
771         } else {
772                 rx51_twldata.vaux3 = &rx51_vaux3_cam;
773         }
774         rx51_twldata.vmmc2 = &rx51_vmmc2;
775         omap_register_i2c_bus(1, 2200, rx51_peripherals_i2c_board_info_1,
776                               ARRAY_SIZE(rx51_peripherals_i2c_board_info_1));
777         omap_register_i2c_bus(2, 100, rx51_peripherals_i2c_board_info_2,
778                               ARRAY_SIZE(rx51_peripherals_i2c_board_info_2));
779         omap_register_i2c_bus(3, 400, NULL, 0);
780         return 0;
781 }
782
783 #if defined(CONFIG_MTD_ONENAND_OMAP2) || \
784         defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)
785
786 static struct mtd_partition onenand_partitions[] = {
787         {
788                 .name           = "bootloader",
789                 .offset         = 0,
790                 .size           = 0x20000,
791                 .mask_flags     = MTD_WRITEABLE,        /* Force read-only */
792         },
793         {
794                 .name           = "config",
795                 .offset         = MTDPART_OFS_APPEND,
796                 .size           = 0x60000,
797         },
798         {
799                 .name           = "log",
800                 .offset         = MTDPART_OFS_APPEND,
801                 .size           = 0x40000,
802         },
803         {
804                 .name           = "kernel",
805                 .offset         = MTDPART_OFS_APPEND,
806                 .size           = 0x200000,
807         },
808         {
809                 .name           = "initfs",
810                 .offset         = MTDPART_OFS_APPEND,
811                 .size           = 0x200000,
812         },
813         {
814                 .name           = "rootfs",
815                 .offset         = MTDPART_OFS_APPEND,
816                 .size           = MTDPART_SIZ_FULL,
817         },
818 };
819
820 static struct omap_onenand_platform_data board_onenand_data = {
821         .cs             = 0,
822         .gpio_irq       = 65,
823         .parts          = onenand_partitions,
824         .nr_parts       = ARRAY_SIZE(onenand_partitions),
825         .flags          = ONENAND_SYNC_READWRITE,
826 };
827
828 static void __init board_onenand_init(void)
829 {
830         gpmc_onenand_init(&board_onenand_data);
831 }
832
833 #else
834
835 static inline void board_onenand_init(void)
836 {
837 }
838
839 #endif
840
841 #if defined(CONFIG_SMC91X) || defined(CONFIG_SMC91X_MODULE)
842
843 static struct omap_smc91x_platform_data board_smc91x_data = {
844         .cs             = 1,
845         .gpio_irq       = 54,
846         .gpio_pwrdwn    = 86,
847         .gpio_reset     = 164,
848         .flags          = GPMC_TIMINGS_SMC91C96 | IORESOURCE_IRQ_HIGHLEVEL,
849 };
850
851 static void __init board_smc91x_init(void)
852 {
853         omap_mux_init_gpio(54, OMAP_PIN_INPUT_PULLDOWN);
854         omap_mux_init_gpio(86, OMAP_PIN_OUTPUT);
855         omap_mux_init_gpio(164, OMAP_PIN_OUTPUT);
856
857         gpmc_smc91x_init(&board_smc91x_data);
858 }
859
860 #else
861
862 static inline void board_smc91x_init(void)
863 {
864 }
865
866 #endif
867
868 static void rx51_wl1251_set_power(bool enable)
869 {
870         gpio_set_value(RX51_WL1251_POWER_GPIO, enable);
871 }
872
873 static void __init rx51_init_wl1251(void)
874 {
875         int irq, ret;
876
877         ret = gpio_request(RX51_WL1251_POWER_GPIO, "wl1251 power");
878         if (ret < 0)
879                 goto error;
880
881         ret = gpio_direction_output(RX51_WL1251_POWER_GPIO, 0);
882         if (ret < 0)
883                 goto err_power;
884
885         ret = gpio_request(RX51_WL1251_IRQ_GPIO, "wl1251 irq");
886         if (ret < 0)
887                 goto err_power;
888
889         ret = gpio_direction_input(RX51_WL1251_IRQ_GPIO);
890         if (ret < 0)
891                 goto err_irq;
892
893         irq = gpio_to_irq(RX51_WL1251_IRQ_GPIO);
894         if (irq < 0)
895                 goto err_irq;
896
897         wl1251_pdata.set_power = rx51_wl1251_set_power;
898         rx51_peripherals_spi_board_info[RX51_SPI_WL1251].irq = irq;
899
900         return;
901
902 err_irq:
903         gpio_free(RX51_WL1251_IRQ_GPIO);
904
905 err_power:
906         gpio_free(RX51_WL1251_POWER_GPIO);
907
908 error:
909         printk(KERN_ERR "wl1251 board initialisation failed\n");
910         wl1251_pdata.set_power = NULL;
911
912         /*
913          * Now rx51_peripherals_spi_board_info[1].irq is zero and
914          * set_power is null, and wl1251_probe() will fail.
915          */
916 }
917
918 void __init rx51_peripherals_init(void)
919 {
920         rx51_i2c_init();
921         board_onenand_init();
922         board_smc91x_init();
923         rx51_add_gpio_keys();
924         rx51_init_wl1251();
925         spi_register_board_info(rx51_peripherals_spi_board_info,
926                                 ARRAY_SIZE(rx51_peripherals_spi_board_info));
927
928         partition = omap_mux_get("core");
929         if (partition)
930                 omap2_hsmmc_init(mmc);
931
932         platform_device_register(&rx51_charger_device);
933 }
934