atmel_lcdfb: fix usage of CONTRAST_CTR in suspend/resume
[~shefty/rdma-dev.git] / arch / arm / mach-omap2 / board-4430sdp.c
1 /*
2  * Board support file for OMAP4430 SDP.
3  *
4  * Copyright (C) 2009 Texas Instruments
5  *
6  * Author: Santosh Shilimkar <santosh.shilimkar@ti.com>
7  *
8  * Based on mach-omap2/board-3430sdp.c
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/io.h>
19 #include <linux/gpio.h>
20 #include <linux/usb/otg.h>
21 #include <linux/spi/spi.h>
22 #include <linux/i2c/twl.h>
23 #include <linux/gpio_keys.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/regulator/fixed.h>
26 #include <linux/leds.h>
27 #include <linux/leds_pwm.h>
28
29 #include <mach/hardware.h>
30 #include <mach/omap4-common.h>
31 #include <asm/mach-types.h>
32 #include <asm/mach/arch.h>
33 #include <asm/mach/map.h>
34
35 #include <plat/board.h>
36 #include <plat/common.h>
37 #include <plat/usb.h>
38 #include <plat/mmc.h>
39 #include <plat/omap4-keypad.h>
40 #include <video/omapdss.h>
41 #include <video/omap-panel-nokia-dsi.h>
42 #include <video/omap-panel-picodlp.h>
43 #include <linux/wl12xx.h>
44
45 #include "mux.h"
46 #include "hsmmc.h"
47 #include "control.h"
48 #include "common-board-devices.h"
49
50 #define ETH_KS8851_IRQ                  34
51 #define ETH_KS8851_POWER_ON             48
52 #define ETH_KS8851_QUART                138
53 #define OMAP4_SFH7741_SENSOR_OUTPUT_GPIO        184
54 #define OMAP4_SFH7741_ENABLE_GPIO               188
55 #define HDMI_GPIO_CT_CP_HPD 60 /* HPD mode enable/disable */
56 #define HDMI_GPIO_LS_OE 41 /* Level shifter for HDMI */
57 #define HDMI_GPIO_HPD  63 /* Hotplug detect */
58 #define DISPLAY_SEL_GPIO        59      /* LCD2/PicoDLP switch */
59 #define DLP_POWER_ON_GPIO       40
60
61 #define GPIO_WIFI_PMENA         54
62 #define GPIO_WIFI_IRQ           53
63
64 static const int sdp4430_keymap[] = {
65         KEY(0, 0, KEY_E),
66         KEY(0, 1, KEY_R),
67         KEY(0, 2, KEY_T),
68         KEY(0, 3, KEY_HOME),
69         KEY(0, 4, KEY_F5),
70         KEY(0, 5, KEY_UNKNOWN),
71         KEY(0, 6, KEY_I),
72         KEY(0, 7, KEY_LEFTSHIFT),
73
74         KEY(1, 0, KEY_D),
75         KEY(1, 1, KEY_F),
76         KEY(1, 2, KEY_G),
77         KEY(1, 3, KEY_SEND),
78         KEY(1, 4, KEY_F6),
79         KEY(1, 5, KEY_UNKNOWN),
80         KEY(1, 6, KEY_K),
81         KEY(1, 7, KEY_ENTER),
82
83         KEY(2, 0, KEY_X),
84         KEY(2, 1, KEY_C),
85         KEY(2, 2, KEY_V),
86         KEY(2, 3, KEY_END),
87         KEY(2, 4, KEY_F7),
88         KEY(2, 5, KEY_UNKNOWN),
89         KEY(2, 6, KEY_DOT),
90         KEY(2, 7, KEY_CAPSLOCK),
91
92         KEY(3, 0, KEY_Z),
93         KEY(3, 1, KEY_KPPLUS),
94         KEY(3, 2, KEY_B),
95         KEY(3, 3, KEY_F1),
96         KEY(3, 4, KEY_F8),
97         KEY(3, 5, KEY_UNKNOWN),
98         KEY(3, 6, KEY_O),
99         KEY(3, 7, KEY_SPACE),
100
101         KEY(4, 0, KEY_W),
102         KEY(4, 1, KEY_Y),
103         KEY(4, 2, KEY_U),
104         KEY(4, 3, KEY_F2),
105         KEY(4, 4, KEY_VOLUMEUP),
106         KEY(4, 5, KEY_UNKNOWN),
107         KEY(4, 6, KEY_L),
108         KEY(4, 7, KEY_LEFT),
109
110         KEY(5, 0, KEY_S),
111         KEY(5, 1, KEY_H),
112         KEY(5, 2, KEY_J),
113         KEY(5, 3, KEY_F3),
114         KEY(5, 4, KEY_F9),
115         KEY(5, 5, KEY_VOLUMEDOWN),
116         KEY(5, 6, KEY_M),
117         KEY(5, 7, KEY_RIGHT),
118
119         KEY(6, 0, KEY_Q),
120         KEY(6, 1, KEY_A),
121         KEY(6, 2, KEY_N),
122         KEY(6, 3, KEY_BACK),
123         KEY(6, 4, KEY_BACKSPACE),
124         KEY(6, 5, KEY_UNKNOWN),
125         KEY(6, 6, KEY_P),
126         KEY(6, 7, KEY_UP),
127
128         KEY(7, 0, KEY_PROG1),
129         KEY(7, 1, KEY_PROG2),
130         KEY(7, 2, KEY_PROG3),
131         KEY(7, 3, KEY_PROG4),
132         KEY(7, 4, KEY_F4),
133         KEY(7, 5, KEY_UNKNOWN),
134         KEY(7, 6, KEY_OK),
135         KEY(7, 7, KEY_DOWN),
136 };
137 static struct omap_device_pad keypad_pads[] = {
138         {       .name   = "kpd_col1.kpd_col1",
139                 .enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
140         },
141         {       .name   = "kpd_col1.kpd_col1",
142                 .enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
143         },
144         {       .name   = "kpd_col2.kpd_col2",
145                 .enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
146         },
147         {       .name   = "kpd_col3.kpd_col3",
148                 .enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
149         },
150         {       .name   = "kpd_col4.kpd_col4",
151                 .enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
152         },
153         {       .name   = "kpd_col5.kpd_col5",
154                 .enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
155         },
156         {       .name   = "gpmc_a23.kpd_col7",
157                 .enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
158         },
159         {       .name   = "gpmc_a22.kpd_col6",
160                 .enable = OMAP_WAKEUP_EN | OMAP_MUX_MODE1,
161         },
162         {       .name   = "kpd_row0.kpd_row0",
163                 .enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
164                         OMAP_MUX_MODE1 | OMAP_INPUT_EN,
165         },
166         {       .name   = "kpd_row1.kpd_row1",
167                 .enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
168                         OMAP_MUX_MODE1 | OMAP_INPUT_EN,
169         },
170         {       .name   = "kpd_row2.kpd_row2",
171                 .enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
172                         OMAP_MUX_MODE1 | OMAP_INPUT_EN,
173         },
174         {       .name   = "kpd_row3.kpd_row3",
175                 .enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
176                         OMAP_MUX_MODE1 | OMAP_INPUT_EN,
177         },
178         {       .name   = "kpd_row4.kpd_row4",
179                 .enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
180                         OMAP_MUX_MODE1 | OMAP_INPUT_EN,
181         },
182         {       .name   = "kpd_row5.kpd_row5",
183                 .enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
184                         OMAP_MUX_MODE1 | OMAP_INPUT_EN,
185         },
186         {       .name   = "gpmc_a18.kpd_row6",
187                 .enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
188                         OMAP_MUX_MODE1 | OMAP_INPUT_EN,
189         },
190         {       .name   = "gpmc_a19.kpd_row7",
191                 .enable = OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_WAKEUP_EN |
192                         OMAP_MUX_MODE1 | OMAP_INPUT_EN,
193         },
194 };
195
196 static struct matrix_keymap_data sdp4430_keymap_data = {
197         .keymap                 = sdp4430_keymap,
198         .keymap_size            = ARRAY_SIZE(sdp4430_keymap),
199 };
200
201 static struct omap4_keypad_platform_data sdp4430_keypad_data = {
202         .keymap_data            = &sdp4430_keymap_data,
203         .rows                   = 8,
204         .cols                   = 8,
205 };
206
207 static struct omap_board_data keypad_data = {
208         .id                     = 1,
209         .pads                   = keypad_pads,
210         .pads_cnt               = ARRAY_SIZE(keypad_pads),
211 };
212
213 static struct gpio_led sdp4430_gpio_leds[] = {
214         {
215                 .name   = "omap4:green:debug0",
216                 .gpio   = 61,
217         },
218         {
219                 .name   = "omap4:green:debug1",
220                 .gpio   = 30,
221         },
222         {
223                 .name   = "omap4:green:debug2",
224                 .gpio   = 7,
225         },
226         {
227                 .name   = "omap4:green:debug3",
228                 .gpio   = 8,
229         },
230         {
231                 .name   = "omap4:green:debug4",
232                 .gpio   = 50,
233         },
234         {
235                 .name   = "omap4:blue:user",
236                 .gpio   = 169,
237         },
238         {
239                 .name   = "omap4:red:user",
240                 .gpio   = 170,
241         },
242         {
243                 .name   = "omap4:green:user",
244                 .gpio   = 139,
245         },
246
247 };
248
249 static struct gpio_keys_button sdp4430_gpio_keys[] = {
250         {
251                 .desc                   = "Proximity Sensor",
252                 .type                   = EV_SW,
253                 .code                   = SW_FRONT_PROXIMITY,
254                 .gpio                   = OMAP4_SFH7741_SENSOR_OUTPUT_GPIO,
255                 .active_low             = 0,
256         }
257 };
258
259 static struct gpio_led_platform_data sdp4430_led_data = {
260         .leds   = sdp4430_gpio_leds,
261         .num_leds       = ARRAY_SIZE(sdp4430_gpio_leds),
262 };
263
264 static struct led_pwm sdp4430_pwm_leds[] = {
265         {
266                 .name           = "omap4:green:chrg",
267                 .pwm_id         = 1,
268                 .max_brightness = 255,
269                 .pwm_period_ns  = 7812500,
270         },
271 };
272
273 static struct led_pwm_platform_data sdp4430_pwm_data = {
274         .num_leds       = ARRAY_SIZE(sdp4430_pwm_leds),
275         .leds           = sdp4430_pwm_leds,
276 };
277
278 static struct platform_device sdp4430_leds_pwm = {
279         .name   = "leds_pwm",
280         .id     = -1,
281         .dev    = {
282                 .platform_data = &sdp4430_pwm_data,
283         },
284 };
285
286 static int omap_prox_activate(struct device *dev)
287 {
288         gpio_set_value(OMAP4_SFH7741_ENABLE_GPIO , 1);
289         return 0;
290 }
291
292 static void omap_prox_deactivate(struct device *dev)
293 {
294         gpio_set_value(OMAP4_SFH7741_ENABLE_GPIO , 0);
295 }
296
297 static struct gpio_keys_platform_data sdp4430_gpio_keys_data = {
298         .buttons        = sdp4430_gpio_keys,
299         .nbuttons       = ARRAY_SIZE(sdp4430_gpio_keys),
300         .enable         = omap_prox_activate,
301         .disable        = omap_prox_deactivate,
302 };
303
304 static struct platform_device sdp4430_gpio_keys_device = {
305         .name   = "gpio-keys",
306         .id     = -1,
307         .dev    = {
308                 .platform_data  = &sdp4430_gpio_keys_data,
309         },
310 };
311
312 static struct platform_device sdp4430_leds_gpio = {
313         .name   = "leds-gpio",
314         .id     = -1,
315         .dev    = {
316                 .platform_data = &sdp4430_led_data,
317         },
318 };
319 static struct spi_board_info sdp4430_spi_board_info[] __initdata = {
320         {
321                 .modalias               = "ks8851",
322                 .bus_num                = 1,
323                 .chip_select            = 0,
324                 .max_speed_hz           = 24000000,
325                 .irq                    = ETH_KS8851_IRQ,
326         },
327 };
328
329 static struct gpio sdp4430_eth_gpios[] __initdata = {
330         { ETH_KS8851_POWER_ON,  GPIOF_OUT_INIT_HIGH,    "eth_power"     },
331         { ETH_KS8851_QUART,     GPIOF_OUT_INIT_HIGH,    "quart"         },
332         { ETH_KS8851_IRQ,       GPIOF_IN,               "eth_irq"       },
333 };
334
335 static int __init omap_ethernet_init(void)
336 {
337         int status;
338
339         /* Request of GPIO lines */
340         status = gpio_request_array(sdp4430_eth_gpios,
341                                     ARRAY_SIZE(sdp4430_eth_gpios));
342         if (status)
343                 pr_err("Cannot request ETH GPIOs\n");
344
345         return status;
346 }
347
348 static struct regulator_consumer_supply sdp4430_vbat_supply[] = {
349         REGULATOR_SUPPLY("vddvibl", "twl6040-vibra"),
350         REGULATOR_SUPPLY("vddvibr", "twl6040-vibra"),
351 };
352
353 static struct regulator_init_data sdp4430_vbat_data = {
354         .constraints = {
355                 .always_on      = 1,
356         },
357         .num_consumer_supplies  = ARRAY_SIZE(sdp4430_vbat_supply),
358         .consumer_supplies      = sdp4430_vbat_supply,
359 };
360
361 static struct fixed_voltage_config sdp4430_vbat_pdata = {
362         .supply_name    = "VBAT",
363         .microvolts     = 3750000,
364         .init_data      = &sdp4430_vbat_data,
365         .gpio           = -EINVAL,
366 };
367
368 static struct platform_device sdp4430_vbat = {
369         .name           = "reg-fixed-voltage",
370         .id             = -1,
371         .dev = {
372                 .platform_data = &sdp4430_vbat_pdata,
373         },
374 };
375
376 static struct platform_device *sdp4430_devices[] __initdata = {
377         &sdp4430_gpio_keys_device,
378         &sdp4430_leds_gpio,
379         &sdp4430_leds_pwm,
380         &sdp4430_vbat,
381 };
382
383 static struct omap_musb_board_data musb_board_data = {
384         .interface_type         = MUSB_INTERFACE_UTMI,
385         .mode                   = MUSB_OTG,
386         .power                  = 100,
387 };
388
389 static struct omap2_hsmmc_info mmc[] = {
390         {
391                 .mmc            = 2,
392                 .caps           =  MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
393                 .gpio_cd        = -EINVAL,
394                 .gpio_wp        = -EINVAL,
395                 .nonremovable   = true,
396                 .ocr_mask       = MMC_VDD_29_30,
397                 .no_off_init    = true,
398         },
399         {
400                 .mmc            = 1,
401                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
402                 .gpio_cd        = -EINVAL,
403                 .gpio_wp        = -EINVAL,
404         },
405         {
406                 .mmc            = 5,
407                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD,
408                 .gpio_cd        = -EINVAL,
409                 .gpio_wp        = -EINVAL,
410                 .ocr_mask       = MMC_VDD_165_195,
411                 .nonremovable   = true,
412         },
413         {}      /* Terminator */
414 };
415
416 static struct regulator_consumer_supply sdp4430_vaux_supply[] = {
417         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
418 };
419
420 static struct regulator_consumer_supply omap4_sdp4430_vmmc5_supply = {
421         .supply = "vmmc",
422         .dev_name = "omap_hsmmc.4",
423 };
424
425 static struct regulator_init_data sdp4430_vmmc5 = {
426         .constraints = {
427                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
428         },
429         .num_consumer_supplies = 1,
430         .consumer_supplies = &omap4_sdp4430_vmmc5_supply,
431 };
432
433 static struct fixed_voltage_config sdp4430_vwlan = {
434         .supply_name            = "vwl1271",
435         .microvolts             = 1800000, /* 1.8V */
436         .gpio                   = GPIO_WIFI_PMENA,
437         .startup_delay          = 70000, /* 70msec */
438         .enable_high            = 1,
439         .enabled_at_boot        = 0,
440         .init_data              = &sdp4430_vmmc5,
441 };
442
443 static struct platform_device omap_vwlan_device = {
444         .name           = "reg-fixed-voltage",
445         .id             = 1,
446         .dev = {
447                 .platform_data = &sdp4430_vwlan,
448         },
449 };
450
451 static int omap4_twl6030_hsmmc_late_init(struct device *dev)
452 {
453         int ret = 0;
454         struct platform_device *pdev = container_of(dev,
455                                 struct platform_device, dev);
456         struct omap_mmc_platform_data *pdata = dev->platform_data;
457
458         /* Setting MMC1 Card detect Irq */
459         if (pdev->id == 0) {
460                 ret = twl6030_mmc_card_detect_config();
461                 if (ret)
462                         pr_err("Failed configuring MMC1 card detect\n");
463                 pdata->slots[0].card_detect_irq = TWL6030_IRQ_BASE +
464                                                 MMCDETECT_INTR_OFFSET;
465                 pdata->slots[0].card_detect = twl6030_mmc_card_detect;
466         }
467         return ret;
468 }
469
470 static __init void omap4_twl6030_hsmmc_set_late_init(struct device *dev)
471 {
472         struct omap_mmc_platform_data *pdata;
473
474         /* dev can be null if CONFIG_MMC_OMAP_HS is not set */
475         if (!dev) {
476                 pr_err("Failed %s\n", __func__);
477                 return;
478         }
479         pdata = dev->platform_data;
480         pdata->init =   omap4_twl6030_hsmmc_late_init;
481 }
482
483 static int __init omap4_twl6030_hsmmc_init(struct omap2_hsmmc_info *controllers)
484 {
485         struct omap2_hsmmc_info *c;
486
487         omap2_hsmmc_init(controllers);
488         for (c = controllers; c->mmc; c++)
489                 omap4_twl6030_hsmmc_set_late_init(c->dev);
490
491         return 0;
492 }
493
494 static struct regulator_init_data sdp4430_vaux1 = {
495         .constraints = {
496                 .min_uV                 = 1000000,
497                 .max_uV                 = 3000000,
498                 .apply_uV               = true,
499                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
500                                         | REGULATOR_MODE_STANDBY,
501                 .valid_ops_mask  = REGULATOR_CHANGE_VOLTAGE
502                                         | REGULATOR_CHANGE_MODE
503                                         | REGULATOR_CHANGE_STATUS,
504         },
505         .num_consumer_supplies  = ARRAY_SIZE(sdp4430_vaux_supply),
506         .consumer_supplies      = sdp4430_vaux_supply,
507 };
508
509 static struct regulator_init_data sdp4430_vusim = {
510         .constraints = {
511                 .min_uV                 = 1200000,
512                 .max_uV                 = 2900000,
513                 .apply_uV               = true,
514                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
515                                         | REGULATOR_MODE_STANDBY,
516                 .valid_ops_mask  = REGULATOR_CHANGE_VOLTAGE
517                                         | REGULATOR_CHANGE_MODE
518                                         | REGULATOR_CHANGE_STATUS,
519         },
520 };
521
522 static struct twl4030_codec_data twl6040_codec = {
523         /* single-step ramp for headset and handsfree */
524         .hs_left_step   = 0x0f,
525         .hs_right_step  = 0x0f,
526         .hf_left_step   = 0x1d,
527         .hf_right_step  = 0x1d,
528 };
529
530 static struct twl4030_vibra_data twl6040_vibra = {
531         .vibldrv_res = 8,
532         .vibrdrv_res = 3,
533         .viblmotor_res = 10,
534         .vibrmotor_res = 10,
535         .vddvibl_uV = 0,        /* fixed volt supply - VBAT */
536         .vddvibr_uV = 0,        /* fixed volt supply - VBAT */
537 };
538
539 static struct twl4030_audio_data twl6040_audio = {
540         .codec          = &twl6040_codec,
541         .vibra          = &twl6040_vibra,
542         .audpwron_gpio  = 127,
543         .naudint_irq    = OMAP44XX_IRQ_SYS_2N,
544         .irq_base       = TWL6040_CODEC_IRQ_BASE,
545 };
546
547 static struct twl4030_platform_data sdp4430_twldata = {
548         .audio          = &twl6040_audio,
549         /* Regulators */
550         .vusim          = &sdp4430_vusim,
551         .vaux1          = &sdp4430_vaux1,
552 };
553
554 static struct i2c_board_info __initdata sdp4430_i2c_3_boardinfo[] = {
555         {
556                 I2C_BOARD_INFO("tmp105", 0x48),
557         },
558         {
559                 I2C_BOARD_INFO("bh1780", 0x29),
560         },
561 };
562 static struct i2c_board_info __initdata sdp4430_i2c_4_boardinfo[] = {
563         {
564                 I2C_BOARD_INFO("hmc5843", 0x1e),
565         },
566 };
567 static int __init omap4_i2c_init(void)
568 {
569         omap4_pmic_get_config(&sdp4430_twldata, TWL_COMMON_PDATA_USB,
570                         TWL_COMMON_REGULATOR_VDAC |
571                         TWL_COMMON_REGULATOR_VAUX2 |
572                         TWL_COMMON_REGULATOR_VAUX3 |
573                         TWL_COMMON_REGULATOR_VMMC |
574                         TWL_COMMON_REGULATOR_VPP |
575                         TWL_COMMON_REGULATOR_VANA |
576                         TWL_COMMON_REGULATOR_VCXIO |
577                         TWL_COMMON_REGULATOR_VUSB |
578                         TWL_COMMON_REGULATOR_CLK32KG);
579         omap4_pmic_init("twl6030", &sdp4430_twldata);
580         omap_register_i2c_bus(2, 400, NULL, 0);
581         omap_register_i2c_bus(3, 400, sdp4430_i2c_3_boardinfo,
582                                 ARRAY_SIZE(sdp4430_i2c_3_boardinfo));
583         omap_register_i2c_bus(4, 400, sdp4430_i2c_4_boardinfo,
584                                 ARRAY_SIZE(sdp4430_i2c_4_boardinfo));
585         return 0;
586 }
587
588 static void __init omap_sfh7741prox_init(void)
589 {
590         int error;
591
592         error = gpio_request_one(OMAP4_SFH7741_ENABLE_GPIO,
593                                  GPIOF_OUT_INIT_LOW, "sfh7741");
594         if (error < 0)
595                 pr_err("%s:failed to request GPIO %d, error %d\n",
596                         __func__, OMAP4_SFH7741_ENABLE_GPIO, error);
597 }
598
599 static struct gpio sdp4430_hdmi_gpios[] = {
600         { HDMI_GPIO_CT_CP_HPD, GPIOF_OUT_INIT_HIGH, "hdmi_gpio_ct_cp_hpd" },
601         { HDMI_GPIO_LS_OE,      GPIOF_OUT_INIT_HIGH,    "hdmi_gpio_ls_oe" },
602         { HDMI_GPIO_HPD, GPIOF_DIR_IN, "hdmi_gpio_hpd" },
603 };
604
605 static int sdp4430_panel_enable_hdmi(struct omap_dss_device *dssdev)
606 {
607         int status;
608
609         status = gpio_request_array(sdp4430_hdmi_gpios,
610                                     ARRAY_SIZE(sdp4430_hdmi_gpios));
611         if (status)
612                 pr_err("%s: Cannot request HDMI GPIOs\n", __func__);
613
614         return status;
615 }
616
617 static void sdp4430_panel_disable_hdmi(struct omap_dss_device *dssdev)
618 {
619         gpio_free_array(sdp4430_hdmi_gpios, ARRAY_SIZE(sdp4430_hdmi_gpios));
620 }
621
622 static struct nokia_dsi_panel_data dsi1_panel = {
623                 .name           = "taal",
624                 .reset_gpio     = 102,
625                 .use_ext_te     = false,
626                 .ext_te_gpio    = 101,
627                 .esd_interval   = 0,
628 };
629
630 static struct omap_dss_device sdp4430_lcd_device = {
631         .name                   = "lcd",
632         .driver_name            = "taal",
633         .type                   = OMAP_DISPLAY_TYPE_DSI,
634         .data                   = &dsi1_panel,
635         .phy.dsi                = {
636                 .clk_lane       = 1,
637                 .clk_pol        = 0,
638                 .data1_lane     = 2,
639                 .data1_pol      = 0,
640                 .data2_lane     = 3,
641                 .data2_pol      = 0,
642
643                 .module         = 0,
644         },
645
646         .clocks = {
647                 .dispc = {
648                         .channel = {
649                                 /* Logic Clock = 172.8 MHz */
650                                 .lck_div        = 1,
651                                 /* Pixel Clock = 34.56 MHz */
652                                 .pck_div        = 5,
653                                 .lcd_clk_src    = OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC,
654                         },
655                         .dispc_fclk_src = OMAP_DSS_CLK_SRC_FCK,
656                 },
657
658                 .dsi = {
659                         .regn           = 16,   /* Fint = 2.4 MHz */
660                         .regm           = 180,  /* DDR Clock = 216 MHz */
661                         .regm_dispc     = 5,    /* PLL1_CLK1 = 172.8 MHz */
662                         .regm_dsi       = 5,    /* PLL1_CLK2 = 172.8 MHz */
663
664                         .lp_clk_div     = 10,   /* LP Clock = 8.64 MHz */
665                         .dsi_fclk_src   = OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI,
666                 },
667         },
668         .channel                = OMAP_DSS_CHANNEL_LCD,
669 };
670
671 static struct nokia_dsi_panel_data dsi2_panel = {
672                 .name           = "taal",
673                 .reset_gpio     = 104,
674                 .use_ext_te     = false,
675                 .ext_te_gpio    = 103,
676                 .esd_interval   = 0,
677 };
678
679 static struct omap_dss_device sdp4430_lcd2_device = {
680         .name                   = "lcd2",
681         .driver_name            = "taal",
682         .type                   = OMAP_DISPLAY_TYPE_DSI,
683         .data                   = &dsi2_panel,
684         .phy.dsi                = {
685                 .clk_lane       = 1,
686                 .clk_pol        = 0,
687                 .data1_lane     = 2,
688                 .data1_pol      = 0,
689                 .data2_lane     = 3,
690                 .data2_pol      = 0,
691
692                 .module         = 1,
693         },
694
695         .clocks = {
696                 .dispc = {
697                         .channel = {
698                                 /* Logic Clock = 172.8 MHz */
699                                 .lck_div        = 1,
700                                 /* Pixel Clock = 34.56 MHz */
701                                 .pck_div        = 5,
702                                 .lcd_clk_src    = OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC,
703                         },
704                         .dispc_fclk_src = OMAP_DSS_CLK_SRC_FCK,
705                 },
706
707                 .dsi = {
708                         .regn           = 16,   /* Fint = 2.4 MHz */
709                         .regm           = 180,  /* DDR Clock = 216 MHz */
710                         .regm_dispc     = 5,    /* PLL1_CLK1 = 172.8 MHz */
711                         .regm_dsi       = 5,    /* PLL1_CLK2 = 172.8 MHz */
712
713                         .lp_clk_div     = 10,   /* LP Clock = 8.64 MHz */
714                         .dsi_fclk_src   = OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DSI,
715                 },
716         },
717         .channel                = OMAP_DSS_CHANNEL_LCD2,
718 };
719
720 static void sdp4430_lcd_init(void)
721 {
722         int r;
723
724         r = gpio_request_one(dsi1_panel.reset_gpio, GPIOF_DIR_OUT,
725                 "lcd1_reset_gpio");
726         if (r)
727                 pr_err("%s: Could not get lcd1_reset_gpio\n", __func__);
728
729         r = gpio_request_one(dsi2_panel.reset_gpio, GPIOF_DIR_OUT,
730                 "lcd2_reset_gpio");
731         if (r)
732                 pr_err("%s: Could not get lcd2_reset_gpio\n", __func__);
733 }
734
735 static struct omap_dss_hdmi_data sdp4430_hdmi_data = {
736         .hpd_gpio = HDMI_GPIO_HPD,
737 };
738
739 static struct omap_dss_device sdp4430_hdmi_device = {
740         .name = "hdmi",
741         .driver_name = "hdmi_panel",
742         .type = OMAP_DISPLAY_TYPE_HDMI,
743         .platform_enable = sdp4430_panel_enable_hdmi,
744         .platform_disable = sdp4430_panel_disable_hdmi,
745         .channel = OMAP_DSS_CHANNEL_DIGIT,
746         .data = &sdp4430_hdmi_data,
747 };
748
749 static struct picodlp_panel_data sdp4430_picodlp_pdata = {
750         .picodlp_adapter_id     = 2,
751         .emu_done_gpio          = 44,
752         .pwrgood_gpio           = 45,
753 };
754
755 static void sdp4430_picodlp_init(void)
756 {
757         int r;
758         const struct gpio picodlp_gpios[] = {
759                 {DLP_POWER_ON_GPIO, GPIOF_OUT_INIT_LOW,
760                         "DLP POWER ON"},
761                 {sdp4430_picodlp_pdata.emu_done_gpio, GPIOF_IN,
762                         "DLP EMU DONE"},
763                 {sdp4430_picodlp_pdata.pwrgood_gpio, GPIOF_OUT_INIT_LOW,
764                         "DLP PWRGOOD"},
765         };
766
767         r = gpio_request_array(picodlp_gpios, ARRAY_SIZE(picodlp_gpios));
768         if (r)
769                 pr_err("Cannot request PicoDLP GPIOs, error %d\n", r);
770 }
771
772 static int sdp4430_panel_enable_picodlp(struct omap_dss_device *dssdev)
773 {
774         gpio_set_value(DISPLAY_SEL_GPIO, 0);
775         gpio_set_value(DLP_POWER_ON_GPIO, 1);
776
777         return 0;
778 }
779
780 static void sdp4430_panel_disable_picodlp(struct omap_dss_device *dssdev)
781 {
782         gpio_set_value(DLP_POWER_ON_GPIO, 0);
783         gpio_set_value(DISPLAY_SEL_GPIO, 1);
784 }
785
786 static struct omap_dss_device sdp4430_picodlp_device = {
787         .name                   = "picodlp",
788         .driver_name            = "picodlp_panel",
789         .type                   = OMAP_DISPLAY_TYPE_DPI,
790         .phy.dpi.data_lines     = 24,
791         .channel                = OMAP_DSS_CHANNEL_LCD2,
792         .platform_enable        = sdp4430_panel_enable_picodlp,
793         .platform_disable       = sdp4430_panel_disable_picodlp,
794         .data                   = &sdp4430_picodlp_pdata,
795 };
796
797 static struct omap_dss_device *sdp4430_dss_devices[] = {
798         &sdp4430_lcd_device,
799         &sdp4430_lcd2_device,
800         &sdp4430_hdmi_device,
801         &sdp4430_picodlp_device,
802 };
803
804 static struct omap_dss_board_info sdp4430_dss_data = {
805         .num_devices    = ARRAY_SIZE(sdp4430_dss_devices),
806         .devices        = sdp4430_dss_devices,
807         .default_device = &sdp4430_lcd_device,
808 };
809
810 static void omap_4430sdp_display_init(void)
811 {
812         int r;
813
814         /* Enable LCD2 by default (instead of Pico DLP) */
815         r = gpio_request_one(DISPLAY_SEL_GPIO, GPIOF_OUT_INIT_HIGH,
816                         "display_sel");
817         if (r)
818                 pr_err("%s: Could not get display_sel GPIO\n", __func__);
819
820         sdp4430_lcd_init();
821         sdp4430_picodlp_init();
822         omap_display_init(&sdp4430_dss_data);
823         /*
824          * OMAP4460SDP/Blaze and OMAP4430 ES2.3 SDP/Blaze boards and
825          * later have external pull up on the HDMI I2C lines
826          */
827         if (cpu_is_omap446x() || omap_rev() > OMAP4430_REV_ES2_2)
828                 omap_hdmi_init(OMAP_HDMI_SDA_SCL_EXTERNAL_PULLUP);
829         else
830                 omap_hdmi_init(0);
831
832         omap_mux_init_gpio(HDMI_GPIO_LS_OE, OMAP_PIN_OUTPUT);
833         omap_mux_init_gpio(HDMI_GPIO_CT_CP_HPD, OMAP_PIN_OUTPUT);
834         omap_mux_init_gpio(HDMI_GPIO_HPD, OMAP_PIN_INPUT_PULLDOWN);
835 }
836
837 #ifdef CONFIG_OMAP_MUX
838 static struct omap_board_mux board_mux[] __initdata = {
839         OMAP4_MUX(USBB2_ULPITLL_CLK, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT),
840         { .reg_offset = OMAP_MUX_TERMINATOR },
841 };
842
843 static struct omap_device_pad serial2_pads[] __initdata = {
844         OMAP_MUX_STATIC("uart2_cts.uart2_cts",
845                          OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
846         OMAP_MUX_STATIC("uart2_rts.uart2_rts",
847                          OMAP_PIN_OUTPUT | OMAP_MUX_MODE0),
848         OMAP_MUX_STATIC("uart2_rx.uart2_rx",
849                          OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
850         OMAP_MUX_STATIC("uart2_tx.uart2_tx",
851                          OMAP_PIN_OUTPUT | OMAP_MUX_MODE0),
852 };
853
854 static struct omap_device_pad serial3_pads[] __initdata = {
855         OMAP_MUX_STATIC("uart3_cts_rctx.uart3_cts_rctx",
856                          OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
857         OMAP_MUX_STATIC("uart3_rts_sd.uart3_rts_sd",
858                          OMAP_PIN_OUTPUT | OMAP_MUX_MODE0),
859         OMAP_MUX_STATIC("uart3_rx_irrx.uart3_rx_irrx",
860                          OMAP_PIN_INPUT | OMAP_MUX_MODE0),
861         OMAP_MUX_STATIC("uart3_tx_irtx.uart3_tx_irtx",
862                          OMAP_PIN_OUTPUT | OMAP_MUX_MODE0),
863 };
864
865 static struct omap_device_pad serial4_pads[] __initdata = {
866         OMAP_MUX_STATIC("uart4_rx.uart4_rx",
867                          OMAP_PIN_INPUT | OMAP_MUX_MODE0),
868         OMAP_MUX_STATIC("uart4_tx.uart4_tx",
869                          OMAP_PIN_OUTPUT | OMAP_MUX_MODE0),
870 };
871
872 static struct omap_board_data serial2_data __initdata = {
873         .id             = 1,
874         .pads           = serial2_pads,
875         .pads_cnt       = ARRAY_SIZE(serial2_pads),
876 };
877
878 static struct omap_board_data serial3_data __initdata = {
879         .id             = 2,
880         .pads           = serial3_pads,
881         .pads_cnt       = ARRAY_SIZE(serial3_pads),
882 };
883
884 static struct omap_board_data serial4_data __initdata = {
885         .id             = 3,
886         .pads           = serial4_pads,
887         .pads_cnt       = ARRAY_SIZE(serial4_pads),
888 };
889
890 static inline void board_serial_init(void)
891 {
892         struct omap_board_data bdata;
893         bdata.flags     = 0;
894         bdata.pads      = NULL;
895         bdata.pads_cnt  = 0;
896         bdata.id        = 0;
897         /* pass dummy data for UART1 */
898         omap_serial_init_port(&bdata);
899
900         omap_serial_init_port(&serial2_data);
901         omap_serial_init_port(&serial3_data);
902         omap_serial_init_port(&serial4_data);
903 }
904 #else
905 #define board_mux       NULL
906
907 static inline void board_serial_init(void)
908 {
909         omap_serial_init();
910 }
911  #endif
912
913 static void omap4_sdp4430_wifi_mux_init(void)
914 {
915         omap_mux_init_gpio(GPIO_WIFI_IRQ, OMAP_PIN_INPUT |
916                                 OMAP_PIN_OFF_WAKEUPENABLE);
917         omap_mux_init_gpio(GPIO_WIFI_PMENA, OMAP_PIN_OUTPUT);
918
919         omap_mux_init_signal("sdmmc5_cmd.sdmmc5_cmd",
920                                 OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
921         omap_mux_init_signal("sdmmc5_clk.sdmmc5_clk",
922                                 OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
923         omap_mux_init_signal("sdmmc5_dat0.sdmmc5_dat0",
924                                 OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
925         omap_mux_init_signal("sdmmc5_dat1.sdmmc5_dat1",
926                                 OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
927         omap_mux_init_signal("sdmmc5_dat2.sdmmc5_dat2",
928                                 OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
929         omap_mux_init_signal("sdmmc5_dat3.sdmmc5_dat3",
930                                 OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
931
932 }
933
934 static struct wl12xx_platform_data omap4_sdp4430_wlan_data __initdata = {
935         .irq = OMAP_GPIO_IRQ(GPIO_WIFI_IRQ),
936         .board_ref_clock = WL12XX_REFCLOCK_26,
937         .board_tcxo_clock = WL12XX_TCXOCLOCK_26,
938 };
939
940 static void omap4_sdp4430_wifi_init(void)
941 {
942         omap4_sdp4430_wifi_mux_init();
943         if (wl12xx_set_platform_data(&omap4_sdp4430_wlan_data))
944                 pr_err("Error setting wl12xx data\n");
945         platform_device_register(&omap_vwlan_device);
946 }
947
948 static void __init omap_4430sdp_init(void)
949 {
950         int status;
951         int package = OMAP_PACKAGE_CBS;
952
953         if (omap_rev() == OMAP4430_REV_ES1_0)
954                 package = OMAP_PACKAGE_CBL;
955         omap4_mux_init(board_mux, NULL, package);
956
957         omap4_i2c_init();
958         omap_sfh7741prox_init();
959         platform_add_devices(sdp4430_devices, ARRAY_SIZE(sdp4430_devices));
960         board_serial_init();
961         omap_sdrc_init(NULL, NULL);
962         omap4_sdp4430_wifi_init();
963         omap4_twl6030_hsmmc_init(mmc);
964
965         usb_musb_init(&musb_board_data);
966
967         status = omap_ethernet_init();
968         if (status) {
969                 pr_err("Ethernet initialization failed: %d\n", status);
970         } else {
971                 sdp4430_spi_board_info[0].irq = gpio_to_irq(ETH_KS8851_IRQ);
972                 spi_register_board_info(sdp4430_spi_board_info,
973                                 ARRAY_SIZE(sdp4430_spi_board_info));
974         }
975
976         status = omap4_keyboard_init(&sdp4430_keypad_data, &keypad_data);
977         if (status)
978                 pr_err("Keypad initialization failed: %d\n", status);
979
980         omap_4430sdp_display_init();
981 }
982
983 MACHINE_START(OMAP_4430SDP, "OMAP4430 4430SDP board")
984         /* Maintainer: Santosh Shilimkar - Texas Instruments Inc */
985         .atag_offset    = 0x100,
986         .reserve        = omap_reserve,
987         .map_io         = omap4_map_io,
988         .init_early     = omap4430_init_early,
989         .init_irq       = gic_init_irq,
990         .init_machine   = omap_4430sdp_init,
991         .timer          = &omap4_timer,
992 MACHINE_END