key_process.c

   1 #include <stdbool.h>
   2 #include <avr/io.h>
   3 #include <avr/interrupt.h>
   4 #include <util/delay.h>
   5 #include "print.h"
   6 #include "debug.h"
   7 #include "timer.h"
   8 #include "util.h"
   9 #include "jump_bootloader.h"
  10 #include "usb_keyboard.h"
  11 #include "usb_mouse.h"
  12 #include "usb_extra.h"
  13 #include "usb_keycodes.h"
  14 #include "usb.h"
  15 #include "layer.h"
  16 #include "matrix_skel.h"
  17 #include "keymap_skel.h"
  18 #include "key_process.h"
  19 #ifdef MOUSEKEY_ENABLE
  20 #   include "mousekey.h"
  21 #endif
  22 #ifdef PS2_MOUSE_ENABLE
  23 #   include "ps2_mouse.h"
  24 #endif
  25
  26
  27 // TODO: refactoring
  28 void proc_matrix(void) {
  29     bool modified = false;
  30     uint8_t fn_bits = 0;
  31
  32     matrix_scan();
  33     modified = matrix_is_modified();
  34
  35     if (modified) {
  36         if (debug_matrix) matrix_print();
  37 #ifdef DEBUG_LED
  38         // LED flash for debug
  39         DEBUG_LED_CONFIG;
  40         DEBUG_LED_ON;
  41 #endif
  42     }
  43
  44     if (matrix_has_ghost()) {
  45         // should send error?
  46         debug("matrix has ghost!!\n");
  47         return;
  48     }
  49
  50     usb_keyboard_swap_report();
  51     usb_keyboard_clear_report();
  52     for (int row = 0; row < matrix_rows(); row++) {
  53         for (int col = 0; col < matrix_cols(); col++) {
  54             if (!matrix_is_on(row, col)) continue;
  55
  56             // TODO: clean code
  57             uint8_t code = layer_get_keycode(row, col);
  58             if (code == KB_NO) {
  59                 // do nothing
  60             } else if (IS_MOD(code)) {
  61                 usb_keyboard_add_mod(code);
  62             } else if (IS_FN(code)) {
  63                 fn_bits |= FN_BIT(code);
  64             } else if (IS_MOUSE(code)) {
  65 #ifdef MOUSEKEY_ENABLE
  66                 mousekey_decode(code);
  67 #endif
  68             }
  69
  70             // audio control & system control
  71             else if (code == KB_MUTE) {
  72                 usb_extra_audio_send(AUDIO_MUTE);
  73                 usb_extra_audio_send(0);
  74                 _delay_ms(500);
  75             } else if (code == KB_VOLU) {
  76                 usb_extra_audio_send(AUDIO_VOL_UP);
  77                 usb_extra_audio_send(0);
  78                 _delay_ms(100);
  79             } else if (code == KB_VOLD) {
  80                 usb_extra_audio_send(AUDIO_VOL_DOWN);
  81                 usb_extra_audio_send(0);
  82                 _delay_ms(100);
  83             } else if (code == KB_PWR) {
  84                 if (suspend && remote_wakeup) {
  85                     usb_remote_wakeup();
  86                 } else {
  87                     usb_extra_system_send(SYSTEM_POWER_DOWN);
  88                 }
  89                 _delay_ms(1000);
  90             }
  91
  92             // normal keys
  93             else {
  94                 usb_keyboard_add_key(code);
  95             }
  96         }
  97     }
  98
  99     if (modified) {
 100 #ifdef DEBUG_LED
 101         // LED flash for debug
 102         DEBUG_LED_CONFIG;
 103         DEBUG_LED_OFF;
 104 #endif
 105     }
 106
 107     layer_switching(fn_bits);
 108
 109     // TODO: clean code
 110     // special mode for control, develop and debug
 111     if (keymap_is_special_mode(fn_bits)) {
 112         switch (usb_keyboard_get_key()) {
 113             case KB_H: // help
 114                 print_enable = true;
 115                 print("b: jump to bootloader\n");
 116                 print("d: toggle debug enable\n");
 117                 print("x: toggle matrix debug\n");
 118                 print("k: toggle keyboard debug\n");
 119                 print("m: toggle mouse debug\n");
 120                 print("p: toggle print enable\n");
 121                 print("v: print version\n");
 122                 print("t: print timer count\n");
 123                 print("s: print status\n");
 124                 print("`: toggle protcol(boot/report)\n");
 125 #ifdef USB_NKRO_ENABLE
 126                 print("n: toggle USB_NKRO\n");
 127 #endif
 128                 print("ESC: power down/wake up\n");
 129 #ifdef PS2_MOUSE_ENABLE
 130                 print("1: ps2_mouse_init \n");
 131                 print("2: ps2_mouse_read \n");
 132                 print("3: ps2_mouse: on/off toggle \n");
 133 #endif
 134                 _delay_ms(500);
 135                 print_enable = false;
 136                 break;
 137 #ifdef PS2_MOUSE_ENABLE
 138             case KB_1:
 139                 usb_keyboard_clear_report();
 140                 usb_keyboard_send();
 141                 print_enable = true;
 142                 print("ps2_mouse_init...\n");
 143                 _delay_ms(500);
 144                 ps2_mouse_init();
 145                 break;
 146             case KB_2:
 147                 usb_keyboard_clear_report();
 148                 usb_keyboard_send();
 149                 print_enable = true;
 150                 print("ps2_mouse_read[btn x y]: ");
 151                 _delay_ms(100);
 152                 ps2_mouse_read();
 153                 phex(ps2_mouse_btn); print(" ");
 154                 phex(ps2_mouse_x); print(" ");
 155                 phex(ps2_mouse_y); print("\n");
 156                 print("ps2_mouse_error_count: "); phex(ps2_mouse_error_count); print("\n");
 157                 break;
 158             case KB_3:
 159                 ps2_mouse_enable = !ps2_mouse_enable;
 160                 print("ps2_mouse: ");
 161                 if (ps2_mouse_enable)
 162                     print("on");
 163                 else
 164                     print("off");
 165                 print("\n");
 166                 _delay_ms(500);
 167                 break;
 168 #endif
 169             case KB_B: // bootloader
 170                 usb_keyboard_clear_report();
 171                 usb_keyboard_send();
 172                 print_enable = true;
 173                 print("jump to bootloader...\n");
 174                 _delay_ms(1000);
 175                 jump_bootloader(); // not return
 176                 break;
 177             case KB_D: // debug all toggle
 178                 usb_keyboard_clear_report();
 179                 usb_keyboard_send();
 180                 debug_enable = !debug_enable;
 181                 if (debug_enable) {
 182                     print_enable = true;
 183                     print("debug enabled.\n");
 184                     debug_matrix = true;
 185                     debug_keyboard = true;
 186                     debug_mouse = true;
 187                 } else {
 188                     print("debug disabled.\n");
 189                     print_enable = false;
 190                     debug_matrix = false;
 191                     debug_keyboard = false;
 192                     debug_mouse = false;
 193                 }
 194                 _delay_ms(1000);
 195                 break;
 196             case KB_X: // debug matrix toggle
 197                 usb_keyboard_clear_report();
 198                 usb_keyboard_send();
 199                 debug_matrix = !debug_matrix;
 200                 if (debug_matrix)
 201                     print("debug matrix enabled.\n");
 202                 else
 203                     print("debug matrix disabled.\n");
 204                 _delay_ms(1000);
 205                 break;
 206             case KB_K: // debug keyboard toggle
 207                 usb_keyboard_clear_report();
 208                 usb_keyboard_send();
 209                 debug_keyboard = !debug_keyboard;
 210                 if (debug_keyboard)
 211                     print("debug keyboard enabled.\n");
 212                 else
 213                     print("debug keyboard disabled.\n");
 214                 _delay_ms(1000);
 215                 break;
 216             case KB_M: // debug mouse toggle
 217                 usb_keyboard_clear_report();
 218                 usb_keyboard_send();
 219                 debug_mouse = !debug_mouse;
 220                 if (debug_mouse)
 221                     print("debug mouse enabled.\n");
 222                 else
 223                     print("debug mouse disabled.\n");
 224                 _delay_ms(1000);
 225                 break;
 226             case KB_V: // print version & information
 227                 usb_keyboard_clear_report();
 228                 usb_keyboard_send();
 229                 print_enable = true;
 230                 print(STR(DESCRIPTION) "\n");
 231                 _delay_ms(1000);
 232                 break;
 233             case KB_T: // print timer
 234                 usb_keyboard_clear_report();
 235                 usb_keyboard_send();
 236                 print_enable = true;
 237                 print("timer: "); phex16(timer_count); print("\n");
 238                 _delay_ms(500);
 239                 break;
 240             case KB_P: // print toggle
 241                 usb_keyboard_clear_report();
 242                 usb_keyboard_send();
 243                 if (print_enable) {
 244                     print("print disabled.\n");
 245                     print_enable = false;
 246                 } else {
 247                     print_enable = true;
 248                     print("print enabled.\n");
 249                 }
 250                 _delay_ms(1000);
 251                 break;
 252             case KB_S:
 253                 usb_keyboard_clear_report();
 254                 usb_keyboard_send();
 255                 print("UDCON: "); phex(UDCON); print("\n");
 256                 print("UDIEN: "); phex(UDIEN); print("\n");
 257                 print("UDINT: "); phex(UDINT); print("\n");
 258                 print("usb_keyboard_leds:"); phex(usb_keyboard_leds); print("\n");
 259                 print("usb_keyboard_protocol:"); phex(usb_keyboard_protocol); print("\n");
 260                 print("usb_keyboard_idle_config:"); phex(usb_keyboard_idle_config); print("\n");
 261                 print("usb_keyboard_idle_count:"); phex(usb_keyboard_idle_count); print("\n");
 262                 print("usb_mouse_protocol:"); phex(usb_mouse_protocol); print("\n");
 263                 if (usb_keyboard_nkro) print("USB_NKRO: enabled\n"); else print("USB_NKRO: disabled\n");
 264                 _delay_ms(500);
 265                 break;
 266             case KB_GRV:
 267                 usb_keyboard_clear_report();
 268                 usb_keyboard_send();
 269                 usb_keyboard_protocol = !usb_keyboard_protocol;
 270                 usb_mouse_protocol = !usb_mouse_protocol;
 271                 print("keyboard protcol: ");
 272                 if (usb_keyboard_protocol) print("report"); else print("boot");
 273                 print("\n");
 274                 print("mouse protcol: ");
 275                 if (usb_mouse_protocol) print("report"); else print("boot");
 276                 print("\n");
 277                 _delay_ms(1000);
 278                 break;
 279 #ifdef USB_NKRO_ENABLE
 280             case KB_N:
 281                 usb_keyboard_clear_report();
 282                 usb_keyboard_send();
 283                 usb_keyboard_nkro = !usb_keyboard_nkro;
 284                 if (usb_keyboard_nkro) print("USB_NKRO: enabled\n"); else print("USB_NKRO: disabled\n");
 285                 _delay_ms(1000);
 286                 break;
 287 #endif
 288             case KB_ESC:
 289                 usb_keyboard_clear_report();
 290                 usb_keyboard_send();
 291                 if (suspend && remote_wakeup) {
 292                     usb_remote_wakeup();
 293                 } else {
 294                     usb_extra_system_send(SYSTEM_POWER_DOWN);
 295                 }
 296                 _delay_ms(1000);
 297                 break;
 298         }
 299     }
 300
 301
 302     if (modified) {
 303         usb_keyboard_send();
 304     }
 305
 306 #ifdef MOUSEKEY_ENABLE
 307     // mouse keys
 308     mousekey_usb_send();
 309 #endif
 310
 311 #ifdef PS2_MOUSE_ENABLE
 312     // ps2 mouse
 313     if (ps2_mouse_read() == 0)
 314         ps2_mouse_usb_send();
 315 #endif
 316 }