3 * NVIDIA Corporation <www.nvidia.com>
5 * See file CREDITS for list of people who contributed to this
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.
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.
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,
27 #include <key_matrix.h>
28 #include <stdio_dev.h>
29 #include <tegra-kbc.h>
31 #include <asm/arch/clock.h>
32 #include <asm/arch/funcmux.h>
33 #include <asm/arch-tegra/timer.h>
34 #include <linux/input.h>
36 DECLARE_GLOBAL_DATA_PTR
;
40 KBC_MAX_KPENT
= 8, /* size of keypress entry queue */
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)
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 */
58 /* keyboard controller config and state */
60 struct input_config input
; /* The input layer */
61 struct key_matrix matrix
; /* The key matrix layer */
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 */
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.
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 */
79 * reads the keyboard fifo for current keypresses
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
86 static int tegra_kbc_find_keys(struct keyb
*config
, int *fifo
,
89 struct key_matrix_key keys
[KBC_MAX_KPENT
], *key
;
93 for (key
= keys
, i
= 0; i
< KBC_MAX_KPENT
; i
++, key
++) {
96 kp_ent
= readl(&config
->kbc
->kp_ent
[i
/ 4]);
98 key
->valid
= (kp_ent
& KBC_KPENT_VALID
) != 0;
99 key
->row
= (kp_ent
>> 3) & 0xf;
100 key
->col
= kp_ent
& 0x7;
102 /* Shift to get next entry */
105 return key_matrix_decode(&config
->matrix
, keys
, KBC_MAX_KPENT
, fifo
,
110 * Process all the keypress sequences in fifo and send key codes
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.
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.
121 * Note: if fifo_cnt is 0, we will tell the input layer that no keys are
124 * @param config Keyboard config
125 * @param fifo_cnt Number of entries in the keyboard fifo
127 static void process_fifo(struct keyb
*config
, int fifo_cnt
)
129 int fifo
[KBC_MAX_KPENT
];
132 /* Always call input_send_keycodes() at least once */
135 cnt
= tegra_kbc_find_keys(config
, fifo
, KBC_MAX_KPENT
);
137 input_send_keycodes(&config
->input
, fifo
, cnt
);
138 } while (--fifo_cnt
> 0);
142 * Check the keyboard controller and emit ASCII characters for any keys that
145 * @param config Keyboard config
147 static void check_for_keys(struct keyb
*config
)
151 if (!config
->first_scan
&&
152 get_timer(config
->last_poll_ms
) < KBC_REPEAT_RATE_MS
)
154 config
->last_poll_ms
= get_timer(0);
155 config
->first_scan
= 0;
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.
161 fifo_cnt
= (readl(&config
->kbc
->interrupt
) >> 4) & 0xf;
162 process_fifo(config
, fifo_cnt
);
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.
171 * @param config Keyboard config
173 static void kbd_wait_for_fifo_init(struct keyb
*config
)
175 if (!config
->inited
) {
176 unsigned long elapsed_time
;
179 elapsed_time
= get_timer(config
->start_time_ms
);
180 delay_ms
= config
->init_dly_ms
- elapsed_time
;
182 udelay(delay_ms
* 1000);
183 debug("%s: delay %ldms\n", __func__
, delay_ms
);
191 * Check the tegra keyboard, and send any keys that are pressed.
193 * This is called by input_tstc() and input_getc() when they need more
196 * @param input Input configuration
197 * @return 1, to indicate that we have something to look at
199 int tegra_kbc_check(struct input_config
*input
)
201 kbd_wait_for_fifo_init(&config
);
202 check_for_keys(&config
);
208 * Test if keys are available to be read
210 * @return 0 if no keys available, 1 if keys are available
212 static int kbd_tstc(void)
214 /* Just get input to do this for us */
215 return input_tstc(&config
.input
);
221 * TODO: U-Boot wants 0 for no key, but Ctrl-@ is a valid key...
223 * @return ASCII key code, or 0 if no key, or -1 if error
225 static int kbd_getc(void)
227 /* Just get input to do this for us */
228 return input_getc(&config
.input
);
231 /* configures keyboard GPIO registers to use the rows and columns */
232 static void config_kbc_gpio(struct kbc_tegra
*kbc
)
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
;
245 row_cfg
= readl(&kbc
->row_cfg
[r_offs
]);
246 col_cfg
= readl(&kbc
->col_cfg
[c_offs
]);
251 if (i
< config
.matrix
.num_rows
) {
252 row_cfg
|= ((i
<< 1) | 1) << r_shift
;
254 col_cfg
|= (((i
- config
.matrix
.num_rows
) << 1) | 1)
258 writel(row_cfg
, &kbc
->row_cfg
[r_offs
]);
259 writel(col_cfg
, &kbc
->col_cfg
[c_offs
]);
264 * Start up the keyboard device
266 static void tegra_kbc_open(void)
268 struct kbc_tegra
*kbc
= config
.kbc
;
269 unsigned int scan_period
;
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().
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
);
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.
283 config
.init_dly_ms
= scan_period
* 2 + 2;
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
);
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;
296 * Set up the tegra keyboard. This is called by the stdio device handler
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.
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().
305 * @return 0 if ok, -ve on error
307 static int init_tegra_keyboard(void)
309 #ifdef CONFIG_OF_CONTROL
312 node
= fdtdec_next_compatible(gd
->fdt_blob
, 0,
313 COMPAT_NVIDIA_TEGRA20_KBC
);
315 debug("%s: cannot locate keyboard node\n", __func__
);
318 config
.kbc
= (struct kbc_tegra
*)fdtdec_get_addr(gd
->fdt_blob
,
320 if ((fdt_addr_t
)config
.kbc
== FDT_ADDR_T_NONE
) {
321 debug("%s: No keyboard register found\n", __func__
);
324 input_set_delays(&config
.input
, KBC_REPEAT_DELAY_MS
,
327 /* Decode the keyboard matrix information (16 rows, 8 columns) */
328 if (key_matrix_init(&config
.matrix
, 16, 8, 1)) {
329 debug("%s: Could not init key matrix\n", __func__
);
332 if (key_matrix_decode_fdt(&config
.matrix
, gd
->fdt_blob
, node
)) {
333 debug("%s: Could not decode key matrix from fdt\n", __func__
);
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
))
343 #error "Tegra keyboard driver requires FDT definitions"
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
);
352 debug("%s: Tegra keyboard ready\n", __func__
);
357 int drv_keyboard_init(void)
359 struct stdio_dev dev
;
361 if (input_init(&config
.input
, 0)) {
362 debug("%s: Cannot set up input\n", __func__
);
365 config
.input
.read_keys
= tegra_kbc_check
;
367 memset(&dev
, '\0', sizeof(dev
));
368 strcpy(dev
.name
, "tegra-kbc");
369 dev
.flags
= DEV_FLAGS_INPUT
| DEV_FLAGS_SYSTEM
;
372 dev
.start
= init_tegra_keyboard
;
374 /* Register the device. init_tegra_keyboard() will be called soon */
375 return input_stdio_register(&dev
);