1 /* 2 * Support for Sharp SL-Cxx00 Series of PDAs 3 * Models: SL-C3000 (Spitz), SL-C1000 (Akita) and SL-C3100 (Borzoi) 4 * 5 * Copyright (c) 2005 Richard Purdie 6 * 7 * Based on Sharp's 2.4 kernel patches/lubbock.c 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 * 13 */ 14 15 #include <linux/kernel.h> 16 #include <linux/init.h> 17 #include <linux/platform_device.h> 18 #include <linux/delay.h> 19 #include <linux/major.h> 20 #include <linux/fs.h> 21 #include <linux/interrupt.h> 22 #include <linux/mmc/host.h> 23 24 #include <asm/setup.h> 25 #include <asm/memory.h> 26 #include <asm/mach-types.h> 27 #include <asm/hardware.h> 28 #include <asm/irq.h> 29 #include <asm/io.h> 30 31 #include <asm/mach/arch.h> 32 #include <asm/mach/map.h> 33 #include <asm/mach/irq.h> 34 35 #include <asm/arch/pxa-regs.h> 36 #include <asm/arch/irq.h> 37 #include <asm/arch/irda.h> 38 #include <asm/arch/mmc.h> 39 #include <asm/arch/udc.h> 40 #include <asm/arch/pxafb.h> 41 #include <asm/arch/akita.h> 42 #include <asm/arch/spitz.h> 43 #include <asm/arch/sharpsl.h> 44 45 #include <asm/mach/sharpsl_param.h> 46 #include <asm/hardware/scoop.h> 47 48 #include "generic.h" 49 #include "sharpsl.h" 50 51 /* 52 * Spitz SCOOP Device #1 53 */ 54 static struct resource spitz_scoop_resources[] = { 55 [0] = { 56 .start = 0x10800000, 57 .end = 0x10800fff, 58 .flags = IORESOURCE_MEM, 59 }, 60 }; 61 62 static struct scoop_config spitz_scoop_setup = { 63 .io_dir = SPITZ_SCP_IO_DIR, 64 .io_out = SPITZ_SCP_IO_OUT, 65 .suspend_clr = SPITZ_SCP_SUS_CLR, 66 .suspend_set = SPITZ_SCP_SUS_SET, 67 }; 68 69 struct platform_device spitzscoop_device = { 70 .name = "sharp-scoop", 71 .id = 0, 72 .dev = { 73 .platform_data = &spitz_scoop_setup, 74 }, 75 .num_resources = ARRAY_SIZE(spitz_scoop_resources), 76 .resource = spitz_scoop_resources, 77 }; 78 79 /* 80 * Spitz SCOOP Device #2 81 */ 82 static struct resource spitz_scoop2_resources[] = { 83 [0] = { 84 .start = 0x08800040, 85 .end = 0x08800fff, 86 .flags = IORESOURCE_MEM, 87 }, 88 }; 89 90 static struct scoop_config spitz_scoop2_setup = { 91 .io_dir = SPITZ_SCP2_IO_DIR, 92 .io_out = SPITZ_SCP2_IO_OUT, 93 .suspend_clr = SPITZ_SCP2_SUS_CLR, 94 .suspend_set = SPITZ_SCP2_SUS_SET, 95 }; 96 97 struct platform_device spitzscoop2_device = { 98 .name = "sharp-scoop", 99 .id = 1, 100 .dev = { 101 .platform_data = &spitz_scoop2_setup, 102 }, 103 .num_resources = ARRAY_SIZE(spitz_scoop2_resources), 104 .resource = spitz_scoop2_resources, 105 }; 106 107 #define SPITZ_PWR_SD 0x01 108 #define SPITZ_PWR_CF 0x02 109 110 /* Power control is shared with between one of the CF slots and SD */ 111 static void spitz_card_pwr_ctrl(int device, unsigned short new_cpr) 112 { 113 unsigned short cpr = read_scoop_reg(&spitzscoop_device.dev, SCOOP_CPR); 114 115 if (new_cpr & 0x0007) { 116 set_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_CF_POWER); 117 if (!(cpr & 0x0002) && !(cpr & 0x0004)) 118 mdelay(5); 119 if (device == SPITZ_PWR_CF) 120 cpr |= 0x0002; 121 if (device == SPITZ_PWR_SD) 122 cpr |= 0x0004; 123 write_scoop_reg(&spitzscoop_device.dev, SCOOP_CPR, cpr | new_cpr); 124 } else { 125 if (device == SPITZ_PWR_CF) 126 cpr &= ~0x0002; 127 if (device == SPITZ_PWR_SD) 128 cpr &= ~0x0004; 129 write_scoop_reg(&spitzscoop_device.dev, SCOOP_CPR, cpr | new_cpr); 130 if (!(cpr & 0x0002) && !(cpr & 0x0004)) { 131 mdelay(1); 132 reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_CF_POWER); 133 } 134 } 135 } 136 137 static void spitz_pcmcia_init(void) 138 { 139 /* Setup default state of GPIO outputs 140 before we enable them as outputs. */ 141 GPSR(GPIO48_nPOE) = GPIO_bit(GPIO48_nPOE) | 142 GPIO_bit(GPIO49_nPWE) | GPIO_bit(GPIO50_nPIOR) | 143 GPIO_bit(GPIO51_nPIOW) | GPIO_bit(GPIO54_nPCE_2); 144 GPSR(GPIO85_nPCE_1) = GPIO_bit(GPIO85_nPCE_1); 145 146 pxa_gpio_mode(GPIO48_nPOE_MD); 147 pxa_gpio_mode(GPIO49_nPWE_MD); 148 pxa_gpio_mode(GPIO50_nPIOR_MD); 149 pxa_gpio_mode(GPIO51_nPIOW_MD); 150 pxa_gpio_mode(GPIO55_nPREG_MD); 151 pxa_gpio_mode(GPIO56_nPWAIT_MD); 152 pxa_gpio_mode(GPIO57_nIOIS16_MD); 153 pxa_gpio_mode(GPIO85_nPCE_1_MD); 154 pxa_gpio_mode(GPIO54_nPCE_2_MD); 155 pxa_gpio_mode(GPIO104_pSKTSEL_MD); 156 } 157 158 static void spitz_pcmcia_pwr(struct device *scoop, unsigned short cpr, int nr) 159 { 160 /* Only need to override behaviour for slot 0 */ 161 if (nr == 0) 162 spitz_card_pwr_ctrl(SPITZ_PWR_CF, cpr); 163 else 164 write_scoop_reg(scoop, SCOOP_CPR, cpr); 165 } 166 167 static struct scoop_pcmcia_dev spitz_pcmcia_scoop[] = { 168 { 169 .dev = &spitzscoop_device.dev, 170 .irq = SPITZ_IRQ_GPIO_CF_IRQ, 171 .cd_irq = SPITZ_IRQ_GPIO_CF_CD, 172 .cd_irq_str = "PCMCIA0 CD", 173 },{ 174 .dev = &spitzscoop2_device.dev, 175 .irq = SPITZ_IRQ_GPIO_CF2_IRQ, 176 .cd_irq = -1, 177 }, 178 }; 179 180 static struct scoop_pcmcia_config spitz_pcmcia_config = { 181 .devs = &spitz_pcmcia_scoop[0], 182 .num_devs = 2, 183 .pcmcia_init = spitz_pcmcia_init, 184 .power_ctrl = spitz_pcmcia_pwr, 185 }; 186 187 EXPORT_SYMBOL(spitzscoop_device); 188 EXPORT_SYMBOL(spitzscoop2_device); 189 190 191 /* 192 * Spitz SSP Device 193 * 194 * Set the parent as the scoop device because a lot of SSP devices 195 * also use scoop functions and this makes the power up/down order 196 * work correctly. 197 */ 198 struct platform_device spitzssp_device = { 199 .name = "corgi-ssp", 200 .dev = { 201 .parent = &spitzscoop_device.dev, 202 }, 203 .id = -1, 204 }; 205 206 struct corgissp_machinfo spitz_ssp_machinfo = { 207 .port = 2, 208 .cs_lcdcon = SPITZ_GPIO_LCDCON_CS, 209 .cs_ads7846 = SPITZ_GPIO_ADS7846_CS, 210 .cs_max1111 = SPITZ_GPIO_MAX1111_CS, 211 .clk_lcdcon = 520, 212 .clk_ads7846 = 14, 213 .clk_max1111 = 56, 214 }; 215 216 217 /* 218 * Spitz Backlight Device 219 */ 220 static struct corgibl_machinfo spitz_bl_machinfo = { 221 .max_intensity = 0x2f, 222 }; 223 224 static struct platform_device spitzbl_device = { 225 .name = "corgi-bl", 226 .dev = { 227 .platform_data = &spitz_bl_machinfo, 228 }, 229 .id = -1, 230 }; 231 232 233 /* 234 * Spitz Keyboard Device 235 */ 236 static struct platform_device spitzkbd_device = { 237 .name = "spitz-keyboard", 238 .id = -1, 239 }; 240 241 242 /* 243 * Spitz Touch Screen Device 244 */ 245 static struct resource spitzts_resources[] = { 246 [0] = { 247 .start = SPITZ_IRQ_GPIO_TP_INT, 248 .end = SPITZ_IRQ_GPIO_TP_INT, 249 .flags = IORESOURCE_IRQ, 250 }, 251 }; 252 253 static struct corgits_machinfo spitz_ts_machinfo = { 254 .get_hsync_len = spitz_get_hsync_len, 255 .put_hsync = spitz_put_hsync, 256 .wait_hsync = spitz_wait_hsync, 257 }; 258 259 static struct platform_device spitzts_device = { 260 .name = "corgi-ts", 261 .dev = { 262 .parent = &spitzssp_device.dev, 263 .platform_data = &spitz_ts_machinfo, 264 }, 265 .id = -1, 266 .num_resources = ARRAY_SIZE(spitzts_resources), 267 .resource = spitzts_resources, 268 }; 269 270 271 /* 272 * MMC/SD Device 273 * 274 * The card detect interrupt isn't debounced so we delay it by 250ms 275 * to give the card a chance to fully insert/eject. 276 */ 277 278 static struct pxamci_platform_data spitz_mci_platform_data; 279 280 static int spitz_mci_init(struct device *dev, irqreturn_t (*spitz_detect_int)(int, void *, struct pt_regs *), void *data) 281 { 282 int err; 283 284 /* setup GPIO for PXA27x MMC controller */ 285 pxa_gpio_mode(GPIO32_MMCCLK_MD); 286 pxa_gpio_mode(GPIO112_MMCCMD_MD); 287 pxa_gpio_mode(GPIO92_MMCDAT0_MD); 288 pxa_gpio_mode(GPIO109_MMCDAT1_MD); 289 pxa_gpio_mode(GPIO110_MMCDAT2_MD); 290 pxa_gpio_mode(GPIO111_MMCDAT3_MD); 291 pxa_gpio_mode(SPITZ_GPIO_nSD_DETECT | GPIO_IN); 292 pxa_gpio_mode(SPITZ_GPIO_nSD_WP | GPIO_IN); 293 294 spitz_mci_platform_data.detect_delay = msecs_to_jiffies(250); 295 296 err = request_irq(SPITZ_IRQ_GPIO_nSD_DETECT, spitz_detect_int, SA_INTERRUPT, 297 "MMC card detect", data); 298 if (err) { 299 printk(KERN_ERR "spitz_mci_init: MMC/SD: can't request MMC card detect IRQ\n"); 300 return -1; 301 } 302 303 set_irq_type(SPITZ_IRQ_GPIO_nSD_DETECT, IRQT_BOTHEDGE); 304 305 return 0; 306 } 307 308 static void spitz_mci_setpower(struct device *dev, unsigned int vdd) 309 { 310 struct pxamci_platform_data* p_d = dev->platform_data; 311 312 if (( 1 << vdd) & p_d->ocr_mask) 313 spitz_card_pwr_ctrl(SPITZ_PWR_SD, 0x0004); 314 else 315 spitz_card_pwr_ctrl(SPITZ_PWR_SD, 0x0000); 316 } 317 318 static int spitz_mci_get_ro(struct device *dev) 319 { 320 return GPLR(SPITZ_GPIO_nSD_WP) & GPIO_bit(SPITZ_GPIO_nSD_WP); 321 } 322 323 static void spitz_mci_exit(struct device *dev, void *data) 324 { 325 free_irq(SPITZ_IRQ_GPIO_nSD_DETECT, data); 326 } 327 328 static struct pxamci_platform_data spitz_mci_platform_data = { 329 .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34, 330 .init = spitz_mci_init, 331 .get_ro = spitz_mci_get_ro, 332 .setpower = spitz_mci_setpower, 333 .exit = spitz_mci_exit, 334 }; 335 336 337 /* 338 * Irda 339 */ 340 static void spitz_irda_transceiver_mode(struct device *dev, int mode) 341 { 342 if (mode & IR_OFF) 343 set_scoop_gpio(&spitzscoop2_device.dev, SPITZ_SCP2_IR_ON); 344 else 345 reset_scoop_gpio(&spitzscoop2_device.dev, SPITZ_SCP2_IR_ON); 346 } 347 348 #ifdef CONFIG_MACH_AKITA 349 static void akita_irda_transceiver_mode(struct device *dev, int mode) 350 { 351 if (mode & IR_OFF) 352 akita_set_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_IR_ON); 353 else 354 akita_reset_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_IR_ON); 355 } 356 #endif 357 358 static struct pxaficp_platform_data spitz_ficp_platform_data = { 359 .transceiver_cap = IR_SIRMODE | IR_OFF, 360 .transceiver_mode = spitz_irda_transceiver_mode, 361 }; 362 363 364 /* 365 * Spitz PXA Framebuffer 366 */ 367 static struct pxafb_mach_info spitz_pxafb_info __initdata = { 368 .pixclock = 19231, 369 .xres = 480, 370 .yres = 640, 371 .bpp = 16, 372 .hsync_len = 40, 373 .left_margin = 46, 374 .right_margin = 125, 375 .vsync_len = 3, 376 .upper_margin = 1, 377 .lower_margin = 0, 378 .sync = 0, 379 .lccr0 = LCCR0_Color | LCCR0_Sngl | LCCR0_Act | LCCR0_LDDALT | LCCR0_OUC | LCCR0_CMDIM | LCCR0_RDSTM, 380 .lccr3 = LCCR3_PixRsEdg | LCCR3_OutEnH, 381 .pxafb_lcd_power = spitz_lcd_power, 382 }; 383 384 385 static struct platform_device *devices[] __initdata = { 386 &spitzscoop_device, 387 &spitzssp_device, 388 &spitzkbd_device, 389 &spitzts_device, 390 &spitzbl_device, 391 }; 392 393 static void __init common_init(void) 394 { 395 PMCR = 0x00; 396 397 /* setup sleep mode values */ 398 PWER = 0x00000002; 399 PFER = 0x00000000; 400 PRER = 0x00000002; 401 PGSR0 = 0x0158C000; 402 PGSR1 = 0x00FF0080; 403 PGSR2 = 0x0001C004; 404 405 /* Stop 3.6MHz and drive HIGH to PCMCIA and CS */ 406 PCFR |= PCFR_OPDE; 407 408 corgi_ssp_set_machinfo(&spitz_ssp_machinfo); 409 410 pxa_gpio_mode(SPITZ_GPIO_HSYNC | GPIO_IN); 411 412 platform_add_devices(devices, ARRAY_SIZE(devices)); 413 pxa_set_mci_info(&spitz_mci_platform_data); 414 pxa_set_ficp_info(&spitz_ficp_platform_data); 415 set_pxa_fb_parent(&spitzssp_device.dev); 416 set_pxa_fb_info(&spitz_pxafb_info); 417 } 418 419 static void __init spitz_init(void) 420 { 421 platform_scoop_config = &spitz_pcmcia_config; 422 423 spitz_bl_machinfo.set_bl_intensity = spitz_bl_set_intensity; 424 425 common_init(); 426 427 platform_device_register(&spitzscoop2_device); 428 } 429 430 #ifdef CONFIG_MACH_AKITA 431 /* 432 * Akita IO Expander 433 */ 434 struct platform_device akitaioexp_device = { 435 .name = "akita-ioexp", 436 .id = -1, 437 }; 438 439 static void __init akita_init(void) 440 { 441 spitz_ficp_platform_data.transceiver_mode = akita_irda_transceiver_mode; 442 443 /* We just pretend the second element of the array doesn't exist */ 444 spitz_pcmcia_config.num_devs = 1; 445 platform_scoop_config = &spitz_pcmcia_config; 446 spitz_bl_machinfo.set_bl_intensity = akita_bl_set_intensity; 447 448 platform_device_register(&akitaioexp_device); 449 450 spitzscoop_device.dev.parent = &akitaioexp_device.dev; 451 common_init(); 452 } 453 #endif 454 455 456 static void __init fixup_spitz(struct machine_desc *desc, 457 struct tag *tags, char **cmdline, struct meminfo *mi) 458 { 459 sharpsl_save_param(); 460 mi->nr_banks = 1; 461 mi->bank[0].start = 0xa0000000; 462 mi->bank[0].node = 0; 463 mi->bank[0].size = (64*1024*1024); 464 } 465 466 #ifdef CONFIG_MACH_SPITZ 467 MACHINE_START(SPITZ, "SHARP Spitz") 468 .phys_ram = 0xa0000000, 469 .phys_io = 0x40000000, 470 .io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc, 471 .fixup = fixup_spitz, 472 .map_io = pxa_map_io, 473 .init_irq = pxa_init_irq, 474 .init_machine = spitz_init, 475 .timer = &pxa_timer, 476 MACHINE_END 477 #endif 478 479 #ifdef CONFIG_MACH_BORZOI 480 MACHINE_START(BORZOI, "SHARP Borzoi") 481 .phys_ram = 0xa0000000, 482 .phys_io = 0x40000000, 483 .io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc, 484 .fixup = fixup_spitz, 485 .map_io = pxa_map_io, 486 .init_irq = pxa_init_irq, 487 .init_machine = spitz_init, 488 .timer = &pxa_timer, 489 MACHINE_END 490 #endif 491 492 #ifdef CONFIG_MACH_AKITA 493 MACHINE_START(AKITA, "SHARP Akita") 494 .phys_ram = 0xa0000000, 495 .phys_io = 0x40000000, 496 .io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc, 497 .fixup = fixup_spitz, 498 .map_io = pxa_map_io, 499 .init_irq = pxa_init_irq, 500 .init_machine = akita_init, 501 .timer = &pxa_timer, 502 MACHINE_END 503 #endif 504