tmk_core/common/keyboard.c

   1 /*
   2 Copyright 2011, 2012, 2013 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
  18 #include <stdint.h>
  19 #include "keyboard.h"
  20 #include "matrix.h"
  21 #include "keymap.h"
  22 #include "host.h"
  23 #include "led.h"
  24 #include "keycode.h"
  25 #include "timer.h"
  26 #include "print.h"
  27 #include "debug.h"
  28 #include "command.h"
  29 #include "util.h"
  30 #include "sendchar.h"
  31 #include "eeconfig.h"
  32 #include "backlight.h"
  33 #include "action_layer.h"
  34 #ifdef BOOTMAGIC_ENABLE
  35 #   include "bootmagic.h"
  36 #else
  37 #   include "magic.h"
  38 #endif
  39 #ifdef MOUSEKEY_ENABLE
  40 #   include "mousekey.h"
  41 #endif
  42 #ifdef PS2_MOUSE_ENABLE
  43 #   include "ps2_mouse.h"
  44 #endif
  45 #ifdef SERIAL_MOUSE_ENABLE
  46 #   include "serial_mouse.h"
  47 #endif
  48 #ifdef ADB_MOUSE_ENABLE
  49 #   include "adb.h"
  50 #endif
  51 #ifdef RGBLIGHT_ENABLE
  52 #   include "rgblight.h"
  53 #endif
  54 #ifdef FAUXCLICKY_ENABLE
  55 #   include "fauxclicky.h"
  56 #endif
  57 #ifdef SERIAL_LINK_ENABLE
  58 #   include "serial_link/system/serial_link.h"
  59 #endif
  60 #ifdef VISUALIZER_ENABLE
  61 #   include "visualizer/visualizer.h"
  62 #endif
  63
  64
  65 #ifdef MATRIX_HAS_GHOST
  66 extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
  67 static matrix_row_t get_real_keys(uint8_t row, matrix_row_t rowdata){
  68     matrix_row_t out = 0;
  69     for (int col = 0; col < MATRIX_COLS; col++) {
  70         if (pgm_read_byte(&keymaps[0][row][col]) && ((rowdata & (1<<col)))){
  71             out |= 1<<col;
  72         }
  73     }
  74     return out;
  75 }
  76
  77
  78 static inline bool countones(matrix_row_t data)
  79 {
  80     int count = 0;
  81     for (int col = 0; col < MATRIX_COLS; col++) {
  82         if (data & (1<<col)){
  83             count++;
  84         }
  85     }
  86     if (count > 1){
  87         return true;
  88     }
  89     return false;
  90 }
  91 static inline bool has_ghost_in_row(uint8_t row, matrix_row_t rowdata)
  92 {
  93     rowdata = get_real_keys(row, rowdata);
  94     if (((rowdata - 1) & rowdata) == 0){
  95         return false;
  96     }
  97     /* No ghost exists when less than 2 keys are down on the row.
  98     If there are "active" blanks in the matrix, the key can't be pressed by the user,
  99     there is no doubt as to which keys are really being pressed.
 100     The ghosts will be ignored, they are KC_NO.   */
 101     // Ghost occurs when the row shares column line with other row, blanks in the matrix don't matter
 102     // If there are more than two real keys pressed and they match another row's real keys, the row will be ignored.
 103     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 104         if (i != row && countones(get_real_keys(i, matrix_get_row(i)) & rowdata)){
 105             return true;
 106         }
 107     }
 108     return false;
 109 }
 110
 111 #endif
 112
 113
 114 __attribute__ ((weak))
 115 void matrix_setup(void) {
 116 }
 117
 118 void keyboard_setup(void) {
 119     matrix_setup();
 120 }
 121
 122 void keyboard_init(void) {
 123     timer_init();
 124     matrix_init();
 125 #ifdef PS2_MOUSE_ENABLE
 126     ps2_mouse_init();
 127 #endif
 128 #ifdef SERIAL_MOUSE_ENABLE
 129     serial_mouse_init();
 130 #endif
 131 #ifdef ADB_MOUSE_ENABLE
 132     adb_mouse_init();
 133 #endif
 134 #ifdef BOOTMAGIC_ENABLE
 135     bootmagic();
 136 #else
 137     magic();
 138 #endif
 139 #ifdef BACKLIGHT_ENABLE
 140     backlight_init();
 141 #endif
 142 #ifdef RGBLIGHT_ENABLE
 143     rgblight_init();
 144 #endif
 145 #ifdef FAUXCLICKY_ENABLE
 146     fauxclicky_init();
 147 #endif
 148 #if defined(NKRO_ENABLE) && defined(FORCE_NKRO)
 149     keymap_config.nkro = 1;
 150 #endif
 151 }
 152
 153 /*
 154  * Do keyboard routine jobs: scan mantrix, light LEDs, ...
 155  * This is repeatedly called as fast as possible.
 156  */
 157 void keyboard_task(void)
 158 {
 159     static matrix_row_t matrix_prev[MATRIX_ROWS];
 160 #ifdef MATRIX_HAS_GHOST
 161   //  static matrix_row_t matrix_ghost[MATRIX_ROWS];
 162 #endif
 163     static uint8_t led_status = 0;
 164     matrix_row_t matrix_row = 0;
 165     matrix_row_t matrix_change = 0;
 166
 167     matrix_scan();
 168     for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
 169         matrix_row = matrix_get_row(r);
 170         matrix_change = matrix_row ^ matrix_prev[r];
 171         if (matrix_change) {
 172 #ifdef MATRIX_HAS_GHOST
 173             if (has_ghost_in_row(r, matrix_row)) {
 174                 /* Keep track of whether ghosted status has changed for
 175                  * debugging. But don't update matrix_prev until un-ghosted, or
 176                  * the last key would be lost.
 177                  */
 178                 //if (debug_matrix && matrix_ghost[r] != matrix_row) {
 179                 //    matrix_print();
 180                 //}
 181                 //matrix_ghost[r] = matrix_row;
 182                 continue;
 183             }
 184             //matrix_ghost[r] = matrix_row;
 185 #endif
 186             if (debug_matrix) matrix_print();
 187             for (uint8_t c = 0; c < MATRIX_COLS; c++) {
 188                 if (matrix_change & ((matrix_row_t)1<<c)) {
 189                     action_exec((keyevent_t){
 190                         .key = (keypos_t){ .row = r, .col = c },
 191                         .pressed = (matrix_row & ((matrix_row_t)1<<c)),
 192                         .time = (timer_read() | 1) /* time should not be 0 */
 193                     });
 194                     // record a processed key
 195                     matrix_prev[r] ^= ((matrix_row_t)1<<c);
 196                     // process a key per task call
 197                     goto MATRIX_LOOP_END;
 198                 }
 199             }
 200         }
 201     }
 202     // call with pseudo tick event when no real key event.
 203     action_exec(TICK);
 204
 205 MATRIX_LOOP_END:
 206
 207 #ifdef MOUSEKEY_ENABLE
 208     // mousekey repeat & acceleration
 209     mousekey_task();
 210 #endif
 211
 212 #ifdef PS2_MOUSE_ENABLE
 213     ps2_mouse_task();
 214 #endif
 215
 216 #ifdef SERIAL_MOUSE_ENABLE
 217     serial_mouse_task();
 218 #endif
 219
 220 #ifdef ADB_MOUSE_ENABLE
 221     adb_mouse_task();
 222 #endif
 223
 224 #ifdef SERIAL_LINK_ENABLE
 225         serial_link_update();
 226 #endif
 227
 228 #ifdef VISUALIZER_ENABLE
 229     visualizer_update(default_layer_state, layer_state, visualizer_get_mods(), host_keyboard_leds());
 230 #endif
 231
 232     // update LED
 233     if (led_status != host_keyboard_leds()) {
 234         led_status = host_keyboard_leds();
 235         keyboard_set_leds(led_status);
 236     }
 237 }
 238
 239 void keyboard_set_leds(uint8_t leds)
 240 {
 241     if (debug_keyboard) { debug("keyboard_set_led: "); debug_hex8(leds); debug("\n"); }
 242     led_set(leds);
 243 }