]> git.gir.st - tmk_keyboard.git/blob - usb.c
git://git.gir.st / tmk_keyboard.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
add mouse function.
[tmk_keyboard.git] / usb.c
1 /* USB Keyboard Plus Debug Channel Example for Teensy USB Development Board
2 * http://www.pjrc.com/teensy/usb_keyboard.html
3 * Copyright (c) 2009 PJRC.COM, LLC
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 * THE SOFTWARE.
22 */
23
24 #include <avr/io.h>
25 #include <avr/pgmspace.h>
26 #include <avr/interrupt.h>
27 #include "usb.h"
28 #include "usb_keyboard.h"
29 #include "usb_mouse.h"
30 #include "usb_debug.h"
31
32
33 /**************************************************************************
34 *
35 * Configurable Options
36 *
37 **************************************************************************/
38
39 // You can change these to give your code its own name.
40 #define STR_MANUFACTURER L"t.m.k."
41 #define STR_PRODUCT L"t.m.k. keyboard"
42
43
44 // Mac OS-X and Linux automatically load the correct drivers. On
45 // Windows, even though the driver is supplied by Microsoft, an
46 // INF file is needed to load the driver. These numbers need to
47 // match the INF file.
48 #define VENDOR_ID 0xFEED
49 #define PRODUCT_ID 0xBABE
50
51
52 // USB devices are supposed to implment a halt feature, which is
53 // rarely (if ever) used. If you comment this line out, the halt
54 // code will be removed, saving 102 bytes of space (gcc 4.3.0).
55 // This is not strictly USB compliant, but works with all major
56 // operating systems.
57 #define SUPPORT_ENDPOINT_HALT
58
59
60
61 /**************************************************************************
62 *
63 * Endpoint Buffer Configuration
64 *
65 **************************************************************************/
66
67 #define ENDPOINT0_SIZE 32
68
69 // 0:control endpoint is enabled automatically by controller.
70 static const uint8_t PROGMEM endpoint_config_table[] = {
71 // enable, UECFG0X(type, direction), UECFG1X(size, bank, allocation)
72 1, EP_TYPE_INTERRUPT_IN, EP_SIZE(KEYBOARD_SIZE) | KEYBOARD_BUFFER, // 1
73 1, EP_TYPE_INTERRUPT_IN, EP_SIZE(MOUSE_SIZE) | MOUSE_BUFFER, // 2
74 1, EP_TYPE_INTERRUPT_IN, EP_SIZE(DEBUG_TX_SIZE) | DEBUG_TX_BUFFER, // 3
75 0, // 4
76 0, // 5
77 0, // 6
78 };
79
80
81 /**************************************************************************
82 *
83 * Descriptor Data
84 *
85 **************************************************************************/
86
87 // Descriptors are the data that your computer reads when it auto-detects
88 // this USB device (called "enumeration" in USB lingo). The most commonly
89 // changed items are editable at the top of this file. Changing things
90 // in here should only be done by those who've read chapter 9 of the USB
91 // spec and relevant portions of any USB class specifications!
92
93
94 static uint8_t PROGMEM device_descriptor[] = {
95 18, // bLength
96 1, // bDescriptorType
97 0x00, 0x02, // bcdUSB
98 0, // bDeviceClass
99 0, // bDeviceSubClass
100 0, // bDeviceProtocol
101 ENDPOINT0_SIZE, // bMaxPacketSize0
102 LSB(VENDOR_ID), MSB(VENDOR_ID), // idVendor
103 LSB(PRODUCT_ID), MSB(PRODUCT_ID), // idProduct
104 0x00, 0x01, // bcdDevice
105 1, // iManufacturer
106 2, // iProduct
107 0, // iSerialNumber
108 1 // bNumConfigurations
109 };
110
111 // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60
112 static uint8_t PROGMEM keyboard_hid_report_desc[] = {
113 0x05, 0x01, // Usage Page (Generic Desktop),
114 0x09, 0x06, // Usage (Keyboard),
115 0xA1, 0x01, // Collection (Application),
116 0x75, 0x01, // Report Size (1),
117 0x95, 0x08, // Report Count (8),
118 0x05, 0x07, // Usage Page (Key Codes),
119 0x19, 0xE0, // Usage Minimum (224),
120 0x29, 0xE7, // Usage Maximum (231),
121 0x15, 0x00, // Logical Minimum (0),
122 0x25, 0x01, // Logical Maximum (1),
123 0x81, 0x02, // Input (Data, Variable, Absolute), ;Modifier byte
124 0x95, 0x01, // Report Count (1),
125 0x75, 0x08, // Report Size (8),
126 0x81, 0x03, // Input (Constant), ;Reserved byte
127 0x95, 0x05, // Report Count (5),
128 0x75, 0x01, // Report Size (1),
129 0x05, 0x08, // Usage Page (LEDs),
130 0x19, 0x01, // Usage Minimum (1),
131 0x29, 0x05, // Usage Maximum (5),
132 0x91, 0x02, // Output (Data, Variable, Absolute), ;LED report
133 0x95, 0x01, // Report Count (1),
134 0x75, 0x03, // Report Size (3),
135 0x91, 0x03, // Output (Constant), ;LED report padding
136 0x95, 0x06, // Report Count (6),
137 0x75, 0x08, // Report Size (8),
138 0x15, 0x00, // Logical Minimum (0),
139 0x25, 0x68, // Logical Maximum(104),
140 0x05, 0x07, // Usage Page (Key Codes),
141 0x19, 0x00, // Usage Minimum (0),
142 0x29, 0x68, // Usage Maximum (104),
143 0x81, 0x00, // Input (Data, Array),
144 0xc0 // End Collection
145 };
146
147 // Mouse Protocol 1, HID 1.11 spec, Appendix B, page 59-60, with wheel extension
148 static uint8_t PROGMEM mouse_hid_report_desc[] = {
149 0x05, 0x01, // Usage Page (Generic Desktop)
150 0x09, 0x02, // Usage (Mouse)
151 0xA1, 0x01, // Collection (Application)
152 0x05, 0x09, // Usage Page (Button)
153 0x19, 0x01, // Usage Minimum (Button #1)
154 0x29, 0x03, // Usage Maximum (Button #3)
155 0x15, 0x00, // Logical Minimum (0)
156 0x25, 0x01, // Logical Maximum (1)
157 0x95, 0x03, // Report Count (3)
158 0x75, 0x01, // Report Size (1)
159 0x81, 0x02, // Input (Data, Variable, Absolute)
160 0x95, 0x01, // Report Count (1)
161 0x75, 0x05, // Report Size (5)
162 0x81, 0x03, // Input (Constant)
163 0x05, 0x01, // Usage Page (Generic Desktop)
164 0x09, 0x30, // Usage (X)
165 0x09, 0x31, // Usage (Y)
166 0x15, 0x81, // Logical Minimum (-127)
167 0x25, 0x7F, // Logical Maximum (127)
168 0x75, 0x08, // Report Size (8),
169 0x95, 0x02, // Report Count (2),
170 0x81, 0x06, // Input (Data, Variable, Relative)
171 0x09, 0x38, // Usage (Wheel)
172 0x95, 0x01, // Report Count (1),
173 0x81, 0x06, // Input (Data, Variable, Relative)
174 0xC0 // End Collection
175 };
176
177 static uint8_t PROGMEM debug_hid_report_desc[] = {
178 0x06, 0x31, 0xFF, // Usage Page 0xFF31 (vendor defined)
179 0x09, 0x74, // Usage 0x74
180 0xA1, 0x53, // Collection 0x53
181 0x75, 0x08, // report size = 8 bits
182 0x15, 0x00, // logical minimum = 0
183 0x26, 0xFF, 0x00, // logical maximum = 255
184 0x95, DEBUG_TX_SIZE, // report count
185 0x09, 0x75, // usage
186 0x81, 0x02, // Input (array)
187 0xC0 // end collection
188 };
189
190 #define CONFIG1_DESC_SIZE (9+(9+9+7)+(9+9+7)+(9+9+7))
191 #define KEYBOARD_HID_DESC_OFFSET (9+9)
192 #define MOUSE_HID_DESC_OFFSET (9+(9+9+7)+9)
193 #define DEBUG_HID_DESC_OFFSET (9+(9+9+7)+(9+9+7)+9)
194 static uint8_t PROGMEM config1_descriptor[CONFIG1_DESC_SIZE] = {
195 // configuration descriptor, USB spec 9.6.3, page 264-266, Table 9-10
196 9, // bLength;
197 2, // bDescriptorType;
198 LSB(CONFIG1_DESC_SIZE), // wTotalLength
199 MSB(CONFIG1_DESC_SIZE),
200 3, // bNumInterfaces
201 1, // bConfigurationValue
202 0, // iConfiguration
203 0xC0, // bmAttributes
204 50, // bMaxPower
205
206 // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
207 9, // bLength
208 4, // bDescriptorType
209 KEYBOARD_INTERFACE, // bInterfaceNumber
210 0, // bAlternateSetting
211 1, // bNumEndpoints
212 0x03, // bInterfaceClass (0x03 = HID)
213 0x01, // bInterfaceSubClass (0x01 = Boot)
214 0x01, // bInterfaceProtocol (0x01 = Keyboard)
215 0, // iInterface
216 // HID descriptor, HID 1.11 spec, section 6.2.1
217 9, // bLength
218 0x21, // bDescriptorType
219 0x11, 0x01, // bcdHID
220 0, // bCountryCode
221 1, // bNumDescriptors
222 0x22, // bDescriptorType
223 sizeof(keyboard_hid_report_desc), // wDescriptorLength
224 0,
225 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
226 7, // bLength
227 5, // bDescriptorType
228 KEYBOARD_ENDPOINT | 0x80, // bEndpointAddress
229 0x03, // bmAttributes (0x03=intr)
230 KEYBOARD_SIZE, 0, // wMaxPacketSize
231 1, // bInterval
232
233 // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
234 9, // bLength
235 4, // bDescriptorType
236 MOUSE_INTERFACE, // bInterfaceNumber
237 0, // bAlternateSetting
238 1, // bNumEndpoints
239 0x03, // bInterfaceClass (0x03 = HID)
240 0x01, // bInterfaceSubClass (0x01 = Boot)
241 0x02, // bInterfaceProtocol (0x02 = Mouse)
242 0, // iInterface
243 // HID descriptor, HID 1.11 spec, section 6.2.1
244 9, // bLength
245 0x21, // bDescriptorType
246 0x11, 0x01, // bcdHID
247 0, // bCountryCode
248 1, // bNumDescriptors
249 0x22, // bDescriptorType
250 sizeof(mouse_hid_report_desc), // wDescriptorLength
251 0,
252 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
253 7, // bLength
254 5, // bDescriptorType
255 MOUSE_ENDPOINT | 0x80, // bEndpointAddress
256 0x03, // bmAttributes (0x03=intr)
257 4, 0, // wMaxPacketSize
258 1, // bInterval
259
260 // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
261 9, // bLength
262 4, // bDescriptorType
263 DEBUG_INTERFACE, // bInterfaceNumber
264 0, // bAlternateSetting
265 1, // bNumEndpoints
266 0x03, // bInterfaceClass (0x03 = HID)
267 0x00, // bInterfaceSubClass
268 0x00, // bInterfaceProtocol
269 0, // iInterface
270 // HID descriptor, HID 1.11 spec, section 6.2.1
271 9, // bLength
272 0x21, // bDescriptorType
273 0x11, 0x01, // bcdHID
274 0, // bCountryCode
275 1, // bNumDescriptors
276 0x22, // bDescriptorType
277 sizeof(debug_hid_report_desc), // wDescriptorLength
278 0,
279 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
280 7, // bLength
281 5, // bDescriptorType
282 DEBUG_TX_ENDPOINT | 0x80, // bEndpointAddress
283 0x03, // bmAttributes (0x03=intr)
284 DEBUG_TX_SIZE, 0, // wMaxPacketSize
285 1 // bInterval
286 };
287
288 // If you're desperate for a little extra code memory, these strings
289 // can be completely removed if iManufacturer, iProduct, iSerialNumber
290 // in the device desciptor are changed to zeros.
291 struct usb_string_descriptor_struct {
292 uint8_t bLength;
293 uint8_t bDescriptorType;
294 int16_t wString[];
295 };
296 static struct usb_string_descriptor_struct PROGMEM string0 = {
297 4,
298 3,
299 {0x0409}
300 };
301 static struct usb_string_descriptor_struct PROGMEM string1 = {
302 sizeof(STR_MANUFACTURER),
303 3,
304 STR_MANUFACTURER
305 };
306 static struct usb_string_descriptor_struct PROGMEM string2 = {
307 sizeof(STR_PRODUCT),
308 3,
309 STR_PRODUCT
310 };
311
312 // This table defines which descriptor data is sent for each specific
313 // request from the host (in wValue and wIndex).
314 static struct descriptor_list_struct {
315 uint16_t wValue; // descriptor type
316 uint16_t wIndex;
317 const uint8_t *addr;
318 uint8_t length;
319 } PROGMEM descriptor_list[] = {
320 // DEVICE descriptor
321 {0x0100, 0x0000, device_descriptor, sizeof(device_descriptor)},
322 // CONFIGURATION descriptor
323 {0x0200, 0x0000, config1_descriptor, sizeof(config1_descriptor)},
324 // HID REPORT
325 {0x2200, KEYBOARD_INTERFACE, keyboard_hid_report_desc, sizeof(keyboard_hid_report_desc)},
326 {0x2100, KEYBOARD_INTERFACE, config1_descriptor+KEYBOARD_HID_DESC_OFFSET, 9},
327 // HID REPORT
328 {0x2200, MOUSE_INTERFACE, mouse_hid_report_desc, sizeof(mouse_hid_report_desc)},
329 {0x2100, MOUSE_INTERFACE, config1_descriptor+MOUSE_HID_DESC_OFFSET, 9},
330 // HID REPORT
331 {0x2200, DEBUG_INTERFACE, debug_hid_report_desc, sizeof(debug_hid_report_desc)},
332 {0x2100, DEBUG_INTERFACE, config1_descriptor+DEBUG_HID_DESC_OFFSET, 9},
333 // STRING descriptor
334 {0x0300, 0x0000, (const uint8_t *)&string0, 4},
335 {0x0301, 0x0409, (const uint8_t *)&string1, sizeof(STR_MANUFACTURER)},
336 {0x0302, 0x0409, (const uint8_t *)&string2, sizeof(STR_PRODUCT)}
337 };
338 #define NUM_DESC_LIST (sizeof(descriptor_list)/sizeof(struct descriptor_list_struct))
339
340
341 /**************************************************************************
342 *
343 * Variables - these are the only non-stack RAM usage
344 *
345 **************************************************************************/
346
347 // zero when we are not configured, non-zero when enumerated
348 static volatile uint8_t usb_configuration=0;
349
350
351 /**************************************************************************
352 *
353 * Public Functions - these are the API intended for the user
354 *
355 **************************************************************************/
356
357
358 // initialize USB
359 void usb_init(void)
360 {
361 HW_CONFIG();
362 USB_FREEZE(); // enable USB
363 PLL_CONFIG(); // config PLL
364 while (!(PLLCSR & (1<<PLOCK))) ; // wait for PLL lock
365 USB_CONFIG(); // start USB clock
366 UDCON = 0; // enable attach resistor
367 usb_configuration = 0;
368 UDIEN = (1<<EORSTE)|(1<<SOFE);
369 sei();
370 }
371
372 // return 0 if the USB is not configured, or the configuration
373 // number selected by the HOST
374 uint8_t usb_configured(void)
375 {
376 return usb_configuration;
377 }
378
379
380
381 /**************************************************************************
382 *
383 * Private Functions - not intended for general user consumption....
384 *
385 **************************************************************************/
386
387
388
389 // USB Device Interrupt - handle all device-level events
390 // the transmit buffer flushing is triggered by the start of frame
391 //
392 ISR(USB_GEN_vect)
393 {
394 uint8_t intbits, t, i;
395 static uint8_t div4=0;
396
397 intbits = UDINT;
398 UDINT = 0;
399 if (intbits & (1<<EORSTI)) {
400 UENUM = 0;
401 UECONX = 1;
402 UECFG0X = EP_TYPE_CONTROL;
403 UECFG1X = EP_SIZE(ENDPOINT0_SIZE) | EP_SINGLE_BUFFER;
404 UEIENX = (1<<RXSTPE);
405 usb_configuration = 0;
406 }
407 if ((intbits & (1<<SOFI)) && usb_configuration) {
408 t = debug_flush_timer;
409 if (t) {
410 debug_flush_timer = -- t;
411 if (!t) {
412 UENUM = DEBUG_TX_ENDPOINT;
413 while ((UEINTX & (1<<RWAL))) {
414 UEDATX = 0;
415 }
416 UEINTX = 0x3A;
417 }
418 }
419 if (keyboard_idle_config && (++div4 & 3) == 0) {
420 UENUM = KEYBOARD_ENDPOINT;
421 if (UEINTX & (1<<RWAL)) {
422 keyboard_idle_count++;
423 if (keyboard_idle_count == keyboard_idle_config) {
424 keyboard_idle_count = 0;
425 UEDATX = keyboard_modifier_keys;
426 UEDATX = 0;
427 for (i=0; i<6; i++) {
428 UEDATX = keyboard_keys[i];
429 }
430 UEINTX = 0x3A;
431 }
432 }
433 }
434 }
435 }
436
437
438
439 // Misc functions to wait for ready and send/receive packets
440 static inline void usb_wait_in_ready(void)
441 {
442 while (!(UEINTX & (1<<TXINI))) ;
443 }
444 static inline void usb_send_in(void)
445 {
446 UEINTX = ~(1<<TXINI);
447 }
448 static inline void usb_wait_receive_out(void)
449 {
450 while (!(UEINTX & (1<<RXOUTI))) ;
451 }
452 static inline void usb_ack_out(void)
453 {
454 UEINTX = ~(1<<RXOUTI);
455 }
456
457
458
459 // USB Endpoint Interrupt - endpoint 0 is handled here. The
460 // other endpoints are manipulated by the user-callable
461 // functions, and the start-of-frame interrupt.
462 //
463 ISR(USB_COM_vect)
464 {
465 uint8_t intbits;
466 const uint8_t *list;
467 const uint8_t *cfg;
468 uint8_t i, n, len, en;
469 uint8_t bmRequestType;
470 uint8_t bRequest;
471 uint16_t wValue;
472 uint16_t wIndex;
473 uint16_t wLength;
474 uint16_t desc_val;
475 const uint8_t *desc_addr;
476 uint8_t desc_length;
477
478 UENUM = 0;
479 intbits = UEINTX;
480 if (intbits & (1<<RXSTPI)) {
481 bmRequestType = UEDATX;
482 bRequest = UEDATX;
483 wValue = UEDATX;
484 wValue |= (UEDATX << 8);
485 wIndex = UEDATX;
486 wIndex |= (UEDATX << 8);
487 wLength = UEDATX;
488 wLength |= (UEDATX << 8);
489 UEINTX = ~((1<<RXSTPI) | (1<<RXOUTI) | (1<<TXINI));
490 if (bRequest == GET_DESCRIPTOR) {
491 list = (const uint8_t *)descriptor_list;
492 for (i=0; ; i++) {
493 if (i >= NUM_DESC_LIST) {
494 UECONX = (1<<STALLRQ)|(1<<EPEN); //stall
495 return;
496 }
497 desc_val = pgm_read_word(list);
498 if (desc_val != wValue) {
499 list += sizeof(struct descriptor_list_struct);
500 continue;
501 }
502 list += 2;
503 desc_val = pgm_read_word(list);
504 if (desc_val != wIndex) {
505 list += sizeof(struct descriptor_list_struct)-2;
506 continue;
507 }
508 list += 2;
509 desc_addr = (const uint8_t *)pgm_read_word(list);
510 list += 2;
511 desc_length = pgm_read_byte(list);
512 break;
513 }
514 len = (wLength < 256) ? wLength : 255;
515 if (len > desc_length) len = desc_length;
516 do {
517 // wait for host ready for IN packet
518 do {
519 i = UEINTX;
520 } while (!(i & ((1<<TXINI)|(1<<RXOUTI))));
521 if (i & (1<<RXOUTI)) return; // abort
522 // send IN packet
523 n = len < ENDPOINT0_SIZE ? len : ENDPOINT0_SIZE;
524 for (i = n; i; i--) {
525 UEDATX = pgm_read_byte(desc_addr++);
526 }
527 len -= n;
528 usb_send_in();
529 } while (len || n == ENDPOINT0_SIZE);
530 return;
531 }
532 if (bRequest == SET_ADDRESS) {
533 usb_send_in();
534 usb_wait_in_ready();
535 UDADDR = wValue | (1<<ADDEN);
536 return;
537 }
538 if (bRequest == SET_CONFIGURATION && bmRequestType == 0) {
539 usb_configuration = wValue;
540 usb_send_in();
541 cfg = endpoint_config_table;
542 for (i=1; i<=6; i++) {
543 UENUM = i;
544 en = pgm_read_byte(cfg++);
545 UECONX = en;
546 if (en) {
547 UECFG0X = pgm_read_byte(cfg++);
548 UECFG1X = pgm_read_byte(cfg++);
549 }
550 }
551 UERST = 0x7E;
552 UERST = 0;
553 return;
554 }
555 if (bRequest == GET_CONFIGURATION && bmRequestType == 0x80) {
556 usb_wait_in_ready();
557 UEDATX = usb_configuration;
558 usb_send_in();
559 return;
560 }
561
562 if (bRequest == GET_STATUS) {
563 usb_wait_in_ready();
564 i = 0;
565 #ifdef SUPPORT_ENDPOINT_HALT
566 if (bmRequestType == 0x82) {
567 UENUM = wIndex;
568 if (UECONX & (1<<STALLRQ)) i = 1;
569 UENUM = 0;
570 }
571 #endif
572 UEDATX = i;
573 UEDATX = 0;
574 usb_send_in();
575 return;
576 }
577 #ifdef SUPPORT_ENDPOINT_HALT
578 if ((bRequest == CLEAR_FEATURE || bRequest == SET_FEATURE)
579 && bmRequestType == 0x02 && wValue == 0) {
580 i = wIndex & 0x7F;
581 if (i >= 1 && i <= MAX_ENDPOINT) {
582 usb_send_in();
583 UENUM = i;
584 if (bRequest == SET_FEATURE) {
585 UECONX = (1<<STALLRQ)|(1<<EPEN);
586 } else {
587 UECONX = (1<<STALLRQC)|(1<<RSTDT)|(1<<EPEN);
588 UERST = (1 << i);
589 UERST = 0;
590 }
591 return;
592 }
593 }
594 #endif
595 if (wIndex == KEYBOARD_INTERFACE) {
596 if (bmRequestType == 0xA1) {
597 if (bRequest == HID_GET_REPORT) {
598 usb_wait_in_ready();
599 UEDATX = keyboard_modifier_keys;
600 UEDATX = 0;
601 for (i=0; i<6; i++) {
602 UEDATX = keyboard_keys[i];
603 }
604 usb_send_in();
605 return;
606 }
607 if (bRequest == HID_GET_IDLE) {
608 usb_wait_in_ready();
609 UEDATX = keyboard_idle_config;
610 usb_send_in();
611 return;
612 }
613 if (bRequest == HID_GET_PROTOCOL) {
614 usb_wait_in_ready();
615 UEDATX = keyboard_protocol;
616 usb_send_in();
617 return;
618 }
619 }
620 if (bmRequestType == 0x21) {
621 if (bRequest == HID_SET_REPORT) {
622 usb_wait_receive_out();
623 keyboard_leds = UEDATX;
624 usb_ack_out();
625 usb_send_in();
626 return;
627 }
628 if (bRequest == HID_SET_IDLE) {
629 keyboard_idle_config = (wValue >> 8);
630 keyboard_idle_count = 0;
631 //usb_wait_in_ready();
632 usb_send_in();
633 return;
634 }
635 if (bRequest == HID_SET_PROTOCOL) {
636 keyboard_protocol = wValue;
637 //usb_wait_in_ready();
638 usb_send_in();
639 return;
640 }
641 }
642 }
643 if (wIndex == MOUSE_INTERFACE) {
644 if (bmRequestType == 0xA1) {
645 if (bRequest == HID_GET_REPORT) {
646 usb_wait_in_ready();
647 UEDATX = mouse_buttons;
648 UEDATX = 0;
649 UEDATX = 0;
650 UEDATX = 0;
651 usb_send_in();
652 return;
653 }
654 if (bRequest == HID_GET_PROTOCOL) {
655 usb_wait_in_ready();
656 UEDATX = mouse_protocol;
657 usb_send_in();
658 return;
659 }
660 }
661 if (bmRequestType == 0x21) {
662 if (bRequest == HID_SET_PROTOCOL) {
663 mouse_protocol = wValue;
664 usb_send_in();
665 return;
666 }
667 }
668 }
669 if (wIndex == DEBUG_INTERFACE) {
670 if (bRequest == HID_GET_REPORT && bmRequestType == 0xA1) {
671 len = wLength;
672 do {
673 // wait for host ready for IN packet
674 do {
675 i = UEINTX;
676 } while (!(i & ((1<<TXINI)|(1<<RXOUTI))));
677 if (i & (1<<RXOUTI)) return; // abort
678 // send IN packet
679 n = len < ENDPOINT0_SIZE ? len : ENDPOINT0_SIZE;
680 for (i = n; i; i--) {
681 UEDATX = 0;
682 }
683 len -= n;
684 usb_send_in();
685 } while (len || n == ENDPOINT0_SIZE);
686 return;
687 }
688 }
689 }
690 UECONX = (1<<STALLRQ) | (1<<EPEN); // stall
691 }
692
693
custom keymap for my minivan; forked from http://github.com/evangs/tmk_keyboard
Imprint / Impressum