Keyboard firmwares for Atmel AVR and Cortex-M
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233
  1. /*
  2. Copyright 2016 Jun Wako <[email protected]>
  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 <stdbool.h>
  16. // USB HID host
  17. #include "Usb.h"
  18. #include "usbhub.h"
  19. #include "hid.h"
  20. #include "hidboot.h"
  21. #include "parser.h"
  22. #include "keycode.h"
  23. #include "util.h"
  24. #include "print.h"
  25. #include "debug.h"
  26. #include "timer.h"
  27. #include "matrix.h"
  28. #include "led.h"
  29. #include "host.h"
  30. #include "keyboard.h"
  31. /* KEY CODE to Matrix
  32. *
  33. * HID keycode(1 byte):
  34. * Higher 5 bits indicates ROW and lower 3 bits COL.
  35. *
  36. * 7 6 5 4 3 2 1 0
  37. * +---------------+
  38. * | ROW | COL |
  39. * +---------------+
  40. *
  41. * Matrix space(16 * 16):
  42. * r\c0123456789ABCDEF
  43. * 0 +----------------+
  44. * : | |
  45. * : | |
  46. * 16 +----------------+
  47. */
  48. #define ROW_MASK 0xF0
  49. #define COL_MASK 0x0F
  50. #define CODE(row, col) (((row) << 4) | (col))
  51. #define ROW(code) (((code) & ROW_MASK) >> 4)
  52. #define COL(code) ((code) & COL_MASK)
  53. #define ROW_BITS(code) (1 << COL(code))
  54. // Integrated key state of all keyboards
  55. static report_keyboard_t keyboard_report;
  56. static bool matrix_is_mod =false;
  57. /*
  58. * USB Host Shield HID keyboards
  59. * This supports two cascaded hubs and four keyboards
  60. */
  61. USB usb_host;
  62. USBHub hub1(&usb_host);
  63. USBHub hub2(&usb_host);
  64. HIDBoot<HID_PROTOCOL_KEYBOARD> kbd1(&usb_host);
  65. HIDBoot<HID_PROTOCOL_KEYBOARD> kbd2(&usb_host);
  66. HIDBoot<HID_PROTOCOL_KEYBOARD> kbd3(&usb_host);
  67. HIDBoot<HID_PROTOCOL_KEYBOARD> kbd4(&usb_host);
  68. KBDReportParser kbd_parser1;
  69. KBDReportParser kbd_parser2;
  70. KBDReportParser kbd_parser3;
  71. KBDReportParser kbd_parser4;
  72. uint8_t matrix_rows(void) { return MATRIX_ROWS; }
  73. uint8_t matrix_cols(void) { return MATRIX_COLS; }
  74. bool matrix_has_ghost(void) { return false; }
  75. void matrix_init(void) {
  76. // USB Host Shield setup
  77. usb_host.Init();
  78. kbd1.SetReportParser(0, (HIDReportParser*)&kbd_parser1);
  79. kbd2.SetReportParser(0, (HIDReportParser*)&kbd_parser2);
  80. kbd3.SetReportParser(0, (HIDReportParser*)&kbd_parser3);
  81. kbd4.SetReportParser(0, (HIDReportParser*)&kbd_parser4);
  82. }
  83. static void or_report(report_keyboard_t report) {
  84. // integrate reports into keyboard_report
  85. keyboard_report.mods |= report.mods;
  86. for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
  87. if (IS_ANY(report.keys[i])) {
  88. for (uint8_t j = 0; j < KEYBOARD_REPORT_KEYS; j++) {
  89. if (! keyboard_report.keys[j]) {
  90. keyboard_report.keys[j] = report.keys[i];
  91. break;
  92. }
  93. }
  94. }
  95. }
  96. }
  97. uint8_t matrix_scan(void) {
  98. static uint16_t last_time_stamp1 = 0;
  99. static uint16_t last_time_stamp2 = 0;
  100. static uint16_t last_time_stamp3 = 0;
  101. static uint16_t last_time_stamp4 = 0;
  102. // check report came from keyboards
  103. if (kbd_parser1.time_stamp != last_time_stamp1 ||
  104. kbd_parser2.time_stamp != last_time_stamp2 ||
  105. kbd_parser3.time_stamp != last_time_stamp3 ||
  106. kbd_parser4.time_stamp != last_time_stamp4) {
  107. last_time_stamp1 = kbd_parser1.time_stamp;
  108. last_time_stamp2 = kbd_parser2.time_stamp;
  109. last_time_stamp3 = kbd_parser3.time_stamp;
  110. last_time_stamp4 = kbd_parser4.time_stamp;
  111. // clear and integrate all reports
  112. keyboard_report = {};
  113. or_report(kbd_parser1.report);
  114. or_report(kbd_parser2.report);
  115. or_report(kbd_parser3.report);
  116. or_report(kbd_parser4.report);
  117. matrix_is_mod = true;
  118. dprintf("state: %02X %02X", keyboard_report.mods, keyboard_report.reserved);
  119. for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
  120. dprintf(" %02X", keyboard_report.keys[i]);
  121. }
  122. dprint("\r\n");
  123. } else {
  124. matrix_is_mod = false;
  125. }
  126. uint16_t timer;
  127. timer = timer_read();
  128. usb_host.Task();
  129. timer = timer_elapsed(timer);
  130. if (timer > 100) {
  131. dprintf("host.Task: %d\n", timer);
  132. }
  133. static uint8_t usb_state = 0;
  134. if (usb_state != usb_host.getUsbTaskState()) {
  135. usb_state = usb_host.getUsbTaskState();
  136. dprintf("usb_state: %02X\n", usb_state);
  137. // restore LED state when keyboard comes up
  138. if (usb_state == USB_STATE_RUNNING) {
  139. keyboard_set_leds(host_keyboard_leds());
  140. }
  141. }
  142. return 1;
  143. }
  144. bool matrix_is_modified(void) {
  145. return matrix_is_mod;
  146. }
  147. bool matrix_is_on(uint8_t row, uint8_t col) {
  148. uint8_t code = CODE(row, col);
  149. if (IS_MOD(code)) {
  150. if (keyboard_report.mods & ROW_BITS(code)) {
  151. return true;
  152. }
  153. }
  154. for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
  155. if (keyboard_report.keys[i] == code) {
  156. return true;
  157. }
  158. }
  159. return false;
  160. }
  161. matrix_row_t matrix_get_row(uint8_t row) {
  162. uint16_t row_bits = 0;
  163. if (IS_MOD(CODE(row, 0)) && keyboard_report.mods) {
  164. row_bits |= keyboard_report.mods;
  165. }
  166. for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
  167. if (IS_ANY(keyboard_report.keys[i])) {
  168. if (row == ROW(keyboard_report.keys[i])) {
  169. row_bits |= ROW_BITS(keyboard_report.keys[i]);
  170. }
  171. }
  172. }
  173. return row_bits;
  174. }
  175. uint8_t matrix_key_count(void) {
  176. uint8_t count = 0;
  177. count += bitpop(keyboard_report.mods);
  178. for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
  179. if (IS_ANY(keyboard_report.keys[i])) {
  180. count++;
  181. }
  182. }
  183. return count;
  184. }
  185. void matrix_print(void) {
  186. print("\nr/c 0123456789ABCDEF\n");
  187. for (uint8_t row = 0; row < matrix_rows(); row++) {
  188. xprintf("%02d: ", row);
  189. print_bin_reverse16(matrix_get_row(row));
  190. print("\n");
  191. }
  192. }
  193. void led_set(uint8_t usb_led)
  194. {
  195. kbd1.SetReport(0, 0, 2, 0, 1, &usb_led);
  196. kbd2.SetReport(0, 0, 2, 0, 1, &usb_led);
  197. kbd3.SetReport(0, 0, 2, 0, 1, &usb_led);
  198. kbd4.SetReport(0, 0, 2, 0, 1, &usb_led);
  199. }