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