omap3: rx51: Use wl1251 in SPI mode 3
[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/spi/wl12xx.h>
18 #include <linux/i2c.h>
19 #include <linux/i2c/twl4030.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
27 #include <plat/mcspi.h>
28 #include <plat/mux.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 "mux.h"
37 #include "mmc-twl4030.h"
38
39 #define SYSTEM_REV_B_USES_VAUX3 0x1699
40 #define SYSTEM_REV_S_USES_VAUX3 0x8
41
42 #define RX51_WL1251_POWER_GPIO          87
43 #define RX51_WL1251_IRQ_GPIO            42
44
45 /* list all spi devices here */
46 enum {
47         RX51_SPI_WL1251,
48 };
49
50 static struct wl12xx_platform_data wl1251_pdata;
51
52 static struct omap2_mcspi_device_config wl1251_mcspi_config = {
53         .turbo_mode     = 0,
54         .single_channel = 1,
55 };
56
57 static struct spi_board_info rx51_peripherals_spi_board_info[] __initdata = {
58         [RX51_SPI_WL1251] = {
59                 .modalias               = "wl1251",
60                 .bus_num                = 4,
61                 .chip_select            = 0,
62                 .max_speed_hz           = 48000000,
63                 .mode                   = SPI_MODE_3,
64                 .controller_data        = &wl1251_mcspi_config,
65                 .platform_data          = &wl1251_pdata,
66         },
67 };
68
69 #if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)
70
71 #define RX51_GPIO_CAMERA_LENS_COVER     110
72 #define RX51_GPIO_CAMERA_FOCUS          68
73 #define RX51_GPIO_CAMERA_CAPTURE        69
74 #define RX51_GPIO_KEYPAD_SLIDE          71
75 #define RX51_GPIO_LOCK_BUTTON           113
76 #define RX51_GPIO_PROXIMITY             89
77
78 #define RX51_GPIO_DEBOUNCE_TIMEOUT      10
79
80 static struct gpio_keys_button rx51_gpio_keys[] = {
81         {
82                 .desc                   = "Camera Lens Cover",
83                 .type                   = EV_SW,
84                 .code                   = SW_CAMERA_LENS_COVER,
85                 .gpio                   = RX51_GPIO_CAMERA_LENS_COVER,
86                 .active_low             = 1,
87                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
88         }, {
89                 .desc                   = "Camera Focus",
90                 .type                   = EV_KEY,
91                 .code                   = KEY_CAMERA_FOCUS,
92                 .gpio                   = RX51_GPIO_CAMERA_FOCUS,
93                 .active_low             = 1,
94                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
95         }, {
96                 .desc                   = "Camera Capture",
97                 .type                   = EV_KEY,
98                 .code                   = KEY_CAMERA,
99                 .gpio                   = RX51_GPIO_CAMERA_CAPTURE,
100                 .active_low             = 1,
101                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
102         }, {
103                 .desc                   = "Lock Button",
104                 .type                   = EV_KEY,
105                 .code                   = KEY_SCREENLOCK,
106                 .gpio                   = RX51_GPIO_LOCK_BUTTON,
107                 .active_low             = 1,
108                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
109         }, {
110                 .desc                   = "Keypad Slide",
111                 .type                   = EV_SW,
112                 .code                   = SW_KEYPAD_SLIDE,
113                 .gpio                   = RX51_GPIO_KEYPAD_SLIDE,
114                 .active_low             = 1,
115                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
116         }, {
117                 .desc                   = "Proximity Sensor",
118                 .type                   = EV_SW,
119                 .code                   = SW_FRONT_PROXIMITY,
120                 .gpio                   = RX51_GPIO_PROXIMITY,
121                 .active_low             = 0,
122                 .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
123         }
124 };
125
126 static struct gpio_keys_platform_data rx51_gpio_keys_data = {
127         .buttons        = rx51_gpio_keys,
128         .nbuttons       = ARRAY_SIZE(rx51_gpio_keys),
129 };
130
131 static struct platform_device rx51_gpio_keys_device = {
132         .name   = "gpio-keys",
133         .id     = -1,
134         .dev    = {
135                 .platform_data  = &rx51_gpio_keys_data,
136         },
137 };
138
139 static void __init rx51_add_gpio_keys(void)
140 {
141         platform_device_register(&rx51_gpio_keys_device);
142 }
143 #else
144 static void __init rx51_add_gpio_keys(void)
145 {
146 }
147 #endif /* CONFIG_KEYBOARD_GPIO || CONFIG_KEYBOARD_GPIO_MODULE */
148
149 static int board_keymap[] = {
150         KEY(0, 0, KEY_Q),
151         KEY(0, 1, KEY_O),
152         KEY(0, 2, KEY_P),
153         KEY(0, 3, KEY_COMMA),
154         KEY(0, 4, KEY_BACKSPACE),
155         KEY(0, 6, KEY_A),
156         KEY(0, 7, KEY_S),
157         KEY(1, 0, KEY_W),
158         KEY(1, 1, KEY_D),
159         KEY(1, 2, KEY_F),
160         KEY(1, 3, KEY_G),
161         KEY(1, 4, KEY_H),
162         KEY(1, 5, KEY_J),
163         KEY(1, 6, KEY_K),
164         KEY(1, 7, KEY_L),
165         KEY(2, 0, KEY_E),
166         KEY(2, 1, KEY_DOT),
167         KEY(2, 2, KEY_UP),
168         KEY(2, 3, KEY_ENTER),
169         KEY(2, 5, KEY_Z),
170         KEY(2, 6, KEY_X),
171         KEY(2, 7, KEY_C),
172         KEY(3, 0, KEY_R),
173         KEY(3, 1, KEY_V),
174         KEY(3, 2, KEY_B),
175         KEY(3, 3, KEY_N),
176         KEY(3, 4, KEY_M),
177         KEY(3, 5, KEY_SPACE),
178         KEY(3, 6, KEY_SPACE),
179         KEY(3, 7, KEY_LEFT),
180         KEY(4, 0, KEY_T),
181         KEY(4, 1, KEY_DOWN),
182         KEY(4, 2, KEY_RIGHT),
183         KEY(4, 4, KEY_LEFTCTRL),
184         KEY(4, 5, KEY_RIGHTALT),
185         KEY(4, 6, KEY_LEFTSHIFT),
186         KEY(5, 0, KEY_Y),
187         KEY(6, 0, KEY_U),
188         KEY(7, 0, KEY_I),
189         KEY(7, 1, KEY_F7),
190         KEY(7, 2, KEY_F8),
191         KEY(0xff, 2, KEY_F9),
192         KEY(0xff, 4, KEY_F10),
193         KEY(0xff, 5, KEY_F11),
194 };
195
196 static struct matrix_keymap_data board_map_data = {
197         .keymap                 = board_keymap,
198         .keymap_size            = ARRAY_SIZE(board_keymap),
199 };
200
201 static struct twl4030_keypad_data rx51_kp_data = {
202         .keymap_data    = &board_map_data,
203         .rows           = 8,
204         .cols           = 8,
205         .rep            = 1,
206 };
207
208 static struct twl4030_madc_platform_data rx51_madc_data = {
209         .irq_line               = 1,
210 };
211
212 static struct twl4030_hsmmc_info mmc[] = {
213         {
214                 .name           = "external",
215                 .mmc            = 1,
216                 .wires          = 4,
217                 .cover_only     = true,
218                 .gpio_cd        = 160,
219                 .gpio_wp        = -EINVAL,
220                 .power_saving   = true,
221         },
222         {
223                 .name           = "internal",
224                 .mmc            = 2,
225                 .wires          = 8,
226                 .gpio_cd        = -EINVAL,
227                 .gpio_wp        = -EINVAL,
228                 .nonremovable   = true,
229                 .power_saving   = true,
230         },
231         {}      /* Terminator */
232 };
233
234 static struct regulator_consumer_supply rx51_vmmc1_supply = {
235         .supply                 = "vmmc",
236 };
237
238 static struct regulator_consumer_supply rx51_vmmc2_supply = {
239         .supply                 = "vmmc",
240 };
241
242 static struct regulator_consumer_supply rx51_vsim_supply = {
243         .supply                 = "vmmc_aux",
244 };
245
246 static struct regulator_init_data rx51_vaux1 = {
247         .constraints = {
248                 .name                   = "V28",
249                 .min_uV                 = 2800000,
250                 .max_uV                 = 2800000,
251                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
252                                         | REGULATOR_MODE_STANDBY,
253                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
254                                         | REGULATOR_CHANGE_STATUS,
255         },
256 };
257
258 static struct regulator_init_data rx51_vaux2 = {
259         .constraints = {
260                 .name                   = "VCSI",
261                 .min_uV                 = 1800000,
262                 .max_uV                 = 1800000,
263                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
264                                         | REGULATOR_MODE_STANDBY,
265                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
266                                         | REGULATOR_CHANGE_STATUS,
267         },
268 };
269
270 /* VAUX3 - adds more power to VIO_18 rail */
271 static struct regulator_init_data rx51_vaux3_cam = {
272         .constraints = {
273                 .name                   = "VCAM_DIG_18",
274                 .min_uV                 = 1800000,
275                 .max_uV                 = 1800000,
276                 .apply_uV               = true,
277                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
278                                         | REGULATOR_MODE_STANDBY,
279                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
280                                         | REGULATOR_CHANGE_STATUS,
281         },
282 };
283
284 static struct regulator_init_data rx51_vaux3_mmc = {
285         .constraints = {
286                 .name                   = "VMMC2_30",
287                 .min_uV                 = 2800000,
288                 .max_uV                 = 3000000,
289                 .apply_uV               = true,
290                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
291                                         | REGULATOR_MODE_STANDBY,
292                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
293                                         | REGULATOR_CHANGE_MODE
294                                         | REGULATOR_CHANGE_STATUS,
295         },
296         .num_consumer_supplies  = 1,
297         .consumer_supplies      = &rx51_vmmc2_supply,
298 };
299
300 static struct regulator_init_data rx51_vaux4 = {
301         .constraints = {
302                 .name                   = "VCAM_ANA_28",
303                 .min_uV                 = 2800000,
304                 .max_uV                 = 2800000,
305                 .apply_uV               = true,
306                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
307                                         | REGULATOR_MODE_STANDBY,
308                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
309                                         | REGULATOR_CHANGE_STATUS,
310         },
311 };
312
313 static struct regulator_init_data rx51_vmmc1 = {
314         .constraints = {
315                 .min_uV                 = 1850000,
316                 .max_uV                 = 3150000,
317                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
318                                         | REGULATOR_MODE_STANDBY,
319                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
320                                         | REGULATOR_CHANGE_MODE
321                                         | REGULATOR_CHANGE_STATUS,
322         },
323         .num_consumer_supplies  = 1,
324         .consumer_supplies      = &rx51_vmmc1_supply,
325 };
326
327 static struct regulator_init_data rx51_vmmc2 = {
328         .constraints = {
329                 .name                   = "VMMC2_30",
330                 .min_uV                 = 1850000,
331                 .max_uV                 = 3150000,
332                 .apply_uV               = true,
333                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
334                                         | REGULATOR_MODE_STANDBY,
335                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
336                                         | REGULATOR_CHANGE_MODE
337                                         | REGULATOR_CHANGE_STATUS,
338         },
339         .num_consumer_supplies  = 1,
340         .consumer_supplies      = &rx51_vmmc2_supply,
341 };
342
343 static struct regulator_init_data rx51_vsim = {
344         .constraints = {
345                 .name                   = "VMMC2_IO_18",
346                 .min_uV                 = 1800000,
347                 .max_uV                 = 1800000,
348                 .apply_uV               = true,
349                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
350                                         | REGULATOR_MODE_STANDBY,
351                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
352                                         | REGULATOR_CHANGE_STATUS,
353         },
354         .num_consumer_supplies  = 1,
355         .consumer_supplies      = &rx51_vsim_supply,
356 };
357
358 static struct regulator_init_data rx51_vdac = {
359         .constraints = {
360                 .min_uV                 = 1800000,
361                 .max_uV                 = 1800000,
362                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
363                                         | REGULATOR_MODE_STANDBY,
364                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
365                                         | REGULATOR_CHANGE_MODE
366                                         | REGULATOR_CHANGE_STATUS,
367         },
368 };
369
370 static int rx51_twlgpio_setup(struct device *dev, unsigned gpio, unsigned n)
371 {
372         /* FIXME this gpio setup is just a placeholder for now */
373         gpio_request(gpio + 6, "backlight_pwm");
374         gpio_direction_output(gpio + 6, 0);
375         gpio_request(gpio + 7, "speaker_en");
376         gpio_direction_output(gpio + 7, 1);
377
378         /* set up MMC adapters, linking their regulators to them */
379         twl4030_mmc_init(mmc);
380         rx51_vmmc1_supply.dev = mmc[0].dev;
381         rx51_vmmc2_supply.dev = mmc[1].dev;
382         rx51_vsim_supply.dev = mmc[1].dev;
383
384         return 0;
385 }
386
387 static struct twl4030_gpio_platform_data rx51_gpio_data = {
388         .gpio_base              = OMAP_MAX_GPIO_LINES,
389         .irq_base               = TWL4030_GPIO_IRQ_BASE,
390         .irq_end                = TWL4030_GPIO_IRQ_END,
391         .pulldowns              = BIT(0) | BIT(1) | BIT(2) | BIT(3)
392                                 | BIT(4) | BIT(5)
393                                 | BIT(8) | BIT(9) | BIT(10) | BIT(11)
394                                 | BIT(12) | BIT(13) | BIT(14) | BIT(15)
395                                 | BIT(16) | BIT(17) ,
396         .setup                  = rx51_twlgpio_setup,
397 };
398
399 static struct twl4030_usb_data rx51_usb_data = {
400         .usb_mode               = T2_USB_MODE_ULPI,
401 };
402
403 static struct twl4030_ins sleep_on_seq[] __initdata = {
404 /*
405  * Turn off VDD1 and VDD2.
406  */
407         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_OFF), 4},
408         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_OFF), 2},
409 /*
410  * And also turn off the OMAP3 PLLs and the sysclk output.
411  */
412         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_OFF), 3},
413         {MSG_SINGULAR(DEV_GRP_P1, 0x17, RES_STATE_OFF), 3},
414 };
415
416 static struct twl4030_script sleep_on_script __initdata = {
417         .script = sleep_on_seq,
418         .size   = ARRAY_SIZE(sleep_on_seq),
419         .flags  = TWL4030_SLEEP_SCRIPT,
420 };
421
422 static struct twl4030_ins wakeup_seq[] __initdata = {
423 /*
424  * Reenable the OMAP3 PLLs.
425  * Wakeup VDD1 and VDD2.
426  * Reenable sysclk output.
427  */
428         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_ACTIVE), 0x30},
429         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_ACTIVE), 0x30},
430         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_ACTIVE), 0x37},
431         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_ACTIVE), 3},
432 };
433
434 static struct twl4030_script wakeup_script __initdata = {
435         .script = wakeup_seq,
436         .size   = ARRAY_SIZE(wakeup_seq),
437         .flags  = TWL4030_WAKEUP12_SCRIPT,
438 };
439
440 static struct twl4030_ins wakeup_p3_seq[] __initdata = {
441 /*
442  * Wakeup VDD1 (dummy to be able to insert a delay)
443  * Enable CLKEN
444  */
445         {MSG_SINGULAR(DEV_GRP_P1, 0x17, RES_STATE_ACTIVE), 3},
446 };
447
448 static struct twl4030_script wakeup_p3_script __initdata = {
449         .script = wakeup_p3_seq,
450         .size   = ARRAY_SIZE(wakeup_p3_seq),
451         .flags  = TWL4030_WAKEUP3_SCRIPT,
452 };
453
454 static struct twl4030_ins wrst_seq[] __initdata = {
455 /*
456  * Reset twl4030.
457  * Reset VDD1 regulator.
458  * Reset VDD2 regulator.
459  * Reset VPLL1 regulator.
460  * Enable sysclk output.
461  * Reenable twl4030.
462  */
463         {MSG_SINGULAR(DEV_GRP_NULL, RES_RESET, RES_STATE_OFF), 2},
464         {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_ALL, 0, 1, RES_STATE_ACTIVE),
465                 0x13},
466         {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_PP, 0, 2, RES_STATE_WRST), 0x13},
467         {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_PP, 0, 3, RES_STATE_OFF), 0x13},
468         {MSG_SINGULAR(DEV_GRP_NULL, RES_VDD1, RES_STATE_WRST), 0x13},
469         {MSG_SINGULAR(DEV_GRP_NULL, RES_VDD2, RES_STATE_WRST), 0x13},
470         {MSG_SINGULAR(DEV_GRP_NULL, RES_VPLL1, RES_STATE_WRST), 0x35},
471         {MSG_SINGULAR(DEV_GRP_P1, RES_HFCLKOUT, RES_STATE_ACTIVE), 2},
472         {MSG_SINGULAR(DEV_GRP_NULL, RES_RESET, RES_STATE_ACTIVE), 2},
473 };
474
475 static struct twl4030_script wrst_script __initdata = {
476         .script = wrst_seq,
477         .size   = ARRAY_SIZE(wrst_seq),
478         .flags  = TWL4030_WRST_SCRIPT,
479 };
480
481 static struct twl4030_script *twl4030_scripts[] __initdata = {
482         /* wakeup12 script should be loaded before sleep script, otherwise a
483            board might hit retention before loading of wakeup script is
484            completed. This can cause boot failures depending on timing issues.
485         */
486         &wakeup_script,
487         &sleep_on_script,
488         &wakeup_p3_script,
489         &wrst_script,
490 };
491
492 static struct twl4030_resconfig twl4030_rconfig[] __initdata = {
493         { .resource = RES_VINTANA1, .devgroup = -1, .type = -1, .type2 = 1 },
494         { .resource = RES_VINTANA2, .devgroup = -1, .type = -1, .type2 = 1 },
495         { .resource = RES_VINTDIG, .devgroup = -1, .type = -1, .type2 = 1 },
496         { .resource = RES_VMMC1, .devgroup = -1, .type = -1, .type2 = 3},
497         { .resource = RES_VMMC2, .devgroup = DEV_GRP_NULL, .type = -1,
498           .type2 = 3},
499         { .resource = RES_VAUX1, .devgroup = -1, .type = -1, .type2 = 3},
500         { .resource = RES_VAUX2, .devgroup = -1, .type = -1, .type2 = 3},
501         { .resource = RES_VAUX3, .devgroup = -1, .type = -1, .type2 = 3},
502         { .resource = RES_VAUX4, .devgroup = -1, .type = -1, .type2 = 3},
503         { .resource = RES_VPLL2, .devgroup = -1, .type = -1, .type2 = 3},
504         { .resource = RES_VDAC, .devgroup = -1, .type = -1, .type2 = 3},
505         { .resource = RES_VSIM, .devgroup = DEV_GRP_NULL, .type = -1,
506           .type2 = 3},
507         { .resource = RES_CLKEN, .devgroup = DEV_GRP_P3, .type = -1,
508                 .type2 = 1 },
509         { 0, 0},
510 };
511
512 static struct twl4030_power_data rx51_t2scripts_data __initdata = {
513         .scripts        = twl4030_scripts,
514         .num = ARRAY_SIZE(twl4030_scripts),
515         .resource_config = twl4030_rconfig,
516 };
517
518
519
520 static struct twl4030_platform_data rx51_twldata __initdata = {
521         .irq_base               = TWL4030_IRQ_BASE,
522         .irq_end                = TWL4030_IRQ_END,
523
524         /* platform_data for children goes here */
525         .gpio                   = &rx51_gpio_data,
526         .keypad                 = &rx51_kp_data,
527         .madc                   = &rx51_madc_data,
528         .usb                    = &rx51_usb_data,
529         .power                  = &rx51_t2scripts_data,
530
531         .vaux1                  = &rx51_vaux1,
532         .vaux2                  = &rx51_vaux2,
533         .vaux4                  = &rx51_vaux4,
534         .vmmc1                  = &rx51_vmmc1,
535         .vsim                   = &rx51_vsim,
536         .vdac                   = &rx51_vdac,
537 };
538
539 static struct i2c_board_info __initdata rx51_peripherals_i2c_board_info_1[] = {
540         {
541                 I2C_BOARD_INFO("twl5030", 0x48),
542                 .flags = I2C_CLIENT_WAKE,
543                 .irq = INT_34XX_SYS_NIRQ,
544                 .platform_data = &rx51_twldata,
545         },
546 };
547
548 static int __init rx51_i2c_init(void)
549 {
550         if ((system_rev >= SYSTEM_REV_S_USES_VAUX3 && system_rev < 0x100) ||
551             system_rev >= SYSTEM_REV_B_USES_VAUX3)
552                 rx51_twldata.vaux3 = &rx51_vaux3_mmc;
553         else {
554                 rx51_twldata.vaux3 = &rx51_vaux3_cam;
555                 rx51_twldata.vmmc2 = &rx51_vmmc2;
556         }
557         omap_register_i2c_bus(1, 2200, rx51_peripherals_i2c_board_info_1,
558                         ARRAY_SIZE(rx51_peripherals_i2c_board_info_1));
559         omap_register_i2c_bus(2, 100, NULL, 0);
560         omap_register_i2c_bus(3, 400, NULL, 0);
561         return 0;
562 }
563
564 #if defined(CONFIG_MTD_ONENAND_OMAP2) || \
565         defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)
566
567 static struct mtd_partition onenand_partitions[] = {
568         {
569                 .name           = "bootloader",
570                 .offset         = 0,
571                 .size           = 0x20000,
572                 .mask_flags     = MTD_WRITEABLE,        /* Force read-only */
573         },
574         {
575                 .name           = "config",
576                 .offset         = MTDPART_OFS_APPEND,
577                 .size           = 0x60000,
578         },
579         {
580                 .name           = "log",
581                 .offset         = MTDPART_OFS_APPEND,
582                 .size           = 0x40000,
583         },
584         {
585                 .name           = "kernel",
586                 .offset         = MTDPART_OFS_APPEND,
587                 .size           = 0x200000,
588         },
589         {
590                 .name           = "initfs",
591                 .offset         = MTDPART_OFS_APPEND,
592                 .size           = 0x200000,
593         },
594         {
595                 .name           = "rootfs",
596                 .offset         = MTDPART_OFS_APPEND,
597                 .size           = MTDPART_SIZ_FULL,
598         },
599 };
600
601 static struct omap_onenand_platform_data board_onenand_data = {
602         .cs             = 0,
603         .gpio_irq       = 65,
604         .parts          = onenand_partitions,
605         .nr_parts       = ARRAY_SIZE(onenand_partitions),
606         .flags          = ONENAND_SYNC_READWRITE,
607 };
608
609 static void __init board_onenand_init(void)
610 {
611         gpmc_onenand_init(&board_onenand_data);
612 }
613
614 #else
615
616 static inline void board_onenand_init(void)
617 {
618 }
619
620 #endif
621
622 #if defined(CONFIG_SMC91X) || defined(CONFIG_SMC91X_MODULE)
623
624 static struct omap_smc91x_platform_data board_smc91x_data = {
625         .cs             = 1,
626         .gpio_irq       = 54,
627         .gpio_pwrdwn    = 86,
628         .gpio_reset     = 164,
629         .flags          = GPMC_TIMINGS_SMC91C96 | IORESOURCE_IRQ_HIGHLEVEL,
630 };
631
632 static void __init board_smc91x_init(void)
633 {
634         omap_mux_init_gpio(54, OMAP_PIN_INPUT_PULLDOWN);
635         omap_mux_init_gpio(86, OMAP_PIN_OUTPUT);
636         omap_mux_init_gpio(164, OMAP_PIN_OUTPUT);
637
638         gpmc_smc91x_init(&board_smc91x_data);
639 }
640
641 #else
642
643 static inline void board_smc91x_init(void)
644 {
645 }
646
647 #endif
648
649 static void rx51_wl1251_set_power(bool enable)
650 {
651         gpio_set_value(RX51_WL1251_POWER_GPIO, enable);
652 }
653
654 static void __init rx51_init_wl1251(void)
655 {
656         int irq, ret;
657
658         ret = gpio_request(RX51_WL1251_POWER_GPIO, "wl1251 power");
659         if (ret < 0)
660                 goto error;
661
662         ret = gpio_direction_output(RX51_WL1251_POWER_GPIO, 0);
663         if (ret < 0)
664                 goto err_power;
665
666         ret = gpio_request(RX51_WL1251_IRQ_GPIO, "wl1251 irq");
667         if (ret < 0)
668                 goto err_power;
669
670         ret = gpio_direction_input(RX51_WL1251_IRQ_GPIO);
671         if (ret < 0)
672                 goto err_irq;
673
674         irq = gpio_to_irq(RX51_WL1251_IRQ_GPIO);
675         if (irq < 0)
676                 goto err_irq;
677
678         wl1251_pdata.set_power = rx51_wl1251_set_power;
679         rx51_peripherals_spi_board_info[RX51_SPI_WL1251].irq = irq;
680
681         return;
682
683 err_irq:
684         gpio_free(RX51_WL1251_IRQ_GPIO);
685
686 err_power:
687         gpio_free(RX51_WL1251_POWER_GPIO);
688
689 error:
690         printk(KERN_ERR "wl1251 board initialisation failed\n");
691         wl1251_pdata.set_power = NULL;
692
693         /*
694          * Now rx51_peripherals_spi_board_info[1].irq is zero and
695          * set_power is null, and wl1251_probe() will fail.
696          */
697 }
698
699 void __init rx51_peripherals_init(void)
700 {
701         rx51_i2c_init();
702         board_onenand_init();
703         board_smc91x_init();
704         rx51_add_gpio_keys();
705         rx51_init_wl1251();
706         spi_register_board_info(rx51_peripherals_spi_board_info,
707                                 ARRAY_SIZE(rx51_peripherals_spi_board_info));
708 }
709