ARM: OMAP2+: Introduce local usb.h
[linux-3.10.git] / arch / arm / mach-omap2 / board-overo.c
1 /*
2  * board-overo.c (Gumstix Overo)
3  *
4  * Initial code: Steve Sakoman <steve@sakoman.com>
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * version 2 as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18  * 02110-1301 USA
19  *
20  */
21
22 #include <linux/clk.h>
23 #include <linux/delay.h>
24 #include <linux/err.h>
25 #include <linux/init.h>
26 #include <linux/io.h>
27 #include <linux/gpio.h>
28 #include <linux/kernel.h>
29 #include <linux/platform_device.h>
30 #include <linux/i2c/twl.h>
31 #include <linux/regulator/machine.h>
32 #include <linux/regulator/fixed.h>
33 #include <linux/spi/spi.h>
34
35 #include <linux/mtd/mtd.h>
36 #include <linux/mtd/nand.h>
37 #include <linux/mtd/partitions.h>
38 #include <linux/mmc/host.h>
39
40 #include <linux/platform_data/mtd-nand-omap2.h>
41 #include <linux/platform_data/spi-omap2-mcspi.h>
42
43 #include <asm/mach-types.h>
44 #include <asm/mach/arch.h>
45 #include <asm/mach/flash.h>
46 #include <asm/mach/map.h>
47
48 #include "common.h"
49 #include <video/omapdss.h>
50 #include <video/omap-panel-generic-dpi.h>
51 #include <video/omap-panel-tfp410.h>
52 #include <plat/gpmc.h>
53
54 #include "mux.h"
55 #include "sdram-micron-mt46h32m32lf-6.h"
56 #include "hsmmc.h"
57 #include "common-board-devices.h"
58
59 #define OVERO_GPIO_BT_XGATE     15
60 #define OVERO_GPIO_W2W_NRESET   16
61 #define OVERO_GPIO_PENDOWN      114
62 #define OVERO_GPIO_BT_NRESET    164
63 #define OVERO_GPIO_USBH_CPEN    168
64 #define OVERO_GPIO_USBH_NRESET  183
65
66 #define OVERO_SMSC911X_CS      5
67 #define OVERO_SMSC911X_GPIO    176
68 #define OVERO_SMSC911X2_CS     4
69 #define OVERO_SMSC911X2_GPIO   65
70
71 #if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
72         defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
73
74 /* fixed regulator for ads7846 */
75 static struct regulator_consumer_supply ads7846_supply[] = {
76         REGULATOR_SUPPLY("vcc", "spi1.0"),
77 };
78
79 static struct regulator_init_data vads7846_regulator = {
80         .constraints = {
81                 .valid_ops_mask         = REGULATOR_CHANGE_STATUS,
82         },
83         .num_consumer_supplies  = ARRAY_SIZE(ads7846_supply),
84         .consumer_supplies      = ads7846_supply,
85 };
86
87 static struct fixed_voltage_config vads7846 = {
88         .supply_name            = "vads7846",
89         .microvolts             = 3300000, /* 3.3V */
90         .gpio                   = -EINVAL,
91         .startup_delay          = 0,
92         .init_data              = &vads7846_regulator,
93 };
94
95 static struct platform_device vads7846_device = {
96         .name           = "reg-fixed-voltage",
97         .id             = 1,
98         .dev = {
99                 .platform_data = &vads7846,
100         },
101 };
102
103 static void __init overo_ads7846_init(void)
104 {
105         omap_ads7846_init(1, OVERO_GPIO_PENDOWN, 0, NULL);
106         platform_device_register(&vads7846_device);
107 }
108
109 #else
110 static inline void __init overo_ads7846_init(void) { return; }
111 #endif
112
113 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
114
115 #include <linux/smsc911x.h>
116 #include "gpmc-smsc911x.h"
117
118 static struct omap_smsc911x_platform_data smsc911x_cfg = {
119         .id             = 0,
120         .cs             = OVERO_SMSC911X_CS,
121         .gpio_irq       = OVERO_SMSC911X_GPIO,
122         .gpio_reset     = -EINVAL,
123         .flags          = SMSC911X_USE_32BIT,
124 };
125
126 static struct omap_smsc911x_platform_data smsc911x2_cfg = {
127         .id             = 1,
128         .cs             = OVERO_SMSC911X2_CS,
129         .gpio_irq       = OVERO_SMSC911X2_GPIO,
130         .gpio_reset     = -EINVAL,
131         .flags          = SMSC911X_USE_32BIT,
132 };
133
134 static void __init overo_init_smsc911x(void)
135 {
136         gpmc_smsc911x_init(&smsc911x_cfg);
137         gpmc_smsc911x_init(&smsc911x2_cfg);
138 }
139
140 #else
141 static inline void __init overo_init_smsc911x(void) { return; }
142 #endif
143
144 /* DSS */
145 static int lcd_enabled;
146 static int dvi_enabled;
147
148 #define OVERO_GPIO_LCD_EN 144
149 #define OVERO_GPIO_LCD_BL 145
150
151 static struct gpio overo_dss_gpios[] __initdata = {
152         { OVERO_GPIO_LCD_EN, GPIOF_OUT_INIT_HIGH, "OVERO_GPIO_LCD_EN" },
153         { OVERO_GPIO_LCD_BL, GPIOF_OUT_INIT_HIGH, "OVERO_GPIO_LCD_BL" },
154 };
155
156 static void __init overo_display_init(void)
157 {
158         if (gpio_request_array(overo_dss_gpios, ARRAY_SIZE(overo_dss_gpios))) {
159                 printk(KERN_ERR "could not obtain DSS control GPIOs\n");
160                 return;
161         }
162
163         gpio_export(OVERO_GPIO_LCD_EN, 0);
164         gpio_export(OVERO_GPIO_LCD_BL, 0);
165 }
166
167 static struct tfp410_platform_data dvi_panel = {
168         .i2c_bus_num            = 3,
169         .power_down_gpio        = -1,
170 };
171
172 static struct omap_dss_device overo_dvi_device = {
173         .name                   = "dvi",
174         .type                   = OMAP_DISPLAY_TYPE_DPI,
175         .driver_name            = "tfp410",
176         .data                   = &dvi_panel,
177         .phy.dpi.data_lines     = 24,
178 };
179
180 static struct omap_dss_device overo_tv_device = {
181         .name = "tv",
182         .driver_name = "venc",
183         .type = OMAP_DISPLAY_TYPE_VENC,
184         .phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
185 };
186
187 static int overo_panel_enable_lcd(struct omap_dss_device *dssdev)
188 {
189         if (dvi_enabled) {
190                 printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
191                 return -EINVAL;
192         }
193
194         gpio_set_value(OVERO_GPIO_LCD_EN, 1);
195         gpio_set_value(OVERO_GPIO_LCD_BL, 1);
196         lcd_enabled = 1;
197         return 0;
198 }
199
200 static void overo_panel_disable_lcd(struct omap_dss_device *dssdev)
201 {
202         gpio_set_value(OVERO_GPIO_LCD_EN, 0);
203         gpio_set_value(OVERO_GPIO_LCD_BL, 0);
204         lcd_enabled = 0;
205 }
206
207 static struct panel_generic_dpi_data lcd43_panel = {
208         .name                   = "samsung_lte430wq_f0c",
209         .platform_enable        = overo_panel_enable_lcd,
210         .platform_disable       = overo_panel_disable_lcd,
211 };
212
213 static struct omap_dss_device overo_lcd43_device = {
214         .name                   = "lcd43",
215         .type                   = OMAP_DISPLAY_TYPE_DPI,
216         .driver_name            = "generic_dpi_panel",
217         .data                   = &lcd43_panel,
218         .phy.dpi.data_lines     = 24,
219 };
220
221 #if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
222         defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
223 static struct omap_dss_device overo_lcd35_device = {
224         .type                   = OMAP_DISPLAY_TYPE_DPI,
225         .name                   = "lcd35",
226         .driver_name            = "lgphilips_lb035q02_panel",
227         .phy.dpi.data_lines     = 24,
228         .platform_enable        = overo_panel_enable_lcd,
229         .platform_disable       = overo_panel_disable_lcd,
230 };
231 #endif
232
233 static struct omap_dss_device *overo_dss_devices[] = {
234         &overo_dvi_device,
235         &overo_tv_device,
236 #if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
237         defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
238         &overo_lcd35_device,
239 #endif
240         &overo_lcd43_device,
241 };
242
243 static struct omap_dss_board_info overo_dss_data = {
244         .num_devices    = ARRAY_SIZE(overo_dss_devices),
245         .devices        = overo_dss_devices,
246         .default_device = &overo_dvi_device,
247 };
248
249 static struct mtd_partition overo_nand_partitions[] = {
250         {
251                 .name           = "xloader",
252                 .offset         = 0,                    /* Offset = 0x00000 */
253                 .size           = 4 * NAND_BLOCK_SIZE,
254                 .mask_flags     = MTD_WRITEABLE
255         },
256         {
257                 .name           = "uboot",
258                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x80000 */
259                 .size           = 14 * NAND_BLOCK_SIZE,
260         },
261         {
262                 .name           = "uboot environment",
263                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x240000 */
264                 .size           = 2 * NAND_BLOCK_SIZE,
265         },
266         {
267                 .name           = "linux",
268                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x280000 */
269                 .size           = 32 * NAND_BLOCK_SIZE,
270         },
271         {
272                 .name           = "rootfs",
273                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x680000 */
274                 .size           = MTDPART_SIZ_FULL,
275         },
276 };
277
278 static struct omap2_hsmmc_info mmc[] = {
279         {
280                 .mmc            = 1,
281                 .caps           = MMC_CAP_4_BIT_DATA,
282                 .gpio_cd        = -EINVAL,
283                 .gpio_wp        = -EINVAL,
284         },
285         {
286                 .mmc            = 2,
287                 .caps           = MMC_CAP_4_BIT_DATA,
288                 .gpio_cd        = -EINVAL,
289                 .gpio_wp        = -EINVAL,
290                 .transceiver    = true,
291                 .ocr_mask       = 0x00100000,   /* 3.3V */
292         },
293         {}      /* Terminator */
294 };
295
296 static struct regulator_consumer_supply overo_vmmc1_supply[] = {
297         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
298 };
299
300 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
301 #include <linux/leds.h>
302
303 static struct gpio_led gpio_leds[] = {
304         {
305                 .name                   = "overo:red:gpio21",
306                 .default_trigger        = "heartbeat",
307                 .gpio                   = 21,
308                 .active_low             = true,
309         },
310         {
311                 .name                   = "overo:blue:gpio22",
312                 .default_trigger        = "none",
313                 .gpio                   = 22,
314                 .active_low             = true,
315         },
316         {
317                 .name                   = "overo:blue:COM",
318                 .default_trigger        = "mmc0",
319                 .gpio                   = -EINVAL,      /* gets replaced */
320                 .active_low             = true,
321         },
322 };
323
324 static struct gpio_led_platform_data gpio_leds_pdata = {
325         .leds           = gpio_leds,
326         .num_leds       = ARRAY_SIZE(gpio_leds),
327 };
328
329 static struct platform_device gpio_leds_device = {
330         .name   = "leds-gpio",
331         .id     = -1,
332         .dev    = {
333                 .platform_data  = &gpio_leds_pdata,
334         },
335 };
336
337 static void __init overo_init_led(void)
338 {
339         platform_device_register(&gpio_leds_device);
340 }
341
342 #else
343 static inline void __init overo_init_led(void) { return; }
344 #endif
345
346 #if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)
347 #include <linux/input.h>
348 #include <linux/gpio_keys.h>
349
350 static struct gpio_keys_button gpio_buttons[] = {
351         {
352                 .code                   = BTN_0,
353                 .gpio                   = 23,
354                 .desc                   = "button0",
355                 .wakeup                 = 1,
356         },
357         {
358                 .code                   = BTN_1,
359                 .gpio                   = 14,
360                 .desc                   = "button1",
361                 .wakeup                 = 1,
362         },
363 };
364
365 static struct gpio_keys_platform_data gpio_keys_pdata = {
366         .buttons        = gpio_buttons,
367         .nbuttons       = ARRAY_SIZE(gpio_buttons),
368 };
369
370 static struct platform_device gpio_keys_device = {
371         .name   = "gpio-keys",
372         .id     = -1,
373         .dev    = {
374                 .platform_data  = &gpio_keys_pdata,
375         },
376 };
377
378 static void __init overo_init_keys(void)
379 {
380         platform_device_register(&gpio_keys_device);
381 }
382
383 #else
384 static inline void __init overo_init_keys(void) { return; }
385 #endif
386
387 static int overo_twl_gpio_setup(struct device *dev,
388                 unsigned gpio, unsigned ngpio)
389 {
390 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
391         /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
392         gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
393 #endif
394
395         return 0;
396 }
397
398 static struct twl4030_gpio_platform_data overo_gpio_data = {
399         .use_leds       = true,
400         .setup          = overo_twl_gpio_setup,
401 };
402
403 static struct regulator_init_data overo_vmmc1 = {
404         .constraints = {
405                 .min_uV                 = 1850000,
406                 .max_uV                 = 3150000,
407                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
408                                         | REGULATOR_MODE_STANDBY,
409                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
410                                         | REGULATOR_CHANGE_MODE
411                                         | REGULATOR_CHANGE_STATUS,
412         },
413         .num_consumer_supplies  = ARRAY_SIZE(overo_vmmc1_supply),
414         .consumer_supplies      = overo_vmmc1_supply,
415 };
416
417 static struct twl4030_platform_data overo_twldata = {
418         .gpio           = &overo_gpio_data,
419         .vmmc1          = &overo_vmmc1,
420 };
421
422 static int __init overo_i2c_init(void)
423 {
424         omap3_pmic_get_config(&overo_twldata,
425                         TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_AUDIO,
426                         TWL_COMMON_REGULATOR_VDAC | TWL_COMMON_REGULATOR_VPLL2);
427
428         overo_twldata.vpll2->constraints.name = "VDVI";
429
430         omap3_pmic_init("tps65950", &overo_twldata);
431         /* i2c2 pins are used for gpio */
432         omap_register_i2c_bus(3, 400, NULL, 0);
433         return 0;
434 }
435
436 static struct spi_board_info overo_spi_board_info[] __initdata = {
437 #if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
438         defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
439         {
440                 .modalias               = "lgphilips_lb035q02_panel-spi",
441                 .bus_num                = 1,
442                 .chip_select            = 1,
443                 .max_speed_hz           = 500000,
444                 .mode                   = SPI_MODE_3,
445         },
446 #endif
447 };
448
449 static int __init overo_spi_init(void)
450 {
451         overo_ads7846_init();
452         spi_register_board_info(overo_spi_board_info,
453                         ARRAY_SIZE(overo_spi_board_info));
454         return 0;
455 }
456
457 static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
458         .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
459         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
460         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
461         .phy_reset  = true,
462         .reset_gpio_port[0]  = -EINVAL,
463         .reset_gpio_port[1]  = OVERO_GPIO_USBH_NRESET,
464         .reset_gpio_port[2]  = -EINVAL
465 };
466
467 #ifdef CONFIG_OMAP_MUX
468 static struct omap_board_mux board_mux[] __initdata = {
469         { .reg_offset = OMAP_MUX_TERMINATOR },
470 };
471 #endif
472
473 static struct gpio overo_bt_gpios[] __initdata = {
474         { OVERO_GPIO_BT_XGATE,  GPIOF_OUT_INIT_LOW,     "lcd enable"    },
475         { OVERO_GPIO_BT_NRESET, GPIOF_OUT_INIT_HIGH,    "lcd bl enable" },
476 };
477
478 static struct regulator_consumer_supply dummy_supplies[] = {
479         REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
480         REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
481         REGULATOR_SUPPLY("vddvario", "smsc911x.1"),
482         REGULATOR_SUPPLY("vdd33a", "smsc911x.1"),
483 };
484
485 static void __init overo_init(void)
486 {
487         int ret;
488
489         regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies));
490         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
491         overo_i2c_init();
492         omap_hsmmc_init(mmc);
493         omap_display_init(&overo_dss_data);
494         omap_serial_init();
495         omap_sdrc_init(mt46h32m32lf6_sdrc_params,
496                                   mt46h32m32lf6_sdrc_params);
497         omap_nand_flash_init(0, overo_nand_partitions,
498                              ARRAY_SIZE(overo_nand_partitions));
499         usb_musb_init(NULL);
500         usbhs_init(&usbhs_bdata);
501         overo_spi_init();
502         overo_init_smsc911x();
503         overo_display_init();
504         overo_init_led();
505         overo_init_keys();
506         omap_twl4030_audio_init("overo");
507
508         /* Ensure SDRC pins are mux'd for self-refresh */
509         omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
510         omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
511
512         ret = gpio_request_one(OVERO_GPIO_W2W_NRESET, GPIOF_OUT_INIT_HIGH,
513                                "OVERO_GPIO_W2W_NRESET");
514         if (ret == 0) {
515                 gpio_export(OVERO_GPIO_W2W_NRESET, 0);
516                 gpio_set_value(OVERO_GPIO_W2W_NRESET, 0);
517                 udelay(10);
518                 gpio_set_value(OVERO_GPIO_W2W_NRESET, 1);
519         } else {
520                 pr_err("could not obtain gpio for OVERO_GPIO_W2W_NRESET\n");
521         }
522
523         ret = gpio_request_array(overo_bt_gpios, ARRAY_SIZE(overo_bt_gpios));
524         if (ret) {
525                 pr_err("%s: could not obtain BT gpios\n", __func__);
526         } else {
527                 gpio_export(OVERO_GPIO_BT_XGATE, 0);
528                 gpio_export(OVERO_GPIO_BT_NRESET, 0);
529                 gpio_set_value(OVERO_GPIO_BT_NRESET, 0);
530                 mdelay(6);
531                 gpio_set_value(OVERO_GPIO_BT_NRESET, 1);
532         }
533
534         ret = gpio_request_one(OVERO_GPIO_USBH_CPEN, GPIOF_OUT_INIT_HIGH,
535                                "OVERO_GPIO_USBH_CPEN");
536         if (ret == 0)
537                 gpio_export(OVERO_GPIO_USBH_CPEN, 0);
538         else
539                 pr_err("could not obtain gpio for OVERO_GPIO_USBH_CPEN\n");
540 }
541
542 MACHINE_START(OVERO, "Gumstix Overo")
543         .atag_offset    = 0x100,
544         .reserve        = omap_reserve,
545         .map_io         = omap3_map_io,
546         .init_early     = omap35xx_init_early,
547         .init_irq       = omap3_init_irq,
548         .handle_irq     = omap3_intc_handle_irq,
549         .init_machine   = overo_init,
550         .init_late      = omap35xx_init_late,
551         .timer          = &omap3_timer,
552         .restart        = omap_prcm_restart,
553 MACHINE_END