arch/arm/mach-omap2/board-zoom-peripherals.c

   1 /*
   2  * Copyright (C) 2009 Texas Instruments Inc.
   3  *
   4  * Modified from mach-omap2/board-zoom2.c
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/input.h>
  15 #include <linux/input/matrix_keypad.h>
  16 #include <linux/gpio.h>
  17 #include <linux/i2c/twl.h>
  18 #include <linux/regulator/machine.h>
  19 #include <linux/regulator/fixed.h>
  20 #include <linux/wl12xx.h>
  21 #include <linux/mmc/host.h>
  22 #include <linux/platform_data/gpio-omap.h>
  23 #include <linux/platform_data/omap-twl4030.h>
  24 #include <linux/usb/phy.h>
  25 #include <linux/pwm.h>
  26 #include <linux/leds_pwm.h>
  27 #include <linux/pwm_backlight.h>
  28
  29 #include <asm/mach-types.h>
  30 #include <asm/mach/arch.h>
  31 #include <asm/mach/map.h>
  32
  33 #include "common.h"
  34
  35 #include "board-zoom.h"
  36
  37 #include "mux.h"
  38 #include "hsmmc.h"
  39 #include "common-board-devices.h"
  40
  41 #define OMAP_ZOOM_WLAN_PMENA_GPIO       (101)
  42 #define OMAP_ZOOM_TSC2004_IRQ_GPIO      (153)
  43 #define OMAP_ZOOM_WLAN_IRQ_GPIO         (162)
  44
  45 /* Zoom2 has Qwerty keyboard*/
  46 static uint32_t board_keymap[] = {
  47         KEY(0, 0, KEY_E),
  48         KEY(0, 1, KEY_R),
  49         KEY(0, 2, KEY_T),
  50         KEY(0, 3, KEY_HOME),
  51         KEY(0, 6, KEY_I),
  52         KEY(0, 7, KEY_LEFTSHIFT),
  53         KEY(1, 0, KEY_D),
  54         KEY(1, 1, KEY_F),
  55         KEY(1, 2, KEY_G),
  56         KEY(1, 3, KEY_SEND),
  57         KEY(1, 6, KEY_K),
  58         KEY(1, 7, KEY_ENTER),
  59         KEY(2, 0, KEY_X),
  60         KEY(2, 1, KEY_C),
  61         KEY(2, 2, KEY_V),
  62         KEY(2, 3, KEY_END),
  63         KEY(2, 6, KEY_DOT),
  64         KEY(2, 7, KEY_CAPSLOCK),
  65         KEY(3, 0, KEY_Z),
  66         KEY(3, 1, KEY_KPPLUS),
  67         KEY(3, 2, KEY_B),
  68         KEY(3, 3, KEY_F1),
  69         KEY(3, 6, KEY_O),
  70         KEY(3, 7, KEY_SPACE),
  71         KEY(4, 0, KEY_W),
  72         KEY(4, 1, KEY_Y),
  73         KEY(4, 2, KEY_U),
  74         KEY(4, 3, KEY_F2),
  75         KEY(4, 4, KEY_VOLUMEUP),
  76         KEY(4, 6, KEY_L),
  77         KEY(4, 7, KEY_LEFT),
  78         KEY(5, 0, KEY_S),
  79         KEY(5, 1, KEY_H),
  80         KEY(5, 2, KEY_J),
  81         KEY(5, 3, KEY_F3),
  82         KEY(5, 4, KEY_UNKNOWN),
  83         KEY(5, 5, KEY_VOLUMEDOWN),
  84         KEY(5, 6, KEY_M),
  85         KEY(5, 7, KEY_RIGHT),
  86         KEY(6, 0, KEY_Q),
  87         KEY(6, 1, KEY_A),
  88         KEY(6, 2, KEY_N),
  89         KEY(6, 3, KEY_BACKSPACE),
  90         KEY(6, 6, KEY_P),
  91         KEY(6, 7, KEY_UP),
  92         KEY(7, 0, KEY_PROG1),   /*MACRO 1 <User defined> */
  93         KEY(7, 1, KEY_PROG2),   /*MACRO 2 <User defined> */
  94         KEY(7, 2, KEY_PROG3),   /*MACRO 3 <User defined> */
  95         KEY(7, 3, KEY_PROG4),   /*MACRO 4 <User defined> */
  96         KEY(7, 6, KEY_SELECT),
  97         KEY(7, 7, KEY_DOWN)
  98 };
  99
 100 static struct matrix_keymap_data board_map_data = {
 101         .keymap                 = board_keymap,
 102         .keymap_size            = ARRAY_SIZE(board_keymap),
 103 };
 104
 105 static struct twl4030_keypad_data zoom_kp_twl4030_data = {
 106         .keymap_data    = &board_map_data,
 107         .rows           = 8,
 108         .cols           = 8,
 109         .rep            = 1,
 110 };
 111
 112 static struct regulator_consumer_supply zoom_vmmc1_supply[] = {
 113         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
 114 };
 115
 116 static struct regulator_consumer_supply zoom_vsim_supply[] = {
 117         REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.0"),
 118 };
 119
 120 static struct regulator_consumer_supply zoom_vmmc2_supply[] = {
 121         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
 122 };
 123
 124 static struct regulator_consumer_supply zoom_vmmc3_supply[] = {
 125         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.2"),
 126 };
 127
 128 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 129 static struct regulator_init_data zoom_vmmc1 = {
 130         .constraints = {
 131                 .min_uV                 = 1850000,
 132                 .max_uV                 = 3150000,
 133                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 134                                         | REGULATOR_MODE_STANDBY,
 135                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 136                                         | REGULATOR_CHANGE_MODE
 137                                         | REGULATOR_CHANGE_STATUS,
 138         },
 139         .num_consumer_supplies  = ARRAY_SIZE(zoom_vmmc1_supply),
 140         .consumer_supplies      = zoom_vmmc1_supply,
 141 };
 142
 143 /* VMMC2 for MMC2 card */
 144 static struct regulator_init_data zoom_vmmc2 = {
 145         .constraints = {
 146                 .min_uV                 = 1850000,
 147                 .max_uV                 = 1850000,
 148                 .apply_uV               = true,
 149                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 150                                         | REGULATOR_MODE_STANDBY,
 151                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 152                                         | REGULATOR_CHANGE_STATUS,
 153         },
 154         .num_consumer_supplies  = ARRAY_SIZE(zoom_vmmc2_supply),
 155         .consumer_supplies      = zoom_vmmc2_supply,
 156 };
 157
 158 /* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
 159 static struct regulator_init_data zoom_vsim = {
 160         .constraints = {
 161                 .min_uV                 = 1800000,
 162                 .max_uV                 = 3000000,
 163                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 164                                         | REGULATOR_MODE_STANDBY,
 165                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 166                                         | REGULATOR_CHANGE_MODE
 167                                         | REGULATOR_CHANGE_STATUS,
 168         },
 169         .num_consumer_supplies  = ARRAY_SIZE(zoom_vsim_supply),
 170         .consumer_supplies      = zoom_vsim_supply,
 171 };
 172
 173 static struct regulator_init_data zoom_vmmc3 = {
 174         .constraints = {
 175                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 176         },
 177         .num_consumer_supplies  = ARRAY_SIZE(zoom_vmmc3_supply),
 178         .consumer_supplies      = zoom_vmmc3_supply,
 179 };
 180
 181 static struct fixed_voltage_config zoom_vwlan = {
 182         .supply_name            = "vwl1271",
 183         .microvolts             = 1800000, /* 1.8V */
 184         .gpio                   = OMAP_ZOOM_WLAN_PMENA_GPIO,
 185         .startup_delay          = 70000, /* 70msec */
 186         .enable_high            = 1,
 187         .enabled_at_boot        = 0,
 188         .init_data              = &zoom_vmmc3,
 189 };
 190
 191 static struct platform_device omap_vwlan_device = {
 192         .name           = "reg-fixed-voltage",
 193         .id             = 1,
 194         .dev = {
 195                 .platform_data  = &zoom_vwlan,
 196         },
 197 };
 198
 199 static struct pwm_lookup zoom_pwm_lookup[] = {
 200         PWM_LOOKUP("twl-pwm", 0, "leds_pwm", "zoom::keypad"),
 201         PWM_LOOKUP("twl-pwm", 1, "pwm-backlight", "backlight"),
 202 };
 203
 204 static struct led_pwm zoom_pwm_leds[] = {
 205         {
 206                 .name           = "zoom::keypad",
 207                 .max_brightness = 127,
 208                 .pwm_period_ns  = 7812500,
 209         },
 210 };
 211
 212 static struct led_pwm_platform_data zoom_pwm_data = {
 213         .num_leds       = ARRAY_SIZE(zoom_pwm_leds),
 214         .leds           = zoom_pwm_leds,
 215 };
 216
 217 static struct platform_device zoom_leds_pwm = {
 218         .name   = "leds_pwm",
 219         .id     = -1,
 220         .dev    = {
 221                 .platform_data = &zoom_pwm_data,
 222         },
 223 };
 224
 225 static struct platform_pwm_backlight_data zoom_backlight_data = {
 226         .pwm_id = 1,
 227         .max_brightness = 127,
 228         .dft_brightness = 127,
 229         .pwm_period_ns = 7812500,
 230         .enable_gpio = -1,
 231 };
 232
 233 static struct platform_device zoom_backlight_pwm = {
 234         .name   = "pwm-backlight",
 235         .id     = -1,
 236         .dev    = {
 237                 .platform_data = &zoom_backlight_data,
 238         },
 239 };
 240
 241 static struct platform_device *zoom_devices[] __initdata = {
 242         &omap_vwlan_device,
 243         &zoom_leds_pwm,
 244         &zoom_backlight_pwm,
 245 };
 246
 247 static struct wl12xx_platform_data omap_zoom_wlan_data __initdata = {
 248         .board_ref_clock = WL12XX_REFCLOCK_26, /* 26 MHz */
 249 };
 250
 251 static struct omap2_hsmmc_info mmc[] = {
 252         {
 253                 .name           = "external",
 254                 .mmc            = 1,
 255                 .caps           = MMC_CAP_4_BIT_DATA,
 256                 .gpio_wp        = -EINVAL,
 257                 .power_saving   = true,
 258                 .deferred       = true,
 259         },
 260         {
 261                 .name           = "internal",
 262                 .mmc            = 2,
 263                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
 264                 .gpio_cd        = -EINVAL,
 265                 .gpio_wp        = -EINVAL,
 266                 .nonremovable   = true,
 267                 .power_saving   = true,
 268         },
 269         {
 270                 .name           = "wl1271",
 271                 .mmc            = 3,
 272                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD,
 273                 .gpio_wp        = -EINVAL,
 274                 .gpio_cd        = -EINVAL,
 275                 .nonremovable   = true,
 276         },
 277         {}      /* Terminator */
 278 };
 279
 280 static struct omap_tw4030_pdata omap_twl4030_audio_data = {
 281         .voice_connected = true,
 282         .custom_routing = true,
 283
 284         .has_hs         = OMAP_TWL4030_LEFT | OMAP_TWL4030_RIGHT,
 285         .has_hf         = OMAP_TWL4030_LEFT | OMAP_TWL4030_RIGHT,
 286
 287         .has_mainmic    = true,
 288         .has_submic     = true,
 289         .has_hsmic      = true,
 290         .has_linein     = OMAP_TWL4030_LEFT | OMAP_TWL4030_RIGHT,
 291 };
 292
 293 static int zoom_twl_gpio_setup(struct device *dev,
 294                 unsigned gpio, unsigned ngpio)
 295 {
 296         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
 297         mmc[0].gpio_cd = gpio + 0;
 298         omap_hsmmc_late_init(mmc);
 299
 300         /* Audio setup */
 301         omap_twl4030_audio_data.jack_detect = gpio + 2;
 302         omap_twl4030_audio_init("Zoom2", &omap_twl4030_audio_data);
 303
 304         return 0;
 305 }
 306
 307 static struct twl4030_gpio_platform_data zoom_gpio_data = {
 308         .setup          = zoom_twl_gpio_setup,
 309 };
 310
 311 static struct twl4030_platform_data zoom_twldata = {
 312         /* platform_data for children goes here */
 313         .gpio           = &zoom_gpio_data,
 314         .keypad         = &zoom_kp_twl4030_data,
 315         .vmmc1          = &zoom_vmmc1,
 316         .vmmc2          = &zoom_vmmc2,
 317         .vsim           = &zoom_vsim,
 318 };
 319
 320 static int __init omap_i2c_init(void)
 321 {
 322         omap3_pmic_get_config(&zoom_twldata,
 323                         TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_BCI |
 324                         TWL_COMMON_PDATA_MADC | TWL_COMMON_PDATA_AUDIO,
 325                         TWL_COMMON_REGULATOR_VDAC | TWL_COMMON_REGULATOR_VPLL2);
 326
 327         if (machine_is_omap_zoom2())
 328                 zoom_twldata.audio->codec->ramp_delay_value = 3; /* 161 ms */
 329
 330         omap_pmic_init(1, 2400, "twl5030", 7 + OMAP_INTC_START, &zoom_twldata);
 331         omap_register_i2c_bus(2, 400, NULL, 0);
 332         omap_register_i2c_bus(3, 400, NULL, 0);
 333         return 0;
 334 }
 335
 336 static void enable_board_wakeup_source(void)
 337 {
 338         /* T2 interrupt line (keypad) */
 339         omap_mux_init_signal("sys_nirq",
 340                 OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
 341 }
 342
 343 void __init zoom_peripherals_init(void)
 344 {
 345         int ret;
 346
 347         omap_zoom_wlan_data.irq = gpio_to_irq(OMAP_ZOOM_WLAN_IRQ_GPIO);
 348         ret = wl12xx_set_platform_data(&omap_zoom_wlan_data);
 349
 350         if (ret)
 351                 pr_err("error setting wl12xx data: %d\n", ret);
 352
 353         omap_hsmmc_init(mmc);
 354         omap_i2c_init();
 355         pwm_add_table(zoom_pwm_lookup, ARRAY_SIZE(zoom_pwm_lookup));
 356         platform_add_devices(zoom_devices, ARRAY_SIZE(zoom_devices));
 357         usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
 358         usb_musb_init(NULL);
 359         enable_board_wakeup_source();
 360         omap_serial_init();
 361 }