~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm/mach-pxa/raumfeld.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp