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
  23 #include <asm/mach-types.h>
  24 #include <asm/mach/arch.h>
  25 #include <asm/mach/map.h>
  26
  27 #include <plat/common.h>
  28 #include <plat/usb.h>
  29
  30 #include <mach/board-zoom.h>
  31
  32 #include "mux.h"
  33 #include "hsmmc.h"
  34 #include "common-board-devices.h"
  35
  36 #define OMAP_ZOOM_WLAN_PMENA_GPIO       (101)
  37 #define OMAP_ZOOM_WLAN_IRQ_GPIO         (162)
  38
  39 #define LCD_PANEL_ENABLE_GPIO           (7 + OMAP_MAX_GPIO_LINES)
  40
  41 /* Zoom2 has Qwerty keyboard*/
  42 static uint32_t board_keymap[] = {
  43         KEY(0, 0, KEY_E),
  44         KEY(0, 1, KEY_R),
  45         KEY(0, 2, KEY_T),
  46         KEY(0, 3, KEY_HOME),
  47         KEY(0, 6, KEY_I),
  48         KEY(0, 7, KEY_LEFTSHIFT),
  49         KEY(1, 0, KEY_D),
  50         KEY(1, 1, KEY_F),
  51         KEY(1, 2, KEY_G),
  52         KEY(1, 3, KEY_SEND),
  53         KEY(1, 6, KEY_K),
  54         KEY(1, 7, KEY_ENTER),
  55         KEY(2, 0, KEY_X),
  56         KEY(2, 1, KEY_C),
  57         KEY(2, 2, KEY_V),
  58         KEY(2, 3, KEY_END),
  59         KEY(2, 6, KEY_DOT),
  60         KEY(2, 7, KEY_CAPSLOCK),
  61         KEY(3, 0, KEY_Z),
  62         KEY(3, 1, KEY_KPPLUS),
  63         KEY(3, 2, KEY_B),
  64         KEY(3, 3, KEY_F1),
  65         KEY(3, 6, KEY_O),
  66         KEY(3, 7, KEY_SPACE),
  67         KEY(4, 0, KEY_W),
  68         KEY(4, 1, KEY_Y),
  69         KEY(4, 2, KEY_U),
  70         KEY(4, 3, KEY_F2),
  71         KEY(4, 4, KEY_VOLUMEUP),
  72         KEY(4, 6, KEY_L),
  73         KEY(4, 7, KEY_LEFT),
  74         KEY(5, 0, KEY_S),
  75         KEY(5, 1, KEY_H),
  76         KEY(5, 2, KEY_J),
  77         KEY(5, 3, KEY_F3),
  78         KEY(5, 4, KEY_UNKNOWN),
  79         KEY(5, 5, KEY_VOLUMEDOWN),
  80         KEY(5, 6, KEY_M),
  81         KEY(5, 7, KEY_RIGHT),
  82         KEY(6, 0, KEY_Q),
  83         KEY(6, 1, KEY_A),
  84         KEY(6, 2, KEY_N),
  85         KEY(6, 3, KEY_BACKSPACE),
  86         KEY(6, 6, KEY_P),
  87         KEY(6, 7, KEY_UP),
  88         KEY(7, 0, KEY_PROG1),   /*MACRO 1 <User defined> */
  89         KEY(7, 1, KEY_PROG2),   /*MACRO 2 <User defined> */
  90         KEY(7, 2, KEY_PROG3),   /*MACRO 3 <User defined> */
  91         KEY(7, 3, KEY_PROG4),   /*MACRO 4 <User defined> */
  92         KEY(7, 6, KEY_SELECT),
  93         KEY(7, 7, KEY_DOWN)
  94 };
  95
  96 static struct matrix_keymap_data board_map_data = {
  97         .keymap                 = board_keymap,
  98         .keymap_size            = ARRAY_SIZE(board_keymap),
  99 };
 100
 101 static struct twl4030_keypad_data zoom_kp_twl4030_data = {
 102         .keymap_data    = &board_map_data,
 103         .rows           = 8,
 104         .cols           = 8,
 105         .rep            = 1,
 106 };
 107
 108 static struct regulator_consumer_supply zoom_vmmc1_supply[] = {
 109         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
 110 };
 111
 112 static struct regulator_consumer_supply zoom_vsim_supply[] = {
 113         REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.0"),
 114 };
 115
 116 static struct regulator_consumer_supply zoom_vmmc2_supply[] = {
 117         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
 118 };
 119
 120 static struct regulator_consumer_supply zoom_vmmc3_supply[] = {
 121         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.2"),
 122 };
 123
 124 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 125 static struct regulator_init_data zoom_vmmc1 = {
 126         .constraints = {
 127                 .min_uV                 = 1850000,
 128                 .max_uV                 = 3150000,
 129                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 130                                         | REGULATOR_MODE_STANDBY,
 131                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 132                                         | REGULATOR_CHANGE_MODE
 133                                         | REGULATOR_CHANGE_STATUS,
 134         },
 135         .num_consumer_supplies  = ARRAY_SIZE(zoom_vmmc1_supply),
 136         .consumer_supplies      = zoom_vmmc1_supply,
 137 };
 138
 139 /* VMMC2 for MMC2 card */
 140 static struct regulator_init_data zoom_vmmc2 = {
 141         .constraints = {
 142                 .min_uV                 = 1850000,
 143                 .max_uV                 = 1850000,
 144                 .apply_uV               = true,
 145                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 146                                         | REGULATOR_MODE_STANDBY,
 147                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 148                                         | REGULATOR_CHANGE_STATUS,
 149         },
 150         .num_consumer_supplies  = ARRAY_SIZE(zoom_vmmc2_supply),
 151         .consumer_supplies      = zoom_vmmc2_supply,
 152 };
 153
 154 /* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
 155 static struct regulator_init_data zoom_vsim = {
 156         .constraints = {
 157                 .min_uV                 = 1800000,
 158                 .max_uV                 = 3000000,
 159                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 160                                         | REGULATOR_MODE_STANDBY,
 161                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 162                                         | REGULATOR_CHANGE_MODE
 163                                         | REGULATOR_CHANGE_STATUS,
 164         },
 165         .num_consumer_supplies  = ARRAY_SIZE(zoom_vsim_supply),
 166         .consumer_supplies      = zoom_vsim_supply,
 167 };
 168
 169 static struct regulator_init_data zoom_vmmc3 = {
 170         .constraints = {
 171                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 172         },
 173         .num_consumer_supplies  = ARRAY_SIZE(zoom_vmmc3_supply),
 174         .consumer_supplies      = zoom_vmmc3_supply,
 175 };
 176
 177 static struct fixed_voltage_config zoom_vwlan = {
 178         .supply_name            = "vwl1271",
 179         .microvolts             = 1800000, /* 1.8V */
 180         .gpio                   = OMAP_ZOOM_WLAN_PMENA_GPIO,
 181         .startup_delay          = 70000, /* 70msec */
 182         .enable_high            = 1,
 183         .enabled_at_boot        = 0,
 184         .init_data              = &zoom_vmmc3,
 185 };
 186
 187 static struct platform_device omap_vwlan_device = {
 188         .name           = "reg-fixed-voltage",
 189         .id             = 1,
 190         .dev = {
 191                 .platform_data  = &zoom_vwlan,
 192         },
 193 };
 194
 195 static struct wl12xx_platform_data omap_zoom_wlan_data __initdata = {
 196         .irq = OMAP_GPIO_IRQ(OMAP_ZOOM_WLAN_IRQ_GPIO),
 197         /* ZOOM ref clock is 26 MHz */
 198         .board_ref_clock = 1,
 199 };
 200
 201 static struct omap2_hsmmc_info mmc[] = {
 202         {
 203                 .name           = "external",
 204                 .mmc            = 1,
 205                 .caps           = MMC_CAP_4_BIT_DATA,
 206                 .gpio_wp        = -EINVAL,
 207                 .power_saving   = true,
 208         },
 209         {
 210                 .name           = "internal",
 211                 .mmc            = 2,
 212                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
 213                 .gpio_cd        = -EINVAL,
 214                 .gpio_wp        = -EINVAL,
 215                 .nonremovable   = true,
 216                 .power_saving   = true,
 217         },
 218         {
 219                 .name           = "wl1271",
 220                 .mmc            = 3,
 221                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD,
 222                 .gpio_wp        = -EINVAL,
 223                 .gpio_cd        = -EINVAL,
 224                 .nonremovable   = true,
 225         },
 226         {}      /* Terminator */
 227 };
 228
 229 static struct regulator_consumer_supply zoom_vpll2_supplies[] = {
 230         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
 231         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
 232 };
 233
 234 static struct regulator_consumer_supply zoom_vdda_dac_supply[] = {
 235         REGULATOR_SUPPLY("vdda_dac", "omapdss_venc"),
 236 };
 237
 238 static struct regulator_init_data zoom_vpll2 = {
 239         .constraints = {
 240                 .min_uV                 = 1800000,
 241                 .max_uV                 = 1800000,
 242                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 243                                         | REGULATOR_MODE_STANDBY,
 244                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 245                                         | REGULATOR_CHANGE_STATUS,
 246         },
 247         .num_consumer_supplies          = ARRAY_SIZE(zoom_vpll2_supplies),
 248         .consumer_supplies              = zoom_vpll2_supplies,
 249 };
 250
 251 static struct regulator_init_data zoom_vdac = {
 252         .constraints = {
 253                 .min_uV                 = 1800000,
 254                 .max_uV                 = 1800000,
 255                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 256                                         | REGULATOR_MODE_STANDBY,
 257                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 258                                         | REGULATOR_CHANGE_STATUS,
 259         },
 260         .num_consumer_supplies          = ARRAY_SIZE(zoom_vdda_dac_supply),
 261         .consumer_supplies              = zoom_vdda_dac_supply,
 262 };
 263
 264 static int zoom_twl_gpio_setup(struct device *dev,
 265                 unsigned gpio, unsigned ngpio)
 266 {
 267         int ret;
 268
 269         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
 270         mmc[0].gpio_cd = gpio + 0;
 271         omap2_hsmmc_init(mmc);
 272
 273         ret = gpio_request_one(LCD_PANEL_ENABLE_GPIO, GPIOF_OUT_INIT_LOW,
 274                                "lcd enable");
 275         if (ret)
 276                 pr_err("Failed to get LCD_PANEL_ENABLE_GPIO (gpio%d).\n",
 277                                 LCD_PANEL_ENABLE_GPIO);
 278
 279         return ret;
 280 }
 281
 282 /* EXTMUTE callback function */
 283 static void zoom2_set_hs_extmute(int mute)
 284 {
 285         gpio_set_value(ZOOM2_HEADSET_EXTMUTE_GPIO, mute);
 286 }
 287
 288 static int zoom_batt_table[] = {
 289 /* 0 C*/
 290 30800, 29500, 28300, 27100,
 291 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 292 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 293 11600, 11200, 10800, 10400, 10000, 9630,  9280,  8950,  8620,  8310,
 294 8020,  7730,  7460,  7200,  6950,  6710,  6470,  6250,  6040,  5830,
 295 5640,  5450,  5260,  5090,  4920,  4760,  4600,  4450,  4310,  4170,
 296 4040,  3910,  3790,  3670,  3550
 297 };
 298
 299 static struct twl4030_bci_platform_data zoom_bci_data = {
 300         .battery_tmp_tbl        = zoom_batt_table,
 301         .tblsize                = ARRAY_SIZE(zoom_batt_table),
 302 };
 303
 304 static struct twl4030_usb_data zoom_usb_data = {
 305         .usb_mode       = T2_USB_MODE_ULPI,
 306 };
 307
 308 static struct twl4030_gpio_platform_data zoom_gpio_data = {
 309         .gpio_base      = OMAP_MAX_GPIO_LINES,
 310         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 311         .irq_end        = TWL4030_GPIO_IRQ_END,
 312         .setup          = zoom_twl_gpio_setup,
 313 };
 314
 315 static struct twl4030_madc_platform_data zoom_madc_data = {
 316         .irq_line       = 1,
 317 };
 318
 319 static struct twl4030_codec_audio_data zoom_audio_data;
 320
 321 static struct twl4030_codec_data zoom_codec_data = {
 322         .audio_mclk = 26000000,
 323         .audio = &zoom_audio_data,
 324 };
 325
 326 static struct twl4030_platform_data zoom_twldata = {
 327         .irq_base       = TWL4030_IRQ_BASE,
 328         .irq_end        = TWL4030_IRQ_END,
 329
 330         /* platform_data for children goes here */
 331         .bci            = &zoom_bci_data,
 332         .madc           = &zoom_madc_data,
 333         .usb            = &zoom_usb_data,
 334         .gpio           = &zoom_gpio_data,
 335         .keypad         = &zoom_kp_twl4030_data,
 336         .codec          = &zoom_codec_data,
 337         .vmmc1          = &zoom_vmmc1,
 338         .vmmc2          = &zoom_vmmc2,
 339         .vsim           = &zoom_vsim,
 340         .vpll2          = &zoom_vpll2,
 341         .vdac           = &zoom_vdac,
 342 };
 343
 344 static int __init omap_i2c_init(void)
 345 {
 346         if (machine_is_omap_zoom2()) {
 347                 zoom_audio_data.ramp_delay_value = 3;   /* 161 ms */
 348                 zoom_audio_data.hs_extmute = 1;
 349                 zoom_audio_data.set_hs_extmute = zoom2_set_hs_extmute;
 350         }
 351         omap_pmic_init(1, 2400, "twl5030", INT_34XX_SYS_NIRQ, &zoom_twldata);
 352         omap_register_i2c_bus(2, 400, NULL, 0);
 353         omap_register_i2c_bus(3, 400, NULL, 0);
 354         return 0;
 355 }
 356
 357 static void enable_board_wakeup_source(void)
 358 {
 359         /* T2 interrupt line (keypad) */
 360         omap_mux_init_signal("sys_nirq",
 361                 OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
 362 }
 363
 364 void __init zoom_peripherals_init(void)
 365 {
 366         if (wl12xx_set_platform_data(&omap_zoom_wlan_data))
 367                 pr_err("error setting wl12xx data\n");
 368
 369         omap_i2c_init();
 370         platform_device_register(&omap_vwlan_device);
 371         usb_musb_init(NULL);
 372         enable_board_wakeup_source();
 373         omap_serial_init();
 374 }