aboutsummaryrefslogtreecommitdiffstats
path: root/arch/arm/mach-pxa/raumfeld.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/arm/mach-pxa/raumfeld.c')
-rw-r--r--arch/arm/mach-pxa/raumfeld.c1108
1 files changed, 1108 insertions, 0 deletions
diff --git a/arch/arm/mach-pxa/raumfeld.c b/arch/arm/mach-pxa/raumfeld.c
new file mode 100644
index 000000000000..3184bdc14526
--- /dev/null
+++ b/arch/arm/mach-pxa/raumfeld.c
@@ -0,0 +1,1108 @@
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 */
111static 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
184static 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
240static 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
294static 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
307static 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
314static 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
328static 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
352static 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
363static 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
372static 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
382static 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
394static 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
451static 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
457static 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
469static 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
484static struct gpio_led_platform_data raumfeld_led_platform_data = {
485 .leds = raumfeld_leds,
486 .num_leds = ARRAY_SIZE(raumfeld_leds),
487};
488
489static 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
501static void w1_enable_external_pullup(int enable)
502{
503 gpio_set_value(GPIO_W1_PULLUP_ENABLE, enable);
504 msleep(100);
505}
506
507static 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
513struct platform_device raumfeld_w1_gpio_device = {
514 .name = "w1-gpio",
515 .dev = {
516 .platform_data = &w1_gpio_platform_data
517 }
518};
519
520static 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 */
538static 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
546static 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 */
555static 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
561static struct gpio_led_platform_data raumfeld_lt3593_platform_data = {
562 .leds = &raumfeld_lt3593_led,
563 .num_leds = 1,
564};
565
566static 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
574static 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
588static 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
595static 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
627struct 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
634static 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
642static 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
685static struct spi_board_info connector_spi_devices[] __initdata = {
686 SPI_AK4104,
687 SPI_DAC7512,
688};
689
690static struct spi_board_info speaker_spi_devices[] __initdata = {
691 SPI_DAC7512,
692};
693
694static struct spi_board_info controller_spi_devices[] __initdata = {
695 SPI_LIS3,
696};
697
698/**
699 * MMC for Marvell Libertas 8688 via SDIO
700 */
701
702static 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
710static 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
716static 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
729static int power_supply_init(struct device *dev)
730{
731 return 0;
732}
733
734static void power_supply_exit(struct device *dev)
735{
736}
737
738static int raumfeld_is_ac_online(void)
739{
740 return !gpio_get_value(GPIO_CHARGE_DC_OK);
741}
742
743static int raumfeld_is_usb_online(void)
744{
745 return 0;
746}
747
748static char *raumfeld_power_supplicants[] = { "ds2760-battery.0" };
749
750static 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
759static 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
769static 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
781static 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
791static 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
828static struct regulator_consumer_supply audio_va_consumer_supply =
829 REGULATOR_SUPPLY("va", "0-0048");
830
831struct 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
839static 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
848static 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
858static struct regulator_consumer_supply audio_dummy_supplies[] = {
859 REGULATOR_SUPPLY("vd", "0-0048"),
860 REGULATOR_SUPPLY("vlc", "0-0048"),
861};
862
863struct 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
871static 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
878static 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
886static 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
895static struct regulator_consumer_supply vcc_mmc_supply =
896 REGULATOR_SUPPLY("vmmc", "pxa2xx-mci.0");
897
898static 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
911struct max8660_subdev_data max8660_v6_subdev_data = {
912 .id = MAX8660_V6,
913 .name = "vmmc",
914 .platform_data = &vcc_mmc_init_data,
915};
916
917static struct max8660_platform_data max8660_pdata = {
918 .subdevs = &max8660_v6_subdev_data,
919 .num_subdevs = 1,
920};
921
922/**
923 * I2C devices
924 */
925
926static struct i2c_board_info raumfeld_pwri2c_board_info = {
927 .type = "max8660",
928 .addr = 0x34,
929 .platform_data = &max8660_pdata,
930};
931
932static struct i2c_board_info raumfeld_connector_i2c_board_info __initdata = {
933 .type = "cs4270",
934 .addr = 0x48,
935};
936
937static struct eeti_ts_platform_data eeti_ts_pdata = {
938 .irq_active_high = 1,
939};
940
941static 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
948static struct platform_device *raumfeld_common_devices[] = {
949 &raumfeld_gpio_keys_device,
950 &raumfeld_led_device,
951 &raumfeld_spi_device,
952};
953
954static 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
979static 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
1025static 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
1046static 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
1058static 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
1075MACHINE_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,
1083MACHINE_END
1084#endif
1085
1086#ifdef CONFIG_MACH_RAUMFELD_CONNECTOR
1087MACHINE_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,
1095MACHINE_END
1096#endif
1097
1098#ifdef CONFIG_MACH_RAUMFELD_SPEAKER
1099MACHINE_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,
1107MACHINE_END
1108#endif
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-26 01:51:28 -0500