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
  20 #include <asm/mach-types.h>
  21 #include <asm/mach/arch.h>
  22 #include <asm/mach/map.h>
  23
  24 #include <plat/common.h>
  25 #include <plat/usb.h>
  26
  27 #include <mach/board-zoom.h>
  28
  29 #include "mux.h"
  30 #include "hsmmc.h"
  31
  32 /* Zoom2 has Qwerty keyboard*/
  33 static int board_keymap[] = {
  34         KEY(0, 0, KEY_E),
  35         KEY(0, 1, KEY_R),
  36         KEY(0, 2, KEY_T),
  37         KEY(0, 3, KEY_HOME),
  38         KEY(0, 6, KEY_I),
  39         KEY(0, 7, KEY_LEFTSHIFT),
  40         KEY(1, 0, KEY_D),
  41         KEY(1, 1, KEY_F),
  42         KEY(1, 2, KEY_G),
  43         KEY(1, 3, KEY_SEND),
  44         KEY(1, 6, KEY_K),
  45         KEY(1, 7, KEY_ENTER),
  46         KEY(2, 0, KEY_X),
  47         KEY(2, 1, KEY_C),
  48         KEY(2, 2, KEY_V),
  49         KEY(2, 3, KEY_END),
  50         KEY(2, 6, KEY_DOT),
  51         KEY(2, 7, KEY_CAPSLOCK),
  52         KEY(3, 0, KEY_Z),
  53         KEY(3, 1, KEY_KPPLUS),
  54         KEY(3, 2, KEY_B),
  55         KEY(3, 3, KEY_F1),
  56         KEY(3, 6, KEY_O),
  57         KEY(3, 7, KEY_SPACE),
  58         KEY(4, 0, KEY_W),
  59         KEY(4, 1, KEY_Y),
  60         KEY(4, 2, KEY_U),
  61         KEY(4, 3, KEY_F2),
  62         KEY(4, 4, KEY_VOLUMEUP),
  63         KEY(4, 6, KEY_L),
  64         KEY(4, 7, KEY_LEFT),
  65         KEY(5, 0, KEY_S),
  66         KEY(5, 1, KEY_H),
  67         KEY(5, 2, KEY_J),
  68         KEY(5, 3, KEY_F3),
  69         KEY(5, 4, KEY_UNKNOWN),
  70         KEY(5, 5, KEY_VOLUMEDOWN),
  71         KEY(5, 6, KEY_M),
  72         KEY(5, 7, KEY_RIGHT),
  73         KEY(6, 0, KEY_Q),
  74         KEY(6, 1, KEY_A),
  75         KEY(6, 2, KEY_N),
  76         KEY(6, 3, KEY_BACKSPACE),
  77         KEY(6, 6, KEY_P),
  78         KEY(6, 7, KEY_UP),
  79         KEY(7, 0, KEY_PROG1),   /*MACRO 1 <User defined> */
  80         KEY(7, 1, KEY_PROG2),   /*MACRO 2 <User defined> */
  81         KEY(7, 2, KEY_PROG3),   /*MACRO 3 <User defined> */
  82         KEY(7, 3, KEY_PROG4),   /*MACRO 4 <User defined> */
  83         KEY(7, 6, KEY_SELECT),
  84         KEY(7, 7, KEY_DOWN)
  85 };
  86
  87 static struct matrix_keymap_data board_map_data = {
  88         .keymap                 = board_keymap,
  89         .keymap_size            = ARRAY_SIZE(board_keymap),
  90 };
  91
  92 static struct twl4030_keypad_data zoom_kp_twl4030_data = {
  93         .keymap_data    = &board_map_data,
  94         .rows           = 8,
  95         .cols           = 8,
  96         .rep            = 1,
  97 };
  98
  99 static struct regulator_consumer_supply zoom_vmmc1_supply = {
 100         .supply         = "vmmc",
 101 };
 102
 103 static struct regulator_consumer_supply zoom_vsim_supply = {
 104         .supply         = "vmmc_aux",
 105 };
 106
 107 static struct regulator_consumer_supply zoom_vmmc2_supply = {
 108         .supply         = "vmmc",
 109 };
 110
 111 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 112 static struct regulator_init_data zoom_vmmc1 = {
 113         .constraints = {
 114                 .min_uV                 = 1850000,
 115                 .max_uV                 = 3150000,
 116                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 117                                         | REGULATOR_MODE_STANDBY,
 118                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 119                                         | REGULATOR_CHANGE_MODE
 120                                         | REGULATOR_CHANGE_STATUS,
 121         },
 122         .num_consumer_supplies  = 1,
 123         .consumer_supplies      = &zoom_vmmc1_supply,
 124 };
 125
 126 /* VMMC2 for MMC2 card */
 127 static struct regulator_init_data zoom_vmmc2 = {
 128         .constraints = {
 129                 .min_uV                 = 1850000,
 130                 .max_uV                 = 1850000,
 131                 .apply_uV               = true,
 132                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 133                                         | REGULATOR_MODE_STANDBY,
 134                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 135                                         | REGULATOR_CHANGE_STATUS,
 136         },
 137         .num_consumer_supplies  = 1,
 138         .consumer_supplies      = &zoom_vmmc2_supply,
 139 };
 140
 141 /* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
 142 static struct regulator_init_data zoom_vsim = {
 143         .constraints = {
 144                 .min_uV                 = 1800000,
 145                 .max_uV                 = 3000000,
 146                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 147                                         | REGULATOR_MODE_STANDBY,
 148                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 149                                         | REGULATOR_CHANGE_MODE
 150                                         | REGULATOR_CHANGE_STATUS,
 151         },
 152         .num_consumer_supplies  = 1,
 153         .consumer_supplies      = &zoom_vsim_supply,
 154 };
 155
 156 static struct omap2_hsmmc_info mmc[] __initdata = {
 157         {
 158                 .name           = "external",
 159                 .mmc            = 1,
 160                 .wires          = 4,
 161                 .gpio_wp        = -EINVAL,
 162                 .power_saving   = true,
 163         },
 164         {
 165                 .name           = "internal",
 166                 .mmc            = 2,
 167                 .wires          = 8,
 168                 .gpio_cd        = -EINVAL,
 169                 .gpio_wp        = -EINVAL,
 170                 .nonremovable   = true,
 171                 .power_saving   = true,
 172         },
 173         {}      /* Terminator */
 174 };
 175
 176 static int zoom_twl_gpio_setup(struct device *dev,
 177                 unsigned gpio, unsigned ngpio)
 178 {
 179         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
 180         mmc[0].gpio_cd = gpio + 0;
 181         omap2_hsmmc_init(mmc);
 182
 183         /* link regulators to MMC adapters ... we "know" the
 184          * regulators will be set up only *after* we return.
 185         */
 186         zoom_vmmc1_supply.dev = mmc[0].dev;
 187         zoom_vsim_supply.dev = mmc[0].dev;
 188         zoom_vmmc2_supply.dev = mmc[1].dev;
 189
 190         return 0;
 191 }
 192
 193 /* EXTMUTE callback function */
 194 void zoom2_set_hs_extmute(int mute)
 195 {
 196         gpio_set_value(ZOOM2_HEADSET_EXTMUTE_GPIO, mute);
 197 }
 198
 199 static int zoom_batt_table[] = {
 200 /* 0 C*/
 201 30800, 29500, 28300, 27100,
 202 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 203 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 204 11600, 11200, 10800, 10400, 10000, 9630,  9280,  8950,  8620,  8310,
 205 8020,  7730,  7460,  7200,  6950,  6710,  6470,  6250,  6040,  5830,
 206 5640,  5450,  5260,  5090,  4920,  4760,  4600,  4450,  4310,  4170,
 207 4040,  3910,  3790,  3670,  3550
 208 };
 209
 210 static struct twl4030_bci_platform_data zoom_bci_data = {
 211         .battery_tmp_tbl        = zoom_batt_table,
 212         .tblsize                = ARRAY_SIZE(zoom_batt_table),
 213 };
 214
 215 static struct twl4030_usb_data zoom_usb_data = {
 216         .usb_mode       = T2_USB_MODE_ULPI,
 217 };
 218
 219 static struct twl4030_gpio_platform_data zoom_gpio_data = {
 220         .gpio_base      = OMAP_MAX_GPIO_LINES,
 221         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 222         .irq_end        = TWL4030_GPIO_IRQ_END,
 223         .setup          = zoom_twl_gpio_setup,
 224 };
 225
 226 static struct twl4030_madc_platform_data zoom_madc_data = {
 227         .irq_line       = 1,
 228 };
 229
 230 static struct twl4030_codec_audio_data zoom_audio_data = {
 231         .audio_mclk = 26000000,
 232 };
 233
 234 static struct twl4030_codec_data zoom_codec_data = {
 235         .audio_mclk = 26000000,
 236         .audio = &zoom_audio_data,
 237 };
 238
 239 static struct twl4030_platform_data zoom_twldata = {
 240         .irq_base       = TWL4030_IRQ_BASE,
 241         .irq_end        = TWL4030_IRQ_END,
 242
 243         /* platform_data for children goes here */
 244         .bci            = &zoom_bci_data,
 245         .madc           = &zoom_madc_data,
 246         .usb            = &zoom_usb_data,
 247         .gpio           = &zoom_gpio_data,
 248         .keypad         = &zoom_kp_twl4030_data,
 249         .codec          = &zoom_codec_data,
 250         .vmmc1          = &zoom_vmmc1,
 251         .vmmc2          = &zoom_vmmc2,
 252         .vsim           = &zoom_vsim,
 253
 254 };
 255
 256 static struct i2c_board_info __initdata zoom_i2c_boardinfo[] = {
 257         {
 258                 I2C_BOARD_INFO("twl5030", 0x48),
 259                 .flags          = I2C_CLIENT_WAKE,
 260                 .irq            = INT_34XX_SYS_NIRQ,
 261                 .platform_data  = &zoom_twldata,
 262         },
 263 };
 264
 265 static int __init omap_i2c_init(void)
 266 {
 267         if (machine_is_omap_zoom2()) {
 268                 zoom_audio_data.ramp_delay_value = 3;   /* 161 ms */
 269                 zoom_audio_data.hs_extmute = 1;
 270                 zoom_audio_data.set_hs_extmute = zoom2_set_hs_extmute;
 271         }
 272         omap_register_i2c_bus(1, 2400, zoom_i2c_boardinfo,
 273                         ARRAY_SIZE(zoom_i2c_boardinfo));
 274         omap_register_i2c_bus(2, 400, NULL, 0);
 275         omap_register_i2c_bus(3, 400, NULL, 0);
 276         return 0;
 277 }
 278
 279 static struct omap_musb_board_data musb_board_data = {
 280         .interface_type         = MUSB_INTERFACE_ULPI,
 281         .mode                   = MUSB_OTG,
 282         .power                  = 100,
 283 };
 284
 285 static void enable_board_wakeup_source(void)
 286 {
 287         /* T2 interrupt line (keypad) */
 288         omap_mux_init_signal("sys_nirq",
 289                 OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
 290 }
 291
 292 void __init zoom_peripherals_init(void)
 293 {
 294         omap_i2c_init();
 295         usb_musb_init(&musb_board_data);
 296         enable_board_wakeup_source();
 297 }