c06eb423c4e4456bed2d8e09c4f515201101dffa
[linux-3.10.git] / arch / arm / mach-omap2 / board-3430sdp.c
1 /*
2  * linux/arch/arm/mach-omap2/board-3430sdp.c
3  *
4  * Copyright (C) 2007 Texas Instruments
5  *
6  * Modified from mach-omap2/board-generic.c
7  *
8  * Initial code: Syed Mohammed Khasim
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/platform_device.h>
18 #include <linux/delay.h>
19 #include <linux/input.h>
20 #include <linux/input/matrix_keypad.h>
21 #include <linux/spi/spi.h>
22 #include <linux/spi/ads7846.h>
23 #include <linux/i2c/twl.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/io.h>
26 #include <linux/gpio.h>
27 #include <linux/mmc/host.h>
28
29 #include <mach/hardware.h>
30 #include <asm/mach-types.h>
31 #include <asm/mach/arch.h>
32 #include <asm/mach/map.h>
33
34 #include <plat/mcspi.h>
35 #include <plat/board.h>
36 #include <plat/usb.h>
37 #include <plat/common.h>
38 #include <plat/dma.h>
39 #include <plat/gpmc.h>
40 #include <plat/display.h>
41 #include <plat/panel-generic-dpi.h>
42
43 #include <plat/gpmc-smc91x.h>
44
45 #include "board-flash.h"
46 #include "mux.h"
47 #include "sdram-qimonda-hyb18m512160af-6.h"
48 #include "hsmmc.h"
49 #include "pm.h"
50 #include "control.h"
51
52 #define CONFIG_DISABLE_HFCLK 1
53
54 #define SDP3430_TS_GPIO_IRQ_SDPV1       3
55 #define SDP3430_TS_GPIO_IRQ_SDPV2       2
56
57 #define ENABLE_VAUX3_DEDICATED  0x03
58 #define ENABLE_VAUX3_DEV_GRP    0x20
59
60 #define TWL4030_MSECURE_GPIO 22
61
62 /* FIXME: These values need to be updated based on more profiling on 3430sdp*/
63 static struct cpuidle_params omap3_cpuidle_params_table[] = {
64         /* C1 */
65         {1, 2, 2, 5},
66         /* C2 */
67         {1, 10, 10, 30},
68         /* C3 */
69         {1, 50, 50, 300},
70         /* C4 */
71         {1, 1500, 1800, 4000},
72         /* C5 */
73         {1, 2500, 7500, 12000},
74         /* C6 */
75         {1, 3000, 8500, 15000},
76         /* C7 */
77         {1, 10000, 30000, 300000},
78 };
79
80 static uint32_t board_keymap[] = {
81         KEY(0, 0, KEY_LEFT),
82         KEY(0, 1, KEY_RIGHT),
83         KEY(0, 2, KEY_A),
84         KEY(0, 3, KEY_B),
85         KEY(0, 4, KEY_C),
86         KEY(1, 0, KEY_DOWN),
87         KEY(1, 1, KEY_UP),
88         KEY(1, 2, KEY_E),
89         KEY(1, 3, KEY_F),
90         KEY(1, 4, KEY_G),
91         KEY(2, 0, KEY_ENTER),
92         KEY(2, 1, KEY_I),
93         KEY(2, 2, KEY_J),
94         KEY(2, 3, KEY_K),
95         KEY(2, 4, KEY_3),
96         KEY(3, 0, KEY_M),
97         KEY(3, 1, KEY_N),
98         KEY(3, 2, KEY_O),
99         KEY(3, 3, KEY_P),
100         KEY(3, 4, KEY_Q),
101         KEY(4, 0, KEY_R),
102         KEY(4, 1, KEY_4),
103         KEY(4, 2, KEY_T),
104         KEY(4, 3, KEY_U),
105         KEY(4, 4, KEY_D),
106         KEY(5, 0, KEY_V),
107         KEY(5, 1, KEY_W),
108         KEY(5, 2, KEY_L),
109         KEY(5, 3, KEY_S),
110         KEY(5, 4, KEY_H),
111         0
112 };
113
114 static struct matrix_keymap_data board_map_data = {
115         .keymap                 = board_keymap,
116         .keymap_size            = ARRAY_SIZE(board_keymap),
117 };
118
119 static struct twl4030_keypad_data sdp3430_kp_data = {
120         .keymap_data    = &board_map_data,
121         .rows           = 5,
122         .cols           = 6,
123         .rep            = 1,
124 };
125
126 static int ts_gpio;     /* Needed for ads7846_get_pendown_state */
127
128 /**
129  * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
130  *
131  * @return - void. If request gpio fails then Flag KERN_ERR.
132  */
133 static void ads7846_dev_init(void)
134 {
135         if (gpio_request(ts_gpio, "ADS7846 pendown") < 0) {
136                 printk(KERN_ERR "can't get ads746 pen down GPIO\n");
137                 return;
138         }
139
140         gpio_direction_input(ts_gpio);
141         gpio_set_debounce(ts_gpio, 310);
142 }
143
144 static int ads7846_get_pendown_state(void)
145 {
146         return !gpio_get_value(ts_gpio);
147 }
148
149 static struct ads7846_platform_data tsc2046_config __initdata = {
150         .get_pendown_state      = ads7846_get_pendown_state,
151         .keep_vref_on           = 1,
152         .wakeup                         = true,
153 };
154
155
156 static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
157         .turbo_mode     = 0,
158         .single_channel = 1,    /* 0: slave, 1: master */
159 };
160
161 static struct spi_board_info sdp3430_spi_board_info[] __initdata = {
162         [0] = {
163                 /*
164                  * TSC2046 operates at a max freqency of 2MHz, so
165                  * operate slightly below at 1.5MHz
166                  */
167                 .modalias               = "ads7846",
168                 .bus_num                = 1,
169                 .chip_select            = 0,
170                 .max_speed_hz           = 1500000,
171                 .controller_data        = &tsc2046_mcspi_config,
172                 .irq                    = 0,
173                 .platform_data          = &tsc2046_config,
174         },
175 };
176
177
178 #define SDP3430_LCD_PANEL_BACKLIGHT_GPIO        8
179 #define SDP3430_LCD_PANEL_ENABLE_GPIO           5
180
181 static unsigned backlight_gpio;
182 static unsigned enable_gpio;
183 static int lcd_enabled;
184 static int dvi_enabled;
185
186 static void __init sdp3430_display_init(void)
187 {
188         int r;
189
190         enable_gpio    = SDP3430_LCD_PANEL_ENABLE_GPIO;
191         backlight_gpio = SDP3430_LCD_PANEL_BACKLIGHT_GPIO;
192
193         r = gpio_request(enable_gpio, "LCD reset");
194         if (r) {
195                 printk(KERN_ERR "failed to get LCD reset GPIO\n");
196                 goto err0;
197         }
198
199         r = gpio_request(backlight_gpio, "LCD Backlight");
200         if (r) {
201                 printk(KERN_ERR "failed to get LCD backlight GPIO\n");
202                 goto err1;
203         }
204
205         gpio_direction_output(enable_gpio, 0);
206         gpio_direction_output(backlight_gpio, 0);
207
208         return;
209 err1:
210         gpio_free(enable_gpio);
211 err0:
212         return;
213 }
214
215 static int sdp3430_panel_enable_lcd(struct omap_dss_device *dssdev)
216 {
217         if (dvi_enabled) {
218                 printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
219                 return -EINVAL;
220         }
221
222         gpio_direction_output(enable_gpio, 1);
223         gpio_direction_output(backlight_gpio, 1);
224
225         lcd_enabled = 1;
226
227         return 0;
228 }
229
230 static void sdp3430_panel_disable_lcd(struct omap_dss_device *dssdev)
231 {
232         lcd_enabled = 0;
233
234         gpio_direction_output(enable_gpio, 0);
235         gpio_direction_output(backlight_gpio, 0);
236 }
237
238 static int sdp3430_panel_enable_dvi(struct omap_dss_device *dssdev)
239 {
240         if (lcd_enabled) {
241                 printk(KERN_ERR "cannot enable DVI, LCD is enabled\n");
242                 return -EINVAL;
243         }
244
245         dvi_enabled = 1;
246
247         return 0;
248 }
249
250 static void sdp3430_panel_disable_dvi(struct omap_dss_device *dssdev)
251 {
252         dvi_enabled = 0;
253 }
254
255 static int sdp3430_panel_enable_tv(struct omap_dss_device *dssdev)
256 {
257         return 0;
258 }
259
260 static void sdp3430_panel_disable_tv(struct omap_dss_device *dssdev)
261 {
262 }
263
264
265 static struct omap_dss_device sdp3430_lcd_device = {
266         .name                   = "lcd",
267         .driver_name            = "sharp_ls_panel",
268         .type                   = OMAP_DISPLAY_TYPE_DPI,
269         .phy.dpi.data_lines     = 16,
270         .platform_enable        = sdp3430_panel_enable_lcd,
271         .platform_disable       = sdp3430_panel_disable_lcd,
272 };
273
274 static struct panel_generic_dpi_data dvi_panel = {
275         .name                   = "generic",
276         .platform_enable        = sdp3430_panel_enable_dvi,
277         .platform_disable       = sdp3430_panel_disable_dvi,
278 };
279
280 static struct omap_dss_device sdp3430_dvi_device = {
281         .name                   = "dvi",
282         .type                   = OMAP_DISPLAY_TYPE_DPI,
283         .driver_name            = "generic_dpi_panel",
284         .data                   = &dvi_panel,
285         .phy.dpi.data_lines     = 24,
286 };
287
288 static struct omap_dss_device sdp3430_tv_device = {
289         .name                   = "tv",
290         .driver_name            = "venc",
291         .type                   = OMAP_DISPLAY_TYPE_VENC,
292         .phy.venc.type          = OMAP_DSS_VENC_TYPE_SVIDEO,
293         .platform_enable        = sdp3430_panel_enable_tv,
294         .platform_disable       = sdp3430_panel_disable_tv,
295 };
296
297
298 static struct omap_dss_device *sdp3430_dss_devices[] = {
299         &sdp3430_lcd_device,
300         &sdp3430_dvi_device,
301         &sdp3430_tv_device,
302 };
303
304 static struct omap_dss_board_info sdp3430_dss_data = {
305         .num_devices    = ARRAY_SIZE(sdp3430_dss_devices),
306         .devices        = sdp3430_dss_devices,
307         .default_device = &sdp3430_lcd_device,
308 };
309
310 static struct regulator_consumer_supply sdp3430_vdda_dac_supply =
311         REGULATOR_SUPPLY("vdda_dac", "omapdss");
312
313 static struct omap_board_config_kernel sdp3430_config[] __initdata = {
314 };
315
316 static void __init omap_3430sdp_init_early(void)
317 {
318         omap2_init_common_infrastructure();
319         omap2_init_common_devices(hyb18m512160af6_sdrc_params, NULL);
320 }
321
322 static int sdp3430_batt_table[] = {
323 /* 0 C*/
324 30800, 29500, 28300, 27100,
325 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
326 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
327 11600, 11200, 10800, 10400, 10000, 9630,   9280,   8950,   8620,   8310,
328 8020,   7730,   7460,   7200,   6950,   6710,   6470,   6250,   6040,   5830,
329 5640,   5450,   5260,   5090,   4920,   4760,   4600,   4450,   4310,   4170,
330 4040,   3910,   3790,   3670,   3550
331 };
332
333 static struct twl4030_bci_platform_data sdp3430_bci_data = {
334         .battery_tmp_tbl        = sdp3430_batt_table,
335         .tblsize                = ARRAY_SIZE(sdp3430_batt_table),
336 };
337
338 static struct omap2_hsmmc_info mmc[] = {
339         {
340                 .mmc            = 1,
341                 /* 8 bits (default) requires S6.3 == ON,
342                  * so the SIM card isn't used; else 4 bits.
343                  */
344                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
345                 .gpio_wp        = 4,
346         },
347         {
348                 .mmc            = 2,
349                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
350                 .gpio_wp        = 7,
351         },
352         {}      /* Terminator */
353 };
354
355 static int sdp3430_twl_gpio_setup(struct device *dev,
356                 unsigned gpio, unsigned ngpio)
357 {
358         /* gpio + 0 is "mmc0_cd" (input/IRQ),
359          * gpio + 1 is "mmc1_cd" (input/IRQ)
360          */
361         mmc[0].gpio_cd = gpio + 0;
362         mmc[1].gpio_cd = gpio + 1;
363         omap2_hsmmc_init(mmc);
364
365         /* gpio + 7 is "sub_lcd_en_bkl" (output/PWM1) */
366         gpio_request(gpio + 7, "sub_lcd_en_bkl");
367         gpio_direction_output(gpio + 7, 0);
368
369         /* gpio + 15 is "sub_lcd_nRST" (output) */
370         gpio_request(gpio + 15, "sub_lcd_nRST");
371         gpio_direction_output(gpio + 15, 0);
372
373         return 0;
374 }
375
376 static struct twl4030_gpio_platform_data sdp3430_gpio_data = {
377         .gpio_base      = OMAP_MAX_GPIO_LINES,
378         .irq_base       = TWL4030_GPIO_IRQ_BASE,
379         .irq_end        = TWL4030_GPIO_IRQ_END,
380         .pulldowns      = BIT(2) | BIT(6) | BIT(8) | BIT(13)
381                                 | BIT(16) | BIT(17),
382         .setup          = sdp3430_twl_gpio_setup,
383 };
384
385 static struct twl4030_usb_data sdp3430_usb_data = {
386         .usb_mode       = T2_USB_MODE_ULPI,
387 };
388
389 static struct twl4030_madc_platform_data sdp3430_madc_data = {
390         .irq_line       = 1,
391 };
392
393 /* regulator consumer mappings */
394
395 /* ads7846 on SPI */
396 static struct regulator_consumer_supply sdp3430_vaux3_supplies[] = {
397         REGULATOR_SUPPLY("vcc", "spi1.0"),
398 };
399
400 static struct regulator_consumer_supply sdp3430_vdda_dac_supplies[] = {
401         REGULATOR_SUPPLY("vdda_dac", "omapdss"),
402 };
403
404 /* VPLL2 for digital video outputs */
405 static struct regulator_consumer_supply sdp3430_vpll2_supplies[] = {
406         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
407 };
408
409 static struct regulator_consumer_supply sdp3430_vmmc1_supplies[] = {
410         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
411 };
412
413 static struct regulator_consumer_supply sdp3430_vsim_supplies[] = {
414         REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.0"),
415 };
416
417 static struct regulator_consumer_supply sdp3430_vmmc2_supplies[] = {
418         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
419 };
420
421 /*
422  * Apply all the fixed voltages since most versions of U-Boot
423  * don't bother with that initialization.
424  */
425
426 /* VAUX1 for mainboard (irda and sub-lcd) */
427 static struct regulator_init_data sdp3430_vaux1 = {
428         .constraints = {
429                 .min_uV                 = 2800000,
430                 .max_uV                 = 2800000,
431                 .apply_uV               = true,
432                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
433                                         | REGULATOR_MODE_STANDBY,
434                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
435                                         | REGULATOR_CHANGE_STATUS,
436         },
437 };
438
439 /* VAUX2 for camera module */
440 static struct regulator_init_data sdp3430_vaux2 = {
441         .constraints = {
442                 .min_uV                 = 2800000,
443                 .max_uV                 = 2800000,
444                 .apply_uV               = true,
445                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
446                                         | REGULATOR_MODE_STANDBY,
447                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
448                                         | REGULATOR_CHANGE_STATUS,
449         },
450 };
451
452 /* VAUX3 for LCD board */
453 static struct regulator_init_data sdp3430_vaux3 = {
454         .constraints = {
455                 .min_uV                 = 2800000,
456                 .max_uV                 = 2800000,
457                 .apply_uV               = true,
458                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
459                                         | REGULATOR_MODE_STANDBY,
460                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
461                                         | REGULATOR_CHANGE_STATUS,
462         },
463         .num_consumer_supplies          = ARRAY_SIZE(sdp3430_vaux3_supplies),
464         .consumer_supplies              = sdp3430_vaux3_supplies,
465 };
466
467 /* VAUX4 for OMAP VDD_CSI2 (camera) */
468 static struct regulator_init_data sdp3430_vaux4 = {
469         .constraints = {
470                 .min_uV                 = 1800000,
471                 .max_uV                 = 1800000,
472                 .apply_uV               = true,
473                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
474                                         | REGULATOR_MODE_STANDBY,
475                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
476                                         | REGULATOR_CHANGE_STATUS,
477         },
478 };
479
480 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
481 static struct regulator_init_data sdp3430_vmmc1 = {
482         .constraints = {
483                 .min_uV                 = 1850000,
484                 .max_uV                 = 3150000,
485                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
486                                         | REGULATOR_MODE_STANDBY,
487                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
488                                         | REGULATOR_CHANGE_MODE
489                                         | REGULATOR_CHANGE_STATUS,
490         },
491         .num_consumer_supplies  = ARRAY_SIZE(sdp3430_vmmc1_supplies),
492         .consumer_supplies      = sdp3430_vmmc1_supplies,
493 };
494
495 /* VMMC2 for MMC2 card */
496 static struct regulator_init_data sdp3430_vmmc2 = {
497         .constraints = {
498                 .min_uV                 = 1850000,
499                 .max_uV                 = 1850000,
500                 .apply_uV               = true,
501                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
502                                         | REGULATOR_MODE_STANDBY,
503                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
504                                         | REGULATOR_CHANGE_STATUS,
505         },
506         .num_consumer_supplies  = ARRAY_SIZE(sdp3430_vmmc2_supplies),
507         .consumer_supplies      = sdp3430_vmmc2_supplies,
508 };
509
510 /* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
511 static struct regulator_init_data sdp3430_vsim = {
512         .constraints = {
513                 .min_uV                 = 1800000,
514                 .max_uV                 = 3000000,
515                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
516                                         | REGULATOR_MODE_STANDBY,
517                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
518                                         | REGULATOR_CHANGE_MODE
519                                         | REGULATOR_CHANGE_STATUS,
520         },
521         .num_consumer_supplies  = ARRAY_SIZE(sdp3430_vsim_supplies),
522         .consumer_supplies      = sdp3430_vsim_supplies,
523 };
524
525 /* VDAC for DSS driving S-Video */
526 static struct regulator_init_data sdp3430_vdac = {
527         .constraints = {
528                 .min_uV                 = 1800000,
529                 .max_uV                 = 1800000,
530                 .apply_uV               = true,
531                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
532                                         | REGULATOR_MODE_STANDBY,
533                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
534                                         | REGULATOR_CHANGE_STATUS,
535         },
536         .num_consumer_supplies  = ARRAY_SIZE(sdp3430_vdda_dac_supplies),
537         .consumer_supplies      = sdp3430_vdda_dac_supplies,
538 };
539
540 static struct regulator_init_data sdp3430_vpll2 = {
541         .constraints = {
542                 .name                   = "VDVI",
543                 .min_uV                 = 1800000,
544                 .max_uV                 = 1800000,
545                 .apply_uV               = true,
546                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
547                                         | REGULATOR_MODE_STANDBY,
548                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
549                                         | REGULATOR_CHANGE_STATUS,
550         },
551         .num_consumer_supplies  = ARRAY_SIZE(sdp3430_vpll2_supplies),
552         .consumer_supplies      = sdp3430_vpll2_supplies,
553 };
554
555 static struct twl4030_codec_audio_data sdp3430_audio;
556
557 static struct twl4030_codec_data sdp3430_codec = {
558         .audio_mclk = 26000000,
559         .audio = &sdp3430_audio,
560 };
561
562 static struct twl4030_platform_data sdp3430_twldata = {
563         .irq_base       = TWL4030_IRQ_BASE,
564         .irq_end        = TWL4030_IRQ_END,
565
566         /* platform_data for children goes here */
567         .bci            = &sdp3430_bci_data,
568         .gpio           = &sdp3430_gpio_data,
569         .madc           = &sdp3430_madc_data,
570         .keypad         = &sdp3430_kp_data,
571         .usb            = &sdp3430_usb_data,
572         .codec          = &sdp3430_codec,
573
574         .vaux1          = &sdp3430_vaux1,
575         .vaux2          = &sdp3430_vaux2,
576         .vaux3          = &sdp3430_vaux3,
577         .vaux4          = &sdp3430_vaux4,
578         .vmmc1          = &sdp3430_vmmc1,
579         .vmmc2          = &sdp3430_vmmc2,
580         .vsim           = &sdp3430_vsim,
581         .vdac           = &sdp3430_vdac,
582         .vpll2          = &sdp3430_vpll2,
583 };
584
585 static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
586         {
587                 I2C_BOARD_INFO("twl4030", 0x48),
588                 .flags = I2C_CLIENT_WAKE,
589                 .irq = INT_34XX_SYS_NIRQ,
590                 .platform_data = &sdp3430_twldata,
591         },
592 };
593
594 static int __init omap3430_i2c_init(void)
595 {
596         /* i2c1 for PMIC only */
597         omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
598                         ARRAY_SIZE(sdp3430_i2c_boardinfo));
599         /* i2c2 on camera connector (for sensor control) and optional isp1301 */
600         omap_register_i2c_bus(2, 400, NULL, 0);
601         /* i2c3 on display connector (for DVI, tfp410) */
602         omap_register_i2c_bus(3, 400, NULL, 0);
603         return 0;
604 }
605
606 #if defined(CONFIG_SMC91X) || defined(CONFIG_SMC91X_MODULE)
607
608 static struct omap_smc91x_platform_data board_smc91x_data = {
609         .cs             = 3,
610         .flags          = GPMC_MUX_ADD_DATA | GPMC_TIMINGS_SMC91C96 |
611                                 IORESOURCE_IRQ_LOWLEVEL,
612 };
613
614 static void __init board_smc91x_init(void)
615 {
616         if (omap_rev() > OMAP3430_REV_ES1_0)
617                 board_smc91x_data.gpio_irq = 6;
618         else
619                 board_smc91x_data.gpio_irq = 29;
620
621         gpmc_smc91x_init(&board_smc91x_data);
622 }
623
624 #else
625
626 static inline void board_smc91x_init(void)
627 {
628 }
629
630 #endif
631
632 static void enable_board_wakeup_source(void)
633 {
634         /* T2 interrupt line (keypad) */
635         omap_mux_init_signal("sys_nirq",
636                 OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
637 }
638
639 static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
640
641         .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
642         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
643         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
644
645         .phy_reset  = true,
646         .reset_gpio_port[0]  = 57,
647         .reset_gpio_port[1]  = 61,
648         .reset_gpio_port[2]  = -EINVAL
649 };
650
651 #ifdef CONFIG_OMAP_MUX
652 static struct omap_board_mux board_mux[] __initdata = {
653         { .reg_offset = OMAP_MUX_TERMINATOR },
654 };
655
656 static struct omap_device_pad serial1_pads[] __initdata = {
657         /*
658          * Note that off output enable is an active low
659          * signal. So setting this means pin is a
660          * input enabled in off mode
661          */
662         OMAP_MUX_STATIC("uart1_cts.uart1_cts",
663                          OMAP_PIN_INPUT |
664                          OMAP_PIN_OFF_INPUT_PULLDOWN |
665                          OMAP_OFFOUT_EN |
666                          OMAP_MUX_MODE0),
667         OMAP_MUX_STATIC("uart1_rts.uart1_rts",
668                          OMAP_PIN_OUTPUT |
669                          OMAP_OFF_EN |
670                          OMAP_MUX_MODE0),
671         OMAP_MUX_STATIC("uart1_rx.uart1_rx",
672                          OMAP_PIN_INPUT |
673                          OMAP_PIN_OFF_INPUT_PULLDOWN |
674                          OMAP_OFFOUT_EN |
675                          OMAP_MUX_MODE0),
676         OMAP_MUX_STATIC("uart1_tx.uart1_tx",
677                          OMAP_PIN_OUTPUT |
678                          OMAP_OFF_EN |
679                          OMAP_MUX_MODE0),
680 };
681
682 static struct omap_device_pad serial2_pads[] __initdata = {
683         OMAP_MUX_STATIC("uart2_cts.uart2_cts",
684                          OMAP_PIN_INPUT_PULLUP |
685                          OMAP_PIN_OFF_INPUT_PULLDOWN |
686                          OMAP_OFFOUT_EN |
687                          OMAP_MUX_MODE0),
688         OMAP_MUX_STATIC("uart2_rts.uart2_rts",
689                          OMAP_PIN_OUTPUT |
690                          OMAP_OFF_EN |
691                          OMAP_MUX_MODE0),
692         OMAP_MUX_STATIC("uart2_rx.uart2_rx",
693                          OMAP_PIN_INPUT |
694                          OMAP_PIN_OFF_INPUT_PULLDOWN |
695                          OMAP_OFFOUT_EN |
696                          OMAP_MUX_MODE0),
697         OMAP_MUX_STATIC("uart2_tx.uart2_tx",
698                          OMAP_PIN_OUTPUT |
699                          OMAP_OFF_EN |
700                          OMAP_MUX_MODE0),
701 };
702
703 static struct omap_device_pad serial3_pads[] __initdata = {
704         OMAP_MUX_STATIC("uart3_cts_rctx.uart3_cts_rctx",
705                          OMAP_PIN_INPUT_PULLDOWN |
706                          OMAP_PIN_OFF_INPUT_PULLDOWN |
707                          OMAP_OFFOUT_EN |
708                          OMAP_MUX_MODE0),
709         OMAP_MUX_STATIC("uart3_rts_sd.uart3_rts_sd",
710                          OMAP_PIN_OUTPUT |
711                          OMAP_OFF_EN |
712                          OMAP_MUX_MODE0),
713         OMAP_MUX_STATIC("uart3_rx_irrx.uart3_rx_irrx",
714                          OMAP_PIN_INPUT |
715                          OMAP_PIN_OFF_INPUT_PULLDOWN |
716                          OMAP_OFFOUT_EN |
717                          OMAP_MUX_MODE0),
718         OMAP_MUX_STATIC("uart3_tx_irtx.uart3_tx_irtx",
719                          OMAP_PIN_OUTPUT |
720                          OMAP_OFF_EN |
721                          OMAP_MUX_MODE0),
722 };
723
724 static struct omap_board_data serial1_data = {
725         .id             = 0,
726         .pads           = serial1_pads,
727         .pads_cnt       = ARRAY_SIZE(serial1_pads),
728 };
729
730 static struct omap_board_data serial2_data = {
731         .id             = 1,
732         .pads           = serial2_pads,
733         .pads_cnt       = ARRAY_SIZE(serial2_pads),
734 };
735
736 static struct omap_board_data serial3_data = {
737         .id             = 2,
738         .pads           = serial3_pads,
739         .pads_cnt       = ARRAY_SIZE(serial3_pads),
740 };
741
742 static inline void board_serial_init(void)
743 {
744         omap_serial_init_port(&serial1_data);
745         omap_serial_init_port(&serial2_data);
746         omap_serial_init_port(&serial3_data);
747 }
748 #else
749 #define board_mux       NULL
750
751 static inline void board_serial_init(void)
752 {
753         omap_serial_init();
754 }
755 #endif
756
757 /*
758  * SDP3430 V2 Board CS organization
759  * Different from SDP3430 V1. Now 4 switches used to specify CS
760  *
761  * See also the Switch S8 settings in the comments.
762  */
763 static char chip_sel_3430[][GPMC_CS_NUM] = {
764         {PDC_NOR, PDC_NAND, PDC_ONENAND, DBG_MPDB, 0, 0, 0, 0}, /* S8:1111 */
765         {PDC_ONENAND, PDC_NAND, PDC_NOR, DBG_MPDB, 0, 0, 0, 0}, /* S8:1110 */
766         {PDC_NAND, PDC_ONENAND, PDC_NOR, DBG_MPDB, 0, 0, 0, 0}, /* S8:1101 */
767 };
768
769 static struct mtd_partition sdp_nor_partitions[] = {
770         /* bootloader (U-Boot, etc) in first sector */
771         {
772                 .name           = "Bootloader-NOR",
773                 .offset         = 0,
774                 .size           = SZ_256K,
775                 .mask_flags     = MTD_WRITEABLE, /* force read-only */
776         },
777         /* bootloader params in the next sector */
778         {
779                 .name           = "Params-NOR",
780                 .offset         = MTDPART_OFS_APPEND,
781                 .size           = SZ_256K,
782                 .mask_flags     = 0,
783         },
784         /* kernel */
785         {
786                 .name           = "Kernel-NOR",
787                 .offset         = MTDPART_OFS_APPEND,
788                 .size           = SZ_2M,
789                 .mask_flags     = 0
790         },
791         /* file system */
792         {
793                 .name           = "Filesystem-NOR",
794                 .offset         = MTDPART_OFS_APPEND,
795                 .size           = MTDPART_SIZ_FULL,
796                 .mask_flags     = 0
797         }
798 };
799
800 static struct mtd_partition sdp_onenand_partitions[] = {
801         {
802                 .name           = "X-Loader-OneNAND",
803                 .offset         = 0,
804                 .size           = 4 * (64 * 2048),
805                 .mask_flags     = MTD_WRITEABLE  /* force read-only */
806         },
807         {
808                 .name           = "U-Boot-OneNAND",
809                 .offset         = MTDPART_OFS_APPEND,
810                 .size           = 2 * (64 * 2048),
811                 .mask_flags     = MTD_WRITEABLE  /* force read-only */
812         },
813         {
814                 .name           = "U-Boot Environment-OneNAND",
815                 .offset         = MTDPART_OFS_APPEND,
816                 .size           = 1 * (64 * 2048),
817         },
818         {
819                 .name           = "Kernel-OneNAND",
820                 .offset         = MTDPART_OFS_APPEND,
821                 .size           = 16 * (64 * 2048),
822         },
823         {
824                 .name           = "File System-OneNAND",
825                 .offset         = MTDPART_OFS_APPEND,
826                 .size           = MTDPART_SIZ_FULL,
827         },
828 };
829
830 static struct mtd_partition sdp_nand_partitions[] = {
831         /* All the partition sizes are listed in terms of NAND block size */
832         {
833                 .name           = "X-Loader-NAND",
834                 .offset         = 0,
835                 .size           = 4 * (64 * 2048),
836                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
837         },
838         {
839                 .name           = "U-Boot-NAND",
840                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x80000 */
841                 .size           = 10 * (64 * 2048),
842                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
843         },
844         {
845                 .name           = "Boot Env-NAND",
846
847                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x1c0000 */
848                 .size           = 6 * (64 * 2048),
849         },
850         {
851                 .name           = "Kernel-NAND",
852                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x280000 */
853                 .size           = 40 * (64 * 2048),
854         },
855         {
856                 .name           = "File System - NAND",
857                 .size           = MTDPART_SIZ_FULL,
858                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x780000 */
859         },
860 };
861
862 static struct flash_partitions sdp_flash_partitions[] = {
863         {
864                 .parts = sdp_nor_partitions,
865                 .nr_parts = ARRAY_SIZE(sdp_nor_partitions),
866         },
867         {
868                 .parts = sdp_onenand_partitions,
869                 .nr_parts = ARRAY_SIZE(sdp_onenand_partitions),
870         },
871         {
872                 .parts = sdp_nand_partitions,
873                 .nr_parts = ARRAY_SIZE(sdp_nand_partitions),
874         },
875 };
876
877 static struct omap_musb_board_data musb_board_data = {
878         .interface_type         = MUSB_INTERFACE_ULPI,
879         .mode                   = MUSB_OTG,
880         .power                  = 100,
881 };
882
883 static void __init omap_3430sdp_init(void)
884 {
885         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
886         omap_board_config = sdp3430_config;
887         omap_board_config_size = ARRAY_SIZE(sdp3430_config);
888         omap3_pm_init_cpuidle(omap3_cpuidle_params_table);
889         omap3430_i2c_init();
890         omap_display_init(&sdp3430_dss_data);
891         if (omap_rev() > OMAP3430_REV_ES1_0)
892                 ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV2;
893         else
894                 ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV1;
895         sdp3430_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
896         spi_register_board_info(sdp3430_spi_board_info,
897                                 ARRAY_SIZE(sdp3430_spi_board_info));
898         ads7846_dev_init();
899         board_serial_init();
900         usb_musb_init(&musb_board_data);
901         board_smc91x_init();
902         board_flash_init(sdp_flash_partitions, chip_sel_3430, 0);
903         sdp3430_display_init();
904         enable_board_wakeup_source();
905         usbhs_init(&usbhs_bdata);
906 }
907
908 MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
909         /* Maintainer: Syed Khasim - Texas Instruments Inc */
910         .boot_params    = 0x80000100,
911         .reserve        = omap_reserve,
912         .map_io         = omap3_map_io,
913         .init_early     = omap_3430sdp_init_early,
914         .init_irq       = omap_init_irq,
915         .init_machine   = omap_3430sdp_init,
916         .timer          = &omap_timer,
917 MACHINE_END