ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[linux-3.10.git] / arch / arm / mach-tegra / board-dalmore-kbc.c
1 /*
2  * arch/arm/mach-tegra/board-dalmore-kbc.c
3  * Keys configuration for Nvidia tegra3 dalmore platform.
4  *
5  * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19  * 02111-1307, USA
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/platform_device.h>
24 #include <linux/input.h>
25 #include <linux/input/tegra_kbc.h>
26 #include <linux/io.h>
27 #include <linux/gpio.h>
28 #include <linux/gpio_keys.h>
29 #include <linux/mfd/palmas.h>
30
31 #include "tegra-board-id.h"
32 #include "board.h"
33 #include "board-dalmore.h"
34 #include "devices.h"
35 #include "iomap.h"
36 #include "wakeups-t11x.h"
37
38 #define DALMORE_ROW_COUNT       3
39 #define DALMORE_COL_COUNT       3
40
41 static int dalmore_wakeup_key(void)
42 {
43         int wakeup_key;
44         u64 status = readl(IO_ADDRESS(TEGRA_PMC_BASE) + PMC_WAKE_STATUS)
45                 | (u64)readl(IO_ADDRESS(TEGRA_PMC_BASE)
46                 + PMC_WAKE2_STATUS) << 32;
47
48         if (status & (1ULL << TEGRA_WAKE_GPIO_PQ0))
49                 wakeup_key = KEY_POWER;
50         else if (status & (1ULL << TEGRA_WAKE_GPIO_PS0))
51                 wakeup_key = SW_LID;
52         else
53                 wakeup_key = KEY_RESERVED;
54
55         return wakeup_key;
56 }
57
58 static const u32 kbd_keymap[] = {
59         KEY(0, 0, KEY_POWER),
60         KEY(0, 1, KEY_HOME),
61
62         KEY(1, 0, KEY_RESERVED),
63         KEY(1, 1, KEY_VOLUMEDOWN),
64
65         KEY(2, 0, KEY_CAMERA),
66         KEY(2, 1, KEY_VOLUMEUP),
67         KEY(2, 2, KEY_2),
68 };
69
70 static const struct matrix_keymap_data keymap_data = {
71         .keymap         = kbd_keymap,
72         .keymap_size    = ARRAY_SIZE(kbd_keymap),
73 };
74
75 static struct tegra_kbc_wake_key dalmore_wake_cfg[] = {
76         [0] = {
77                 .row = 0,
78                 .col = 0,
79         },
80 };
81
82 static struct tegra_kbc_platform_data dalmore_kbc_platform_data = {
83         .debounce_cnt = 20 * 32, /* 20 ms debaunce time */
84         .repeat_cnt = 1,
85         .scan_count = 30,
86         .wakeup = true,
87         .keymap_data = &keymap_data,
88         .wake_cnt = 1,
89         .wake_cfg = &dalmore_wake_cfg[0],
90         .wakeup_key = KEY_POWER,
91 #ifdef CONFIG_ANDROID
92         .disable_ev_rep = true,
93 #endif
94 };
95
96 #define GPIO_KCODE(_kcode, _kev, _gpio, _irq, _iswake, _deb)    \
97         {                                               \
98                 .code = _kcode,                         \
99                 .gpio = TEGRA_GPIO_##_gpio,             \
100                 .irq = _irq,                            \
101                 .active_low = 1,                        \
102                 .desc = #_kcode,                        \
103                 .type = _kev,                           \
104                 .wakeup = _iswake,                      \
105                 .debounce_interval = _deb,              \
106         }
107
108 #define GPIO_KEY(_id, _gpio, _iswake)   \
109         GPIO_KCODE(_id, EV_KEY, _gpio, 0, _iswake, 10)
110
111 #define GPIO_IKEY(_id, _irq, _iswake, _deb)     \
112         GPIO_KCODE(_id, EV_KEY, INVALID, _irq, _iswake, _deb)
113
114 static struct gpio_keys_button dalmore_int_keys[] = {
115         [0] = GPIO_IKEY(KEY_POWER, MAX77663_IRQ_BASE +
116                                 MAX77663_IRQ_ONOFF_EN0_FALLING, 0, 100),
117         [1] = GPIO_IKEY(KEY_POWER, MAX77663_IRQ_BASE +
118                                 MAX77663_IRQ_ONOFF_EN0_1SEC, 0, 3000),
119 };
120
121 static struct gpio_keys_button dalmore_e1611_1001_keys[] = {
122         [0] = GPIO_KEY(KEY_POWER, PQ0, 1),
123         [1] = GPIO_KEY(KEY_VOLUMEUP, PR2, 0),
124         [2] = GPIO_KEY(KEY_VOLUMEDOWN, PR1, 0),
125         [3] = GPIO_KEY(KEY_HOME, PI5, 0),
126         [4] = GPIO_KCODE(SW_ROTATE_LOCK, EV_SW, PQ1, 0, 0, 10),
127 };
128
129 static struct gpio_keys_button dalmore_e1611_1000_keys[] = {
130         [0] = GPIO_KCODE(SW_ROTATE_LOCK, EV_SW, PI5, 0, 0, 10),
131 };
132
133 static struct gpio_keys_platform_data dalmore_int_keys_pdata = {
134         .buttons        = dalmore_int_keys,
135         .nbuttons       = ARRAY_SIZE(dalmore_int_keys),
136 };
137
138 static struct gpio_keys_platform_data dalmore_e1611_1001_keys_pdata = {
139         .buttons        = dalmore_e1611_1001_keys,
140         .nbuttons       = ARRAY_SIZE(dalmore_e1611_1001_keys),
141         .wakeup_key     = dalmore_wakeup_key,
142 };
143
144 static struct gpio_keys_platform_data dalmore_e1611_1000_keys_pdata = {
145         .buttons        = dalmore_e1611_1000_keys,
146         .nbuttons       = ARRAY_SIZE(dalmore_e1611_1000_keys),
147 };
148
149 static struct platform_device dalmore_gpio_keys_device = {
150         .name   = "gpio-keys",
151         .id     = 0,
152         .dev    = {
153                 .platform_data  = &dalmore_int_keys_pdata,
154         },
155 };
156
157 static void __init dalmore_register_kbc(void)
158 {
159         struct tegra_kbc_platform_data *data = &dalmore_kbc_platform_data;
160         int i;
161
162         tegra_kbc_device.dev.platform_data = &dalmore_kbc_platform_data;
163
164         for (i = 0; i < DALMORE_ROW_COUNT; i++) {
165                 data->pin_cfg[i].num = i;
166                 data->pin_cfg[i].type = PIN_CFG_ROW;
167         }
168         for (i = 0; i < DALMORE_COL_COUNT; i++) {
169                 data->pin_cfg[i + KBC_PIN_GPIO_11].num = i;
170                 data->pin_cfg[i + KBC_PIN_GPIO_11].type = PIN_CFG_COL;
171         }
172
173         platform_device_register(&tegra_kbc_device);
174 }
175
176 int __init dalmore_kbc_init(void)
177 {
178         struct board_info board_info;
179
180         tegra_get_board_info(&board_info);
181         pr_info("Boardid:SKU = 0x%04x:0x%04x\n", board_info.board_id, board_info.sku);
182
183         if (board_info.board_id == BOARD_E1613) {
184                 dalmore_register_kbc();
185                 goto gpio_keys;
186         }
187
188         if ((board_info.board_id == BOARD_E1611) && (board_info.sku == 1000)) {
189                 dalmore_register_kbc();
190                 dalmore_gpio_keys_device.dev.platform_data =
191                                         &dalmore_e1611_1000_keys_pdata;
192         } else {
193                 int ret;
194
195                 ret = gpio_request(TEGRA_GPIO_PR0, "row0");
196                 if (ret < 0) {
197                         pr_err("gpio_request for PR0 failed: %d\n", ret);
198                 } else {
199                         gpio_direction_output(TEGRA_GPIO_PR0, 0);
200                 }
201
202                 dalmore_gpio_keys_device.dev.platform_data =
203                                         &dalmore_e1611_1001_keys_pdata;
204         }
205
206 gpio_keys:
207         platform_device_register(&dalmore_gpio_keys_device);
208         return 0;
209 }