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