usb_keyboard.c.bak

   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_back = &_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
  43         timeout = UDFNUML + 50;
  44         do {
  45                 intr_state = SREG;
  46                 cli();
  47                 UENUM = KEYBOARD_ENDPOINT;
  48                 // are we ready to transmit?
  49                 if (UEINTX & (1<<RWAL)) break;
  50                 SREG = intr_state;
  51
  52                 // has the USB gone offline?
  53                 if (!usb_configured()) return -1;
  54                 // have we waited too long?
  55                 if (UDFNUML == timeout) return -1;
  56         } while (1);
  57         UEDATX = report->mods;
  58         UEDATX = 0;
  59         for (i = 0; i < 6; i++) {
  60                 UEDATX = report->keys[i];
  61         }
  62         UEINTX = 0x3A;
  63
  64 /*
  65         timeout = UDFNUML + 50;
  66         do {
  67                 intr_state = SREG;
  68                 cli();
  69                 UENUM = KEYBOARD_ENDPOINT2;
  70                 // are we ready to transmit?
  71                 if (UEINTX & (1<<RWAL)) break;
  72                 SREG = intr_state;
  73
  74                 // has the USB gone offline?
  75                 if (!usb_configured()) return -1;
  76                 // have we waited too long?
  77                 if (UDFNUML == timeout) return -1;
  78         } while (1);
  79         UEDATX = 0;
  80         UEDATX = 0;
  81         for (i = 6; i < 12; i++) {
  82                 UEDATX = report->keys[i];
  83         }
  84         UEINTX = 0x3A;
  85 */
  86
  87         usb_keyboard_idle_count = 0;
  88         report->is_sent =true;
  89         usb_keyboard_print_report(report);
  90         return 0;
  91 }
  92
  93 void usb_keyboard_swap_report(void) {
  94     usb_keyboard_report_t *tmp = usb_keyboard_report_back;
  95     usb_keyboard_report_back = usb_keyboard_report;
  96     usb_keyboard_report = tmp;
  97 }
  98
  99 void usb_keyboard_clear_report(void) {
 100     usb_keyboard_clear_keys();
 101     usb_keyboard_clear_mods();
 102     usb_keyboard_report->is_sent = false;
 103 }
 104
 105 void usb_keyboard_clear_keys(void) {
 106     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) usb_keyboard_report->keys[i] = 0;
 107 }
 108
 109 void usb_keyboard_clear_mods(void)
 110 {
 111     usb_keyboard_report->mods = 0;
 112 }
 113
 114 void usb_keyboard_add_code(uint8_t code)
 115 {
 116     if (IS_MOD(code)) {
 117         usb_keyboard_add_mod(code);
 118     } else {
 119         usb_keyboard_add_key(code);
 120     }
 121 }
 122
 123 void usb_keyboard_add_key(uint8_t code)
 124 {
 125     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) {
 126         if (!usb_keyboard_report->keys[i]) {
 127             usb_keyboard_report->keys[i] = code;
 128             return;
 129         }
 130     }
 131 }
 132
 133 void usb_keyboard_set_keys(uint8_t *keys)
 134 {
 135     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++)
 136         usb_keyboard_report->keys[i] = keys[i];
 137 }
 138
 139 void usb_keyboard_set_mods(uint8_t mods)
 140 {
 141     usb_keyboard_report->mods = mods;
 142 }
 143
 144 void usb_keyboard_add_mod(uint8_t code)
 145 {
 146     usb_keyboard_report->mods |= MOD_BIT(code);
 147 }
 148
 149 void usb_keyboard_del_code(uint8_t code)
 150 {
 151     if (IS_MOD(code)) {
 152         usb_keyboard_del_mod(code);
 153     } else {
 154         usb_keyboard_del_key(code);
 155     }
 156 }
 157
 158 void usb_keyboard_del_key(uint8_t code)
 159 {
 160     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) {
 161         if (usb_keyboard_report->keys[i] == code) {
 162             usb_keyboard_report->keys[i] = KB_NO;
 163             return;
 164         }
 165     }
 166 }
 167
 168 void usb_keyboard_del_mod(uint8_t code)
 169 {
 170     usb_keyboard_report->mods &= ~MOD_BIT(code);
 171 }
 172
 173 bool usb_keyboard_is_sent(void)
 174 {
 175     return usb_keyboard_report->is_sent;
 176 }
 177
 178 bool usb_keyboard_has_key(void)
 179 {
 180     uint8_t keys = 0;
 181     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) keys |= usb_keyboard_report->keys[i];
 182     return keys ? true : false;
 183 }
 184
 185 bool usb_keyboard_has_mod(void)
 186 {
 187     return usb_keyboard_report->mods ? true : false;
 188 }
 189
 190 void usb_keyboard_print_report(usb_keyboard_report_t *report)
 191 {
 192     if (!debug_keyboard) return;
 193     print("keys: ");
 194     for (int i = 0; i < KEYBOARD_REPORT_MAX; i++) { phex(report->keys[i]); print(" "); }
 195     print(" mods: "); phex(report->mods); print("\n");
 196 }