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