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