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 <mach/board-zoom.h>
  29
  30 #include "mux.h"
  31 #include "hsmmc.h"
  32
  33 /* Zoom2 has Qwerty keyboard*/
  34 static uint32_t 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 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 113 static struct regulator_init_data zoom_vmmc1 = {
 114         .constraints = {
 115                 .min_uV                 = 1850000,
 116                 .max_uV                 = 3150000,
 117                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 118                                         | REGULATOR_MODE_STANDBY,
 119                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 120                                         | REGULATOR_CHANGE_MODE
 121                                         | REGULATOR_CHANGE_STATUS,
 122         },
 123         .num_consumer_supplies  = 1,
 124         .consumer_supplies      = &zoom_vmmc1_supply,
 125 };
 126
 127 /* VMMC2 for MMC2 card */
 128 static struct regulator_init_data zoom_vmmc2 = {
 129         .constraints = {
 130                 .min_uV                 = 1850000,
 131                 .max_uV                 = 1850000,
 132                 .apply_uV               = true,
 133                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 134                                         | REGULATOR_MODE_STANDBY,
 135                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 136                                         | REGULATOR_CHANGE_STATUS,
 137         },
 138         .num_consumer_supplies  = 1,
 139         .consumer_supplies      = &zoom_vmmc2_supply,
 140 };
 141
 142 /* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
 143 static struct regulator_init_data zoom_vsim = {
 144         .constraints = {
 145                 .min_uV                 = 1800000,
 146                 .max_uV                 = 3000000,
 147                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 148                                         | REGULATOR_MODE_STANDBY,
 149                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 150                                         | REGULATOR_CHANGE_MODE
 151                                         | REGULATOR_CHANGE_STATUS,
 152         },
 153         .num_consumer_supplies  = 1,
 154         .consumer_supplies      = &zoom_vsim_supply,
 155 };
 156
 157 static struct omap2_hsmmc_info mmc[] __initdata = {
 158         {
 159                 .name           = "external",
 160                 .mmc            = 1,
 161                 .caps           = MMC_CAP_4_BIT_DATA,
 162                 .gpio_wp        = -EINVAL,
 163                 .power_saving   = true,
 164         },
 165         {
 166                 .name           = "internal",
 167                 .mmc            = 2,
 168                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
 169                 .gpio_cd        = -EINVAL,
 170                 .gpio_wp        = -EINVAL,
 171                 .nonremovable   = true,
 172                 .power_saving   = true,
 173         },
 174         {}      /* Terminator */
 175 };
 176
 177 static int zoom_twl_gpio_setup(struct device *dev,
 178                 unsigned gpio, unsigned ngpio)
 179 {
 180         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
 181         mmc[0].gpio_cd = gpio + 0;
 182         omap2_hsmmc_init(mmc);
 183
 184         /* link regulators to MMC adapters ... we "know" the
 185          * regulators will be set up only *after* we return.
 186         */
 187         zoom_vmmc1_supply.dev = mmc[0].dev;
 188         zoom_vsim_supply.dev = mmc[0].dev;
 189         zoom_vmmc2_supply.dev = mmc[1].dev;
 190
 191         return 0;
 192 }
 193
 194
 195 static int zoom_batt_table[] = {
 196 /* 0 C*/
 197 30800, 29500, 28300, 27100,
 198 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 199 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 200 11600, 11200, 10800, 10400, 10000, 9630,  9280,  8950,  8620,  8310,
 201 8020,  7730,  7460,  7200,  6950,  6710,  6470,  6250,  6040,  5830,
 202 5640,  5450,  5260,  5090,  4920,  4760,  4600,  4450,  4310,  4170,
 203 4040,  3910,  3790,  3670,  3550
 204 };
 205
 206 static struct twl4030_bci_platform_data zoom_bci_data = {
 207         .battery_tmp_tbl        = zoom_batt_table,
 208         .tblsize                = ARRAY_SIZE(zoom_batt_table),
 209 };
 210
 211 static struct twl4030_usb_data zoom_usb_data = {
 212         .usb_mode       = T2_USB_MODE_ULPI,
 213 };
 214
 215 static struct twl4030_gpio_platform_data zoom_gpio_data = {
 216         .gpio_base      = OMAP_MAX_GPIO_LINES,
 217         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 218         .irq_end        = TWL4030_GPIO_IRQ_END,
 219         .setup          = zoom_twl_gpio_setup,
 220 };
 221
 222 static struct twl4030_madc_platform_data zoom_madc_data = {
 223         .irq_line       = 1,
 224 };
 225
 226 static struct twl4030_codec_audio_data zoom_audio_data = {
 227         .audio_mclk = 26000000,
 228 };
 229
 230 static struct twl4030_codec_data zoom_codec_data = {
 231         .audio_mclk = 26000000,
 232         .audio = &zoom_audio_data,
 233 };
 234
 235 static struct twl4030_platform_data zoom_twldata = {
 236         .irq_base       = TWL4030_IRQ_BASE,
 237         .irq_end        = TWL4030_IRQ_END,
 238
 239         /* platform_data for children goes here */
 240         .bci            = &zoom_bci_data,
 241         .madc           = &zoom_madc_data,
 242         .usb            = &zoom_usb_data,
 243         .gpio           = &zoom_gpio_data,
 244         .keypad         = &zoom_kp_twl4030_data,
 245         .codec          = &zoom_codec_data,
 246         .vmmc1          = &zoom_vmmc1,
 247         .vmmc2          = &zoom_vmmc2,
 248         .vsim           = &zoom_vsim,
 249
 250 };
 251
 252 static struct i2c_board_info __initdata zoom_i2c_boardinfo[] = {
 253         {
 254                 I2C_BOARD_INFO("twl5030", 0x48),
 255                 .flags          = I2C_CLIENT_WAKE,
 256                 .irq            = INT_34XX_SYS_NIRQ,
 257                 .platform_data  = &zoom_twldata,
 258         },
 259 };
 260
 261 static int __init omap_i2c_init(void)
 262 {
 263         omap_register_i2c_bus(1, 2400, zoom_i2c_boardinfo,
 264                         ARRAY_SIZE(zoom_i2c_boardinfo));
 265         omap_register_i2c_bus(2, 400, NULL, 0);
 266         omap_register_i2c_bus(3, 400, NULL, 0);
 267         return 0;
 268 }
 269
 270 static struct omap_musb_board_data musb_board_data = {
 271         .interface_type         = MUSB_INTERFACE_ULPI,
 272         .mode                   = MUSB_OTG,
 273         .power                  = 100,
 274 };
 275
 276 static void enable_board_wakeup_source(void)
 277 {
 278         /* T2 interrupt line (keypad) */
 279         omap_mux_init_signal("sys_nirq",
 280                 OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
 281 }
 282
 283 void __init zoom_peripherals_init(void)
 284 {
 285         omap_i2c_init();
 286         usb_musb_init(&musb_board_data);
 287         enable_board_wakeup_source();
 288         omap_serial_init();
 289 }