projects / deliverable / linux.git / blob
? search:


c162369e9f779577147d6944faf60d73e72b6cc4
[deliverable/linux.git] / arch / arm / mach-omap1 / board-ams-delta.c
1 /*
2 * linux/arch/arm/mach-omap1/board-ams-delta.c
3 *
4 * Modified from board-generic.c
5 *
6 * Board specific inits for the Amstrad E3 (codename Delta) videophone
7 *
8 * Copyright (C) 2006 Jonathan McDowell <noodles@earth.li>
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 #include <linux/basic_mmio_gpio.h>
15 #include <linux/gpio.h>
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/input.h>
19 #include <linux/interrupt.h>
20 #include <linux/leds.h>
21 #include <linux/platform_device.h>
22 #include <linux/regulator/consumer.h>
23 #include <linux/regulator/fixed.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/serial_8250.h>
26 #include <linux/export.h>
27 #include <linux/omapfb.h>
28 #include <linux/io.h>
29
30 #include <media/soc_camera.h>
31
32 #include <asm/serial.h>
33 #include <asm/mach-types.h>
34 #include <asm/mach/arch.h>
35 #include <asm/mach/map.h>
36
37 #include <plat/board-ams-delta.h>
38 #include <plat/keypad.h>
39 #include <plat/mux.h>
40
41 #include <mach/hardware.h>
42 #include <mach/ams-delta-fiq.h>
43 #include <mach/camera.h>
44 #include <mach/usb.h>
45
46 #include "iomap.h"
47 #include "common.h"
48
49 static const unsigned int ams_delta_keymap[] = {
50 KEY(0, 0, KEY_F1), /* Advert */
51
52 KEY(0, 3, KEY_COFFEE), /* Games */
53 KEY(0, 2, KEY_QUESTION), /* Directory */
54 KEY(2, 3, KEY_CONNECT), /* Internet */
55 KEY(1, 2, KEY_SHOP), /* Services */
56 KEY(1, 1, KEY_PHONE), /* VoiceMail */
57
58 KEY(0, 1, KEY_DELETE), /* Delete */
59 KEY(2, 2, KEY_PLAY), /* Play */
60 KEY(1, 0, KEY_PAGEUP), /* Up */
61 KEY(1, 3, KEY_PAGEDOWN), /* Down */
62 KEY(2, 0, KEY_EMAIL), /* ReadEmail */
63 KEY(2, 1, KEY_STOP), /* Stop */
64
65 /* Numeric keypad portion */
66 KEY(0, 7, KEY_KP1),
67 KEY(0, 6, KEY_KP2),
68 KEY(0, 5, KEY_KP3),
69 KEY(1, 7, KEY_KP4),
70 KEY(1, 6, KEY_KP5),
71 KEY(1, 5, KEY_KP6),
72 KEY(2, 7, KEY_KP7),
73 KEY(2, 6, KEY_KP8),
74 KEY(2, 5, KEY_KP9),
75 KEY(3, 6, KEY_KP0),
76 KEY(3, 7, KEY_KPASTERISK),
77 KEY(3, 5, KEY_KPDOT), /* # key */
78 KEY(7, 2, KEY_NUMLOCK), /* Mute */
79 KEY(7, 1, KEY_KPMINUS), /* Recall */
80 KEY(6, 1, KEY_KPPLUS), /* Redial */
81 KEY(7, 6, KEY_KPSLASH), /* Handsfree */
82 KEY(6, 0, KEY_ENTER), /* Video */
83
84 KEY(7, 4, KEY_CAMERA), /* Photo */
85
86 KEY(0, 4, KEY_F2), /* Home */
87 KEY(1, 4, KEY_F3), /* Office */
88 KEY(2, 4, KEY_F4), /* Mobile */
89 KEY(7, 7, KEY_F5), /* SMS */
90 KEY(7, 5, KEY_F6), /* Email */
91
92 /* QWERTY portion of keypad */
93 KEY(3, 4, KEY_Q),
94 KEY(3, 3, KEY_W),
95 KEY(3, 2, KEY_E),
96 KEY(3, 1, KEY_R),
97 KEY(3, 0, KEY_T),
98 KEY(4, 7, KEY_Y),
99 KEY(4, 6, KEY_U),
100 KEY(4, 5, KEY_I),
101 KEY(4, 4, KEY_O),
102 KEY(4, 3, KEY_P),
103
104 KEY(4, 2, KEY_A),
105 KEY(4, 1, KEY_S),
106 KEY(4, 0, KEY_D),
107 KEY(5, 7, KEY_F),
108 KEY(5, 6, KEY_G),
109 KEY(5, 5, KEY_H),
110 KEY(5, 4, KEY_J),
111 KEY(5, 3, KEY_K),
112 KEY(5, 2, KEY_L),
113
114 KEY(5, 1, KEY_Z),
115 KEY(5, 0, KEY_X),
116 KEY(6, 7, KEY_C),
117 KEY(6, 6, KEY_V),
118 KEY(6, 5, KEY_B),
119 KEY(6, 4, KEY_N),
120 KEY(6, 3, KEY_M),
121 KEY(6, 2, KEY_SPACE),
122
123 KEY(7, 0, KEY_LEFTSHIFT), /* Vol up */
124 KEY(7, 3, KEY_LEFTCTRL), /* Vol down */
125 };
126
127 #define LATCH1_PHYS 0x01000000
128 #define LATCH1_VIRT 0xEA000000
129 #define MODEM_PHYS 0x04000000
130 #define MODEM_VIRT 0xEB000000
131 #define LATCH2_PHYS 0x08000000
132 #define LATCH2_VIRT 0xEC000000
133
134 static struct map_desc ams_delta_io_desc[] __initdata = {
135 /* AMS_DELTA_LATCH1 */
136 {
137 .virtual = LATCH1_VIRT,
138 .pfn = __phys_to_pfn(LATCH1_PHYS),
139 .length = 0x01000000,
140 .type = MT_DEVICE
141 },
142 /* AMS_DELTA_LATCH2 */
143 {
144 .virtual = LATCH2_VIRT,
145 .pfn = __phys_to_pfn(LATCH2_PHYS),
146 .length = 0x01000000,
147 .type = MT_DEVICE
148 },
149 /* AMS_DELTA_MODEM */
150 {
151 .virtual = MODEM_VIRT,
152 .pfn = __phys_to_pfn(MODEM_PHYS),
153 .length = 0x01000000,
154 .type = MT_DEVICE
155 }
156 };
157
158 static struct omap_lcd_config ams_delta_lcd_config __initdata = {
159 .ctrl_name = "internal",
160 };
161
162 static struct omap_usb_config ams_delta_usb_config = {
163 .register_host = 1,
164 .hmc_mode = 16,
165 .pins[0] = 2,
166 };
167
168 #define LATCH1_GPIO_BASE 232
169 #define LATCH1_NGPIO 8
170
171 static struct resource latch1_resources[] = {
172 [0] = {
173 .name = "dat",
174 .start = LATCH1_PHYS,
175 .end = LATCH1_PHYS + (LATCH1_NGPIO - 1) / 8,
176 .flags = IORESOURCE_MEM,
177 },
178 };
179
180 static struct bgpio_pdata latch1_pdata = {
181 .base = LATCH1_GPIO_BASE,
182 .ngpio = LATCH1_NGPIO,
183 };
184
185 static struct platform_device latch1_gpio_device = {
186 .name = "basic-mmio-gpio",
187 .id = 0,
188 .resource = latch1_resources,
189 .num_resources = ARRAY_SIZE(latch1_resources),
190 .dev = {
191 .platform_data = &latch1_pdata,
192 },
193 };
194
195 static struct resource latch2_resources[] = {
196 [0] = {
197 .name = "dat",
198 .start = LATCH2_PHYS,
199 .end = LATCH2_PHYS + (AMS_DELTA_LATCH2_NGPIO - 1) / 8,
200 .flags = IORESOURCE_MEM,
201 },
202 };
203
204 static struct bgpio_pdata latch2_pdata = {
205 .base = AMS_DELTA_LATCH2_GPIO_BASE,
206 .ngpio = AMS_DELTA_LATCH2_NGPIO,
207 };
208
209 static struct platform_device latch2_gpio_device = {
210 .name = "basic-mmio-gpio",
211 .id = 1,
212 .resource = latch2_resources,
213 .num_resources = ARRAY_SIZE(latch2_resources),
214 .dev = {
215 .platform_data = &latch2_pdata,
216 },
217 };
218
219 static const struct gpio latch_gpios[] __initconst = {
220 {
221 .gpio = LATCH1_GPIO_BASE + 6,
222 .flags = GPIOF_OUT_INIT_LOW,
223 .label = "dockit1",
224 },
225 {
226 .gpio = LATCH1_GPIO_BASE + 7,
227 .flags = GPIOF_OUT_INIT_LOW,
228 .label = "dockit2",
229 },
230 {
231 .gpio = AMS_DELTA_GPIO_PIN_SCARD_RSTIN,
232 .flags = GPIOF_OUT_INIT_LOW,
233 .label = "scard_rstin",
234 },
235 {
236 .gpio = AMS_DELTA_GPIO_PIN_SCARD_CMDVCC,
237 .flags = GPIOF_OUT_INIT_LOW,
238 .label = "scard_cmdvcc",
239 },
240 {
241 .gpio = AMS_DELTA_GPIO_PIN_MODEM_CODEC,
242 .flags = GPIOF_OUT_INIT_LOW,
243 .label = "modem_codec",
244 },
245 {
246 .gpio = AMS_DELTA_LATCH2_GPIO_BASE + 14,
247 .flags = GPIOF_OUT_INIT_LOW,
248 .label = "hookflash1",
249 },
250 {
251 .gpio = AMS_DELTA_LATCH2_GPIO_BASE + 15,
252 .flags = GPIOF_OUT_INIT_LOW,
253 .label = "hookflash2",
254 },
255 };
256
257 static struct regulator_consumer_supply modem_nreset_consumers[] = {
258 REGULATOR_SUPPLY("RESET#", "serial8250.1"),
259 REGULATOR_SUPPLY("POR", "cx20442-codec"),
260 };
261
262 static struct regulator_init_data modem_nreset_data = {
263 .constraints = {
264 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
265 .boot_on = 1,
266 },
267 .num_consumer_supplies = ARRAY_SIZE(modem_nreset_consumers),
268 .consumer_supplies = modem_nreset_consumers,
269 };
270
271 static struct fixed_voltage_config modem_nreset_config = {
272 .supply_name = "modem_nreset",
273 .microvolts = 3300000,
274 .gpio = AMS_DELTA_GPIO_PIN_MODEM_NRESET,
275 .startup_delay = 25000,
276 .enable_high = 1,
277 .enabled_at_boot = 1,
278 .init_data = &modem_nreset_data,
279 };
280
281 static struct platform_device modem_nreset_device = {
282 .name = "reg-fixed-voltage",
283 .id = -1,
284 .dev = {
285 .platform_data = &modem_nreset_config,
286 },
287 };
288
289 struct modem_private_data {
290 struct regulator *regulator;
291 };
292
293 static struct modem_private_data modem_priv;
294
295 void ams_delta_latch_write(int base, int ngpio, u16 mask, u16 value)
296 {
297 int bit = 0;
298 u16 bitpos = 1 << bit;
299
300 for (; bit < ngpio; bit++, bitpos = bitpos << 1) {
301 if (!(mask & bitpos))
302 continue;
303 else
304 gpio_set_value(base + bit, (value & bitpos) != 0);
305 }
306 }
307 EXPORT_SYMBOL(ams_delta_latch_write);
308
309 static struct resource ams_delta_nand_resources[] = {
310 [0] = {
311 .start = OMAP1_MPUIO_BASE,
312 .end = OMAP1_MPUIO_BASE +
313 OMAP_MPUIO_IO_CNTL + sizeof(u32) - 1,
314 .flags = IORESOURCE_MEM,
315 },
316 };
317
318 static struct platform_device ams_delta_nand_device = {
319 .name = "ams-delta-nand",
320 .id = -1,
321 .num_resources = ARRAY_SIZE(ams_delta_nand_resources),
322 .resource = ams_delta_nand_resources,
323 };
324
325 static struct resource ams_delta_kp_resources[] = {
326 [0] = {
327 .start = INT_KEYBOARD,
328 .end = INT_KEYBOARD,
329 .flags = IORESOURCE_IRQ,
330 },
331 };
332
333 static const struct matrix_keymap_data ams_delta_keymap_data = {
334 .keymap = ams_delta_keymap,
335 .keymap_size = ARRAY_SIZE(ams_delta_keymap),
336 };
337
338 static struct omap_kp_platform_data ams_delta_kp_data = {
339 .rows = 8,
340 .cols = 8,
341 .keymap_data = &ams_delta_keymap_data,
342 .delay = 9,
343 };
344
345 static struct platform_device ams_delta_kp_device = {
346 .name = "omap-keypad",
347 .id = -1,
348 .dev = {
349 .platform_data = &ams_delta_kp_data,
350 },
351 .num_resources = ARRAY_SIZE(ams_delta_kp_resources),
352 .resource = ams_delta_kp_resources,
353 };
354
355 static struct platform_device ams_delta_lcd_device = {
356 .name = "lcd_ams_delta",
357 .id = -1,
358 };
359
360 static const struct gpio_led gpio_leds[] __initconst = {
361 {
362 .name = "camera",
363 .gpio = LATCH1_GPIO_BASE + 0,
364 .default_state = LEDS_GPIO_DEFSTATE_OFF,
365 #ifdef CONFIG_LEDS_TRIGGERS
366 .default_trigger = "ams_delta_camera",
367 #endif
368 },
369 {
370 .name = "advert",
371 .gpio = LATCH1_GPIO_BASE + 1,
372 .default_state = LEDS_GPIO_DEFSTATE_OFF,
373 },
374 {
375 .name = "email",
376 .gpio = LATCH1_GPIO_BASE + 2,
377 .default_state = LEDS_GPIO_DEFSTATE_OFF,
378 },
379 {
380 .name = "handsfree",
381 .gpio = LATCH1_GPIO_BASE + 3,
382 .default_state = LEDS_GPIO_DEFSTATE_OFF,
383 },
384 {
385 .name = "voicemail",
386 .gpio = LATCH1_GPIO_BASE + 4,
387 .default_state = LEDS_GPIO_DEFSTATE_OFF,
388 },
389 {
390 .name = "voice",
391 .gpio = LATCH1_GPIO_BASE + 5,
392 .default_state = LEDS_GPIO_DEFSTATE_OFF,
393 },
394 };
395
396 static const struct gpio_led_platform_data leds_pdata __initconst = {
397 .leds = gpio_leds,
398 .num_leds = ARRAY_SIZE(gpio_leds),
399 };
400
401 static struct i2c_board_info ams_delta_camera_board_info[] = {
402 {
403 I2C_BOARD_INFO("ov6650", 0x60),
404 },
405 };
406
407 #ifdef CONFIG_LEDS_TRIGGERS
408 DEFINE_LED_TRIGGER(ams_delta_camera_led_trigger);
409
410 static int ams_delta_camera_power(struct device *dev, int power)
411 {
412 /*
413 * turn on camera LED
414 */
415 if (power)
416 led_trigger_event(ams_delta_camera_led_trigger, LED_FULL);
417 else
418 led_trigger_event(ams_delta_camera_led_trigger, LED_OFF);
419 return 0;
420 }
421 #else
422 #define ams_delta_camera_power NULL
423 #endif
424
425 static struct soc_camera_link ams_delta_iclink = {
426 .bus_id = 0, /* OMAP1 SoC camera bus */
427 .i2c_adapter_id = 1,
428 .board_info = &ams_delta_camera_board_info[0],
429 .module_name = "ov6650",
430 .power = ams_delta_camera_power,
431 };
432
433 static struct platform_device ams_delta_camera_device = {
434 .name = "soc-camera-pdrv",
435 .id = 0,
436 .dev = {
437 .platform_data = &ams_delta_iclink,
438 },
439 };
440
441 static struct omap1_cam_platform_data ams_delta_camera_platform_data = {
442 .camexclk_khz = 12000, /* default 12MHz clock, no extra DPLL */
443 .lclk_khz_max = 1334, /* results in 5fps CIF, 10fps QCIF */
444 };
445
446 static struct platform_device *ams_delta_devices[] __initdata = {
447 &latch1_gpio_device,
448 &latch2_gpio_device,
449 &ams_delta_kp_device,
450 &ams_delta_camera_device,
451 };
452
453 static struct platform_device *late_devices[] __initdata = {
454 &ams_delta_nand_device,
455 &ams_delta_lcd_device,
456 };
457
458 static void __init ams_delta_init(void)
459 {
460 /* mux pins for uarts */
461 omap_cfg_reg(UART1_TX);
462 omap_cfg_reg(UART1_RTS);
463
464 /* parallel camera interface */
465 omap_cfg_reg(H19_1610_CAM_EXCLK);
466 omap_cfg_reg(J15_1610_CAM_LCLK);
467 omap_cfg_reg(L18_1610_CAM_VS);
468 omap_cfg_reg(L15_1610_CAM_HS);
469 omap_cfg_reg(L19_1610_CAM_D0);
470 omap_cfg_reg(K14_1610_CAM_D1);
471 omap_cfg_reg(K15_1610_CAM_D2);
472 omap_cfg_reg(K19_1610_CAM_D3);
473 omap_cfg_reg(K18_1610_CAM_D4);
474 omap_cfg_reg(J14_1610_CAM_D5);
475 omap_cfg_reg(J19_1610_CAM_D6);
476 omap_cfg_reg(J18_1610_CAM_D7);
477
478 omap_serial_init();
479 omap_register_i2c_bus(1, 100, NULL, 0);
480
481 omap1_usb_init(&ams_delta_usb_config);
482 omap1_set_camera_info(&ams_delta_camera_platform_data);
483 #ifdef CONFIG_LEDS_TRIGGERS
484 led_trigger_register_simple("ams_delta_camera",
485 &ams_delta_camera_led_trigger);
486 #endif
487 gpio_led_register_device(-1, &leds_pdata);
488 platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices));
489
490 ams_delta_init_fiq();
491
492 omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1);
493
494 omapfb_set_lcd_config(&ams_delta_lcd_config);
495 }
496
497 static void modem_pm(struct uart_port *port, unsigned int state, unsigned old)
498 {
499 struct modem_private_data *priv = port->private_data;
500
501 if (IS_ERR(priv->regulator))
502 return;
503
504 if (state == old)
505 return;
506
507 if (state == 0)
508 regulator_enable(priv->regulator);
509 else if (old == 0)
510 regulator_disable(priv->regulator);
511 }
512
513 static struct plat_serial8250_port ams_delta_modem_ports[] = {
514 {
515 .membase = IOMEM(MODEM_VIRT),
516 .mapbase = MODEM_PHYS,
517 .irq = -EINVAL, /* changed later */
518 .flags = UPF_BOOT_AUTOCONF,
519 .irqflags = IRQF_TRIGGER_RISING,
520 .iotype = UPIO_MEM,
521 .regshift = 1,
522 .uartclk = BASE_BAUD * 16,
523 .pm = modem_pm,
524 .private_data = &modem_priv,
525 },
526 { },
527 };
528
529 static struct platform_device ams_delta_modem_device = {
530 .name = "serial8250",
531 .id = PLAT8250_DEV_PLATFORM1,
532 .dev = {
533 .platform_data = ams_delta_modem_ports,
534 },
535 };
536
537 static int __init late_init(void)
538 {
539 int err;
540
541 if (!machine_is_ams_delta())
542 return -ENODEV;
543
544 err = gpio_request_array(latch_gpios, ARRAY_SIZE(latch_gpios));
545 if (err) {
546 pr_err("Couldn't take over latch1/latch2 GPIO pins\n");
547 return err;
548 }
549
550 platform_add_devices(late_devices, ARRAY_SIZE(late_devices));
551
552 err = platform_device_register(&modem_nreset_device);
553 if (err) {
554 pr_err("Couldn't register the modem regulator device\n");
555 return err;
556 }
557
558 omap_cfg_reg(M14_1510_GPIO2);
559 ams_delta_modem_ports[0].irq =
560 gpio_to_irq(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
561
562 err = gpio_request(AMS_DELTA_GPIO_PIN_MODEM_IRQ, "modem");
563 if (err) {
564 pr_err("Couldn't request gpio pin for modem\n");
565 return err;
566 }
567 gpio_direction_input(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
568
569 /* Initialize the modem_nreset regulator consumer before use */
570 modem_priv.regulator = ERR_PTR(-ENODEV);
571
572 ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_CODEC,
573 AMS_DELTA_LATCH2_MODEM_CODEC);
574
575 err = platform_device_register(&ams_delta_modem_device);
576 if (err)
577 goto gpio_free;
578
579 /*
580 * Once the modem device is registered, the modem_nreset
581 * regulator can be requested on behalf of that device.
582 */
583 modem_priv.regulator = regulator_get(&ams_delta_modem_device.dev,
584 "RESET#");
585 if (IS_ERR(modem_priv.regulator)) {
586 err = PTR_ERR(modem_priv.regulator);
587 goto unregister;
588 }
589 return 0;
590
591 unregister:
592 platform_device_unregister(&ams_delta_modem_device);
593 gpio_free:
594 gpio_free(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
595 return err;
596 }
597
598 static void __init ams_delta_init_late(void)
599 {
600 omap1_init_late();
601 late_init();
602 }
603
604 static void __init ams_delta_map_io(void)
605 {
606 omap15xx_map_io();
607 iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc));
608 }
609
610 MACHINE_START(AMS_DELTA, "Amstrad E3 (Delta)")
611 /* Maintainer: Jonathan McDowell <noodles@earth.li> */
612 .atag_offset = 0x100,
613 .map_io = ams_delta_map_io,
614 .init_early = omap1_init_early,
615 .reserve = omap_reserve,
616 .init_irq = omap1_init_irq,
617 .init_machine = ams_delta_init,
618 .init_late = ams_delta_init_late,
619 .timer = &omap1_timer,
620 .restart = omap1_restart,
621 MACHINE_END
Linux kernel - Deliverables
This page took 0.042042 seconds and 4 git commands to generate.