35572c427fa8449a16cfc35e0300001b5114e9b0
[linux-2.6.git] / arch / arm / mach-pxa / palm27x.c
1 /*
2  * Common code for Palm LD, T5, TX, Z72
3  *
4  * Copyright (C) 2010
5  * Marek Vasut <marek.vasut@gmail.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  */
12
13 #include <linux/platform_device.h>
14 #include <linux/delay.h>
15 #include <linux/irq.h>
16 #include <linux/gpio_keys.h>
17 #include <linux/input.h>
18 #include <linux/pda_power.h>
19 #include <linux/pwm_backlight.h>
20 #include <linux/gpio.h>
21 #include <linux/wm97xx.h>
22 #include <linux/power_supply.h>
23 #include <linux/usb/gpio_vbus.h>
24 #include <linux/regulator/max1586.h>
25
26 #include <asm/mach-types.h>
27 #include <asm/mach/arch.h>
28 #include <asm/mach/map.h>
29
30 #include <mach/pxa27x.h>
31 #include <mach/audio.h>
32 #include <mach/mmc.h>
33 #include <mach/pxafb.h>
34 #include <mach/irda.h>
35 #include <mach/udc.h>
36 #include <mach/palmasoc.h>
37 #include <mach/palm27x.h>
38
39 #include <plat/i2c.h>
40
41 #include "generic.h"
42 #include "devices.h"
43
44 /******************************************************************************
45  * SD/MMC card controller
46  ******************************************************************************/
47 #if defined(CONFIG_MMC_PXA) || defined(CONFIG_MMC_PXA_MODULE)
48 static struct pxamci_platform_data palm27x_mci_platform_data = {
49         .ocr_mask               = MMC_VDD_32_33 | MMC_VDD_33_34,
50         .detect_delay_ms        = 200,
51 };
52
53 void __init palm27x_mmc_init(int detect, int ro, int power,
54                                         int power_inverted)
55 {
56         palm27x_mci_platform_data.gpio_card_detect      = detect;
57         palm27x_mci_platform_data.gpio_card_ro          = ro;
58         palm27x_mci_platform_data.gpio_power            = power;
59         palm27x_mci_platform_data.gpio_power_invert     = power_inverted;
60
61         pxa_set_mci_info(&palm27x_mci_platform_data);
62 }
63 #endif
64
65 /******************************************************************************
66  * Power management - standby
67  ******************************************************************************/
68 #if defined(CONFIG_SUSPEND)
69 void __init palm27x_pm_init(unsigned long str_base)
70 {
71         static const unsigned long resume[] = {
72                 0xe3a00101,     /* mov  r0,     #0x40000000 */
73                 0xe380060f,     /* orr  r0, r0, #0x00f00000 */
74                 0xe590f008,     /* ldr  pc, [r0, #0x08] */
75         };
76
77         /*
78          * Copy the bootloader.
79          * NOTE: PalmZ72 uses a different wakeup method!
80          */
81         memcpy(phys_to_virt(str_base), resume, sizeof(resume));
82 }
83 #endif
84
85 /******************************************************************************
86  * Framebuffer
87  ******************************************************************************/
88 #if defined(CONFIG_FB_PXA) || defined(CONFIG_FB_PXA_MODULE)
89 struct pxafb_mode_info palm_320x480_lcd_mode = {
90         .pixclock       = 57692,
91         .xres           = 320,
92         .yres           = 480,
93         .bpp            = 16,
94
95         .left_margin    = 32,
96         .right_margin   = 1,
97         .upper_margin   = 7,
98         .lower_margin   = 1,
99
100         .hsync_len      = 4,
101         .vsync_len      = 1,
102 };
103
104 struct pxafb_mode_info palm_320x320_lcd_mode = {
105         .pixclock       = 115384,
106         .xres           = 320,
107         .yres           = 320,
108         .bpp            = 16,
109
110         .left_margin    = 27,
111         .right_margin   = 7,
112         .upper_margin   = 7,
113         .lower_margin   = 8,
114
115         .hsync_len      = 6,
116         .vsync_len      = 1,
117 };
118
119 struct pxafb_mode_info palm_320x320_new_lcd_mode = {
120         .pixclock       = 86538,
121         .xres           = 320,
122         .yres           = 320,
123         .bpp            = 16,
124
125         .left_margin    = 20,
126         .right_margin   = 8,
127         .upper_margin   = 8,
128         .lower_margin   = 5,
129
130         .hsync_len      = 4,
131         .vsync_len      = 1,
132 };
133
134 static struct pxafb_mach_info palm27x_lcd_screen = {
135         .num_modes      = 1,
136         .lcd_conn       = LCD_COLOR_TFT_16BPP | LCD_PCLK_EDGE_FALL,
137 };
138
139 static int palm27x_lcd_power;
140 static void palm27x_lcd_ctl(int on, struct fb_var_screeninfo *info)
141 {
142         gpio_set_value(palm27x_lcd_power, on);
143 }
144
145 void __init palm27x_lcd_init(int power, struct pxafb_mode_info *mode)
146 {
147         palm27x_lcd_screen.modes = mode;
148
149         if (gpio_is_valid(power)) {
150                 if (!gpio_request(power, "LCD power")) {
151                         pr_err("Palm27x: failed to claim lcd power gpio!\n");
152                         return;
153                 }
154                 if (!gpio_direction_output(power, 1)) {
155                         pr_err("Palm27x: lcd power configuration failed!\n");
156                         return;
157                 }
158                 palm27x_lcd_power = power;
159                 palm27x_lcd_screen.pxafb_lcd_power = palm27x_lcd_ctl;
160         }
161
162         set_pxa_fb_info(&palm27x_lcd_screen);
163 }
164 #endif
165
166 /******************************************************************************
167  * USB Gadget
168  ******************************************************************************/
169 #if     defined(CONFIG_USB_GADGET_PXA27X) || \
170         defined(CONFIG_USB_GADGET_PXA27X_MODULE)
171 static struct gpio_vbus_mach_info palm27x_udc_info = {
172         .gpio_vbus_inverted     = 1,
173 };
174
175 static struct platform_device palm27x_gpio_vbus = {
176         .name   = "gpio-vbus",
177         .id     = -1,
178         .dev    = {
179                 .platform_data  = &palm27x_udc_info,
180         },
181 };
182
183 void __init palm27x_udc_init(int vbus, int pullup, int vbus_inverted)
184 {
185         palm27x_udc_info.gpio_vbus      = vbus;
186         palm27x_udc_info.gpio_pullup    = pullup;
187
188         palm27x_udc_info.gpio_vbus_inverted = vbus_inverted;
189
190         if (!gpio_request(pullup, "USB Pullup")) {
191                 gpio_direction_output(pullup,
192                         palm27x_udc_info.gpio_vbus_inverted);
193                 gpio_free(pullup);
194         } else
195                 return;
196
197         platform_device_register(&palm27x_gpio_vbus);
198 }
199 #endif
200
201 /******************************************************************************
202  * IrDA
203  ******************************************************************************/
204 #if defined(CONFIG_IRDA) || defined(CONFIG_IRDA_MODULE)
205 static struct pxaficp_platform_data palm27x_ficp_platform_data = {
206         .transceiver_cap        = IR_SIRMODE | IR_OFF,
207 };
208
209 void __init palm27x_irda_init(int pwdn)
210 {
211         palm27x_ficp_platform_data.gpio_pwdown = pwdn;
212         pxa_set_ficp_info(&palm27x_ficp_platform_data);
213 }
214 #endif
215
216 /******************************************************************************
217  * WM97xx audio, battery
218  ******************************************************************************/
219 #if     defined(CONFIG_TOUCHSCREEN_WM97XX) || \
220         defined(CONFIG_TOUCHSCREEN_WM97XX_MODULE)
221 static struct wm97xx_batt_pdata palm27x_batt_pdata = {
222         .batt_aux       = WM97XX_AUX_ID3,
223         .temp_aux       = WM97XX_AUX_ID2,
224         .charge_gpio    = -1,
225         .batt_mult      = 1000,
226         .batt_div       = 414,
227         .temp_mult      = 1,
228         .temp_div       = 1,
229         .batt_tech      = POWER_SUPPLY_TECHNOLOGY_LIPO,
230         .batt_name      = "main-batt",
231 };
232
233 static struct wm97xx_pdata palm27x_wm97xx_pdata = {
234         .batt_pdata     = &palm27x_batt_pdata,
235 };
236
237 static pxa2xx_audio_ops_t palm27x_ac97_pdata = {
238         .codec_pdata    = { &palm27x_wm97xx_pdata, },
239 };
240
241 static struct palm27x_asoc_info palm27x_asoc_pdata = {
242         .jack_gpio      = -1,
243 };
244
245 static struct platform_device palm27x_asoc = {
246         .name = "palm27x-asoc",
247         .id   = -1,
248         .dev  = {
249                 .platform_data = &palm27x_asoc_pdata,
250         },
251 };
252
253 void __init palm27x_ac97_init(int minv, int maxv, int jack, int reset)
254 {
255         palm27x_ac97_pdata.reset_gpio   = reset;
256         palm27x_asoc_pdata.jack_gpio    = jack;
257
258         if (minv < 0 || maxv < 0) {
259                 palm27x_ac97_pdata.codec_pdata[0] = NULL;
260                 pxa_set_ac97_info(&palm27x_ac97_pdata);
261         } else {
262                 palm27x_batt_pdata.min_voltage  = minv,
263                 palm27x_batt_pdata.max_voltage  = maxv,
264
265                 pxa_set_ac97_info(&palm27x_ac97_pdata);
266                 platform_device_register(&palm27x_asoc);
267         }
268 }
269 #endif
270
271 /******************************************************************************
272  * Backlight
273  ******************************************************************************/
274 #if defined(CONFIG_BACKLIGHT_PWM) || defined(CONFIG_BACKLIGHT_PWM_MODULE)
275 static int palm_bl_power;
276 static int palm_lcd_power;
277
278 static int palm27x_backlight_init(struct device *dev)
279 {
280         int ret;
281
282         ret = gpio_request(palm_bl_power, "BL POWER");
283         if (ret)
284                 goto err;
285         ret = gpio_direction_output(palm_bl_power, 0);
286         if (ret)
287                 goto err2;
288
289         if (gpio_is_valid(palm_lcd_power)) {
290                 ret = gpio_request(palm_lcd_power, "LCD POWER");
291                 if (ret)
292                         goto err2;
293                 ret = gpio_direction_output(palm_lcd_power, 0);
294                 if (ret)
295                         goto err3;
296         }
297
298         return 0;
299 err3:
300         gpio_free(palm_lcd_power);
301 err2:
302         gpio_free(palm_bl_power);
303 err:
304         return ret;
305 }
306
307 static int palm27x_backlight_notify(struct device *dev, int brightness)
308 {
309         gpio_set_value(palm_bl_power, brightness);
310         if (gpio_is_valid(palm_lcd_power))
311                 gpio_set_value(palm_lcd_power, brightness);
312         return brightness;
313 }
314
315 static void palm27x_backlight_exit(struct device *dev)
316 {
317         gpio_free(palm_bl_power);
318         if (gpio_is_valid(palm_lcd_power))
319                 gpio_free(palm_lcd_power);
320 }
321
322 static struct platform_pwm_backlight_data palm27x_backlight_data = {
323         .pwm_id         = 0,
324         .max_brightness = 0xfe,
325         .dft_brightness = 0x7e,
326         .pwm_period_ns  = 3500 * 1024,
327         .init           = palm27x_backlight_init,
328         .notify         = palm27x_backlight_notify,
329         .exit           = palm27x_backlight_exit,
330 };
331
332 static struct platform_device palm27x_backlight = {
333         .name   = "pwm-backlight",
334         .dev    = {
335                 .parent         = &pxa27x_device_pwm0.dev,
336                 .platform_data  = &palm27x_backlight_data,
337         },
338 };
339
340 void __init palm27x_pwm_init(int bl, int lcd)
341 {
342         palm_bl_power   = bl;
343         palm_lcd_power  = lcd;
344         platform_device_register(&palm27x_backlight);
345 }
346 #endif
347
348 /******************************************************************************
349  * Power supply
350  ******************************************************************************/
351 #if defined(CONFIG_PDA_POWER) || defined(CONFIG_PDA_POWER_MODULE)
352 static int palm_ac_state;
353 static int palm_usb_state;
354
355 static int palm27x_power_supply_init(struct device *dev)
356 {
357         int ret;
358
359         ret = gpio_request(palm_ac_state, "AC state");
360         if (ret)
361                 goto err1;
362         ret = gpio_direction_input(palm_ac_state);
363         if (ret)
364                 goto err2;
365
366         if (gpio_is_valid(palm_usb_state)) {
367                 ret = gpio_request(palm_usb_state, "USB state");
368                 if (ret)
369                         goto err2;
370                 ret = gpio_direction_input(palm_usb_state);
371                 if (ret)
372                         goto err3;
373         }
374
375         return 0;
376 err3:
377         gpio_free(palm_usb_state);
378 err2:
379         gpio_free(palm_ac_state);
380 err1:
381         return ret;
382 }
383
384 static void palm27x_power_supply_exit(struct device *dev)
385 {
386         gpio_free(palm_usb_state);
387         gpio_free(palm_ac_state);
388 }
389
390 static int palm27x_is_ac_online(void)
391 {
392         return gpio_get_value(palm_ac_state);
393 }
394
395 static int palm27x_is_usb_online(void)
396 {
397         return !gpio_get_value(palm_usb_state);
398 }
399 static char *palm27x_supplicants[] = {
400         "main-battery",
401 };
402
403 static struct pda_power_pdata palm27x_ps_info = {
404         .init                   = palm27x_power_supply_init,
405         .exit                   = palm27x_power_supply_exit,
406         .is_ac_online           = palm27x_is_ac_online,
407         .is_usb_online          = palm27x_is_usb_online,
408         .supplied_to            = palm27x_supplicants,
409         .num_supplicants        = ARRAY_SIZE(palm27x_supplicants),
410 };
411
412 static struct platform_device palm27x_power_supply = {
413         .name = "pda-power",
414         .id   = -1,
415         .dev  = {
416                 .platform_data = &palm27x_ps_info,
417         },
418 };
419
420 void __init palm27x_power_init(int ac, int usb)
421 {
422         palm_ac_state   = ac;
423         palm_usb_state  = usb;
424         platform_device_register(&palm27x_power_supply);
425 }
426 #endif
427
428 /******************************************************************************
429  * Core power regulator
430  ******************************************************************************/
431 #if defined(CONFIG_REGULATOR_MAX1586) || \
432     defined(CONFIG_REGULATOR_MAX1586_MODULE)
433 static struct regulator_consumer_supply palm27x_max1587a_consumers[] = {
434         {
435                 .supply = "vcc_core",
436         }
437 };
438
439 static struct regulator_init_data palm27x_max1587a_v3_info = {
440         .constraints = {
441                 .name           = "vcc_core range",
442                 .min_uV         = 900000,
443                 .max_uV         = 1705000,
444                 .always_on      = 1,
445                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
446         },
447         .consumer_supplies      = palm27x_max1587a_consumers,
448         .num_consumer_supplies  = ARRAY_SIZE(palm27x_max1587a_consumers),
449 };
450
451 static struct max1586_subdev_data palm27x_max1587a_subdevs[] = {
452         {
453                 .name           = "vcc_core",
454                 .id             = MAX1586_V3,
455                 .platform_data  = &palm27x_max1587a_v3_info,
456         }
457 };
458
459 static struct max1586_platform_data palm27x_max1587a_info = {
460         .subdevs     = palm27x_max1587a_subdevs,
461         .num_subdevs = ARRAY_SIZE(palm27x_max1587a_subdevs),
462         .v3_gain     = MAX1586_GAIN_R24_3k32, /* 730..1550 mV */
463 };
464
465 static struct i2c_board_info __initdata palm27x_pi2c_board_info[] = {
466         {
467                 I2C_BOARD_INFO("max1586", 0x14),
468                 .platform_data  = &palm27x_max1587a_info,
469         },
470 };
471
472 static struct i2c_pxa_platform_data palm27x_i2c_power_info = {
473         .use_pio        = 1,
474 };
475
476 void __init palm27x_pmic_init(void)
477 {
478         i2c_register_board_info(1, ARRAY_AND_SIZE(palm27x_pi2c_board_info));
479         pxa27x_set_i2c_power_info(&palm27x_i2c_power_info);
480 }
481 #endif