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