]>
Commit | Line | Data |
---|---|---|
6642a681 RI |
1 | /* |
2 | * (C) Copyright 2011 | |
3 | * NVIDIA Corporation <www.nvidia.com> | |
4 | * | |
5 | * See file CREDITS for list of people who contributed to this | |
6 | * project. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License as | |
10 | * published by the Free Software Foundation; either version 2 of | |
11 | * the License, or (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
21 | * MA 02111-1307 USA | |
22 | */ | |
23 | ||
24 | #include <common.h> | |
25 | #include <fdtdec.h> | |
26 | #include <input.h> | |
27 | #include <key_matrix.h> | |
28 | #include <stdio_dev.h> | |
29 | #include <tegra-kbc.h> | |
30 | #include <asm/io.h> | |
31 | #include <asm/arch/clock.h> | |
32 | #include <asm/arch/funcmux.h> | |
33 | #include <asm/arch/timer.h> | |
34 | #include <linux/input.h> | |
35 | ||
36 | DECLARE_GLOBAL_DATA_PTR; | |
37 | ||
38 | enum { | |
39 | KBC_MAX_GPIO = 24, | |
40 | KBC_MAX_KPENT = 8, /* size of keypress entry queue */ | |
41 | }; | |
42 | ||
43 | #define KBC_FIFO_TH_CNT_SHIFT 14 | |
44 | #define KBC_DEBOUNCE_CNT_SHIFT 4 | |
45 | #define KBC_CONTROL_FIFO_CNT_INT_EN (1 << 3) | |
46 | #define KBC_CONTROL_KBC_EN (1 << 0) | |
47 | #define KBC_INT_FIFO_CNT_INT_STATUS (1 << 2) | |
48 | #define KBC_KPENT_VALID (1 << 7) | |
49 | #define KBC_ST_STATUS (1 << 3) | |
50 | ||
51 | enum { | |
52 | KBC_DEBOUNCE_COUNT = 2, | |
53 | KBC_REPEAT_RATE_MS = 30, | |
54 | KBC_REPEAT_DELAY_MS = 240, | |
55 | KBC_CLOCK_KHZ = 32, /* Keyboard uses a 32KHz clock */ | |
56 | }; | |
57 | ||
58 | /* keyboard controller config and state */ | |
59 | static struct keyb { | |
60 | struct input_config input; /* The input layer */ | |
61 | struct key_matrix matrix; /* The key matrix layer */ | |
62 | ||
63 | struct kbc_tegra *kbc; /* tegra keyboard controller */ | |
64 | unsigned char inited; /* 1 if keyboard has been inited */ | |
65 | unsigned char first_scan; /* 1 if this is our first key scan */ | |
66 | ||
67 | /* | |
68 | * After init we must wait a short time before polling the keyboard. | |
69 | * This gives the tegra keyboard controller time to react after reset | |
70 | * and lets us grab keys pressed during reset. | |
71 | */ | |
72 | unsigned int init_dly_ms; /* Delay before we can read keyboard */ | |
73 | unsigned int start_time_ms; /* Time that we inited (in ms) */ | |
74 | unsigned int last_poll_ms; /* Time we should last polled */ | |
75 | unsigned int next_repeat_ms; /* Next time we repeat a key */ | |
76 | } config; | |
77 | ||
78 | /** | |
79 | * reads the keyboard fifo for current keypresses | |
80 | * | |
81 | * @param config Keyboard config | |
82 | * @param fifo Place to put fifo results | |
83 | * @param max_keycodes Maximum number of key codes to put in the fifo | |
84 | * @return number of items put into fifo | |
85 | */ | |
86 | static int tegra_kbc_find_keys(struct keyb *config, int *fifo, | |
87 | int max_keycodes) | |
88 | { | |
89 | struct key_matrix_key keys[KBC_MAX_KPENT], *key; | |
90 | u32 kp_ent = 0; | |
91 | int i; | |
92 | ||
93 | for (key = keys, i = 0; i < KBC_MAX_KPENT; i++, key++) { | |
94 | /* Get next word */ | |
95 | if (!(i & 3)) | |
96 | kp_ent = readl(&config->kbc->kp_ent[i / 4]); | |
97 | ||
98 | key->valid = (kp_ent & KBC_KPENT_VALID) != 0; | |
99 | key->row = (kp_ent >> 3) & 0xf; | |
100 | key->col = kp_ent & 0x7; | |
101 | ||
102 | /* Shift to get next entry */ | |
103 | kp_ent >>= 8; | |
104 | } | |
105 | return key_matrix_decode(&config->matrix, keys, KBC_MAX_KPENT, fifo, | |
106 | max_keycodes); | |
107 | } | |
108 | ||
109 | /** | |
110 | * Process all the keypress sequences in fifo and send key codes | |
111 | * | |
112 | * The fifo contains zero or more keypress sets. Each set | |
113 | * consists of from 1-8 keycodes, representing the keycodes which | |
114 | * were simultaneously pressed during that scan. | |
115 | * | |
116 | * This function works through each set and generates ASCII characters | |
117 | * for each. Not that one set may produce more than one ASCII characters - | |
118 | * for example holding down 'd' and 'f' at the same time will generate | |
119 | * two ASCII characters. | |
120 | * | |
121 | * Note: if fifo_cnt is 0, we will tell the input layer that no keys are | |
122 | * pressed. | |
123 | * | |
124 | * @param config Keyboard config | |
125 | * @param fifo_cnt Number of entries in the keyboard fifo | |
126 | */ | |
127 | static void process_fifo(struct keyb *config, int fifo_cnt) | |
128 | { | |
129 | int fifo[KBC_MAX_KPENT]; | |
130 | int cnt = 0; | |
131 | ||
132 | /* Always call input_send_keycodes() at least once */ | |
133 | do { | |
134 | if (fifo_cnt) | |
135 | cnt = tegra_kbc_find_keys(config, fifo, KBC_MAX_KPENT); | |
136 | ||
137 | input_send_keycodes(&config->input, fifo, cnt); | |
138 | } while (--fifo_cnt > 0); | |
139 | } | |
140 | ||
141 | /** | |
142 | * Check the keyboard controller and emit ASCII characters for any keys that | |
143 | * are pressed. | |
144 | * | |
145 | * @param config Keyboard config | |
146 | */ | |
147 | static void check_for_keys(struct keyb *config) | |
148 | { | |
149 | int fifo_cnt; | |
150 | ||
151 | if (!config->first_scan && | |
152 | get_timer(config->last_poll_ms) < KBC_REPEAT_RATE_MS) | |
153 | return; | |
154 | config->last_poll_ms = get_timer(0); | |
155 | config->first_scan = 0; | |
156 | ||
157 | /* | |
158 | * Once we get here we know the keyboard has been scanned. So if there | |
159 | * scan waiting for us, we know that nothing is held down. | |
160 | */ | |
161 | fifo_cnt = (readl(&config->kbc->interrupt) >> 4) & 0xf; | |
162 | process_fifo(config, fifo_cnt); | |
163 | } | |
164 | ||
165 | /** | |
166 | * In order to detect keys pressed on boot, wait for the hardware to | |
167 | * complete scanning the keys. This includes time to transition from | |
168 | * Wkup mode to Continous polling mode and the repoll time. We can | |
169 | * deduct the time that's already elapsed. | |
170 | * | |
171 | * @param config Keyboard config | |
172 | */ | |
173 | static void kbd_wait_for_fifo_init(struct keyb *config) | |
174 | { | |
175 | if (!config->inited) { | |
176 | unsigned long elapsed_time; | |
177 | long delay_ms; | |
178 | ||
179 | elapsed_time = get_timer(config->start_time_ms); | |
180 | delay_ms = config->init_dly_ms - elapsed_time; | |
181 | if (delay_ms > 0) { | |
182 | udelay(delay_ms * 1000); | |
183 | debug("%s: delay %ldms\n", __func__, delay_ms); | |
184 | } | |
185 | ||
186 | config->inited = 1; | |
187 | } | |
188 | } | |
189 | ||
190 | /** | |
191 | * Check the tegra keyboard, and send any keys that are pressed. | |
192 | * | |
193 | * This is called by input_tstc() and input_getc() when they need more | |
194 | * characters | |
195 | * | |
196 | * @param input Input configuration | |
197 | * @return 1, to indicate that we have something to look at | |
198 | */ | |
199 | int tegra_kbc_check(struct input_config *input) | |
200 | { | |
201 | kbd_wait_for_fifo_init(&config); | |
202 | check_for_keys(&config); | |
203 | ||
204 | return 1; | |
205 | } | |
206 | ||
207 | /** | |
208 | * Test if keys are available to be read | |
209 | * | |
210 | * @return 0 if no keys available, 1 if keys are available | |
211 | */ | |
212 | static int kbd_tstc(void) | |
213 | { | |
214 | /* Just get input to do this for us */ | |
215 | return input_tstc(&config.input); | |
216 | } | |
217 | ||
218 | /** | |
219 | * Read a key | |
220 | * | |
221 | * TODO: U-Boot wants 0 for no key, but Ctrl-@ is a valid key... | |
222 | * | |
223 | * @return ASCII key code, or 0 if no key, or -1 if error | |
224 | */ | |
225 | static int kbd_getc(void) | |
226 | { | |
227 | /* Just get input to do this for us */ | |
228 | return input_getc(&config.input); | |
229 | } | |
230 | ||
231 | /* configures keyboard GPIO registers to use the rows and columns */ | |
232 | static void config_kbc_gpio(struct kbc_tegra *kbc) | |
233 | { | |
234 | int i; | |
235 | ||
236 | for (i = 0; i < KBC_MAX_GPIO; i++) { | |
237 | u32 row_cfg, col_cfg; | |
238 | u32 r_shift = 5 * (i % 6); | |
239 | u32 c_shift = 4 * (i % 8); | |
240 | u32 r_mask = 0x1f << r_shift; | |
241 | u32 c_mask = 0xf << c_shift; | |
242 | u32 r_offs = i / 6; | |
243 | u32 c_offs = i / 8; | |
244 | ||
245 | row_cfg = readl(&kbc->row_cfg[r_offs]); | |
246 | col_cfg = readl(&kbc->col_cfg[c_offs]); | |
247 | ||
248 | row_cfg &= ~r_mask; | |
249 | col_cfg &= ~c_mask; | |
250 | ||
251 | if (i < config.matrix.num_rows) { | |
252 | row_cfg |= ((i << 1) | 1) << r_shift; | |
253 | } else { | |
254 | col_cfg |= (((i - config.matrix.num_rows) << 1) | 1) | |
255 | << c_shift; | |
256 | } | |
257 | ||
258 | writel(row_cfg, &kbc->row_cfg[r_offs]); | |
259 | writel(col_cfg, &kbc->col_cfg[c_offs]); | |
260 | } | |
261 | } | |
262 | ||
263 | /** | |
264 | * Start up the keyboard device | |
265 | */ | |
266 | static void tegra_kbc_open(void) | |
267 | { | |
268 | struct kbc_tegra *kbc = config.kbc; | |
269 | unsigned int scan_period; | |
270 | u32 val; | |
271 | ||
272 | /* | |
273 | * We will scan at twice the keyboard repeat rate, so that there is | |
274 | * always a scan ready when we check it in check_for_keys(). | |
275 | */ | |
276 | scan_period = KBC_REPEAT_RATE_MS / 2; | |
277 | writel(scan_period * KBC_CLOCK_KHZ, &kbc->rpt_dly); | |
278 | writel(scan_period * KBC_CLOCK_KHZ, &kbc->init_dly); | |
279 | /* | |
280 | * Before reading from the keyboard we must wait for the init_dly | |
281 | * plus the rpt_delay, plus 2ms for the row scan time. | |
282 | */ | |
283 | config.init_dly_ms = scan_period * 2 + 2; | |
284 | ||
285 | val = KBC_DEBOUNCE_COUNT << KBC_DEBOUNCE_CNT_SHIFT; | |
286 | val |= 1 << KBC_FIFO_TH_CNT_SHIFT; /* fifo interrupt threshold */ | |
287 | val |= KBC_CONTROL_KBC_EN; /* enable */ | |
288 | writel(val, &kbc->control); | |
289 | ||
290 | config.start_time_ms = get_timer(0); | |
291 | config.last_poll_ms = config.next_repeat_ms = get_timer(0); | |
292 | config.first_scan = 1; | |
293 | } | |
294 | ||
295 | /** | |
296 | * Set up the tegra keyboard. This is called by the stdio device handler | |
297 | * | |
298 | * We want to do this init when the keyboard is actually used rather than | |
299 | * at start-up, since keyboard input may not currently be selected. | |
300 | * | |
301 | * Once the keyboard starts there will be a period during which we must | |
302 | * wait for the keyboard to init. We do this only when a key is first | |
303 | * read - see kbd_wait_for_fifo_init(). | |
304 | * | |
305 | * @return 0 if ok, -ve on error | |
306 | */ | |
307 | static int init_tegra_keyboard(void) | |
308 | { | |
309 | #ifdef CONFIG_OF_CONTROL | |
310 | int node; | |
311 | ||
312 | node = fdtdec_next_compatible(gd->fdt_blob, 0, | |
313 | COMPAT_NVIDIA_TEGRA20_KBC); | |
314 | if (node < 0) { | |
315 | debug("%s: cannot locate keyboard node\n", __func__); | |
316 | return node; | |
317 | } | |
318 | config.kbc = (struct kbc_tegra *)fdtdec_get_addr(gd->fdt_blob, | |
319 | node, "reg"); | |
320 | if ((fdt_addr_t)config.kbc == FDT_ADDR_T_NONE) { | |
321 | debug("%s: No keyboard register found\n", __func__); | |
322 | return -1; | |
323 | } | |
1b1d3e64 SG |
324 | input_set_delays(&config.input, KBC_REPEAT_DELAY_MS, |
325 | KBC_REPEAT_RATE_MS); | |
6642a681 RI |
326 | |
327 | /* Decode the keyboard matrix information (16 rows, 8 columns) */ | |
328 | if (key_matrix_init(&config.matrix, 16, 8)) { | |
329 | debug("%s: Could not init key matrix\n", __func__); | |
330 | return -1; | |
331 | } | |
332 | if (key_matrix_decode_fdt(&config.matrix, gd->fdt_blob, node)) { | |
333 | debug("%s: Could not decode key matrix from fdt\n", __func__); | |
334 | return -1; | |
335 | } | |
336 | if (config.matrix.fn_keycode) { | |
337 | if (input_add_table(&config.input, KEY_FN, -1, | |
338 | config.matrix.fn_keycode, | |
339 | config.matrix.key_count)) | |
340 | return -1; | |
341 | } | |
342 | #else | |
343 | #error "Tegra keyboard driver requires FDT definitions" | |
344 | #endif | |
345 | ||
346 | /* Set up pin mux and enable the clock */ | |
347 | funcmux_select(PERIPH_ID_KBC, FUNCMUX_DEFAULT); | |
348 | clock_enable(PERIPH_ID_KBC); | |
349 | config_kbc_gpio(config.kbc); | |
350 | ||
351 | tegra_kbc_open(); | |
352 | debug("%s: Tegra keyboard ready\n", __func__); | |
353 | ||
354 | return 0; | |
355 | } | |
356 | ||
357 | int drv_keyboard_init(void) | |
358 | { | |
359 | struct stdio_dev dev; | |
360 | ||
1b1d3e64 | 361 | if (input_init(&config.input, 0)) { |
6642a681 RI |
362 | debug("%s: Cannot set up input\n", __func__); |
363 | return -1; | |
364 | } | |
365 | config.input.read_keys = tegra_kbc_check; | |
366 | ||
367 | memset(&dev, '\0', sizeof(dev)); | |
368 | strcpy(dev.name, "tegra-kbc"); | |
369 | dev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM; | |
370 | dev.getc = kbd_getc; | |
371 | dev.tstc = kbd_tstc; | |
372 | dev.start = init_tegra_keyboard; | |
373 | ||
374 | /* Register the device. init_tegra_keyboard() will be called soon */ | |
375 | return input_stdio_register(&dev); | |
376 | } |