1 /* USB Keyboard and CDC Serial Device for Teensy USB Development Board
2 * Copyright (c) 2009 PJRC.COM, LLC
3 * Modifications by Jacob Alexander (2011-2014)
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:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
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
26 #include "usb_keyboard_serial.h"
30 // ----- Variables -----
32 // zero when we are not configured, non-zero when enumerated
33 static volatile uint8_t usb_configuration = 0;
35 // the time remaining before we transmit any partially full
36 // packet, or send a zero length packet.
37 static volatile uint8_t transmit_flush_timer = 0;
38 static uint8_t transmit_previous_timeout = 0;
40 // serial port settings (baud rate, control signals, etc) set
41 // by the PC. These are ignored, but kept in RAM.
42 static uint8_t cdc_line_coding[7] = {0x00, 0xE1, 0x00, 0x00, 0x00, 0x00, 0x08};
43 static uint8_t cdc_line_rtsdtr = 0;
47 // ----- USB Keyboard Functions -----
49 // Sends normal keyboard out to host
50 // NOTE: Make sure to match the descriptor
51 void usb_keyboard_toHost()
56 UEDATX = USBKeys_Modifiers;
61 // Normal Keys, only supports 6 in Boot mode
62 for ( i = 0; i < 6; i++)
64 UEDATX = USBKeys_Keys[i];
69 // send the contents of USBKeys_Keys and USBKeys_Modifiers
70 inline void usb_keyboard_send()
72 uint8_t intr_state, timeout;
75 timeout = UDFNUML + 50;
77 // Ready to transmit keypresses?
82 // has the USB gone offline? or exceeded timeout?
83 if ( !usb_configuration || UDFNUML == timeout )
85 erro_print("USB Offline? Timeout?");
89 // get ready to try checking again
93 // If not using Boot protocol, send NKRO
94 UENUM = USBKeys_Protocol ? KEYBOARD_NKRO_ENDPOINT : KEYBOARD_ENDPOINT;
95 } while ( !( UEINTX & (1 << RWAL) ) );
97 switch ( USBKeys_Protocol )
99 // Send boot keyboard interrupt packet(s)
101 usb_keyboard_toHost();
102 USBKeys_Changed = USBKeyChangeState_None;
105 // Send NKRO keyboard interrupts packet(s)
108 if ( USBKeys_Changed & USBKeyChangeState_Modifiers )
111 UEDATX = USBKeys_Modifiers;
112 UEINTX = 0; // Finished with ID
114 USBKeys_Changed &= ~USBKeyChangeState_Modifiers; // Mark sent
116 // Check main key section
117 if ( USBKeys_Changed & USBKeyChangeState_MainKeys )
121 // 4-49 (first 6 bytes)
122 for ( uint8_t byte = 0; byte < 6; byte++ )
123 UEDATX = USBKeys_Keys[ byte ];
125 UEINTX = 0; // Finished with ID
127 USBKeys_Changed &= ~USBKeyChangeState_MainKeys; // Mark sent
129 // Check secondary key section
130 if ( USBKeys_Changed & USBKeyChangeState_SecondaryKeys )
134 // 51-155 (Middle 14 bytes)
135 for ( uint8_t byte = 6; byte < 20; byte++ )
136 UEDATX = USBKeys_Keys[ byte ];
138 UEINTX = 0; // Finished with ID
140 USBKeys_Changed &= ~USBKeyChangeState_SecondaryKeys; // Mark sent
142 // Check tertiary key section
143 if ( USBKeys_Changed & USBKeyChangeState_TertiaryKeys )
147 // 157-164 (Next byte)
148 for ( uint8_t byte = 20; byte < 21; byte++ )
149 UEDATX = USBKeys_Keys[ byte ];
151 UEINTX = 0; // Finished with ID
153 USBKeys_Changed &= ~USBKeyChangeState_TertiaryKeys; // Mark sent
155 // Check quartiary key section
156 if ( USBKeys_Changed & USBKeyChangeState_TertiaryKeys )
160 // 176-221 (last 6 bytes)
161 for ( uint8_t byte = 21; byte < 27; byte++ )
162 UEDATX = USBKeys_Keys[ byte ];
164 UEINTX = 0; // Finished with ID
166 USBKeys_Changed &= ~USBKeyChangeState_QuartiaryKeys; // Mark sent
168 // Check system control keys
169 if ( USBKeys_Changed & USBKeyChangeState_System )
172 UEDATX = USBKeys_SysCtrl;
173 UEINTX = 0; // Finished with ID
175 USBKeys_Changed &= ~USBKeyChangeState_System; // Mark sent
177 // Check consumer control keys
178 if ( USBKeys_Changed & USBKeyChangeState_Consumer )
181 UEDATX = (uint8_t)(USBKeys_ConsCtrl & 0x00FF);
182 UEDATX = (uint8_t)(USBKeys_ConsCtrl >> 8);
183 UEINTX = 0; // Finished with ID
185 USBKeys_Changed &= ~USBKeyChangeState_Consumer; // Mark sent
191 USBKeys_Idle_Count = 0;
197 // ----- USB Virtual Serial Port (CDC) Functions -----
199 // get the next character, or -1 if nothing received
200 int16_t usb_serial_getchar()
202 uint8_t c, intr_state;
204 // interrupts are disabled so these functions can be
205 // used from the main program or interrupt context,
206 // even both in the same program!
209 if (!usb_configuration) {
213 UENUM = CDC_RX_ENDPOINT;
216 if (!(c & (1<<RWAL))) {
218 if (c & (1<<RXOUTI)) {
225 // take one byte out of the buffer
227 // if buffer completely used, release it
228 if (!(UEINTX & (1<<RWAL))) UEINTX = 0x6B;
233 // number of bytes available in the receive buffer
234 uint8_t usb_serial_available()
236 uint8_t n=0, i, intr_state;
240 if (usb_configuration) {
241 UENUM = CDC_RX_ENDPOINT;
245 if (i & (1<<RXOUTI) && !(i & (1<<RWAL))) UEINTX = 0x6B;
252 // discard any buffered input
253 void usb_serial_flush_input()
257 if (usb_configuration) {
260 UENUM = CDC_RX_ENDPOINT;
261 while ((UEINTX & (1<<RWAL))) {
268 // transmit a character. 0 returned on success, -1 on error
269 int8_t usb_serial_putchar( uint8_t c )
271 uint8_t timeout, intr_state;
273 // if we're not online (enumerated and configured), error
274 if (!usb_configuration) return -1;
275 // interrupts are disabled so these functions can be
276 // used from the main program or interrupt context,
277 // even both in the same program!
280 UENUM = CDC_TX_ENDPOINT;
281 // if we gave up due to timeout before, don't wait again
282 if (transmit_previous_timeout) {
283 if (!(UEINTX & (1<<RWAL))) {
287 transmit_previous_timeout = 0;
289 // wait for the FIFO to be ready to accept data
290 timeout = UDFNUML + TRANSMIT_TIMEOUT;
292 // are we ready to transmit?
293 if (UEINTX & (1<<RWAL)) break;
295 // have we waited too long? This happens if the user
296 // is not running an application that is listening
297 if (UDFNUML == timeout) {
298 transmit_previous_timeout = 1;
301 // has the USB gone offline?
302 if (!usb_configuration) return -1;
303 // get ready to try checking again
306 UENUM = CDC_TX_ENDPOINT;
308 // actually write the byte into the FIFO
310 // if this completed a packet, transmit it now!
311 if (!(UEINTX & (1<<RWAL))) UEINTX = 0x3A;
312 transmit_flush_timer = TRANSMIT_FLUSH_TIMEOUT;
318 // transmit a character, but do not wait if the buffer is full,
319 // 0 returned on success, -1 on buffer full or error
320 int8_t usb_serial_putchar_nowait( uint8_t c )
324 if (!usb_configuration) return -1;
327 UENUM = CDC_TX_ENDPOINT;
328 if (!(UEINTX & (1<<RWAL))) {
333 // actually write the byte into the FIFO
335 // if this completed a packet, transmit it now!
336 if (!(UEINTX & (1<<RWAL))) UEINTX = 0x3A;
337 transmit_flush_timer = TRANSMIT_FLUSH_TIMEOUT;
342 // transmit a buffer.
343 // 0 returned on success, -1 on error
344 // This function is optimized for speed! Each call takes approx 6.1 us overhead
345 // plus 0.25 us per byte. 12 Mbit/sec USB has 8.67 us per-packet overhead and
346 // takes 0.67 us per byte. If called with 64 byte packet-size blocks, this function
347 // can transmit at full USB speed using 43% CPU time. The maximum theoretical speed
348 // is 19 packets per USB frame, or 1216 kbytes/sec. However, bulk endpoints have the
349 // lowest priority, so any other USB devices will likely reduce the speed. Speed
350 // can also be limited by how quickly the PC-based software reads data, as the host
351 // controller in the PC will not allocate bandwitdh without a pending read request.
352 // (thanks to Victor Suarez for testing and feedback and initial code)
354 int8_t usb_serial_write( const char *buffer, uint16_t size )
356 uint8_t timeout, intr_state, write_size;
358 // if we're not online (enumerated and configured), error
359 if (!usb_configuration) return -1;
360 // interrupts are disabled so these functions can be
361 // used from the main program or interrupt context,
362 // even both in the same program!
365 UENUM = CDC_TX_ENDPOINT;
366 // if we gave up due to timeout before, don't wait again
368 if (transmit_previous_timeout) {
369 if (!(UEINTX & (1<<RWAL))) {
373 transmit_previous_timeout = 0;
376 // each iteration of this loop transmits a packet
378 // wait for the FIFO to be ready to accept data
379 timeout = UDFNUML + TRANSMIT_TIMEOUT;
381 // are we ready to transmit?
382 if (UEINTX & (1<<RWAL)) break;
384 // have we waited too long? This happens if the user
385 // is not running an application that is listening
386 if (UDFNUML == timeout) {
387 transmit_previous_timeout = 1;
390 // has the USB gone offline?
391 if (!usb_configuration) return -4;
392 // get ready to try checking again
395 UENUM = CDC_TX_ENDPOINT;
398 // compute how many bytes will fit into the next packet
399 write_size = CDC_TX_SIZE - UEBCLX;
400 if (write_size > size) write_size = size;
404 switch (write_size) {
405 #if (CDC_TX_SIZE == 64)
406 case 64: UEDATX = *buffer++;
407 case 63: UEDATX = *buffer++;
408 case 62: UEDATX = *buffer++;
409 case 61: UEDATX = *buffer++;
410 case 60: UEDATX = *buffer++;
411 case 59: UEDATX = *buffer++;
412 case 58: UEDATX = *buffer++;
413 case 57: UEDATX = *buffer++;
414 case 56: UEDATX = *buffer++;
415 case 55: UEDATX = *buffer++;
416 case 54: UEDATX = *buffer++;
417 case 53: UEDATX = *buffer++;
418 case 52: UEDATX = *buffer++;
419 case 51: UEDATX = *buffer++;
420 case 50: UEDATX = *buffer++;
421 case 49: UEDATX = *buffer++;
422 case 48: UEDATX = *buffer++;
423 case 47: UEDATX = *buffer++;
424 case 46: UEDATX = *buffer++;
425 case 45: UEDATX = *buffer++;
426 case 44: UEDATX = *buffer++;
427 case 43: UEDATX = *buffer++;
428 case 42: UEDATX = *buffer++;
429 case 41: UEDATX = *buffer++;
430 case 40: UEDATX = *buffer++;
431 case 39: UEDATX = *buffer++;
432 case 38: UEDATX = *buffer++;
433 case 37: UEDATX = *buffer++;
434 case 36: UEDATX = *buffer++;
435 case 35: UEDATX = *buffer++;
436 case 34: UEDATX = *buffer++;
437 case 33: UEDATX = *buffer++;
439 #if (CDC_TX_SIZE >= 32)
440 case 32: UEDATX = *buffer++;
441 case 31: UEDATX = *buffer++;
442 case 30: UEDATX = *buffer++;
443 case 29: UEDATX = *buffer++;
444 case 28: UEDATX = *buffer++;
445 case 27: UEDATX = *buffer++;
446 case 26: UEDATX = *buffer++;
447 case 25: UEDATX = *buffer++;
448 case 24: UEDATX = *buffer++;
449 case 23: UEDATX = *buffer++;
450 case 22: UEDATX = *buffer++;
451 case 21: UEDATX = *buffer++;
452 case 20: UEDATX = *buffer++;
453 case 19: UEDATX = *buffer++;
454 case 18: UEDATX = *buffer++;
455 case 17: UEDATX = *buffer++;
457 #if (CDC_TX_SIZE >= 16)
458 case 16: UEDATX = *buffer++;
459 case 15: UEDATX = *buffer++;
460 case 14: UEDATX = *buffer++;
461 case 13: UEDATX = *buffer++;
462 case 12: UEDATX = *buffer++;
463 case 11: UEDATX = *buffer++;
464 case 10: UEDATX = *buffer++;
465 case 9: UEDATX = *buffer++;
467 case 8: UEDATX = *buffer++;
468 case 7: UEDATX = *buffer++;
469 case 6: UEDATX = *buffer++;
470 case 5: UEDATX = *buffer++;
471 case 4: UEDATX = *buffer++;
472 case 3: UEDATX = *buffer++;
473 case 2: UEDATX = *buffer++;
475 case 1: UEDATX = *buffer++;
478 // if this completed a packet, transmit it now!
479 if (!(UEINTX & (1<<RWAL))) UEINTX = 0x3A;
480 transmit_flush_timer = TRANSMIT_FLUSH_TIMEOUT;
486 // immediately transmit any buffered output.
487 // This doesn't actually transmit the data - that is impossible!
488 // USB devices only transmit when the host allows, so the best
489 // we can do is release the FIFO buffer for when the host wants it
490 void usb_serial_flush_output()
496 if (transmit_flush_timer) {
497 UENUM = CDC_TX_ENDPOINT;
499 transmit_flush_timer = 0;
504 // functions to read the various async serial settings. These
505 // aren't actually used by USB at all (communication is always
506 // at full USB speed), but they are set by the host so we can
507 // set them properly if we're converting the USB to a real serial
509 uint32_t usb_serial_get_baud()
511 uint32_t *baud = (uint32_t*)cdc_line_coding;
514 uint8_t usb_serial_get_stopbits()
516 return cdc_line_coding[4];
518 uint8_t usb_serial_get_paritytype()
520 return cdc_line_coding[5];
522 uint8_t usb_serial_get_numbits()
524 return cdc_line_coding[6];
526 uint8_t usb_serial_get_control()
528 return cdc_line_rtsdtr;
531 // write the control signals, DCD, DSR, RI, etc
532 // There is no CTS signal. If software on the host has transmitted
533 // data to you but you haven't been calling the getchar function,
534 // it remains buffered (either here or on the host) and can not be
535 // lost because you weren't listening at the right time, like it
536 // would in real serial communication.
537 int8_t usb_serial_set_control( uint8_t signals )
543 if (!usb_configuration) {
544 // we're not enumerated/configured
549 UENUM = CDC_ACM_ENDPOINT;
550 if (!(UEINTX & (1<<RWAL))) {
552 // TODO; should this try to abort the previously
553 // buffered message??
561 UEDATX = 0; // 0 seems to work nicely. what if this is 1??
573 // ----- General USB Functions -----
575 // Set the avr into firmware reload mode
576 void usb_device_reload()
579 // Disable watchdog, if enabled
580 // Disable all peripherals
583 USBCON = (1 << FRZCLK); // Disable USB
587 #if defined(__AVR_AT90USB162__) // Teensy 1.0
588 EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0;
589 TIMSK0 = 0; TIMSK1 = 0; UCSR1B = 0;
590 DDRB = 0; DDRC = 0; DDRD = 0;
591 PORTB = 0; PORTC = 0; PORTD = 0;
592 asm volatile("jmp 0x3E00");
593 #elif defined(__AVR_ATmega32U4__) // Teensy 2.0
594 EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; ADCSRA = 0;
595 TIMSK0 = 0; TIMSK1 = 0; TIMSK3 = 0; TIMSK4 = 0; UCSR1B = 0; TWCR = 0;
596 DDRB = 0; DDRC = 0; DDRD = 0; DDRE = 0; DDRF = 0; TWCR = 0;
597 PORTB = 0; PORTC = 0; PORTD = 0; PORTE = 0; PORTF = 0;
598 asm volatile("jmp 0x7E00");
599 #elif defined(__AVR_AT90USB646__) // Teensy++ 1.0
600 EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; ADCSRA = 0;
601 TIMSK0 = 0; TIMSK1 = 0; TIMSK2 = 0; TIMSK3 = 0; UCSR1B = 0; TWCR = 0;
602 DDRA = 0; DDRB = 0; DDRC = 0; DDRD = 0; DDRE = 0; DDRF = 0;
603 PORTA = 0; PORTB = 0; PORTC = 0; PORTD = 0; PORTE = 0; PORTF = 0;
604 asm volatile("jmp 0xFC00");
605 #elif defined(__AVR_AT90USB1286__) // Teensy++ 2.0
606 EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; ADCSRA = 0;
607 TIMSK0 = 0; TIMSK1 = 0; TIMSK2 = 0; TIMSK3 = 0; UCSR1B = 0; TWCR = 0;
608 DDRA = 0; DDRB = 0; DDRC = 0; DDRD = 0; DDRE = 0; DDRF = 0;
609 PORTA = 0; PORTB = 0; PORTC = 0; PORTD = 0; PORTE = 0; PORTF = 0;
610 asm volatile("jmp 0x1FC00");
615 // WDT Setup for software reset the chip
627 USB_FREEZE(); // enable USB
628 PLL_CONFIG(); // config PLL
629 while (!(PLLCSR & (1<<PLOCK))) ; // wait for PLL lock
630 USB_CONFIG(); // start USB clock
631 UDCON = 0; // enable attach resistor
632 usb_configuration = 0;
633 UDIEN = (1<<EORSTE) | (1<<SOFE);
636 // Disable watchdog timer after possible software reset
637 //wdt_init(); // XXX Not working...seems to be ok without this, not sure though
640 // return 0 if the USB is not configured, or the configuration
641 // number selected by the HOST
642 uint8_t usb_configured()
644 return usb_configuration;
647 // USB Device Interrupt - handle all device-level events
648 // the transmit buffer flushing is triggered by the start of frame
652 uint8_t intbits, t_cdc;
656 if ( intbits & (1 << EORSTI) )
660 UECFG0X = EP_TYPE_CONTROL;
661 UECFG1X = EP_SIZE(ENDPOINT0_SIZE) | EP_SINGLE_BUFFER;
662 UEIENX = (1 << RXSTPE);
663 usb_configuration = 0;
666 if ( (intbits & (1 << SOFI)) && usb_configuration )
668 t_cdc = transmit_flush_timer;
671 transmit_flush_timer = --t_cdc;
674 UENUM = CDC_TX_ENDPOINT;
678 static uint8_t div4 = 0;
679 if ( USBKeys_Idle_Config && (++div4 & 3) == 0 )
681 USBKeys_Idle_Count++;
682 if ( USBKeys_Idle_Count == USBKeys_Idle_Config )
684 // XXX TODO Is this even used? If so, when? -Jacob
685 // From hasu's code, this section looks like it could fix the Mac SET_IDLE problem
686 // Send normal keyboard interrupt packet(s)
687 switch ( USBKeys_Protocol )
689 // Send boot keyboard interrupt packet(s)
690 case 0: usb_keyboard_toHost(); break;
691 // Send NKRO keyboard interrupts packet(s)
692 //case 1: usb_nkrokeyboard_toHost(); break; // XXX Not valid anymore
702 // Misc functions to wait for ready and send/receive packets
703 static inline void usb_wait_in_ready()
705 while (!(UEINTX & (1<<TXINI))) ;
707 static inline void usb_send_in()
709 UEINTX = ~(1<<TXINI);
711 static inline void usb_wait_receive_out()
713 while (!(UEINTX & (1<<RXOUTI))) ;
715 static inline void usb_ack_out()
717 UEINTX = ~(1<<RXOUTI);
722 // USB Endpoint Interrupt - endpoint 0 is handled here. The
723 // other endpoints are manipulated by the user-callable
724 // functions, and the start-of-frame interrupt.
731 uint8_t i, n, len, en;
733 uint8_t bmRequestType;
739 const uint8_t *desc_addr;
744 if (intbits & (1<<RXSTPI))
746 bmRequestType = UEDATX;
749 wValue |= (UEDATX << 8);
751 wIndex |= (UEDATX << 8);
753 wLength |= (UEDATX << 8);
754 UEINTX = ~((1<<RXSTPI) | (1<<RXOUTI) | (1<<TXINI));
756 if ( bRequest == GET_DESCRIPTOR )
758 list = (const uint8_t *)descriptor_list;
761 if ( i >= NUM_DESC_LIST )
763 UECONX = (1 << STALLRQ) | (1 << EPEN); //stall
766 desc_val = pgm_read_word(list);
767 if ( desc_val != wValue )
769 list += sizeof( struct descriptor_list_struct );
773 desc_val = pgm_read_word(list);
774 if ( desc_val != wIndex )
776 list += sizeof(struct descriptor_list_struct) - 2;
780 desc_addr = (const uint8_t *)pgm_read_word(list);
782 desc_length = pgm_read_byte(list);
785 len = (wLength < 256) ? wLength : 255;
786 if (len > desc_length) len = desc_length;
788 // wait for host ready for IN packet
791 } while (!(i & ((1<<TXINI)|(1<<RXOUTI))));
792 if (i & (1<<RXOUTI)) return; // abort
794 n = len < ENDPOINT0_SIZE ? len : ENDPOINT0_SIZE;
795 for (i = n; i; i--) {
796 UEDATX = pgm_read_byte(desc_addr++);
800 } while (len || n == ENDPOINT0_SIZE);
804 if (bRequest == SET_ADDRESS) {
807 UDADDR = wValue | (1<<ADDEN);
811 if ( bRequest == SET_CONFIGURATION && bmRequestType == 0 )
813 usb_configuration = wValue;
815 transmit_flush_timer = 0;
817 cfg = endpoint_config_table;
818 // Setup each of the 6 additional endpoints (0th already configured)
819 for ( i = 1; i < 6; i++ )
822 en = pgm_read_byte(cfg++);
826 UECFG0X = pgm_read_byte(cfg++);
827 UECFG1X = pgm_read_byte(cfg++);
835 if (bRequest == GET_CONFIGURATION && bmRequestType == 0x80) {
837 UEDATX = usb_configuration;
842 if ( ( wIndex == KEYBOARD_INTERFACE && USBKeys_Protocol == 0 )
843 || ( wIndex == KEYBOARD_NKRO_INTERFACE && USBKeys_Protocol == 1 ) )
845 if ( bmRequestType == 0xA1)
847 if ( bRequest == HID_GET_REPORT )
851 // Send normal keyboard interrupt packet(s)
852 switch ( USBKeys_Protocol )
854 // Send boot keyboard interrupt packet(s)
855 case 0: usb_keyboard_toHost(); break;
856 // Send NKRO keyboard interrupts packet(s)
857 //case 1: usb_nkrokeyboard_toHost(); break; // XXX Not valid anymore
863 if ( bRequest == HID_GET_IDLE )
866 UEDATX = USBKeys_Idle_Config;
870 if ( bRequest == HID_GET_PROTOCOL )
873 UEDATX = USBKeys_Protocol;
878 if ( bmRequestType == 0x21 )
880 if ( bRequest == HID_SET_REPORT )
882 usb_wait_receive_out();
883 USBKeys_LEDs = UEDATX;
888 if ( bRequest == HID_SET_IDLE )
891 USBKeys_Idle_Config = (wValue >> 8);
892 USBKeys_Idle_Count = 0;
897 if ( bRequest == HID_SET_PROTOCOL )
900 USBKeys_Protocol = wValue; // 0 - Boot Mode, 1 - NKRO Mode
908 if (bRequest == CDC_GET_LINE_CODING && bmRequestType == 0xA1) {
911 for (i=0; i<7; i++) {
918 if (bRequest == CDC_SET_LINE_CODING && bmRequestType == 0x21) {
919 usb_wait_receive_out();
921 for (i=0; i<7; i++) {
929 if (bRequest == CDC_SET_CONTROL_LINE_STATE && bmRequestType == 0x21) {
930 cdc_line_rtsdtr = wValue;
936 if (bRequest == GET_STATUS) {
939 if (bmRequestType == 0x82) {
941 if (UECONX & (1<<STALLRQ)) i = 1;
950 if ((bRequest == CLEAR_FEATURE || bRequest == SET_FEATURE)
951 && bmRequestType == 0x02 && wValue == 0) {
953 if (i >= 1 && i <= MAX_ENDPOINT) {
956 if (bRequest == SET_FEATURE) {
957 UECONX = (1<<STALLRQ)|(1<<EPEN);
959 UECONX = (1<<STALLRQC)|(1<<RSTDT)|(1<<EPEN);
967 UECONX = (1 << STALLRQ) | (1 << EPEN); // stall