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