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 static matrix_row_t matrix_ghost_check[MATRIX_ROWS];
  67
  68 static inline bool countones(matrix_row_t data)
  69 {
  70     int count = 0;
  71     for (int col = 0; col < MATRIX_COLS; col++) {
  72         if (data & (1<<col))
  73             count++;
  74     }
  75     if (count > 1){
  76         return true;
  77     }
  78     return false;
  79 }
  80 static inline bool has_ghost_in_row(uint8_t row, matrix_row_t rowdata)
  81 {
  82     rowdata &= matrix_ghost_check[row];
  83     if (((rowdata - 1) & rowdata) == 0){
  84         return false;
  85     }
  86     /* No ghost exists when less than 2 keys are down on the row.
  87     If there are "active" blanks in the matrix, the key can't be pressed by the user,
  88     there is no doubt as to which keys are really being pressed.
  89     The ghosts will be ignored, they are KC_NO.   */
  90     // Ghost occurs when the row shares column line with other row, blanks in the matrix don't matter
  91     // If there are more than two real keys pressed and they match another row's real keys, the row will be ignored.
  92     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
  93         if (i != row && countones((matrix_get_row(i) & matrix_ghost_check[i]) & rowdata)){
  94             return true;
  95         }
  96     }
  97     return false;
  98 }
  99
 100 extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
 101 // bit map of true keys and empty spots in matrix, each row is reversed
 102 static inline void make_ghost_check_array(void){
 103     for (int row = 0; row < MATRIX_ROWS; row++) {
 104         for (int col = 0; col < MATRIX_COLS; col++) {
 105             if (pgm_read_byte(&keymaps[0][row][col]) != 0)
 106                 matrix_ghost_check[row] |= 1<<col;
 107         }
 108     }
 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 #ifdef MATRIX_HAS_GHOST
 152     make_ghost_check_array();
 153 #endif
 154 }
 155
 156 /*
 157  * Do keyboard routine jobs: scan mantrix, light LEDs, ...
 158  * This is repeatedly called as fast as possible.
 159  */
 160 void keyboard_task(void)
 161 {
 162     static matrix_row_t matrix_prev[MATRIX_ROWS];
 163 #ifdef MATRIX_HAS_GHOST
 164   //  static matrix_row_t matrix_ghost[MATRIX_ROWS];
 165 #endif
 166     static uint8_t led_status = 0;
 167     matrix_row_t matrix_row = 0;
 168     matrix_row_t matrix_change = 0;
 169
 170     matrix_scan();
 171     for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
 172         matrix_row = matrix_get_row(r);
 173         matrix_change = matrix_row ^ matrix_prev[r];
 174         if (matrix_change) {
 175 #ifdef MATRIX_HAS_GHOST
 176             if (has_ghost_in_row(r, matrix_row)) {
 177                 /* Keep track of whether ghosted status has changed for
 178                  * debugging. But don't update matrix_prev until un-ghosted, or
 179                  * the last key would be lost.
 180                  */
 181                 //if (debug_matrix && matrix_ghost[r] != matrix_row) {
 182                 //    matrix_print();
 183                 //}
 184                 //matrix_ghost[r] = matrix_row;
 185                 continue;
 186             }
 187             //matrix_ghost[r] = matrix_row;
 188 #endif
 189             if (debug_matrix) matrix_print();
 190             for (uint8_t c = 0; c < MATRIX_COLS; c++) {
 191                 if (matrix_change & ((matrix_row_t)1<<c)) {
 192                     action_exec((keyevent_t){
 193                         .key = (keypos_t){ .row = r, .col = c },
 194                         .pressed = (matrix_row & ((matrix_row_t)1<<c)),
 195                         .time = (timer_read() | 1) /* time should not be 0 */
 196                     });
 197                     // record a processed key
 198                     matrix_prev[r] ^= ((matrix_row_t)1<<c);
 199                     // process a key per task call
 200                     goto MATRIX_LOOP_END;
 201                 }
 202             }
 203         }
 204     }
 205     // call with pseudo tick event when no real key event.
 206     action_exec(TICK);
 207
 208 MATRIX_LOOP_END:
 209
 210 #ifdef MOUSEKEY_ENABLE
 211     // mousekey repeat & acceleration
 212     mousekey_task();
 213 #endif
 214
 215 #ifdef PS2_MOUSE_ENABLE
 216     ps2_mouse_task();
 217 #endif
 218
 219 #ifdef SERIAL_MOUSE_ENABLE
 220     serial_mouse_task();
 221 #endif
 222
 223 #ifdef ADB_MOUSE_ENABLE
 224     adb_mouse_task();
 225 #endif
 226
 227 #ifdef SERIAL_LINK_ENABLE
 228         serial_link_update();
 229 #endif
 230
 231 #ifdef VISUALIZER_ENABLE
 232     visualizer_update(default_layer_state, layer_state, visualizer_get_mods(), host_keyboard_leds());
 233 #endif
 234
 235     // update LED
 236     if (led_status != host_keyboard_leds()) {
 237         led_status = host_keyboard_leds();
 238         keyboard_set_leds(led_status);
 239     }
 240 }
 241
 242 void keyboard_set_leds(uint8_t leds)
 243 {
 244     if (debug_keyboard) { debug("keyboard_set_led: "); debug_hex8(leds); debug("\n"); }
 245     led_set(leds);
 246 }