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/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 <mach/ams-delta-fiq.h> 45 #include "camera.h" 46 #include <mach/usb.h> 47 48 #include "iomap.h" 49 #include "common.h" 50 51 static const unsigned int ams_delta_keymap[] = { 52 KEY(0, 0, KEY_F1), /* Advert */ 53 54 KEY(0, 3, KEY_COFFEE), /* Games */ 55 KEY(0, 2, KEY_QUESTION), /* Directory */ 56 KEY(2, 3, KEY_CONNECT), /* Internet */ 57 KEY(1, 2, KEY_SHOP), /* Services */ 58 KEY(1, 1, KEY_PHONE), /* VoiceMail */ 59 60 KEY(0, 1, KEY_DELETE), /* Delete */ 61 KEY(2, 2, KEY_PLAY), /* Play */ 62 KEY(1, 0, KEY_PAGEUP), /* Up */ 63 KEY(1, 3, KEY_PAGEDOWN), /* Down */ 64 KEY(2, 0, KEY_EMAIL), /* ReadEmail */ 65 KEY(2, 1, KEY_STOP), /* Stop */ 66 67 /* Numeric keypad portion */ 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), /* # key */ 80 KEY(7, 2, KEY_NUMLOCK), /* Mute */ 81 KEY(7, 1, KEY_KPMINUS), /* Recall */ 82 KEY(6, 1, KEY_KPPLUS), /* Redial */ 83 KEY(7, 6, KEY_KPSLASH), /* Handsfree */ 84 KEY(6, 0, KEY_ENTER), /* Video */ 85 86 KEY(7, 4, KEY_CAMERA), /* Photo */ 87 88 KEY(0, 4, KEY_F2), /* Home */ 89 KEY(1, 4, KEY_F3), /* Office */ 90 KEY(2, 4, KEY_F4), /* Mobile */ 91 KEY(7, 7, KEY_F5), /* SMS */ 92 KEY(7, 5, KEY_F6), /* Email */ 93 94 /* QWERTY portion of keypad */ 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), /* Vol up */ 126 KEY(7, 3, KEY_LEFTCTRL), /* Vol down */ 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 136 static struct map_desc ams_delta_io_desc[] __initdata = { 137 /* AMS_DELTA_LATCH1 */ 138 { 139 .virtual = LATCH1_VIRT, 140 .pfn = __phys_to_pfn(LATCH1_PHYS), 141 .length = 0x01000000, 142 .type = MT_DEVICE 143 }, 144 /* AMS_DELTA_LATCH2 */ 145 { 146 .virtual = LATCH2_VIRT, 147 .pfn = __phys_to_pfn(LATCH2_PHYS), 148 .length = 0x01000000, 149 .type = MT_DEVICE 150 }, 151 /* AMS_DELTA_MODEM */ 152 { 153 .virtual = MODEM_VIRT, 154 .pfn = __phys_to_pfn(MODEM_PHYS), 155 .length = 0x01000000, 156 .type = MT_DEVICE 157 } 158 }; 159 160 static const struct omap_lcd_config ams_delta_lcd_config __initconst = { 161 .ctrl_name = "internal", 162 }; 163 164 static 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 173 static 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 static struct bgpio_pdata latch1_pdata = { 183 .base = LATCH1_GPIO_BASE, 184 .ngpio = LATCH1_NGPIO, 185 }; 186 187 static struct platform_device latch1_gpio_device = { 188 .name = "basic-mmio-gpio", 189 .id = 0, 190 .resource = latch1_resources, 191 .num_resources = ARRAY_SIZE(latch1_resources), 192 .dev = { 193 .platform_data = &latch1_pdata, 194 }, 195 }; 196 197 static struct resource latch2_resources[] = { 198 [0] = { 199 .name = "dat", 200 .start = LATCH2_PHYS, 201 .end = LATCH2_PHYS + (AMS_DELTA_LATCH2_NGPIO - 1) / 8, 202 .flags = IORESOURCE_MEM, 203 }, 204 }; 205 206 #define LATCH2_LABEL "latch2" 207 208 static struct bgpio_pdata latch2_pdata = { 209 .label = LATCH2_LABEL, 210 .base = AMS_DELTA_LATCH2_GPIO_BASE, 211 .ngpio = AMS_DELTA_LATCH2_NGPIO, 212 }; 213 214 static struct platform_device latch2_gpio_device = { 215 .name = "basic-mmio-gpio", 216 .id = 1, 217 .resource = latch2_resources, 218 .num_resources = ARRAY_SIZE(latch2_resources), 219 .dev = { 220 .platform_data = &latch2_pdata, 221 }, 222 }; 223 224 #define LATCH2_PIN_LCD_VBLEN 0 225 #define LATCH2_PIN_LCD_NDISP 1 226 #define LATCH2_PIN_NAND_NCE 2 227 #define LATCH2_PIN_NAND_NRE 3 228 #define LATCH2_PIN_NAND_NWP 4 229 #define LATCH2_PIN_NAND_NWE 5 230 #define LATCH2_PIN_NAND_ALE 6 231 #define LATCH2_PIN_NAND_CLE 7 232 #define LATCH2_PIN_KEYBRD_PWR 8 233 #define LATCH2_PIN_KEYBRD_DATAOUT 9 234 #define LATCH2_PIN_SCARD_RSTIN 10 235 #define LATCH2_PIN_SCARD_CMDVCC 11 236 #define LATCH2_PIN_MODEM_NRESET 12 237 #define LATCH2_PIN_MODEM_CODEC 13 238 #define LATCH2_PIN_HOOKFLASH1 14 239 #define LATCH2_PIN_HOOKFLASH2 15 240 241 static const struct gpio latch_gpios[] __initconst = { 242 { 243 .gpio = LATCH1_GPIO_BASE + 6, 244 .flags = GPIOF_OUT_INIT_LOW, 245 .label = "dockit1", 246 }, 247 { 248 .gpio = LATCH1_GPIO_BASE + 7, 249 .flags = GPIOF_OUT_INIT_LOW, 250 .label = "dockit2", 251 }, 252 { 253 .gpio = AMS_DELTA_GPIO_PIN_SCARD_RSTIN, 254 .flags = GPIOF_OUT_INIT_LOW, 255 .label = "scard_rstin", 256 }, 257 { 258 .gpio = AMS_DELTA_GPIO_PIN_SCARD_CMDVCC, 259 .flags = GPIOF_OUT_INIT_LOW, 260 .label = "scard_cmdvcc", 261 }, 262 { 263 .gpio = AMS_DELTA_LATCH2_GPIO_BASE + 14, 264 .flags = GPIOF_OUT_INIT_LOW, 265 .label = "hookflash1", 266 }, 267 { 268 .gpio = AMS_DELTA_LATCH2_GPIO_BASE + 15, 269 .flags = GPIOF_OUT_INIT_LOW, 270 .label = "hookflash2", 271 }, 272 }; 273 274 static struct regulator_consumer_supply modem_nreset_consumers[] = { 275 REGULATOR_SUPPLY("RESET#", "serial8250.1"), 276 REGULATOR_SUPPLY("POR", "cx20442-codec"), 277 }; 278 279 static struct regulator_init_data modem_nreset_data = { 280 .constraints = { 281 .valid_ops_mask = REGULATOR_CHANGE_STATUS, 282 .boot_on = 1, 283 }, 284 .num_consumer_supplies = ARRAY_SIZE(modem_nreset_consumers), 285 .consumer_supplies = modem_nreset_consumers, 286 }; 287 288 static struct fixed_voltage_config modem_nreset_config = { 289 .supply_name = "modem_nreset", 290 .microvolts = 3300000, 291 .gpio = AMS_DELTA_GPIO_PIN_MODEM_NRESET, 292 .startup_delay = 25000, 293 .enable_high = 1, 294 .enabled_at_boot = 1, 295 .init_data = &modem_nreset_data, 296 }; 297 298 static struct platform_device modem_nreset_device = { 299 .name = "reg-fixed-voltage", 300 .id = -1, 301 .dev = { 302 .platform_data = &modem_nreset_config, 303 }, 304 }; 305 306 struct modem_private_data { 307 struct regulator *regulator; 308 }; 309 310 static struct modem_private_data modem_priv; 311 312 void ams_delta_latch_write(int base, int ngpio, u16 mask, u16 value) 313 { 314 int bit = 0; 315 u16 bitpos = 1 << bit; 316 317 for (; bit < ngpio; bit++, bitpos = bitpos << 1) { 318 if (!(mask & bitpos)) 319 continue; 320 else 321 gpio_set_value(base + bit, (value & bitpos) != 0); 322 } 323 } 324 EXPORT_SYMBOL(ams_delta_latch_write); 325 326 static struct resource ams_delta_nand_resources[] = { 327 [0] = { 328 .start = OMAP1_MPUIO_BASE, 329 .end = OMAP1_MPUIO_BASE + 330 OMAP_MPUIO_IO_CNTL + sizeof(u32) - 1, 331 .flags = IORESOURCE_MEM, 332 }, 333 }; 334 335 static struct platform_device ams_delta_nand_device = { 336 .name = "ams-delta-nand", 337 .id = -1, 338 .num_resources = ARRAY_SIZE(ams_delta_nand_resources), 339 .resource = ams_delta_nand_resources, 340 }; 341 342 #define OMAP_GPIO_LABEL "gpio-0-15" 343 344 static struct gpiod_lookup_table ams_delta_nand_gpio_table = { 345 .table = { 346 GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_NAND_RB, "rdy", 347 0), 348 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NCE, "nce", 0), 349 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NRE, "nre", 0), 350 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NWP, "nwp", 0), 351 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NWE, "nwe", 0), 352 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_ALE, "ale", 0), 353 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_CLE, "cle", 0), 354 { }, 355 }, 356 }; 357 358 static struct resource ams_delta_kp_resources[] = { 359 [0] = { 360 .start = INT_KEYBOARD, 361 .end = INT_KEYBOARD, 362 .flags = IORESOURCE_IRQ, 363 }, 364 }; 365 366 static const struct matrix_keymap_data ams_delta_keymap_data = { 367 .keymap = ams_delta_keymap, 368 .keymap_size = ARRAY_SIZE(ams_delta_keymap), 369 }; 370 371 static struct omap_kp_platform_data ams_delta_kp_data = { 372 .rows = 8, 373 .cols = 8, 374 .keymap_data = &ams_delta_keymap_data, 375 .delay = 9, 376 }; 377 378 static struct platform_device ams_delta_kp_device = { 379 .name = "omap-keypad", 380 .id = -1, 381 .dev = { 382 .platform_data = &ams_delta_kp_data, 383 }, 384 .num_resources = ARRAY_SIZE(ams_delta_kp_resources), 385 .resource = ams_delta_kp_resources, 386 }; 387 388 static struct platform_device ams_delta_lcd_device = { 389 .name = "lcd_ams_delta", 390 .id = -1, 391 }; 392 393 static struct gpiod_lookup_table ams_delta_lcd_gpio_table = { 394 .table = { 395 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_LCD_VBLEN, "vblen", 0), 396 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_LCD_NDISP, "ndisp", 0), 397 { }, 398 }, 399 }; 400 401 static const struct gpio_led gpio_leds[] __initconst = { 402 { 403 .name = "camera", 404 .gpio = LATCH1_GPIO_BASE + 0, 405 .default_state = LEDS_GPIO_DEFSTATE_OFF, 406 #ifdef CONFIG_LEDS_TRIGGERS 407 .default_trigger = "ams_delta_camera", 408 #endif 409 }, 410 { 411 .name = "advert", 412 .gpio = LATCH1_GPIO_BASE + 1, 413 .default_state = LEDS_GPIO_DEFSTATE_OFF, 414 }, 415 { 416 .name = "email", 417 .gpio = LATCH1_GPIO_BASE + 2, 418 .default_state = LEDS_GPIO_DEFSTATE_OFF, 419 }, 420 { 421 .name = "handsfree", 422 .gpio = LATCH1_GPIO_BASE + 3, 423 .default_state = LEDS_GPIO_DEFSTATE_OFF, 424 }, 425 { 426 .name = "voicemail", 427 .gpio = LATCH1_GPIO_BASE + 4, 428 .default_state = LEDS_GPIO_DEFSTATE_OFF, 429 }, 430 { 431 .name = "voice", 432 .gpio = LATCH1_GPIO_BASE + 5, 433 .default_state = LEDS_GPIO_DEFSTATE_OFF, 434 }, 435 }; 436 437 static const struct gpio_led_platform_data leds_pdata __initconst = { 438 .leds = gpio_leds, 439 .num_leds = ARRAY_SIZE(gpio_leds), 440 }; 441 442 static struct i2c_board_info ams_delta_camera_board_info[] = { 443 { 444 I2C_BOARD_INFO("ov6650", 0x60), 445 }, 446 }; 447 448 #ifdef CONFIG_LEDS_TRIGGERS 449 DEFINE_LED_TRIGGER(ams_delta_camera_led_trigger); 450 451 static int ams_delta_camera_power(struct device *dev, int power) 452 { 453 /* 454 * turn on camera LED 455 */ 456 if (power) 457 led_trigger_event(ams_delta_camera_led_trigger, LED_FULL); 458 else 459 led_trigger_event(ams_delta_camera_led_trigger, LED_OFF); 460 return 0; 461 } 462 #else 463 #define ams_delta_camera_power NULL 464 #endif 465 466 static struct soc_camera_link ams_delta_iclink = { 467 .bus_id = 0, /* OMAP1 SoC camera bus */ 468 .i2c_adapter_id = 1, 469 .board_info = &ams_delta_camera_board_info[0], 470 .module_name = "ov6650", 471 .power = ams_delta_camera_power, 472 }; 473 474 static struct platform_device ams_delta_camera_device = { 475 .name = "soc-camera-pdrv", 476 .id = 0, 477 .dev = { 478 .platform_data = &ams_delta_iclink, 479 }, 480 }; 481 482 static struct omap1_cam_platform_data ams_delta_camera_platform_data = { 483 .camexclk_khz = 12000, /* default 12MHz clock, no extra DPLL */ 484 .lclk_khz_max = 1334, /* results in 5fps CIF, 10fps QCIF */ 485 }; 486 487 static struct platform_device ams_delta_audio_device = { 488 .name = "ams-delta-audio", 489 .id = -1, 490 }; 491 492 static struct gpiod_lookup_table ams_delta_audio_gpio_table = { 493 .table = { 494 GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_HOOK_SWITCH, 495 "hook_switch", 0), 496 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_MODEM_CODEC, 497 "modem_codec", 0), 498 { }, 499 }, 500 }; 501 502 static struct platform_device cx20442_codec_device = { 503 .name = "cx20442-codec", 504 .id = -1, 505 }; 506 507 static struct gpiod_lookup_table ams_delta_serio_gpio_table = { 508 .table = { 509 GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_KEYBRD_DATA, 510 "data", 0), 511 GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_KEYBRD_CLK, 512 "clock", 0), 513 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_KEYBRD_PWR, 514 "power", 0), 515 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_KEYBRD_DATAOUT, 516 "dataout", 0), 517 { }, 518 }, 519 }; 520 521 static struct platform_device *ams_delta_devices[] __initdata = { 522 &latch1_gpio_device, 523 &latch2_gpio_device, 524 &ams_delta_kp_device, 525 &ams_delta_camera_device, 526 &ams_delta_audio_device, 527 }; 528 529 static struct platform_device *late_devices[] __initdata = { 530 &ams_delta_nand_device, 531 &ams_delta_lcd_device, 532 &cx20442_codec_device, 533 }; 534 535 static struct gpiod_lookup_table *ams_delta_gpio_tables[] __initdata = { 536 &ams_delta_audio_gpio_table, 537 &ams_delta_serio_gpio_table, 538 }; 539 540 static struct gpiod_lookup_table *late_gpio_tables[] __initdata = { 541 &ams_delta_lcd_gpio_table, 542 &ams_delta_nand_gpio_table, 543 }; 544 545 static void __init ams_delta_init(void) 546 { 547 /* mux pins for uarts */ 548 omap_cfg_reg(UART1_TX); 549 omap_cfg_reg(UART1_RTS); 550 551 /* parallel camera interface */ 552 omap_cfg_reg(H19_1610_CAM_EXCLK); 553 omap_cfg_reg(J15_1610_CAM_LCLK); 554 omap_cfg_reg(L18_1610_CAM_VS); 555 omap_cfg_reg(L15_1610_CAM_HS); 556 omap_cfg_reg(L19_1610_CAM_D0); 557 omap_cfg_reg(K14_1610_CAM_D1); 558 omap_cfg_reg(K15_1610_CAM_D2); 559 omap_cfg_reg(K19_1610_CAM_D3); 560 omap_cfg_reg(K18_1610_CAM_D4); 561 omap_cfg_reg(J14_1610_CAM_D5); 562 omap_cfg_reg(J19_1610_CAM_D6); 563 omap_cfg_reg(J18_1610_CAM_D7); 564 565 omap_serial_init(); 566 omap_register_i2c_bus(1, 100, NULL, 0); 567 568 omap1_usb_init(&ams_delta_usb_config); 569 omap1_set_camera_info(&ams_delta_camera_platform_data); 570 #ifdef CONFIG_LEDS_TRIGGERS 571 led_trigger_register_simple("ams_delta_camera", 572 &ams_delta_camera_led_trigger); 573 #endif 574 gpio_led_register_device(-1, &leds_pdata); 575 platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices)); 576 577 /* 578 * As soon as devices have been registered, assign their dev_names 579 * to respective GPIO lookup tables before they are added. 580 */ 581 ams_delta_audio_gpio_table.dev_id = 582 dev_name(&ams_delta_audio_device.dev); 583 /* 584 * No device name is assigned to GPIO lookup table for serio device 585 * as long as serio driver is not converted to platform device driver. 586 */ 587 588 gpiod_add_lookup_tables(ams_delta_gpio_tables, 589 ARRAY_SIZE(ams_delta_gpio_tables)); 590 591 ams_delta_init_fiq(); 592 593 omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1); 594 595 omapfb_set_lcd_config(&ams_delta_lcd_config); 596 } 597 598 static void modem_pm(struct uart_port *port, unsigned int state, unsigned old) 599 { 600 struct modem_private_data *priv = port->private_data; 601 int ret; 602 603 if (IS_ERR(priv->regulator)) 604 return; 605 606 if (state == old) 607 return; 608 609 if (state == 0) 610 ret = regulator_enable(priv->regulator); 611 else if (old == 0) 612 ret = regulator_disable(priv->regulator); 613 else 614 ret = 0; 615 616 if (ret) 617 dev_warn(port->dev, 618 "ams_delta modem_pm: failed to %sable regulator: %d\n", 619 state ? "dis" : "en", ret); 620 } 621 622 static struct plat_serial8250_port ams_delta_modem_ports[] = { 623 { 624 .membase = IOMEM(MODEM_VIRT), 625 .mapbase = MODEM_PHYS, 626 .irq = -EINVAL, /* changed later */ 627 .flags = UPF_BOOT_AUTOCONF, 628 .irqflags = IRQF_TRIGGER_RISING, 629 .iotype = UPIO_MEM, 630 .regshift = 1, 631 .uartclk = BASE_BAUD * 16, 632 .pm = modem_pm, 633 .private_data = &modem_priv, 634 }, 635 { }, 636 }; 637 638 static struct platform_device ams_delta_modem_device = { 639 .name = "serial8250", 640 .id = PLAT8250_DEV_PLATFORM1, 641 .dev = { 642 .platform_data = ams_delta_modem_ports, 643 }, 644 }; 645 646 static int __init late_init(void) 647 { 648 int err; 649 650 if (!machine_is_ams_delta()) 651 return -ENODEV; 652 653 err = gpio_request_array(latch_gpios, ARRAY_SIZE(latch_gpios)); 654 if (err) { 655 pr_err("Couldn't take over latch1/latch2 GPIO pins\n"); 656 return err; 657 } 658 659 platform_add_devices(late_devices, ARRAY_SIZE(late_devices)); 660 661 /* 662 * As soon as devices have been registered, assign their dev_names 663 * to respective GPIO lookup tables before they are added. 664 */ 665 ams_delta_lcd_gpio_table.dev_id = dev_name(&ams_delta_lcd_device.dev); 666 ams_delta_nand_gpio_table.dev_id = dev_name(&ams_delta_nand_device.dev); 667 668 gpiod_add_lookup_tables(late_gpio_tables, ARRAY_SIZE(late_gpio_tables)); 669 670 err = platform_device_register(&modem_nreset_device); 671 if (err) { 672 pr_err("Couldn't register the modem regulator device\n"); 673 return err; 674 } 675 676 omap_cfg_reg(M14_1510_GPIO2); 677 ams_delta_modem_ports[0].irq = 678 gpio_to_irq(AMS_DELTA_GPIO_PIN_MODEM_IRQ); 679 680 err = gpio_request(AMS_DELTA_GPIO_PIN_MODEM_IRQ, "modem"); 681 if (err) { 682 pr_err("Couldn't request gpio pin for modem\n"); 683 return err; 684 } 685 gpio_direction_input(AMS_DELTA_GPIO_PIN_MODEM_IRQ); 686 687 /* Initialize the modem_nreset regulator consumer before use */ 688 modem_priv.regulator = ERR_PTR(-ENODEV); 689 690 ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_CODEC, 691 AMS_DELTA_LATCH2_MODEM_CODEC); 692 693 err = platform_device_register(&ams_delta_modem_device); 694 if (err) 695 goto gpio_free; 696 697 /* 698 * Once the modem device is registered, the modem_nreset 699 * regulator can be requested on behalf of that device. 700 */ 701 modem_priv.regulator = regulator_get(&ams_delta_modem_device.dev, 702 "RESET#"); 703 if (IS_ERR(modem_priv.regulator)) { 704 err = PTR_ERR(modem_priv.regulator); 705 goto unregister; 706 } 707 return 0; 708 709 unregister: 710 platform_device_unregister(&ams_delta_modem_device); 711 gpio_free: 712 gpio_free(AMS_DELTA_GPIO_PIN_MODEM_IRQ); 713 return err; 714 } 715 716 static void __init ams_delta_init_late(void) 717 { 718 omap1_init_late(); 719 late_init(); 720 } 721 722 static void __init ams_delta_map_io(void) 723 { 724 omap15xx_map_io(); 725 iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc)); 726 } 727 728 MACHINE_START(AMS_DELTA, "Amstrad E3 (Delta)") 729 /* Maintainer: Jonathan McDowell <noodles@earth.li> */ 730 .atag_offset = 0x100, 731 .map_io = ams_delta_map_io, 732 .init_early = omap1_init_early, 733 .init_irq = omap1_init_irq, 734 .handle_irq = omap1_handle_irq, 735 .init_machine = ams_delta_init, 736 .init_late = ams_delta_init_late, 737 .init_time = omap1_timer_init, 738 .restart = omap1_restart, 739 MACHINE_END 740