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>
28 #include <mach/hardware.h>
29 #include <asm/mach-types.h>
31 #include <asm/setup.h>
32 #include <asm/system.h>
34 #include <asm/mach/arch.h>
35 #include <asm/mach/map.h>
36 #include <asm/mach/irq.h>
38 #include <mach/pxa-regs.h>
39 #include <mach/pxa2xx-regs.h>
40 #include <mach/mfp-pxa25x.h>
44 #include <mach/irda.h>
45 #include <mach/poodle.h>
46 #include <mach/pxafb.h>
47 #include <mach/sharpsl.h>
49 #include <mach/pxa2xx_spi.h>
51 #include <asm/hardware/scoop.h>
52 #include <asm/hardware/locomo.h>
53 #include <asm/mach/sharpsl_param.h>
59 static unsigned long poodle_pin_config
[] __initdata
= {
72 GPIO24_GPIO
, /* POODLE_GPIO_TP_CS - SFRM as chip select */
75 GPIO28_I2S_BITCLK_OUT
,
132 GPIO9_GPIO
, /* POODLE_GPIO_nSD_DETECT */
133 GPIO7_GPIO
, /* POODLE_GPIO_nSD_WP */
134 GPIO3_GPIO
, /* POODLE_GPIO_SD_PWR */
135 GPIO33_GPIO
, /* POODLE_GPIO_SD_PWR1 */
137 GPIO20_GPIO
, /* POODLE_GPIO_USB_PULLUP */
138 GPIO22_GPIO
, /* POODLE_GPIO_IR_ON */
141 static struct resource poodle_scoop_resources
[] = {
145 .flags
= IORESOURCE_MEM
,
149 static struct scoop_config poodle_scoop_setup
= {
150 .io_dir
= POODLE_SCOOP_IO_DIR
,
151 .io_out
= POODLE_SCOOP_IO_OUT
,
152 .gpio_base
= POODLE_SCOOP_GPIO_BASE
,
155 struct platform_device poodle_scoop_device
= {
156 .name
= "sharp-scoop",
159 .platform_data
= &poodle_scoop_setup
,
161 .num_resources
= ARRAY_SIZE(poodle_scoop_resources
),
162 .resource
= poodle_scoop_resources
,
165 static struct scoop_pcmcia_dev poodle_pcmcia_scoop
[] = {
167 .dev
= &poodle_scoop_device
.dev
,
168 .irq
= POODLE_IRQ_GPIO_CF_IRQ
,
169 .cd_irq
= POODLE_IRQ_GPIO_CF_CD
,
170 .cd_irq_str
= "PCMCIA0 CD",
174 static struct scoop_pcmcia_config poodle_pcmcia_config
= {
175 .devs
= &poodle_pcmcia_scoop
[0],
179 EXPORT_SYMBOL(poodle_scoop_device
);
183 static struct resource locomo_resources
[] = {
187 .flags
= IORESOURCE_MEM
,
190 .start
= IRQ_GPIO(10),
192 .flags
= IORESOURCE_IRQ
,
196 struct platform_device poodle_locomo_device
= {
199 .num_resources
= ARRAY_SIZE(locomo_resources
),
200 .resource
= locomo_resources
,
203 EXPORT_SYMBOL(poodle_locomo_device
);
205 #if defined(CONFIG_SPI_PXA2XX) || defined(CONFIG_SPI_PXA2XX_MODULE)
206 static struct pxa2xx_spi_master poodle_spi_info
= {
210 static struct ads7846_platform_data poodle_ads7846_info
= {
212 .vref_delay_usecs
= 100,
215 .gpio_pendown
= POODLE_GPIO_TP_INT
,
218 static void ads7846_cs(u32 command
)
220 gpio_set_value(POODLE_GPIO_TP_CS
, !(command
== PXA2XX_CS_ASSERT
));
223 static struct pxa2xx_spi_chip poodle_ads7846_chip
= {
224 .cs_control
= ads7846_cs
,
227 static struct spi_board_info poodle_spi_devices
[] = {
229 .modalias
= "ads7846",
230 .max_speed_hz
= 10000,
232 .platform_data
= &poodle_ads7846_info
,
233 .controller_data
= &poodle_ads7846_chip
,
234 .irq
= gpio_to_irq(POODLE_GPIO_TP_INT
),
238 static void __init
poodle_init_spi(void)
242 err
= gpio_request(POODLE_GPIO_TP_CS
, "ADS7846_CS");
246 gpio_direction_output(POODLE_GPIO_TP_CS
, 1);
248 pxa2xx_set_spi_info(1, &poodle_spi_info
);
249 spi_register_board_info(ARRAY_AND_SIZE(poodle_spi_devices
));
252 static inline void poodle_init_spi(void) {}
258 * The card detect interrupt isn't debounced so we delay it by 250ms
259 * to give the card a chance to fully insert/eject.
261 static struct pxamci_platform_data poodle_mci_platform_data
;
263 static int poodle_mci_init(struct device
*dev
, irq_handler_t poodle_detect_int
, void *data
)
267 err
= gpio_request(POODLE_GPIO_nSD_DETECT
, "nSD_DETECT");
271 err
= gpio_request(POODLE_GPIO_nSD_WP
, "nSD_WP");
275 err
= gpio_request(POODLE_GPIO_SD_PWR
, "SD_PWR");
279 err
= gpio_request(POODLE_GPIO_SD_PWR1
, "SD_PWR1");
283 gpio_direction_input(POODLE_GPIO_nSD_DETECT
);
284 gpio_direction_input(POODLE_GPIO_nSD_WP
);
286 gpio_direction_output(POODLE_GPIO_SD_PWR
, 0);
287 gpio_direction_output(POODLE_GPIO_SD_PWR1
, 0);
289 poodle_mci_platform_data
.detect_delay
= msecs_to_jiffies(250);
291 err
= request_irq(POODLE_IRQ_GPIO_nSD_DETECT
, poodle_detect_int
,
292 IRQF_DISABLED
| IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
,
293 "MMC card detect", data
);
295 pr_err("%s: MMC/SD: can't request MMC card detect IRQ\n",
303 gpio_free(POODLE_GPIO_SD_PWR1
);
305 gpio_free(POODLE_GPIO_SD_PWR
);
307 gpio_free(POODLE_GPIO_nSD_WP
);
309 gpio_free(POODLE_GPIO_nSD_DETECT
);
314 static void poodle_mci_setpower(struct device
*dev
, unsigned int vdd
)
316 struct pxamci_platform_data
* p_d
= dev
->platform_data
;
318 if ((1 << vdd
) & p_d
->ocr_mask
) {
319 gpio_set_value(POODLE_GPIO_SD_PWR
, 1);
321 gpio_set_value(POODLE_GPIO_SD_PWR1
, 1);
323 gpio_set_value(POODLE_GPIO_SD_PWR1
, 0);
324 gpio_set_value(POODLE_GPIO_SD_PWR
, 0);
328 static int poodle_mci_get_ro(struct device
*dev
)
330 return !!gpio_get_value(POODLE_GPIO_nSD_WP
);
331 return GPLR(POODLE_GPIO_nSD_WP
) & GPIO_bit(POODLE_GPIO_nSD_WP
);
335 static void poodle_mci_exit(struct device
*dev
, void *data
)
337 free_irq(POODLE_IRQ_GPIO_nSD_DETECT
, data
);
338 gpio_free(POODLE_GPIO_SD_PWR1
);
339 gpio_free(POODLE_GPIO_SD_PWR
);
340 gpio_free(POODLE_GPIO_nSD_WP
);
341 gpio_free(POODLE_GPIO_nSD_DETECT
);
344 static struct pxamci_platform_data poodle_mci_platform_data
= {
345 .ocr_mask
= MMC_VDD_32_33
|MMC_VDD_33_34
,
346 .init
= poodle_mci_init
,
347 .get_ro
= poodle_mci_get_ro
,
348 .setpower
= poodle_mci_setpower
,
349 .exit
= poodle_mci_exit
,
356 static void poodle_irda_transceiver_mode(struct device
*dev
, int mode
)
358 gpio_set_value(POODLE_GPIO_IR_ON
, mode
& IR_OFF
);
359 pxa2xx_transceiver_mode(dev
, mode
);
362 static int poodle_irda_startup(struct device
*dev
)
366 err
= gpio_request(POODLE_GPIO_IR_ON
, "IR_ON");
370 gpio_direction_output(POODLE_GPIO_IR_ON
, 1);
374 static void poodle_irda_shutdown(struct device
*dev
)
376 gpio_free(POODLE_GPIO_IR_ON
);
379 static struct pxaficp_platform_data poodle_ficp_platform_data
= {
380 .transceiver_cap
= IR_SIRMODE
| IR_OFF
,
381 .transceiver_mode
= poodle_irda_transceiver_mode
,
382 .startup
= poodle_irda_startup
,
383 .shutdown
= poodle_irda_shutdown
,
388 * USB Device Controller
390 static struct pxa2xx_udc_mach_info udc_info __initdata
= {
391 /* no connect GPIO; poodle can't tell connection status */
392 .gpio_pullup
= POODLE_GPIO_USB_PULLUP
,
397 static struct pxafb_mode_info poodle_fb_mode
= {
408 .sync
= FB_SYNC_HOR_HIGH_ACT
| FB_SYNC_VERT_HIGH_ACT
,
411 static struct pxafb_mach_info poodle_fb_info
= {
412 .modes
= &poodle_fb_mode
,
414 .lcd_conn
= LCD_COLOR_TFT_16BPP
,
417 static struct mtd_partition sharpsl_rom_parts
[] = {
419 .name
="Boot PROM Filesystem",
420 .offset
= 0x00120000,
421 .size
= MTDPART_SIZ_FULL
,
425 static struct physmap_flash_data sharpsl_rom_data
= {
427 .nr_parts
= ARRAY_SIZE(sharpsl_rom_parts
),
428 .parts
= sharpsl_rom_parts
,
431 static struct resource sharpsl_rom_resources
[] = {
435 .flags
= IORESOURCE_MEM
,
439 static struct platform_device sharpsl_rom_device
= {
440 .name
= "physmap-flash",
442 .resource
= sharpsl_rom_resources
,
443 .num_resources
= ARRAY_SIZE(sharpsl_rom_resources
),
444 .dev
.platform_data
= &sharpsl_rom_data
,
447 static struct platform_device
*devices
[] __initdata
= {
448 &poodle_locomo_device
,
449 &poodle_scoop_device
,
453 static void poodle_poweroff(void)
455 arm_machine_restart('h');
458 static void poodle_restart(char mode
)
460 arm_machine_restart('h');
463 static void __init
poodle_init(void)
467 pm_power_off
= poodle_poweroff
;
468 arm_pm_restart
= poodle_restart
;
472 pxa2xx_mfp_config(ARRAY_AND_SIZE(poodle_pin_config
));
474 platform_scoop_config
= &poodle_pcmcia_config
;
476 ret
= platform_add_devices(devices
, ARRAY_SIZE(devices
));
478 pr_warning("poodle: Unable to register LoCoMo device\n");
480 set_pxa_fb_parent(&poodle_locomo_device
.dev
);
481 set_pxa_fb_info(&poodle_fb_info
);
482 pxa_set_udc_info(&udc_info
);
483 pxa_set_mci_info(&poodle_mci_platform_data
);
484 pxa_set_ficp_info(&poodle_ficp_platform_data
);
485 pxa_set_i2c_info(NULL
);
489 static void __init
fixup_poodle(struct machine_desc
*desc
,
490 struct tag
*tags
, char **cmdline
, struct meminfo
*mi
)
492 sharpsl_save_param();
494 mi
->bank
[0].start
= 0xa0000000;
495 mi
->bank
[0].node
= 0;
496 mi
->bank
[0].size
= (32*1024*1024);
499 MACHINE_START(POODLE
, "SHARP Poodle")
500 .phys_io
= 0x40000000,
501 .io_pg_offst
= (io_p2v(0x40000000) >> 18) & 0xfffc,
502 .fixup
= fixup_poodle
,
503 .map_io
= pxa_map_io
,
504 .init_irq
= pxa25x_init_irq
,
506 .init_machine
= poodle_init
,