2 * linux/arch/arm/mach-pxa/poodle.c
4 * Support for the SHARP Poodle Board.
7 * linux/arch/arm/mach-pxa/lubbock.c Author: Nicolas Pitre
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.
14 * 12-Dec-2002 Sharp Corporation for Poodle
15 * John Lenz <lenz@cs.wisc.edu> updates to 2.6
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/platform_device.h>
22 #include <linux/delay.h>
23 #include <linux/mtd/physmap.h>
24 #include <linux/gpio.h>
25 #include <linux/spi/spi.h>
26 #include <linux/spi/ads7846.h>
27 #include <linux/mtd/sharpsl.h>
29 #include <mach/hardware.h>
30 #include <asm/mach-types.h>
32 #include <asm/setup.h>
33 #include <asm/system.h>
35 #include <asm/mach/arch.h>
36 #include <asm/mach/map.h>
37 #include <asm/mach/irq.h>
39 #include <mach/pxa25x.h>
43 #include <mach/irda.h>
44 #include <mach/poodle.h>
45 #include <mach/pxafb.h>
46 #include <mach/sharpsl.h>
48 #include <mach/pxa2xx_spi.h>
50 #include <asm/hardware/scoop.h>
51 #include <asm/hardware/locomo.h>
52 #include <asm/mach/sharpsl_param.h>
58 static unsigned long poodle_pin_config
[] __initdata
= {
71 GPIO24_GPIO
, /* POODLE_GPIO_TP_CS - SFRM as chip select */
74 GPIO28_I2S_BITCLK_OUT
,
131 GPIO9_GPIO
, /* POODLE_GPIO_nSD_DETECT */
132 GPIO7_GPIO
, /* POODLE_GPIO_nSD_WP */
133 GPIO3_GPIO
, /* POODLE_GPIO_SD_PWR */
134 GPIO33_GPIO
, /* POODLE_GPIO_SD_PWR1 */
136 GPIO20_GPIO
, /* POODLE_GPIO_USB_PULLUP */
137 GPIO22_GPIO
, /* POODLE_GPIO_IR_ON */
140 static struct resource poodle_scoop_resources
[] = {
144 .flags
= IORESOURCE_MEM
,
148 static struct scoop_config poodle_scoop_setup
= {
149 .io_dir
= POODLE_SCOOP_IO_DIR
,
150 .io_out
= POODLE_SCOOP_IO_OUT
,
151 .gpio_base
= POODLE_SCOOP_GPIO_BASE
,
154 struct platform_device poodle_scoop_device
= {
155 .name
= "sharp-scoop",
158 .platform_data
= &poodle_scoop_setup
,
160 .num_resources
= ARRAY_SIZE(poodle_scoop_resources
),
161 .resource
= poodle_scoop_resources
,
164 static struct scoop_pcmcia_dev poodle_pcmcia_scoop
[] = {
166 .dev
= &poodle_scoop_device
.dev
,
167 .irq
= POODLE_IRQ_GPIO_CF_IRQ
,
168 .cd_irq
= POODLE_IRQ_GPIO_CF_CD
,
169 .cd_irq_str
= "PCMCIA0 CD",
173 static struct scoop_pcmcia_config poodle_pcmcia_config
= {
174 .devs
= &poodle_pcmcia_scoop
[0],
178 EXPORT_SYMBOL(poodle_scoop_device
);
182 static struct resource locomo_resources
[] = {
186 .flags
= IORESOURCE_MEM
,
189 .start
= IRQ_GPIO(10),
191 .flags
= IORESOURCE_IRQ
,
195 struct platform_device poodle_locomo_device
= {
198 .num_resources
= ARRAY_SIZE(locomo_resources
),
199 .resource
= locomo_resources
,
202 EXPORT_SYMBOL(poodle_locomo_device
);
204 #if defined(CONFIG_SPI_PXA2XX) || defined(CONFIG_SPI_PXA2XX_MODULE)
205 static struct pxa2xx_spi_master poodle_spi_info
= {
209 static struct ads7846_platform_data poodle_ads7846_info
= {
211 .vref_delay_usecs
= 100,
214 .gpio_pendown
= POODLE_GPIO_TP_INT
,
217 static struct pxa2xx_spi_chip poodle_ads7846_chip
= {
218 .gpio_cs
= POODLE_GPIO_TP_CS
,
221 static struct spi_board_info poodle_spi_devices
[] = {
223 .modalias
= "ads7846",
224 .max_speed_hz
= 10000,
226 .platform_data
= &poodle_ads7846_info
,
227 .controller_data
= &poodle_ads7846_chip
,
228 .irq
= gpio_to_irq(POODLE_GPIO_TP_INT
),
232 static void __init
poodle_init_spi(void)
234 pxa2xx_set_spi_info(1, &poodle_spi_info
);
235 spi_register_board_info(ARRAY_AND_SIZE(poodle_spi_devices
));
238 static inline void poodle_init_spi(void) {}
244 * The card detect interrupt isn't debounced so we delay it by 250ms
245 * to give the card a chance to fully insert/eject.
247 static struct pxamci_platform_data poodle_mci_platform_data
;
249 static int poodle_mci_init(struct device
*dev
, irq_handler_t poodle_detect_int
, void *data
)
253 err
= gpio_request(POODLE_GPIO_nSD_DETECT
, "nSD_DETECT");
257 err
= gpio_request(POODLE_GPIO_nSD_WP
, "nSD_WP");
261 err
= gpio_request(POODLE_GPIO_SD_PWR
, "SD_PWR");
265 err
= gpio_request(POODLE_GPIO_SD_PWR1
, "SD_PWR1");
269 gpio_direction_input(POODLE_GPIO_nSD_DETECT
);
270 gpio_direction_input(POODLE_GPIO_nSD_WP
);
272 gpio_direction_output(POODLE_GPIO_SD_PWR
, 0);
273 gpio_direction_output(POODLE_GPIO_SD_PWR1
, 0);
275 poodle_mci_platform_data
.detect_delay
= msecs_to_jiffies(250);
277 err
= request_irq(POODLE_IRQ_GPIO_nSD_DETECT
, poodle_detect_int
,
278 IRQF_DISABLED
| IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
,
279 "MMC card detect", data
);
281 pr_err("%s: MMC/SD: can't request MMC card detect IRQ\n",
289 gpio_free(POODLE_GPIO_SD_PWR1
);
291 gpio_free(POODLE_GPIO_SD_PWR
);
293 gpio_free(POODLE_GPIO_nSD_WP
);
295 gpio_free(POODLE_GPIO_nSD_DETECT
);
300 static void poodle_mci_setpower(struct device
*dev
, unsigned int vdd
)
302 struct pxamci_platform_data
* p_d
= dev
->platform_data
;
304 if ((1 << vdd
) & p_d
->ocr_mask
) {
305 gpio_set_value(POODLE_GPIO_SD_PWR
, 1);
307 gpio_set_value(POODLE_GPIO_SD_PWR1
, 1);
309 gpio_set_value(POODLE_GPIO_SD_PWR1
, 0);
310 gpio_set_value(POODLE_GPIO_SD_PWR
, 0);
314 static int poodle_mci_get_ro(struct device
*dev
)
316 return !!gpio_get_value(POODLE_GPIO_nSD_WP
);
317 return GPLR(POODLE_GPIO_nSD_WP
) & GPIO_bit(POODLE_GPIO_nSD_WP
);
321 static void poodle_mci_exit(struct device
*dev
, void *data
)
323 free_irq(POODLE_IRQ_GPIO_nSD_DETECT
, data
);
324 gpio_free(POODLE_GPIO_SD_PWR1
);
325 gpio_free(POODLE_GPIO_SD_PWR
);
326 gpio_free(POODLE_GPIO_nSD_WP
);
327 gpio_free(POODLE_GPIO_nSD_DETECT
);
330 static struct pxamci_platform_data poodle_mci_platform_data
= {
331 .ocr_mask
= MMC_VDD_32_33
|MMC_VDD_33_34
,
332 .init
= poodle_mci_init
,
333 .get_ro
= poodle_mci_get_ro
,
334 .setpower
= poodle_mci_setpower
,
335 .exit
= poodle_mci_exit
,
342 static void poodle_irda_transceiver_mode(struct device
*dev
, int mode
)
344 gpio_set_value(POODLE_GPIO_IR_ON
, mode
& IR_OFF
);
345 pxa2xx_transceiver_mode(dev
, mode
);
348 static int poodle_irda_startup(struct device
*dev
)
352 err
= gpio_request(POODLE_GPIO_IR_ON
, "IR_ON");
356 gpio_direction_output(POODLE_GPIO_IR_ON
, 1);
360 static void poodle_irda_shutdown(struct device
*dev
)
362 gpio_free(POODLE_GPIO_IR_ON
);
365 static struct pxaficp_platform_data poodle_ficp_platform_data
= {
366 .transceiver_cap
= IR_SIRMODE
| IR_OFF
,
367 .transceiver_mode
= poodle_irda_transceiver_mode
,
368 .startup
= poodle_irda_startup
,
369 .shutdown
= poodle_irda_shutdown
,
374 * USB Device Controller
376 static struct pxa2xx_udc_mach_info udc_info __initdata
= {
377 /* no connect GPIO; poodle can't tell connection status */
378 .gpio_pullup
= POODLE_GPIO_USB_PULLUP
,
383 static struct pxafb_mode_info poodle_fb_mode
= {
394 .sync
= FB_SYNC_HOR_HIGH_ACT
| FB_SYNC_VERT_HIGH_ACT
,
397 static struct pxafb_mach_info poodle_fb_info
= {
398 .modes
= &poodle_fb_mode
,
400 .lcd_conn
= LCD_COLOR_TFT_16BPP
,
403 static struct mtd_partition sharpsl_nand_partitions
[] = {
405 .name
= "System Area",
407 .size
= 7 * 1024 * 1024,
410 .name
= "Root Filesystem",
411 .offset
= 7 * 1024 * 1024,
412 .size
= 22 * 1024 * 1024,
415 .name
= "Home Filesystem",
416 .offset
= MTDPART_OFS_APPEND
,
417 .size
= MTDPART_SIZ_FULL
,
421 static uint8_t scan_ff_pattern
[] = { 0xff, 0xff };
423 static struct nand_bbt_descr sharpsl_bbt
= {
427 .pattern
= scan_ff_pattern
430 static struct sharpsl_nand_platform_data sharpsl_nand_platform_data
= {
431 .badblock_pattern
= &sharpsl_bbt
,
432 .partitions
= sharpsl_nand_partitions
,
433 .nr_partitions
= ARRAY_SIZE(sharpsl_nand_partitions
),
436 static struct resource sharpsl_nand_resources
[] = {
440 .flags
= IORESOURCE_MEM
,
444 static struct platform_device sharpsl_nand_device
= {
445 .name
= "sharpsl-nand",
447 .resource
= sharpsl_nand_resources
,
448 .num_resources
= ARRAY_SIZE(sharpsl_nand_resources
),
449 .dev
.platform_data
= &sharpsl_nand_platform_data
,
452 static struct mtd_partition sharpsl_rom_parts
[] = {
454 .name
="Boot PROM Filesystem",
455 .offset
= 0x00120000,
456 .size
= MTDPART_SIZ_FULL
,
460 static struct physmap_flash_data sharpsl_rom_data
= {
462 .nr_parts
= ARRAY_SIZE(sharpsl_rom_parts
),
463 .parts
= sharpsl_rom_parts
,
466 static struct resource sharpsl_rom_resources
[] = {
470 .flags
= IORESOURCE_MEM
,
474 static struct platform_device sharpsl_rom_device
= {
475 .name
= "physmap-flash",
477 .resource
= sharpsl_rom_resources
,
478 .num_resources
= ARRAY_SIZE(sharpsl_rom_resources
),
479 .dev
.platform_data
= &sharpsl_rom_data
,
482 static struct platform_device
*devices
[] __initdata
= {
483 &poodle_locomo_device
,
484 &poodle_scoop_device
,
485 &sharpsl_nand_device
,
489 static void poodle_poweroff(void)
491 arm_machine_restart('h', NULL
);
494 static void poodle_restart(char mode
, const char *cmd
)
496 arm_machine_restart('h', cmd
);
499 static void __init
poodle_init(void)
503 pm_power_off
= poodle_poweroff
;
504 arm_pm_restart
= poodle_restart
;
508 pxa2xx_mfp_config(ARRAY_AND_SIZE(poodle_pin_config
));
510 platform_scoop_config
= &poodle_pcmcia_config
;
512 ret
= platform_add_devices(devices
, ARRAY_SIZE(devices
));
514 pr_warning("poodle: Unable to register LoCoMo device\n");
516 set_pxa_fb_parent(&poodle_locomo_device
.dev
);
517 set_pxa_fb_info(&poodle_fb_info
);
518 pxa_set_udc_info(&udc_info
);
519 pxa_set_mci_info(&poodle_mci_platform_data
);
520 pxa_set_ficp_info(&poodle_ficp_platform_data
);
521 pxa_set_i2c_info(NULL
);
525 static void __init
fixup_poodle(struct machine_desc
*desc
,
526 struct tag
*tags
, char **cmdline
, struct meminfo
*mi
)
528 sharpsl_save_param();
530 mi
->bank
[0].start
= 0xa0000000;
531 mi
->bank
[0].node
= 0;
532 mi
->bank
[0].size
= (32*1024*1024);
535 MACHINE_START(POODLE
, "SHARP Poodle")
536 .phys_io
= 0x40000000,
537 .io_pg_offst
= (io_p2v(0x40000000) >> 18) & 0xfffc,
538 .fixup
= fixup_poodle
,
539 .map_io
= pxa_map_io
,
540 .init_irq
= pxa25x_init_irq
,
542 .init_machine
= poodle_init
,