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