usb_keyboard.c

   1 #include <avr/interrupt.h>
   2 #include <avr/pgmspace.h>
   3 #include "usb_keycodes.h"
   4 #include "usb_keyboard.h"
   5 #include "print.h"
   6 #include "debug.h"
   7
   8
   9 // keyboard report.
  10 static usb_keyboard_report_t _report0 = { {0}, 0 };
  11 static usb_keyboard_report_t _report1 = { {0}, 0 };
  12 usb_keyboard_report_t *usb_keyboard_report = &_report0;
  13 usb_keyboard_report_t *usb_keyboard_report_prev = &_report1;
  14
  15 // protocol setting from the host.  We use exactly the same report
  16 // either way, so this variable only stores the setting since we
  17 // are required to be able to report which setting is in use.
  18 uint8_t usb_keyboard_protocol=1;
  19
  20 // the idle configuration, how often we send the report to the
  21 // host (ms * 4) even when it hasn't changed
  22 uint8_t usb_keyboard_idle_config=125;
  23
  24 // count until idle timeout
  25 uint8_t usb_keyboard_idle_count=0;
  26
  27 // 1=num lock, 2=caps lock, 4=scroll lock, 8=compose, 16=kana
  28 volatile uint8_t usb_keyboard_leds=0;
  29
  30
  31 int8_t usb_keyboard_send(void)
  32 {
  33     return usb_keyboard_send_report(usb_keyboard_report);
  34 }
  35
  36
  37 int8_t usb_keyboard_send_report(usb_keyboard_report_t *report)
  38 {
  39         uint8_t i, intr_state, timeout;
  40
  41         if (!usb_configured()) return -1;
  42         intr_state = SREG;
  43         cli();
  44         UENUM = KEYBOARD_ENDPOINT;
  45         timeout = UDFNUML + 50;
  46         while (1) {
  47                 // are we ready to transmit?
  48                 if (UEINTX & (1<<RWAL)) break;
  49                 SREG = intr_state;
  50                 // has the USB gone offline?
  51                 if (!usb_configured()) return -1;
  52                 // have we waited too long?
  53                 if (UDFNUML == timeout) return -1;
  54                 // get ready to try checking again
  55                 intr_state = SREG;
  56                 cli();
  57                 UENUM = KEYBOARD_ENDPOINT;
  58         }
  59         UEDATX = report->mods;
  60         UEDATX = 0;
  61         for (i = 0; i < 6; i++) {
  62                 UEDATX = report->keys[i];
  63         }
  64         UEINTX = 0x3A;
  65         SREG = intr_state;
  66
  67         if (!usb_configured()) return -1;
  68         intr_state = SREG;
  69         cli();
  70         UENUM = KEYBOARD_ENDPOINT2;
  71         timeout = UDFNUML + 50;
  72         while (1) {
  73                 // are we ready to transmit?
  74                 if (UEINTX & (1<<RWAL)) break;
  75                 SREG = intr_state;
  76                 // has the USB gone offline?
  77                 if (!usb_configured()) return -1;
  78                 // have we waited too long?
  79                 if (UDFNUML == timeout) return -1;
  80                 // get ready to try checking again
  81                 intr_state = SREG;
  82                 cli();
  83                 UENUM = KEYBOARD_ENDPOINT2;
  84         }
  85         UEDATX = 0;
  86         UEDATX = 0;
  87         for (i = 6; i < 12; i++) {
  88                 UEDATX = report->keys[i];
  89         }
  90         UEINTX = 0x3A;
  91         SREG = intr_state;
  92
  93         usb_keyboard_idle_count = 0;
  94         report->is_sent =true;
  95         usb_keyboard_print_report(report);
  96         return 0;
  97 }
  98
  99 void usb_keyboard_swap_report(void) {
 100     usb_keyboard_report_t *tmp = usb_keyboard_report_prev;
 101     usb_keyboard_report_prev = usb_keyboard_report;
 102     usb_keyboard_report = tmp;
 103 }
 104
 105 void usb_keyboard_clear_report(void) {
 106     usb_keyboard_clear_keys();
 107     usb_keyboard_clear_mods();
 108     usb_keyboard_report->is_sent = false;
 109 }
 110
 111 void usb_keyboard_clear_keys(void) {
 112     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) usb_keyboard_report->keys[i] = 0;
 113 }
 114
 115 void usb_keyboard_clear_mods(void)
 116 {
 117     usb_keyboard_report->mods = 0;
 118 }
 119
 120 void usb_keyboard_add_code(uint8_t code)
 121 {
 122     if (IS_MOD(code)) {
 123         usb_keyboard_add_mod(code);
 124     } else {
 125         usb_keyboard_add_key(code);
 126     }
 127 }
 128
 129 void usb_keyboard_add_key(uint8_t code)
 130 {
 131     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) {
 132         if (!usb_keyboard_report->keys[i]) {
 133             usb_keyboard_report->keys[i] = code;
 134             return;
 135         }
 136     }
 137 }
 138
 139 void usb_keyboard_set_keys(uint8_t *keys)
 140 {
 141     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++)
 142         usb_keyboard_report->keys[i] = keys[i];
 143 }
 144
 145 void usb_keyboard_set_mods(uint8_t mods)
 146 {
 147     usb_keyboard_report->mods = mods;
 148 }
 149
 150 void usb_keyboard_add_mod(uint8_t code)
 151 {
 152     usb_keyboard_report->mods |= MOD_BIT(code);
 153 }
 154
 155 void usb_keyboard_del_code(uint8_t code)
 156 {
 157     if (IS_MOD(code)) {
 158         usb_keyboard_del_mod(code);
 159     } else {
 160         usb_keyboard_del_key(code);
 161     }
 162 }
 163
 164 void usb_keyboard_del_key(uint8_t code)
 165 {
 166     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) {
 167         if (usb_keyboard_report->keys[i] == code) {
 168             usb_keyboard_report->keys[i] = KB_NO;
 169             return;
 170         }
 171     }
 172 }
 173
 174 void usb_keyboard_del_mod(uint8_t code)
 175 {
 176     usb_keyboard_report->mods &= ~MOD_BIT(code);
 177 }
 178
 179 bool usb_keyboard_is_sent(void)
 180 {
 181     return usb_keyboard_report->is_sent;
 182 }
 183
 184 bool usb_keyboard_has_key(void)
 185 {
 186     uint8_t keys = 0;
 187     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) keys |= usb_keyboard_report->keys[i];
 188     return keys ? true : false;
 189 }
 190
 191 bool usb_keyboard_has_mod(void)
 192 {
 193     return usb_keyboard_report->mods ? true : false;
 194 }
 195
 196 void usb_keyboard_print_report(usb_keyboard_report_t *report)
 197 {
 198     if (!debug_keyboard) return;
 199     print("keys: ");
 200     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) { phex(report->keys[i]); print(" "); }
 201     print(" mods: "); phex(report->mods); print("\n");
 202 }