aboutsummaryrefslogtreecommitdiff
path: root/common/keyboard.c
diff options
context:
space:
mode:
Diffstat (limited to 'common/keyboard.c')
-rw-r--r--common/keyboard.c580
1 files changed, 24 insertions, 556 deletions
diff --git a/common/keyboard.c b/common/keyboard.c
index 2dee51d4b..5e9945baf 100644
--- a/common/keyboard.c
+++ b/common/keyboard.c
@@ -1,5 +1,5 @@
1/* 1/*
2Copyright 2011,2012 Jun Wako <wakojun@gmail.com> 2Copyright 2011,2012,2013 Jun Wako <wakojun@gmail.com>
3 3
4This program is free software: you can redistribute it and/or modify 4This program is free software: you can redistribute it and/or modify
5it under the terms of the GNU General Public License as published by 5it under the terms of the GNU General Public License as published by
@@ -26,536 +26,39 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
26#include "command.h" 26#include "command.h"
27#include "util.h" 27#include "util.h"
28#include "sendchar.h" 28#include "sendchar.h"
29#include "bootloader.h"
29#ifdef MOUSEKEY_ENABLE 30#ifdef MOUSEKEY_ENABLE
30#include "mousekey.h" 31#include "mousekey.h"
31#endif 32#endif
32 33
33 34
34#define Kdebug(s) do { if (debug_keyboard) debug(s); } while(0)
35#define Kdebug_P(s) do { if (debug_keyboard) debug_P(s); } while(0)
36#define Kdebug_hex(s) do { if (debug_keyboard) debug_hex(s); } while(0)
37
38#define LAYER_DELAY 250
39
40typedef enum keykind {
41 NONE,
42 FN_DOWN, FN_UP,
43 FNK_DOWN, FNK_UP,
44 KEY_DOWN, KEY_UP,
45 MOD_DOWN, MOD_UP,
46} keykind_t;
47
48typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;
49
50
51#ifdef KEYMAP_DEFAULT_LAYER
52uint8_t default_layer = KEYMAP_DEFAULT_LAYER;
53uint8_t current_layer = KEYMAP_DEFAULT_LAYER;
54#else
55uint8_t default_layer = 0;
56uint8_t current_layer = 0;
57#endif
58
59/* keyboard internal states */
60static kbdstate_t kbdstate = IDLE;
61static uint8_t fn_state_bits = 0;
62static keyrecord_t delayed_fn;
63static keyrecord_t waiting_key;
64
65
66static const char *state_str(kbdstate_t state)
67{
68 if (state == IDLE) return PSTR("IDLE");
69 if (state == DELAYING) return PSTR("DELAYING");
70 if (state == WAITING) return PSTR("WAITING");
71 if (state == PRESSING) return PSTR("PRESSING");
72 return PSTR("UNKNOWN");
73}
74
75static inline keykind_t get_keykind(uint8_t code, bool pressed)
76{
77 if IS_KEY(code) return (pressed ? KEY_DOWN : KEY_UP);
78 if IS_MOD(code) return (pressed ? MOD_DOWN : MOD_UP);
79 if IS_FN(code) {
80 if (keymap_fn_keycode(FN_INDEX(code)))
81 return (pressed ? FNK_DOWN : FNK_UP);
82 else
83 return (pressed ? FN_DOWN : FN_UP);
84 }
85 if IS_MOUSEKEY(code) return (pressed ? KEY_DOWN : KEY_UP);
86 if IS_SYSTEM(code) return (pressed ? KEY_DOWN : KEY_UP);
87 if IS_CONSUMER(code) return (pressed ? KEY_DOWN : KEY_UP);
88 return NONE;
89}
90
91static void clear_keyboard(void)
92{
93 host_clear_keys();
94 host_clear_mods();
95 host_send_keyboard_report();
96
97 host_system_send(0);
98 host_consumer_send(0);
99
100#ifdef MOUSEKEY_ENABLE
101 mousekey_clear();
102 mousekey_send();
103#endif
104}
105
106static void clear_keyboard_but_mods(void)
107{
108 host_clear_keys();
109 host_send_keyboard_report();
110
111 host_system_send(0);
112 host_consumer_send(0);
113
114#ifdef MOUSEKEY_ENABLE
115 mousekey_clear();
116 mousekey_send();
117#endif
118}
119
120static bool anykey_sent_to_host(void)
121{
122 return (host_has_anykey() || host_mouse_in_use() ||
123 host_last_sysytem_report() || host_last_consumer_report());
124}
125
126static void layer_switch_on(uint8_t code)
127{
128 if (!IS_FN(code)) return;
129 fn_state_bits |= FN_BIT(code);
130 uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer);
131 if (current_layer != new_layer) {
132 Kdebug("Layer Switch(on): "); Kdebug_hex(current_layer);
133 Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
134
135 clear_keyboard_but_mods();
136 current_layer = new_layer;
137 }
138}
139
140static bool layer_switch_off(uint8_t code)
141{
142 if (!IS_FN(code)) return false;
143 fn_state_bits &= ~FN_BIT(code);
144 uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer);
145 if (current_layer != new_layer) {
146 Kdebug("Layer Switch(off): "); Kdebug_hex(current_layer);
147 Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
148
149 clear_keyboard_but_mods();
150 current_layer = new_layer;
151 return true;
152 }
153 return false;
154}
155
156static void register_code(uint8_t code)
157{
158 if IS_KEY(code) {
159 if (!command_proc(code)) {
160 host_add_key(code);
161 host_send_keyboard_report();
162 }
163 }
164 else if IS_MOD(code) {
165 host_add_mod_bit(MOD_BIT(code));
166 host_send_keyboard_report();
167 }
168 else if IS_FN(code) {
169 if (!command_proc(keymap_fn_keycode(FN_INDEX(code)))) {
170 host_add_key(keymap_fn_keycode(FN_INDEX(code)));
171 host_send_keyboard_report();
172 }
173 }
174 else if IS_MOUSEKEY(code) {
175#ifdef MOUSEKEY_ENABLE
176 mousekey_on(code);
177 mousekey_send();
178#endif
179 }
180 else if IS_CONSUMER(code) {
181 uint16_t usage = 0;
182 switch (code) {
183 case KC_AUDIO_MUTE:
184 usage = AUDIO_MUTE;
185 break;
186 case KC_AUDIO_VOL_UP:
187 usage = AUDIO_VOL_UP;
188 break;
189 case KC_AUDIO_VOL_DOWN:
190 usage = AUDIO_VOL_DOWN;
191 break;
192 case KC_MEDIA_NEXT_TRACK:
193 usage = TRANSPORT_NEXT_TRACK;
194 break;
195 case KC_MEDIA_PREV_TRACK:
196 usage = TRANSPORT_PREV_TRACK;
197 break;
198 case KC_MEDIA_STOP:
199 usage = TRANSPORT_STOP;
200 break;
201 case KC_MEDIA_PLAY_PAUSE:
202 usage = TRANSPORT_PLAY_PAUSE;
203 break;
204 case KC_MEDIA_SELECT:
205 usage = AL_CC_CONFIG;
206 break;
207 case KC_MAIL:
208 usage = AL_EMAIL;
209 break;
210 case KC_CALCULATOR:
211 usage = AL_CALCULATOR;
212 break;
213 case KC_MY_COMPUTER:
214 usage = AL_LOCAL_BROWSER;
215 break;
216 case KC_WWW_SEARCH:
217 usage = AC_SEARCH;
218 break;
219 case KC_WWW_HOME:
220 usage = AC_HOME;
221 break;
222 case KC_WWW_BACK:
223 usage = AC_BACK;
224 break;
225 case KC_WWW_FORWARD:
226 usage = AC_FORWARD;
227 break;
228 case KC_WWW_STOP:
229 usage = AC_STOP;
230 break;
231 case KC_WWW_REFRESH:
232 usage = AC_REFRESH;
233 break;
234 case KC_WWW_FAVORITES:
235 usage = AC_BOOKMARKS;
236 break;
237 }
238 host_consumer_send(usage);
239 }
240 else if IS_SYSTEM(code) {
241 uint16_t usage = 0;
242 switch (code) {
243 case KC_SYSTEM_POWER:
244 usage = SYSTEM_POWER_DOWN;
245 break;
246 case KC_SYSTEM_SLEEP:
247 usage = SYSTEM_SLEEP;
248 break;
249 case KC_SYSTEM_WAKE:
250 usage = SYSTEM_WAKE_UP;
251 break;
252 }
253 host_system_send(usage);
254 }
255
256}
257
258static void unregister_code(uint8_t code)
259{
260 if IS_KEY(code) {
261 host_del_key(code);
262 host_send_keyboard_report();
263 }
264 else if IS_MOD(code) {
265 host_del_mod_bit(MOD_BIT(code));
266 host_send_keyboard_report();
267 }
268 else if IS_FN(code) {
269 host_del_key(keymap_fn_keycode(FN_INDEX(code)));
270 host_send_keyboard_report();
271 }
272 else if IS_MOUSEKEY(code) {
273#ifdef MOUSEKEY_ENABLE
274 mousekey_off(code);
275 mousekey_send();
276#endif
277 }
278 else if IS_CONSUMER(code) {
279 host_consumer_send(0x0000);
280 }
281 else if IS_SYSTEM(code) {
282 host_system_send(0x0000);
283 }
284}
285
286/*
287 *
288 * Event/State|IDLE PRESSING DELAYING[f] WAITING[f,k]
289 * -----------+------------------------------------------------------------------
290 * Fn Down |(L+) -*1 WAITING(Sk) IDLE(Rf,Ps)*7
291 * Up |(L-) IDLE(L-)*8 IDLE(L-)*8 IDLE(L-)*8
292 * Fnk Down |DELAYING(Sf)* (Rf) WAITING(Sk) IDLE(Rf,Ps,Rf)
293 * Up |(L-) IDLE(L-/Uf)*8 IDLE(Rf,Uf/L-)*3 IDLE(Rf,Ps,Uf/L-)*3
294 * Key Down |PRESSING(Rk) (Rk) WAITING(Sk) IDLE(Rf,Ps,Rk)
295 * Up |(Uk) IDLE(Uk)*4 (Uk) IDLE(L+,Ps,Pk)/(Uk)*a
296 * |
297 * Delay |- - IDLE(L+) IDLE(L+,Ps)
298 * Magic Key |COMMAND*5
299 *
300 * *1: ignore Fn if other key is down.
301 * *2: register Fnk if any key is pressing
302 * *3: register/unregister delayed Fnk and move to IDLE if code == delayed Fnk, else *8
303 * *4: if no keys registered to host
304 * *5: unregister all keys
305 * *6: only if no keys down
306 * *7: ignore Fn because Fnk key and stored key are down.
307 * *8: move to IDLE if layer switch(off) occurs, else stay at current state
308 * *9: repeat key if pressing Fnk twice quickly(move to PRESSING)
309 * *a: layer switch and process waiting key and code if code == wainting key, else unregister key
310 *
311 * States:
312 * IDLE: No key is down except modifiers
313 * DELAYING: delay layer switch after pressing Fn with alt keycode
314 * WAITING: key is pressed during DELAYING
315 *
316 * Events:
317 * Fn: Fn key without alternative keycode
318 * Fnk: Fn key with alternative keycode
319 * -: ignore
320 * Delay: layer switch delay term is elapsed
321 *
322 * Actions:
323 * Rk: register key
324 * Uk: unregister key
325 * Rf: register Fn(alt keycode)
326 * Uf: unregister Fn(alt keycode)
327 * Rs: register stored key
328 * Us: unregister stored key
329 * Sk: Store key(waiting Key)
330 * Sf: Store Fn(delayed Fn)
331 * Ps: Process stored key
332 * Ps: Process key
333 * Is: Interpret stored keys in current layer
334 * L+: Switch to new layer(*unregister* all keys but modifiers)
335 * L-: Switch back to last layer(*unregister* all keys but modifiers)
336 * Ld: Switch back to default layer(*unregister* all keys but modifiers)
337 */
338#define NEXT(state) do { \
339 Kdebug("NEXT: "); Kdebug_P(state_str(kbdstate)); \
340 kbdstate = state; \
341 Kdebug(" -> "); Kdebug_P(state_str(kbdstate)); Kdebug("\n"); \
342} while (0)
343
344static inline void process_key(keyevent_t event)
345{
346 uint8_t code = keymap_get_keycode(current_layer, event.key.row, event.key.col);
347 keykind_t kind = get_keykind(code, event.pressed);
348
349 uint8_t tmp_mods;
350
351 Kdebug("state: "); Kdebug_P(state_str(kbdstate));
352 Kdebug(" kind: "); Kdebug_hex(kind);
353 Kdebug(" code: "); Kdebug_hex(code);
354 if (event.pressed) { Kdebug("d"); } else { Kdebug("u"); }
355 Kdebug("\n");
356
357 switch (kbdstate) {
358 case IDLE:
359 switch (kind) {
360 case FN_DOWN:
361 layer_switch_on(code);
362 break;
363 case FN_UP:
364 layer_switch_off(code);
365 break;
366 case FNK_DOWN:
367 // repeat Fn alt key when press Fn key down, up then down again quickly
368 if (KEYEQ(delayed_fn.event.key, event.key) &&
369 timer_elapsed(delayed_fn.time) < LAYER_DELAY) {
370 register_code(code);
371 NEXT(PRESSING);
372 } else {
373 delayed_fn = (keyrecord_t) {
374 .event = event,
375 .code = code,
376 .mods = keyboard_report->mods,
377 .time = timer_read()
378 };
379 NEXT(DELAYING);
380 }
381 break;
382 case FNK_UP:
383 layer_switch_off(code);
384 break;
385 case KEY_DOWN:
386 register_code(code);
387 NEXT(PRESSING);
388 break;
389 case MOD_DOWN:
390 register_code(code);
391 break;
392 case KEY_UP:
393 case MOD_UP:
394 unregister_code(code);
395 break;
396 default:
397 break;
398 }
399 break;
400 case PRESSING:
401 switch (kind) {
402 case FN_DOWN:
403 // ignored when any key is pressed
404 break;
405 case FN_UP:
406 if (layer_switch_off(code))
407 NEXT(IDLE);
408 break;
409 case FNK_DOWN:
410 register_code(code);
411 break;
412 case FNK_UP:
413 if (layer_switch_off(code)) {
414 NEXT(IDLE);
415 } else {
416 unregister_code(code);
417 if (!anykey_sent_to_host())
418 NEXT(IDLE);
419 }
420 break;
421 case KEY_DOWN:
422 case MOD_DOWN:
423 register_code(code);
424 break;
425 case KEY_UP:
426 case MOD_UP:
427 unregister_code(code);
428 if (!anykey_sent_to_host())
429 NEXT(IDLE);
430 break;
431 default:
432 break;
433 }
434 break;
435 case DELAYING:
436 switch (kind) {
437 case FN_DOWN:
438 case FNK_DOWN:
439 case KEY_DOWN:
440 waiting_key = (keyrecord_t) {
441 .event = event,
442 .code = code,
443 .mods = keyboard_report->mods,
444 .time = timer_read()
445 };
446 NEXT(WAITING);
447 break;
448 case MOD_DOWN:
449 register_code(code);
450 break;
451 case FN_UP:
452 if (layer_switch_off(code))
453 NEXT(IDLE);
454 break;
455 case FNK_UP:
456 if (code == delayed_fn.code) {
457 // type Fn with alt keycode
458 // restore the mod status at the time of pressing Fn key
459 tmp_mods = keyboard_report->mods;
460 host_set_mods(delayed_fn.mods);
461 register_code(delayed_fn.code);
462 unregister_code(delayed_fn.code);
463 host_set_mods(tmp_mods);
464 NEXT(IDLE);
465 } else {
466 if (layer_switch_off(code))
467 NEXT(IDLE);
468 }
469 break;
470 case KEY_UP:
471 case MOD_UP:
472 unregister_code(code);
473 break;
474 default:
475 break;
476 }
477 break;
478 case WAITING:
479 switch (kind) {
480 case FN_DOWN:
481 case FNK_DOWN:
482 case KEY_DOWN:
483 tmp_mods = keyboard_report->mods;
484 host_set_mods(delayed_fn.mods);
485 register_code(delayed_fn.code);
486 host_set_mods(waiting_key.mods);
487 register_code(waiting_key.code);
488 host_set_mods(tmp_mods);
489 if (kind == FN_DOWN) {
490 // ignore Fn
491 } else if (kind == FNK_DOWN) {
492 register_code(code);
493 } else if (kind == KEY_DOWN) {
494 register_code(code);
495 }
496 NEXT(IDLE);
497 break;
498 case MOD_DOWN:
499 register_code(code);
500 break;
501 case FN_UP:
502 if (layer_switch_off(code))
503 NEXT(IDLE);
504 break;
505 case FNK_UP:
506 if (code == delayed_fn.code) {
507 // alt down, key down, alt up
508 tmp_mods = keyboard_report->mods;
509 host_set_mods(delayed_fn.mods);
510 register_code(delayed_fn.code);
511 host_set_mods(waiting_key.mods);
512 register_code(waiting_key.code);
513 unregister_code(delayed_fn.code);
514 host_set_mods(tmp_mods);
515 NEXT(IDLE);
516 } else {
517 if (layer_switch_off(code))
518 NEXT(IDLE);
519 }
520 break;
521 case KEY_UP:
522 if (code == waiting_key.code) {
523 layer_switch_on(delayed_fn.code);
524 NEXT(IDLE);
525 // process waiting_key
526 tmp_mods = keyboard_report->mods;
527 host_set_mods(waiting_key.mods);
528 process_key(waiting_key.event);
529 host_set_mods(tmp_mods);
530 process_key(event);
531 } else {
532 unregister_code(code);
533 }
534 break;
535 case MOD_UP:
536 unregister_code(code);
537 break;
538 default:
539 break;
540 }
541 break;
542 }
543}
544
545void keyboard_init(void) 35void keyboard_init(void)
546{ 36{
547 // TODO: to enable debug print magic key bind on boot time
548
549 // TODO: configuration of sendchar impl 37 // TODO: configuration of sendchar impl
550 print_sendchar_func = sendchar; 38 print_sendchar_func = sendchar;
551 39
552 timer_init(); 40 timer_init();
553 matrix_init(); 41 matrix_init();
42
43 /* boot magic keys goes here */
44 matrix_scan();
45#ifdef IS_BOOTMAGIC_BOOTLOADER
46 /* kick up bootloader */
47 if (IS_BOOTMAGIC_BOOTLOADER()) bootloader_jump();
48#endif
49#ifdef IS_BOOTMAGIC_DEBUG
50 if (IS_BOOTMAGIC_DEBUG()) debug_enable = true;
51#endif
52
554#ifdef PS2_MOUSE_ENABLE 53#ifdef PS2_MOUSE_ENABLE
555 ps2_mouse_init(); 54 ps2_mouse_init();
556#endif 55#endif
557} 56}
558 57
58/*
59 * Do keyboard routine jobs: scan mantrix, light LEDs, ...
60 * This is repeatedly called as fast as possible.
61 */
559void keyboard_task(void) 62void keyboard_task(void)
560{ 63{
561 static matrix_row_t matrix_prev[MATRIX_ROWS]; 64 static matrix_row_t matrix_prev[MATRIX_ROWS];
@@ -572,9 +75,10 @@ void keyboard_task(void)
572 75
573 for (uint8_t c = 0; c < MATRIX_COLS; c++) { 76 for (uint8_t c = 0; c < MATRIX_COLS; c++) {
574 if (matrix_change & ((matrix_row_t)1<<c)) { 77 if (matrix_change & ((matrix_row_t)1<<c)) {
575 process_key((keyevent_t){ 78 action_exec((keyevent_t){
576 .key = (key_t){ .row = r, .col = c }, 79 .key.pos = (keypos_t){ .row = r, .col = c },
577 .pressed = (matrix_row & ((matrix_row_t)1<<c)) 80 .pressed = (matrix_row & (1<<c)),
81 .time = (timer_read() | 1) /* time should not be 0 */
578 }); 82 });
579 // record a processed key 83 // record a processed key
580 matrix_prev[r] ^= ((matrix_row_t)1<<c); 84 matrix_prev[r] ^= ((matrix_row_t)1<<c);
@@ -584,55 +88,19 @@ void keyboard_task(void)
584 } 88 }
585 } 89 }
586 } 90 }
587 MATRIX_LOOP_END: 91 // call with pseudo tick event when no real key event.
588 92 action_exec(TICK);
589 // layer switch when delay term elapses
590 if (kbdstate == DELAYING || kbdstate == WAITING) {
591 if (timer_elapsed(delayed_fn.time) > LAYER_DELAY) {
592 if (kbdstate == DELAYING) {
593 layer_switch_on(delayed_fn.code);
594 NEXT(IDLE);
595 }
596 if (kbdstate == WAITING) {
597 layer_switch_on(delayed_fn.code);
598 NEXT(IDLE);
599 uint8_t tmp_mods = keyboard_report->mods;
600 host_set_mods(waiting_key.mods);
601 process_key(waiting_key.event);
602 host_set_mods(tmp_mods);
603 }
604 }
605 }
606 93
94MATRIX_LOOP_END:
607#ifdef MOUSEKEY_ENABLE 95#ifdef MOUSEKEY_ENABLE
608 // mousekey repeat & acceleration 96 // mousekey repeat & acceleration
609 mousekey_task(); 97 mousekey_task();
610#endif 98#endif
611
612 // FAIL SAFE: clear all key if no key down
613 if (matrix_change) {
614 matrix_row_t is_matrix_on = 0;
615 for (int r = 0; r < MATRIX_ROWS; r++) {
616 is_matrix_on |= matrix_get_row(r);
617 }
618 if (!is_matrix_on) {
619 Kdebug("FAIL SAFE: clear all keys(default layer).\n");
620 clear_keyboard();
621 current_layer = default_layer;
622 fn_state_bits = 0;
623 delayed_fn = (keyrecord_t){};
624 waiting_key = (keyrecord_t){};
625 NEXT(IDLE);
626 }
627 }
628
629 // update LED 99 // update LED
630 if (led_status != host_keyboard_leds()) { 100 if (led_status != host_keyboard_leds()) {
631 led_status = host_keyboard_leds(); 101 led_status = host_keyboard_leds();
632 keyboard_set_leds(led_status); 102 keyboard_set_leds(led_status);
633 } 103 }
634
635 return;
636} 104}
637 105
638void keyboard_set_leds(uint8_t leds) 106void keyboard_set_leds(uint8_t leds)
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-12 20:48:51 +0000