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 STENO_ENABLE
  55 #   include "process_steno.h"
  56 #endif
  57 #ifdef FAUXCLICKY_ENABLE
  58 #   include "fauxclicky.h"
  59 #endif
  60 #ifdef SERIAL_LINK_ENABLE
  61 #   include "serial_link/system/serial_link.h"
  62 #endif
  63 #ifdef VISUALIZER_ENABLE
  64 #   include "visualizer/visualizer.h"
  65 #endif
  66
  67 #ifdef MATRIX_HAS_GHOST
  68 extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
  69 static matrix_row_t get_real_keys(uint8_t row, matrix_row_t rowdata){
  70     matrix_row_t out = 0;
  71     for (uint8_t col = 0; col < MATRIX_COLS; col++) {
  72         //read each key in the row data and check if the keymap defines it as a real key
  73         if (pgm_read_byte(&keymaps[0][row][col]) && (rowdata & (1<<col))){
  74             //this creates new row data, if a key is defined in the keymap, it will be set here
  75             out |= 1<<col;
  76         }
  77     }
  78     return out;
  79 }
  80
  81 static inline bool popcount_more_than_one(matrix_row_t rowdata)
  82 {
  83     rowdata &= rowdata-1; //if there are less than two bits (keys) set, rowdata will become zero
  84     return rowdata;
  85 }
  86
  87 static inline bool has_ghost_in_row(uint8_t row, matrix_row_t rowdata)
  88 {
  89     /* No ghost exists when less than 2 keys are down on the row.
  90     If there are "active" blanks in the matrix, the key can't be pressed by the user,
  91     there is no doubt as to which keys are really being pressed.
  92     The ghosts will be ignored, they are KC_NO.   */
  93     rowdata = get_real_keys(row, rowdata);
  94     if ((popcount_more_than_one(rowdata)) == 0){
  95         return false;
  96     }
  97     /* Ghost occurs when the row shares a column line with other row,
  98     and two columns are read on each row. Blanks in the matrix don't matter,
  99     so they are filtered out.
 100     If there are two or more real keys pressed and they match columns with
 101     at least two of another row's real keys, the row will be ignored. Keep in mind,
 102     we are checking one row at a time, not all of them at once.
 103     */
 104     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 105         if (i != row && popcount_more_than_one(get_real_keys(i, matrix_get_row(i)) & rowdata)){
 106             return true;
 107         }
 108     }
 109     return false;
 110 }
 111
 112 #endif
 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 STENO_ENABLE
 146     steno_init();
 147 #endif
 148 #ifdef FAUXCLICKY_ENABLE
 149     fauxclicky_init();
 150 #endif
 151 #if defined(NKRO_ENABLE) && defined(FORCE_NKRO)
 152     keymap_config.nkro = 1;
 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 }