keyboard.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397
  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 "print.h"
  23. #include "debug.h"
  24. #include "command.h"
  25. #include "util.h"
  26. #include "sendchar.h"
  27. #include "eeconfig.h"
  28. #include "backlight.h"
  29. #include "action_layer.h"
  30. #ifdef BOOTMAGIC_ENABLE
  31. # include "bootmagic.h"
  32. #else
  33. # include "magic.h"
  34. #endif
  35. #ifdef MOUSEKEY_ENABLE
  36. # include "mousekey.h"
  37. #endif
  38. #ifdef PS2_MOUSE_ENABLE
  39. # include "ps2_mouse.h"
  40. #endif
  41. #ifdef SERIAL_MOUSE_ENABLE
  42. # include "serial_mouse.h"
  43. #endif
  44. #ifdef ADB_MOUSE_ENABLE
  45. # include "adb.h"
  46. #endif
  47. #ifdef RGBLIGHT_ENABLE
  48. # include "rgblight.h"
  49. #endif
  50. #ifdef STENO_ENABLE
  51. # include "process_steno.h"
  52. #endif
  53. #ifdef FAUXCLICKY_ENABLE
  54. # include "fauxclicky.h"
  55. #endif
  56. #ifdef SERIAL_LINK_ENABLE
  57. # include "serial_link/system/serial_link.h"
  58. #endif
  59. #ifdef VISUALIZER_ENABLE
  60. # include "visualizer/visualizer.h"
  61. #endif
  62. #ifdef POINTING_DEVICE_ENABLE
  63. # include "pointing_device.h"
  64. #endif
  65. #ifdef MIDI_ENABLE
  66. # include "process_midi.h"
  67. #endif
  68. #ifdef HD44780_ENABLE
  69. # include "hd44780.h"
  70. #endif
  71. #ifdef QWIIC_ENABLE
  72. # include "qwiic.h"
  73. #endif
  74. #ifdef OLED_DRIVER_ENABLE
  75. # include "oled_driver.h"
  76. #endif
  77. #ifdef VELOCIKEY_ENABLE
  78. # include "velocikey.h"
  79. #endif
  80. // Only enable this if console is enabled to print to
  81. #if defined(DEBUG_MATRIX_SCAN_RATE) && defined(CONSOLE_ENABLE)
  82. static uint32_t matrix_timer = 0;
  83. static uint32_t matrix_scan_count = 0;
  84. void matrix_scan_perf_task(void) {
  85. matrix_scan_count++;
  86. uint32_t timer_now = timer_read32();
  87. if (TIMER_DIFF_32(timer_now, matrix_timer) > 1000) {
  88. dprintf("matrix scan frequency: %d\n", matrix_scan_count);
  89. matrix_timer = timer_now;
  90. matrix_scan_count = 0;
  91. }
  92. }
  93. #else
  94. # define matrix_scan_perf_task()
  95. #endif
  96. #ifdef MATRIX_HAS_GHOST
  97. extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
  98. static matrix_row_t get_real_keys(uint8_t row, matrix_row_t rowdata) {
  99. matrix_row_t out = 0;
  100. for (uint8_t col = 0; col < MATRIX_COLS; col++) {
  101. // read each key in the row data and check if the keymap defines it as a real key
  102. if (pgm_read_byte(&keymaps[0][row][col]) && (rowdata & (1 << col))) {
  103. // this creates new row data, if a key is defined in the keymap, it will be set here
  104. out |= 1 << col;
  105. }
  106. }
  107. return out;
  108. }
  109. static inline bool popcount_more_than_one(matrix_row_t rowdata) {
  110. rowdata &= rowdata - 1; // if there are less than two bits (keys) set, rowdata will become zero
  111. return rowdata;
  112. }
  113. static inline bool has_ghost_in_row(uint8_t row, matrix_row_t rowdata) {
  114. /* No ghost exists when less than 2 keys are down on the row.
  115. If there are "active" blanks in the matrix, the key can't be pressed by the user,
  116. there is no doubt as to which keys are really being pressed.
  117. The ghosts will be ignored, they are KC_NO. */
  118. rowdata = get_real_keys(row, rowdata);
  119. if ((popcount_more_than_one(rowdata)) == 0) {
  120. return false;
  121. }
  122. /* Ghost occurs when the row shares a column line with other row,
  123. and two columns are read on each row. Blanks in the matrix don't matter,
  124. so they are filtered out.
  125. If there are two or more real keys pressed and they match columns with
  126. at least two of another row's real keys, the row will be ignored. Keep in mind,
  127. we are checking one row at a time, not all of them at once.
  128. */
  129. for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
  130. if (i != row && popcount_more_than_one(get_real_keys(i, matrix_get_row(i)) & rowdata)) {
  131. return true;
  132. }
  133. }
  134. return false;
  135. }
  136. #endif
  137. void disable_jtag(void) {
  138. // To use PF4-7 (PC2-5 on ATmega32A), disable JTAG by writing JTD bit twice within four cycles.
  139. #if (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__))
  140. MCUCR |= _BV(JTD);
  141. MCUCR |= _BV(JTD);
  142. #elif defined(__AVR_ATmega32A__)
  143. MCUCSR |= _BV(JTD);
  144. MCUCSR |= _BV(JTD);
  145. #endif
  146. }
  147. /** \brief matrix_setup
  148. *
  149. * FIXME: needs doc
  150. */
  151. __attribute__((weak)) void matrix_setup(void) {}
  152. /** \brief keyboard_pre_init_user
  153. *
  154. * FIXME: needs doc
  155. */
  156. __attribute__((weak)) void keyboard_pre_init_user(void) {}
  157. /** \brief keyboard_pre_init_kb
  158. *
  159. * FIXME: needs doc
  160. */
  161. __attribute__((weak)) void keyboard_pre_init_kb(void) { keyboard_pre_init_user(); }
  162. /** \brief keyboard_post_init_user
  163. *
  164. * FIXME: needs doc
  165. */
  166. __attribute__((weak)) void keyboard_post_init_user() {}
  167. /** \brief keyboard_post_init_kb
  168. *
  169. * FIXME: needs doc
  170. */
  171. __attribute__((weak)) void keyboard_post_init_kb(void) { keyboard_post_init_user(); }
  172. /** \brief keyboard_setup
  173. *
  174. * FIXME: needs doc
  175. */
  176. void keyboard_setup(void) {
  177. #ifndef NO_JTAG_DISABLE
  178. disable_jtag();
  179. #endif
  180. matrix_setup();
  181. keyboard_pre_init_kb();
  182. }
  183. /** \brief is_keyboard_master
  184. *
  185. * FIXME: needs doc
  186. */
  187. __attribute__((weak)) bool is_keyboard_master(void) { return true; }
  188. /** \brief keyboard_init
  189. *
  190. * FIXME: needs doc
  191. */
  192. void keyboard_init(void) {
  193. timer_init();
  194. matrix_init();
  195. #ifdef QWIIC_ENABLE
  196. qwiic_init();
  197. #endif
  198. #ifdef OLED_DRIVER_ENABLE
  199. oled_init(OLED_ROTATION_0);
  200. #endif
  201. #ifdef PS2_MOUSE_ENABLE
  202. ps2_mouse_init();
  203. #endif
  204. #ifdef SERIAL_MOUSE_ENABLE
  205. serial_mouse_init();
  206. #endif
  207. #ifdef ADB_MOUSE_ENABLE
  208. adb_mouse_init();
  209. #endif
  210. #ifdef BOOTMAGIC_ENABLE
  211. bootmagic();
  212. #else
  213. magic();
  214. #endif
  215. #ifdef BACKLIGHT_ENABLE
  216. backlight_init();
  217. #endif
  218. #ifdef RGBLIGHT_ENABLE
  219. rgblight_init();
  220. #endif
  221. #ifdef STENO_ENABLE
  222. steno_init();
  223. #endif
  224. #ifdef FAUXCLICKY_ENABLE
  225. fauxclicky_init();
  226. #endif
  227. #ifdef POINTING_DEVICE_ENABLE
  228. pointing_device_init();
  229. #endif
  230. #if defined(NKRO_ENABLE) && defined(FORCE_NKRO)
  231. keymap_config.nkro = 1;
  232. #endif
  233. keyboard_post_init_kb(); /* Always keep this last */
  234. }
  235. /** \brief Keyboard task: Do keyboard routine jobs
  236. *
  237. * Do routine keyboard jobs:
  238. *
  239. * * scan matrix
  240. * * handle mouse movements
  241. * * run visualizer code
  242. * * handle midi commands
  243. * * light LEDs
  244. *
  245. * This is repeatedly called as fast as possible.
  246. */
  247. void keyboard_task(void) {
  248. static matrix_row_t matrix_prev[MATRIX_ROWS];
  249. static uint8_t led_status = 0;
  250. matrix_row_t matrix_row = 0;
  251. matrix_row_t matrix_change = 0;
  252. #ifdef QMK_KEYS_PER_SCAN
  253. uint8_t keys_processed = 0;
  254. #endif
  255. #if defined(OLED_DRIVER_ENABLE) && !defined(OLED_DISABLE_TIMEOUT)
  256. uint8_t ret = matrix_scan();
  257. #else
  258. matrix_scan();
  259. #endif
  260. if (is_keyboard_master()) {
  261. for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
  262. matrix_row = matrix_get_row(r);
  263. matrix_change = matrix_row ^ matrix_prev[r];
  264. if (matrix_change) {
  265. #ifdef MATRIX_HAS_GHOST
  266. if (has_ghost_in_row(r, matrix_row)) {
  267. continue;
  268. }
  269. #endif
  270. if (debug_matrix) matrix_print();
  271. for (uint8_t c = 0; c < MATRIX_COLS; c++) {
  272. if (matrix_change & ((matrix_row_t)1 << c)) {
  273. action_exec((keyevent_t){
  274. .key = (keypos_t){.row = r, .col = c}, .pressed = (matrix_row & ((matrix_row_t)1 << c)), .time = (timer_read() | 1) /* time should not be 0 */
  275. });
  276. // record a processed key
  277. matrix_prev[r] ^= ((matrix_row_t)1 << c);
  278. #ifdef QMK_KEYS_PER_SCAN
  279. // only jump out if we have processed "enough" keys.
  280. if (++keys_processed >= QMK_KEYS_PER_SCAN)
  281. #endif
  282. // process a key per task call
  283. goto MATRIX_LOOP_END;
  284. }
  285. }
  286. }
  287. }
  288. }
  289. // call with pseudo tick event when no real key event.
  290. #ifdef QMK_KEYS_PER_SCAN
  291. // we can get here with some keys processed now.
  292. if (!keys_processed)
  293. #endif
  294. action_exec(TICK);
  295. MATRIX_LOOP_END:
  296. #ifdef DEBUG_MATRIX_SCAN_RATE
  297. matrix_scan_perf_task();
  298. #endif
  299. #ifdef QWIIC_ENABLE
  300. qwiic_task();
  301. #endif
  302. #ifdef OLED_DRIVER_ENABLE
  303. oled_task();
  304. # ifndef OLED_DISABLE_TIMEOUT
  305. // Wake up oled if user is using those fabulous keys!
  306. if (ret) oled_on();
  307. # endif
  308. #endif
  309. #ifdef MOUSEKEY_ENABLE
  310. // mousekey repeat & acceleration
  311. mousekey_task();
  312. #endif
  313. #ifdef PS2_MOUSE_ENABLE
  314. ps2_mouse_task();
  315. #endif
  316. #ifdef SERIAL_MOUSE_ENABLE
  317. serial_mouse_task();
  318. #endif
  319. #ifdef ADB_MOUSE_ENABLE
  320. adb_mouse_task();
  321. #endif
  322. #ifdef SERIAL_LINK_ENABLE
  323. serial_link_update();
  324. #endif
  325. #ifdef VISUALIZER_ENABLE
  326. visualizer_update(default_layer_state, layer_state, visualizer_get_mods(), host_keyboard_leds());
  327. #endif
  328. #ifdef POINTING_DEVICE_ENABLE
  329. pointing_device_task();
  330. #endif
  331. #ifdef MIDI_ENABLE
  332. midi_task();
  333. #endif
  334. #ifdef VELOCIKEY_ENABLE
  335. if (velocikey_enabled()) {
  336. velocikey_decelerate();
  337. }
  338. #endif
  339. // update LED
  340. if (led_status != host_keyboard_leds()) {
  341. led_status = host_keyboard_leds();
  342. keyboard_set_leds(led_status);
  343. }
  344. }
  345. /** \brief keyboard set leds
  346. *
  347. * FIXME: needs doc
  348. */
  349. void keyboard_set_leds(uint8_t leds) {
  350. if (debug_keyboard) {
  351. debug("keyboard_set_led: ");
  352. debug_hex8(leds);
  353. debug("\n");
  354. }
  355. led_set(leds);
  356. }