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