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         .supply         = "vmmc",
 110 };
 111
 112 static struct regulator_consumer_supply zoom_vsim_supply = {
 113         .supply         = "vmmc_aux",
 114 };
 115
 116 static struct regulator_consumer_supply zoom_vmmc2_supply = {
 117         .supply         = "vmmc",
 118 };
 119
 120 static struct regulator_consumer_supply zoom_vmmc3_supply = {
 121         .supply         = "vmmc",
 122         .dev_name       = "omap_hsmmc.2",
 123 };
 124
 125 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 126 static struct regulator_init_data zoom_vmmc1 = {
 127         .constraints = {
 128                 .min_uV                 = 1850000,
 129                 .max_uV                 = 3150000,
 130                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 131                                         | REGULATOR_MODE_STANDBY,
 132                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 133                                         | REGULATOR_CHANGE_MODE
 134                                         | REGULATOR_CHANGE_STATUS,
 135         },
 136         .num_consumer_supplies  = 1,
 137         .consumer_supplies      = &zoom_vmmc1_supply,
 138 };
 139
 140 /* VMMC2 for MMC2 card */
 141 static struct regulator_init_data zoom_vmmc2 = {
 142         .constraints = {
 143                 .min_uV                 = 1850000,
 144                 .max_uV                 = 1850000,
 145                 .apply_uV               = true,
 146                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 147                                         | REGULATOR_MODE_STANDBY,
 148                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 149                                         | REGULATOR_CHANGE_STATUS,
 150         },
 151         .num_consumer_supplies  = 1,
 152         .consumer_supplies      = &zoom_vmmc2_supply,
 153 };
 154
 155 /* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
 156 static struct regulator_init_data zoom_vsim = {
 157         .constraints = {
 158                 .min_uV                 = 1800000,
 159                 .max_uV                 = 3000000,
 160                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 161                                         | REGULATOR_MODE_STANDBY,
 162                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 163                                         | REGULATOR_CHANGE_MODE
 164                                         | REGULATOR_CHANGE_STATUS,
 165         },
 166         .num_consumer_supplies  = 1,
 167         .consumer_supplies      = &zoom_vsim_supply,
 168 };
 169
 170 static struct regulator_init_data zoom_vmmc3 = {
 171         .constraints = {
 172                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 173         },
 174         .num_consumer_supplies  = 1,
 175         .consumer_supplies = &zoom_vmmc3_supply,
 176 };
 177
 178 static struct fixed_voltage_config zoom_vwlan = {
 179         .supply_name            = "vwl1271",
 180         .microvolts             = 1800000, /* 1.8V */
 181         .gpio                   = OMAP_ZOOM_WLAN_PMENA_GPIO,
 182         .startup_delay          = 70000, /* 70msec */
 183         .enable_high            = 1,
 184         .enabled_at_boot        = 0,
 185         .init_data              = &zoom_vmmc3,
 186 };
 187
 188 static struct platform_device omap_vwlan_device = {
 189         .name           = "reg-fixed-voltage",
 190         .id             = 1,
 191         .dev = {
 192                 .platform_data  = &zoom_vwlan,
 193         },
 194 };
 195
 196 static struct wl12xx_platform_data omap_zoom_wlan_data __initdata = {
 197         .irq = OMAP_GPIO_IRQ(OMAP_ZOOM_WLAN_IRQ_GPIO),
 198         /* ZOOM ref clock is 26 MHz */
 199         .board_ref_clock = 1,
 200 };
 201
 202 static struct omap2_hsmmc_info mmc[] = {
 203         {
 204                 .name           = "external",
 205                 .mmc            = 1,
 206                 .caps           = MMC_CAP_4_BIT_DATA,
 207                 .gpio_wp        = -EINVAL,
 208                 .power_saving   = true,
 209         },
 210         {
 211                 .name           = "internal",
 212                 .mmc            = 2,
 213                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
 214                 .gpio_cd        = -EINVAL,
 215                 .gpio_wp        = -EINVAL,
 216                 .nonremovable   = true,
 217                 .power_saving   = true,
 218         },
 219         {
 220                 .name           = "wl1271",
 221                 .mmc            = 3,
 222                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD,
 223                 .gpio_wp        = -EINVAL,
 224                 .gpio_cd        = -EINVAL,
 225                 .nonremovable   = true,
 226         },
 227         {}      /* Terminator */
 228 };
 229
 230 static struct regulator_consumer_supply zoom_vpll2_supplies[] = {
 231         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
 232         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
 233 };
 234
 235 static struct regulator_consumer_supply zoom_vdda_dac_supply =
 236         REGULATOR_SUPPLY("vdda_dac", "omapdss_venc");
 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          = 1,
 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         /* link regulators to MMC adapters ... we "know" the
 274          * regulators will be set up only *after* we return.
 275         */
 276         zoom_vmmc1_supply.dev = mmc[0].dev;
 277         zoom_vsim_supply.dev = mmc[0].dev;
 278         zoom_vmmc2_supply.dev = mmc[1].dev;
 279
 280         ret = gpio_request(LCD_PANEL_ENABLE_GPIO, "lcd enable");
 281         if (ret) {
 282                 pr_err("Failed to get LCD_PANEL_ENABLE_GPIO (gpio%d).\n",
 283                                 LCD_PANEL_ENABLE_GPIO);
 284                 return ret;
 285         }
 286         gpio_direction_output(LCD_PANEL_ENABLE_GPIO, 0);
 287
 288         return ret;
 289 }
 290
 291 /* EXTMUTE callback function */
 292 static void zoom2_set_hs_extmute(int mute)
 293 {
 294         gpio_set_value(ZOOM2_HEADSET_EXTMUTE_GPIO, mute);
 295 }
 296
 297 static int zoom_batt_table[] = {
 298 /* 0 C*/
 299 30800, 29500, 28300, 27100,
 300 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 301 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 302 11600, 11200, 10800, 10400, 10000, 9630,  9280,  8950,  8620,  8310,
 303 8020,  7730,  7460,  7200,  6950,  6710,  6470,  6250,  6040,  5830,
 304 5640,  5450,  5260,  5090,  4920,  4760,  4600,  4450,  4310,  4170,
 305 4040,  3910,  3790,  3670,  3550
 306 };
 307
 308 static struct twl4030_bci_platform_data zoom_bci_data = {
 309         .battery_tmp_tbl        = zoom_batt_table,
 310         .tblsize                = ARRAY_SIZE(zoom_batt_table),
 311 };
 312
 313 static struct twl4030_usb_data zoom_usb_data = {
 314         .usb_mode       = T2_USB_MODE_ULPI,
 315 };
 316
 317 static struct twl4030_gpio_platform_data zoom_gpio_data = {
 318         .gpio_base      = OMAP_MAX_GPIO_LINES,
 319         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 320         .irq_end        = TWL4030_GPIO_IRQ_END,
 321         .setup          = zoom_twl_gpio_setup,
 322 };
 323
 324 static struct twl4030_madc_platform_data zoom_madc_data = {
 325         .irq_line       = 1,
 326 };
 327
 328 static struct twl4030_codec_audio_data zoom_audio_data;
 329
 330 static struct twl4030_codec_data zoom_codec_data = {
 331         .audio_mclk = 26000000,
 332         .audio = &zoom_audio_data,
 333 };
 334
 335 static struct twl4030_platform_data zoom_twldata = {
 336         .irq_base       = TWL4030_IRQ_BASE,
 337         .irq_end        = TWL4030_IRQ_END,
 338
 339         /* platform_data for children goes here */
 340         .bci            = &zoom_bci_data,
 341         .madc           = &zoom_madc_data,
 342         .usb            = &zoom_usb_data,
 343         .gpio           = &zoom_gpio_data,
 344         .keypad         = &zoom_kp_twl4030_data,
 345         .codec          = &zoom_codec_data,
 346         .vmmc1          = &zoom_vmmc1,
 347         .vmmc2          = &zoom_vmmc2,
 348         .vsim           = &zoom_vsim,
 349         .vpll2          = &zoom_vpll2,
 350         .vdac           = &zoom_vdac,
 351 };
 352
 353 static int __init omap_i2c_init(void)
 354 {
 355         if (machine_is_omap_zoom2()) {
 356                 zoom_audio_data.ramp_delay_value = 3;   /* 161 ms */
 357                 zoom_audio_data.hs_extmute = 1;
 358                 zoom_audio_data.set_hs_extmute = zoom2_set_hs_extmute;
 359         }
 360         omap_pmic_init(1, 2400, "twl5030", INT_34XX_SYS_NIRQ, &zoom_twldata);
 361         omap_register_i2c_bus(2, 400, NULL, 0);
 362         omap_register_i2c_bus(3, 400, NULL, 0);
 363         return 0;
 364 }
 365
 366 static struct omap_musb_board_data musb_board_data = {
 367         .interface_type         = MUSB_INTERFACE_ULPI,
 368         .mode                   = MUSB_OTG,
 369         .power                  = 100,
 370 };
 371
 372 static void enable_board_wakeup_source(void)
 373 {
 374         /* T2 interrupt line (keypad) */
 375         omap_mux_init_signal("sys_nirq",
 376                 OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
 377 }
 378
 379 void __init zoom_peripherals_init(void)
 380 {
 381         if (wl12xx_set_platform_data(&omap_zoom_wlan_data))
 382                 pr_err("error setting wl12xx data\n");
 383
 384         omap_i2c_init();
 385         platform_device_register(&omap_vwlan_device);
 386         usb_musb_init(&musb_board_data);
 387         enable_board_wakeup_source();
 388         omap_serial_init();
 389 }