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
  35 #define OMAP_ZOOM_WLAN_PMENA_GPIO       (101)
  36 #define OMAP_ZOOM_WLAN_IRQ_GPIO         (162)
  37
  38 #define LCD_PANEL_ENABLE_GPIO           (7 + OMAP_MAX_GPIO_LINES)
  39
  40 /* Zoom2 has Qwerty keyboard*/
  41 static uint32_t board_keymap[] = {
  42         KEY(0, 0, KEY_E),
  43         KEY(0, 1, KEY_R),
  44         KEY(0, 2, KEY_T),
  45         KEY(0, 3, KEY_HOME),
  46         KEY(0, 6, KEY_I),
  47         KEY(0, 7, KEY_LEFTSHIFT),
  48         KEY(1, 0, KEY_D),
  49         KEY(1, 1, KEY_F),
  50         KEY(1, 2, KEY_G),
  51         KEY(1, 3, KEY_SEND),
  52         KEY(1, 6, KEY_K),
  53         KEY(1, 7, KEY_ENTER),
  54         KEY(2, 0, KEY_X),
  55         KEY(2, 1, KEY_C),
  56         KEY(2, 2, KEY_V),
  57         KEY(2, 3, KEY_END),
  58         KEY(2, 6, KEY_DOT),
  59         KEY(2, 7, KEY_CAPSLOCK),
  60         KEY(3, 0, KEY_Z),
  61         KEY(3, 1, KEY_KPPLUS),
  62         KEY(3, 2, KEY_B),
  63         KEY(3, 3, KEY_F1),
  64         KEY(3, 6, KEY_O),
  65         KEY(3, 7, KEY_SPACE),
  66         KEY(4, 0, KEY_W),
  67         KEY(4, 1, KEY_Y),
  68         KEY(4, 2, KEY_U),
  69         KEY(4, 3, KEY_F2),
  70         KEY(4, 4, KEY_VOLUMEUP),
  71         KEY(4, 6, KEY_L),
  72         KEY(4, 7, KEY_LEFT),
  73         KEY(5, 0, KEY_S),
  74         KEY(5, 1, KEY_H),
  75         KEY(5, 2, KEY_J),
  76         KEY(5, 3, KEY_F3),
  77         KEY(5, 4, KEY_UNKNOWN),
  78         KEY(5, 5, KEY_VOLUMEDOWN),
  79         KEY(5, 6, KEY_M),
  80         KEY(5, 7, KEY_RIGHT),
  81         KEY(6, 0, KEY_Q),
  82         KEY(6, 1, KEY_A),
  83         KEY(6, 2, KEY_N),
  84         KEY(6, 3, KEY_BACKSPACE),
  85         KEY(6, 6, KEY_P),
  86         KEY(6, 7, KEY_UP),
  87         KEY(7, 0, KEY_PROG1),   /*MACRO 1 <User defined> */
  88         KEY(7, 1, KEY_PROG2),   /*MACRO 2 <User defined> */
  89         KEY(7, 2, KEY_PROG3),   /*MACRO 3 <User defined> */
  90         KEY(7, 3, KEY_PROG4),   /*MACRO 4 <User defined> */
  91         KEY(7, 6, KEY_SELECT),
  92         KEY(7, 7, KEY_DOWN)
  93 };
  94
  95 static struct matrix_keymap_data board_map_data = {
  96         .keymap                 = board_keymap,
  97         .keymap_size            = ARRAY_SIZE(board_keymap),
  98 };
  99
 100 static struct twl4030_keypad_data zoom_kp_twl4030_data = {
 101         .keymap_data    = &board_map_data,
 102         .rows           = 8,
 103         .cols           = 8,
 104         .rep            = 1,
 105 };
 106
 107 static struct regulator_consumer_supply zoom_vmmc1_supply = {
 108         .supply         = "vmmc",
 109 };
 110
 111 static struct regulator_consumer_supply zoom_vsim_supply = {
 112         .supply         = "vmmc_aux",
 113 };
 114
 115 static struct regulator_consumer_supply zoom_vmmc2_supply = {
 116         .supply         = "vmmc",
 117 };
 118
 119 static struct regulator_consumer_supply zoom_vmmc3_supply = {
 120         .supply         = "vmmc",
 121         .dev_name       = "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  = 1,
 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  = 1,
 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  = 1,
 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  = 1,
 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_supply =
 230         REGULATOR_SUPPLY("vdds_dsi", "omapdss");
 231
 232 static struct regulator_consumer_supply zoom_vdda_dac_supply =
 233         REGULATOR_SUPPLY("vdda_dac", "omapdss");
 234
 235 static struct regulator_init_data zoom_vpll2 = {
 236         .constraints = {
 237                 .min_uV                 = 1800000,
 238                 .max_uV                 = 1800000,
 239                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 240                                         | REGULATOR_MODE_STANDBY,
 241                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 242                                         | REGULATOR_CHANGE_STATUS,
 243         },
 244         .num_consumer_supplies          = 1,
 245         .consumer_supplies              = &zoom_vpll2_supply,
 246 };
 247
 248 static struct regulator_init_data zoom_vdac = {
 249         .constraints = {
 250                 .min_uV                 = 1800000,
 251                 .max_uV                 = 1800000,
 252                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 253                                         | REGULATOR_MODE_STANDBY,
 254                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 255                                         | REGULATOR_CHANGE_STATUS,
 256         },
 257         .num_consumer_supplies          = 1,
 258         .consumer_supplies              = &zoom_vdda_dac_supply,
 259 };
 260
 261 static int zoom_twl_gpio_setup(struct device *dev,
 262                 unsigned gpio, unsigned ngpio)
 263 {
 264         int ret;
 265
 266         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
 267         mmc[0].gpio_cd = gpio + 0;
 268         omap2_hsmmc_init(mmc);
 269
 270         /* link regulators to MMC adapters ... we "know" the
 271          * regulators will be set up only *after* we return.
 272         */
 273         zoom_vmmc1_supply.dev = mmc[0].dev;
 274         zoom_vsim_supply.dev = mmc[0].dev;
 275         zoom_vmmc2_supply.dev = mmc[1].dev;
 276
 277         ret = gpio_request(LCD_PANEL_ENABLE_GPIO, "lcd enable");
 278         if (ret) {
 279                 pr_err("Failed to get LCD_PANEL_ENABLE_GPIO (gpio%d).\n",
 280                                 LCD_PANEL_ENABLE_GPIO);
 281                 return ret;
 282         }
 283         gpio_direction_output(LCD_PANEL_ENABLE_GPIO, 0);
 284
 285         return ret;
 286 }
 287
 288 /* EXTMUTE callback function */
 289 static void zoom2_set_hs_extmute(int mute)
 290 {
 291         gpio_set_value(ZOOM2_HEADSET_EXTMUTE_GPIO, mute);
 292 }
 293
 294 static int zoom_batt_table[] = {
 295 /* 0 C*/
 296 30800, 29500, 28300, 27100,
 297 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 298 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 299 11600, 11200, 10800, 10400, 10000, 9630,  9280,  8950,  8620,  8310,
 300 8020,  7730,  7460,  7200,  6950,  6710,  6470,  6250,  6040,  5830,
 301 5640,  5450,  5260,  5090,  4920,  4760,  4600,  4450,  4310,  4170,
 302 4040,  3910,  3790,  3670,  3550
 303 };
 304
 305 static struct twl4030_bci_platform_data zoom_bci_data = {
 306         .battery_tmp_tbl        = zoom_batt_table,
 307         .tblsize                = ARRAY_SIZE(zoom_batt_table),
 308 };
 309
 310 static struct twl4030_usb_data zoom_usb_data = {
 311         .usb_mode       = T2_USB_MODE_ULPI,
 312 };
 313
 314 static struct twl4030_gpio_platform_data zoom_gpio_data = {
 315         .gpio_base      = OMAP_MAX_GPIO_LINES,
 316         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 317         .irq_end        = TWL4030_GPIO_IRQ_END,
 318         .setup          = zoom_twl_gpio_setup,
 319 };
 320
 321 static struct twl4030_madc_platform_data zoom_madc_data = {
 322         .irq_line       = 1,
 323 };
 324
 325 static struct twl4030_codec_audio_data zoom_audio_data;
 326
 327 static struct twl4030_codec_data zoom_codec_data = {
 328         .audio_mclk = 26000000,
 329         .audio = &zoom_audio_data,
 330 };
 331
 332 static struct twl4030_platform_data zoom_twldata = {
 333         .irq_base       = TWL4030_IRQ_BASE,
 334         .irq_end        = TWL4030_IRQ_END,
 335
 336         /* platform_data for children goes here */
 337         .bci            = &zoom_bci_data,
 338         .madc           = &zoom_madc_data,
 339         .usb            = &zoom_usb_data,
 340         .gpio           = &zoom_gpio_data,
 341         .keypad         = &zoom_kp_twl4030_data,
 342         .codec          = &zoom_codec_data,
 343         .vmmc1          = &zoom_vmmc1,
 344         .vmmc2          = &zoom_vmmc2,
 345         .vsim           = &zoom_vsim,
 346         .vpll2          = &zoom_vpll2,
 347         .vdac           = &zoom_vdac,
 348 };
 349
 350 static struct i2c_board_info __initdata zoom_i2c_boardinfo[] = {
 351         {
 352                 I2C_BOARD_INFO("twl5030", 0x48),
 353                 .flags          = I2C_CLIENT_WAKE,
 354                 .irq            = INT_34XX_SYS_NIRQ,
 355                 .platform_data  = &zoom_twldata,
 356         },
 357 };
 358
 359 static int __init omap_i2c_init(void)
 360 {
 361         if (machine_is_omap_zoom2()) {
 362                 zoom_audio_data.ramp_delay_value = 3;   /* 161 ms */
 363                 zoom_audio_data.hs_extmute = 1;
 364                 zoom_audio_data.set_hs_extmute = zoom2_set_hs_extmute;
 365         }
 366         omap_register_i2c_bus(1, 2400, zoom_i2c_boardinfo,
 367                         ARRAY_SIZE(zoom_i2c_boardinfo));
 368         omap_register_i2c_bus(2, 400, NULL, 0);
 369         omap_register_i2c_bus(3, 400, NULL, 0);
 370         return 0;
 371 }
 372
 373 static struct omap_musb_board_data musb_board_data = {
 374         .interface_type         = MUSB_INTERFACE_ULPI,
 375         .mode                   = MUSB_OTG,
 376         .power                  = 100,
 377 };
 378
 379 static void enable_board_wakeup_source(void)
 380 {
 381         /* T2 interrupt line (keypad) */
 382         omap_mux_init_signal("sys_nirq",
 383                 OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
 384 }
 385
 386 void __init zoom_peripherals_init(void)
 387 {
 388         if (wl12xx_set_platform_data(&omap_zoom_wlan_data))
 389                 pr_err("error setting wl12xx data\n");
 390
 391         omap_i2c_init();
 392         platform_device_register(&omap_vwlan_device);
 393         usb_musb_init(&musb_board_data);
 394         enable_board_wakeup_source();
 395         omap_serial_init();
 396 }