1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/arch/arm/mach-omap1/board-ams-delta.c 4 * 5 * Modified from board-generic.c 6 * 7 * Board specific inits for the Amstrad E3 (codename Delta) videophone 8 * 9 * Copyright (C) 2006 Jonathan McDowell <noodles@earth.li> 10 */ 11 #include <linux/gpio/driver.h> 12 #include <linux/gpio/machine.h> 13 #include <linux/gpio/consumer.h> 14 #include <linux/gpio.h> 15 #include <linux/kernel.h> 16 #include <linux/init.h> 17 #include <linux/input.h> 18 #include <linux/interrupt.h> 19 #include <linux/leds.h> 20 #include <linux/platform_device.h> 21 #include <linux/regulator/consumer.h> 22 #include <linux/regulator/fixed.h> 23 #include <linux/regulator/machine.h> 24 #include <linux/serial_8250.h> 25 #include <linux/export.h> 26 #include <linux/omapfb.h> 27 #include <linux/io.h> 28 #include <linux/platform_data/gpio-omap.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 <linux/platform_data/keypad-omap.h> 38 #include <mach/mux.h> 39 40 #include <mach/hardware.h> 41 #include "camera.h" 42 #include <mach/usb.h> 43 44 #include "ams-delta-fiq.h" 45 #include "board-ams-delta.h" 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 const struct omap_lcd_config ams_delta_lcd_config __initconst = { 159 .ctrl_name = "internal", 160 }; 161 162 static struct omap_usb_config ams_delta_usb_config __initdata = { 163 .register_host = 1, 164 .hmc_mode = 16, 165 .pins[0] = 2, 166 }; 167 168 #define LATCH1_NGPIO 8 169 170 static struct resource latch1_resources[] = { 171 [0] = { 172 .name = "dat", 173 .start = LATCH1_PHYS, 174 .end = LATCH1_PHYS + (LATCH1_NGPIO - 1) / 8, 175 .flags = IORESOURCE_MEM, 176 }, 177 }; 178 179 #define LATCH1_LABEL "latch1" 180 181 static struct bgpio_pdata latch1_pdata = { 182 .label = LATCH1_LABEL, 183 .base = -1, 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 #define LATCH1_PIN_LED_CAMERA 0 198 #define LATCH1_PIN_LED_ADVERT 1 199 #define LATCH1_PIN_LED_MAIL 2 200 #define LATCH1_PIN_LED_HANDSFREE 3 201 #define LATCH1_PIN_LED_VOICEMAIL 4 202 #define LATCH1_PIN_LED_VOICE 5 203 #define LATCH1_PIN_DOCKIT1 6 204 #define LATCH1_PIN_DOCKIT2 7 205 206 #define LATCH2_NGPIO 16 207 208 static struct resource latch2_resources[] = { 209 [0] = { 210 .name = "dat", 211 .start = LATCH2_PHYS, 212 .end = LATCH2_PHYS + (LATCH2_NGPIO - 1) / 8, 213 .flags = IORESOURCE_MEM, 214 }, 215 }; 216 217 #define LATCH2_LABEL "latch2" 218 219 static struct bgpio_pdata latch2_pdata = { 220 .label = LATCH2_LABEL, 221 .base = -1, 222 .ngpio = LATCH2_NGPIO, 223 }; 224 225 static struct platform_device latch2_gpio_device = { 226 .name = "basic-mmio-gpio", 227 .id = 1, 228 .resource = latch2_resources, 229 .num_resources = ARRAY_SIZE(latch2_resources), 230 .dev = { 231 .platform_data = &latch2_pdata, 232 }, 233 }; 234 235 #define LATCH2_PIN_LCD_VBLEN 0 236 #define LATCH2_PIN_LCD_NDISP 1 237 #define LATCH2_PIN_NAND_NCE 2 238 #define LATCH2_PIN_NAND_NRE 3 239 #define LATCH2_PIN_NAND_NWP 4 240 #define LATCH2_PIN_NAND_NWE 5 241 #define LATCH2_PIN_NAND_ALE 6 242 #define LATCH2_PIN_NAND_CLE 7 243 #define LATCH2_PIN_KEYBRD_PWR 8 244 #define LATCH2_PIN_KEYBRD_DATAOUT 9 245 #define LATCH2_PIN_SCARD_RSTIN 10 246 #define LATCH2_PIN_SCARD_CMDVCC 11 247 #define LATCH2_PIN_MODEM_NRESET 12 248 #define LATCH2_PIN_MODEM_CODEC 13 249 #define LATCH2_PIN_HANDSFREE_MUTE 14 250 #define LATCH2_PIN_HANDSET_MUTE 15 251 252 static struct regulator_consumer_supply modem_nreset_consumers[] = { 253 REGULATOR_SUPPLY("RESET#", "serial8250.1"), 254 REGULATOR_SUPPLY("POR", "cx20442-codec"), 255 }; 256 257 static struct regulator_init_data modem_nreset_data = { 258 .constraints = { 259 .valid_ops_mask = REGULATOR_CHANGE_STATUS, 260 .boot_on = 1, 261 }, 262 .num_consumer_supplies = ARRAY_SIZE(modem_nreset_consumers), 263 .consumer_supplies = modem_nreset_consumers, 264 }; 265 266 static struct fixed_voltage_config modem_nreset_config = { 267 .supply_name = "modem_nreset", 268 .microvolts = 3300000, 269 .startup_delay = 25000, 270 .enabled_at_boot = 1, 271 .init_data = &modem_nreset_data, 272 }; 273 274 static struct platform_device modem_nreset_device = { 275 .name = "reg-fixed-voltage", 276 .id = -1, 277 .dev = { 278 .platform_data = &modem_nreset_config, 279 }, 280 }; 281 282 static struct gpiod_lookup_table ams_delta_nreset_gpiod_table = { 283 .dev_id = "reg-fixed-voltage", 284 .table = { 285 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_MODEM_NRESET, 286 NULL, GPIO_ACTIVE_HIGH), 287 { }, 288 }, 289 }; 290 291 struct modem_private_data { 292 struct regulator *regulator; 293 }; 294 295 static struct modem_private_data modem_priv; 296 297 static struct platform_device ams_delta_nand_device = { 298 .name = "ams-delta-nand", 299 .id = -1, 300 }; 301 302 #define OMAP_GPIO_LABEL "gpio-0-15" 303 #define OMAP_MPUIO_LABEL "mpuio" 304 305 static struct gpiod_lookup_table ams_delta_nand_gpio_table = { 306 .table = { 307 GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_NAND_RB, "rdy", 308 0), 309 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NCE, "nce", 0), 310 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NRE, "nre", 0), 311 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NWP, "nwp", 0), 312 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NWE, "nwe", 0), 313 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_ALE, "ale", 0), 314 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_CLE, "cle", 0), 315 GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 0, "data", 0, 0), 316 GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 1, "data", 1, 0), 317 GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 2, "data", 2, 0), 318 GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 3, "data", 3, 0), 319 GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 4, "data", 4, 0), 320 GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 5, "data", 5, 0), 321 GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 6, "data", 6, 0), 322 GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 7, "data", 7, 0), 323 { }, 324 }, 325 }; 326 327 static struct resource ams_delta_kp_resources[] = { 328 [0] = { 329 .start = INT_KEYBOARD, 330 .end = INT_KEYBOARD, 331 .flags = IORESOURCE_IRQ, 332 }, 333 }; 334 335 static const struct matrix_keymap_data ams_delta_keymap_data = { 336 .keymap = ams_delta_keymap, 337 .keymap_size = ARRAY_SIZE(ams_delta_keymap), 338 }; 339 340 static struct omap_kp_platform_data ams_delta_kp_data = { 341 .rows = 8, 342 .cols = 8, 343 .keymap_data = &ams_delta_keymap_data, 344 .delay = 9, 345 }; 346 347 static struct platform_device ams_delta_kp_device = { 348 .name = "omap-keypad", 349 .id = -1, 350 .dev = { 351 .platform_data = &ams_delta_kp_data, 352 }, 353 .num_resources = ARRAY_SIZE(ams_delta_kp_resources), 354 .resource = ams_delta_kp_resources, 355 }; 356 357 static struct platform_device ams_delta_lcd_device = { 358 .name = "lcd_ams_delta", 359 .id = -1, 360 }; 361 362 static struct gpiod_lookup_table ams_delta_lcd_gpio_table = { 363 .table = { 364 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_LCD_VBLEN, "vblen", 0), 365 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_LCD_NDISP, "ndisp", 0), 366 { }, 367 }, 368 }; 369 370 static struct gpio_led gpio_leds[] __initdata = { 371 [LATCH1_PIN_LED_CAMERA] = { 372 .name = "camera", 373 .default_state = LEDS_GPIO_DEFSTATE_OFF, 374 #ifdef CONFIG_LEDS_TRIGGERS 375 .default_trigger = "ams_delta_camera", 376 #endif 377 }, 378 [LATCH1_PIN_LED_ADVERT] = { 379 .name = "advert", 380 .default_state = LEDS_GPIO_DEFSTATE_OFF, 381 }, 382 [LATCH1_PIN_LED_MAIL] = { 383 .name = "email", 384 .default_state = LEDS_GPIO_DEFSTATE_OFF, 385 }, 386 [LATCH1_PIN_LED_HANDSFREE] = { 387 .name = "handsfree", 388 .default_state = LEDS_GPIO_DEFSTATE_OFF, 389 }, 390 [LATCH1_PIN_LED_VOICEMAIL] = { 391 .name = "voicemail", 392 .default_state = LEDS_GPIO_DEFSTATE_OFF, 393 }, 394 [LATCH1_PIN_LED_VOICE] = { 395 .name = "voice", 396 .default_state = LEDS_GPIO_DEFSTATE_OFF, 397 }, 398 }; 399 400 static const struct gpio_led_platform_data leds_pdata __initconst = { 401 .leds = gpio_leds, 402 .num_leds = ARRAY_SIZE(gpio_leds), 403 }; 404 405 static struct gpiod_lookup_table leds_gpio_table = { 406 .table = { 407 GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_CAMERA, NULL, 408 LATCH1_PIN_LED_CAMERA, 0), 409 GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_ADVERT, NULL, 410 LATCH1_PIN_LED_ADVERT, 0), 411 GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_MAIL, NULL, 412 LATCH1_PIN_LED_MAIL, 0), 413 GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_HANDSFREE, NULL, 414 LATCH1_PIN_LED_HANDSFREE, 0), 415 GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_VOICEMAIL, NULL, 416 LATCH1_PIN_LED_VOICEMAIL, 0), 417 GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_VOICE, NULL, 418 LATCH1_PIN_LED_VOICE, 0), 419 { }, 420 }, 421 }; 422 423 static struct i2c_board_info ams_delta_camera_board_info[] = { 424 { 425 I2C_BOARD_INFO("ov6650", 0x60), 426 }, 427 }; 428 429 #ifdef CONFIG_LEDS_TRIGGERS 430 DEFINE_LED_TRIGGER(ams_delta_camera_led_trigger); 431 432 static int ams_delta_camera_power(struct device *dev, int power) 433 { 434 /* 435 * turn on camera LED 436 */ 437 if (power) 438 led_trigger_event(ams_delta_camera_led_trigger, LED_FULL); 439 else 440 led_trigger_event(ams_delta_camera_led_trigger, LED_OFF); 441 return 0; 442 } 443 #else 444 #define ams_delta_camera_power NULL 445 #endif 446 447 static struct soc_camera_link ams_delta_iclink = { 448 .bus_id = 0, /* OMAP1 SoC camera bus */ 449 .i2c_adapter_id = 1, 450 .board_info = &ams_delta_camera_board_info[0], 451 .module_name = "ov6650", 452 .power = ams_delta_camera_power, 453 }; 454 455 static struct platform_device ams_delta_camera_device = { 456 .name = "soc-camera-pdrv", 457 .id = 0, 458 .dev = { 459 .platform_data = &ams_delta_iclink, 460 }, 461 }; 462 463 static struct omap1_cam_platform_data ams_delta_camera_platform_data = { 464 .camexclk_khz = 12000, /* default 12MHz clock, no extra DPLL */ 465 .lclk_khz_max = 1334, /* results in 5fps CIF, 10fps QCIF */ 466 }; 467 468 static struct platform_device ams_delta_audio_device = { 469 .name = "ams-delta-audio", 470 .id = -1, 471 }; 472 473 static struct gpiod_lookup_table ams_delta_audio_gpio_table = { 474 .table = { 475 GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_HOOK_SWITCH, 476 "hook_switch", 0), 477 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_MODEM_CODEC, 478 "modem_codec", 0), 479 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_HANDSFREE_MUTE, 480 "handsfree_mute", 0), 481 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_HANDSET_MUTE, 482 "handset_mute", 0), 483 { }, 484 }, 485 }; 486 487 static struct platform_device cx20442_codec_device = { 488 .name = "cx20442-codec", 489 .id = -1, 490 }; 491 492 static struct resource ams_delta_serio_resources[] = { 493 { 494 .flags = IORESOURCE_IRQ, 495 /* 496 * Initialize IRQ resource with invalid IRQ number. 497 * It will be replaced with dynamically allocated GPIO IRQ 498 * obtained from GPIO chip as soon as the chip is available. 499 */ 500 .start = -EINVAL, 501 .end = -EINVAL, 502 }, 503 }; 504 505 static struct platform_device ams_delta_serio_device = { 506 .name = "ams-delta-serio", 507 .id = PLATFORM_DEVID_NONE, 508 .dev = { 509 /* 510 * Initialize .platform_data explicitly with NULL to 511 * indicate it is going to be used. It will be replaced 512 * with FIQ buffer address as soon as FIQ is initialized. 513 */ 514 .platform_data = NULL, 515 }, 516 .num_resources = ARRAY_SIZE(ams_delta_serio_resources), 517 .resource = ams_delta_serio_resources, 518 }; 519 520 static struct regulator_consumer_supply keybrd_pwr_consumers[] = { 521 /* 522 * Initialize supply .dev_name with NULL. It will be replaced 523 * with serio dev_name() as soon as the serio device is registered. 524 */ 525 REGULATOR_SUPPLY("vcc", NULL), 526 }; 527 528 static struct regulator_init_data keybrd_pwr_initdata = { 529 .constraints = { 530 .valid_ops_mask = REGULATOR_CHANGE_STATUS, 531 }, 532 .num_consumer_supplies = ARRAY_SIZE(keybrd_pwr_consumers), 533 .consumer_supplies = keybrd_pwr_consumers, 534 }; 535 536 static struct fixed_voltage_config keybrd_pwr_config = { 537 .supply_name = "keybrd_pwr", 538 .microvolts = 5000000, 539 .init_data = &keybrd_pwr_initdata, 540 }; 541 542 static struct platform_device keybrd_pwr_device = { 543 .name = "reg-fixed-voltage", 544 .id = PLATFORM_DEVID_AUTO, 545 .dev = { 546 .platform_data = &keybrd_pwr_config, 547 }, 548 }; 549 550 static struct gpiod_lookup_table keybrd_pwr_gpio_table = { 551 .table = { 552 GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_KEYBRD_PWR, NULL, 553 GPIO_ACTIVE_HIGH), 554 { }, 555 }, 556 }; 557 558 static struct platform_device *ams_delta_devices[] __initdata = { 559 &latch1_gpio_device, 560 &latch2_gpio_device, 561 &ams_delta_kp_device, 562 &ams_delta_camera_device, 563 &ams_delta_audio_device, 564 &ams_delta_serio_device, 565 &ams_delta_nand_device, 566 &ams_delta_lcd_device, 567 &cx20442_codec_device, 568 }; 569 570 static struct gpiod_lookup_table *ams_delta_gpio_tables[] __initdata = { 571 &ams_delta_nreset_gpiod_table, 572 &ams_delta_audio_gpio_table, 573 &keybrd_pwr_gpio_table, 574 &ams_delta_lcd_gpio_table, 575 &ams_delta_nand_gpio_table, 576 }; 577 578 /* 579 * Some drivers may not use GPIO lookup tables but need to be provided 580 * with GPIO numbers. The same applies to GPIO based IRQ lines - some 581 * drivers may even not use GPIO layer but expect just IRQ numbers. 582 * We could either define GPIO lookup tables then use them on behalf 583 * of those devices, or we can use GPIO driver level methods for 584 * identification of GPIO and IRQ numbers. For the purpose of the latter, 585 * defina a helper function which identifies GPIO chips by their labels. 586 */ 587 static int gpiochip_match_by_label(struct gpio_chip *chip, void *data) 588 { 589 char *label = data; 590 591 return !strcmp(label, chip->label); 592 } 593 594 static struct gpiod_hog ams_delta_gpio_hogs[] = { 595 GPIO_HOG(LATCH2_LABEL, LATCH2_PIN_KEYBRD_DATAOUT, "keybrd_dataout", 596 GPIO_ACTIVE_HIGH, GPIOD_OUT_LOW), 597 {}, 598 }; 599 600 static struct plat_serial8250_port ams_delta_modem_ports[]; 601 602 /* 603 * Obtain MODEM IRQ GPIO descriptor using its hardware pin 604 * number and assign related IRQ number to the MODEM port. 605 * Keep the GPIO descriptor open so nobody steps in. 606 */ 607 static void __init modem_assign_irq(struct gpio_chip *chip) 608 { 609 struct gpio_desc *gpiod; 610 611 gpiod = gpiochip_request_own_desc(chip, AMS_DELTA_GPIO_PIN_MODEM_IRQ, 612 "modem_irq", GPIO_ACTIVE_HIGH, 613 GPIOD_IN); 614 if (IS_ERR(gpiod)) { 615 pr_err("%s: modem IRQ GPIO request failed (%ld)\n", __func__, 616 PTR_ERR(gpiod)); 617 } else { 618 ams_delta_modem_ports[0].irq = gpiod_to_irq(gpiod); 619 } 620 } 621 622 /* 623 * The purpose of this function is to take care of proper initialization of 624 * devices and data structures which depend on GPIO lines provided by OMAP GPIO 625 * banks but their drivers don't use GPIO lookup tables or GPIO layer at all. 626 * The function may be called as soon as OMAP GPIO devices are probed. 627 * Since that happens at postcore_initcall, it can be called successfully 628 * from init_machine or later. 629 * Dependent devices may be registered from within this function or later. 630 */ 631 static void __init omap_gpio_deps_init(void) 632 { 633 struct gpio_chip *chip; 634 635 chip = gpiochip_find(OMAP_GPIO_LABEL, gpiochip_match_by_label); 636 if (!chip) { 637 pr_err("%s: OMAP GPIO chip not found\n", __func__); 638 return; 639 } 640 641 /* 642 * Start with FIQ initialization as it may have to request 643 * and release successfully each OMAP GPIO pin in turn. 644 */ 645 ams_delta_init_fiq(chip, &ams_delta_serio_device); 646 647 modem_assign_irq(chip); 648 } 649 650 /* 651 * Initialize latch2 pins with values which are safe for dependent on-board 652 * devices or useful for their successull initialization even before GPIO 653 * driver takes control over the latch pins: 654 * - LATCH2_PIN_LCD_VBLEN = 0 655 * - LATCH2_PIN_LCD_NDISP = 0 Keep LCD device powered off before its 656 * driver takes control over it. 657 * - LATCH2_PIN_NAND_NCE = 0 658 * - LATCH2_PIN_NAND_NWP = 0 Keep NAND device down and write- 659 * protected before its driver takes 660 * control over it. 661 * - LATCH2_PIN_KEYBRD_PWR = 0 Keep keyboard powered off before serio 662 * driver takes control over it. 663 * - LATCH2_PIN_KEYBRD_DATAOUT = 0 Keep low to avoid corruption of first 664 * byte of data received from attached 665 * keyboard when serio device is probed; 666 * the pin is also hogged low by the latch2 667 * GPIO driver as soon as it is ready. 668 * - LATCH2_PIN_MODEM_NRESET = 1 Enable voice MODEM device, allowing for 669 * its successful probe even before a 670 * regulator it depends on, which in turn 671 * takes control over the pin, is set up. 672 * - LATCH2_PIN_MODEM_CODEC = 1 Attach voice MODEM CODEC data port 673 * to the MODEM so the CODEC is under 674 * control even if audio driver doesn't 675 * take it over. 676 */ 677 static void __init ams_delta_latch2_init(void) 678 { 679 u16 latch2 = 1 << LATCH2_PIN_MODEM_NRESET | 1 << LATCH2_PIN_MODEM_CODEC; 680 681 __raw_writew(latch2, LATCH2_VIRT); 682 } 683 684 static void __init ams_delta_init(void) 685 { 686 struct platform_device *leds_pdev; 687 688 /* mux pins for uarts */ 689 omap_cfg_reg(UART1_TX); 690 omap_cfg_reg(UART1_RTS); 691 692 /* parallel camera interface */ 693 omap_cfg_reg(H19_1610_CAM_EXCLK); 694 omap_cfg_reg(J15_1610_CAM_LCLK); 695 omap_cfg_reg(L18_1610_CAM_VS); 696 omap_cfg_reg(L15_1610_CAM_HS); 697 omap_cfg_reg(L19_1610_CAM_D0); 698 omap_cfg_reg(K14_1610_CAM_D1); 699 omap_cfg_reg(K15_1610_CAM_D2); 700 omap_cfg_reg(K19_1610_CAM_D3); 701 omap_cfg_reg(K18_1610_CAM_D4); 702 omap_cfg_reg(J14_1610_CAM_D5); 703 omap_cfg_reg(J19_1610_CAM_D6); 704 omap_cfg_reg(J18_1610_CAM_D7); 705 706 omap_gpio_deps_init(); 707 ams_delta_latch2_init(); 708 gpiod_add_hogs(ams_delta_gpio_hogs); 709 710 omap_serial_init(); 711 omap_register_i2c_bus(1, 100, NULL, 0); 712 713 omap1_usb_init(&ams_delta_usb_config); 714 omap1_set_camera_info(&ams_delta_camera_platform_data); 715 #ifdef CONFIG_LEDS_TRIGGERS 716 led_trigger_register_simple("ams_delta_camera", 717 &ams_delta_camera_led_trigger); 718 #endif 719 platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices)); 720 721 /* 722 * As soon as regulator consumers have been registered, assign their 723 * dev_names to consumer supply entries of respective regulators. 724 */ 725 keybrd_pwr_consumers[0].dev_name = 726 dev_name(&ams_delta_serio_device.dev); 727 728 /* 729 * Once consumer supply entries are populated with dev_names, 730 * register regulator devices. At this stage only the keyboard 731 * power regulator has its consumer supply table fully populated. 732 */ 733 platform_device_register(&keybrd_pwr_device); 734 735 /* 736 * As soon as GPIO consumers have been registered, assign 737 * their dev_names to respective GPIO lookup tables. 738 */ 739 ams_delta_audio_gpio_table.dev_id = 740 dev_name(&ams_delta_audio_device.dev); 741 keybrd_pwr_gpio_table.dev_id = dev_name(&keybrd_pwr_device.dev); 742 ams_delta_nand_gpio_table.dev_id = dev_name(&ams_delta_nand_device.dev); 743 ams_delta_lcd_gpio_table.dev_id = dev_name(&ams_delta_lcd_device.dev); 744 745 /* 746 * Once GPIO lookup tables are populated with dev_names, register them. 747 */ 748 gpiod_add_lookup_tables(ams_delta_gpio_tables, 749 ARRAY_SIZE(ams_delta_gpio_tables)); 750 751 leds_pdev = gpio_led_register_device(PLATFORM_DEVID_NONE, &leds_pdata); 752 if (!IS_ERR_OR_NULL(leds_pdev)) { 753 leds_gpio_table.dev_id = dev_name(&leds_pdev->dev); 754 gpiod_add_lookup_table(&leds_gpio_table); 755 } 756 757 omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1); 758 759 omapfb_set_lcd_config(&ams_delta_lcd_config); 760 } 761 762 static void modem_pm(struct uart_port *port, unsigned int state, unsigned old) 763 { 764 struct modem_private_data *priv = port->private_data; 765 int ret; 766 767 if (!priv) 768 return; 769 770 if (IS_ERR(priv->regulator)) 771 return; 772 773 if (state == old) 774 return; 775 776 if (state == 0) 777 ret = regulator_enable(priv->regulator); 778 else if (old == 0) 779 ret = regulator_disable(priv->regulator); 780 else 781 ret = 0; 782 783 if (ret) 784 dev_warn(port->dev, 785 "ams_delta modem_pm: failed to %sable regulator: %d\n", 786 state ? "dis" : "en", ret); 787 } 788 789 static struct plat_serial8250_port ams_delta_modem_ports[] = { 790 { 791 .membase = IOMEM(MODEM_VIRT), 792 .mapbase = MODEM_PHYS, 793 .irq = IRQ_NOTCONNECTED, /* changed later */ 794 .flags = UPF_BOOT_AUTOCONF, 795 .irqflags = IRQF_TRIGGER_RISING, 796 .iotype = UPIO_MEM, 797 .regshift = 1, 798 .uartclk = BASE_BAUD * 16, 799 .pm = modem_pm, 800 .private_data = &modem_priv, 801 }, 802 { }, 803 }; 804 805 static struct platform_device ams_delta_modem_device = { 806 .name = "serial8250", 807 .id = PLAT8250_DEV_PLATFORM1, 808 .dev = { 809 .platform_data = ams_delta_modem_ports, 810 }, 811 }; 812 813 static int __init modem_nreset_init(void) 814 { 815 int err; 816 817 err = platform_device_register(&modem_nreset_device); 818 if (err) 819 pr_err("Couldn't register the modem regulator device\n"); 820 821 return err; 822 } 823 824 825 /* 826 * This function expects MODEM IRQ number already assigned to the port. 827 * The MODEM device requires its RESET# pin kept high during probe. 828 * That requirement can be fulfilled in several ways: 829 * - with a descriptor of already functional modem_nreset regulator 830 * assigned to the MODEM private data, 831 * - with the regulator not yet controlled by modem_pm function but 832 * already enabled by default on probe, 833 * - before the modem_nreset regulator is probed, with the pin already 834 * set high explicitly. 835 * The last one is already guaranteed by ams_delta_latch2_init() called 836 * from machine_init. 837 * In order to avoid taking over ttyS0 device slot, the MODEM device 838 * should be registered after OMAP serial ports. Since those ports 839 * are registered at arch_initcall, this function can be called safely 840 * at arch_initcall_sync earliest. 841 */ 842 static int __init ams_delta_modem_init(void) 843 { 844 int err; 845 846 if (!machine_is_ams_delta()) 847 return -ENODEV; 848 849 omap_cfg_reg(M14_1510_GPIO2); 850 851 /* Initialize the modem_nreset regulator consumer before use */ 852 modem_priv.regulator = ERR_PTR(-ENODEV); 853 854 err = platform_device_register(&ams_delta_modem_device); 855 856 return err; 857 } 858 arch_initcall_sync(ams_delta_modem_init); 859 860 static int __init late_init(void) 861 { 862 int err; 863 864 err = modem_nreset_init(); 865 if (err) 866 return err; 867 868 /* 869 * Once the modem device is registered, the modem_nreset 870 * regulator can be requested on behalf of that device. 871 */ 872 modem_priv.regulator = regulator_get(&ams_delta_modem_device.dev, 873 "RESET#"); 874 if (IS_ERR(modem_priv.regulator)) { 875 err = PTR_ERR(modem_priv.regulator); 876 goto unregister; 877 } 878 return 0; 879 880 unregister: 881 platform_device_unregister(&ams_delta_modem_device); 882 return err; 883 } 884 885 static void __init ams_delta_init_late(void) 886 { 887 omap1_init_late(); 888 late_init(); 889 } 890 891 static void __init ams_delta_map_io(void) 892 { 893 omap15xx_map_io(); 894 iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc)); 895 } 896 897 MACHINE_START(AMS_DELTA, "Amstrad E3 (Delta)") 898 /* Maintainer: Jonathan McDowell <noodles@earth.li> */ 899 .atag_offset = 0x100, 900 .map_io = ams_delta_map_io, 901 .init_early = omap1_init_early, 902 .init_irq = omap1_init_irq, 903 .handle_irq = omap1_handle_irq, 904 .init_machine = ams_delta_init, 905 .init_late = ams_delta_init_late, 906 .init_time = omap1_timer_init, 907 .restart = omap1_restart, 908 MACHINE_END 909