?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: 7409/1: Do not call flush_cache_user_range with mmap_sem held
[linux/fpc-iii.git] / arch / arm / mach-omap2 / board-omap3beagle.c
blob7f21d24bd437732724a45af9302c50a514f56482
1 /*
2 * linux/arch/arm/mach-omap2/board-omap3beagle.c
3 *
4 * Copyright (C) 2008 Texas Instruments
5 *
6 * Modified from mach-omap2/board-3430sdp.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/err.h>
20 #include <linux/clk.h>
21 #include <linux/io.h>
22 #include <linux/leds.h>
23 #include <linux/gpio.h>
24 #include <linux/input.h>
25 #include <linux/gpio_keys.h>
26 #include <linux/opp.h>
27
28 #include <linux/mtd/mtd.h>
29 #include <linux/mtd/partitions.h>
30 #include <linux/mtd/nand.h>
31 #include <linux/mmc/host.h>
32
33 #include <linux/regulator/machine.h>
34 #include <linux/i2c/twl.h>
35
36 #include <mach/hardware.h>
37 #include <asm/mach-types.h>
38 #include <asm/mach/arch.h>
39 #include <asm/mach/map.h>
40 #include <asm/mach/flash.h>
41
42 #include <plat/board.h>
43 #include <plat/common.h>
44 #include <video/omapdss.h>
45 #include <video/omap-panel-generic-dpi.h>
46 #include <plat/gpmc.h>
47 #include <plat/nand.h>
48 #include <plat/usb.h>
49 #include <plat/omap_device.h>
50
51 #include "mux.h"
52 #include "hsmmc.h"
53 #include "timer-gp.h"
54 #include "pm.h"
55 #include "common-board-devices.h"
56
57 /*
58 * OMAP3 Beagle revision
59 * Run time detection of Beagle revision is done by reading GPIO.
60 * GPIO ID -
61 * AXBX = GPIO173, GPIO172, GPIO171: 1 1 1
62 * C1_3 = GPIO173, GPIO172, GPIO171: 1 1 0
63 * C4 = GPIO173, GPIO172, GPIO171: 1 0 1
64 * XM = GPIO173, GPIO172, GPIO171: 0 0 0
65 */
66 enum {
67 OMAP3BEAGLE_BOARD_UNKN = 0,
68 OMAP3BEAGLE_BOARD_AXBX,
69 OMAP3BEAGLE_BOARD_C1_3,
70 OMAP3BEAGLE_BOARD_C4,
71 OMAP3BEAGLE_BOARD_XM,
72 };
73
74 static u8 omap3_beagle_version;
75
76 static u8 omap3_beagle_get_rev(void)
77 {
78 return omap3_beagle_version;
79 }
80
81 static struct gpio omap3_beagle_rev_gpios[] __initdata = {
82 { 171, GPIOF_IN, "rev_id_0" },
83 { 172, GPIOF_IN, "rev_id_1" },
84 { 173, GPIOF_IN, "rev_id_2" },
85 };
86
87 static void __init omap3_beagle_init_rev(void)
88 {
89 int ret;
90 u16 beagle_rev = 0;
91
92 omap_mux_init_gpio(171, OMAP_PIN_INPUT_PULLUP);
93 omap_mux_init_gpio(172, OMAP_PIN_INPUT_PULLUP);
94 omap_mux_init_gpio(173, OMAP_PIN_INPUT_PULLUP);
95
96 ret = gpio_request_array(omap3_beagle_rev_gpios,
97 ARRAY_SIZE(omap3_beagle_rev_gpios));
98 if (ret < 0) {
99 printk(KERN_ERR "Unable to get revision detection GPIO pins\n");
100 omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
101 return;
102 }
103
104 beagle_rev = gpio_get_value(171) | (gpio_get_value(172) << 1)
105 | (gpio_get_value(173) << 2);
106
107 gpio_free_array(omap3_beagle_rev_gpios,
108 ARRAY_SIZE(omap3_beagle_rev_gpios));
109
110 switch (beagle_rev) {
111 case 7:
112 printk(KERN_INFO "OMAP3 Beagle Rev: Ax/Bx\n");
113 omap3_beagle_version = OMAP3BEAGLE_BOARD_AXBX;
114 break;
115 case 6:
116 printk(KERN_INFO "OMAP3 Beagle Rev: C1/C2/C3\n");
117 omap3_beagle_version = OMAP3BEAGLE_BOARD_C1_3;
118 break;
119 case 5:
120 printk(KERN_INFO "OMAP3 Beagle Rev: C4\n");
121 omap3_beagle_version = OMAP3BEAGLE_BOARD_C4;
122 break;
123 case 0:
124 printk(KERN_INFO "OMAP3 Beagle Rev: xM\n");
125 omap3_beagle_version = OMAP3BEAGLE_BOARD_XM;
126 break;
127 default:
128 printk(KERN_INFO "OMAP3 Beagle Rev: unknown %hd\n", beagle_rev);
129 omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
130 }
131 }
132
133 static struct mtd_partition omap3beagle_nand_partitions[] = {
134 /* All the partition sizes are listed in terms of NAND block size */
135 {
136 .name = "X-Loader",
137 .offset = 0,
138 .size = 4 * NAND_BLOCK_SIZE,
139 .mask_flags = MTD_WRITEABLE, /* force read-only */
140 },
141 {
142 .name = "U-Boot",
143 .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */
144 .size = 15 * NAND_BLOCK_SIZE,
145 .mask_flags = MTD_WRITEABLE, /* force read-only */
146 },
147 {
148 .name = "U-Boot Env",
149 .offset = MTDPART_OFS_APPEND, /* Offset = 0x260000 */
150 .size = 1 * NAND_BLOCK_SIZE,
151 },
152 {
153 .name = "Kernel",
154 .offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */
155 .size = 32 * NAND_BLOCK_SIZE,
156 },
157 {
158 .name = "File System",
159 .offset = MTDPART_OFS_APPEND, /* Offset = 0x680000 */
160 .size = MTDPART_SIZ_FULL,
161 },
162 };
163
164 /* DSS */
165
166 static int beagle_enable_dvi(struct omap_dss_device *dssdev)
167 {
168 if (gpio_is_valid(dssdev->reset_gpio))
169 gpio_set_value(dssdev->reset_gpio, 1);
170
171 return 0;
172 }
173
174 static void beagle_disable_dvi(struct omap_dss_device *dssdev)
175 {
176 if (gpio_is_valid(dssdev->reset_gpio))
177 gpio_set_value(dssdev->reset_gpio, 0);
178 }
179
180 static struct panel_generic_dpi_data dvi_panel = {
181 .name = "generic",
182 .platform_enable = beagle_enable_dvi,
183 .platform_disable = beagle_disable_dvi,
184 };
185
186 static struct omap_dss_device beagle_dvi_device = {
187 .type = OMAP_DISPLAY_TYPE_DPI,
188 .name = "dvi",
189 .driver_name = "generic_dpi_panel",
190 .data = &dvi_panel,
191 .phy.dpi.data_lines = 24,
192 .reset_gpio = -EINVAL,
193 };
194
195 static struct omap_dss_device beagle_tv_device = {
196 .name = "tv",
197 .driver_name = "venc",
198 .type = OMAP_DISPLAY_TYPE_VENC,
199 .phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
200 };
201
202 static struct omap_dss_device *beagle_dss_devices[] = {
203 &beagle_dvi_device,
204 &beagle_tv_device,
205 };
206
207 static struct omap_dss_board_info beagle_dss_data = {
208 .num_devices = ARRAY_SIZE(beagle_dss_devices),
209 .devices = beagle_dss_devices,
210 .default_device = &beagle_dvi_device,
211 };
212
213 static struct regulator_consumer_supply beagle_vdac_supply =
214 REGULATOR_SUPPLY("vdda_dac", "omapdss_venc");
215
216 static struct regulator_consumer_supply beagle_vdvi_supplies[] = {
217 REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
218 REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
219 };
220
221 static void __init beagle_display_init(void)
222 {
223 int r;
224
225 r = gpio_request_one(beagle_dvi_device.reset_gpio, GPIOF_OUT_INIT_LOW,
226 "DVI reset");
227 if (r < 0)
228 printk(KERN_ERR "Unable to get DVI reset GPIO\n");
229 }
230
231 #include "sdram-micron-mt46h32m32lf-6.h"
232
233 static struct omap2_hsmmc_info mmc[] = {
234 {
235 .mmc = 1,
236 .caps = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
237 .gpio_wp = 29,
238 },
239 {} /* Terminator */
240 };
241
242 static struct regulator_consumer_supply beagle_vmmc1_supply = {
243 .supply = "vmmc",
244 };
245
246 static struct regulator_consumer_supply beagle_vsim_supply = {
247 .supply = "vmmc_aux",
248 };
249
250 static struct gpio_led gpio_leds[];
251
252 static int beagle_twl_gpio_setup(struct device *dev,
253 unsigned gpio, unsigned ngpio)
254 {
255 int r, usb_pwr_level;
256
257 if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
258 mmc[0].gpio_wp = -EINVAL;
259 } else if ((omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C1_3) ||
260 (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C4)) {
261 omap_mux_init_gpio(23, OMAP_PIN_INPUT);
262 mmc[0].gpio_wp = 23;
263 } else {
264 omap_mux_init_gpio(29, OMAP_PIN_INPUT);
265 }
266 /* gpio + 0 is "mmc0_cd" (input/IRQ) */
267 mmc[0].gpio_cd = gpio + 0;
268 omap2_hsmmc_init(mmc);
269
270 /* link regulators to MMC adapters */
271 beagle_vmmc1_supply.dev = mmc[0].dev;
272 beagle_vsim_supply.dev = mmc[0].dev;
273
274 /*
275 * TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, XM active
276 * high / others active low)
277 * DVI reset GPIO is different between beagle revisions
278 */
279 if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
280 usb_pwr_level = GPIOF_OUT_INIT_HIGH;
281 beagle_dvi_device.reset_gpio = 129;
282 /*
283 * gpio + 1 on Xm controls the TFP410's enable line (active low)
284 * gpio + 2 control varies depending on the board rev as below:
285 * P7/P8 revisions(prototype): Camera EN
286 * A2+ revisions (production): LDO (DVI, serial, led blocks)
287 */
288 r = gpio_request_one(gpio + 1, GPIOF_OUT_INIT_LOW,
289 "nDVI_PWR_EN");
290 if (r)
291 pr_err("%s: unable to configure nDVI_PWR_EN\n",
292 __func__);
293 r = gpio_request_one(gpio + 2, GPIOF_OUT_INIT_HIGH,
294 "DVI_LDO_EN");
295 if (r)
296 pr_err("%s: unable to configure DVI_LDO_EN\n",
297 __func__);
298 } else {
299 usb_pwr_level = GPIOF_OUT_INIT_LOW;
300 beagle_dvi_device.reset_gpio = 170;
301 /*
302 * REVISIT: need ehci-omap hooks for external VBUS
303 * power switch and overcurrent detect
304 */
305 if (gpio_request_one(gpio + 1, GPIOF_IN, "EHCI_nOC"))
306 pr_err("%s: unable to configure EHCI_nOC\n", __func__);
307 }
308
309 gpio_request_one(gpio + TWL4030_GPIO_MAX, usb_pwr_level, "nEN_USB_PWR");
310
311 /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
312 gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
313
314 return 0;
315 }
316
317 static struct twl4030_gpio_platform_data beagle_gpio_data = {
318 .gpio_base = OMAP_MAX_GPIO_LINES,
319 .irq_base = TWL4030_GPIO_IRQ_BASE,
320 .irq_end = TWL4030_GPIO_IRQ_END,
321 .use_leds = true,
322 .pullups = BIT(1),
323 .pulldowns = BIT(2) | BIT(6) | BIT(7) | BIT(8) | BIT(13)
324 | BIT(15) | BIT(16) | BIT(17),
325 .setup = beagle_twl_gpio_setup,
326 };
327
328 /* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
329 static struct regulator_init_data beagle_vmmc1 = {
330 .constraints = {
331 .min_uV = 1850000,
332 .max_uV = 3150000,
333 .valid_modes_mask = REGULATOR_MODE_NORMAL
334 | REGULATOR_MODE_STANDBY,
335 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
336 | REGULATOR_CHANGE_MODE
337 | REGULATOR_CHANGE_STATUS,
338 },
339 .num_consumer_supplies = 1,
340 .consumer_supplies = &beagle_vmmc1_supply,
341 };
342
343 /* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */
344 static struct regulator_init_data beagle_vsim = {
345 .constraints = {
346 .min_uV = 1800000,
347 .max_uV = 3000000,
348 .valid_modes_mask = REGULATOR_MODE_NORMAL
349 | REGULATOR_MODE_STANDBY,
350 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
351 | REGULATOR_CHANGE_MODE
352 | REGULATOR_CHANGE_STATUS,
353 },
354 .num_consumer_supplies = 1,
355 .consumer_supplies = &beagle_vsim_supply,
356 };
357
358 /* VDAC for DSS driving S-Video (8 mA unloaded, max 65 mA) */
359 static struct regulator_init_data beagle_vdac = {
360 .constraints = {
361 .min_uV = 1800000,
362 .max_uV = 1800000,
363 .valid_modes_mask = REGULATOR_MODE_NORMAL
364 | REGULATOR_MODE_STANDBY,
365 .valid_ops_mask = REGULATOR_CHANGE_MODE
366 | REGULATOR_CHANGE_STATUS,
367 },
368 .num_consumer_supplies = 1,
369 .consumer_supplies = &beagle_vdac_supply,
370 };
371
372 /* VPLL2 for digital video outputs */
373 static struct regulator_init_data beagle_vpll2 = {
374 .constraints = {
375 .name = "VDVI",
376 .min_uV = 1800000,
377 .max_uV = 1800000,
378 .valid_modes_mask = REGULATOR_MODE_NORMAL
379 | REGULATOR_MODE_STANDBY,
380 .valid_ops_mask = REGULATOR_CHANGE_MODE
381 | REGULATOR_CHANGE_STATUS,
382 },
383 .num_consumer_supplies = ARRAY_SIZE(beagle_vdvi_supplies),
384 .consumer_supplies = beagle_vdvi_supplies,
385 };
386
387 static struct twl4030_usb_data beagle_usb_data = {
388 .usb_mode = T2_USB_MODE_ULPI,
389 };
390
391 static struct twl4030_codec_audio_data beagle_audio_data;
392
393 static struct twl4030_codec_data beagle_codec_data = {
394 .audio_mclk = 26000000,
395 .audio = &beagle_audio_data,
396 };
397
398 static struct twl4030_platform_data beagle_twldata = {
399 .irq_base = TWL4030_IRQ_BASE,
400 .irq_end = TWL4030_IRQ_END,
401
402 /* platform_data for children goes here */
403 .usb = &beagle_usb_data,
404 .gpio = &beagle_gpio_data,
405 .codec = &beagle_codec_data,
406 .vmmc1 = &beagle_vmmc1,
407 .vsim = &beagle_vsim,
408 .vdac = &beagle_vdac,
409 .vpll2 = &beagle_vpll2,
410 };
411
412 static struct i2c_board_info __initdata beagle_i2c_eeprom[] = {
413 {
414 I2C_BOARD_INFO("eeprom", 0x50),
415 },
416 };
417
418 static int __init omap3_beagle_i2c_init(void)
419 {
420 omap3_pmic_init("twl4030", &beagle_twldata);
421 /* Bus 3 is attached to the DVI port where devices like the pico DLP
422 * projector don't work reliably with 400kHz */
423 omap_register_i2c_bus(3, 100, beagle_i2c_eeprom, ARRAY_SIZE(beagle_i2c_eeprom));
424 return 0;
425 }
426
427 static struct gpio_led gpio_leds[] = {
428 {
429 .name = "beagleboard::usr0",
430 .default_trigger = "heartbeat",
431 .gpio = 150,
432 },
433 {
434 .name = "beagleboard::usr1",
435 .default_trigger = "mmc0",
436 .gpio = 149,
437 },
438 {
439 .name = "beagleboard::pmu_stat",
440 .gpio = -EINVAL, /* gets replaced */
441 .active_low = true,
442 },
443 };
444
445 static struct gpio_led_platform_data gpio_led_info = {
446 .leds = gpio_leds,
447 .num_leds = ARRAY_SIZE(gpio_leds),
448 };
449
450 static struct platform_device leds_gpio = {
451 .name = "leds-gpio",
452 .id = -1,
453 .dev = {
454 .platform_data = &gpio_led_info,
455 },
456 };
457
458 static struct gpio_keys_button gpio_buttons[] = {
459 {
460 .code = BTN_EXTRA,
461 .gpio = 7,
462 .desc = "user",
463 .wakeup = 1,
464 },
465 };
466
467 static struct gpio_keys_platform_data gpio_key_info = {
468 .buttons = gpio_buttons,
469 .nbuttons = ARRAY_SIZE(gpio_buttons),
470 };
471
472 static struct platform_device keys_gpio = {
473 .name = "gpio-keys",
474 .id = -1,
475 .dev = {
476 .platform_data = &gpio_key_info,
477 },
478 };
479
480 static void __init omap3_beagle_init_early(void)
481 {
482 omap2_init_common_infrastructure();
483 omap2_init_common_devices(mt46h32m32lf6_sdrc_params,
484 mt46h32m32lf6_sdrc_params);
485 }
486
487 static void __init omap3_beagle_init_irq(void)
488 {
489 omap_init_irq();
490 #ifdef CONFIG_OMAP_32K_TIMER
491 omap2_gp_clockevent_set_gptimer(12);
492 #endif
493 }
494
495 static struct platform_device *omap3_beagle_devices[] __initdata = {
496 &leds_gpio,
497 &keys_gpio,
498 };
499
500 static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
501
502 .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
503 .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
504 .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
505
506 .phy_reset = true,
507 .reset_gpio_port[0] = -EINVAL,
508 .reset_gpio_port[1] = 147,
509 .reset_gpio_port[2] = -EINVAL
510 };
511
512 #ifdef CONFIG_OMAP_MUX
513 static struct omap_board_mux board_mux[] __initdata = {
514 { .reg_offset = OMAP_MUX_TERMINATOR },
515 };
516 #endif
517
518 static void __init beagle_opp_init(void)
519 {
520 int r = 0;
521
522 /* Initialize the omap3 opp table */
523 if (omap3_opp_init()) {
524 pr_err("%s: opp default init failed\n", __func__);
525 return;
526 }
527
528 /* Custom OPP enabled for XM */
529 if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
530 struct omap_hwmod *mh = omap_hwmod_lookup("mpu");
531 struct omap_hwmod *dh = omap_hwmod_lookup("iva");
532 struct device *dev;
533
534 if (!mh || !dh) {
535 pr_err("%s: Aiee.. no mpu/dsp devices? %p %p\n",
536 __func__, mh, dh);
537 return;
538 }
539 /* Enable MPU 1GHz and lower opps */
540 dev = &mh->od->pdev.dev;
541 r = opp_enable(dev, 800000000);
542 /* TODO: MPU 1GHz needs SR and ABB */
543
544 /* Enable IVA 800MHz and lower opps */
545 dev = &dh->od->pdev.dev;
546 r |= opp_enable(dev, 660000000);
547 /* TODO: DSP 800MHz needs SR and ABB */
548 if (r) {
549 pr_err("%s: failed to enable higher opp %d\n",
550 __func__, r);
551 /*
552 * Cleanup - disable the higher freqs - we dont care
553 * about the results
554 */
555 dev = &mh->od->pdev.dev;
556 opp_disable(dev, 800000000);
557 dev = &dh->od->pdev.dev;
558 opp_disable(dev, 660000000);
559 }
560 }
561 return;
562 }
563
564 static void __init omap3_beagle_init(void)
565 {
566 omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
567 omap3_beagle_init_rev();
568 omap3_beagle_i2c_init();
569 platform_add_devices(omap3_beagle_devices,
570 ARRAY_SIZE(omap3_beagle_devices));
571 omap_display_init(&beagle_dss_data);
572 omap_serial_init();
573
574 omap_mux_init_gpio(170, OMAP_PIN_INPUT);
575 /* REVISIT leave DVI powered down until it's needed ... */
576 gpio_request_one(170, GPIOF_OUT_INIT_HIGH, "DVI_nPD");
577
578 usb_musb_init(NULL);
579 usbhs_init(&usbhs_bdata);
580 omap_nand_flash_init(NAND_BUSWIDTH_16, omap3beagle_nand_partitions,
581 ARRAY_SIZE(omap3beagle_nand_partitions));
582
583 /* Ensure msecure is mux'd to be able to set the RTC. */
584 omap_mux_init_signal("sys_drm_msecure", OMAP_PIN_OFF_OUTPUT_HIGH);
585
586 /* Ensure SDRC pins are mux'd for self-refresh */
587 omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
588 omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
589
590 beagle_display_init();
591 beagle_opp_init();
592 }
593
594 MACHINE_START(OMAP3_BEAGLE, "OMAP3 Beagle Board")
595 /* Maintainer: Syed Mohammed Khasim - http://beagleboard.org */
596 .boot_params = 0x80000100,
597 .reserve = omap_reserve,
598 .map_io = omap3_map_io,
599 .init_early = omap3_beagle_init_early,
600 .init_irq = omap3_beagle_init_irq,
601 .init_machine = omap3_beagle_init,
602 .timer = &omap_timer,
603 MACHINE_END
Linux with added FPC-III support