1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/gpio/driver.h>
15#include <linux/gpio/machine.h>
16#include <linux/gpio.h>
17#include <linux/kernel.h>
18#include <linux/init.h>
19#include <linux/input.h>
20#include <linux/interrupt.h>
21#include <linux/leds.h>
22#include <linux/platform_device.h>
23#include <linux/regulator/consumer.h>
24#include <linux/regulator/fixed.h>
25#include <linux/regulator/machine.h>
26#include <linux/serial_8250.h>
27#include <linux/export.h>
28#include <linux/omapfb.h>
29#include <linux/io.h>
30#include <linux/platform_data/gpio-omap.h>
31
32#include <media/soc_camera.h>
33
34#include <asm/serial.h>
35#include <asm/mach-types.h>
36#include <asm/mach/arch.h>
37#include <asm/mach/map.h>
38
39#include <mach/board-ams-delta.h>
40#include <linux/platform_data/keypad-omap.h>
41#include <mach/mux.h>
42
43#include <mach/hardware.h>
44#include "camera.h"
45#include <mach/usb.h>
46
47#include "ams-delta-fiq.h"
48#include "iomap.h"
49#include "common.h"
50
51static const unsigned int ams_delta_keymap[] = {
52 KEY(0, 0, KEY_F1),
53
54 KEY(0, 3, KEY_COFFEE),
55 KEY(0, 2, KEY_QUESTION),
56 KEY(2, 3, KEY_CONNECT),
57 KEY(1, 2, KEY_SHOP),
58 KEY(1, 1, KEY_PHONE),
59
60 KEY(0, 1, KEY_DELETE),
61 KEY(2, 2, KEY_PLAY),
62 KEY(1, 0, KEY_PAGEUP),
63 KEY(1, 3, KEY_PAGEDOWN),
64 KEY(2, 0, KEY_EMAIL),
65 KEY(2, 1, KEY_STOP),
66
67
68 KEY(0, 7, KEY_KP1),
69 KEY(0, 6, KEY_KP2),
70 KEY(0, 5, KEY_KP3),
71 KEY(1, 7, KEY_KP4),
72 KEY(1, 6, KEY_KP5),
73 KEY(1, 5, KEY_KP6),
74 KEY(2, 7, KEY_KP7),
75 KEY(2, 6, KEY_KP8),
76 KEY(2, 5, KEY_KP9),
77 KEY(3, 6, KEY_KP0),
78 KEY(3, 7, KEY_KPASTERISK),
79 KEY(3, 5, KEY_KPDOT),
80 KEY(7, 2, KEY_NUMLOCK),
81 KEY(7, 1, KEY_KPMINUS),
82 KEY(6, 1, KEY_KPPLUS),
83 KEY(7, 6, KEY_KPSLASH),
84 KEY(6, 0, KEY_ENTER),
85
86 KEY(7, 4, KEY_CAMERA),
87
88 KEY(0, 4, KEY_F2),
89 KEY(1, 4, KEY_F3),
90 KEY(2, 4, KEY_F4),
91 KEY(7, 7, KEY_F5),
92 KEY(7, 5, KEY_F6),
93
94
95 KEY(3, 4, KEY_Q),
96 KEY(3, 3, KEY_W),
97 KEY(3, 2, KEY_E),
98 KEY(3, 1, KEY_R),
99 KEY(3, 0, KEY_T),
100 KEY(4, 7, KEY_Y),
101 KEY(4, 6, KEY_U),
102 KEY(4, 5, KEY_I),
103 KEY(4, 4, KEY_O),
104 KEY(4, 3, KEY_P),
105
106 KEY(4, 2, KEY_A),
107 KEY(4, 1, KEY_S),
108 KEY(4, 0, KEY_D),
109 KEY(5, 7, KEY_F),
110 KEY(5, 6, KEY_G),
111 KEY(5, 5, KEY_H),
112 KEY(5, 4, KEY_J),
113 KEY(5, 3, KEY_K),
114 KEY(5, 2, KEY_L),
115
116 KEY(5, 1, KEY_Z),
117 KEY(5, 0, KEY_X),
118 KEY(6, 7, KEY_C),
119 KEY(6, 6, KEY_V),
120 KEY(6, 5, KEY_B),
121 KEY(6, 4, KEY_N),
122 KEY(6, 3, KEY_M),
123 KEY(6, 2, KEY_SPACE),
124
125 KEY(7, 0, KEY_LEFTSHIFT),
126 KEY(7, 3, KEY_LEFTCTRL),
127};
128
129#define LATCH1_PHYS 0x01000000
130#define LATCH1_VIRT 0xEA000000
131#define MODEM_PHYS 0x04000000
132#define MODEM_VIRT 0xEB000000
133#define LATCH2_PHYS 0x08000000
134#define LATCH2_VIRT 0xEC000000
135
136static struct map_desc ams_delta_io_desc[] __initdata = {
137
138 {
139 .virtual = LATCH1_VIRT,
140 .pfn = __phys_to_pfn(LATCH1_PHYS),
141 .length = 0x01000000,
142 .type = MT_DEVICE
143 },
144
145 {
146 .virtual = LATCH2_VIRT,
147 .pfn = __phys_to_pfn(LATCH2_PHYS),
148 .length = 0x01000000,
149 .type = MT_DEVICE
150 },
151
152 {
153 .virtual = MODEM_VIRT,
154 .pfn = __phys_to_pfn(MODEM_PHYS),
155 .length = 0x01000000,
156 .type = MT_DEVICE
157 }
158};
159
160static const struct omap_lcd_config ams_delta_lcd_config __initconst = {
161 .ctrl_name = "internal",
162};
163
164static struct omap_usb_config ams_delta_usb_config __initdata = {
165 .register_host = 1,
166 .hmc_mode = 16,
167 .pins[0] = 2,
168};
169
170#define LATCH1_GPIO_BASE 232
171#define LATCH1_NGPIO 8
172
173static struct resource latch1_resources[] = {
174 [0] = {
175 .name = "dat",
176 .start = LATCH1_PHYS,
177 .end = LATCH1_PHYS + (LATCH1_NGPIO - 1) / 8,
178 .flags = IORESOURCE_MEM,
179 },
180};
181
182#define LATCH1_LABEL "latch1"
183
184static struct bgpio_pdata latch1_pdata = {
185 .label = LATCH1_LABEL,
186 .base = LATCH1_GPIO_BASE,
187 .ngpio = LATCH1_NGPIO,
188};
189
190static struct platform_device latch1_gpio_device = {
191 .name = "basic-mmio-gpio",
192 .id = 0,
193 .resource = latch1_resources,
194 .num_resources = ARRAY_SIZE(latch1_resources),
195 .dev = {
196 .platform_data = &latch1_pdata,
197 },
198};
199
200#define LATCH1_PIN_LED_CAMERA 0
201#define LATCH1_PIN_LED_ADVERT 1
202#define LATCH1_PIN_LED_MAIL 2
203#define LATCH1_PIN_LED_HANDSFREE 3
204#define LATCH1_PIN_LED_VOICEMAIL 4
205#define LATCH1_PIN_LED_VOICE 5
206#define LATCH1_PIN_DOCKIT1 6
207#define LATCH1_PIN_DOCKIT2 7
208
209static struct resource latch2_resources[] = {
210 [0] = {
211 .name = "dat",
212 .start = LATCH2_PHYS,
213 .end = LATCH2_PHYS + (AMS_DELTA_LATCH2_NGPIO - 1) / 8,
214 .flags = IORESOURCE_MEM,
215 },
216};
217
218#define LATCH2_LABEL "latch2"
219
220static struct bgpio_pdata latch2_pdata = {
221 .label = LATCH2_LABEL,
222 .base = AMS_DELTA_LATCH2_GPIO_BASE,
223 .ngpio = AMS_DELTA_LATCH2_NGPIO,
224};
225
226static struct platform_device latch2_gpio_device = {
227 .name = "basic-mmio-gpio",
228 .id = 1,
229 .resource = latch2_resources,
230 .num_resources = ARRAY_SIZE(latch2_resources),
231 .dev = {
232 .platform_data = &latch2_pdata,
233 },
234};
235
236#define LATCH2_PIN_LCD_VBLEN 0
237#define LATCH2_PIN_LCD_NDISP 1
238#define LATCH2_PIN_NAND_NCE 2
239#define LATCH2_PIN_NAND_NRE 3
240#define LATCH2_PIN_NAND_NWP 4
241#define LATCH2_PIN_NAND_NWE 5
242#define LATCH2_PIN_NAND_ALE 6
243#define LATCH2_PIN_NAND_CLE 7
244#define LATCH2_PIN_KEYBRD_PWR 8
245#define LATCH2_PIN_KEYBRD_DATAOUT 9
246#define LATCH2_PIN_SCARD_RSTIN 10
247#define LATCH2_PIN_SCARD_CMDVCC 11
248#define LATCH2_PIN_MODEM_NRESET 12
249#define LATCH2_PIN_MODEM_CODEC 13
250#define LATCH2_PIN_HOOKFLASH1 14
251#define LATCH2_PIN_HOOKFLASH2 15
252
253static const struct gpio latch_gpios[] __initconst = {
254 {
255 .gpio = LATCH1_GPIO_BASE + 6,
256 .flags = GPIOF_OUT_INIT_LOW,
257 .label = "dockit1",
258 },
259 {
260 .gpio = LATCH1_GPIO_BASE + 7,
261 .flags = GPIOF_OUT_INIT_LOW,
262 .label = "dockit2",
263 },
264 {
265 .gpio = AMS_DELTA_GPIO_PIN_SCARD_RSTIN,
266 .flags = GPIOF_OUT_INIT_LOW,
267 .label = "scard_rstin",
268 },
269 {
270 .gpio = AMS_DELTA_GPIO_PIN_SCARD_CMDVCC,
271 .flags = GPIOF_OUT_INIT_LOW,
272 .label = "scard_cmdvcc",
273 },
274 {
275 .gpio = AMS_DELTA_LATCH2_GPIO_BASE + 14,
276 .flags = GPIOF_OUT_INIT_LOW,
277 .label = "hookflash1",
278 },
279 {
280 .gpio = AMS_DELTA_LATCH2_GPIO_BASE + 15,
281 .flags = GPIOF_OUT_INIT_LOW,
282 .label = "hookflash2",
283 },
284};
285
286static struct regulator_consumer_supply modem_nreset_consumers[] = {
287 REGULATOR_SUPPLY("RESET#", "serial8250.1"),
288 REGULATOR_SUPPLY("POR", "cx20442-codec"),
289};
290
291static struct regulator_init_data modem_nreset_data = {
292 .constraints = {
293 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
294 .boot_on = 1,
295 },
296 .num_consumer_supplies = ARRAY_SIZE(modem_nreset_consumers),
297 .consumer_supplies = modem_nreset_consumers,
298};
299
300static struct fixed_voltage_config modem_nreset_config = {
301 .supply_name = "modem_nreset",
302 .microvolts = 3300000,
303 .gpio = AMS_DELTA_GPIO_PIN_MODEM_NRESET,
304 .startup_delay = 25000,
305 .enable_high = 1,
306 .enabled_at_boot = 1,
307 .init_data = &modem_nreset_data,
308};
309
310static struct platform_device modem_nreset_device = {
311 .name = "reg-fixed-voltage",
312 .id = -1,
313 .dev = {
314 .platform_data = &modem_nreset_config,
315 },
316};
317
318struct modem_private_data {
319 struct regulator *regulator;
320};
321
322static struct modem_private_data modem_priv;
323
324void ams_delta_latch_write(int base, int ngpio, u16 mask, u16 value)
325{
326 int bit = 0;
327 u16 bitpos = 1 << bit;
328
329 for (; bit < ngpio; bit++, bitpos = bitpos << 1) {
330 if (!(mask & bitpos))
331 continue;
332 else
333 gpio_set_value(base + bit, (value & bitpos) != 0);
334 }
335}
336EXPORT_SYMBOL(ams_delta_latch_write);
337
338static struct resource ams_delta_nand_resources[] = {
339 [0] = {
340 .start = OMAP1_MPUIO_BASE,
341 .end = OMAP1_MPUIO_BASE +
342 OMAP_MPUIO_IO_CNTL + sizeof(u32) - 1,
343 .flags = IORESOURCE_MEM,
344 },
345};
346
347static struct platform_device ams_delta_nand_device = {
348 .name = "ams-delta-nand",
349 .id = -1,
350 .num_resources = ARRAY_SIZE(ams_delta_nand_resources),
351 .resource = ams_delta_nand_resources,
352};
353
354#define OMAP_GPIO_LABEL "gpio-0-15"
355
356static struct gpiod_lookup_table ams_delta_nand_gpio_table = {
357 .table = {
358 GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_NAND_RB, "rdy",
359 0),
360 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NCE, "nce", 0),
361 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NRE, "nre", 0),
362 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NWP, "nwp", 0),
363 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NWE, "nwe", 0),
364 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_ALE, "ale", 0),
365 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_CLE, "cle", 0),
366 { },
367 },
368};
369
370static struct resource ams_delta_kp_resources[] = {
371 [0] = {
372 .start = INT_KEYBOARD,
373 .end = INT_KEYBOARD,
374 .flags = IORESOURCE_IRQ,
375 },
376};
377
378static const struct matrix_keymap_data ams_delta_keymap_data = {
379 .keymap = ams_delta_keymap,
380 .keymap_size = ARRAY_SIZE(ams_delta_keymap),
381};
382
383static struct omap_kp_platform_data ams_delta_kp_data = {
384 .rows = 8,
385 .cols = 8,
386 .keymap_data = &ams_delta_keymap_data,
387 .delay = 9,
388};
389
390static struct platform_device ams_delta_kp_device = {
391 .name = "omap-keypad",
392 .id = -1,
393 .dev = {
394 .platform_data = &ams_delta_kp_data,
395 },
396 .num_resources = ARRAY_SIZE(ams_delta_kp_resources),
397 .resource = ams_delta_kp_resources,
398};
399
400static struct platform_device ams_delta_lcd_device = {
401 .name = "lcd_ams_delta",
402 .id = -1,
403};
404
405static struct gpiod_lookup_table ams_delta_lcd_gpio_table = {
406 .table = {
407 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_LCD_VBLEN, "vblen", 0),
408 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_LCD_NDISP, "ndisp", 0),
409 { },
410 },
411};
412
413
414
415
416
417
418static struct gpio_led gpio_leds[] __initdata = {
419 [LATCH1_PIN_LED_CAMERA] = {
420 .name = "camera",
421 .gpio = -EINVAL,
422 .default_state = LEDS_GPIO_DEFSTATE_OFF,
423#ifdef CONFIG_LEDS_TRIGGERS
424 .default_trigger = "ams_delta_camera",
425#endif
426 },
427 [LATCH1_PIN_LED_ADVERT] = {
428 .name = "advert",
429 .gpio = -EINVAL,
430 .default_state = LEDS_GPIO_DEFSTATE_OFF,
431 },
432 [LATCH1_PIN_LED_MAIL] = {
433 .name = "email",
434 .gpio = -EINVAL,
435 .default_state = LEDS_GPIO_DEFSTATE_OFF,
436 },
437 [LATCH1_PIN_LED_HANDSFREE] = {
438 .name = "handsfree",
439 .gpio = -EINVAL,
440 .default_state = LEDS_GPIO_DEFSTATE_OFF,
441 },
442 [LATCH1_PIN_LED_VOICEMAIL] = {
443 .name = "voicemail",
444 .gpio = -EINVAL,
445 .default_state = LEDS_GPIO_DEFSTATE_OFF,
446 },
447 [LATCH1_PIN_LED_VOICE] = {
448 .name = "voice",
449 .gpio = -EINVAL,
450 .default_state = LEDS_GPIO_DEFSTATE_OFF,
451 },
452};
453
454static const struct gpio_led_platform_data leds_pdata __initconst = {
455 .leds = gpio_leds,
456 .num_leds = ARRAY_SIZE(gpio_leds),
457};
458
459static struct i2c_board_info ams_delta_camera_board_info[] = {
460 {
461 I2C_BOARD_INFO("ov6650", 0x60),
462 },
463};
464
465#ifdef CONFIG_LEDS_TRIGGERS
466DEFINE_LED_TRIGGER(ams_delta_camera_led_trigger);
467
468static int ams_delta_camera_power(struct device *dev, int power)
469{
470
471
472
473 if (power)
474 led_trigger_event(ams_delta_camera_led_trigger, LED_FULL);
475 else
476 led_trigger_event(ams_delta_camera_led_trigger, LED_OFF);
477 return 0;
478}
479#else
480#define ams_delta_camera_power NULL
481#endif
482
483static struct soc_camera_link ams_delta_iclink = {
484 .bus_id = 0,
485 .i2c_adapter_id = 1,
486 .board_info = &ams_delta_camera_board_info[0],
487 .module_name = "ov6650",
488 .power = ams_delta_camera_power,
489};
490
491static struct platform_device ams_delta_camera_device = {
492 .name = "soc-camera-pdrv",
493 .id = 0,
494 .dev = {
495 .platform_data = &ams_delta_iclink,
496 },
497};
498
499static struct omap1_cam_platform_data ams_delta_camera_platform_data = {
500 .camexclk_khz = 12000,
501 .lclk_khz_max = 1334,
502};
503
504static struct platform_device ams_delta_audio_device = {
505 .name = "ams-delta-audio",
506 .id = -1,
507};
508
509static struct gpiod_lookup_table ams_delta_audio_gpio_table = {
510 .table = {
511 GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_HOOK_SWITCH,
512 "hook_switch", 0),
513 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_MODEM_CODEC,
514 "modem_codec", 0),
515 { },
516 },
517};
518
519static struct platform_device cx20442_codec_device = {
520 .name = "cx20442-codec",
521 .id = -1,
522};
523
524static struct resource ams_delta_serio_resources[] = {
525 {
526 .flags = IORESOURCE_IRQ,
527
528
529
530
531
532 .start = -EINVAL,
533 .end = -EINVAL,
534 },
535};
536
537static struct platform_device ams_delta_serio_device = {
538 .name = "ams-delta-serio",
539 .id = PLATFORM_DEVID_NONE,
540 .dev = {
541
542
543
544
545
546 .platform_data = NULL,
547 },
548 .num_resources = ARRAY_SIZE(ams_delta_serio_resources),
549 .resource = ams_delta_serio_resources,
550};
551
552static struct regulator_consumer_supply keybrd_pwr_consumers[] = {
553
554
555
556
557 REGULATOR_SUPPLY("vcc", NULL),
558};
559
560static struct regulator_init_data keybrd_pwr_initdata = {
561 .constraints = {
562 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
563 },
564 .num_consumer_supplies = ARRAY_SIZE(keybrd_pwr_consumers),
565 .consumer_supplies = keybrd_pwr_consumers,
566};
567
568static struct fixed_voltage_config keybrd_pwr_config = {
569 .supply_name = "keybrd_pwr",
570 .microvolts = 5000000,
571 .gpio = AMS_DELTA_GPIO_PIN_KEYBRD_PWR,
572 .enable_high = 1,
573 .init_data = &keybrd_pwr_initdata,
574};
575
576static struct platform_device keybrd_pwr_device = {
577 .name = "reg-fixed-voltage",
578 .id = PLATFORM_DEVID_AUTO,
579 .dev = {
580 .platform_data = &keybrd_pwr_config,
581 },
582};
583
584static struct gpiod_lookup_table keybrd_pwr_gpio_table = {
585 .table = {
586 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_KEYBRD_PWR, NULL,
587 GPIO_ACTIVE_HIGH),
588 { },
589 },
590};
591
592static struct platform_device *ams_delta_devices[] __initdata = {
593 &latch1_gpio_device,
594 &latch2_gpio_device,
595 &ams_delta_kp_device,
596 &ams_delta_camera_device,
597 &ams_delta_audio_device,
598 &ams_delta_serio_device,
599 &ams_delta_nand_device,
600 &ams_delta_lcd_device,
601 &cx20442_codec_device,
602};
603
604static struct gpiod_lookup_table *ams_delta_gpio_tables[] __initdata = {
605 &ams_delta_audio_gpio_table,
606 &keybrd_pwr_gpio_table,
607 &ams_delta_lcd_gpio_table,
608 &ams_delta_nand_gpio_table,
609};
610
611
612
613
614
615
616
617
618
619
620static int gpiochip_match_by_label(struct gpio_chip *chip, void *data)
621{
622 char *label = data;
623
624 return !strcmp(label, chip->label);
625}
626
627static struct gpiod_hog ams_delta_gpio_hogs[] = {
628 GPIO_HOG(LATCH2_LABEL, LATCH2_PIN_KEYBRD_DATAOUT, "keybrd_dataout",
629 GPIO_ACTIVE_HIGH, GPIOD_OUT_LOW),
630 {},
631};
632
633
634
635
636
637
638
639
640
641
642static void __init omap_gpio_deps_init(void)
643{
644 struct gpio_chip *chip;
645
646 chip = gpiochip_find(OMAP_GPIO_LABEL, gpiochip_match_by_label);
647 if (!chip) {
648 pr_err("%s: OMAP GPIO chip not found\n", __func__);
649 return;
650 }
651
652 ams_delta_init_fiq(chip, &ams_delta_serio_device);
653}
654
655static void __init ams_delta_init(void)
656{
657
658 omap_cfg_reg(UART1_TX);
659 omap_cfg_reg(UART1_RTS);
660
661
662 omap_cfg_reg(H19_1610_CAM_EXCLK);
663 omap_cfg_reg(J15_1610_CAM_LCLK);
664 omap_cfg_reg(L18_1610_CAM_VS);
665 omap_cfg_reg(L15_1610_CAM_HS);
666 omap_cfg_reg(L19_1610_CAM_D0);
667 omap_cfg_reg(K14_1610_CAM_D1);
668 omap_cfg_reg(K15_1610_CAM_D2);
669 omap_cfg_reg(K19_1610_CAM_D3);
670 omap_cfg_reg(K18_1610_CAM_D4);
671 omap_cfg_reg(J14_1610_CAM_D5);
672 omap_cfg_reg(J19_1610_CAM_D6);
673 omap_cfg_reg(J18_1610_CAM_D7);
674
675 omap_gpio_deps_init();
676 gpiod_add_hogs(ams_delta_gpio_hogs);
677
678 omap_serial_init();
679 omap_register_i2c_bus(1, 100, NULL, 0);
680
681 omap1_usb_init(&ams_delta_usb_config);
682 omap1_set_camera_info(&ams_delta_camera_platform_data);
683#ifdef CONFIG_LEDS_TRIGGERS
684 led_trigger_register_simple("ams_delta_camera",
685 &ams_delta_camera_led_trigger);
686#endif
687 platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices));
688
689
690
691
692
693 keybrd_pwr_consumers[0].dev_name =
694 dev_name(&ams_delta_serio_device.dev);
695
696
697
698
699
700
701 platform_device_register(&keybrd_pwr_device);
702
703
704
705
706
707 ams_delta_audio_gpio_table.dev_id =
708 dev_name(&ams_delta_audio_device.dev);
709 keybrd_pwr_gpio_table.dev_id = dev_name(&keybrd_pwr_device.dev);
710 ams_delta_nand_gpio_table.dev_id = dev_name(&ams_delta_nand_device.dev);
711 ams_delta_lcd_gpio_table.dev_id = dev_name(&ams_delta_lcd_device.dev);
712
713
714
715
716 gpiod_add_lookup_tables(ams_delta_gpio_tables,
717 ARRAY_SIZE(ams_delta_gpio_tables));
718
719 omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1);
720
721 omapfb_set_lcd_config(&ams_delta_lcd_config);
722}
723
724static void modem_pm(struct uart_port *port, unsigned int state, unsigned old)
725{
726 struct modem_private_data *priv = port->private_data;
727 int ret;
728
729 if (IS_ERR(priv->regulator))
730 return;
731
732 if (state == old)
733 return;
734
735 if (state == 0)
736 ret = regulator_enable(priv->regulator);
737 else if (old == 0)
738 ret = regulator_disable(priv->regulator);
739 else
740 ret = 0;
741
742 if (ret)
743 dev_warn(port->dev,
744 "ams_delta modem_pm: failed to %sable regulator: %d\n",
745 state ? "dis" : "en", ret);
746}
747
748static struct plat_serial8250_port ams_delta_modem_ports[] = {
749 {
750 .membase = IOMEM(MODEM_VIRT),
751 .mapbase = MODEM_PHYS,
752 .irq = -EINVAL,
753 .flags = UPF_BOOT_AUTOCONF,
754 .irqflags = IRQF_TRIGGER_RISING,
755 .iotype = UPIO_MEM,
756 .regshift = 1,
757 .uartclk = BASE_BAUD * 16,
758 .pm = modem_pm,
759 .private_data = &modem_priv,
760 },
761 { },
762};
763
764static struct platform_device ams_delta_modem_device = {
765 .name = "serial8250",
766 .id = PLAT8250_DEV_PLATFORM1,
767 .dev = {
768 .platform_data = ams_delta_modem_ports,
769 },
770};
771
772
773
774
775
776
777
778
779
780
781static void __init ams_delta_led_init(struct gpio_chip *chip)
782{
783 struct gpio_desc *gpiod;
784 int i;
785
786 for (i = LATCH1_PIN_LED_CAMERA; i < LATCH1_PIN_DOCKIT1; i++) {
787 gpiod = gpiochip_request_own_desc(chip, i, NULL);
788 if (IS_ERR(gpiod)) {
789 pr_warn("%s: %s GPIO %d request failed (%ld)\n",
790 __func__, LATCH1_LABEL, i, PTR_ERR(gpiod));
791 continue;
792 }
793
794
795 gpio_leds[i].gpio = desc_to_gpio(gpiod);
796
797 gpiochip_free_own_desc(gpiod);
798 }
799
800 gpio_led_register_device(PLATFORM_DEVID_NONE, &leds_pdata);
801}
802
803
804
805
806
807
808
809
810
811
812
813static int __init ams_delta_gpio_init(void)
814{
815 struct gpio_chip *chip;
816 int err;
817
818 if (!machine_is_ams_delta())
819 return -ENODEV;
820
821 chip = gpiochip_find(LATCH1_LABEL, gpiochip_match_by_label);
822 if (!chip)
823 pr_err("%s: latch1 GPIO chip not found\n", __func__);
824 else
825 ams_delta_led_init(chip);
826
827 err = gpio_request_array(latch_gpios, ARRAY_SIZE(latch_gpios));
828 if (err)
829 pr_err("Couldn't take over latch1/latch2 GPIO pins\n");
830
831 return err;
832}
833device_initcall_sync(ams_delta_gpio_init);
834
835static int __init modem_nreset_init(void)
836{
837 int err;
838
839 err = platform_device_register(&modem_nreset_device);
840 if (err)
841 pr_err("Couldn't register the modem regulator device\n");
842
843 return err;
844}
845
846
847static int __init ams_delta_modem_init(void)
848{
849 int err;
850
851 omap_cfg_reg(M14_1510_GPIO2);
852 ams_delta_modem_ports[0].irq =
853 gpio_to_irq(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
854
855 err = gpio_request(AMS_DELTA_GPIO_PIN_MODEM_IRQ, "modem");
856 if (err) {
857 pr_err("Couldn't request gpio pin for modem\n");
858 return err;
859 }
860 gpio_direction_input(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
861
862
863 modem_priv.regulator = ERR_PTR(-ENODEV);
864
865 ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_CODEC,
866 AMS_DELTA_LATCH2_MODEM_CODEC);
867
868 err = platform_device_register(&ams_delta_modem_device);
869 if (err)
870 gpio_free(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
871
872 return err;
873}
874
875static int __init late_init(void)
876{
877 int err;
878
879 err = modem_nreset_init();
880 if (err)
881 return err;
882
883 err = ams_delta_modem_init();
884 if (err)
885 return err;
886
887
888
889
890
891 modem_priv.regulator = regulator_get(&ams_delta_modem_device.dev,
892 "RESET#");
893 if (IS_ERR(modem_priv.regulator)) {
894 err = PTR_ERR(modem_priv.regulator);
895 goto unregister;
896 }
897 return 0;
898
899unregister:
900 platform_device_unregister(&ams_delta_modem_device);
901 gpio_free(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
902 return err;
903}
904
905static void __init ams_delta_init_late(void)
906{
907 omap1_init_late();
908 late_init();
909}
910
911static void __init ams_delta_map_io(void)
912{
913 omap15xx_map_io();
914 iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc));
915}
916
917MACHINE_START(AMS_DELTA, "Amstrad E3 (Delta)")
918
919 .atag_offset = 0x100,
920 .map_io = ams_delta_map_io,
921 .init_early = omap1_init_early,
922 .init_irq = omap1_init_irq,
923 .handle_irq = omap1_handle_irq,
924 .init_machine = ams_delta_init,
925 .init_late = ams_delta_init_late,
926 .init_time = omap1_timer_init,
927 .restart = omap1_restart,
928MACHINE_END
929