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