keyboard.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565
  1. /*
  2. Copyright 2011, 2012, 2013 Jun Wako <wakojun@gmail.com>
  3. This program is free software: you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation, either version 2 of the License, or
  6. (at your option) any later version.
  7. This program is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. GNU General Public License for more details.
  11. You should have received a copy of the GNU General Public License
  12. along with this program. If not, see <http://www.gnu.org/licenses/>.
  13. */
  14. #include <stdint.h>
  15. #include "keyboard.h"
  16. #include "matrix.h"
  17. #include "keymap.h"
  18. #include "host.h"
  19. #include "led.h"
  20. #include "keycode.h"
  21. #include "timer.h"
  22. #include "sync_timer.h"
  23. #include "print.h"
  24. #include "debug.h"
  25. #include "command.h"
  26. #include "util.h"
  27. #include "sendchar.h"
  28. #include "eeconfig.h"
  29. #include "action_layer.h"
  30. #ifdef BACKLIGHT_ENABLE
  31. # include "backlight.h"
  32. #endif
  33. #ifdef MOUSEKEY_ENABLE
  34. # include "mousekey.h"
  35. #endif
  36. #ifdef PS2_MOUSE_ENABLE
  37. # include "ps2_mouse.h"
  38. #endif
  39. #ifdef SERIAL_MOUSE_ENABLE
  40. # include "serial_mouse.h"
  41. #endif
  42. #ifdef ADB_MOUSE_ENABLE
  43. # include "adb.h"
  44. #endif
  45. #ifdef RGBLIGHT_ENABLE
  46. # include "rgblight.h"
  47. #endif
  48. #ifdef LED_MATRIX_ENABLE
  49. # include "led_matrix.h"
  50. #endif
  51. #ifdef RGB_MATRIX_ENABLE
  52. # include "rgb_matrix.h"
  53. #endif
  54. #ifdef ENCODER_ENABLE
  55. # include "encoder.h"
  56. #endif
  57. #ifdef STENO_ENABLE
  58. # include "process_steno.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. #ifdef POINTING_DEVICE_ENABLE
  67. # include "pointing_device.h"
  68. #endif
  69. #ifdef MIDI_ENABLE
  70. # include "process_midi.h"
  71. #endif
  72. #ifdef JOYSTICK_ENABLE
  73. # include "process_joystick.h"
  74. #endif
  75. #ifdef HD44780_ENABLE
  76. # include "hd44780.h"
  77. #endif
  78. #ifdef QWIIC_ENABLE
  79. # include "qwiic.h"
  80. #endif
  81. #ifdef OLED_DRIVER_ENABLE
  82. # include "oled_driver.h"
  83. #endif
  84. #ifdef ST7565_ENABLE
  85. # include "st7565.h"
  86. #endif
  87. #ifdef VELOCIKEY_ENABLE
  88. # include "velocikey.h"
  89. #endif
  90. #ifdef VIA_ENABLE
  91. # include "via.h"
  92. #endif
  93. #ifdef DIP_SWITCH_ENABLE
  94. # include "dip_switch.h"
  95. #endif
  96. #ifdef STM32_EEPROM_ENABLE
  97. # include "eeprom_stm32.h"
  98. #endif
  99. #ifdef EEPROM_DRIVER
  100. # include "eeprom_driver.h"
  101. #endif
  102. #if defined(CRC_ENABLE)
  103. # include "crc.h"
  104. #endif
  105. #ifdef DIGITIZER_ENABLE
  106. # include "digitizer.h"
  107. #endif
  108. static uint32_t last_input_modification_time = 0;
  109. uint32_t last_input_activity_time(void) { return last_input_modification_time; }
  110. uint32_t last_input_activity_elapsed(void) { return timer_elapsed32(last_input_modification_time); }
  111. static uint32_t last_matrix_modification_time = 0;
  112. uint32_t last_matrix_activity_time(void) { return last_matrix_modification_time; }
  113. uint32_t last_matrix_activity_elapsed(void) { return timer_elapsed32(last_matrix_modification_time); }
  114. void last_matrix_activity_trigger(void) { last_matrix_modification_time = last_input_modification_time = timer_read32(); }
  115. static uint32_t last_encoder_modification_time = 0;
  116. uint32_t last_encoder_activity_time(void) { return last_encoder_modification_time; }
  117. uint32_t last_encoder_activity_elapsed(void) { return timer_elapsed32(last_encoder_modification_time); }
  118. void last_encoder_activity_trigger(void) { last_encoder_modification_time = last_input_modification_time = timer_read32(); }
  119. // Only enable this if console is enabled to print to
  120. #if defined(DEBUG_MATRIX_SCAN_RATE)
  121. static uint32_t matrix_timer = 0;
  122. static uint32_t matrix_scan_count = 0;
  123. static uint32_t last_matrix_scan_count = 0;
  124. void matrix_scan_perf_task(void) {
  125. matrix_scan_count++;
  126. uint32_t timer_now = timer_read32();
  127. if (TIMER_DIFF_32(timer_now, matrix_timer) > 1000) {
  128. # if defined(CONSOLE_ENABLE)
  129. dprintf("matrix scan frequency: %lu\n", matrix_scan_count);
  130. # endif
  131. last_matrix_scan_count = matrix_scan_count;
  132. matrix_timer = timer_now;
  133. matrix_scan_count = 0;
  134. }
  135. }
  136. uint32_t get_matrix_scan_rate(void) { return last_matrix_scan_count; }
  137. #else
  138. # define matrix_scan_perf_task()
  139. #endif
  140. #ifdef MATRIX_HAS_GHOST
  141. extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
  142. static matrix_row_t get_real_keys(uint8_t row, matrix_row_t rowdata) {
  143. matrix_row_t out = 0;
  144. for (uint8_t col = 0; col < MATRIX_COLS; col++) {
  145. // read each key in the row data and check if the keymap defines it as a real key
  146. if (pgm_read_byte(&keymaps[0][row][col]) && (rowdata & (1 << col))) {
  147. // this creates new row data, if a key is defined in the keymap, it will be set here
  148. out |= 1 << col;
  149. }
  150. }
  151. return out;
  152. }
  153. static inline bool popcount_more_than_one(matrix_row_t rowdata) {
  154. rowdata &= rowdata - 1; // if there are less than two bits (keys) set, rowdata will become zero
  155. return rowdata;
  156. }
  157. static inline bool has_ghost_in_row(uint8_t row, matrix_row_t rowdata) {
  158. /* No ghost exists when less than 2 keys are down on the row.
  159. If there are "active" blanks in the matrix, the key can't be pressed by the user,
  160. there is no doubt as to which keys are really being pressed.
  161. The ghosts will be ignored, they are KC_NO. */
  162. rowdata = get_real_keys(row, rowdata);
  163. if ((popcount_more_than_one(rowdata)) == 0) {
  164. return false;
  165. }
  166. /* Ghost occurs when the row shares a column line with other row,
  167. and two columns are read on each row. Blanks in the matrix don't matter,
  168. so they are filtered out.
  169. If there are two or more real keys pressed and they match columns with
  170. at least two of another row's real keys, the row will be ignored. Keep in mind,
  171. we are checking one row at a time, not all of them at once.
  172. */
  173. for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
  174. if (i != row && popcount_more_than_one(get_real_keys(i, matrix_get_row(i)) & rowdata)) {
  175. return true;
  176. }
  177. }
  178. return false;
  179. }
  180. #endif
  181. void disable_jtag(void) {
  182. // To use PF4-7 (PC2-5 on ATmega32A), disable JTAG by writing JTD bit twice within four cycles.
  183. #if (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__))
  184. MCUCR |= _BV(JTD);
  185. MCUCR |= _BV(JTD);
  186. #elif defined(__AVR_ATmega32A__)
  187. MCUCSR |= _BV(JTD);
  188. MCUCSR |= _BV(JTD);
  189. #endif
  190. }
  191. /** \brief matrix_setup
  192. *
  193. * FIXME: needs doc
  194. */
  195. __attribute__((weak)) void matrix_setup(void) {}
  196. /** \brief keyboard_pre_init_user
  197. *
  198. * FIXME: needs doc
  199. */
  200. __attribute__((weak)) void keyboard_pre_init_user(void) {}
  201. /** \brief keyboard_pre_init_kb
  202. *
  203. * FIXME: needs doc
  204. */
  205. __attribute__((weak)) void keyboard_pre_init_kb(void) { keyboard_pre_init_user(); }
  206. /** \brief keyboard_post_init_user
  207. *
  208. * FIXME: needs doc
  209. */
  210. __attribute__((weak)) void keyboard_post_init_user() {}
  211. /** \brief keyboard_post_init_kb
  212. *
  213. * FIXME: needs doc
  214. */
  215. __attribute__((weak)) void keyboard_post_init_kb(void) { keyboard_post_init_user(); }
  216. /** \brief keyboard_setup
  217. *
  218. * FIXME: needs doc
  219. */
  220. void keyboard_setup(void) {
  221. #ifndef NO_JTAG_DISABLE
  222. disable_jtag();
  223. #endif
  224. print_set_sendchar(sendchar);
  225. #ifdef STM32_EEPROM_ENABLE
  226. EEPROM_Init();
  227. #endif
  228. #ifdef EEPROM_DRIVER
  229. eeprom_driver_init();
  230. #endif
  231. matrix_setup();
  232. keyboard_pre_init_kb();
  233. }
  234. /** \brief is_keyboard_master
  235. *
  236. * FIXME: needs doc
  237. */
  238. __attribute__((weak)) bool is_keyboard_master(void) { return true; }
  239. /** \brief is_keyboard_left
  240. *
  241. * FIXME: needs doc
  242. */
  243. __attribute__((weak)) bool is_keyboard_left(void) { return true; }
  244. /** \brief should_process_keypress
  245. *
  246. * Override this function if you have a condition where keypresses processing should change:
  247. * - splits where the slave side needs to process for rgb/oled functionality
  248. */
  249. __attribute__((weak)) bool should_process_keypress(void) { return is_keyboard_master(); }
  250. /** \brief housekeeping_task_kb
  251. *
  252. * Override this function if you have a need to execute code for every keyboard main loop iteration.
  253. * This is specific to keyboard-level functionality.
  254. */
  255. __attribute__((weak)) void housekeeping_task_kb(void) {}
  256. /** \brief housekeeping_task_user
  257. *
  258. * Override this function if you have a need to execute code for every keyboard main loop iteration.
  259. * This is specific to user/keymap-level functionality.
  260. */
  261. __attribute__((weak)) void housekeeping_task_user(void) {}
  262. /** \brief housekeeping_task
  263. *
  264. * Invokes hooks for executing code after QMK is done after each loop iteration.
  265. */
  266. void housekeeping_task(void) {
  267. housekeeping_task_kb();
  268. housekeeping_task_user();
  269. }
  270. /** \brief keyboard_init
  271. *
  272. * FIXME: needs doc
  273. */
  274. void keyboard_init(void) {
  275. timer_init();
  276. sync_timer_init();
  277. matrix_init();
  278. #if defined(CRC_ENABLE)
  279. crc_init();
  280. #endif
  281. #ifdef VIA_ENABLE
  282. via_init();
  283. #endif
  284. #ifdef QWIIC_ENABLE
  285. qwiic_init();
  286. #endif
  287. #ifdef OLED_DRIVER_ENABLE
  288. oled_init(OLED_ROTATION_0);
  289. #endif
  290. #ifdef ST7565_ENABLE
  291. st7565_init(DISPLAY_ROTATION_0);
  292. #endif
  293. #ifdef PS2_MOUSE_ENABLE
  294. ps2_mouse_init();
  295. #endif
  296. #ifdef SERIAL_MOUSE_ENABLE
  297. serial_mouse_init();
  298. #endif
  299. #ifdef ADB_MOUSE_ENABLE
  300. adb_mouse_init();
  301. #endif
  302. #ifdef BACKLIGHT_ENABLE
  303. backlight_init();
  304. #endif
  305. #ifdef RGBLIGHT_ENABLE
  306. rgblight_init();
  307. #endif
  308. #ifdef ENCODER_ENABLE
  309. encoder_init();
  310. #endif
  311. #ifdef STENO_ENABLE
  312. steno_init();
  313. #endif
  314. #ifdef POINTING_DEVICE_ENABLE
  315. pointing_device_init();
  316. #endif
  317. #if defined(NKRO_ENABLE) && defined(FORCE_NKRO)
  318. keymap_config.nkro = 1;
  319. eeconfig_update_keymap(keymap_config.raw);
  320. #endif
  321. #ifdef DIP_SWITCH_ENABLE
  322. dip_switch_init();
  323. #endif
  324. #if defined(DEBUG_MATRIX_SCAN_RATE) && defined(CONSOLE_ENABLE)
  325. debug_enable = true;
  326. #endif
  327. keyboard_post_init_kb(); /* Always keep this last */
  328. }
  329. /** \brief key_event_task
  330. *
  331. * This function is responsible for calling into other systems when they need to respond to electrical switch press events.
  332. * This is differnet than keycode events as no layer processing, or filtering occurs.
  333. */
  334. void switch_events(uint8_t row, uint8_t col, bool pressed) {
  335. #if defined(LED_MATRIX_ENABLE)
  336. process_led_matrix(row, col, pressed);
  337. #endif
  338. #if defined(RGB_MATRIX_ENABLE)
  339. process_rgb_matrix(row, col, pressed);
  340. #endif
  341. }
  342. /** \brief Keyboard task: Do keyboard routine jobs
  343. *
  344. * Do routine keyboard jobs:
  345. *
  346. * * scan matrix
  347. * * handle mouse movements
  348. * * run visualizer code
  349. * * handle midi commands
  350. * * light LEDs
  351. *
  352. * This is repeatedly called as fast as possible.
  353. */
  354. void keyboard_task(void) {
  355. static matrix_row_t matrix_prev[MATRIX_ROWS];
  356. static uint8_t led_status = 0;
  357. matrix_row_t matrix_row = 0;
  358. matrix_row_t matrix_change = 0;
  359. #ifdef QMK_KEYS_PER_SCAN
  360. uint8_t keys_processed = 0;
  361. #endif
  362. #ifdef ENCODER_ENABLE
  363. bool encoders_changed = false;
  364. #endif
  365. uint8_t matrix_changed = matrix_scan();
  366. if (matrix_changed) last_matrix_activity_trigger();
  367. for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
  368. matrix_row = matrix_get_row(r);
  369. matrix_change = matrix_row ^ matrix_prev[r];
  370. if (matrix_change) {
  371. #ifdef MATRIX_HAS_GHOST
  372. if (has_ghost_in_row(r, matrix_row)) {
  373. continue;
  374. }
  375. #endif
  376. if (debug_matrix) matrix_print();
  377. matrix_row_t col_mask = 1;
  378. for (uint8_t c = 0; c < MATRIX_COLS; c++, col_mask <<= 1) {
  379. if (matrix_change & col_mask) {
  380. if (should_process_keypress()) {
  381. action_exec((keyevent_t){
  382. .key = (keypos_t){.row = r, .col = c}, .pressed = (matrix_row & col_mask), .time = (timer_read() | 1) /* time should not be 0 */
  383. });
  384. }
  385. // record a processed key
  386. matrix_prev[r] ^= col_mask;
  387. switch_events(r, c, (matrix_row & col_mask));
  388. #ifdef QMK_KEYS_PER_SCAN
  389. // only jump out if we have processed "enough" keys.
  390. if (++keys_processed >= QMK_KEYS_PER_SCAN)
  391. #endif
  392. // process a key per task call
  393. goto MATRIX_LOOP_END;
  394. }
  395. }
  396. }
  397. }
  398. // call with pseudo tick event when no real key event.
  399. #ifdef QMK_KEYS_PER_SCAN
  400. // we can get here with some keys processed now.
  401. if (!keys_processed)
  402. #endif
  403. action_exec(TICK);
  404. MATRIX_LOOP_END:
  405. #ifdef DEBUG_MATRIX_SCAN_RATE
  406. matrix_scan_perf_task();
  407. #endif
  408. #if defined(RGBLIGHT_ENABLE)
  409. rgblight_task();
  410. #endif
  411. #ifdef LED_MATRIX_ENABLE
  412. led_matrix_task();
  413. #endif
  414. #ifdef RGB_MATRIX_ENABLE
  415. rgb_matrix_task();
  416. #endif
  417. #if defined(BACKLIGHT_ENABLE)
  418. # if defined(BACKLIGHT_PIN) || defined(BACKLIGHT_PINS)
  419. backlight_task();
  420. # endif
  421. #endif
  422. #ifdef ENCODER_ENABLE
  423. encoders_changed = encoder_read();
  424. if (encoders_changed) last_encoder_activity_trigger();
  425. #endif
  426. #ifdef QWIIC_ENABLE
  427. qwiic_task();
  428. #endif
  429. #ifdef OLED_DRIVER_ENABLE
  430. oled_task();
  431. # ifndef OLED_DISABLE_TIMEOUT
  432. // Wake up oled if user is using those fabulous keys or spinning those encoders!
  433. # ifdef ENCODER_ENABLE
  434. if (matrix_changed || encoders_changed) oled_on();
  435. # else
  436. if (matrix_changed) oled_on();
  437. # endif
  438. # endif
  439. #endif
  440. #ifdef ST7565_ENABLE
  441. st7565_task();
  442. # ifndef ST7565_DISABLE_TIMEOUT
  443. // Wake up display if user is using those fabulous keys or spinning those encoders!
  444. # ifdef ENCODER_ENABLE
  445. if (matrix_changed || encoders_changed) st7565_on();
  446. # else
  447. if (matrix_changed) st7565_on();
  448. # endif
  449. # endif
  450. #endif
  451. #ifdef MOUSEKEY_ENABLE
  452. // mousekey repeat & acceleration
  453. mousekey_task();
  454. #endif
  455. #ifdef PS2_MOUSE_ENABLE
  456. ps2_mouse_task();
  457. #endif
  458. #ifdef SERIAL_MOUSE_ENABLE
  459. serial_mouse_task();
  460. #endif
  461. #ifdef ADB_MOUSE_ENABLE
  462. adb_mouse_task();
  463. #endif
  464. #ifdef SERIAL_LINK_ENABLE
  465. serial_link_update();
  466. #endif
  467. #ifdef VISUALIZER_ENABLE
  468. visualizer_update(default_layer_state, layer_state, visualizer_get_mods(), host_keyboard_leds());
  469. #endif
  470. #ifdef POINTING_DEVICE_ENABLE
  471. pointing_device_task();
  472. #endif
  473. #ifdef MIDI_ENABLE
  474. midi_task();
  475. #endif
  476. #ifdef VELOCIKEY_ENABLE
  477. if (velocikey_enabled()) {
  478. velocikey_decelerate();
  479. }
  480. #endif
  481. #ifdef JOYSTICK_ENABLE
  482. joystick_task();
  483. #endif
  484. #ifdef DIGITIZER_ENABLE
  485. digitizer_task();
  486. #endif
  487. // update LED
  488. if (led_status != host_keyboard_leds()) {
  489. led_status = host_keyboard_leds();
  490. keyboard_set_leds(led_status);
  491. }
  492. }
  493. /** \brief keyboard set leds
  494. *
  495. * FIXME: needs doc
  496. */
  497. void keyboard_set_leds(uint8_t leds) {
  498. if (debug_keyboard) {
  499. debug("keyboard_set_led: ");
  500. debug_hex8(leds);
  501. debug("\n");
  502. }
  503. led_set(leds);
  504. }