1/* 2 * linux/arch/arm/mach-pxa/poodle.c 3 * 4 * Support for the SHARP Poodle Board. 5 * 6 * Based on: 7 * linux/arch/arm/mach-pxa/lubbock.c Author: Nicolas Pitre 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 * Change Log 14 * 12-Dec-2002 Sharp Corporation for Poodle 15 * John Lenz <lenz@cs.wisc.edu> updates to 2.6 16 */ 17#include <linux/kernel.h> 18#include <linux/init.h> 19#include <linux/export.h> 20#include <linux/platform_device.h> 21#include <linux/fb.h> 22#include <linux/pm.h> 23#include <linux/delay.h> 24#include <linux/mtd/physmap.h> 25#include <linux/gpio.h> 26#include <linux/i2c.h> 27#include <linux/i2c/pxa-i2c.h> 28#include <linux/regulator/machine.h> 29#include <linux/spi/spi.h> 30#include <linux/spi/ads7846.h> 31#include <linux/spi/pxa2xx_spi.h> 32#include <linux/mtd/sharpsl.h> 33#include <linux/memblock.h> 34 35#include <mach/hardware.h> 36#include <asm/mach-types.h> 37#include <asm/irq.h> 38#include <asm/setup.h> 39 40#include <asm/mach/arch.h> 41#include <asm/mach/map.h> 42#include <asm/mach/irq.h> 43 44#include <mach/pxa25x.h> 45#include <linux/platform_data/mmc-pxamci.h> 46#include <mach/udc.h> 47#include <linux/platform_data/irda-pxaficp.h> 48#include <mach/poodle.h> 49#include <linux/platform_data/video-pxafb.h> 50 51#include <asm/hardware/scoop.h> 52#include <asm/hardware/locomo.h> 53#include <asm/mach/sharpsl_param.h> 54 55#include "generic.h" 56#include "devices.h" 57 58static unsigned long poodle_pin_config[] __initdata = { 59 /* I/O */ 60 GPIO79_nCS_3, 61 GPIO80_nCS_4, 62 GPIO18_RDY, 63 64 /* Clock */ 65 GPIO12_32KHz, 66 67 /* SSP1 */ 68 GPIO23_SSP1_SCLK, 69 GPIO25_SSP1_TXD, 70 GPIO26_SSP1_RXD, 71 GPIO24_GPIO, /* POODLE_GPIO_TP_CS - SFRM as chip select */ 72 73 /* I2S */ 74 GPIO28_I2S_BITCLK_OUT, 75 GPIO29_I2S_SDATA_IN, 76 GPIO30_I2S_SDATA_OUT, 77 GPIO31_I2S_SYNC, 78 GPIO32_I2S_SYSCLK, 79 80 /* Infra-Red */ 81 GPIO47_FICP_TXD, 82 GPIO46_FICP_RXD, 83 84 /* FFUART */ 85 GPIO40_FFUART_DTR, 86 GPIO41_FFUART_RTS, 87 GPIO39_FFUART_TXD, 88 GPIO37_FFUART_DSR, 89 GPIO34_FFUART_RXD, 90 GPIO35_FFUART_CTS, 91 92 /* LCD */ 93 GPIOxx_LCD_TFT_16BPP, 94 95 /* PC Card */ 96 GPIO48_nPOE, 97 GPIO49_nPWE, 98 GPIO50_nPIOR, 99 GPIO51_nPIOW, 100 GPIO52_nPCE_1, 101 GPIO53_nPCE_2, 102 GPIO54_nPSKTSEL, 103 GPIO55_nPREG, 104 GPIO56_nPWAIT, 105 GPIO57_nIOIS16, 106 107 /* MMC */ 108 GPIO6_MMC_CLK, 109 GPIO8_MMC_CS0, 110 111 /* GPIO */ 112 GPIO9_GPIO, /* POODLE_GPIO_nSD_DETECT */ 113 GPIO7_GPIO, /* POODLE_GPIO_nSD_WP */ 114 GPIO3_GPIO, /* POODLE_GPIO_SD_PWR */ 115 GPIO33_GPIO, /* POODLE_GPIO_SD_PWR1 */ 116 117 GPIO20_GPIO, /* POODLE_GPIO_USB_PULLUP */ 118 GPIO22_GPIO, /* POODLE_GPIO_IR_ON */ 119}; 120 121static struct resource poodle_scoop_resources[] = { 122 [0] = { 123 .start = 0x10800000, 124 .end = 0x10800fff, 125 .flags = IORESOURCE_MEM, 126 }, 127}; 128 129static struct scoop_config poodle_scoop_setup = { 130 .io_dir = POODLE_SCOOP_IO_DIR, 131 .io_out = POODLE_SCOOP_IO_OUT, 132 .gpio_base = POODLE_SCOOP_GPIO_BASE, 133}; 134 135struct platform_device poodle_scoop_device = { 136 .name = "sharp-scoop", 137 .id = -1, 138 .dev = { 139 .platform_data = &poodle_scoop_setup, 140 }, 141 .num_resources = ARRAY_SIZE(poodle_scoop_resources), 142 .resource = poodle_scoop_resources, 143}; 144 145static struct scoop_pcmcia_dev poodle_pcmcia_scoop[] = { 146{ 147 .dev = &poodle_scoop_device.dev, 148 .irq = POODLE_IRQ_GPIO_CF_IRQ, 149 .cd_irq = POODLE_IRQ_GPIO_CF_CD, 150 .cd_irq_str = "PCMCIA0 CD", 151}, 152}; 153 154static struct scoop_pcmcia_config poodle_pcmcia_config = { 155 .devs = &poodle_pcmcia_scoop[0], 156 .num_devs = 1, 157}; 158 159EXPORT_SYMBOL(poodle_scoop_device); 160 161 162static struct platform_device poodle_audio_device = { 163 .name = "poodle-audio", 164 .id = -1, 165}; 166 167/* LoCoMo device */ 168static struct resource locomo_resources[] = { 169 [0] = { 170 .start = 0x10000000, 171 .end = 0x10001fff, 172 .flags = IORESOURCE_MEM, 173 }, 174 [1] = { 175 .start = PXA_GPIO_TO_IRQ(10), 176 .end = PXA_GPIO_TO_IRQ(10), 177 .flags = IORESOURCE_IRQ, 178 }, 179}; 180 181static struct locomo_platform_data locomo_info = { 182 .irq_base = IRQ_BOARD_START, 183}; 184 185struct platform_device poodle_locomo_device = { 186 .name = "locomo", 187 .id = 0, 188 .num_resources = ARRAY_SIZE(locomo_resources), 189 .resource = locomo_resources, 190 .dev = { 191 .platform_data = &locomo_info, 192 }, 193}; 194 195EXPORT_SYMBOL(poodle_locomo_device); 196 197#if defined(CONFIG_SPI_PXA2XX) || defined(CONFIG_SPI_PXA2XX_MODULE) 198static struct pxa2xx_spi_master poodle_spi_info = { 199 .num_chipselect = 1, 200}; 201 202static struct ads7846_platform_data poodle_ads7846_info = { 203 .model = 7846, 204 .vref_delay_usecs = 100, 205 .x_plate_ohms = 419, 206 .y_plate_ohms = 486, 207 .gpio_pendown = POODLE_GPIO_TP_INT, 208}; 209 210static struct pxa2xx_spi_chip poodle_ads7846_chip = { 211 .gpio_cs = POODLE_GPIO_TP_CS, 212}; 213 214static struct spi_board_info poodle_spi_devices[] = { 215 { 216 .modalias = "ads7846", 217 .max_speed_hz = 10000, 218 .bus_num = 1, 219 .platform_data = &poodle_ads7846_info, 220 .controller_data= &poodle_ads7846_chip, 221 .irq = PXA_GPIO_TO_IRQ(POODLE_GPIO_TP_INT), 222 }, 223}; 224 225static void __init poodle_init_spi(void) 226{ 227 pxa2xx_set_spi_info(1, &poodle_spi_info); 228 spi_register_board_info(ARRAY_AND_SIZE(poodle_spi_devices)); 229} 230#else 231static inline void poodle_init_spi(void) {} 232#endif 233 234/* 235 * MMC/SD Device 236 * 237 * The card detect interrupt isn't debounced so we delay it by 250ms 238 * to give the card a chance to fully insert/eject. 239 */ 240static int poodle_mci_init(struct device *dev, irq_handler_t poodle_detect_int, void *data) 241{ 242 int err; 243 244 err = gpio_request(POODLE_GPIO_SD_PWR, "SD_PWR"); 245 if (err) 246 goto err_free_2; 247 248 err = gpio_request(POODLE_GPIO_SD_PWR1, "SD_PWR1"); 249 if (err) 250 goto err_free_3; 251 252 gpio_direction_output(POODLE_GPIO_SD_PWR, 0); 253 gpio_direction_output(POODLE_GPIO_SD_PWR1, 0); 254 255 return 0; 256 257err_free_3: 258 gpio_free(POODLE_GPIO_SD_PWR); 259err_free_2: 260 return err; 261} 262 263static int poodle_mci_setpower(struct device *dev, unsigned int vdd) 264{ 265 struct pxamci_platform_data* p_d = dev->platform_data; 266 267 if ((1 << vdd) & p_d->ocr_mask) { 268 gpio_set_value(POODLE_GPIO_SD_PWR, 1); 269 mdelay(2); 270 gpio_set_value(POODLE_GPIO_SD_PWR1, 1); 271 } else { 272 gpio_set_value(POODLE_GPIO_SD_PWR1, 0); 273 gpio_set_value(POODLE_GPIO_SD_PWR, 0); 274 } 275 276 return 0; 277} 278 279static void poodle_mci_exit(struct device *dev, void *data) 280{ 281 gpio_free(POODLE_GPIO_SD_PWR1); 282 gpio_free(POODLE_GPIO_SD_PWR); 283} 284 285static struct pxamci_platform_data poodle_mci_platform_data = { 286 .detect_delay_ms = 250, 287 .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34, 288 .init = poodle_mci_init, 289 .setpower = poodle_mci_setpower, 290 .exit = poodle_mci_exit, 291 .gpio_card_detect = POODLE_GPIO_nSD_DETECT, 292 .gpio_card_ro = POODLE_GPIO_nSD_WP, 293 .gpio_power = -1, 294}; 295 296 297/* 298 * Irda 299 */ 300static struct pxaficp_platform_data poodle_ficp_platform_data = { 301 .gpio_pwdown = POODLE_GPIO_IR_ON, 302 .transceiver_cap = IR_SIRMODE | IR_OFF, 303}; 304 305 306/* 307 * USB Device Controller 308 */ 309static struct pxa2xx_udc_mach_info udc_info __initdata = { 310 /* no connect GPIO; poodle can't tell connection status */ 311 .gpio_pullup = POODLE_GPIO_USB_PULLUP, 312}; 313 314 315/* PXAFB device */ 316static struct pxafb_mode_info poodle_fb_mode = { 317 .pixclock = 144700, 318 .xres = 320, 319 .yres = 240, 320 .bpp = 16, 321 .hsync_len = 7, 322 .left_margin = 11, 323 .right_margin = 30, 324 .vsync_len = 2, 325 .upper_margin = 2, 326 .lower_margin = 0, 327 .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, 328}; 329 330static struct pxafb_mach_info poodle_fb_info = { 331 .modes = &poodle_fb_mode, 332 .num_modes = 1, 333 .lcd_conn = LCD_COLOR_TFT_16BPP, 334}; 335 336static struct mtd_partition sharpsl_nand_partitions[] = { 337 { 338 .name = "System Area", 339 .offset = 0, 340 .size = 7 * 1024 * 1024, 341 }, 342 { 343 .name = "Root Filesystem", 344 .offset = 7 * 1024 * 1024, 345 .size = 22 * 1024 * 1024, 346 }, 347 { 348 .name = "Home Filesystem", 349 .offset = MTDPART_OFS_APPEND, 350 .size = MTDPART_SIZ_FULL, 351 }, 352}; 353 354static uint8_t scan_ff_pattern[] = { 0xff, 0xff }; 355 356static struct nand_bbt_descr sharpsl_bbt = { 357 .options = 0, 358 .offs = 4, 359 .len = 2, 360 .pattern = scan_ff_pattern 361}; 362 363static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = { 364 .badblock_pattern = &sharpsl_bbt, 365 .partitions = sharpsl_nand_partitions, 366 .nr_partitions = ARRAY_SIZE(sharpsl_nand_partitions), 367}; 368 369static struct resource sharpsl_nand_resources[] = { 370 { 371 .start = 0x0C000000, 372 .end = 0x0C000FFF, 373 .flags = IORESOURCE_MEM, 374 }, 375}; 376 377static struct platform_device sharpsl_nand_device = { 378 .name = "sharpsl-nand", 379 .id = -1, 380 .resource = sharpsl_nand_resources, 381 .num_resources = ARRAY_SIZE(sharpsl_nand_resources), 382 .dev.platform_data = &sharpsl_nand_platform_data, 383}; 384 385static struct mtd_partition sharpsl_rom_parts[] = { 386 { 387 .name ="Boot PROM Filesystem", 388 .offset = 0x00120000, 389 .size = MTDPART_SIZ_FULL, 390 }, 391}; 392 393static struct physmap_flash_data sharpsl_rom_data = { 394 .width = 2, 395 .nr_parts = ARRAY_SIZE(sharpsl_rom_parts), 396 .parts = sharpsl_rom_parts, 397}; 398 399static struct resource sharpsl_rom_resources[] = { 400 { 401 .start = 0x00000000, 402 .end = 0x007fffff, 403 .flags = IORESOURCE_MEM, 404 }, 405}; 406 407static struct platform_device sharpsl_rom_device = { 408 .name = "physmap-flash", 409 .id = -1, 410 .resource = sharpsl_rom_resources, 411 .num_resources = ARRAY_SIZE(sharpsl_rom_resources), 412 .dev.platform_data = &sharpsl_rom_data, 413}; 414 415static struct platform_device *devices[] __initdata = { 416 &poodle_locomo_device, 417 &poodle_scoop_device, 418 &poodle_audio_device, 419 &sharpsl_nand_device, 420 &sharpsl_rom_device, 421}; 422 423static struct i2c_board_info __initdata poodle_i2c_devices[] = { 424 { I2C_BOARD_INFO("wm8731", 0x1b) }, 425}; 426 427static void poodle_poweroff(void) 428{ 429 pxa_restart(REBOOT_HARD, NULL); 430} 431 432static void __init poodle_init(void) 433{ 434 int ret = 0; 435 436 pm_power_off = poodle_poweroff; 437 438 PCFR |= PCFR_OPDE; 439 440 pxa2xx_mfp_config(ARRAY_AND_SIZE(poodle_pin_config)); 441 442 pxa_set_ffuart_info(NULL); 443 pxa_set_btuart_info(NULL); 444 pxa_set_stuart_info(NULL); 445 446 platform_scoop_config = &poodle_pcmcia_config; 447 448 ret = platform_add_devices(devices, ARRAY_SIZE(devices)); 449 if (ret) 450 pr_warn("poodle: Unable to register LoCoMo device\n"); 451 452 pxa_set_fb_info(&poodle_locomo_device.dev, &poodle_fb_info); 453 pxa_set_udc_info(&udc_info); 454 pxa_set_mci_info(&poodle_mci_platform_data); 455 pxa_set_ficp_info(&poodle_ficp_platform_data); 456 pxa_set_i2c_info(NULL); 457 i2c_register_board_info(0, ARRAY_AND_SIZE(poodle_i2c_devices)); 458 poodle_init_spi(); 459 regulator_has_full_constraints(); 460} 461 462static void __init fixup_poodle(struct tag *tags, char **cmdline) 463{ 464 sharpsl_save_param(); 465 memblock_add(0xa0000000, SZ_32M); 466} 467 468MACHINE_START(POODLE, "SHARP Poodle") 469 .fixup = fixup_poodle, 470 .map_io = pxa25x_map_io, 471 .nr_irqs = POODLE_NR_IRQS, /* 4 for LoCoMo */ 472 .init_irq = pxa25x_init_irq, 473 .handle_irq = pxa25x_handle_irq, 474 .init_time = pxa_timer_init, 475 .init_machine = poodle_init, 476 .restart = pxa_restart, 477MACHINE_END 478