1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Support for Sharp SL-Cxx00 Series of PDAs 4 * Models: SL-C3000 (Spitz), SL-C1000 (Akita) and SL-C3100 (Borzoi) 5 * 6 * Copyright (c) 2005 Richard Purdie 7 * 8 * Based on Sharp's 2.4 kernel patches/lubbock.c 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/platform_device.h> 13 #include <linux/delay.h> 14 #include <linux/gpio_keys.h> 15 #include <linux/gpio.h> 16 #include <linux/gpio/machine.h> 17 #include <linux/gpio/property.h> 18 #include <linux/leds.h> 19 #include <linux/i2c.h> 20 #include <linux/platform_data/i2c-pxa.h> 21 #include <linux/platform_data/pca953x.h> 22 #include <linux/property.h> 23 #include <linux/spi/spi.h> 24 #include <linux/spi/ads7846.h> 25 #include <linux/spi/corgi_lcd.h> 26 #include <linux/mtd/sharpsl.h> 27 #include <linux/mtd/physmap.h> 28 #include <linux/input-event-codes.h> 29 #include <linux/input/matrix_keypad.h> 30 #include <linux/regulator/machine.h> 31 #include <linux/io.h> 32 #include <linux/property.h> 33 #include <linux/reboot.h> 34 #include <linux/memblock.h> 35 36 #include <asm/setup.h> 37 #include <asm/mach-types.h> 38 #include <asm/mach/arch.h> 39 #include <asm/mach/sharpsl_param.h> 40 #include <asm/hardware/scoop.h> 41 42 #include "pxa27x.h" 43 #include "pxa27x-udc.h" 44 #include "reset.h" 45 #include <linux/platform_data/mmc-pxamci.h> 46 #include <linux/platform_data/usb-ohci-pxa27x.h> 47 #include <linux/platform_data/video-pxafb.h> 48 #include "spitz.h" 49 #include "sharpsl_pm.h" 50 #include "smemc.h" 51 52 #include "generic.h" 53 #include "devices.h" 54 55 /****************************************************************************** 56 * Pin configuration 57 ******************************************************************************/ 58 static unsigned long spitz_pin_config[] __initdata = { 59 /* Chip Selects */ 60 GPIO78_nCS_2, /* SCOOP #2 */ 61 GPIO79_nCS_3, /* NAND */ 62 GPIO80_nCS_4, /* SCOOP #1 */ 63 64 /* LCD - 16bpp Active TFT */ 65 GPIOxx_LCD_TFT_16BPP, 66 67 /* PC Card */ 68 GPIO48_nPOE, 69 GPIO49_nPWE, 70 GPIO50_nPIOR, 71 GPIO51_nPIOW, 72 GPIO85_nPCE_1, 73 GPIO54_nPCE_2, 74 GPIO55_nPREG, 75 GPIO56_nPWAIT, 76 GPIO57_nIOIS16, 77 GPIO104_PSKTSEL, 78 79 /* I2S */ 80 GPIO28_I2S_BITCLK_OUT, 81 GPIO29_I2S_SDATA_IN, 82 GPIO30_I2S_SDATA_OUT, 83 GPIO31_I2S_SYNC, 84 85 /* MMC */ 86 GPIO32_MMC_CLK, 87 GPIO112_MMC_CMD, 88 GPIO92_MMC_DAT_0, 89 GPIO109_MMC_DAT_1, 90 GPIO110_MMC_DAT_2, 91 GPIO111_MMC_DAT_3, 92 93 /* GPIOs */ 94 GPIO9_GPIO, /* SPITZ_GPIO_nSD_DETECT */ 95 GPIO16_GPIO, /* SPITZ_GPIO_SYNC */ 96 GPIO81_GPIO, /* SPITZ_GPIO_nSD_WP */ 97 GPIO41_GPIO, /* SPITZ_GPIO_USB_CONNECT */ 98 GPIO37_GPIO, /* SPITZ_GPIO_USB_HOST */ 99 GPIO35_GPIO, /* SPITZ_GPIO_USB_DEVICE */ 100 GPIO22_GPIO, /* SPITZ_GPIO_HSYNC */ 101 GPIO94_GPIO, /* SPITZ_GPIO_CF_CD */ 102 GPIO105_GPIO, /* SPITZ_GPIO_CF_IRQ */ 103 GPIO106_GPIO, /* SPITZ_GPIO_CF2_IRQ */ 104 105 /* GPIO matrix keypad */ 106 GPIO88_GPIO, /* column 0 */ 107 GPIO23_GPIO, /* column 1 */ 108 GPIO24_GPIO, /* column 2 */ 109 GPIO25_GPIO, /* column 3 */ 110 GPIO26_GPIO, /* column 4 */ 111 GPIO27_GPIO, /* column 5 */ 112 GPIO52_GPIO, /* column 6 */ 113 GPIO103_GPIO, /* column 7 */ 114 GPIO107_GPIO, /* column 8 */ 115 GPIO108_GPIO, /* column 9 */ 116 GPIO114_GPIO, /* column 10 */ 117 GPIO12_GPIO, /* row 0 */ 118 GPIO17_GPIO, /* row 1 */ 119 GPIO91_GPIO, /* row 2 */ 120 GPIO34_GPIO, /* row 3 */ 121 GPIO36_GPIO, /* row 4 */ 122 GPIO38_GPIO, /* row 5 */ 123 GPIO39_GPIO, /* row 6 */ 124 125 /* I2C */ 126 GPIO117_I2C_SCL, 127 GPIO118_I2C_SDA, 128 129 GPIO0_GPIO | WAKEUP_ON_EDGE_RISE, /* SPITZ_GPIO_KEY_INT */ 130 GPIO1_GPIO | WAKEUP_ON_EDGE_FALL, /* SPITZ_GPIO_RESET */ 131 }; 132 133 static const struct software_node spitz_scoop_1_gpiochip_node = { 134 .name = "sharp-scoop.0", 135 }; 136 137 /* Only on Spitz */ 138 static const struct software_node spitz_scoop_2_gpiochip_node = { 139 .name = "sharp-scoop.1", 140 }; 141 142 /* Only on Akita */ 143 static const struct software_node akita_max7310_gpiochip_node = { 144 .name = "i2c-max7310", 145 }; 146 147 /****************************************************************************** 148 * Scoop GPIO expander 149 ******************************************************************************/ 150 #if defined(CONFIG_SHARP_SCOOP) || defined(CONFIG_SHARP_SCOOP_MODULE) 151 /* SCOOP Device #1 */ 152 static struct resource spitz_scoop_1_resources[] = { 153 [0] = { 154 .start = 0x10800000, 155 .end = 0x10800fff, 156 .flags = IORESOURCE_MEM, 157 }, 158 }; 159 160 static struct scoop_config spitz_scoop_1_setup = { 161 .io_dir = SPITZ_SCP_IO_DIR, 162 .io_out = SPITZ_SCP_IO_OUT, 163 .suspend_clr = SPITZ_SCP_SUS_CLR, 164 .suspend_set = SPITZ_SCP_SUS_SET, 165 .gpio_base = SPITZ_SCP_GPIO_BASE, 166 }; 167 168 struct platform_device spitz_scoop_1_device = { 169 .name = "sharp-scoop", 170 .id = 0, 171 .dev = { 172 .platform_data = &spitz_scoop_1_setup, 173 }, 174 .num_resources = ARRAY_SIZE(spitz_scoop_1_resources), 175 .resource = spitz_scoop_1_resources, 176 }; 177 178 /* SCOOP Device #2 */ 179 static struct resource spitz_scoop_2_resources[] = { 180 [0] = { 181 .start = 0x08800040, 182 .end = 0x08800fff, 183 .flags = IORESOURCE_MEM, 184 }, 185 }; 186 187 static struct scoop_config spitz_scoop_2_setup = { 188 .io_dir = SPITZ_SCP2_IO_DIR, 189 .io_out = SPITZ_SCP2_IO_OUT, 190 .suspend_clr = SPITZ_SCP2_SUS_CLR, 191 .suspend_set = SPITZ_SCP2_SUS_SET, 192 .gpio_base = SPITZ_SCP2_GPIO_BASE, 193 }; 194 195 struct platform_device spitz_scoop_2_device = { 196 .name = "sharp-scoop", 197 .id = 1, 198 .dev = { 199 .platform_data = &spitz_scoop_2_setup, 200 }, 201 .num_resources = ARRAY_SIZE(spitz_scoop_2_resources), 202 .resource = spitz_scoop_2_resources, 203 }; 204 205 static void __init spitz_scoop_init(void) 206 { 207 platform_device_register(&spitz_scoop_1_device); 208 209 /* Akita doesn't have the second SCOOP chip */ 210 if (!machine_is_akita()) 211 platform_device_register(&spitz_scoop_2_device); 212 } 213 214 /* Power control is shared with between one of the CF slots and SD */ 215 static void __maybe_unused spitz_card_pwr_ctrl(uint8_t enable, uint8_t new_cpr) 216 { 217 unsigned short cpr; 218 unsigned long flags; 219 220 if (new_cpr & 0x7) { 221 gpio_set_value(SPITZ_GPIO_CF_POWER, 1); 222 mdelay(5); 223 } 224 225 local_irq_save(flags); 226 227 cpr = read_scoop_reg(&spitz_scoop_1_device.dev, SCOOP_CPR); 228 229 if (enable & new_cpr) 230 cpr |= new_cpr; 231 else 232 cpr &= ~enable; 233 234 write_scoop_reg(&spitz_scoop_1_device.dev, SCOOP_CPR, cpr); 235 236 local_irq_restore(flags); 237 238 if (!(cpr & 0x7)) { 239 mdelay(1); 240 gpio_set_value(SPITZ_GPIO_CF_POWER, 0); 241 } 242 } 243 244 #else 245 static inline void spitz_scoop_init(void) {} 246 static inline void spitz_card_pwr_ctrl(uint8_t enable, uint8_t new_cpr) {} 247 #endif 248 249 /****************************************************************************** 250 * PCMCIA 251 ******************************************************************************/ 252 #if defined(CONFIG_PCMCIA_PXA2XX) || defined(CONFIG_PCMCIA_PXA2XX_MODULE) 253 static void spitz_pcmcia_pwr(struct device *scoop, uint16_t cpr, int nr) 254 { 255 /* Only need to override behaviour for slot 0 */ 256 if (nr == 0) 257 spitz_card_pwr_ctrl( 258 cpr & (SCOOP_CPR_CF_3V | SCOOP_CPR_CF_XV), cpr); 259 else 260 write_scoop_reg(scoop, SCOOP_CPR, cpr); 261 } 262 263 static struct scoop_pcmcia_dev spitz_pcmcia_scoop[] = { 264 { 265 .dev = &spitz_scoop_1_device.dev, 266 .irq = SPITZ_IRQ_GPIO_CF_IRQ, 267 .cd_irq = SPITZ_IRQ_GPIO_CF_CD, 268 .cd_irq_str = "PCMCIA0 CD", 269 }, { 270 .dev = &spitz_scoop_2_device.dev, 271 .irq = SPITZ_IRQ_GPIO_CF2_IRQ, 272 .cd_irq = -1, 273 }, 274 }; 275 276 static struct scoop_pcmcia_config spitz_pcmcia_config = { 277 .devs = &spitz_pcmcia_scoop[0], 278 .num_devs = 2, 279 .power_ctrl = spitz_pcmcia_pwr, 280 }; 281 282 static void __init spitz_pcmcia_init(void) 283 { 284 /* Akita has only one PCMCIA slot used */ 285 if (machine_is_akita()) 286 spitz_pcmcia_config.num_devs = 1; 287 288 platform_scoop_config = &spitz_pcmcia_config; 289 } 290 #else 291 static inline void spitz_pcmcia_init(void) {} 292 #endif 293 294 /****************************************************************************** 295 * GPIO keyboard 296 ******************************************************************************/ 297 #if defined(CONFIG_KEYBOARD_MATRIX) || defined(CONFIG_KEYBOARD_MATRIX_MODULE) 298 299 #define SPITZ_KEY_CALENDAR KEY_F1 300 #define SPITZ_KEY_ADDRESS KEY_F2 301 #define SPITZ_KEY_FN KEY_F3 302 #define SPITZ_KEY_CANCEL KEY_F4 303 #define SPITZ_KEY_EXOK KEY_F5 304 #define SPITZ_KEY_EXCANCEL KEY_F6 305 #define SPITZ_KEY_EXJOGDOWN KEY_F7 306 #define SPITZ_KEY_EXJOGUP KEY_F8 307 #define SPITZ_KEY_JAP1 KEY_LEFTALT 308 #define SPITZ_KEY_JAP2 KEY_RIGHTCTRL 309 #define SPITZ_KEY_SYNC KEY_F9 310 #define SPITZ_KEY_MAIL KEY_F10 311 #define SPITZ_KEY_OK KEY_F11 312 #define SPITZ_KEY_MENU KEY_F12 313 314 static const uint32_t spitz_keymap[] = { 315 KEY(0, 0, KEY_LEFTCTRL), 316 KEY(0, 1, KEY_1), 317 KEY(0, 2, KEY_3), 318 KEY(0, 3, KEY_5), 319 KEY(0, 4, KEY_6), 320 KEY(0, 5, KEY_7), 321 KEY(0, 6, KEY_9), 322 KEY(0, 7, KEY_0), 323 KEY(0, 8, KEY_BACKSPACE), 324 KEY(0, 9, SPITZ_KEY_EXOK), /* EXOK */ 325 KEY(0, 10, SPITZ_KEY_EXCANCEL), /* EXCANCEL */ 326 KEY(1, 1, KEY_2), 327 KEY(1, 2, KEY_4), 328 KEY(1, 3, KEY_R), 329 KEY(1, 4, KEY_Y), 330 KEY(1, 5, KEY_8), 331 KEY(1, 6, KEY_I), 332 KEY(1, 7, KEY_O), 333 KEY(1, 8, KEY_P), 334 KEY(1, 9, SPITZ_KEY_EXJOGDOWN), /* EXJOGDOWN */ 335 KEY(1, 10, SPITZ_KEY_EXJOGUP), /* EXJOGUP */ 336 KEY(2, 0, KEY_TAB), 337 KEY(2, 1, KEY_Q), 338 KEY(2, 2, KEY_E), 339 KEY(2, 3, KEY_T), 340 KEY(2, 4, KEY_G), 341 KEY(2, 5, KEY_U), 342 KEY(2, 6, KEY_J), 343 KEY(2, 7, KEY_K), 344 KEY(3, 0, SPITZ_KEY_ADDRESS), /* ADDRESS */ 345 KEY(3, 1, KEY_W), 346 KEY(3, 2, KEY_S), 347 KEY(3, 3, KEY_F), 348 KEY(3, 4, KEY_V), 349 KEY(3, 5, KEY_H), 350 KEY(3, 6, KEY_M), 351 KEY(3, 7, KEY_L), 352 KEY(3, 9, KEY_RIGHTSHIFT), 353 KEY(4, 0, SPITZ_KEY_CALENDAR), /* CALENDAR */ 354 KEY(4, 1, KEY_A), 355 KEY(4, 2, KEY_D), 356 KEY(4, 3, KEY_C), 357 KEY(4, 4, KEY_B), 358 KEY(4, 5, KEY_N), 359 KEY(4, 6, KEY_DOT), 360 KEY(4, 8, KEY_ENTER), 361 KEY(4, 9, KEY_LEFTSHIFT), 362 KEY(5, 0, SPITZ_KEY_MAIL), /* MAIL */ 363 KEY(5, 1, KEY_Z), 364 KEY(5, 2, KEY_X), 365 KEY(5, 3, KEY_MINUS), 366 KEY(5, 4, KEY_SPACE), 367 KEY(5, 5, KEY_COMMA), 368 KEY(5, 7, KEY_UP), 369 KEY(5, 10, SPITZ_KEY_FN), /* FN */ 370 KEY(6, 0, KEY_SYSRQ), 371 KEY(6, 1, SPITZ_KEY_JAP1), /* JAP1 */ 372 KEY(6, 2, SPITZ_KEY_JAP2), /* JAP2 */ 373 KEY(6, 3, SPITZ_KEY_CANCEL), /* CANCEL */ 374 KEY(6, 4, SPITZ_KEY_OK), /* OK */ 375 KEY(6, 5, SPITZ_KEY_MENU), /* MENU */ 376 KEY(6, 6, KEY_LEFT), 377 KEY(6, 7, KEY_DOWN), 378 KEY(6, 8, KEY_RIGHT), 379 }; 380 381 static const struct software_node_ref_args spitz_mkp_row_gpios[] = { 382 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 12, GPIO_ACTIVE_HIGH), 383 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 17, GPIO_ACTIVE_HIGH), 384 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 91, GPIO_ACTIVE_HIGH), 385 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 34, GPIO_ACTIVE_HIGH), 386 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 36, GPIO_ACTIVE_HIGH), 387 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 38, GPIO_ACTIVE_HIGH), 388 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 39, GPIO_ACTIVE_HIGH), 389 }; 390 391 static const struct software_node_ref_args spitz_mkp_col_gpios[] = { 392 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 88, GPIO_ACTIVE_HIGH), 393 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 23, GPIO_ACTIVE_HIGH), 394 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 24, GPIO_ACTIVE_HIGH), 395 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 25, GPIO_ACTIVE_HIGH), 396 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 26, GPIO_ACTIVE_HIGH), 397 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 27, GPIO_ACTIVE_HIGH), 398 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 52, GPIO_ACTIVE_HIGH), 399 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 103, GPIO_ACTIVE_HIGH), 400 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 107, GPIO_ACTIVE_HIGH), 401 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 108, GPIO_ACTIVE_HIGH), 402 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, 114, GPIO_ACTIVE_HIGH), 403 }; 404 405 static const struct property_entry spitz_mkp_properties[] = { 406 PROPERTY_ENTRY_U32_ARRAY("linux,keymap", spitz_keymap), 407 PROPERTY_ENTRY_REF_ARRAY("row-gpios", spitz_mkp_row_gpios), 408 PROPERTY_ENTRY_REF_ARRAY("col-gpios", spitz_mkp_col_gpios), 409 PROPERTY_ENTRY_U32("col-scan-delay-us", 10), 410 PROPERTY_ENTRY_U32("debounce-delay-ms", 10), 411 PROPERTY_ENTRY_BOOL("wakeup-source"), 412 { } 413 }; 414 415 static const struct platform_device_info spitz_mkp_info __initconst = { 416 .name = "matrix-keypad", 417 .id = PLATFORM_DEVID_NONE, 418 .properties = spitz_mkp_properties, 419 }; 420 421 422 static void __init spitz_mkp_init(void) 423 { 424 struct platform_device *pd; 425 int err; 426 427 pd = platform_device_register_full(&spitz_mkp_info); 428 err = PTR_ERR_OR_ZERO(pd); 429 if (err) 430 pr_err("failed to create keypad device: %d\n", err); 431 } 432 #else 433 static inline void spitz_mkp_init(void) {} 434 #endif 435 436 /****************************************************************************** 437 * GPIO keys 438 ******************************************************************************/ 439 #if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE) 440 static const struct software_node spitz_gpio_keys_node = { 441 .name = "spitz-gpio-keys", 442 }; 443 444 static const struct property_entry spitz_suspend_key_props[] = { 445 PROPERTY_ENTRY_U32("linux,input-type", EV_PWR), 446 PROPERTY_ENTRY_U32("linux,code", KEY_SUSPEND), 447 PROPERTY_ENTRY_GPIO("gpios", &pxa2xx_gpiochip_node, 448 SPITZ_GPIO_ON_KEY, GPIO_ACTIVE_HIGH), 449 PROPERTY_ENTRY_STRING("label", "On Off"), 450 PROPERTY_ENTRY_BOOL("wakeup-source"), 451 { } 452 }; 453 454 static const struct software_node spitz_suspend_key_node = { 455 .parent = &spitz_gpio_keys_node, 456 .properties = spitz_suspend_key_props, 457 }; 458 459 static const struct property_entry spitz_sw1_props[] = { 460 PROPERTY_ENTRY_U32("linux,input-type", EV_SW), 461 PROPERTY_ENTRY_U32("linux,code", 0), 462 PROPERTY_ENTRY_GPIO("gpios", &pxa2xx_gpiochip_node, 463 SPITZ_GPIO_SWA, GPIO_ACTIVE_HIGH), 464 PROPERTY_ENTRY_STRING("label", "Display Down"), 465 { } 466 }; 467 468 static const struct software_node spitz_sw1_node = { 469 .parent = &spitz_gpio_keys_node, 470 .properties = spitz_sw1_props, 471 }; 472 473 static const struct property_entry spitz_sw2_props[] = { 474 PROPERTY_ENTRY_U32("linux,input-type", EV_SW), 475 PROPERTY_ENTRY_U32("linux,code", 1), 476 PROPERTY_ENTRY_GPIO("gpios", &pxa2xx_gpiochip_node, 477 SPITZ_GPIO_SWB, GPIO_ACTIVE_HIGH), 478 PROPERTY_ENTRY_STRING("label", "Lid Closed"), 479 { } 480 }; 481 482 static const struct software_node spitz_sw2_node = { 483 .parent = &spitz_gpio_keys_node, 484 .properties = spitz_sw2_props, 485 }; 486 487 static const struct software_node *spitz_gpio_keys_swnodes[] = { 488 &spitz_gpio_keys_node, 489 &spitz_suspend_key_node, 490 &spitz_sw1_node, 491 &spitz_sw2_node, 492 NULL 493 }; 494 495 static void __init spitz_keys_init(void) 496 { 497 struct platform_device_info keys_info = { 498 .name = "gpio-keys", 499 .id = PLATFORM_DEVID_NONE, 500 }; 501 struct platform_device *pd; 502 int err; 503 504 err = software_node_register_node_group(spitz_gpio_keys_swnodes); 505 if (err) { 506 pr_err("failed to register gpio-keys software nodes: %d\n", err); 507 return; 508 } 509 510 keys_info.fwnode = software_node_fwnode(&spitz_gpio_keys_node); 511 512 pd = platform_device_register_full(&keys_info); 513 err = PTR_ERR_OR_ZERO(pd); 514 if (err) 515 pr_err("failed to create gpio-keys device: %d\n", err); 516 } 517 #else 518 static inline void spitz_keys_init(void) {} 519 #endif 520 521 /****************************************************************************** 522 * LEDs 523 ******************************************************************************/ 524 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE) 525 static const struct software_node spitz_gpio_leds_node = { 526 .name = "spitz-leds", 527 }; 528 529 static const struct property_entry spitz_orange_led_props[] = { 530 PROPERTY_ENTRY_STRING("linux,default-trigger", "sharpsl-charge"), 531 PROPERTY_ENTRY_GPIO("gpios", 532 &spitz_scoop_1_gpiochip_node, 6, GPIO_ACTIVE_HIGH), 533 { } 534 }; 535 536 static const struct software_node spitz_orange_led_node = { 537 .name = "spitz:amber:charge", 538 .parent = &spitz_gpio_leds_node, 539 .properties = spitz_orange_led_props, 540 }; 541 542 static const struct property_entry spitz_green_led_props[] = { 543 PROPERTY_ENTRY_STRING("linux,default-trigger", "disk-activity"), 544 PROPERTY_ENTRY_GPIO("gpios", 545 &spitz_scoop_1_gpiochip_node, 0, GPIO_ACTIVE_HIGH), 546 { } 547 }; 548 549 static const struct software_node spitz_green_led_node = { 550 .name = "spitz:green:hddactivity", 551 .parent = &spitz_gpio_leds_node, 552 .properties = spitz_green_led_props, 553 }; 554 555 static const struct software_node *spitz_gpio_leds_swnodes[] = { 556 &spitz_gpio_leds_node, 557 &spitz_orange_led_node, 558 &spitz_green_led_node, 559 NULL 560 }; 561 562 static void __init spitz_leds_init(void) 563 { 564 struct platform_device_info led_info = { 565 .name = "leds-gpio", 566 .id = PLATFORM_DEVID_NONE, 567 }; 568 struct platform_device *led_dev; 569 int err; 570 571 err = software_node_register_node_group(spitz_gpio_leds_swnodes); 572 if (err) { 573 pr_err("failed to register LED software nodes: %d\n", err); 574 return; 575 } 576 577 led_info.fwnode = software_node_fwnode(&spitz_gpio_leds_node); 578 579 led_dev = platform_device_register_full(&led_info); 580 err = PTR_ERR_OR_ZERO(led_dev); 581 if (err) 582 pr_err("failed to create LED device: %d\n", err); 583 } 584 #else 585 static inline void spitz_leds_init(void) {} 586 #endif 587 588 /****************************************************************************** 589 * SSP Devices 590 ******************************************************************************/ 591 #if defined(CONFIG_SPI_PXA2XX) || defined(CONFIG_SPI_PXA2XX_MODULE) 592 593 static const struct property_entry spitz_ads7846_props[] = { 594 PROPERTY_ENTRY_STRING("compatible", "ti,ads7846"), 595 PROPERTY_ENTRY_U32("touchscreen-max-pressure", 1024), 596 PROPERTY_ENTRY_U16("ti,x-plate-ohms", 419), 597 PROPERTY_ENTRY_U16("ti,y-plate-ohms", 486), 598 PROPERTY_ENTRY_U16("ti,vref-delay-usecs", 100), 599 PROPERTY_ENTRY_GPIO("pendown-gpios", &pxa2xx_gpiochip_node, 600 SPITZ_GPIO_TP_INT, GPIO_ACTIVE_LOW), 601 PROPERTY_ENTRY_GPIO("ti,hsync-gpios", &pxa2xx_gpiochip_node, 602 SPITZ_GPIO_HSYNC, GPIO_ACTIVE_LOW), 603 { } 604 }; 605 606 static const struct software_node spitz_ads7846_swnode = { 607 .name = "ads7846", 608 .properties = spitz_ads7846_props, 609 }; 610 611 static const struct property_entry spitz_lcdcon_props[] = { 612 PROPERTY_ENTRY_GPIO("BL_CONT-gpios", 613 &spitz_scoop_2_gpiochip_node, 6, GPIO_ACTIVE_LOW), 614 PROPERTY_ENTRY_GPIO("BL_ON-gpios", 615 &spitz_scoop_2_gpiochip_node, 7, GPIO_ACTIVE_HIGH), 616 { } 617 }; 618 619 static const struct property_entry akita_lcdcon_props[] = { 620 PROPERTY_ENTRY_GPIO("BL_ON-gpios", 621 &akita_max7310_gpiochip_node, 3, GPIO_ACTIVE_HIGH), 622 PROPERTY_ENTRY_GPIO("BL_CONT-gpios", 623 &akita_max7310_gpiochip_node, 4, GPIO_ACTIVE_LOW), 624 { } 625 }; 626 627 static struct software_node spitz_lcdcon_node = { 628 .name = "spitz-lcdcon", 629 }; 630 631 static struct corgi_lcd_platform_data spitz_lcdcon_info = { 632 .init_mode = CORGI_LCD_MODE_VGA, 633 .max_intensity = 0x2f, 634 .default_intensity = 0x1f, 635 .limit_mask = 0x0b, 636 .kick_battery = sharpsl_battery_kick, 637 }; 638 639 static struct spi_board_info spitz_spi_devices[] = { 640 { 641 .modalias = "ads7846", 642 .max_speed_hz = 1200000, 643 .bus_num = 2, 644 .chip_select = 0, 645 .swnode = &spitz_ads7846_swnode, 646 .irq = PXA_GPIO_TO_IRQ(SPITZ_GPIO_TP_INT), 647 }, { 648 .modalias = "corgi-lcd", 649 .max_speed_hz = 50000, 650 .bus_num = 2, 651 .chip_select = 1, 652 .platform_data = &spitz_lcdcon_info, 653 .swnode = &spitz_lcdcon_node, 654 }, { 655 .modalias = "max1111", 656 .max_speed_hz = 450000, 657 .bus_num = 2, 658 .chip_select = 2, 659 }, 660 }; 661 662 static const struct software_node_ref_args spitz_spi_gpio_refs[] = { 663 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, SPITZ_GPIO_ADS7846_CS, 664 GPIO_ACTIVE_LOW), 665 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, SPITZ_GPIO_LCDCON_CS, 666 GPIO_ACTIVE_LOW), 667 SOFTWARE_NODE_REFERENCE(&pxa2xx_gpiochip_node, SPITZ_GPIO_MAX1111_CS, 668 GPIO_ACTIVE_LOW), 669 }; 670 671 static const struct property_entry spitz_spi_properties[] = { 672 PROPERTY_ENTRY_REF_ARRAY("gpios", spitz_spi_gpio_refs), 673 { } 674 }; 675 676 static const struct platform_device_info spitz_spi_device_info = { 677 .name = "pxa2xx-spi", 678 /* pxa2xx-spi platform-device ID equals respective SSP platform-device ID + 1 */ 679 .id = 2, 680 .properties = spitz_spi_properties, 681 }; 682 683 static void __init spitz_spi_init(void) 684 { 685 struct platform_device *pd; 686 int err; 687 688 pd = platform_device_register_full(&spitz_spi_device_info); 689 err = PTR_ERR_OR_ZERO(pd); 690 if (err) 691 pr_err("pxa2xx-spi: failed to instantiate SPI controller: %d\n", 692 err); 693 694 spitz_lcdcon_node.properties = machine_is_akita() ? 695 akita_lcdcon_props : spitz_lcdcon_props; 696 spi_register_board_info(ARRAY_AND_SIZE(spitz_spi_devices)); 697 } 698 #else 699 static inline void spitz_spi_init(void) {} 700 #endif 701 702 /****************************************************************************** 703 * SD/MMC card controller 704 ******************************************************************************/ 705 #if defined(CONFIG_MMC_PXA) || defined(CONFIG_MMC_PXA_MODULE) 706 /* 707 * NOTE: The card detect interrupt isn't debounced so we delay it by 250ms to 708 * give the card a chance to fully insert/eject. 709 */ 710 static int spitz_mci_setpower(struct device *dev, unsigned int vdd) 711 { 712 struct pxamci_platform_data* p_d = dev->platform_data; 713 714 if ((1 << vdd) & p_d->ocr_mask) 715 spitz_card_pwr_ctrl(SCOOP_CPR_SD_3V, SCOOP_CPR_SD_3V); 716 else 717 spitz_card_pwr_ctrl(SCOOP_CPR_SD_3V, 0x0); 718 719 return 0; 720 } 721 722 static struct pxamci_platform_data spitz_mci_platform_data = { 723 .detect_delay_ms = 250, 724 .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34, 725 .setpower = spitz_mci_setpower, 726 }; 727 728 static const struct property_entry spitz_mci_props[] __initconst = { 729 PROPERTY_ENTRY_GPIO("cd-gpios", &pxa2xx_gpiochip_node, 730 SPITZ_GPIO_nSD_DETECT, GPIO_ACTIVE_LOW), 731 PROPERTY_ENTRY_GPIO("wp-gpios", &pxa2xx_gpiochip_node, 732 SPITZ_GPIO_nSD_WP, GPIO_ACTIVE_LOW), 733 { } 734 }; 735 736 static void __init spitz_mmc_init(void) 737 { 738 pxa_set_mci_info(&spitz_mci_platform_data, spitz_mci_props); 739 } 740 #else 741 static inline void spitz_mmc_init(void) {} 742 #endif 743 744 /****************************************************************************** 745 * USB Host 746 ******************************************************************************/ 747 #if defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE) 748 static int spitz_ohci_init(struct device *dev) 749 { 750 int err; 751 752 err = gpio_request(SPITZ_GPIO_USB_HOST, "USB_HOST"); 753 if (err) 754 return err; 755 756 /* Only Port 2 is connected, setup USB Port 2 Output Control Register */ 757 UP2OCR = UP2OCR_HXS | UP2OCR_HXOE | UP2OCR_DPPDE | UP2OCR_DMPDE; 758 759 return gpio_direction_output(SPITZ_GPIO_USB_HOST, 1); 760 } 761 762 static void spitz_ohci_exit(struct device *dev) 763 { 764 gpio_free(SPITZ_GPIO_USB_HOST); 765 } 766 767 static struct pxaohci_platform_data spitz_ohci_platform_data = { 768 .port_mode = PMM_NPS_MODE, 769 .init = spitz_ohci_init, 770 .exit = spitz_ohci_exit, 771 .flags = ENABLE_PORT_ALL | NO_OC_PROTECTION, 772 .power_budget = 150, 773 }; 774 775 static void __init spitz_uhc_init(void) 776 { 777 pxa_set_ohci_info(&spitz_ohci_platform_data); 778 } 779 #else 780 static inline void spitz_uhc_init(void) {} 781 #endif 782 783 /****************************************************************************** 784 * Framebuffer 785 ******************************************************************************/ 786 #if defined(CONFIG_FB_PXA) || defined(CONFIG_FB_PXA_MODULE) 787 static struct pxafb_mode_info spitz_pxafb_modes[] = { 788 { 789 .pixclock = 19231, 790 .xres = 480, 791 .yres = 640, 792 .bpp = 16, 793 .hsync_len = 40, 794 .left_margin = 46, 795 .right_margin = 125, 796 .vsync_len = 3, 797 .upper_margin = 1, 798 .lower_margin = 0, 799 .sync = 0, 800 }, { 801 .pixclock = 134617, 802 .xres = 240, 803 .yres = 320, 804 .bpp = 16, 805 .hsync_len = 20, 806 .left_margin = 20, 807 .right_margin = 46, 808 .vsync_len = 2, 809 .upper_margin = 1, 810 .lower_margin = 0, 811 .sync = 0, 812 }, 813 }; 814 815 static struct pxafb_mach_info spitz_pxafb_info = { 816 .modes = spitz_pxafb_modes, 817 .num_modes = ARRAY_SIZE(spitz_pxafb_modes), 818 .fixed_modes = 1, 819 .lcd_conn = LCD_COLOR_TFT_16BPP | LCD_ALTERNATE_MAPPING, 820 }; 821 822 static void __init spitz_lcd_init(void) 823 { 824 pxa_set_fb_info(NULL, &spitz_pxafb_info); 825 } 826 #else 827 static inline void spitz_lcd_init(void) {} 828 #endif 829 830 /****************************************************************************** 831 * NAND Flash 832 ******************************************************************************/ 833 #if defined(CONFIG_MTD_NAND_SHARPSL) || defined(CONFIG_MTD_NAND_SHARPSL_MODULE) 834 static uint8_t scan_ff_pattern[] = { 0xff, 0xff }; 835 836 static struct nand_bbt_descr spitz_nand_bbt = { 837 .options = 0, 838 .offs = 4, 839 .len = 2, 840 .pattern = scan_ff_pattern 841 }; 842 843 static int akita_ooblayout_ecc(struct mtd_info *mtd, int section, 844 struct mtd_oob_region *oobregion) 845 { 846 if (section > 12) 847 return -ERANGE; 848 849 switch (section % 3) { 850 case 0: 851 oobregion->offset = 5; 852 oobregion->length = 1; 853 break; 854 855 case 1: 856 oobregion->offset = 1; 857 oobregion->length = 3; 858 break; 859 860 case 2: 861 oobregion->offset = 6; 862 oobregion->length = 2; 863 break; 864 } 865 866 oobregion->offset += (section / 3) * 0x10; 867 868 return 0; 869 } 870 871 static int akita_ooblayout_free(struct mtd_info *mtd, int section, 872 struct mtd_oob_region *oobregion) 873 { 874 if (section) 875 return -ERANGE; 876 877 oobregion->offset = 8; 878 oobregion->length = 9; 879 880 return 0; 881 } 882 883 static const struct mtd_ooblayout_ops akita_ooblayout_ops = { 884 .ecc = akita_ooblayout_ecc, 885 .free = akita_ooblayout_free, 886 }; 887 888 static const char * const probes[] = { 889 "cmdlinepart", 890 "ofpart", 891 "sharpslpart", 892 NULL, 893 }; 894 895 static struct sharpsl_nand_platform_data spitz_nand_pdata = { 896 .badblock_pattern = &spitz_nand_bbt, 897 .part_parsers = probes, 898 }; 899 900 static struct resource spitz_nand_resources[] = { 901 { 902 .start = PXA_CS3_PHYS, 903 .end = PXA_CS3_PHYS + SZ_4K - 1, 904 .flags = IORESOURCE_MEM, 905 }, 906 }; 907 908 static struct platform_device spitz_nand_device = { 909 .name = "sharpsl-nand", 910 .id = -1, 911 .resource = spitz_nand_resources, 912 .num_resources = ARRAY_SIZE(spitz_nand_resources), 913 .dev = { 914 .platform_data = &spitz_nand_pdata, 915 } 916 }; 917 918 static void __init spitz_nand_init(void) 919 { 920 if (machine_is_akita() || machine_is_borzoi()) { 921 spitz_nand_bbt.len = 1; 922 spitz_nand_pdata.ecc_layout = &akita_ooblayout_ops; 923 } 924 925 platform_device_register(&spitz_nand_device); 926 } 927 #else 928 static inline void spitz_nand_init(void) {} 929 #endif 930 931 /****************************************************************************** 932 * NOR Flash 933 ******************************************************************************/ 934 #if defined(CONFIG_MTD_PHYSMAP) || defined(CONFIG_MTD_PHYSMAP_MODULE) 935 static struct mtd_partition spitz_rom_parts[] = { 936 { 937 .name ="Boot PROM Filesystem", 938 .offset = 0x00140000, 939 .size = MTDPART_SIZ_FULL, 940 }, 941 }; 942 943 static struct physmap_flash_data spitz_rom_data = { 944 .width = 2, 945 .nr_parts = ARRAY_SIZE(spitz_rom_parts), 946 .parts = spitz_rom_parts, 947 }; 948 949 static struct resource spitz_rom_resources[] = { 950 { 951 .start = PXA_CS0_PHYS, 952 .end = PXA_CS0_PHYS + SZ_8M - 1, 953 .flags = IORESOURCE_MEM, 954 }, 955 }; 956 957 static struct platform_device spitz_rom_device = { 958 .name = "physmap-flash", 959 .id = -1, 960 .resource = spitz_rom_resources, 961 .num_resources = ARRAY_SIZE(spitz_rom_resources), 962 .dev = { 963 .platform_data = &spitz_rom_data, 964 }, 965 }; 966 967 static void __init spitz_nor_init(void) 968 { 969 platform_device_register(&spitz_rom_device); 970 } 971 #else 972 static inline void spitz_nor_init(void) {} 973 #endif 974 975 /****************************************************************************** 976 * I2C devices 977 ******************************************************************************/ 978 #if defined(CONFIG_I2C_PXA) || defined(CONFIG_I2C_PXA_MODULE) 979 static struct pca953x_platform_data akita_pca953x_pdata = { 980 .gpio_base = AKITA_IOEXP_GPIO_BASE, 981 }; 982 983 static struct i2c_board_info spitz_i2c_devs[] = { 984 { 985 .type = "wm8750", 986 .addr = 0x1b, 987 }, { 988 .type = "max7310", 989 .addr = 0x18, 990 .platform_data = &akita_pca953x_pdata, 991 }, 992 }; 993 994 static struct regulator_consumer_supply isl6271a_consumers[] = { 995 REGULATOR_SUPPLY("vcc_core", NULL), 996 }; 997 998 static struct regulator_init_data isl6271a_info[] = { 999 { 1000 .constraints = { 1001 .name = "vcc_core range", 1002 .min_uV = 850000, 1003 .max_uV = 1600000, 1004 .always_on = 1, 1005 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE, 1006 }, 1007 .consumer_supplies = isl6271a_consumers, 1008 .num_consumer_supplies = ARRAY_SIZE(isl6271a_consumers), 1009 } 1010 }; 1011 1012 static struct i2c_board_info spitz_pi2c_devs[] = { 1013 { 1014 .type = "isl6271a", 1015 .addr = 0x0c, 1016 .platform_data = &isl6271a_info, 1017 }, 1018 }; 1019 1020 static void __init spitz_i2c_init(void) 1021 { 1022 int size = ARRAY_SIZE(spitz_i2c_devs); 1023 1024 /* Only Akita has the max7310 chip */ 1025 if (!machine_is_akita()) 1026 size--; 1027 1028 pxa_set_i2c_info(NULL); 1029 pxa27x_set_i2c_power_info(NULL); 1030 i2c_register_board_info(0, spitz_i2c_devs, size); 1031 i2c_register_board_info(1, ARRAY_AND_SIZE(spitz_pi2c_devs)); 1032 } 1033 #else 1034 static inline void spitz_i2c_init(void) {} 1035 #endif 1036 1037 static const struct property_entry spitz_audio_props[] = { 1038 PROPERTY_ENTRY_GPIO("mute-l-gpios", &spitz_scoop_1_gpiochip_node, 3, 1039 GPIO_ACTIVE_HIGH), 1040 PROPERTY_ENTRY_GPIO("mute-r-gpios", &spitz_scoop_1_gpiochip_node, 4, 1041 GPIO_ACTIVE_HIGH), 1042 PROPERTY_ENTRY_GPIO("mic-gpios", &spitz_scoop_2_gpiochip_node, 8, 1043 GPIO_ACTIVE_HIGH), 1044 { } 1045 }; 1046 1047 static const struct property_entry akita_audio_props[] = { 1048 PROPERTY_ENTRY_GPIO("mute-l-gpios", &spitz_scoop_1_gpiochip_node, 3, 1049 GPIO_ACTIVE_HIGH), 1050 PROPERTY_ENTRY_GPIO("mute-r-gpios", &spitz_scoop_1_gpiochip_node, 4, 1051 GPIO_ACTIVE_HIGH), 1052 PROPERTY_ENTRY_GPIO("mic-gpios", &akita_max7310_gpiochip_node, 2, 1053 GPIO_ACTIVE_HIGH), 1054 { } 1055 }; 1056 1057 /****************************************************************************** 1058 * Audio devices 1059 ******************************************************************************/ 1060 static inline void spitz_audio_init(void) 1061 { 1062 struct platform_device_info audio_info = { 1063 .name = "spitz-audio", 1064 .id = PLATFORM_DEVID_NONE, 1065 .properties = machine_is_akita() ? 1066 akita_audio_props : spitz_audio_props, 1067 }; 1068 1069 platform_device_register_full(&audio_info); 1070 } 1071 1072 /****************************************************************************** 1073 * Machine init 1074 ******************************************************************************/ 1075 static void spitz_poweroff(void) 1076 { 1077 pxa_restart(REBOOT_GPIO, NULL); 1078 } 1079 1080 static void spitz_restart(enum reboot_mode mode, const char *cmd) 1081 { 1082 uint32_t msc0 = __raw_readl(MSC0); 1083 /* Bootloader magic for a reboot */ 1084 if ((msc0 & 0xffff0000) == 0x7ff00000) 1085 __raw_writel((msc0 & 0xffff) | 0x7ee00000, MSC0); 1086 1087 spitz_poweroff(); 1088 } 1089 1090 static void __init spitz_init(void) 1091 { 1092 software_node_register(&spitz_scoop_1_gpiochip_node); 1093 if (machine_is_akita()) 1094 software_node_register(&akita_max7310_gpiochip_node); 1095 else 1096 software_node_register(&spitz_scoop_2_gpiochip_node); 1097 1098 init_gpio_reset(SPITZ_GPIO_ON_RESET, 1, 0); 1099 pm_power_off = spitz_poweroff; 1100 1101 PMCR = 0x00; 1102 1103 /* Stop 3.6MHz and drive HIGH to PCMCIA and CS */ 1104 PCFR |= PCFR_OPDE; 1105 1106 pxa2xx_mfp_config(ARRAY_AND_SIZE(spitz_pin_config)); 1107 1108 pxa_set_ffuart_info(NULL); 1109 pxa_set_btuart_info(NULL); 1110 pxa_set_stuart_info(NULL); 1111 1112 spitz_spi_init(); 1113 spitz_scoop_init(); 1114 spitz_mkp_init(); 1115 spitz_keys_init(); 1116 spitz_leds_init(); 1117 spitz_mmc_init(); 1118 spitz_pcmcia_init(); 1119 spitz_uhc_init(); 1120 spitz_lcd_init(); 1121 spitz_nor_init(); 1122 spitz_nand_init(); 1123 spitz_i2c_init(); 1124 spitz_audio_init(); 1125 1126 regulator_has_full_constraints(); 1127 } 1128 1129 static void __init spitz_fixup(struct tag *tags, char **cmdline) 1130 { 1131 sharpsl_save_param(); 1132 memblock_add(0xa0000000, SZ_64M); 1133 } 1134 1135 #ifdef CONFIG_MACH_SPITZ 1136 MACHINE_START(SPITZ, "SHARP Spitz") 1137 .fixup = spitz_fixup, 1138 .map_io = pxa27x_map_io, 1139 .nr_irqs = PXA_NR_IRQS, 1140 .init_irq = pxa27x_init_irq, 1141 .init_machine = spitz_init, 1142 .init_time = pxa_timer_init, 1143 .restart = spitz_restart, 1144 MACHINE_END 1145 #endif 1146 1147 #ifdef CONFIG_MACH_BORZOI 1148 MACHINE_START(BORZOI, "SHARP Borzoi") 1149 .fixup = spitz_fixup, 1150 .map_io = pxa27x_map_io, 1151 .nr_irqs = PXA_NR_IRQS, 1152 .init_irq = pxa27x_init_irq, 1153 .init_machine = spitz_init, 1154 .init_time = pxa_timer_init, 1155 .restart = spitz_restart, 1156 MACHINE_END 1157 #endif 1158 1159 #ifdef CONFIG_MACH_AKITA 1160 MACHINE_START(AKITA, "SHARP Akita") 1161 .fixup = spitz_fixup, 1162 .map_io = pxa27x_map_io, 1163 .nr_irqs = PXA_NR_IRQS, 1164 .init_irq = pxa27x_init_irq, 1165 .init_machine = spitz_init, 1166 .init_time = pxa_timer_init, 1167 .restart = spitz_restart, 1168 MACHINE_END 1169 #endif 1170