x86/PCI: truncate _CRS windows with _LEN > _MAX - _MIN + 1
[linux-2.6.git] / arch / arm / mach-pxa / raumfeld.c
1 /*
2  * arch/arm/mach-pxa/raumfeld.c
3  *
4  * Support for the following Raumfeld devices:
5  *
6  *      * Controller
7  *      * Connector
8  *      * Speaker S/M
9  *
10  * See http://www.raumfeld.com for details.
11  *
12  * Copyright (c) 2009 Daniel Mack <daniel@caiaq.de>
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License version 2 as
16  * published by the Free Software Foundation.
17  */
18
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/sysdev.h>
22 #include <linux/platform_device.h>
23 #include <linux/interrupt.h>
24 #include <linux/gpio.h>
25 #include <linux/smsc911x.h>
26 #include <linux/input.h>
27 #include <linux/rotary_encoder.h>
28 #include <linux/gpio_keys.h>
29 #include <linux/input/eeti_ts.h>
30 #include <linux/leds.h>
31 #include <linux/w1-gpio.h>
32 #include <linux/sched.h>
33 #include <linux/pwm_backlight.h>
34 #include <linux/i2c.h>
35 #include <linux/spi/spi.h>
36 #include <linux/spi/spi_gpio.h>
37 #include <linux/lis3lv02d.h>
38 #include <linux/pda_power.h>
39 #include <linux/power_supply.h>
40 #include <linux/pda_power.h>
41 #include <linux/power_supply.h>
42 #include <linux/regulator/max8660.h>
43 #include <linux/regulator/machine.h>
44 #include <linux/regulator/fixed.h>
45 #include <linux/regulator/consumer.h>
46 #include <linux/delay.h>
47
48 #include <asm/mach-types.h>
49 #include <asm/mach/arch.h>
50
51 #include <mach/hardware.h>
52 #include <mach/pxa3xx-regs.h>
53 #include <mach/mfp-pxa3xx.h>
54 #include <mach/mfp-pxa300.h>
55 #include <mach/ohci.h>
56 #include <mach/pxafb.h>
57 #include <mach/mmc.h>
58 #include <plat/i2c.h>
59 #include <plat/pxa3xx_nand.h>
60
61 #include "generic.h"
62 #include "devices.h"
63 #include "clock.h"
64
65 /* common GPIO  definitions */
66
67 /* inputs */
68 #define GPIO_ON_OFF             (14)
69 #define GPIO_VOLENC_A           (19)
70 #define GPIO_VOLENC_B           (20)
71 #define GPIO_CHARGE_DONE        (23)
72 #define GPIO_CHARGE_IND         (27)
73 #define GPIO_TOUCH_IRQ          (32)
74 #define GPIO_ETH_IRQ            (40)
75 #define GPIO_SPI_MISO           (98)
76 #define GPIO_ACCEL_IRQ          (104)
77 #define GPIO_RESCUE_BOOT        (115)
78 #define GPIO_DOCK_DETECT        (116)
79 #define GPIO_KEY1               (117)
80 #define GPIO_KEY2               (118)
81 #define GPIO_KEY3               (119)
82 #define GPIO_CHARGE_USB_OK      (112)
83 #define GPIO_CHARGE_DC_OK       (101)
84 #define GPIO_CHARGE_USB_SUSP    (102)
85
86 /* outputs */
87 #define GPIO_SHUTDOWN_SUPPLY    (16)
88 #define GPIO_SHUTDOWN_BATT      (18)
89 #define GPIO_CHRG_PEN2          (31)
90 #define GPIO_TFT_VA_EN          (33)
91 #define GPIO_SPDIF_CS           (34)
92 #define GPIO_LED2               (35)
93 #define GPIO_LED1               (36)
94 #define GPIO_SPDIF_RESET        (38)
95 #define GPIO_SPI_CLK            (95)
96 #define GPIO_MCLK_DAC_CS        (96)
97 #define GPIO_SPI_MOSI           (97)
98 #define GPIO_W1_PULLUP_ENABLE   (105)
99 #define GPIO_DISPLAY_ENABLE     (106)
100 #define GPIO_MCLK_RESET         (111)
101 #define GPIO_W2W_RESET          (113)
102 #define GPIO_W2W_PDN            (114)
103 #define GPIO_CODEC_RESET        (120)
104 #define GPIO_AUDIO_VA_ENABLE    (124)
105 #define GPIO_ACCEL_CS           (125)
106 #define GPIO_ONE_WIRE           (126)
107
108 /*
109  * GPIO configurations
110  */
111 static mfp_cfg_t raumfeld_controller_pin_config[] __initdata = {
112         /* UART1 */
113         GPIO77_UART1_RXD,
114         GPIO78_UART1_TXD,
115         GPIO79_UART1_CTS,
116         GPIO81_UART1_DSR,
117         GPIO83_UART1_DTR,
118         GPIO84_UART1_RTS,
119
120         /* UART3 */
121         GPIO110_UART3_RXD,
122
123         /* USB Host */
124         GPIO0_2_USBH_PEN,
125         GPIO1_2_USBH_PWR,
126
127         /* I2C */
128         GPIO21_I2C_SCL | MFP_LPM_FLOAT | MFP_PULL_FLOAT,
129         GPIO22_I2C_SDA | MFP_LPM_FLOAT | MFP_PULL_FLOAT,
130
131         /* SPI */
132         GPIO34_GPIO,    /* SPDIF_CS */
133         GPIO96_GPIO,    /* MCLK_CS */
134         GPIO125_GPIO,   /* ACCEL_CS */
135
136         /* MMC */
137         GPIO3_MMC1_DAT0,
138         GPIO4_MMC1_DAT1,
139         GPIO5_MMC1_DAT2,
140         GPIO6_MMC1_DAT3,
141         GPIO7_MMC1_CLK,
142         GPIO8_MMC1_CMD,
143
144         /* One-wire */
145         GPIO126_GPIO | MFP_LPM_FLOAT,
146         GPIO105_GPIO | MFP_PULL_LOW | MFP_LPM_PULL_LOW,
147
148         /* CHRG_USB_OK */
149         GPIO101_GPIO | MFP_PULL_HIGH,
150         /* CHRG_USB_OK */
151         GPIO112_GPIO | MFP_PULL_HIGH,
152         /* CHRG_USB_SUSP */
153         GPIO102_GPIO,
154         /* DISPLAY_ENABLE */
155         GPIO106_GPIO,
156         /* DOCK_DETECT */
157         GPIO116_GPIO | MFP_LPM_FLOAT | MFP_PULL_FLOAT,
158
159         /* LCD */
160         GPIO54_LCD_LDD_0,
161         GPIO55_LCD_LDD_1,
162         GPIO56_LCD_LDD_2,
163         GPIO57_LCD_LDD_3,
164         GPIO58_LCD_LDD_4,
165         GPIO59_LCD_LDD_5,
166         GPIO60_LCD_LDD_6,
167         GPIO61_LCD_LDD_7,
168         GPIO62_LCD_LDD_8,
169         GPIO63_LCD_LDD_9,
170         GPIO64_LCD_LDD_10,
171         GPIO65_LCD_LDD_11,
172         GPIO66_LCD_LDD_12,
173         GPIO67_LCD_LDD_13,
174         GPIO68_LCD_LDD_14,
175         GPIO69_LCD_LDD_15,
176         GPIO70_LCD_LDD_16,
177         GPIO71_LCD_LDD_17,
178         GPIO72_LCD_FCLK,
179         GPIO73_LCD_LCLK,
180         GPIO74_LCD_PCLK,
181         GPIO75_LCD_BIAS,
182 };
183
184 static mfp_cfg_t raumfeld_connector_pin_config[] __initdata = {
185         /* UART1 */
186         GPIO77_UART1_RXD,
187         GPIO78_UART1_TXD,
188         GPIO79_UART1_CTS,
189         GPIO81_UART1_DSR,
190         GPIO83_UART1_DTR,
191         GPIO84_UART1_RTS,
192
193         /* UART3 */
194         GPIO110_UART3_RXD,
195
196         /* USB Host */
197         GPIO0_2_USBH_PEN,
198         GPIO1_2_USBH_PWR,
199
200         /* I2C */
201         GPIO21_I2C_SCL | MFP_LPM_FLOAT | MFP_PULL_FLOAT,
202         GPIO22_I2C_SDA | MFP_LPM_FLOAT | MFP_PULL_FLOAT,
203
204         /* SPI */
205         GPIO34_GPIO,    /* SPDIF_CS */
206         GPIO96_GPIO,    /* MCLK_CS */
207         GPIO125_GPIO,   /* ACCEL_CS */
208
209         /* MMC */
210         GPIO3_MMC1_DAT0,
211         GPIO4_MMC1_DAT1,
212         GPIO5_MMC1_DAT2,
213         GPIO6_MMC1_DAT3,
214         GPIO7_MMC1_CLK,
215         GPIO8_MMC1_CMD,
216
217         /* Ethernet */
218         GPIO1_nCS2,                     /* CS */
219         GPIO40_GPIO | MFP_PULL_HIGH,    /* IRQ */
220
221         /* SSP for I2S */
222         GPIO85_SSP1_SCLK,
223         GPIO89_SSP1_EXTCLK,
224         GPIO86_SSP1_FRM,
225         GPIO87_SSP1_TXD,
226         GPIO88_SSP1_RXD,
227         GPIO90_SSP1_SYSCLK,
228
229         /* SSP2 for S/PDIF */
230         GPIO25_SSP2_SCLK,
231         GPIO26_SSP2_FRM,
232         GPIO27_SSP2_TXD,
233         GPIO29_SSP2_EXTCLK,
234
235         /* LEDs */
236         GPIO35_GPIO | MFP_LPM_PULL_LOW,
237         GPIO36_GPIO | MFP_LPM_DRIVE_HIGH,
238 };
239
240 static mfp_cfg_t raumfeld_speaker_pin_config[] __initdata = {
241         /* UART1 */
242         GPIO77_UART1_RXD,
243         GPIO78_UART1_TXD,
244         GPIO79_UART1_CTS,
245         GPIO81_UART1_DSR,
246         GPIO83_UART1_DTR,
247         GPIO84_UART1_RTS,
248
249         /* UART3 */
250         GPIO110_UART3_RXD,
251
252         /* USB Host */
253         GPIO0_2_USBH_PEN,
254         GPIO1_2_USBH_PWR,
255
256         /* I2C */
257         GPIO21_I2C_SCL | MFP_LPM_FLOAT | MFP_PULL_FLOAT,
258         GPIO22_I2C_SDA | MFP_LPM_FLOAT | MFP_PULL_FLOAT,
259
260         /* SPI */
261         GPIO34_GPIO,    /* SPDIF_CS */
262         GPIO96_GPIO,    /* MCLK_CS */
263         GPIO125_GPIO,   /* ACCEL_CS */
264
265         /* MMC */
266         GPIO3_MMC1_DAT0,
267         GPIO4_MMC1_DAT1,
268         GPIO5_MMC1_DAT2,
269         GPIO6_MMC1_DAT3,
270         GPIO7_MMC1_CLK,
271         GPIO8_MMC1_CMD,
272
273         /* Ethernet */
274         GPIO1_nCS2,                     /* CS */
275         GPIO40_GPIO | MFP_PULL_HIGH,    /* IRQ */
276
277         /* SSP for I2S */
278         GPIO85_SSP1_SCLK,
279         GPIO89_SSP1_EXTCLK,
280         GPIO86_SSP1_FRM,
281         GPIO87_SSP1_TXD,
282         GPIO88_SSP1_RXD,
283         GPIO90_SSP1_SYSCLK,
284
285         /* LEDs */
286         GPIO35_GPIO | MFP_LPM_PULL_LOW,
287         GPIO36_GPIO | MFP_LPM_DRIVE_HIGH,
288 };
289
290 /*
291  * SMSC LAN9220 Ethernet
292  */
293
294 static struct resource smc91x_resources[] = {
295         {
296                 .start  = PXA3xx_CS2_PHYS,
297                 .end    = PXA3xx_CS2_PHYS + 0xfffff,
298                 .flags  = IORESOURCE_MEM,
299         },
300         {
301                 .start  = gpio_to_irq(GPIO_ETH_IRQ),
302                 .end    = gpio_to_irq(GPIO_ETH_IRQ),
303                 .flags  = IORESOURCE_IRQ | IRQF_TRIGGER_FALLING,
304         }
305 };
306
307 static struct smsc911x_platform_config raumfeld_smsc911x_config = {
308         .phy_interface  = PHY_INTERFACE_MODE_MII,
309         .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
310         .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
311         .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
312 };
313
314 static struct platform_device smc91x_device = {
315         .name           = "smsc911x",
316         .id             = -1,
317         .num_resources  = ARRAY_SIZE(smc91x_resources),
318         .resource       = smc91x_resources,
319         .dev            = {
320                 .platform_data = &raumfeld_smsc911x_config,
321         }
322 };
323
324 /**
325  * NAND
326  */
327
328 static struct mtd_partition raumfeld_nand_partitions[] = {
329         {
330                 .name           = "Bootloader",
331                 .offset         = 0,
332                 .size           = 0xa0000,
333                 .mask_flags     = MTD_WRITEABLE, /* force read-only */
334         },
335         {
336                 .name           = "BootloaderEnvironment",
337                 .offset         = 0xa0000,
338                 .size           = 0x20000,
339         },
340         {
341                 .name           = "BootloaderSplashScreen",
342                 .offset         = 0xc0000,
343                 .size           = 0x60000,
344         },
345         {
346                 .name           = "UBI",
347                 .offset         = 0x120000,
348                 .size           = MTDPART_SIZ_FULL,
349         },
350 };
351
352 static struct pxa3xx_nand_platform_data raumfeld_nand_info = {
353         .enable_arbiter = 1,
354         .keep_config    = 1,
355         .parts          = raumfeld_nand_partitions,
356         .nr_parts       = ARRAY_SIZE(raumfeld_nand_partitions),
357 };
358
359 /**
360  * USB (OHCI) support
361  */
362
363 static struct pxaohci_platform_data raumfeld_ohci_info = {
364         .port_mode      = PMM_GLOBAL_MODE,
365         .flags          = ENABLE_PORT1,
366 };
367
368 /**
369  * Rotary encoder input device
370  */
371
372 static struct rotary_encoder_platform_data raumfeld_rotary_encoder_info = {
373         .steps          = 24,
374         .axis           = REL_X,
375         .relative_axis  = 1,
376         .gpio_a         = GPIO_VOLENC_A,
377         .gpio_b         = GPIO_VOLENC_B,
378         .inverted_a     = 1,
379         .inverted_b     = 0,
380 };
381
382 static struct platform_device rotary_encoder_device = {
383         .name           = "rotary-encoder",
384         .id             = 0,
385         .dev            = {
386                 .platform_data = &raumfeld_rotary_encoder_info,
387         }
388 };
389
390 /**
391  * GPIO buttons
392  */
393
394 static struct gpio_keys_button gpio_keys_button[] = {
395         {
396                 .code                   = KEY_F1,
397                 .type                   = EV_KEY,
398                 .gpio                   = GPIO_KEY1,
399                 .active_low             = 1,
400                 .wakeup                 = 0,
401                 .debounce_interval      = 5, /* ms */
402                 .desc                   = "Button 1",
403         },
404         {
405                 .code                   = KEY_F2,
406                 .type                   = EV_KEY,
407                 .gpio                   = GPIO_KEY2,
408                 .active_low             = 1,
409                 .wakeup                 = 0,
410                 .debounce_interval      = 5, /* ms */
411                 .desc                   = "Button 2",
412         },
413         {
414                 .code                   = KEY_F3,
415                 .type                   = EV_KEY,
416                 .gpio                   = GPIO_KEY3,
417                 .active_low             = 1,
418                 .wakeup                 = 0,
419                 .debounce_interval      = 5, /* ms */
420                 .desc                   = "Button 3",
421         },
422         {
423                 .code                   = KEY_F4,
424                 .type                   = EV_KEY,
425                 .gpio                   = GPIO_RESCUE_BOOT,
426                 .active_low             = 0,
427                 .wakeup                 = 0,
428                 .debounce_interval      = 5, /* ms */
429                 .desc                   = "rescue boot button",
430         },
431         {
432                 .code                   = KEY_F5,
433                 .type                   = EV_KEY,
434                 .gpio                   = GPIO_DOCK_DETECT,
435                 .active_low             = 1,
436                 .wakeup                 = 0,
437                 .debounce_interval      = 5, /* ms */
438                 .desc                   = "dock detect",
439         },
440         {
441                 .code                   = KEY_F6,
442                 .type                   = EV_KEY,
443                 .gpio                   = GPIO_ON_OFF,
444                 .active_low             = 0,
445                 .wakeup                 = 0,
446                 .debounce_interval      = 5, /* ms */
447                 .desc                   = "on/off button",
448         },
449 };
450
451 static struct gpio_keys_platform_data gpio_keys_platform_data = {
452         .buttons        = gpio_keys_button,
453         .nbuttons       = ARRAY_SIZE(gpio_keys_button),
454         .rep            = 0,
455 };
456
457 static struct platform_device raumfeld_gpio_keys_device = {
458         .name   = "gpio-keys",
459         .id     = -1,
460         .dev    = {
461                 .platform_data  = &gpio_keys_platform_data,
462         }
463 };
464
465 /**
466  * GPIO LEDs
467  */
468
469 static struct gpio_led raumfeld_leds[] = {
470         {
471                 .name           = "raumfeld:1",
472                 .gpio           = GPIO_LED1,
473                 .active_low     = 1,
474                 .default_state  = LEDS_GPIO_DEFSTATE_ON,
475         },
476         {
477                 .name           = "raumfeld:2",
478                 .gpio           = GPIO_LED2,
479                 .active_low     = 0,
480                 .default_state  = LEDS_GPIO_DEFSTATE_OFF,
481         }
482 };
483
484 static struct gpio_led_platform_data raumfeld_led_platform_data = {
485         .leds           = raumfeld_leds,
486         .num_leds       = ARRAY_SIZE(raumfeld_leds),
487 };
488
489 static struct platform_device raumfeld_led_device = {
490         .name   = "leds-gpio",
491         .id     = -1,
492         .dev    = {
493                 .platform_data = &raumfeld_led_platform_data,
494         },
495 };
496
497 /**
498  * One-wire (W1 bus) support
499  */
500
501 static void w1_enable_external_pullup(int enable)
502 {
503         gpio_set_value(GPIO_W1_PULLUP_ENABLE, enable);
504         msleep(100);
505 }
506
507 static struct w1_gpio_platform_data w1_gpio_platform_data = {
508         .pin                    = GPIO_ONE_WIRE,
509         .is_open_drain          = 0,
510         .enable_external_pullup = w1_enable_external_pullup,
511 };
512
513 struct platform_device raumfeld_w1_gpio_device = {
514         .name   = "w1-gpio",
515         .dev    = {
516                 .platform_data = &w1_gpio_platform_data
517         }
518 };
519
520 static void __init raumfeld_w1_init(void)
521 {
522         int ret = gpio_request(GPIO_W1_PULLUP_ENABLE,
523                                 "W1 external pullup enable");
524
525         if (ret < 0)
526                 pr_warning("Unable to request GPIO_W1_PULLUP_ENABLE\n");
527         else
528                 gpio_direction_output(GPIO_W1_PULLUP_ENABLE, 0);
529
530         platform_device_register(&raumfeld_w1_gpio_device);
531 }
532
533 /**
534  * Framebuffer device
535  */
536
537 /* PWM controlled backlight */
538 static struct platform_pwm_backlight_data raumfeld_pwm_backlight_data = {
539         .pwm_id         = 0,
540         .max_brightness = 100,
541         .dft_brightness = 100,
542         /* 10000 ns = 10 ms ^= 100 kHz */
543         .pwm_period_ns  = 10000,
544 };
545
546 static struct platform_device raumfeld_pwm_backlight_device = {
547         .name   = "pwm-backlight",
548         .dev    = {
549                 .parent         = &pxa27x_device_pwm0.dev,
550                 .platform_data  = &raumfeld_pwm_backlight_data,
551         }
552 };
553
554 /* LT3593 controlled backlight */
555 static struct gpio_led raumfeld_lt3593_led = {
556         .name           = "backlight",
557         .gpio           = mfp_to_gpio(MFP_PIN_GPIO17),
558         .default_state  = LEDS_GPIO_DEFSTATE_ON,
559 };
560
561 static struct gpio_led_platform_data raumfeld_lt3593_platform_data = {
562         .leds           = &raumfeld_lt3593_led,
563         .num_leds       = 1,
564 };
565
566 static struct platform_device raumfeld_lt3593_device = {
567         .name   = "leds-lt3593",
568         .id     = -1,
569         .dev    = {
570                 .platform_data = &raumfeld_lt3593_platform_data,
571         },
572 };
573
574 static struct pxafb_mode_info sharp_lq043t3dx02_mode = {
575         .pixclock       = 111000,
576         .xres           = 480,
577         .yres           = 272,
578         .bpp            = 16,
579         .hsync_len      = 4,
580         .left_margin    = 2,
581         .right_margin   = 1,
582         .vsync_len      = 1,
583         .upper_margin   = 3,
584         .lower_margin   = 1,
585         .sync           = 0,
586 };
587
588 static struct pxafb_mach_info raumfeld_sharp_lcd_info = {
589         .modes          = &sharp_lq043t3dx02_mode,
590         .num_modes      = 1,
591         .video_mem_size = 0x400000,
592         .lcd_conn       = LCD_COLOR_TFT_16BPP | LCD_PCLK_EDGE_FALL,
593 };
594
595 static void __init raumfeld_lcd_init(void)
596 {
597         int ret;
598
599         set_pxa_fb_info(&raumfeld_sharp_lcd_info);
600
601         /* Earlier devices had the backlight regulator controlled
602          * via PWM, later versions use another controller for that */
603         if ((system_rev & 0xff) < 2) {
604                 mfp_cfg_t raumfeld_pwm_pin_config = GPIO17_PWM0_OUT;
605                 pxa3xx_mfp_config(&raumfeld_pwm_pin_config, 1);
606                 platform_device_register(&raumfeld_pwm_backlight_device);
607         } else
608                 platform_device_register(&raumfeld_lt3593_device);
609
610         ret = gpio_request(GPIO_TFT_VA_EN, "display VA enable");
611         if (ret < 0)
612                 pr_warning("Unable to request GPIO_TFT_VA_EN\n");
613         else
614                 gpio_direction_output(GPIO_TFT_VA_EN, 1);
615
616         ret = gpio_request(GPIO_DISPLAY_ENABLE, "display enable");
617         if (ret < 0)
618                 pr_warning("Unable to request GPIO_DISPLAY_ENABLE\n");
619         else
620                 gpio_direction_output(GPIO_DISPLAY_ENABLE, 1);
621 }
622
623 /**
624  * SPI devices
625  */
626
627 struct spi_gpio_platform_data raumfeld_spi_platform_data = {
628         .sck            = GPIO_SPI_CLK,
629         .mosi           = GPIO_SPI_MOSI,
630         .miso           = GPIO_SPI_MISO,
631         .num_chipselect = 3,
632 };
633
634 static struct platform_device raumfeld_spi_device = {
635         .name   = "spi_gpio",
636         .id     = 0,
637         .dev    = {
638                 .platform_data  = &raumfeld_spi_platform_data,
639         }
640 };
641
642 static struct lis3lv02d_platform_data lis3_pdata = {
643         .click_flags    = LIS3_CLICK_SINGLE_X |
644                           LIS3_CLICK_SINGLE_Y |
645                           LIS3_CLICK_SINGLE_Z,
646         .irq_cfg        = LIS3_IRQ1_CLICK | LIS3_IRQ2_CLICK,
647         .wakeup_flags   = LIS3_WAKEUP_X_LO | LIS3_WAKEUP_X_HI |
648                           LIS3_WAKEUP_Y_LO | LIS3_WAKEUP_Y_HI |
649                           LIS3_WAKEUP_Z_LO | LIS3_WAKEUP_Z_HI,
650         .wakeup_thresh  = 10,
651         .click_thresh_x = 10,
652         .click_thresh_y = 10,
653         .click_thresh_z = 10,
654 };
655
656 #define SPI_AK4104      \
657 {                       \
658         .modalias       = "ak4104",     \
659         .max_speed_hz   = 10000,        \
660         .bus_num        = 0,            \
661         .chip_select    = 0,            \
662         .controller_data = (void *) GPIO_SPDIF_CS,      \
663 }
664
665 #define SPI_LIS3        \
666 {                       \
667         .modalias       = "lis3lv02d_spi",      \
668         .max_speed_hz   = 1000000,              \
669         .bus_num        = 0,                    \
670         .chip_select    = 1,                    \
671         .controller_data = (void *) GPIO_ACCEL_CS,      \
672         .platform_data  = &lis3_pdata,          \
673         .irq            = gpio_to_irq(GPIO_ACCEL_IRQ),  \
674 }
675
676 #define SPI_DAC7512     \
677 {       \
678         .modalias       = "dac7512",            \
679         .max_speed_hz   = 1000000,              \
680         .bus_num        = 0,                    \
681         .chip_select    = 2,                    \
682         .controller_data = (void *) GPIO_MCLK_DAC_CS,   \
683 }
684
685 static struct spi_board_info connector_spi_devices[] __initdata = {
686         SPI_AK4104,
687         SPI_DAC7512,
688 };
689
690 static struct spi_board_info speaker_spi_devices[] __initdata = {
691         SPI_DAC7512,
692 };
693
694 static struct spi_board_info controller_spi_devices[] __initdata = {
695         SPI_LIS3,
696 };
697
698 /**
699  * MMC for Marvell Libertas 8688 via SDIO
700  */
701
702 static int raumfeld_mci_init(struct device *dev, irq_handler_t isr, void *data)
703 {
704         gpio_set_value(GPIO_W2W_RESET, 1);
705         gpio_set_value(GPIO_W2W_PDN, 1);
706
707         return 0;
708 }
709
710 static void raumfeld_mci_exit(struct device *dev, void *data)
711 {
712         gpio_set_value(GPIO_W2W_RESET, 0);
713         gpio_set_value(GPIO_W2W_PDN, 0);
714 }
715
716 static struct pxamci_platform_data raumfeld_mci_platform_data = {
717         .init                   = raumfeld_mci_init,
718         .exit                   = raumfeld_mci_exit,
719         .detect_delay           = 20,
720         .gpio_card_detect       = -1,
721         .gpio_card_ro           = -1,
722         .gpio_power             = -1,
723 };
724
725 /*
726  * External power / charge logic
727  */
728
729 static int power_supply_init(struct device *dev)
730 {
731         return 0;
732 }
733
734 static void power_supply_exit(struct device *dev)
735 {
736 }
737
738 static int raumfeld_is_ac_online(void)
739 {
740         return !gpio_get_value(GPIO_CHARGE_DC_OK);
741 }
742
743 static int raumfeld_is_usb_online(void)
744 {
745         return 0;
746 }
747
748 static char *raumfeld_power_supplicants[] = { "ds2760-battery.0" };
749
750 static struct pda_power_pdata power_supply_info = {
751         .init                   = power_supply_init,
752         .is_ac_online           = raumfeld_is_ac_online,
753         .is_usb_online          = raumfeld_is_usb_online,
754         .exit                   = power_supply_exit,
755         .supplied_to            = raumfeld_power_supplicants,
756         .num_supplicants        = ARRAY_SIZE(raumfeld_power_supplicants)
757 };
758
759 static struct resource power_supply_resources[] = {
760         {
761                 .name  = "ac",
762                 .flags = IORESOURCE_IRQ |
763                          IORESOURCE_IRQ_HIGHEDGE | IORESOURCE_IRQ_LOWEDGE,
764                 .start = GPIO_CHARGE_DC_OK,
765                 .end   = GPIO_CHARGE_DC_OK,
766         },
767 };
768
769 static irqreturn_t charge_done_irq(int irq, void *dev_id)
770 {
771         struct power_supply *psy;
772
773         psy = power_supply_get_by_name("ds2760-battery.0");
774
775         if (psy)
776                 power_supply_set_battery_charged(psy);
777
778         return IRQ_HANDLED;
779 }
780
781 static struct platform_device raumfeld_power_supply = {
782         .name = "pda-power",
783         .id   = -1,
784         .dev  = {
785                 .platform_data = &power_supply_info,
786         },
787         .resource      = power_supply_resources,
788         .num_resources = ARRAY_SIZE(power_supply_resources),
789 };
790
791 static void __init raumfeld_power_init(void)
792 {
793         int ret;
794
795         /* Set PEN2 high to enable maximum charge current */
796         ret = gpio_request(GPIO_CHRG_PEN2, "CHRG_PEN2");
797         if (ret < 0)
798                 pr_warning("Unable to request GPIO_CHRG_PEN2\n");
799         else
800                 gpio_direction_output(GPIO_CHRG_PEN2, 1);
801
802         ret = gpio_request(GPIO_CHARGE_DC_OK, "CABLE_DC_OK");
803         if (ret < 0)
804                 pr_warning("Unable to request GPIO_CHARGE_DC_OK\n");
805
806         ret = gpio_request(GPIO_CHARGE_USB_SUSP, "CHARGE_USB_SUSP");
807         if (ret < 0)
808                 pr_warning("Unable to request GPIO_CHARGE_USB_SUSP\n");
809         else
810                 gpio_direction_output(GPIO_CHARGE_USB_SUSP, 0);
811
812         power_supply_resources[0].start = gpio_to_irq(GPIO_CHARGE_DC_OK);
813         power_supply_resources[0].end = gpio_to_irq(GPIO_CHARGE_DC_OK);
814
815         ret = request_irq(gpio_to_irq(GPIO_CHARGE_DONE),
816                         &charge_done_irq, IORESOURCE_IRQ_LOWEDGE,
817                         "charge_done", NULL);
818
819         if (ret < 0)
820                 printk(KERN_ERR "%s: unable to register irq %d\n", __func__,
821                         GPIO_CHARGE_DONE);
822         else
823                 platform_device_register(&raumfeld_power_supply);
824 }
825
826 /* Fixed regulator for AUDIO_VA, 0-0048 maps to the cs4270 codec device */
827
828 static struct regulator_consumer_supply audio_va_consumer_supply =
829         REGULATOR_SUPPLY("va", "0-0048");
830
831 struct regulator_init_data audio_va_initdata = {
832         .consumer_supplies = &audio_va_consumer_supply,
833         .num_consumer_supplies = 1,
834         .constraints = {
835                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
836         },
837 };
838
839 static struct fixed_voltage_config audio_va_config = {
840         .supply_name            = "audio_va",
841         .microvolts             = 5000000,
842         .gpio                   = GPIO_AUDIO_VA_ENABLE,
843         .enable_high            = 1,
844         .enabled_at_boot        = 0,
845         .init_data              = &audio_va_initdata,
846 };
847
848 static struct platform_device audio_va_device = {
849         .name   = "reg-fixed-voltage",
850         .id     = 0,
851         .dev    = {
852                 .platform_data = &audio_va_config,
853         },
854 };
855
856 /* Dummy supplies for Codec's VD/VLC */
857
858 static struct regulator_consumer_supply audio_dummy_supplies[] = {
859         REGULATOR_SUPPLY("vd", "0-0048"),
860         REGULATOR_SUPPLY("vlc", "0-0048"),
861 };
862
863 struct regulator_init_data audio_dummy_initdata = {
864         .consumer_supplies = audio_dummy_supplies,
865         .num_consumer_supplies = ARRAY_SIZE(audio_dummy_supplies),
866         .constraints = {
867                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
868         },
869 };
870
871 static struct fixed_voltage_config audio_dummy_config = {
872         .supply_name            = "audio_vd",
873         .microvolts             = 3300000,
874         .gpio                   = -1,
875         .init_data              = &audio_dummy_initdata,
876 };
877
878 static struct platform_device audio_supply_dummy_device = {
879         .name   = "reg-fixed-voltage",
880         .id     = 1,
881         .dev    = {
882                 .platform_data = &audio_dummy_config,
883         },
884 };
885
886 static struct platform_device *audio_regulator_devices[] = {
887         &audio_va_device,
888         &audio_supply_dummy_device,
889 };
890
891 /**
892  * Regulator support via MAX8660
893  */
894
895 static struct regulator_consumer_supply vcc_mmc_supply =
896         REGULATOR_SUPPLY("vmmc", "pxa2xx-mci.0");
897
898 static struct regulator_init_data vcc_mmc_init_data = {
899         .constraints = {
900                 .min_uV                 = 3300000,
901                 .max_uV                 = 3300000,
902                 .valid_modes_mask       = REGULATOR_MODE_NORMAL,
903                 .valid_ops_mask         = REGULATOR_CHANGE_STATUS |
904                                           REGULATOR_CHANGE_VOLTAGE |
905                                           REGULATOR_CHANGE_MODE,
906         },
907         .consumer_supplies = &vcc_mmc_supply,
908         .num_consumer_supplies = 1,
909 };
910
911 struct max8660_subdev_data max8660_v6_subdev_data = {
912         .id             = MAX8660_V6,
913         .name           = "vmmc",
914         .platform_data  = &vcc_mmc_init_data,
915 };
916
917 static struct max8660_platform_data max8660_pdata = {
918         .subdevs = &max8660_v6_subdev_data,
919         .num_subdevs = 1,
920 };
921
922 /**
923  * I2C devices
924  */
925
926 static struct i2c_board_info raumfeld_pwri2c_board_info = {
927         .type           = "max8660",
928         .addr           = 0x34,
929         .platform_data  = &max8660_pdata,
930 };
931
932 static struct i2c_board_info raumfeld_connector_i2c_board_info __initdata = {
933         .type   = "cs4270",
934         .addr   = 0x48,
935 };
936
937 static struct eeti_ts_platform_data eeti_ts_pdata = {
938         .irq_active_high = 1,
939 };
940
941 static struct i2c_board_info raumfeld_controller_i2c_board_info __initdata = {
942         .type   = "eeti_ts",
943         .addr   = 0x0a,
944         .irq    = gpio_to_irq(GPIO_TOUCH_IRQ),
945         .platform_data = &eeti_ts_pdata,
946 };
947
948 static struct platform_device *raumfeld_common_devices[] = {
949         &raumfeld_gpio_keys_device,
950         &raumfeld_led_device,
951         &raumfeld_spi_device,
952 };
953
954 static void __init raumfeld_audio_init(void)
955 {
956         int ret;
957
958         ret = gpio_request(GPIO_CODEC_RESET, "cs4270 reset");
959         if (ret < 0)
960                 pr_warning("unable to request GPIO_CODEC_RESET\n");
961         else
962                 gpio_direction_output(GPIO_CODEC_RESET, 1);
963
964         ret = gpio_request(GPIO_SPDIF_RESET, "ak4104 s/pdif reset");
965         if (ret < 0)
966                 pr_warning("unable to request GPIO_SPDIF_RESET\n");
967         else
968                 gpio_direction_output(GPIO_SPDIF_RESET, 1);
969
970         ret = gpio_request(GPIO_MCLK_RESET, "MCLK reset");
971         if (ret < 0)
972                 pr_warning("unable to request GPIO_MCLK_RESET\n");
973         else
974                 gpio_direction_output(GPIO_MCLK_RESET, 1);
975
976         platform_add_devices(ARRAY_AND_SIZE(audio_regulator_devices));
977 }
978
979 static void __init raumfeld_common_init(void)
980 {
981         int ret;
982
983         /* The on/off button polarity has changed after revision 1 */
984         if ((system_rev & 0xff) > 1) {
985                 int i;
986
987                 for (i = 0; i < ARRAY_SIZE(gpio_keys_button); i++)
988                         if (!strcmp(gpio_keys_button[i].desc, "on/off button"))
989                                 gpio_keys_button[i].active_low = 1;
990         }
991
992         enable_irq_wake(IRQ_WAKEUP0);
993
994         pxa3xx_set_nand_info(&raumfeld_nand_info);
995         pxa3xx_set_i2c_power_info(NULL);
996         pxa_set_ohci_info(&raumfeld_ohci_info);
997         pxa_set_mci_info(&raumfeld_mci_platform_data);
998         pxa_set_i2c_info(NULL);
999         pxa_set_ffuart_info(NULL);
1000
1001         ret = gpio_request(GPIO_W2W_RESET, "Wi2Wi reset");
1002         if (ret < 0)
1003                 pr_warning("Unable to request GPIO_W2W_RESET\n");
1004         else
1005                 gpio_direction_output(GPIO_W2W_RESET, 0);
1006
1007         ret = gpio_request(GPIO_W2W_PDN, "Wi2Wi powerup");
1008         if (ret < 0)
1009                 pr_warning("Unable to request GPIO_W2W_PDN\n");
1010         else
1011                 gpio_direction_output(GPIO_W2W_PDN, 0);
1012
1013         /* this can be used to switch off the device */
1014         ret = gpio_request(GPIO_SHUTDOWN_SUPPLY,
1015                                 "supply shutdown");
1016         if (ret < 0)
1017                 pr_warning("Unable to request GPIO_SHUTDOWN_SUPPLY\n");
1018         else
1019                 gpio_direction_output(GPIO_SHUTDOWN_SUPPLY, 0);
1020
1021         platform_add_devices(ARRAY_AND_SIZE(raumfeld_common_devices));
1022         i2c_register_board_info(1, &raumfeld_pwri2c_board_info, 1);
1023 }
1024
1025 static void __init raumfeld_controller_init(void)
1026 {
1027         int ret;
1028
1029         pxa3xx_mfp_config(ARRAY_AND_SIZE(raumfeld_controller_pin_config));
1030         platform_device_register(&rotary_encoder_device);
1031         spi_register_board_info(ARRAY_AND_SIZE(controller_spi_devices));
1032         i2c_register_board_info(0, &raumfeld_controller_i2c_board_info, 1);
1033
1034         ret = gpio_request(GPIO_SHUTDOWN_BATT, "battery shutdown");
1035         if (ret < 0)
1036                 pr_warning("Unable to request GPIO_SHUTDOWN_BATT\n");
1037         else
1038                 gpio_direction_output(GPIO_SHUTDOWN_BATT, 0);
1039
1040         raumfeld_common_init();
1041         raumfeld_power_init();
1042         raumfeld_lcd_init();
1043         raumfeld_w1_init();
1044 }
1045
1046 static void __init raumfeld_connector_init(void)
1047 {
1048         pxa3xx_mfp_config(ARRAY_AND_SIZE(raumfeld_connector_pin_config));
1049         spi_register_board_info(ARRAY_AND_SIZE(connector_spi_devices));
1050         i2c_register_board_info(0, &raumfeld_connector_i2c_board_info, 1);
1051
1052         platform_device_register(&smc91x_device);
1053
1054         raumfeld_audio_init();
1055         raumfeld_common_init();
1056 }
1057
1058 static void __init raumfeld_speaker_init(void)
1059 {
1060         pxa3xx_mfp_config(ARRAY_AND_SIZE(raumfeld_speaker_pin_config));
1061         spi_register_board_info(ARRAY_AND_SIZE(speaker_spi_devices));
1062         i2c_register_board_info(0, &raumfeld_connector_i2c_board_info, 1);
1063
1064         platform_device_register(&smc91x_device);
1065         platform_device_register(&rotary_encoder_device);
1066
1067         raumfeld_audio_init();
1068         raumfeld_common_init();
1069 }
1070
1071 /* physical memory regions */
1072 #define RAUMFELD_SDRAM_BASE     0xa0000000      /* SDRAM region */
1073
1074 #ifdef CONFIG_MACH_RAUMFELD_RC
1075 MACHINE_START(RAUMFELD_RC, "Raumfeld Controller")
1076         .phys_io        = 0x40000000,
1077         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
1078         .boot_params    = RAUMFELD_SDRAM_BASE + 0x100,
1079         .init_machine   = raumfeld_controller_init,
1080         .map_io         = pxa_map_io,
1081         .init_irq       = pxa3xx_init_irq,
1082         .timer          = &pxa_timer,
1083 MACHINE_END
1084 #endif
1085
1086 #ifdef CONFIG_MACH_RAUMFELD_CONNECTOR
1087 MACHINE_START(RAUMFELD_CONNECTOR, "Raumfeld Connector")
1088         .phys_io        = 0x40000000,
1089         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
1090         .boot_params    = RAUMFELD_SDRAM_BASE + 0x100,
1091         .init_machine   = raumfeld_connector_init,
1092         .map_io         = pxa_map_io,
1093         .init_irq       = pxa3xx_init_irq,
1094         .timer          = &pxa_timer,
1095 MACHINE_END
1096 #endif
1097
1098 #ifdef CONFIG_MACH_RAUMFELD_SPEAKER
1099 MACHINE_START(RAUMFELD_SPEAKER, "Raumfeld Speaker")
1100         .phys_io        = 0x40000000,
1101         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
1102         .boot_params    = RAUMFELD_SDRAM_BASE + 0x100,
1103         .init_machine   = raumfeld_speaker_init,
1104         .map_io         = pxa_map_io,
1105         .init_irq       = pxa3xx_init_irq,
1106         .timer          = &pxa_timer,
1107 MACHINE_END
1108 #endif