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