1/* 2 * linux/arch/arm/mach-pxa/lubbock.c 3 * 4 * Support for the Intel DBPXA250 Development Platform. 5 * 6 * Author: Nicolas Pitre 7 * Created: Jun 15, 2001 8 * Copyright: MontaVista Software Inc. 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 */ 14#include <linux/module.h> 15#include <linux/kernel.h> 16#include <linux/init.h> 17#include <linux/platform_device.h> 18#include <linux/sysdev.h> 19#include <linux/major.h> 20#include <linux/fb.h> 21#include <linux/interrupt.h> 22#include <linux/mtd/mtd.h> 23#include <linux/mtd/partitions.h> 24#include <linux/smc91x.h> 25 26#include <linux/spi/spi.h> 27#include <linux/spi/ads7846.h> 28#include <mach/pxa2xx_spi.h> 29 30#include <asm/setup.h> 31#include <asm/memory.h> 32#include <asm/mach-types.h> 33#include <mach/hardware.h> 34#include <asm/irq.h> 35#include <asm/sizes.h> 36 37#include <asm/mach/arch.h> 38#include <asm/mach/map.h> 39#include <asm/mach/irq.h> 40#include <asm/mach/flash.h> 41 42#include <asm/hardware/sa1111.h> 43 44#include <mach/pxa25x.h> 45#include <mach/gpio.h> 46#include <mach/audio.h> 47#include <mach/lubbock.h> 48#include <mach/udc.h> 49#include <mach/irda.h> 50#include <mach/pxafb.h> 51#include <mach/mmc.h> 52#include <mach/pm.h> 53 54#include "generic.h" 55#include "clock.h" 56#include "devices.h" 57 58static unsigned long lubbock_pin_config[] __initdata = { 59 GPIO15_nCS_1, /* CS1 - Flash */ 60 GPIO78_nCS_2, /* CS2 - Baseboard FGPA */ 61 GPIO79_nCS_3, /* CS3 - SMC ethernet */ 62 GPIO80_nCS_4, /* CS4 - SA1111 */ 63 64 /* SSP data pins */ 65 GPIO23_SSP1_SCLK, 66 GPIO25_SSP1_TXD, 67 GPIO26_SSP1_RXD, 68 69 /* AC97 */ 70 GPIO28_AC97_BITCLK, 71 GPIO29_AC97_SDATA_IN_0, 72 GPIO30_AC97_SDATA_OUT, 73 GPIO31_AC97_SYNC, 74 75 /* LCD - 16bpp DSTN */ 76 GPIOxx_LCD_DSTN_16BPP, 77 78 /* BTUART */ 79 GPIO42_BTUART_RXD, 80 GPIO43_BTUART_TXD, 81 GPIO44_BTUART_CTS, 82 GPIO45_BTUART_RTS, 83 84 /* PC Card */ 85 GPIO48_nPOE, 86 GPIO49_nPWE, 87 GPIO50_nPIOR, 88 GPIO51_nPIOW, 89 GPIO52_nPCE_1, 90 GPIO53_nPCE_2, 91 GPIO54_nPSKTSEL, 92 GPIO55_nPREG, 93 GPIO56_nPWAIT, 94 GPIO57_nIOIS16, 95 96 /* MMC */ 97 GPIO6_MMC_CLK, 98 GPIO8_MMC_CS0, 99 100 /* wakeup */ 101 GPIO1_GPIO | WAKEUP_ON_EDGE_RISE, 102}; 103 104#define LUB_HEXLED __LUB_REG(LUBBOCK_FPGA_PHYS + 0x010) 105#define LUB_MISC_WR __LUB_REG(LUBBOCK_FPGA_PHYS + 0x080) 106 107void lubbock_set_hexled(uint32_t value) 108{ 109 LUB_HEXLED = value; 110} 111 112void lubbock_set_misc_wr(unsigned int mask, unsigned int set) 113{ 114 unsigned long flags; 115 116 local_irq_save(flags); 117 LUB_MISC_WR = (LUB_MISC_WR & ~mask) | (set & mask); 118 local_irq_restore(flags); 119} 120EXPORT_SYMBOL(lubbock_set_misc_wr); 121 122static unsigned long lubbock_irq_enabled; 123 124static void lubbock_mask_irq(unsigned int irq) 125{ 126 int lubbock_irq = (irq - LUBBOCK_IRQ(0)); 127 LUB_IRQ_MASK_EN = (lubbock_irq_enabled &= ~(1 << lubbock_irq)); 128} 129 130static void lubbock_unmask_irq(unsigned int irq) 131{ 132 int lubbock_irq = (irq - LUBBOCK_IRQ(0)); 133 /* the irq can be acknowledged only if deasserted, so it's done here */ 134 LUB_IRQ_SET_CLR &= ~(1 << lubbock_irq); 135 LUB_IRQ_MASK_EN = (lubbock_irq_enabled |= (1 << lubbock_irq)); 136} 137 138static struct irq_chip lubbock_irq_chip = { 139 .name = "FPGA", 140 .ack = lubbock_mask_irq, 141 .mask = lubbock_mask_irq, 142 .unmask = lubbock_unmask_irq, 143}; 144 145static void lubbock_irq_handler(unsigned int irq, struct irq_desc *desc) 146{ 147 unsigned long pending = LUB_IRQ_SET_CLR & lubbock_irq_enabled; 148 do { 149 desc->chip->ack(irq); /* clear our parent irq */ 150 if (likely(pending)) { 151 irq = LUBBOCK_IRQ(0) + __ffs(pending); 152 generic_handle_irq(irq); 153 } 154 pending = LUB_IRQ_SET_CLR & lubbock_irq_enabled; 155 } while (pending); 156} 157 158static void __init lubbock_init_irq(void) 159{ 160 int irq; 161 162 pxa25x_init_irq(); 163 164 /* setup extra lubbock irqs */ 165 for (irq = LUBBOCK_IRQ(0); irq <= LUBBOCK_LAST_IRQ; irq++) { 166 set_irq_chip(irq, &lubbock_irq_chip); 167 set_irq_handler(irq, handle_level_irq); 168 set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); 169 } 170 171 set_irq_chained_handler(IRQ_GPIO(0), lubbock_irq_handler); 172 set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING); 173} 174 175#ifdef CONFIG_PM 176 177static int lubbock_irq_resume(struct sys_device *dev) 178{ 179 LUB_IRQ_MASK_EN = lubbock_irq_enabled; 180 return 0; 181} 182 183static struct sysdev_class lubbock_irq_sysclass = { 184 .name = "cpld_irq", 185 .resume = lubbock_irq_resume, 186}; 187 188static struct sys_device lubbock_irq_device = { 189 .cls = &lubbock_irq_sysclass, 190}; 191 192static int __init lubbock_irq_device_init(void) 193{ 194 int ret = -ENODEV; 195 196 if (machine_is_lubbock()) { 197 ret = sysdev_class_register(&lubbock_irq_sysclass); 198 if (ret == 0) 199 ret = sysdev_register(&lubbock_irq_device); 200 } 201 return ret; 202} 203 204device_initcall(lubbock_irq_device_init); 205 206#endif 207 208static int lubbock_udc_is_connected(void) 209{ 210 return (LUB_MISC_RD & (1 << 9)) == 0; 211} 212 213static struct pxa2xx_udc_mach_info udc_info __initdata = { 214 .udc_is_connected = lubbock_udc_is_connected, 215 // no D+ pullup; lubbock can't connect/disconnect in software 216}; 217 218static struct resource sa1111_resources[] = { 219 [0] = { 220 .start = 0x10000000, 221 .end = 0x10001fff, 222 .flags = IORESOURCE_MEM, 223 }, 224 [1] = { 225 .start = LUBBOCK_SA1111_IRQ, 226 .end = LUBBOCK_SA1111_IRQ, 227 .flags = IORESOURCE_IRQ, 228 }, 229}; 230 231static struct sa1111_platform_data sa1111_info = { 232 .irq_base = IRQ_BOARD_END, 233}; 234 235static struct platform_device sa1111_device = { 236 .name = "sa1111", 237 .id = -1, 238 .num_resources = ARRAY_SIZE(sa1111_resources), 239 .resource = sa1111_resources, 240 .dev = { 241 .platform_data = &sa1111_info, 242 }, 243}; 244 245/* ADS7846 is connected through SSP ... and if your board has J5 populated, 246 * you can select it to replace the ucb1400 by switching the touchscreen cable 247 * (to J5) and poking board registers (as done below). Else it's only useful 248 * for the temperature sensors. 249 */ 250static struct pxa2xx_spi_master pxa_ssp_master_info = { 251 .num_chipselect = 1, 252}; 253 254static int lubbock_ads7846_pendown_state(void) 255{ 256 /* TS_BUSY is bit 8 in LUB_MISC_RD, but pendown is irq-only */ 257 return 0; 258} 259 260static struct ads7846_platform_data ads_info = { 261 .model = 7846, 262 .vref_delay_usecs = 100, /* internal, no cap */ 263 .get_pendown_state = lubbock_ads7846_pendown_state, 264 // .x_plate_ohms = 500, /* GUESS! */ 265 // .y_plate_ohms = 500, /* GUESS! */ 266}; 267 268static void ads7846_cs(u32 command) 269{ 270 static const unsigned TS_nCS = 1 << 11; 271 lubbock_set_misc_wr(TS_nCS, (command == PXA2XX_CS_ASSERT) ? 0 : TS_nCS); 272} 273 274static struct pxa2xx_spi_chip ads_hw = { 275 .tx_threshold = 1, 276 .rx_threshold = 2, 277 .cs_control = ads7846_cs, 278}; 279 280static struct spi_board_info spi_board_info[] __initdata = { { 281 .modalias = "ads7846", 282 .platform_data = &ads_info, 283 .controller_data = &ads_hw, 284 .irq = LUBBOCK_BB_IRQ, 285 .max_speed_hz = 120000 /* max sample rate at 3V */ 286 * 26 /* command + data + overhead */, 287 .bus_num = 1, 288 .chip_select = 0, 289}, 290}; 291 292static struct resource smc91x_resources[] = { 293 [0] = { 294 .name = "smc91x-regs", 295 .start = 0x0c000c00, 296 .end = 0x0c0fffff, 297 .flags = IORESOURCE_MEM, 298 }, 299 [1] = { 300 .start = LUBBOCK_ETH_IRQ, 301 .end = LUBBOCK_ETH_IRQ, 302 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE, 303 }, 304 [2] = { 305 .name = "smc91x-attrib", 306 .start = 0x0e000000, 307 .end = 0x0e0fffff, 308 .flags = IORESOURCE_MEM, 309 }, 310}; 311 312static struct smc91x_platdata lubbock_smc91x_info = { 313 .flags = SMC91X_USE_16BIT | SMC91X_NOWAIT | SMC91X_IO_SHIFT_2, 314}; 315 316static struct platform_device smc91x_device = { 317 .name = "smc91x", 318 .id = -1, 319 .num_resources = ARRAY_SIZE(smc91x_resources), 320 .resource = smc91x_resources, 321 .dev = { 322 .platform_data = &lubbock_smc91x_info, 323 }, 324}; 325 326static struct resource flash_resources[] = { 327 [0] = { 328 .start = 0x00000000, 329 .end = SZ_64M - 1, 330 .flags = IORESOURCE_MEM, 331 }, 332 [1] = { 333 .start = 0x04000000, 334 .end = 0x04000000 + SZ_64M - 1, 335 .flags = IORESOURCE_MEM, 336 }, 337}; 338 339static struct mtd_partition lubbock_partitions[] = { 340 { 341 .name = "Bootloader", 342 .size = 0x00040000, 343 .offset = 0, 344 .mask_flags = MTD_WRITEABLE /* force read-only */ 345 },{ 346 .name = "Kernel", 347 .size = 0x00100000, 348 .offset = 0x00040000, 349 },{ 350 .name = "Filesystem", 351 .size = MTDPART_SIZ_FULL, 352 .offset = 0x00140000 353 } 354}; 355 356static struct flash_platform_data lubbock_flash_data[2] = { 357 { 358 .map_name = "cfi_probe", 359 .parts = lubbock_partitions, 360 .nr_parts = ARRAY_SIZE(lubbock_partitions), 361 }, { 362 .map_name = "cfi_probe", 363 .parts = NULL, 364 .nr_parts = 0, 365 } 366}; 367 368static struct platform_device lubbock_flash_device[2] = { 369 { 370 .name = "pxa2xx-flash", 371 .id = 0, 372 .dev = { 373 .platform_data = &lubbock_flash_data[0], 374 }, 375 .resource = &flash_resources[0], 376 .num_resources = 1, 377 }, 378 { 379 .name = "pxa2xx-flash", 380 .id = 1, 381 .dev = { 382 .platform_data = &lubbock_flash_data[1], 383 }, 384 .resource = &flash_resources[1], 385 .num_resources = 1, 386 }, 387}; 388 389static struct platform_device *devices[] __initdata = { 390 &sa1111_device, 391 &smc91x_device, 392 &lubbock_flash_device[0], 393 &lubbock_flash_device[1], 394}; 395 396static struct pxafb_mode_info sharp_lm8v31_mode = { 397 .pixclock = 270000, 398 .xres = 640, 399 .yres = 480, 400 .bpp = 16, 401 .hsync_len = 1, 402 .left_margin = 3, 403 .right_margin = 3, 404 .vsync_len = 1, 405 .upper_margin = 0, 406 .lower_margin = 0, 407 .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, 408 .cmap_greyscale = 0, 409}; 410 411static struct pxafb_mach_info sharp_lm8v31 = { 412 .modes = &sharp_lm8v31_mode, 413 .num_modes = 1, 414 .cmap_inverse = 0, 415 .cmap_static = 0, 416 .lcd_conn = LCD_COLOR_DSTN_16BPP | LCD_PCLK_EDGE_FALL | 417 LCD_AC_BIAS_FREQ(255), 418}; 419 420#define MMC_POLL_RATE msecs_to_jiffies(1000) 421 422static void lubbock_mmc_poll(unsigned long); 423static irq_handler_t mmc_detect_int; 424 425static struct timer_list mmc_timer = { 426 .function = lubbock_mmc_poll, 427}; 428 429static void lubbock_mmc_poll(unsigned long data) 430{ 431 unsigned long flags; 432 433 /* clear any previous irq state, then ... */ 434 local_irq_save(flags); 435 LUB_IRQ_SET_CLR &= ~(1 << 0); 436 local_irq_restore(flags); 437 438 /* poll until mmc/sd card is removed */ 439 if (LUB_IRQ_SET_CLR & (1 << 0)) 440 mod_timer(&mmc_timer, jiffies + MMC_POLL_RATE); 441 else { 442 (void) mmc_detect_int(LUBBOCK_SD_IRQ, (void *)data); 443 enable_irq(LUBBOCK_SD_IRQ); 444 } 445} 446 447static irqreturn_t lubbock_detect_int(int irq, void *data) 448{ 449 /* IRQ is level triggered; disable, and poll for removal */ 450 disable_irq(irq); 451 mod_timer(&mmc_timer, jiffies + MMC_POLL_RATE); 452 453 return mmc_detect_int(irq, data); 454} 455 456static int lubbock_mci_init(struct device *dev, 457 irq_handler_t detect_int, 458 void *data) 459{ 460 /* detect card insert/eject */ 461 mmc_detect_int = detect_int; 462 init_timer(&mmc_timer); 463 mmc_timer.data = (unsigned long) data; 464 return request_irq(LUBBOCK_SD_IRQ, lubbock_detect_int, 465 IRQF_SAMPLE_RANDOM, "lubbock-sd-detect", data); 466} 467 468static int lubbock_mci_get_ro(struct device *dev) 469{ 470 return (LUB_MISC_RD & (1 << 2)) != 0; 471} 472 473static void lubbock_mci_exit(struct device *dev, void *data) 474{ 475 free_irq(LUBBOCK_SD_IRQ, data); 476 del_timer_sync(&mmc_timer); 477} 478 479static struct pxamci_platform_data lubbock_mci_platform_data = { 480 .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34, 481 .detect_delay_ms = 10, 482 .init = lubbock_mci_init, 483 .get_ro = lubbock_mci_get_ro, 484 .exit = lubbock_mci_exit, 485 .gpio_card_detect = -1, 486 .gpio_card_ro = -1, 487 .gpio_power = -1, 488}; 489 490static void lubbock_irda_transceiver_mode(struct device *dev, int mode) 491{ 492 unsigned long flags; 493 494 local_irq_save(flags); 495 if (mode & IR_SIRMODE) { 496 LUB_MISC_WR &= ~(1 << 4); 497 } else if (mode & IR_FIRMODE) { 498 LUB_MISC_WR |= 1 << 4; 499 } 500 pxa2xx_transceiver_mode(dev, mode); 501 local_irq_restore(flags); 502} 503 504static struct pxaficp_platform_data lubbock_ficp_platform_data = { 505 .gpio_pwdown = -1, 506 .transceiver_cap = IR_SIRMODE | IR_FIRMODE, 507 .transceiver_mode = lubbock_irda_transceiver_mode, 508}; 509 510static void __init lubbock_init(void) 511{ 512 int flashboot = (LUB_CONF_SWITCHES & 1); 513 514 pxa2xx_mfp_config(ARRAY_AND_SIZE(lubbock_pin_config)); 515 516 pxa_set_ffuart_info(NULL); 517 pxa_set_btuart_info(NULL); 518 pxa_set_stuart_info(NULL); 519 520 clk_add_alias("SA1111_CLK", NULL, "GPIO11_CLK", NULL); 521 pxa_set_udc_info(&udc_info); 522 set_pxa_fb_info(&sharp_lm8v31); 523 pxa_set_mci_info(&lubbock_mci_platform_data); 524 pxa_set_ficp_info(&lubbock_ficp_platform_data); 525 pxa_set_ac97_info(NULL); 526 527 lubbock_flash_data[0].width = lubbock_flash_data[1].width = 528 (BOOT_DEF & 1) ? 2 : 4; 529 /* Compensate for the nROMBT switch which swaps the flash banks */ 530 printk(KERN_NOTICE "Lubbock configured to boot from %s (bank %d)\n", 531 flashboot?"Flash":"ROM", flashboot); 532 533 lubbock_flash_data[flashboot^1].name = "application-flash"; 534 lubbock_flash_data[flashboot].name = "boot-rom"; 535 (void) platform_add_devices(devices, ARRAY_SIZE(devices)); 536 537 pxa2xx_set_spi_info(1, &pxa_ssp_master_info); 538 spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info)); 539} 540 541static struct map_desc lubbock_io_desc[] __initdata = { 542 { /* CPLD */ 543 .virtual = LUBBOCK_FPGA_VIRT, 544 .pfn = __phys_to_pfn(LUBBOCK_FPGA_PHYS), 545 .length = 0x00100000, 546 .type = MT_DEVICE 547 } 548}; 549 550static void __init lubbock_map_io(void) 551{ 552 pxa_map_io(); 553 iotable_init(lubbock_io_desc, ARRAY_SIZE(lubbock_io_desc)); 554 555 PCFR |= PCFR_OPDE; 556} 557 558MACHINE_START(LUBBOCK, "Intel DBPXA250 Development Platform (aka Lubbock)") 559 /* Maintainer: MontaVista Software Inc. */ 560 .phys_io = 0x40000000, 561 .io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc, 562 .map_io = lubbock_map_io, 563 .init_irq = lubbock_init_irq, 564 .timer = &pxa_timer, 565 .init_machine = lubbock_init, 566MACHINE_END 567