aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDaniel Mack <daniel@caiaq.de>2009-11-27 07:47:09 -0500
committerEric Miao <eric.y.miao@gmail.com>2009-12-18 02:34:38 -0500
commit550ee52d823845f882ddadcd032b33169866a739 (patch)
treec7aa0195e64f4e5fd6194a107d061712be133302
parent55639353a0035052d9ea6cfe4dde0ac7fcbb2c9f (diff)
[ARM] pxa/raumfeld: add platform support
This adds support for Raumfeld's 'Controller', 'Connector', 'Speaker S' and 'Speaker M' devices. They're all based on PXA303 SoCs. Signed-off-by: Daniel Mack <daniel@caiaq.de> Signed-off-by: Eric Miao <eric.y.miao@gmail.com>
Diffstat
-rw-r--r--arch/arm/mach-pxa/Kconfig18
-rw-r--r--arch/arm/mach-pxa/Makefile3
-rw-r--r--arch/arm/mach-pxa/raumfeld.c1100
3 files changed, 1121 insertions, 0 deletions
diff --git a/arch/arm/mach-pxa/Kconfig b/arch/arm/mach-pxa/Kconfig
index 8a0837ea0294..fdb966e590a2 100644
--- a/arch/arm/mach-pxa/Kconfig
+++ b/arch/arm/mach-pxa/Kconfig
@@ -415,6 +415,24 @@ config MACH_TREO680
415 Say Y here if you intend to run this kernel on Palm Treo 680 415 Say Y here if you intend to run this kernel on Palm Treo 680
416 smartphone. 416 smartphone.
417 417
418config MACH_RAUMFELD_RC
419 bool "Raumfeld Controller"
420 select PXA3xx
421 select CPU_PXA300
422 select HAVE_PWM
423
424config MACH_RAUMFELD_CONNECTOR
425 bool "Raumfeld Connector"
426 select PXA3xx
427 select CPU_PXA300
428 select PXA_SSP
429
430config MACH_RAUMFELD_SPEAKER
431 bool "Raumfeld Speaker"
432 select PXA3xx
433 select CPU_PXA300
434 select PXA_SSP
435
418config PXA_SHARPSL 436config PXA_SHARPSL
419 bool "SHARP Zaurus SL-5600, SL-C7xx and SL-Cxx00 Models" 437 bool "SHARP Zaurus SL-5600, SL-C7xx and SL-Cxx00 Models"
420 select SHARP_SCOOP 438 select SHARP_SCOOP
diff --git a/arch/arm/mach-pxa/Makefile b/arch/arm/mach-pxa/Makefile
index f64afda7e6f6..9d831939b3c5 100644
--- a/arch/arm/mach-pxa/Makefile
+++ b/arch/arm/mach-pxa/Makefile
@@ -89,6 +89,9 @@ obj-$(CONFIG_MACH_E740) += e740.o
89obj-$(CONFIG_MACH_E750) += e750.o 89obj-$(CONFIG_MACH_E750) += e750.o
90obj-$(CONFIG_MACH_E400) += e400.o 90obj-$(CONFIG_MACH_E400) += e400.o
91obj-$(CONFIG_MACH_E800) += e800.o 91obj-$(CONFIG_MACH_E800) += e800.o
92obj-$(CONFIG_MACH_RAUMFELD_RC) += raumfeld.o
93obj-$(CONFIG_MACH_RAUMFELD_CONNECTOR) += raumfeld.o
94obj-$(CONFIG_MACH_RAUMFELD_SPEAKER) += raumfeld.o
92 95
93# Support for blinky lights 96# Support for blinky lights
94led-y := leds.o 97led-y := leds.o
diff --git a/arch/arm/mach-pxa/raumfeld.c b/arch/arm/mach-pxa/raumfeld.c
new file mode 100644
index 000000000000..06717d7995cb
--- /dev/null
+++ b/arch/arm/mach-pxa/raumfeld.c
@@ -0,0 +1,1100 @@
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
236static mfp_cfg_t raumfeld_speaker_pin_config[] __initdata = {
237 /* UART1 */
238 GPIO77_UART1_RXD,
239 GPIO78_UART1_TXD,
240 GPIO79_UART1_CTS,
241 GPIO81_UART1_DSR,
242 GPIO83_UART1_DTR,
243 GPIO84_UART1_RTS,
244
245 /* UART3 */
246 GPIO110_UART3_RXD,
247
248 /* USB Host */
249 GPIO0_2_USBH_PEN,
250 GPIO1_2_USBH_PWR,
251
252 /* I2C */
253 GPIO21_I2C_SCL | MFP_LPM_FLOAT | MFP_PULL_FLOAT,
254 GPIO22_I2C_SDA | MFP_LPM_FLOAT | MFP_PULL_FLOAT,
255
256 /* SPI */
257 GPIO34_GPIO, /* SPDIF_CS */
258 GPIO96_GPIO, /* MCLK_CS */
259 GPIO125_GPIO, /* ACCEL_CS */
260
261 /* MMC */
262 GPIO3_MMC1_DAT0,
263 GPIO4_MMC1_DAT1,
264 GPIO5_MMC1_DAT2,
265 GPIO6_MMC1_DAT3,
266 GPIO7_MMC1_CLK,
267 GPIO8_MMC1_CMD,
268
269 /* Ethernet */
270 GPIO1_nCS2, /* CS */
271 GPIO40_GPIO | MFP_PULL_HIGH, /* IRQ */
272
273 /* SSP for I2S */
274 GPIO85_SSP1_SCLK,
275 GPIO89_SSP1_EXTCLK,
276 GPIO86_SSP1_FRM,
277 GPIO87_SSP1_TXD,
278 GPIO88_SSP1_RXD,
279 GPIO90_SSP1_SYSCLK,
280};
281
282/*
283 * SMSC LAN9220 Ethernet
284 */
285
286static struct resource smc91x_resources[] = {
287 {
288 .start = PXA3xx_CS2_PHYS,
289 .end = PXA3xx_CS2_PHYS + 0xfffff,
290 .flags = IORESOURCE_MEM,
291 },
292 {
293 .start = gpio_to_irq(GPIO_ETH_IRQ),
294 .end = gpio_to_irq(GPIO_ETH_IRQ),
295 .flags = IORESOURCE_IRQ | IRQF_TRIGGER_FALLING,
296 }
297};
298
299static struct smsc911x_platform_config raumfeld_smsc911x_config = {
300 .phy_interface = PHY_INTERFACE_MODE_MII,
301 .irq_polarity = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
302 .irq_type = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
303 .flags = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
304};
305
306static struct platform_device smc91x_device = {
307 .name = "smsc911x",
308 .id = -1,
309 .num_resources = ARRAY_SIZE(smc91x_resources),
310 .resource = smc91x_resources,
311 .dev = {
312 .platform_data = &raumfeld_smsc911x_config,
313 }
314};
315
316/**
317 * NAND
318 */
319
320static struct mtd_partition raumfeld_nand_partitions[] = {
321 {
322 .name = "Bootloader",
323 .offset = 0,
324 .size = 0xa0000,
325 .mask_flags = MTD_WRITEABLE, /* force read-only */
326 },
327 {
328 .name = "BootloaderEnvironment",
329 .offset = 0xa0000,
330 .size = 0x20000,
331 },
332 {
333 .name = "BootloaderSplashScreen",
334 .offset = 0xc0000,
335 .size = 0x60000,
336 },
337 {
338 .name = "UBI",
339 .offset = 0x120000,
340 .size = MTDPART_SIZ_FULL,
341 },
342};
343
344static struct pxa3xx_nand_platform_data raumfeld_nand_info = {
345 .enable_arbiter = 1,
346 .keep_config = 1,
347 .parts = raumfeld_nand_partitions,
348 .nr_parts = ARRAY_SIZE(raumfeld_nand_partitions),
349};
350
351/**
352 * USB (OHCI) support
353 */
354
355static struct pxaohci_platform_data raumfeld_ohci_info = {
356 .port_mode = PMM_GLOBAL_MODE,
357 .flags = ENABLE_PORT1,
358};
359
360/**
361 * Rotary encoder input device
362 */
363
364static struct rotary_encoder_platform_data raumfeld_rotary_encoder_info = {
365 .steps = 24,
366 .axis = REL_X,
367 .relative_axis = 1,
368 .gpio_a = GPIO_VOLENC_A,
369 .gpio_b = GPIO_VOLENC_B,
370 .inverted_a = 1,
371 .inverted_b = 0,
372};
373
374static struct platform_device rotary_encoder_device = {
375 .name = "rotary-encoder",
376 .id = 0,
377 .dev = {
378 .platform_data = &raumfeld_rotary_encoder_info,
379 }
380};
381
382/**
383 * GPIO buttons
384 */
385
386static struct gpio_keys_button gpio_keys_button[] = {
387 {
388 .code = KEY_F1,
389 .type = EV_KEY,
390 .gpio = GPIO_KEY1,
391 .active_low = 1,
392 .wakeup = 0,
393 .debounce_interval = 5, /* ms */
394 .desc = "Button 1",
395 },
396 {
397 .code = KEY_F2,
398 .type = EV_KEY,
399 .gpio = GPIO_KEY2,
400 .active_low = 1,
401 .wakeup = 0,
402 .debounce_interval = 5, /* ms */
403 .desc = "Button 2",
404 },
405 {
406 .code = KEY_F3,
407 .type = EV_KEY,
408 .gpio = GPIO_KEY3,
409 .active_low = 1,
410 .wakeup = 0,
411 .debounce_interval = 5, /* ms */
412 .desc = "Button 3",
413 },
414 {
415 .code = KEY_F4,
416 .type = EV_KEY,
417 .gpio = GPIO_RESCUE_BOOT,
418 .active_low = 0,
419 .wakeup = 0,
420 .debounce_interval = 5, /* ms */
421 .desc = "rescue boot button",
422 },
423 {
424 .code = KEY_F5,
425 .type = EV_KEY,
426 .gpio = GPIO_DOCK_DETECT,
427 .active_low = 1,
428 .wakeup = 0,
429 .debounce_interval = 5, /* ms */
430 .desc = "dock detect",
431 },
432 {
433 .code = KEY_F6,
434 .type = EV_KEY,
435 .gpio = GPIO_ON_OFF,
436 .active_low = 0,
437 .wakeup = 0,
438 .debounce_interval = 5, /* ms */
439 .desc = "on/off button",
440 },
441};
442
443static struct gpio_keys_platform_data gpio_keys_platform_data = {
444 .buttons = gpio_keys_button,
445 .nbuttons = ARRAY_SIZE(gpio_keys_button),
446 .rep = 0,
447};
448
449static struct platform_device raumfeld_gpio_keys_device = {
450 .name = "gpio-keys",
451 .id = -1,
452 .dev = {
453 .platform_data = &gpio_keys_platform_data,
454 }
455};
456
457/**
458 * GPIO LEDs
459 */
460
461static struct gpio_led raumfeld_leds[] = {
462 {
463 .name = "raumfeld:1",
464 .gpio = GPIO_LED1,
465 .active_low = 1,
466 .default_state = LEDS_GPIO_DEFSTATE_ON,
467 },
468 {
469 .name = "raumfeld:2",
470 .gpio = GPIO_LED2,
471 .active_low = 0,
472 .default_state = LEDS_GPIO_DEFSTATE_OFF,
473 }
474};
475
476static struct gpio_led_platform_data raumfeld_led_platform_data = {
477 .leds = raumfeld_leds,
478 .num_leds = ARRAY_SIZE(raumfeld_leds),
479};
480
481static struct platform_device raumfeld_led_device = {
482 .name = "leds-gpio",
483 .id = -1,
484 .dev = {
485 .platform_data = &raumfeld_led_platform_data,
486 },
487};
488
489/**
490 * One-wire (W1 bus) support
491 */
492
493static void w1_enable_external_pullup(int enable)
494{
495 gpio_set_value(GPIO_W1_PULLUP_ENABLE, enable);
496 msleep(100);
497}
498
499static struct w1_gpio_platform_data w1_gpio_platform_data = {
500 .pin = GPIO_ONE_WIRE,
501 .is_open_drain = 0,
502 .enable_external_pullup = w1_enable_external_pullup,
503};
504
505struct platform_device raumfeld_w1_gpio_device = {
506 .name = "w1-gpio",
507 .dev = {
508 .platform_data = &w1_gpio_platform_data
509 }
510};
511
512static void __init raumfeld_w1_init(void)
513{
514 int ret = gpio_request(GPIO_W1_PULLUP_ENABLE,
515 "W1 external pullup enable");
516
517 if (ret < 0)
518 pr_warning("Unable to request GPIO_W1_PULLUP_ENABLE\n");
519 else
520 gpio_direction_output(GPIO_W1_PULLUP_ENABLE, 0);
521
522 platform_device_register(&raumfeld_w1_gpio_device);
523}
524
525/**
526 * Framebuffer device
527 */
528
529/* PWM controlled backlight */
530static struct platform_pwm_backlight_data raumfeld_pwm_backlight_data = {
531 .pwm_id = 0,
532 .max_brightness = 100,
533 .dft_brightness = 100,
534 /* 10000 ns = 10 ms ^= 100 kHz */
535 .pwm_period_ns = 10000,
536};
537
538static struct platform_device raumfeld_pwm_backlight_device = {
539 .name = "pwm-backlight",
540 .dev = {
541 .parent = &pxa27x_device_pwm0.dev,
542 .platform_data = &raumfeld_pwm_backlight_data,
543 }
544};
545
546/* LT3593 controlled backlight */
547static struct gpio_led raumfeld_lt3593_led = {
548 .name = "backlight",
549 .gpio = mfp_to_gpio(MFP_PIN_GPIO17),
550 .default_state = LEDS_GPIO_DEFSTATE_ON,
551};
552
553static struct gpio_led_platform_data raumfeld_lt3593_platform_data = {
554 .leds = &raumfeld_lt3593_led,
555 .num_leds = 1,
556};
557
558static struct platform_device raumfeld_lt3593_device = {
559 .name = "leds-lt3593",
560 .id = -1,
561 .dev = {
562 .platform_data = &raumfeld_lt3593_platform_data,
563 },
564};
565
566static struct pxafb_mode_info sharp_lq043t3dx02_mode = {
567 .pixclock = 111000,
568 .xres = 480,
569 .yres = 272,
570 .bpp = 16,
571 .hsync_len = 4,
572 .left_margin = 2,
573 .right_margin = 1,
574 .vsync_len = 1,
575 .upper_margin = 3,
576 .lower_margin = 1,
577 .sync = 0,
578};
579
580static struct pxafb_mach_info raumfeld_sharp_lcd_info = {
581 .modes = &sharp_lq043t3dx02_mode,
582 .num_modes = 1,
583 .video_mem_size = 0x400000,
584 .lcd_conn = LCD_COLOR_TFT_16BPP | LCD_PCLK_EDGE_FALL,
585};
586
587static void __init raumfeld_lcd_init(void)
588{
589 int ret;
590
591 set_pxa_fb_info(&raumfeld_sharp_lcd_info);
592
593 /* Earlier devices had the backlight regulator controlled
594 * via PWM, later versions use another controller for that */
595 if ((system_rev & 0xff) < 2) {
596 mfp_cfg_t raumfeld_pwm_pin_config = GPIO17_PWM0_OUT;
597 pxa3xx_mfp_config(&raumfeld_pwm_pin_config, 1);
598 platform_device_register(&raumfeld_pwm_backlight_device);
599 } else
600 platform_device_register(&raumfeld_lt3593_device);
601
602 ret = gpio_request(GPIO_TFT_VA_EN, "display VA enable");
603 if (ret < 0)
604 pr_warning("Unable to request GPIO_TFT_VA_EN\n");
605 else
606 gpio_direction_output(GPIO_TFT_VA_EN, 1);
607
608 ret = gpio_request(GPIO_DISPLAY_ENABLE, "display enable");
609 if (ret < 0)
610 pr_warning("Unable to request GPIO_DISPLAY_ENABLE\n");
611 else
612 gpio_direction_output(GPIO_DISPLAY_ENABLE, 1);
613}
614
615/**
616 * SPI devices
617 */
618
619struct spi_gpio_platform_data raumfeld_spi_platform_data = {
620 .sck = GPIO_SPI_CLK,
621 .mosi = GPIO_SPI_MOSI,
622 .miso = GPIO_SPI_MISO,
623 .num_chipselect = 3,
624};
625
626static struct platform_device raumfeld_spi_device = {
627 .name = "spi_gpio",
628 .id = 0,
629 .dev = {
630 .platform_data = &raumfeld_spi_platform_data,
631 }
632};
633
634static struct lis3lv02d_platform_data lis3_pdata = {
635 .click_flags = LIS3_CLICK_SINGLE_X |
636 LIS3_CLICK_SINGLE_Y |
637 LIS3_CLICK_SINGLE_Z,
638 .irq_cfg = LIS3_IRQ1_CLICK | LIS3_IRQ2_CLICK,
639 .wakeup_flags = LIS3_WAKEUP_X_LO | LIS3_WAKEUP_X_HI |
640 LIS3_WAKEUP_Y_LO | LIS3_WAKEUP_Y_HI |
641 LIS3_WAKEUP_Z_LO | LIS3_WAKEUP_Z_HI,
642 .wakeup_thresh = 10,
643 .click_thresh_x = 10,
644 .click_thresh_y = 10,
645 .click_thresh_z = 10,
646};
647
648#define SPI_AK4104 \
649{ \
650 .modalias = "ak4104", \
651 .max_speed_hz = 10000, \
652 .bus_num = 0, \
653 .chip_select = 0, \
654 .controller_data = (void *) GPIO_SPDIF_CS, \
655}
656
657#define SPI_LIS3 \
658{ \
659 .modalias = "lis3lv02d_spi", \
660 .max_speed_hz = 1000000, \
661 .bus_num = 0, \
662 .chip_select = 1, \
663 .controller_data = (void *) GPIO_ACCEL_CS, \
664 .platform_data = &lis3_pdata, \
665 .irq = gpio_to_irq(GPIO_ACCEL_IRQ), \
666}
667
668#define SPI_DAC7512 \
669{ \
670 .modalias = "dac7512", \
671 .max_speed_hz = 1000000, \
672 .bus_num = 0, \
673 .chip_select = 2, \
674 .controller_data = (void *) GPIO_MCLK_DAC_CS, \
675}
676
677static struct spi_board_info connector_spi_devices[] __initdata = {
678 SPI_AK4104,
679 SPI_DAC7512,
680};
681
682static struct spi_board_info speaker_spi_devices[] __initdata = {
683 SPI_DAC7512,
684};
685
686static struct spi_board_info controller_spi_devices[] __initdata = {
687 SPI_LIS3,
688};
689
690/**
691 * MMC for Marvell Libertas 8688 via SDIO
692 */
693
694static int raumfeld_mci_init(struct device *dev, irq_handler_t isr, void *data)
695{
696 gpio_set_value(GPIO_W2W_RESET, 1);
697 gpio_set_value(GPIO_W2W_PDN, 1);
698
699 return 0;
700}
701
702static void raumfeld_mci_exit(struct device *dev, void *data)
703{
704 gpio_set_value(GPIO_W2W_RESET, 0);
705 gpio_set_value(GPIO_W2W_PDN, 0);
706}
707
708static struct pxamci_platform_data raumfeld_mci_platform_data = {
709 .init = raumfeld_mci_init,
710 .exit = raumfeld_mci_exit,
711 .detect_delay = 20,
712 .gpio_card_detect = -1,
713 .gpio_card_ro = -1,
714 .gpio_power = -1,
715};
716
717/*
718 * External power / charge logic
719 */
720
721static int power_supply_init(struct device *dev)
722{
723 return 0;
724}
725
726static void power_supply_exit(struct device *dev)
727{
728}
729
730static int raumfeld_is_ac_online(void)
731{
732 return !gpio_get_value(GPIO_CHARGE_DC_OK);
733}
734
735static int raumfeld_is_usb_online(void)
736{
737 return 0;
738}
739
740static char *raumfeld_power_supplicants[] = { "ds2760-battery.0" };
741
742static struct pda_power_pdata power_supply_info = {
743 .init = power_supply_init,
744 .is_ac_online = raumfeld_is_ac_online,
745 .is_usb_online = raumfeld_is_usb_online,
746 .exit = power_supply_exit,
747 .supplied_to = raumfeld_power_supplicants,
748 .num_supplicants = ARRAY_SIZE(raumfeld_power_supplicants)
749};
750
751static struct resource power_supply_resources[] = {
752 {
753 .name = "ac",
754 .flags = IORESOURCE_IRQ |
755 IORESOURCE_IRQ_HIGHEDGE | IORESOURCE_IRQ_LOWEDGE,
756 .start = GPIO_CHARGE_DC_OK,
757 .end = GPIO_CHARGE_DC_OK,
758 },
759};
760
761static irqreturn_t charge_done_irq(int irq, void *dev_id)
762{
763 struct power_supply *psy;
764
765 psy = power_supply_get_by_name("ds2760-battery.0");
766
767 if (psy)
768 power_supply_set_battery_charged(psy);
769
770 return IRQ_HANDLED;
771}
772
773static struct platform_device raumfeld_power_supply = {
774 .name = "pda-power",
775 .id = -1,
776 .dev = {
777 .platform_data = &power_supply_info,
778 },
779 .resource = power_supply_resources,
780 .num_resources = ARRAY_SIZE(power_supply_resources),
781};
782
783static void __init raumfeld_power_init(void)
784{
785 int ret;
786
787 /* Set PEN2 high to enable maximum charge current */
788 ret = gpio_request(GPIO_CHRG_PEN2, "CHRG_PEN2");
789 if (ret < 0)
790 pr_warning("Unable to request GPIO_CHRG_PEN2\n");
791 else
792 gpio_direction_output(GPIO_CHRG_PEN2, 1);
793
794 ret = gpio_request(GPIO_CHARGE_DC_OK, "CABLE_DC_OK");
795 if (ret < 0)
796 pr_warning("Unable to request GPIO_CHARGE_DC_OK\n");
797
798 ret = gpio_request(GPIO_CHARGE_USB_SUSP, "CHARGE_USB_SUSP");
799 if (ret < 0)
800 pr_warning("Unable to request GPIO_CHARGE_USB_SUSP\n");
801 else
802 gpio_direction_output(GPIO_CHARGE_USB_SUSP, 0);
803
804 power_supply_resources[0].start = gpio_to_irq(GPIO_CHARGE_DC_OK);
805 power_supply_resources[0].end = gpio_to_irq(GPIO_CHARGE_DC_OK);
806
807 ret = request_irq(gpio_to_irq(GPIO_CHARGE_DONE),
808 &charge_done_irq, IORESOURCE_IRQ_LOWEDGE,
809 "charge_done", NULL);
810
811 if (ret < 0)
812 printk(KERN_ERR "%s: unable to register irq %d\n", __func__,
813 GPIO_CHARGE_DONE);
814 else
815 platform_device_register(&raumfeld_power_supply);
816}
817
818/* Fixed regulator for AUDIO_VA, 0-0048 maps to the cs4270 codec device */
819
820static struct regulator_consumer_supply audio_va_consumer_supply =
821 REGULATOR_SUPPLY("va", "0-0048");
822
823struct regulator_init_data audio_va_initdata = {
824 .consumer_supplies = &audio_va_consumer_supply,
825 .num_consumer_supplies = 1,
826 .constraints = {
827 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
828 },
829};
830
831static struct fixed_voltage_config audio_va_config = {
832 .supply_name = "audio_va",
833 .microvolts = 5000000,
834 .gpio = GPIO_AUDIO_VA_ENABLE,
835 .enable_high = 1,
836 .enabled_at_boot = 0,
837 .init_data = &audio_va_initdata,
838};
839
840static struct platform_device audio_va_device = {
841 .name = "reg-fixed-voltage",
842 .id = 0,
843 .dev = {
844 .platform_data = &audio_va_config,
845 },
846};
847
848/* Dummy supplies for Codec's VD/VLC */
849
850static struct regulator_consumer_supply audio_dummy_supplies[] = {
851 REGULATOR_SUPPLY("vd", "0-0048"),
852 REGULATOR_SUPPLY("vlc", "0-0048"),
853};
854
855struct regulator_init_data audio_dummy_initdata = {
856 .consumer_supplies = audio_dummy_supplies,
857 .num_consumer_supplies = ARRAY_SIZE(audio_dummy_supplies),
858 .constraints = {
859 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
860 },
861};
862
863static struct fixed_voltage_config audio_dummy_config = {
864 .supply_name = "audio_vd",
865 .microvolts = 3300000,
866 .gpio = -1,
867 .init_data = &audio_dummy_initdata,
868};
869
870static struct platform_device audio_supply_dummy_device = {
871 .name = "reg-fixed-voltage",
872 .id = 1,
873 .dev = {
874 .platform_data = &audio_dummy_config,
875 },
876};
877
878static struct platform_device *audio_regulator_devices[] = {
879 &audio_va_device,
880 &audio_supply_dummy_device,
881};
882
883/**
884 * Regulator support via MAX8660
885 */
886
887static struct regulator_consumer_supply vcc_mmc_supply =
888 REGULATOR_SUPPLY("vmmc", "pxa2xx-mci.0");
889
890static struct regulator_init_data vcc_mmc_init_data = {
891 .constraints = {
892 .min_uV = 3300000,
893 .max_uV = 3300000,
894 .valid_modes_mask = REGULATOR_MODE_NORMAL,
895 .valid_ops_mask = REGULATOR_CHANGE_STATUS |
896 REGULATOR_CHANGE_VOLTAGE |
897 REGULATOR_CHANGE_MODE,
898 },
899 .consumer_supplies = &vcc_mmc_supply,
900 .num_consumer_supplies = 1,
901};
902
903struct max8660_subdev_data max8660_v6_subdev_data = {
904 .id = MAX8660_V6,
905 .name = "vmmc",
906 .platform_data = &vcc_mmc_init_data,
907};
908
909static struct max8660_platform_data max8660_pdata = {
910 .subdevs = &max8660_v6_subdev_data,
911 .num_subdevs = 1,
912};
913
914/**
915 * I2C devices
916 */
917
918static struct i2c_board_info raumfeld_pwri2c_board_info = {
919 .type = "max8660",
920 .addr = 0x34,
921 .platform_data = &max8660_pdata,
922};
923
924static struct i2c_board_info raumfeld_connector_i2c_board_info __initdata = {
925 .type = "cs4270",
926 .addr = 0x48,
927};
928
929static struct eeti_ts_platform_data eeti_ts_pdata = {
930 .irq_active_high = 1,
931};
932
933static struct i2c_board_info raumfeld_controller_i2c_board_info __initdata = {
934 .type = "eeti_ts",
935 .addr = 0x0a,
936 .irq = gpio_to_irq(GPIO_TOUCH_IRQ),
937 .platform_data = &eeti_ts_pdata,
938};
939
940static struct platform_device *raumfeld_common_devices[] = {
941 &raumfeld_gpio_keys_device,
942 &raumfeld_led_device,
943 &raumfeld_spi_device,
944};
945
946static void __init raumfeld_audio_init(void)
947{
948 int ret;
949
950 ret = gpio_request(GPIO_CODEC_RESET, "cs4270 reset");
951 if (ret < 0)
952 pr_warning("unable to request GPIO_CODEC_RESET\n");
953 else
954 gpio_direction_output(GPIO_CODEC_RESET, 1);
955
956 ret = gpio_request(GPIO_SPDIF_RESET, "ak4104 s/pdif reset");
957 if (ret < 0)
958 pr_warning("unable to request GPIO_SPDIF_RESET\n");
959 else
960 gpio_direction_output(GPIO_SPDIF_RESET, 1);
961
962 ret = gpio_request(GPIO_MCLK_RESET, "MCLK reset");
963 if (ret < 0)
964 pr_warning("unable to request GPIO_MCLK_RESET\n");
965 else
966 gpio_direction_output(GPIO_MCLK_RESET, 1);
967
968 platform_add_devices(ARRAY_AND_SIZE(audio_regulator_devices));
969}
970
971static void __init raumfeld_common_init(void)
972{
973 int ret;
974
975 /* The on/off button polarity has changed after revision 1 */
976 if ((system_rev & 0xff) > 1) {
977 int i;
978
979 for (i = 0; i < ARRAY_SIZE(gpio_keys_button); i++)
980 if (!strcmp(gpio_keys_button[i].desc, "on/off button"))
981 gpio_keys_button[i].active_low = 1;
982 }
983
984 enable_irq_wake(IRQ_WAKEUP0);
985
986 pxa3xx_set_nand_info(&raumfeld_nand_info);
987 pxa3xx_set_i2c_power_info(NULL);
988 pxa_set_ohci_info(&raumfeld_ohci_info);
989 pxa_set_mci_info(&raumfeld_mci_platform_data);
990 pxa_set_i2c_info(NULL);
991 pxa_set_ffuart_info(NULL);
992
993 ret = gpio_request(GPIO_W2W_RESET, "Wi2Wi reset");
994 if (ret < 0)
995 pr_warning("Unable to request GPIO_W2W_RESET\n");
996 else
997 gpio_direction_output(GPIO_W2W_RESET, 0);
998
999 ret = gpio_request(GPIO_W2W_PDN, "Wi2Wi powerup");
1000 if (ret < 0)
1001 pr_warning("Unable to request GPIO_W2W_PDN\n");
1002 else
1003 gpio_direction_output(GPIO_W2W_PDN, 0);
1004
1005 /* this can be used to switch off the device */
1006 ret = gpio_request(GPIO_SHUTDOWN_SUPPLY,
1007 "supply shutdown");
1008 if (ret < 0)
1009 pr_warning("Unable to request GPIO_SHUTDOWN_SUPPLY\n");
1010 else
1011 gpio_direction_output(GPIO_SHUTDOWN_SUPPLY, 0);
1012
1013 platform_add_devices(ARRAY_AND_SIZE(raumfeld_common_devices));
1014 i2c_register_board_info(1, &raumfeld_pwri2c_board_info, 1);
1015}
1016
1017static void __init raumfeld_controller_init(void)
1018{
1019 int ret;
1020
1021 pxa3xx_mfp_config(ARRAY_AND_SIZE(raumfeld_controller_pin_config));
1022 platform_device_register(&rotary_encoder_device);
1023 spi_register_board_info(ARRAY_AND_SIZE(controller_spi_devices));
1024 i2c_register_board_info(0, &raumfeld_controller_i2c_board_info, 1);
1025
1026 ret = gpio_request(GPIO_SHUTDOWN_BATT, "battery shutdown");
1027 if (ret < 0)
1028 pr_warning("Unable to request GPIO_SHUTDOWN_BATT\n");
1029 else
1030 gpio_direction_output(GPIO_SHUTDOWN_BATT, 0);
1031
1032 raumfeld_common_init();
1033 raumfeld_power_init();
1034 raumfeld_lcd_init();
1035 raumfeld_w1_init();
1036}
1037
1038static void __init raumfeld_connector_init(void)
1039{
1040 pxa3xx_mfp_config(ARRAY_AND_SIZE(raumfeld_connector_pin_config));
1041 spi_register_board_info(ARRAY_AND_SIZE(connector_spi_devices));
1042 i2c_register_board_info(0, &raumfeld_connector_i2c_board_info, 1);
1043
1044 platform_device_register(&smc91x_device);
1045
1046 raumfeld_audio_init();
1047 raumfeld_common_init();
1048}
1049
1050static void __init raumfeld_speaker_init(void)
1051{
1052 pxa3xx_mfp_config(ARRAY_AND_SIZE(raumfeld_speaker_pin_config));
1053 spi_register_board_info(ARRAY_AND_SIZE(speaker_spi_devices));
1054 i2c_register_board_info(0, &raumfeld_connector_i2c_board_info, 1);
1055
1056 platform_device_register(&smc91x_device);
1057 platform_device_register(&rotary_encoder_device);
1058
1059 raumfeld_audio_init();
1060 raumfeld_common_init();
1061}
1062
1063/* physical memory regions */
1064#define RAUMFELD_SDRAM_BASE 0xa0000000 /* SDRAM region */
1065
1066#ifdef CONFIG_MACH_RAUMFELD_RC
1067MACHINE_START(RAUMFELD_RC, "Raumfeld Controller")
1068 .phys_io = 0x40000000,
1069 .io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
1070 .boot_params = RAUMFELD_SDRAM_BASE + 0x100,
1071 .init_machine = raumfeld_controller_init,
1072 .map_io = pxa_map_io,
1073 .init_irq = pxa3xx_init_irq,
1074 .timer = &pxa_timer,
1075MACHINE_END
1076#endif
1077
1078#ifdef CONFIG_MACH_RAUMFELD_CONNECTOR
1079MACHINE_START(RAUMFELD_CONNECTOR, "Raumfeld Connector")
1080 .phys_io = 0x40000000,
1081 .io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
1082 .boot_params = RAUMFELD_SDRAM_BASE + 0x100,
1083 .init_machine = raumfeld_connector_init,
1084 .map_io = pxa_map_io,
1085 .init_irq = pxa3xx_init_irq,
1086 .timer = &pxa_timer,
1087MACHINE_END
1088#endif
1089
1090#ifdef CONFIG_MACH_RAUMFELD_SPEAKER
1091MACHINE_START(RAUMFELD_SPEAKER, "Raumfeld Speaker")
1092 .phys_io = 0x40000000,
1093 .io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
1094 .boot_params = RAUMFELD_SDRAM_BASE + 0x100,
1095 .init_machine = raumfeld_speaker_init,
1096 .map_io = pxa_map_io,
1097 .init_irq = pxa3xx_init_irq,
1098 .timer = &pxa_timer,
1099MACHINE_END
1100#endif
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-02 19:52:42 -0500