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/gpio.h>
24 #include <linux/spi/spi.h>
25 #include <linux/spi/ads7846.h>
27 #include <mach/hardware.h>
28 #include <asm/mach-types.h>
30 #include <asm/setup.h>
31 #include <asm/system.h>
33 #include <asm/mach/arch.h>
34 #include <asm/mach/map.h>
35 #include <asm/mach/irq.h>
37 #include <mach/pxa-regs.h>
38 #include <mach/pxa2xx-regs.h>
39 #include <mach/mfp-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 void ads7846_cs(u32 command
)
219 gpio_set_value(POODLE_GPIO_TP_CS
, !(command
== PXA2XX_CS_ASSERT
));
222 static struct pxa2xx_spi_chip poodle_ads7846_chip
= {
223 .cs_control
= ads7846_cs
,
226 static struct spi_board_info poodle_spi_devices
[] = {
228 .modalias
= "ads7846",
229 .max_speed_hz
= 10000,
231 .platform_data
= &poodle_ads7846_info
,
232 .controller_data
= &poodle_ads7846_chip
,
233 .irq
= gpio_to_irq(POODLE_GPIO_TP_INT
),
237 static void __init
poodle_init_spi(void)
241 err
= gpio_request(POODLE_GPIO_TP_CS
, "ADS7846_CS");
245 gpio_direction_output(POODLE_GPIO_TP_CS
, 1);
247 pxa2xx_set_spi_info(1, &poodle_spi_info
);
248 spi_register_board_info(ARRAY_AND_SIZE(poodle_spi_devices
));
251 static inline void poodle_init_spi(void) {}
257 * The card detect interrupt isn't debounced so we delay it by 250ms
258 * to give the card a chance to fully insert/eject.
260 static struct pxamci_platform_data poodle_mci_platform_data
;
262 static int poodle_mci_init(struct device
*dev
, irq_handler_t poodle_detect_int
, void *data
)
266 err
= gpio_request(POODLE_GPIO_nSD_DETECT
, "nSD_DETECT");
270 err
= gpio_request(POODLE_GPIO_nSD_WP
, "nSD_WP");
274 err
= gpio_request(POODLE_GPIO_SD_PWR
, "SD_PWR");
278 err
= gpio_request(POODLE_GPIO_SD_PWR1
, "SD_PWR1");
282 gpio_direction_input(POODLE_GPIO_nSD_DETECT
);
283 gpio_direction_input(POODLE_GPIO_nSD_WP
);
285 gpio_direction_output(POODLE_GPIO_SD_PWR
, 0);
286 gpio_direction_output(POODLE_GPIO_SD_PWR1
, 0);
288 poodle_mci_platform_data
.detect_delay
= msecs_to_jiffies(250);
290 err
= request_irq(POODLE_IRQ_GPIO_nSD_DETECT
, poodle_detect_int
,
291 IRQF_DISABLED
| IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
,
292 "MMC card detect", data
);
294 pr_err("%s: MMC/SD: can't request MMC card detect IRQ\n",
302 gpio_free(POODLE_GPIO_SD_PWR1
);
304 gpio_free(POODLE_GPIO_SD_PWR
);
306 gpio_free(POODLE_GPIO_nSD_WP
);
308 gpio_free(POODLE_GPIO_nSD_DETECT
);
313 static void poodle_mci_setpower(struct device
*dev
, unsigned int vdd
)
315 struct pxamci_platform_data
* p_d
= dev
->platform_data
;
317 if ((1 << vdd
) & p_d
->ocr_mask
) {
318 gpio_set_value(POODLE_GPIO_SD_PWR
, 1);
320 gpio_set_value(POODLE_GPIO_SD_PWR1
, 1);
322 gpio_set_value(POODLE_GPIO_SD_PWR1
, 0);
323 gpio_set_value(POODLE_GPIO_SD_PWR
, 0);
327 static int poodle_mci_get_ro(struct device
*dev
)
329 return !!gpio_get_value(POODLE_GPIO_nSD_WP
);
330 return GPLR(POODLE_GPIO_nSD_WP
) & GPIO_bit(POODLE_GPIO_nSD_WP
);
334 static void poodle_mci_exit(struct device
*dev
, void *data
)
336 free_irq(POODLE_IRQ_GPIO_nSD_DETECT
, data
);
337 gpio_free(POODLE_GPIO_SD_PWR1
);
338 gpio_free(POODLE_GPIO_SD_PWR
);
339 gpio_free(POODLE_GPIO_nSD_WP
);
340 gpio_free(POODLE_GPIO_nSD_DETECT
);
343 static struct pxamci_platform_data poodle_mci_platform_data
= {
344 .ocr_mask
= MMC_VDD_32_33
|MMC_VDD_33_34
,
345 .init
= poodle_mci_init
,
346 .get_ro
= poodle_mci_get_ro
,
347 .setpower
= poodle_mci_setpower
,
348 .exit
= poodle_mci_exit
,
355 static void poodle_irda_transceiver_mode(struct device
*dev
, int mode
)
357 gpio_set_value(POODLE_GPIO_IR_ON
, mode
& IR_OFF
);
358 pxa2xx_transceiver_mode(dev
, mode
);
361 static int poodle_irda_startup(struct device
*dev
)
365 err
= gpio_request(POODLE_GPIO_IR_ON
, "IR_ON");
369 gpio_direction_output(POODLE_GPIO_IR_ON
, 1);
373 static void poodle_irda_shutdown(struct device
*dev
)
375 gpio_free(POODLE_GPIO_IR_ON
);
378 static struct pxaficp_platform_data poodle_ficp_platform_data
= {
379 .transceiver_cap
= IR_SIRMODE
| IR_OFF
,
380 .transceiver_mode
= poodle_irda_transceiver_mode
,
381 .startup
= poodle_irda_startup
,
382 .shutdown
= poodle_irda_shutdown
,
387 * USB Device Controller
389 static struct pxa2xx_udc_mach_info udc_info __initdata
= {
390 /* no connect GPIO; poodle can't tell connection status */
391 .gpio_pullup
= POODLE_GPIO_USB_PULLUP
,
396 static struct pxafb_mode_info poodle_fb_mode
= {
407 .sync
= FB_SYNC_HOR_HIGH_ACT
| FB_SYNC_VERT_HIGH_ACT
,
410 static struct pxafb_mach_info poodle_fb_info
= {
411 .modes
= &poodle_fb_mode
,
413 .lcd_conn
= LCD_COLOR_TFT_16BPP
,
416 static struct platform_device
*devices
[] __initdata
= {
417 &poodle_locomo_device
,
418 &poodle_scoop_device
,
421 static void poodle_poweroff(void)
423 arm_machine_restart('h');
426 static void poodle_restart(char mode
)
428 arm_machine_restart('h');
431 static void __init
poodle_init(void)
435 pm_power_off
= poodle_poweroff
;
436 arm_pm_restart
= poodle_restart
;
440 pxa2xx_mfp_config(ARRAY_AND_SIZE(poodle_pin_config
));
442 platform_scoop_config
= &poodle_pcmcia_config
;
444 ret
= platform_add_devices(devices
, ARRAY_SIZE(devices
));
446 pr_warning("poodle: Unable to register LoCoMo device\n");
448 set_pxa_fb_parent(&poodle_locomo_device
.dev
);
449 set_pxa_fb_info(&poodle_fb_info
);
450 pxa_set_udc_info(&udc_info
);
451 pxa_set_mci_info(&poodle_mci_platform_data
);
452 pxa_set_ficp_info(&poodle_ficp_platform_data
);
453 pxa_set_i2c_info(NULL
);
457 static void __init
fixup_poodle(struct machine_desc
*desc
,
458 struct tag
*tags
, char **cmdline
, struct meminfo
*mi
)
460 sharpsl_save_param();
462 mi
->bank
[0].start
= 0xa0000000;
463 mi
->bank
[0].node
= 0;
464 mi
->bank
[0].size
= (32*1024*1024);
467 MACHINE_START(POODLE
, "SHARP Poodle")
468 .phys_io
= 0x40000000,
469 .io_pg_offst
= (io_p2v(0x40000000) >> 18) & 0xfffc,
470 .fixup
= fixup_poodle
,
471 .map_io
= pxa_map_io
,
472 .init_irq
= pxa25x_init_irq
,
474 .init_machine
= poodle_init
,