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 clear_keyboard(void)
  85 {
  86     host_clear_keys();
  87     host_clear_mods();
  88     host_send_keyboard_report();
  89
  90     host_system_send(0);
  91     host_consumer_send(0);
  92
  93     mousekey_clear();
  94     mousekey_send();
  95 }
  96
  97 static void clear_keyboard_but_mods(void)
  98 {
  99     host_clear_keys();
 100     host_send_keyboard_report();
 101
 102     host_system_send(0);
 103     host_consumer_send(0);
 104
 105     mousekey_clear();
 106     mousekey_send();
 107 }
 108
 109 static void layer_switch_on(uint8_t code)
 110 {
 111     if (!IS_FN(code)) return;
 112     fn_state_bits |= FN_BIT(code);
 113     if (current_layer != keymap_fn_layer(FN_INDEX(code))) {
 114         clear_keyboard_but_mods();
 115
 116         debug("Layer Switch(on): "); debug_hex(current_layer);
 117         current_layer = keymap_fn_layer(FN_INDEX(code));
 118         debug(" -> "); debug_hex(current_layer); debug("\n");
 119     }
 120 }
 121
 122 static void layer_switch_off(uint8_t code)
 123 {
 124     if (!IS_FN(code)) return;
 125     fn_state_bits &= ~FN_BIT(code);
 126     if (current_layer != keymap_fn_layer(biton(fn_state_bits))) {
 127         clear_keyboard_but_mods();
 128
 129         debug("Layer Switch(off): "); debug_hex(current_layer);
 130         current_layer = keymap_fn_layer(biton(fn_state_bits));
 131         debug(" -> "); debug_hex(current_layer); debug("\n");
 132     }
 133 }
 134
 135 // whether any key except modifier is down or not
 136 static inline bool is_anykey_down(void)
 137 {
 138     for (int r = 0; r < MATRIX_ROWS; r++) {
 139         matrix_row_t matrix_row = matrix_get_row(r);
 140         for (int c = 0; c < MATRIX_COLS; c++) {
 141             if (matrix_row && (1<<c)) {
 142                 if (IS_KEY(keymap_get_keycode(current_layer, r, c))) {
 143                     return true;
 144                 }
 145             }
 146         }
 147     }
 148     return false;
 149 }
 150
 151 static void register_code(uint8_t code)
 152 {
 153     if IS_KEY(code) {
 154         host_add_key(code);
 155         host_send_keyboard_report();
 156     }
 157     else if IS_MOD(code) {
 158         host_add_mod_bit(MOD_BIT(code));
 159         host_send_keyboard_report();
 160     }
 161     else if IS_MOUSEKEY(code) {
 162         mousekey_on(code);
 163         mousekey_send();
 164     }
 165     else if IS_CONSUMER(code) {
 166         uint16_t usage = 0;
 167         switch (code) {
 168             case KC_AUDIO_MUTE:
 169                 usage = AUDIO_MUTE;
 170                 break;
 171             case KC_AUDIO_VOL_UP:
 172                 usage = AUDIO_VOL_UP;
 173                 break;
 174             case KC_AUDIO_VOL_DOWN:
 175                 usage = AUDIO_VOL_DOWN;
 176                 break;
 177             case KC_MEDIA_NEXT_TRACK:
 178                 usage = TRANSPORT_NEXT_TRACK;
 179                 break;
 180             case KC_MEDIA_PREV_TRACK:
 181                 usage = TRANSPORT_PREV_TRACK;
 182                 break;
 183             case KC_MEDIA_STOP:
 184                 usage = TRANSPORT_STOP;
 185                 break;
 186             case KC_MEDIA_PLAY_PAUSE:
 187                 usage = TRANSPORT_PLAY_PAUSE;
 188                 break;
 189             case KC_MEDIA_SELECT:
 190                 usage = AL_CC_CONFIG;
 191                 break;
 192             case KC_MAIL:
 193                 usage = AL_EMAIL;
 194                 break;
 195             case KC_CALCULATOR:
 196                 usage = AL_CALCULATOR;
 197                 break;
 198             case KC_MY_COMPUTER:
 199                 usage = AL_LOCAL_BROWSER;
 200                 break;
 201             case KC_WWW_SEARCH:
 202                 usage = AC_SEARCH;
 203                 break;
 204             case KC_WWW_HOME:
 205                 usage = AC_HOME;
 206                 break;
 207             case KC_WWW_BACK:
 208                 usage = AC_BACK;
 209                 break;
 210             case KC_WWW_FORWARD:
 211                 usage = AC_FORWARD;
 212                 break;
 213             case KC_WWW_STOP:
 214                 usage = AC_STOP;
 215                 break;
 216             case KC_WWW_REFRESH:
 217                 usage = AC_REFRESH;
 218                 break;
 219             case KC_WWW_FAVORITES:
 220                 usage = AC_BOOKMARKS;
 221                 break;
 222         }
 223         host_consumer_send(usage);
 224     }
 225     else if IS_SYSTEM(code) {
 226         uint16_t usage = 0;
 227         switch (code) {
 228             case KC_SYSTEM_POWER:
 229                 usage = SYSTEM_POWER_DOWN;
 230                 break;
 231             case KC_SYSTEM_SLEEP:
 232                 usage = SYSTEM_SLEEP;
 233                 break;
 234             case KC_SYSTEM_WAKE:
 235                 usage = SYSTEM_WAKE_UP;
 236                 break;
 237         }
 238         host_system_send(usage);
 239     }
 240
 241 }
 242
 243 static void unregister_code(uint8_t code)
 244 {
 245     if IS_KEY(code) {
 246         host_del_key(code);
 247         host_send_keyboard_report();
 248     }
 249     else if IS_MOD(code) {
 250         host_del_mod_bit(MOD_BIT(code));
 251         host_send_keyboard_report();
 252     }
 253     else if IS_MOUSEKEY(code) {
 254         mousekey_off(code);
 255         mousekey_send();
 256     }
 257     else if IS_CONSUMER(code) {
 258         host_consumer_send(0x0000);
 259     }
 260     else if IS_SYSTEM(code) {
 261         host_system_send(0x0000);
 262     }
 263 }
 264
 265 /*
 266  *
 267  * Event/State|IDLE             DELAYING[f]     WAITING[f,k]        PRESSING
 268  * -----------+------------------------------------------------------------------
 269  * Fn  Down   |IDLE(L+)         WAITING(Sk)     WAITING(Sk)         -
 270  *     Up     |IDLE(L-)         IDLE(L-)        IDLE(L-)            IDLE(L-)
 271  * Fnk Down   |DELAYING(Sf)     WAITING(Sk)     WAINTING(Sk)        PRESSING(Rf)
 272  *     Up     |IDLE(L-)         IDLE(Rf,Uf)     IDLE(Rf,Ps,Uf)*3    PRESSING(Uf)
 273  * Key Down   |PRESSING(Rk)     WAITING(Sk)     WAITING(Sk)         PRESSING(Rk)
 274  *     Up     |IDLE(Uk)         DELAYING(Uk)    IDLE(L+,Ps,Uk)      IDLE(Uk)*4
 275  * Delay      |-                IDLE(L+)        IDLE(L+,Ps)         -
 276  *            |
 277  * No key Down|IDLE(Ld)         IDLE(Ld)        IDLE(Ld)            IDLE(Ld)
 278  *
 279  * *2: register Fnk if any key is pressing
 280  * *3: when Fnk == Stored Fnk, if not ignore.
 281  * *4: when no registered key any more
 282  *
 283  * States:
 284  *      IDLE:
 285  *      DELAYING: delay layer switch after pressing Fn with alt keycode
 286  *      WAITING: key is pressed during DELAYING
 287  *
 288  * Events:
 289  *      Fn: Fn key without alternative keycode
 290  *      Fnk: Fn key with alternative keycode
 291  *      -: ignore
 292  *
 293  * Actions:
 294  *      Rk: register key
 295  *      Uk: unregister key
 296  *      Rf: register stored Fn(alt keycode)
 297  *      Uf: unregister stored Fn(alt keycode)
 298  *      Rs: register stored key
 299  *      Us: unregister stored key
 300  *      Sk: store key
 301  *      Sf: store Fn
 302  *      Ps: play stored key(Interpret stored key and transit state)
 303  *      L+: Switch to new layer(*unregister* all keys but modifiers)
 304  *      L-: Switch back to last layer(*unregister* all keys but modifiers)
 305  *      Ld: Switch back to default layer(*unregister* all keys but modifiers)
 306  */
 307 #define NEXT(state)     do { \
 308     debug("NEXT: "); print_P(state_str(kbdstate)); \
 309     kbdstate = state; \
 310     debug(" -> "); print_P(state_str(kbdstate)); debug("\n"); \
 311 } while (0)
 312
 313 static inline void process_key(keyevent_t event)
 314 {
 315     uint8_t code = keymap_get_keycode(current_layer, event.key.row, event.key.col);
 316     keykind_t kind = get_keykind(code, event.pressed);
 317
 318     uint8_t tmp_mods;
 319
 320     debug("state: "); print_P(state_str(kbdstate));
 321     debug(" kind: "); debug_hex(kind);
 322     debug(" code: "); debug_hex(code);
 323     if (event.pressed) { debug("d"); } else { debug("u"); }
 324     debug("\n");
 325
 326     switch (kbdstate) {
 327         case IDLE:
 328             switch (kind) {
 329                 case FN_DOWN:
 330                     layer_switch_on(code);
 331                     break;
 332                 case FN_UP:
 333                     layer_switch_off(code);
 334                     break;
 335                 case FNK_DOWN:
 336                     // repeat Fn alt key when press Fn key down, up then down again quickly
 337                     if (KEYEQ(delayed_fn.event.key, event.key) &&
 338                             timer_elapsed(delayed_fn.time) < LAYER_DELAY) {
 339                         register_code(keymap_fn_keycode(FN_INDEX(code)));
 340                         NEXT(PRESSING);
 341                     } else {
 342                         delayed_fn = (keyrecord_t) {
 343                             .event = event,
 344                             .code = code,
 345                             .mods = keyboard_report->mods,
 346                             .time = timer_read()
 347                         };
 348                         NEXT(DELAYING);
 349                     }
 350                     break;
 351                 case FNK_UP:
 352                     layer_switch_off(code);
 353                     break;
 354                 case KEY_DOWN:
 355                     register_code(code);
 356                     NEXT(PRESSING);
 357                     break;
 358                 case MOD_DOWN:
 359                     register_code(code);
 360                     break;
 361                 case KEY_UP:
 362                 case MOD_UP:
 363                     unregister_code(code);
 364                     break;
 365                 default:
 366                     break;
 367             }
 368             break;
 369         case PRESSING:
 370             switch (kind) {
 371                 case FN_DOWN:
 372                     // ignored when any key is pressed
 373                     break;
 374                 case FN_UP:
 375                     layer_switch_off(code);
 376                     NEXT(IDLE);
 377                     break;
 378                 case FNK_DOWN:
 379                     register_code(keymap_fn_keycode(FN_INDEX(code)));
 380                     break;
 381                 case FNK_UP:
 382                     // can't know whether layer switched or not
 383                     layer_switch_off(code);
 384                     unregister_code(keymap_fn_keycode(FN_INDEX(code)));
 385                     break;
 386                 case KEY_DOWN:
 387                 case MOD_DOWN:
 388                     register_code(code);
 389                     break;
 390                 case KEY_UP:
 391                 case MOD_UP:
 392                     unregister_code(code);
 393                     // no key registered? mousekey, mediakey, systemkey
 394                     if (!host_has_anykey())
 395                         NEXT(IDLE);
 396                     break;
 397                 default:
 398                     break;
 399             }
 400             break;
 401         case DELAYING:
 402             switch (kind) {
 403                 case FN_DOWN:
 404                 case FNK_DOWN:
 405                 case KEY_DOWN:
 406                     waiting_key = (keyrecord_t) {
 407                         .event = event,
 408                         .code = code,
 409                         .mods = keyboard_report->mods,
 410                         .time = timer_read()
 411                     };
 412                     NEXT(WAITING);
 413                     break;
 414                 case MOD_DOWN:
 415                     register_code(code);
 416                     break;
 417                 case FN_UP:
 418                     layer_switch_off(code);
 419                     NEXT(IDLE);
 420                     break;
 421                 case FNK_UP:
 422                     if (code == delayed_fn.code) {
 423                         // type Fn with alt keycode
 424                         // restore the mod status at the time of pressing Fn key
 425                         tmp_mods = keyboard_report->mods;
 426                         host_set_mods(delayed_fn.mods);
 427                         register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 428                         unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 429                         host_set_mods(tmp_mods);
 430                         NEXT(IDLE);
 431                     } else {
 432                         layer_switch_off(code);
 433                         NEXT(IDLE);
 434                     }
 435                     break;
 436                 case KEY_UP:
 437                     unregister_code(code);
 438                     NEXT(IDLE);
 439                     break;
 440                 case MOD_UP:
 441                     unregister_code(code);
 442                     break;
 443                 default:
 444                     break;
 445             }
 446             break;
 447         case WAITING:
 448             switch (kind) {
 449                 case FN_DOWN:
 450                 case FNK_DOWN:
 451                 case KEY_DOWN:
 452                     tmp_mods = keyboard_report->mods;
 453                     host_set_mods(delayed_fn.mods);
 454                     register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 455                     host_set_mods(waiting_key.mods);
 456                     register_code(waiting_key.code);
 457                     host_set_mods(tmp_mods);
 458                     register_code(code);
 459                     NEXT(IDLE);
 460                     break;
 461                 case MOD_DOWN:
 462                     register_code(code);
 463                     break;
 464                 case FN_UP:
 465                     layer_switch_off(code);
 466                     NEXT(IDLE);
 467                     break;
 468                 case FNK_UP:
 469                     if (code == delayed_fn.code) {
 470                         // alt down, key down, alt up
 471                         tmp_mods = keyboard_report->mods;
 472                         host_set_mods(delayed_fn.mods);
 473                         register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 474                         host_set_mods(waiting_key.mods);
 475                         register_code(waiting_key.code);
 476                         unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code)));
 477                         host_set_mods(tmp_mods);
 478                         NEXT(IDLE);
 479                     } else {
 480                         layer_switch_off(code);
 481                         NEXT(IDLE);
 482                     }
 483                     break;
 484                 case KEY_UP:
 485                     if (code == waiting_key.code) {
 486                         layer_switch_on(delayed_fn.code);
 487                         NEXT(IDLE);
 488                         // process waiting_key
 489                         tmp_mods = keyboard_report->mods;
 490                         host_set_mods(waiting_key.mods);
 491                         process_key(waiting_key.event);
 492                         host_set_mods(tmp_mods);
 493                         process_key(event);
 494                     } else {
 495                         unregister_code(code);
 496                     }
 497                     break;
 498                 case MOD_UP:
 499                     unregister_code(code);
 500                     break;
 501                 default:
 502                     break;
 503             }
 504             break;
 505     }
 506 }
 507
 508 void keyboard_init(void)
 509 {
 510     debug_keyboard = true;
 511
 512     timer_init();
 513     matrix_init();
 514 #ifdef PS2_MOUSE_ENABLE
 515     ps2_mouse_init();
 516 #endif
 517 }
 518
 519 void keyboard_task(void)
 520 {
 521     static matrix_row_t matrix_prev[MATRIX_ROWS];
 522     matrix_row_t matrix_row = 0;
 523     matrix_row_t matrix_change = 0;
 524
 525     matrix_scan();
 526     if (command_proc()) {
 527         debug("COMMAND\n");
 528         // TODO: COMMAND state?
 529         clear_keyboard();
 530         return;
 531     }
 532
 533     for (int r = 0; r < MATRIX_ROWS; r++) {
 534         matrix_row = matrix_get_row(r);
 535         matrix_change = matrix_row ^ matrix_prev[r];
 536         if (matrix_change) {
 537             if (debug_matrix) matrix_print();
 538
 539             for (int c = 0; c < MATRIX_COLS; c++) {
 540                 if (matrix_change & (1<<c)) {
 541                     process_key((keyevent_t){
 542                         .key = (key_t){ .row = r, .col = c },
 543                         .pressed = (matrix_row & (1<<c))
 544                     });
 545                     // record a processed key
 546                     matrix_prev[r] ^= (1<<c);
 547                     // process a key per task call
 548                     goto MATRIX_LOOP_END;
 549                 }
 550             }
 551         }
 552     }
 553     MATRIX_LOOP_END:
 554
 555     // layer switch when delay term elapses
 556     if (kbdstate == DELAYING || kbdstate == WAITING) {
 557         if (timer_elapsed(delayed_fn.time) > LAYER_DELAY) {
 558             if (kbdstate == DELAYING) {
 559                 layer_switch_on(delayed_fn.code);
 560                 NEXT(IDLE);
 561             }
 562             if (kbdstate == WAITING) {
 563                 layer_switch_on(delayed_fn.code);
 564                 NEXT(IDLE);
 565                 uint8_t tmp_mods = keyboard_report->mods;
 566                 host_set_mods(waiting_key.mods);
 567                 process_key(waiting_key.event);
 568                 host_set_mods(tmp_mods);
 569             }
 570         }
 571     }
 572
 573     // mousekey repeat & acceleration
 574     mousekey_task();
 575
 576     // FAIL SAFE: clear all key if no key down
 577     if (matrix_change) {
 578         matrix_row_t is_matrix_on = 0;
 579         for (int r = 0; r < MATRIX_ROWS; r++) {
 580             is_matrix_on |= matrix_get_row(r);
 581         }
 582         if (!is_matrix_on) {
 583             debug("FAIL SAFE: clear all keys.\n");
 584             clear_keyboard();
 585         }
 586     }
 587
 588     return;
 589 }
 590
 591 void keyboard_set_leds(uint8_t leds)
 592 {
 593     led_set(leds);
 594 }