Merge remote-tracking branch 'moduleh/module.h-split'
[linux-2.6/next.git] / arch / arm / mach-pxa / spitz.c
blob29dc9e73d44a662d16450d8826bf97896f263632
1 /*
2 * Support for Sharp SL-Cxx00 Series of PDAs
3 * Models: SL-C3000 (Spitz), SL-C1000 (Akita) and SL-C3100 (Borzoi)
5 * Copyright (c) 2005 Richard Purdie
7 * Based on Sharp's 2.4 kernel patches/lubbock.c
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.
15 #include <linux/kernel.h>
16 #include <linux/platform_device.h>
17 #include <linux/delay.h>
18 #include <linux/gpio_keys.h>
19 #include <linux/gpio.h>
20 #include <linux/leds.h>
21 #include <linux/i2c.h>
22 #include <linux/i2c/pxa-i2c.h>
23 #include <linux/i2c/pca953x.h>
24 #include <linux/spi/spi.h>
25 #include <linux/spi/ads7846.h>
26 #include <linux/spi/corgi_lcd.h>
27 #include <linux/spi/pxa2xx_spi.h>
28 #include <linux/mtd/sharpsl.h>
29 #include <linux/mtd/physmap.h>
30 #include <linux/input/matrix_keypad.h>
31 #include <linux/regulator/machine.h>
32 #include <linux/io.h>
33 #include <linux/module.h>
35 #include <asm/setup.h>
36 #include <asm/mach-types.h>
37 #include <asm/mach/arch.h>
38 #include <asm/mach/sharpsl_param.h>
39 #include <asm/hardware/scoop.h>
41 #include <mach/pxa27x.h>
42 #include <mach/pxa27x-udc.h>
43 #include <mach/reset.h>
44 #include <mach/irda.h>
45 #include <mach/mmc.h>
46 #include <mach/ohci.h>
47 #include <mach/pxafb.h>
48 #include <mach/spitz.h>
49 #include <mach/sharpsl_pm.h>
50 #include <mach/smemc.h>
52 #include "generic.h"
53 #include "devices.h"
55 /******************************************************************************
56 * Pin configuration
57 ******************************************************************************/
58 static unsigned long spitz_pin_config[] __initdata = {
59 /* Chip Selects */
60 GPIO78_nCS_2, /* SCOOP #2 */
61 GPIO79_nCS_3, /* NAND */
62 GPIO80_nCS_4, /* SCOOP #1 */
64 /* LCD - 16bpp Active TFT */
65 GPIOxx_LCD_TFT_16BPP,
67 /* PC Card */
68 GPIO48_nPOE,
69 GPIO49_nPWE,
70 GPIO50_nPIOR,
71 GPIO51_nPIOW,
72 GPIO85_nPCE_1,
73 GPIO54_nPCE_2,
74 GPIO55_nPREG,
75 GPIO56_nPWAIT,
76 GPIO57_nIOIS16,
77 GPIO104_PSKTSEL,
79 /* I2S */
80 GPIO28_I2S_BITCLK_OUT,
81 GPIO29_I2S_SDATA_IN,
82 GPIO30_I2S_SDATA_OUT,
83 GPIO31_I2S_SYNC,
85 /* MMC */
86 GPIO32_MMC_CLK,
87 GPIO112_MMC_CMD,
88 GPIO92_MMC_DAT_0,
89 GPIO109_MMC_DAT_1,
90 GPIO110_MMC_DAT_2,
91 GPIO111_MMC_DAT_3,
93 /* GPIOs */
94 GPIO9_GPIO, /* SPITZ_GPIO_nSD_DETECT */
95 GPIO16_GPIO, /* SPITZ_GPIO_SYNC */
96 GPIO81_GPIO, /* SPITZ_GPIO_nSD_WP */
97 GPIO41_GPIO, /* SPITZ_GPIO_USB_CONNECT */
98 GPIO37_GPIO, /* SPITZ_GPIO_USB_HOST */
99 GPIO35_GPIO, /* SPITZ_GPIO_USB_DEVICE */
100 GPIO22_GPIO, /* SPITZ_GPIO_HSYNC */
101 GPIO94_GPIO, /* SPITZ_GPIO_CF_CD */
102 GPIO105_GPIO, /* SPITZ_GPIO_CF_IRQ */
103 GPIO106_GPIO, /* SPITZ_GPIO_CF2_IRQ */
105 /* GPIO matrix keypad */
106 GPIO88_GPIO, /* column 0 */
107 GPIO23_GPIO, /* column 1 */
108 GPIO24_GPIO, /* column 2 */
109 GPIO25_GPIO, /* column 3 */
110 GPIO26_GPIO, /* column 4 */
111 GPIO27_GPIO, /* column 5 */
112 GPIO52_GPIO, /* column 6 */
113 GPIO103_GPIO, /* column 7 */
114 GPIO107_GPIO, /* column 8 */
115 GPIO108_GPIO, /* column 9 */
116 GPIO114_GPIO, /* column 10 */
117 GPIO12_GPIO, /* row 0 */
118 GPIO17_GPIO, /* row 1 */
119 GPIO91_GPIO, /* row 2 */
120 GPIO34_GPIO, /* row 3 */
121 GPIO36_GPIO, /* row 4 */
122 GPIO38_GPIO, /* row 5 */
123 GPIO39_GPIO, /* row 6 */
125 /* I2C */
126 GPIO117_I2C_SCL,
127 GPIO118_I2C_SDA,
129 GPIO0_GPIO | WAKEUP_ON_EDGE_RISE, /* SPITZ_GPIO_KEY_INT */
130 GPIO1_GPIO | WAKEUP_ON_EDGE_FALL, /* SPITZ_GPIO_RESET */
134 /******************************************************************************
135 * Scoop GPIO expander
136 ******************************************************************************/
137 #if defined(CONFIG_SHARP_SCOOP) || defined(CONFIG_SHARP_SCOOP_MODULE)
138 /* SCOOP Device #1 */
139 static struct resource spitz_scoop_1_resources[] = {
140 [0] = {
141 .start = 0x10800000,
142 .end = 0x10800fff,
143 .flags = IORESOURCE_MEM,
147 static struct scoop_config spitz_scoop_1_setup = {
148 .io_dir = SPITZ_SCP_IO_DIR,
149 .io_out = SPITZ_SCP_IO_OUT,
150 .suspend_clr = SPITZ_SCP_SUS_CLR,
151 .suspend_set = SPITZ_SCP_SUS_SET,
152 .gpio_base = SPITZ_SCP_GPIO_BASE,
155 struct platform_device spitz_scoop_1_device = {
156 .name = "sharp-scoop",
157 .id = 0,
158 .dev = {
159 .platform_data = &spitz_scoop_1_setup,
161 .num_resources = ARRAY_SIZE(spitz_scoop_1_resources),
162 .resource = spitz_scoop_1_resources,
165 /* SCOOP Device #2 */
166 static struct resource spitz_scoop_2_resources[] = {
167 [0] = {
168 .start = 0x08800040,
169 .end = 0x08800fff,
170 .flags = IORESOURCE_MEM,
174 static struct scoop_config spitz_scoop_2_setup = {
175 .io_dir = SPITZ_SCP2_IO_DIR,
176 .io_out = SPITZ_SCP2_IO_OUT,
177 .suspend_clr = SPITZ_SCP2_SUS_CLR,
178 .suspend_set = SPITZ_SCP2_SUS_SET,
179 .gpio_base = SPITZ_SCP2_GPIO_BASE,
182 struct platform_device spitz_scoop_2_device = {
183 .name = "sharp-scoop",
184 .id = 1,
185 .dev = {
186 .platform_data = &spitz_scoop_2_setup,
188 .num_resources = ARRAY_SIZE(spitz_scoop_2_resources),
189 .resource = spitz_scoop_2_resources,
192 static void __init spitz_scoop_init(void)
194 platform_device_register(&spitz_scoop_1_device);
196 /* Akita doesn't have the second SCOOP chip */
197 if (!machine_is_akita())
198 platform_device_register(&spitz_scoop_2_device);
201 /* Power control is shared with between one of the CF slots and SD */
202 static void spitz_card_pwr_ctrl(uint8_t enable, uint8_t new_cpr)
204 unsigned short cpr;
205 unsigned long flags;
207 if (new_cpr & 0x7) {
208 gpio_set_value(SPITZ_GPIO_CF_POWER, 1);
209 mdelay(5);
212 local_irq_save(flags);
214 cpr = read_scoop_reg(&spitz_scoop_1_device.dev, SCOOP_CPR);
216 if (enable & new_cpr)
217 cpr |= new_cpr;
218 else
219 cpr &= ~enable;
221 write_scoop_reg(&spitz_scoop_1_device.dev, SCOOP_CPR, cpr);
223 local_irq_restore(flags);
225 if (!(cpr & 0x7)) {
226 mdelay(1);
227 gpio_set_value(SPITZ_GPIO_CF_POWER, 0);
231 #else
232 static inline void spitz_scoop_init(void) {}
233 static inline void spitz_card_pwr_ctrl(uint8_t enable, uint8_t new_cpr) {}
234 #endif
236 /******************************************************************************
237 * PCMCIA
238 ******************************************************************************/
239 #if defined(CONFIG_PCMCIA_PXA2XX) || defined(CONFIG_PCMCIA_PXA2XX_MODULE)
240 static void spitz_pcmcia_pwr(struct device *scoop, uint16_t cpr, int nr)
242 /* Only need to override behaviour for slot 0 */
243 if (nr == 0)
244 spitz_card_pwr_ctrl(
245 cpr & (SCOOP_CPR_CF_3V | SCOOP_CPR_CF_XV), cpr);
246 else
247 write_scoop_reg(scoop, SCOOP_CPR, cpr);
250 static struct scoop_pcmcia_dev spitz_pcmcia_scoop[] = {
252 .dev = &spitz_scoop_1_device.dev,
253 .irq = SPITZ_IRQ_GPIO_CF_IRQ,
254 .cd_irq = SPITZ_IRQ_GPIO_CF_CD,
255 .cd_irq_str = "PCMCIA0 CD",
256 }, {
257 .dev = &spitz_scoop_2_device.dev,
258 .irq = SPITZ_IRQ_GPIO_CF2_IRQ,
259 .cd_irq = -1,
263 static struct scoop_pcmcia_config spitz_pcmcia_config = {
264 .devs = &spitz_pcmcia_scoop[0],
265 .num_devs = 2,
266 .power_ctrl = spitz_pcmcia_pwr,
269 static void __init spitz_pcmcia_init(void)
271 /* Akita has only one PCMCIA slot used */
272 if (machine_is_akita())
273 spitz_pcmcia_config.num_devs = 1;
275 platform_scoop_config = &spitz_pcmcia_config;
277 #else
278 static inline void spitz_pcmcia_init(void) {}
279 #endif
281 /******************************************************************************
282 * GPIO keyboard
283 ******************************************************************************/
284 #if defined(CONFIG_KEYBOARD_MATRIX) || defined(CONFIG_KEYBOARD_MATRIX_MODULE)
286 #define SPITZ_KEY_CALENDAR KEY_F1
287 #define SPITZ_KEY_ADDRESS KEY_F2
288 #define SPITZ_KEY_FN KEY_F3
289 #define SPITZ_KEY_CANCEL KEY_F4
290 #define SPITZ_KEY_EXOK KEY_F5
291 #define SPITZ_KEY_EXCANCEL KEY_F6
292 #define SPITZ_KEY_EXJOGDOWN KEY_F7
293 #define SPITZ_KEY_EXJOGUP KEY_F8
294 #define SPITZ_KEY_JAP1 KEY_LEFTALT
295 #define SPITZ_KEY_JAP2 KEY_RIGHTCTRL
296 #define SPITZ_KEY_SYNC KEY_F9
297 #define SPITZ_KEY_MAIL KEY_F10
298 #define SPITZ_KEY_OK KEY_F11
299 #define SPITZ_KEY_MENU KEY_F12
301 static const uint32_t spitz_keymap[] = {
302 KEY(0, 0, KEY_LEFTCTRL),
303 KEY(0, 1, KEY_1),
304 KEY(0, 2, KEY_3),
305 KEY(0, 3, KEY_5),
306 KEY(0, 4, KEY_6),
307 KEY(0, 5, KEY_7),
308 KEY(0, 6, KEY_9),
309 KEY(0, 7, KEY_0),
310 KEY(0, 8, KEY_BACKSPACE),
311 KEY(0, 9, SPITZ_KEY_EXOK), /* EXOK */
312 KEY(0, 10, SPITZ_KEY_EXCANCEL), /* EXCANCEL */
313 KEY(1, 1, KEY_2),
314 KEY(1, 2, KEY_4),
315 KEY(1, 3, KEY_R),
316 KEY(1, 4, KEY_Y),
317 KEY(1, 5, KEY_8),
318 KEY(1, 6, KEY_I),
319 KEY(1, 7, KEY_O),
320 KEY(1, 8, KEY_P),
321 KEY(1, 9, SPITZ_KEY_EXJOGDOWN), /* EXJOGDOWN */
322 KEY(1, 10, SPITZ_KEY_EXJOGUP), /* EXJOGUP */
323 KEY(2, 0, KEY_TAB),
324 KEY(2, 1, KEY_Q),
325 KEY(2, 2, KEY_E),
326 KEY(2, 3, KEY_T),
327 KEY(2, 4, KEY_G),
328 KEY(2, 5, KEY_U),
329 KEY(2, 6, KEY_J),
330 KEY(2, 7, KEY_K),
331 KEY(3, 0, SPITZ_KEY_ADDRESS), /* ADDRESS */
332 KEY(3, 1, KEY_W),
333 KEY(3, 2, KEY_S),
334 KEY(3, 3, KEY_F),
335 KEY(3, 4, KEY_V),
336 KEY(3, 5, KEY_H),
337 KEY(3, 6, KEY_M),
338 KEY(3, 7, KEY_L),
339 KEY(3, 9, KEY_RIGHTSHIFT),
340 KEY(4, 0, SPITZ_KEY_CALENDAR), /* CALENDAR */
341 KEY(4, 1, KEY_A),
342 KEY(4, 2, KEY_D),
343 KEY(4, 3, KEY_C),
344 KEY(4, 4, KEY_B),
345 KEY(4, 5, KEY_N),
346 KEY(4, 6, KEY_DOT),
347 KEY(4, 8, KEY_ENTER),
348 KEY(4, 9, KEY_LEFTSHIFT),
349 KEY(5, 0, SPITZ_KEY_MAIL), /* MAIL */
350 KEY(5, 1, KEY_Z),
351 KEY(5, 2, KEY_X),
352 KEY(5, 3, KEY_MINUS),
353 KEY(5, 4, KEY_SPACE),
354 KEY(5, 5, KEY_COMMA),
355 KEY(5, 7, KEY_UP),
356 KEY(5, 10, SPITZ_KEY_FN), /* FN */
357 KEY(6, 0, KEY_SYSRQ),
358 KEY(6, 1, SPITZ_KEY_JAP1), /* JAP1 */
359 KEY(6, 2, SPITZ_KEY_JAP2), /* JAP2 */
360 KEY(6, 3, SPITZ_KEY_CANCEL), /* CANCEL */
361 KEY(6, 4, SPITZ_KEY_OK), /* OK */
362 KEY(6, 5, SPITZ_KEY_MENU), /* MENU */
363 KEY(6, 6, KEY_LEFT),
364 KEY(6, 7, KEY_DOWN),
365 KEY(6, 8, KEY_RIGHT),
368 static const struct matrix_keymap_data spitz_keymap_data = {
369 .keymap = spitz_keymap,
370 .keymap_size = ARRAY_SIZE(spitz_keymap),
373 static const uint32_t spitz_row_gpios[] =
374 { 12, 17, 91, 34, 36, 38, 39 };
375 static const uint32_t spitz_col_gpios[] =
376 { 88, 23, 24, 25, 26, 27, 52, 103, 107, 108, 114 };
378 static struct matrix_keypad_platform_data spitz_mkp_pdata = {
379 .keymap_data = &spitz_keymap_data,
380 .row_gpios = spitz_row_gpios,
381 .col_gpios = spitz_col_gpios,
382 .num_row_gpios = ARRAY_SIZE(spitz_row_gpios),
383 .num_col_gpios = ARRAY_SIZE(spitz_col_gpios),
384 .col_scan_delay_us = 10,
385 .debounce_ms = 10,
386 .wakeup = 1,
389 static struct platform_device spitz_mkp_device = {
390 .name = "matrix-keypad",
391 .id = -1,
392 .dev = {
393 .platform_data = &spitz_mkp_pdata,
397 static void __init spitz_mkp_init(void)
399 platform_device_register(&spitz_mkp_device);
401 #else
402 static inline void spitz_mkp_init(void) {}
403 #endif
405 /******************************************************************************
406 * GPIO keys
407 ******************************************************************************/
408 #if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)
409 static struct gpio_keys_button spitz_gpio_keys[] = {
411 .type = EV_PWR,
412 .code = KEY_SUSPEND,
413 .gpio = SPITZ_GPIO_ON_KEY,
414 .desc = "On Off",
415 .wakeup = 1,
417 /* Two buttons detecting the lid state */
419 .type = EV_SW,
420 .code = 0,
421 .gpio = SPITZ_GPIO_SWA,
422 .desc = "Display Down",
425 .type = EV_SW,
426 .code = 1,
427 .gpio = SPITZ_GPIO_SWB,
428 .desc = "Lid Closed",
432 static struct gpio_keys_platform_data spitz_gpio_keys_platform_data = {
433 .buttons = spitz_gpio_keys,
434 .nbuttons = ARRAY_SIZE(spitz_gpio_keys),
437 static struct platform_device spitz_gpio_keys_device = {
438 .name = "gpio-keys",
439 .id = -1,
440 .dev = {
441 .platform_data = &spitz_gpio_keys_platform_data,
445 static void __init spitz_keys_init(void)
447 platform_device_register(&spitz_gpio_keys_device);
449 #else
450 static inline void spitz_keys_init(void) {}
451 #endif
453 /******************************************************************************
454 * LEDs
455 ******************************************************************************/
456 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
457 static struct gpio_led spitz_gpio_leds[] = {
459 .name = "spitz:amber:charge",
460 .default_trigger = "sharpsl-charge",
461 .gpio = SPITZ_GPIO_LED_ORANGE,
464 .name = "spitz:green:hddactivity",
465 .default_trigger = "ide-disk",
466 .gpio = SPITZ_GPIO_LED_GREEN,
470 static struct gpio_led_platform_data spitz_gpio_leds_info = {
471 .leds = spitz_gpio_leds,
472 .num_leds = ARRAY_SIZE(spitz_gpio_leds),
475 static struct platform_device spitz_led_device = {
476 .name = "leds-gpio",
477 .id = -1,
478 .dev = {
479 .platform_data = &spitz_gpio_leds_info,
483 static void __init spitz_leds_init(void)
485 platform_device_register(&spitz_led_device);
487 #else
488 static inline void spitz_leds_init(void) {}
489 #endif
491 /******************************************************************************
492 * SSP Devices
493 ******************************************************************************/
494 #if defined(CONFIG_SPI_PXA2XX) || defined(CONFIG_SPI_PXA2XX_MODULE)
495 static void spitz_ads7846_wait_for_hsync(void)
497 while (gpio_get_value(SPITZ_GPIO_HSYNC))
498 cpu_relax();
500 while (!gpio_get_value(SPITZ_GPIO_HSYNC))
501 cpu_relax();
504 static struct ads7846_platform_data spitz_ads7846_info = {
505 .model = 7846,
506 .vref_delay_usecs = 100,
507 .x_plate_ohms = 419,
508 .y_plate_ohms = 486,
509 .pressure_max = 1024,
510 .gpio_pendown = SPITZ_GPIO_TP_INT,
511 .wait_for_sync = spitz_ads7846_wait_for_hsync,
514 static struct pxa2xx_spi_chip spitz_ads7846_chip = {
515 .gpio_cs = SPITZ_GPIO_ADS7846_CS,
518 static void spitz_bl_kick_battery(void)
520 void (*kick_batt)(void);
522 kick_batt = symbol_get(sharpsl_battery_kick);
523 if (kick_batt) {
524 kick_batt();
525 symbol_put(sharpsl_battery_kick);
529 static struct corgi_lcd_platform_data spitz_lcdcon_info = {
530 .init_mode = CORGI_LCD_MODE_VGA,
531 .max_intensity = 0x2f,
532 .default_intensity = 0x1f,
533 .limit_mask = 0x0b,
534 .gpio_backlight_cont = SPITZ_GPIO_BACKLIGHT_CONT,
535 .gpio_backlight_on = SPITZ_GPIO_BACKLIGHT_ON,
536 .kick_battery = spitz_bl_kick_battery,
539 static struct pxa2xx_spi_chip spitz_lcdcon_chip = {
540 .gpio_cs = SPITZ_GPIO_LCDCON_CS,
543 static struct pxa2xx_spi_chip spitz_max1111_chip = {
544 .gpio_cs = SPITZ_GPIO_MAX1111_CS,
547 static struct spi_board_info spitz_spi_devices[] = {
549 .modalias = "ads7846",
550 .max_speed_hz = 1200000,
551 .bus_num = 2,
552 .chip_select = 0,
553 .platform_data = &spitz_ads7846_info,
554 .controller_data = &spitz_ads7846_chip,
555 .irq = gpio_to_irq(SPITZ_GPIO_TP_INT),
556 }, {
557 .modalias = "corgi-lcd",
558 .max_speed_hz = 50000,
559 .bus_num = 2,
560 .chip_select = 1,
561 .platform_data = &spitz_lcdcon_info,
562 .controller_data = &spitz_lcdcon_chip,
563 }, {
564 .modalias = "max1111",
565 .max_speed_hz = 450000,
566 .bus_num = 2,
567 .chip_select = 2,
568 .controller_data = &spitz_max1111_chip,
572 static struct pxa2xx_spi_master spitz_spi_info = {
573 .num_chipselect = 3,
576 static void __init spitz_spi_init(void)
578 struct corgi_lcd_platform_data *lcd_data = &spitz_lcdcon_info;
580 if (machine_is_akita()) {
581 lcd_data->gpio_backlight_cont = AKITA_GPIO_BACKLIGHT_CONT;
582 lcd_data->gpio_backlight_on = AKITA_GPIO_BACKLIGHT_ON;
585 pxa2xx_set_spi_info(2, &spitz_spi_info);
586 spi_register_board_info(ARRAY_AND_SIZE(spitz_spi_devices));
588 #else
589 static inline void spitz_spi_init(void) {}
590 #endif
592 /******************************************************************************
593 * SD/MMC card controller
594 ******************************************************************************/
595 #if defined(CONFIG_MMC_PXA) || defined(CONFIG_MMC_PXA_MODULE)
597 * NOTE: The card detect interrupt isn't debounced so we delay it by 250ms to
598 * give the card a chance to fully insert/eject.
600 static void spitz_mci_setpower(struct device *dev, unsigned int vdd)
602 struct pxamci_platform_data* p_d = dev->platform_data;
604 if ((1 << vdd) & p_d->ocr_mask)
605 spitz_card_pwr_ctrl(SCOOP_CPR_SD_3V, SCOOP_CPR_SD_3V);
606 else
607 spitz_card_pwr_ctrl(SCOOP_CPR_SD_3V, 0x0);
610 static struct pxamci_platform_data spitz_mci_platform_data = {
611 .detect_delay_ms = 250,
612 .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34,
613 .setpower = spitz_mci_setpower,
614 .gpio_card_detect = SPITZ_GPIO_nSD_DETECT,
615 .gpio_card_ro = SPITZ_GPIO_nSD_WP,
616 .gpio_power = -1,
619 static void __init spitz_mmc_init(void)
621 pxa_set_mci_info(&spitz_mci_platform_data);
623 #else
624 static inline void spitz_mmc_init(void) {}
625 #endif
627 /******************************************************************************
628 * USB Host
629 ******************************************************************************/
630 #if defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
631 static int spitz_ohci_init(struct device *dev)
633 int err;
635 err = gpio_request(SPITZ_GPIO_USB_HOST, "USB_HOST");
636 if (err)
637 return err;
639 /* Only Port 2 is connected, setup USB Port 2 Output Control Register */
640 UP2OCR = UP2OCR_HXS | UP2OCR_HXOE | UP2OCR_DPPDE | UP2OCR_DMPDE;
642 return gpio_direction_output(SPITZ_GPIO_USB_HOST, 1);
645 static void spitz_ohci_exit(struct device *dev)
647 gpio_free(SPITZ_GPIO_USB_HOST);
650 static struct pxaohci_platform_data spitz_ohci_platform_data = {
651 .port_mode = PMM_NPS_MODE,
652 .init = spitz_ohci_init,
653 .exit = spitz_ohci_exit,
654 .flags = ENABLE_PORT_ALL | NO_OC_PROTECTION,
655 .power_budget = 150,
658 static void __init spitz_uhc_init(void)
660 pxa_set_ohci_info(&spitz_ohci_platform_data);
662 #else
663 static inline void spitz_uhc_init(void) {}
664 #endif
666 /******************************************************************************
667 * IrDA
668 ******************************************************************************/
669 #if defined(CONFIG_PXA_FICP) || defined(CONFIG_PXA_FICP_MODULE)
670 static struct pxaficp_platform_data spitz_ficp_platform_data = {
671 .transceiver_cap = IR_SIRMODE | IR_OFF,
674 static void __init spitz_irda_init(void)
676 if (machine_is_akita())
677 spitz_ficp_platform_data.gpio_pwdown = AKITA_GPIO_IR_ON;
678 else
679 spitz_ficp_platform_data.gpio_pwdown = SPITZ_GPIO_IR_ON;
681 pxa_set_ficp_info(&spitz_ficp_platform_data);
683 #else
684 static inline void spitz_irda_init(void) {}
685 #endif
687 /******************************************************************************
688 * Framebuffer
689 ******************************************************************************/
690 #if defined(CONFIG_FB_PXA) || defined(CONFIG_FB_PXA_MODULE)
691 static struct pxafb_mode_info spitz_pxafb_modes[] = {
693 .pixclock = 19231,
694 .xres = 480,
695 .yres = 640,
696 .bpp = 16,
697 .hsync_len = 40,
698 .left_margin = 46,
699 .right_margin = 125,
700 .vsync_len = 3,
701 .upper_margin = 1,
702 .lower_margin = 0,
703 .sync = 0,
704 }, {
705 .pixclock = 134617,
706 .xres = 240,
707 .yres = 320,
708 .bpp = 16,
709 .hsync_len = 20,
710 .left_margin = 20,
711 .right_margin = 46,
712 .vsync_len = 2,
713 .upper_margin = 1,
714 .lower_margin = 0,
715 .sync = 0,
719 static struct pxafb_mach_info spitz_pxafb_info = {
720 .modes = spitz_pxafb_modes,
721 .num_modes = ARRAY_SIZE(spitz_pxafb_modes),
722 .fixed_modes = 1,
723 .lcd_conn = LCD_COLOR_TFT_16BPP | LCD_ALTERNATE_MAPPING,
726 static void __init spitz_lcd_init(void)
728 pxa_set_fb_info(NULL, &spitz_pxafb_info);
730 #else
731 static inline void spitz_lcd_init(void) {}
732 #endif
734 /******************************************************************************
735 * Framebuffer
736 ******************************************************************************/
737 #if defined(CONFIG_MTD_NAND_SHARPSL) || defined(CONFIG_MTD_NAND_SHARPSL_MODULE)
738 static struct mtd_partition spitz_nand_partitions[] = {
740 .name = "System Area",
741 .offset = 0,
742 .size = 7 * 1024 * 1024,
743 }, {
744 .name = "Root Filesystem",
745 .offset = 7 * 1024 * 1024,
746 }, {
747 .name = "Home Filesystem",
748 .offset = MTDPART_OFS_APPEND,
749 .size = MTDPART_SIZ_FULL,
753 static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
755 static struct nand_bbt_descr spitz_nand_bbt = {
756 .options = 0,
757 .offs = 4,
758 .len = 2,
759 .pattern = scan_ff_pattern
762 static struct nand_ecclayout akita_oobinfo = {
763 .oobfree = { {0x08, 0x09} },
764 .eccbytes = 24,
765 .eccpos = {
766 0x05, 0x01, 0x02, 0x03, 0x06, 0x07, 0x15, 0x11,
767 0x12, 0x13, 0x16, 0x17, 0x25, 0x21, 0x22, 0x23,
768 0x26, 0x27, 0x35, 0x31, 0x32, 0x33, 0x36, 0x37,
772 static struct sharpsl_nand_platform_data spitz_nand_pdata = {
773 .badblock_pattern = &spitz_nand_bbt,
774 .partitions = spitz_nand_partitions,
775 .nr_partitions = ARRAY_SIZE(spitz_nand_partitions),
778 static struct resource spitz_nand_resources[] = {
780 .start = PXA_CS3_PHYS,
781 .end = PXA_CS3_PHYS + SZ_4K - 1,
782 .flags = IORESOURCE_MEM,
786 static struct platform_device spitz_nand_device = {
787 .name = "sharpsl-nand",
788 .id = -1,
789 .resource = spitz_nand_resources,
790 .num_resources = ARRAY_SIZE(spitz_nand_resources),
791 .dev = {
792 .platform_data = &spitz_nand_pdata,
796 static void __init spitz_nand_init(void)
798 if (machine_is_spitz()) {
799 spitz_nand_partitions[1].size = 5 * 1024 * 1024;
800 } else if (machine_is_akita()) {
801 spitz_nand_partitions[1].size = 58 * 1024 * 1024;
802 spitz_nand_bbt.len = 1;
803 spitz_nand_pdata.ecc_layout = &akita_oobinfo;
804 } else if (machine_is_borzoi()) {
805 spitz_nand_partitions[1].size = 32 * 1024 * 1024;
806 spitz_nand_bbt.len = 1;
807 spitz_nand_pdata.ecc_layout = &akita_oobinfo;
810 platform_device_register(&spitz_nand_device);
812 #else
813 static inline void spitz_nand_init(void) {}
814 #endif
816 /******************************************************************************
817 * NOR Flash
818 ******************************************************************************/
819 #if defined(CONFIG_MTD_PHYSMAP) || defined(CONFIG_MTD_PHYSMAP_MODULE)
820 static struct mtd_partition spitz_rom_parts[] = {
822 .name ="Boot PROM Filesystem",
823 .offset = 0x00140000,
824 .size = MTDPART_SIZ_FULL,
828 static struct physmap_flash_data spitz_rom_data = {
829 .width = 2,
830 .nr_parts = ARRAY_SIZE(spitz_rom_parts),
831 .parts = spitz_rom_parts,
834 static struct resource spitz_rom_resources[] = {
836 .start = PXA_CS0_PHYS,
837 .end = PXA_CS0_PHYS + SZ_8M - 1,
838 .flags = IORESOURCE_MEM,
842 static struct platform_device spitz_rom_device = {
843 .name = "physmap-flash",
844 .id = -1,
845 .resource = spitz_rom_resources,
846 .num_resources = ARRAY_SIZE(spitz_rom_resources),
847 .dev = {
848 .platform_data = &spitz_rom_data,
852 static void __init spitz_nor_init(void)
854 platform_device_register(&spitz_rom_device);
856 #else
857 static inline void spitz_nor_init(void) {}
858 #endif
860 /******************************************************************************
861 * GPIO expander
862 ******************************************************************************/
863 #if defined(CONFIG_I2C_PXA) || defined(CONFIG_I2C_PXA_MODULE)
864 static struct pca953x_platform_data akita_pca953x_pdata = {
865 .gpio_base = AKITA_IOEXP_GPIO_BASE,
868 static struct i2c_board_info spitz_i2c_devs[] = {
870 .type = "wm8750",
871 .addr = 0x1b,
872 }, {
873 .type = "max7310",
874 .addr = 0x18,
875 .platform_data = &akita_pca953x_pdata,
879 static struct regulator_consumer_supply isl6271a_consumers[] = {
881 .supply = "vcc_core",
885 static struct regulator_init_data isl6271a_info[] = {
887 .constraints = {
888 .name = "vcc_core range",
889 .min_uV = 850000,
890 .max_uV = 1600000,
891 .always_on = 1,
892 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
894 .consumer_supplies = isl6271a_consumers,
895 .num_consumer_supplies = ARRAY_SIZE(isl6271a_consumers),
899 static struct i2c_board_info spitz_pi2c_devs[] = {
901 .type = "isl6271a",
902 .addr = 0x0c,
903 .platform_data = &isl6271a_info,
907 static void __init spitz_i2c_init(void)
909 int size = ARRAY_SIZE(spitz_i2c_devs);
911 /* Only Akita has the max7310 chip */
912 if (!machine_is_akita())
913 size--;
915 pxa_set_i2c_info(NULL);
916 pxa27x_set_i2c_power_info(NULL);
917 i2c_register_board_info(0, spitz_i2c_devs, size);
918 i2c_register_board_info(1, ARRAY_AND_SIZE(spitz_pi2c_devs));
920 #else
921 static inline void spitz_i2c_init(void) {}
922 #endif
924 /******************************************************************************
925 * Machine init
926 ******************************************************************************/
927 static void spitz_poweroff(void)
929 arm_machine_restart('g', NULL);
932 static void spitz_restart(char mode, const char *cmd)
934 uint32_t msc0 = __raw_readl(MSC0);
935 /* Bootloader magic for a reboot */
936 if ((msc0 & 0xffff0000) == 0x7ff00000)
937 __raw_writel((msc0 & 0xffff) | 0x7ee00000, MSC0);
939 spitz_poweroff();
942 static void __init spitz_init(void)
944 init_gpio_reset(SPITZ_GPIO_ON_RESET, 1, 0);
945 pm_power_off = spitz_poweroff;
946 arm_pm_restart = spitz_restart;
948 PMCR = 0x00;
950 /* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
951 PCFR |= PCFR_OPDE;
953 pxa2xx_mfp_config(ARRAY_AND_SIZE(spitz_pin_config));
955 pxa_set_ffuart_info(NULL);
956 pxa_set_btuart_info(NULL);
957 pxa_set_stuart_info(NULL);
959 spitz_spi_init();
960 spitz_scoop_init();
961 spitz_mkp_init();
962 spitz_keys_init();
963 spitz_leds_init();
964 spitz_mmc_init();
965 spitz_pcmcia_init();
966 spitz_irda_init();
967 spitz_uhc_init();
968 spitz_lcd_init();
969 spitz_nor_init();
970 spitz_nand_init();
971 spitz_i2c_init();
974 static void __init spitz_fixup(struct machine_desc *desc,
975 struct tag *tags, char **cmdline, struct meminfo *mi)
977 sharpsl_save_param();
978 mi->nr_banks = 1;
979 mi->bank[0].start = 0xa0000000;
980 mi->bank[0].size = (64*1024*1024);
983 #ifdef CONFIG_MACH_SPITZ
984 MACHINE_START(SPITZ, "SHARP Spitz")
985 .fixup = spitz_fixup,
986 .map_io = pxa27x_map_io,
987 .init_irq = pxa27x_init_irq,
988 .handle_irq = pxa27x_handle_irq,
989 .init_machine = spitz_init,
990 .timer = &pxa_timer,
991 MACHINE_END
992 #endif
994 #ifdef CONFIG_MACH_BORZOI
995 MACHINE_START(BORZOI, "SHARP Borzoi")
996 .fixup = spitz_fixup,
997 .map_io = pxa27x_map_io,
998 .init_irq = pxa27x_init_irq,
999 .handle_irq = pxa27x_handle_irq,
1000 .init_machine = spitz_init,
1001 .timer = &pxa_timer,
1002 MACHINE_END
1003 #endif
1005 #ifdef CONFIG_MACH_AKITA
1006 MACHINE_START(AKITA, "SHARP Akita")
1007 .fixup = spitz_fixup,
1008 .map_io = pxa27x_map_io,
1009 .init_irq = pxa27x_init_irq,
1010 .handle_irq = pxa27x_handle_irq,
1011 .init_machine = spitz_init,
1012 .timer = &pxa_timer,
1013 MACHINE_END
1014 #endif