common/keyboard.c

   1 /*
   2 Copyright 2011 Jun Wako <wakojun@gmail.com>
   3
   4 This program is free software: you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation, either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17 #include "keyboard.h"
  18 #include "matrix.h"
  19 #include "keymap.h"
  20 #include "host.h"
  21 #include "led.h"
  22 #include "keycode.h"
  23 #include "timer.h"
  24 #include "print.h"
  25 #include "debug.h"
  26 #include "command.h"
  27 #include "util.h"
  28 #ifdef MOUSEKEY_ENABLE
  29 #include "mousekey.h"
  30 #endif
  31 #ifdef EXTRAKEY_ENABLE
  32 #include <util/delay.h>
  33 #endif
  34
  35
  36 #define LAYER_DELAY     250
  37
  38 typedef enum keykind {
  39     NONE,
  40     FN_DOWN, FN_UP,
  41     FNK_DOWN, FNK_UP,
  42     KEY_DOWN, KEY_UP,
  43     MOD_DOWN, MOD_UP,
  44 } keykind_t;
  45
  46 typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;
  47
  48
  49 uint8_t current_layer = 0;
  50 uint8_t default_layer = 0;
  51
  52 /* keyboard internal states */
  53 static kbdstate_t kbdstate = IDLE;
  54 static uint8_t fn_state_bits = 0;
  55 static keyrecord_t delayed_fn;
  56 static keyrecord_t waiting_key;
  57
  58
  59 static const char *state_str(kbdstate_t state)
  60 {
  61     if (state == IDLE)      return PSTR("IDLE");
  62     if (state == DELAYING)  return PSTR("DELAYING");
  63     if (state == WAITING)   return PSTR("WAITING");
  64     if (state == PRESSING)  return PSTR("PRESSING");
  65     return PSTR("UNKNOWN");
  66 }
  67
  68 static inline keykind_t get_keykind(uint8_t code, bool pressed)
  69 {
  70     if IS_KEY(code)         return (pressed ? KEY_DOWN : KEY_UP);
  71     if IS_MOD(code)         return (pressed ? MOD_DOWN : MOD_UP);
  72     if IS_FN(code) {
  73         if (keymap_fn_keycode(FN_INDEX(code)))
  74             return (pressed ? FNK_DOWN : FNK_UP);
  75         else
  76             return (pressed ? FN_DOWN : FN_UP);
  77     }
  78     if IS_MOUSEKEY(code)    return (pressed ? KEY_DOWN : KEY_UP);
  79     if IS_SYSTEM(code)      return (pressed ? KEY_DOWN : KEY_UP);
  80     if IS_CONSUMER(code)    return (pressed ? KEY_DOWN : KEY_UP);
  81     return  NONE;
  82 }
  83
  84 static void layer_switch_on(uint8_t code)
  85 {
  86     if (!IS_FN(code)) return;
  87     fn_state_bits |= FN_BIT(code);
  88     if (current_layer != keymap_fn_layer(FN_INDEX(code))) {
  89         // clear all key execpt Mod key
  90         host_clear_all_keys_but_mods();
  91         host_system_send(0);
  92         host_consumer_send(0);
  93         mousekey_clear();
  94         mousekey_send();
  95
  96         debug("Layer Switch(on): "); debug_hex(current_layer);
  97         current_layer = keymap_fn_layer(FN_INDEX(code));
  98         debug(" -> "); debug_hex(current_layer); debug("\n");
  99     }
 100 }
 101
 102 static void layer_switch_off(uint8_t code)
 103 {
 104     if (!IS_FN(code)) return;
 105     fn_state_bits &= ~FN_BIT(code);
 106     if (current_layer != keymap_fn_layer(biton(fn_state_bits))) {
 107         // clear all key execpt Mod key
 108         host_clear_all_keys_but_mods();
 109         host_system_send(0);
 110         host_consumer_send(0);
 111         mousekey_clear();
 112         mousekey_send();
 113
 114         debug("Layer Switch(off): "); debug_hex(current_layer);
 115         current_layer = keymap_fn_layer(biton(fn_state_bits));
 116         debug(" -> "); debug_hex(current_layer); debug("\n");
 117     }
 118 }
 119
 120 static inline uint8_t get_keycode(key_t key)
 121 {
 122     return keymap_get_keycode(current_layer, key.row, key.col);
 123 }
 124
 125 // whether any key except modifier is down or not
 126 static inline bool is_anykey_down(void)
 127 {
 128     for (int r = 0; r < MATRIX_ROWS; r++) {
 129         matrix_row_t matrix_row = matrix_get_row(r);
 130         for (int c = 0; c < MATRIX_COLS; c++) {
 131             if (matrix_row && (1<<c)) {
 132                 if (IS_KEY(get_keycode((key_t){ .row = r, .col = c }))) {
 133                     return true;
 134                 }
 135             }
 136         }
 137     }
 138     return false;
 139 }
 140
 141 static void register_code(uint8_t code)
 142 {
 143 debug("register_code\n");
 144     if IS_KEY(code) {
 145         host_add_key(code);
 146         host_send_keyboard_report();
 147     }
 148     else if IS_MOD(code) {
 149         host_add_mod_bit(MOD_BIT(code));
 150         host_send_keyboard_report();
 151     }
 152     else if IS_MOUSEKEY(code) {
 153         mousekey_on(code);
 154         mousekey_send();
 155     }
 156     else if IS_CONSUMER(code) {
 157 debug("consumer\n");
 158         uint16_t usage = 0;
 159         switch (code) {
 160             case KC_AUDIO_MUTE:
 161                 usage = AUDIO_MUTE;
 162                 break;
 163             case KC_AUDIO_VOL_UP:
 164                 usage = AUDIO_VOL_UP;
 165                 break;
 166             case KC_AUDIO_VOL_DOWN:
 167                 usage = AUDIO_VOL_DOWN;
 168                 break;
 169             case KC_MEDIA_NEXT_TRACK:
 170                 usage = TRANSPORT_NEXT_TRACK;
 171                 break;
 172             case KC_MEDIA_PREV_TRACK:
 173                 usage = TRANSPORT_PREV_TRACK;
 174                 break;
 175             case KC_MEDIA_STOP:
 176                 usage = TRANSPORT_STOP;
 177                 break;
 178             case KC_MEDIA_PLAY_PAUSE:
 179                 usage = TRANSPORT_PLAY_PAUSE;
 180                 break;
 181             case KC_MEDIA_SELECT:
 182                 usage = AL_CC_CONFIG;
 183                 break;
 184             case KC_MAIL:
 185                 usage = AL_EMAIL;
 186                 break;
 187             case KC_CALCULATOR:
 188                 usage = AL_CALCULATOR;
 189                 break;
 190             case KC_MY_COMPUTER:
 191                 usage = AL_LOCAL_BROWSER;
 192                 break;
 193             case KC_WWW_SEARCH:
 194                 usage = AC_SEARCH;
 195                 break;
 196             case KC_WWW_HOME:
 197                 usage = AC_HOME;
 198                 break;
 199             case KC_WWW_BACK:
 200                 usage = AC_BACK;
 201                 break;
 202             case KC_WWW_FORWARD:
 203                 usage = AC_FORWARD;
 204                 break;
 205             case KC_WWW_STOP:
 206                 usage = AC_STOP;
 207                 break;
 208             case KC_WWW_REFRESH:
 209                 usage = AC_REFRESH;
 210                 break;
 211             case KC_WWW_FAVORITES:
 212                 usage = AC_BOOKMARKS;
 213                 break;
 214         }
 215 debug("usage: "); phex16(usage); debug("\n");
 216         host_consumer_send(usage);
 217     }
 218     else if IS_SYSTEM(code) {
 219         uint16_t usage = 0;
 220         switch (code) {
 221             case KC_SYSTEM_POWER:
 222                 usage = SYSTEM_POWER_DOWN;
 223                 break;
 224             case KC_SYSTEM_SLEEP:
 225                 usage = SYSTEM_SLEEP;
 226                 break;
 227             case KC_SYSTEM_WAKE:
 228                 usage = SYSTEM_WAKE_UP;
 229                 break;
 230         }
 231         host_system_send(usage);
 232     }
 233
 234 }
 235
 236 static void unregister_code(uint8_t code)
 237 {
 238     if IS_KEY(code) {
 239         host_del_key(code);
 240         host_send_keyboard_report();
 241     }
 242     else if IS_MOD(code) {
 243         host_del_mod_bit(MOD_BIT(code));
 244         host_send_keyboard_report();
 245     }
 246     else if IS_MOUSEKEY(code) {
 247         mousekey_off(code);
 248         mousekey_send();
 249     }
 250     else if IS_CONSUMER(code) {
 251         host_consumer_send(0x0000);
 252     }
 253     else if IS_SYSTEM(code) {
 254         host_system_send(0x0000);
 255     }
 256 }
 257
 258 /*
 259  *
 260  * Event/State|IDLE             DELAYING[f]     WAITING[f,k]        PRESSING
 261  * -----------+------------------------------------------------------------------
 262  * Fn  Down   |IDLE(L+)         WAITING(Sk)     WAITING(Sk)         -
 263  *     Up     |IDLE(L-)         IDLE(L-)        IDLE(L-)            IDLE(L-)
 264  * Fnk Down   |DELAYING(Sf)     WAITING(Sk)     WAINTING(Sk)        PRESSING(Rf)
 265  *     Up     |IDLE(L-)         IDLE(Rf,Uf)     IDLE(Rf,Ps,Uf)*3    PRESSING(Uf)
 266  * Key Down   |PRESSING(Rk)     WAITING(Sk)     WAITING(Sk)         PRESSING(Rk)
 267  *     Up     |IDLE(Uk)         DELAYING(Uk)    IDLE(L+,Ps,Uk)      IDLE(Uk)*4
 268  * Delay      |-                IDLE(L+)        IDLE(L+,Ps)         -
 269  *            |
 270  * No key Down|IDLE(Ld)         IDLE(Ld)        IDLE(Ld)            IDLE(Ld)
 271  *
 272  * *2: register Fnk if any key is pressing
 273  * *3: when Fnk == Stored Fnk, if not ignore.
 274  * *4: when no registered key any more
 275  *
 276  * States:
 277  *      IDLE:
 278  *      DELAYING: delay layer switch after pressing Fn with alt keycode
 279  *      WAITING: key is pressed during DELAYING
 280  *
 281  * Events:
 282  *      Fn: Fn key without alternative keycode
 283  *      Fnk: Fn key with alternative keycode
 284  *      -: ignore
 285  *
 286  * Actions:
 287  *      Rk: register key
 288  *      Uk: unregister key
 289  *      Rf: register stored Fn(alt keycode)
 290  *      Uf: unregister stored Fn(alt keycode)
 291  *      Rs: register stored key
 292  *      Us: unregister stored key
 293  *      Sk: store key
 294  *      Sf: store Fn
 295  *      Ps: play stored key(Interpret stored key and transit state)
 296  *      L+: Switch to new layer(*retain* Modifiers only)
 297  *      L-: Switch back to last layer(*clear* stored key/Fn, *unregister* all Modifier/key)
 298  *      Ld: Switch back to default layer(*clear* stored key/Fn, *unregister* all Modifier/key)
 299  */
 300 #define NEXT(state)     do { \
 301     debug("NEXT: "); print_P(state_str(kbdstate)); \
 302     kbdstate = state; \
 303     debug(" -> "); print_P(state_str(kbdstate)); debug("\n"); \
 304 } while (0)
 305
 306 static inline void process_key(keyevent_t event)
 307 {
 308     /* TODO: ring buffer
 309     static keyrecord_t waiting_keys[5];
 310     static uint8_t waiting_keys_head = 0;
 311     static uint8_t waiting_keys_tail = 0;
 312     */
 313
 314     uint8_t code = get_keycode(event.key);
 315     keykind_t kind = get_keykind(code, event.pressed);
 316
 317     uint8_t tmp_mods;
 318
 319     debug("state: "); print_P(state_str(kbdstate));
 320     debug(" kind: "); debug_hex(kind);
 321     debug(" code: "); debug_hex(code);
 322     if (event.pressed) { debug("d"); } else { debug("u"); }
 323     debug("\n");
 324
 325     switch (kbdstate) {
 326         case IDLE:
 327             switch (kind) {
 328                 case FN_DOWN:
 329                     layer_switch_on(code);
 330                     break;
 331                 case FN_UP:
 332                     layer_switch_off(code);
 333                     break;
 334                 case FNK_DOWN:
 335                     // repeat Fn alt key when press Fn key down, up then down again quickly
 336                     if (KEYEQ(delayed_fn.event.key, event.key) &&
 337                             timer_elapsed(delayed_fn.time) < LAYER_DELAY) {
 338                         register_code(keymap_fn_keycode(FN_INDEX(code)));
 339                         NEXT(PRESSING);
 340                     } else {
 341                         delayed_fn = (keyrecord_t) {
 342                             .event = event,
 343                             .code = code,
 344                             .mods = keyboard_report->mods,
 345                             .time = timer_read()
 346                         };
 347                         NEXT(DELAYING);
 348                     }
 349                     break;
 350                 case FNK_UP:
 351                     layer_switch_off(code);
 352                     break;
 353                 case KEY_DOWN:
 354                     register_code(code);
 355                     NEXT(PRESSING);
 356                     break;
 357                 case MOD_DOWN:
 358                     register_code(code);
 359                     break;
 360                 case KEY_UP:
 361                 case MOD_UP:
 362                     unregister_code(code);
 363                     break;
 364                 default:
 365                     break;
 366             }
 367             break;
 368         case PRESSING:
 369             switch (kind) {
 370                 case FN_DOWN:
 371                     // ignored when any key is pressed
 372                     break;
 373                 case FN_UP:
 374                     layer_switch_off(code);
 375                     NEXT(IDLE);
 376                     break;
 377                 case FNK_DOWN:
 378                     register_code(keymap_fn_keycode(FN_INDEX(code)));
 379                     break;
 380                 case FNK_UP:
 381                     // can't know whether layer switched or not
 382                     layer_switch_off(code);
 383                     unregister_code(keymap_fn_keycode(FN_INDEX(code)));
 384                     break;
 385                 case KEY_DOWN:
 386                 case MOD_DOWN:
 387                     register_code(code);
 388                     break;
 389                 case KEY_UP:
 390                 case MOD_UP:
 391                     unregister_code(code);
 392                     // no key registered? mousekey, mediakey, systemkey
 393                     if (!host_has_anykey())
 394                         NEXT(IDLE);
 395                     break;
 396                 default:
 397                     break;
 398             }
 399             break;
 400         case DELAYING:
 401             switch (kind) {
 402                 case FN_DOWN:
 403                 case FNK_DOWN:
 404                 case KEY_DOWN:
 405                     waiting_key = (keyrecord_t) {
 406                         .event = event,
 407                         .code = code,
 408                         .mods = keyboard_report->mods,
 409                         .time = timer_read()
 410                     };
 411                     NEXT(WAITING);
 412                     break;
 413                 case MOD_DOWN:
 414                     register_code(code);
 415                     break;
 416                 case FN_UP:
 417                     layer_switch_off(code);
 418                     NEXT(IDLE);
 419                     break;
 420                 case FNK_UP:
 421                     if (code == delayed_fn.code) {
 422                         // type Fn with alt keycode
 423                         // restore the mod status at the time of pressing Fn key
 424                         tmp_mods = keyboard_report->mods;
 425                         host_set_mods(delayed_fn.mods);
 426                         register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 427                         unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 428                         host_set_mods(tmp_mods);
 429                         NEXT(IDLE);
 430                     } else {
 431                         layer_switch_off(code);
 432                         NEXT(IDLE);
 433                     }
 434                     break;
 435                 case KEY_UP:
 436                     unregister_code(code);
 437                     NEXT(IDLE);
 438                     break;
 439                 case MOD_UP:
 440                     unregister_code(code);
 441                     break;
 442                 default:
 443                     break;
 444             }
 445             break;
 446         case WAITING:
 447             switch (kind) {
 448                 case FN_DOWN:
 449                 case FNK_DOWN:
 450                 case KEY_DOWN:
 451                     tmp_mods = keyboard_report->mods;
 452                     host_set_mods(delayed_fn.mods);
 453                     register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 454                     host_set_mods(waiting_key.mods);
 455                     register_code(waiting_key.code);
 456                     host_set_mods(tmp_mods);
 457                     register_code(code);
 458                     NEXT(IDLE);
 459                     break;
 460                 case MOD_DOWN:
 461                     register_code(code);
 462                     break;
 463                 case FN_UP:
 464                     layer_switch_off(code);
 465                     NEXT(IDLE);
 466                     break;
 467                 case FNK_UP:
 468                     if (code == delayed_fn.code) {
 469                         // alt down, key down, alt up
 470                         tmp_mods = keyboard_report->mods;
 471                         host_set_mods(delayed_fn.mods);
 472                         register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 473                         host_set_mods(waiting_key.mods);
 474                         register_code(waiting_key.code);
 475                         unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 476                         host_set_mods(tmp_mods);
 477                         NEXT(IDLE);
 478                     } else {
 479                         layer_switch_off(code);
 480                         NEXT(IDLE);
 481                     }
 482                     break;
 483                 case KEY_UP:
 484                     if (code == waiting_key.code) {
 485                         layer_switch_on(delayed_fn.code);
 486                         NEXT(IDLE);
 487                         // process waiting_key
 488                         tmp_mods = keyboard_report->mods;
 489                         host_set_mods(waiting_key.mods);
 490                         process_key(waiting_key.event);
 491                         host_set_mods(tmp_mods);
 492                         process_key(event);
 493                     } else {
 494                         unregister_code(code);
 495                     }
 496                     break;
 497                 case MOD_UP:
 498                     unregister_code(code);
 499                     break;
 500                 default:
 501                     break;
 502             }
 503             break;
 504     }
 505
 506     // TODO: FAIL SAFE: unregister all keys when no key down
 507 }
 508
 509 void keyboard_init(void)
 510 {
 511     debug_keyboard = true;
 512
 513     timer_init();
 514     matrix_init();
 515 #ifdef PS2_MOUSE_ENABLE
 516     ps2_mouse_init();
 517 #endif
 518 }
 519
 520 void keyboard_task(void)
 521 {
 522     static matrix_row_t matrix_prev[MATRIX_ROWS];
 523     matrix_row_t matrix_row = 0;
 524     matrix_row_t matrix_change = 0;
 525
 526     matrix_scan();
 527     if (command_proc()) {
 528         debug("COMMAND\n");
 529         // TODO: clear all keys
 530         host_clear_keyboard_report();
 531         host_send_keyboard_report();
 532         return;
 533     }
 534     for (int r = 0; r < MATRIX_ROWS; r++) {
 535         matrix_row = matrix_get_row(r);
 536         matrix_change = matrix_row ^ matrix_prev[r];
 537         if (matrix_change) {
 538             if (debug_matrix) matrix_print();
 539
 540             for (int c = 0; c < MATRIX_COLS; c++) {
 541                 if (matrix_change & (1<<c)) {
 542                     process_key((keyevent_t){
 543                         .key = (key_t){ .row = r, .col = c },
 544                         .pressed = (matrix_row & (1<<c))
 545                     });
 546                     // record a processed key
 547                     matrix_prev[r] ^= (1<<c);
 548                     // process a key per task call
 549                     goto MATRIX_LOOP_END;
 550                 }
 551             }
 552         }
 553     }
 554     MATRIX_LOOP_END:
 555     // TODO: FAIL SAFE: clear all key if no key down
 556
 557     // layer switch when delay term elapses
 558     if (kbdstate == DELAYING || kbdstate == WAITING) {
 559         if (timer_elapsed(delayed_fn.time) > LAYER_DELAY) {
 560             if (kbdstate == DELAYING) {
 561                 layer_switch_on(delayed_fn.code);
 562                 NEXT(IDLE);
 563             }
 564             if (kbdstate == WAITING) {
 565                 layer_switch_on(delayed_fn.code);
 566                 NEXT(IDLE);
 567                 uint8_t tmp_mods = keyboard_report->mods;
 568                 host_set_mods(waiting_key.mods);
 569                 process_key(waiting_key.event);
 570                 host_set_mods(tmp_mods);
 571             }
 572         }
 573     }
 574
 575     // mousekey repeat & acceleration
 576     mousekey_task();
 577
 578     return;
 579 }
 580
 581 void keyboard_set_leds(uint8_t leds)
 582 {
 583     led_set(leds);
 584 }