controller/Output/pjrcUSB/avr/usb_keyboard_serial.c

/* USB Keyboard and CDC Serial Device for Teensy USB Development Board
 * Copyright (c) 2009 PJRC.COM, LLC
 * Modifications by Jacob Alexander (2011-2014)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */


// Local Includes
#include "usb_keyboard_serial.h"
#include <print.h>


// ----- Variables -----

// zero when we are not configured, non-zero when enumerated
static volatile uint8_t usb_configuration = 0;

// the time remaining before we transmit any partially full
// packet, or send a zero length packet.
static volatile uint8_t transmit_flush_timer = 0;
static uint8_t transmit_previous_timeout = 0;

// serial port settings (baud rate, control signals, etc) set
// by the PC.  These are ignored, but kept in RAM.
static uint8_t cdc_line_coding[7] = {0x00, 0xE1, 0x00, 0x00, 0x00, 0x00, 0x08};
static uint8_t cdc_line_rtsdtr = 0;



// ----- USB Keyboard Functions -----

// Sends normal keyboard out to host
// NOTE: Make sure to match the descriptor
void usb_keyboard_toHost()
{
	uint8_t i;

	// Modifiers
	UEDATX = USBKeys_Modifiers;

	// Reserved Byte
	UEDATX = 0x00;

	// Normal Keys, only supports 6 in Boot mode
	for ( i = 0; i < 6; i++)
	{
		UEDATX = USBKeys_Keys[i];
	}
	UEINTX = 0x00;
}

// send the contents of USBKeys_Keys and USBKeys_Modifiers
inline void usb_keyboard_send()
{
	uint8_t intr_state, timeout;

	intr_state = SREG;
	timeout = UDFNUML + 50;

	// Ready to transmit keypresses?
	do
	{
		SREG = intr_state;

		// has the USB gone offline? or exceeded timeout?
		if ( !usb_configuration || UDFNUML == timeout )
		{
			erro_print("USB Offline? Timeout?");
			return;
		}

		// get ready to try checking again
		intr_state = SREG;
		cli();

		// If not using Boot protocol, send NKRO
		UENUM = USBKeys_Protocol ? KEYBOARD_NKRO_ENDPOINT : KEYBOARD_ENDPOINT;
	} while ( !( UEINTX & (1 << RWAL) ) );

	switch ( USBKeys_Protocol )
	{
	// Send boot keyboard interrupt packet(s)
	case 0:
		usb_keyboard_toHost();
		USBKeys_Changed = USBKeyChangeState_None;
		break;

	// Send NKRO keyboard interrupts packet(s)
	case 1:
		// Check system control keys
		if ( USBKeys_Changed & USBKeyChangeState_System )
		{
			UEDATX = 0x02; // ID
			UEDATX = USBKeys_SysCtrl;
			UEINTX = 0; // Finished with ID

			USBKeys_Changed &= ~USBKeyChangeState_System; // Mark sent
		}

		// Check consumer control keys
		if ( USBKeys_Changed & USBKeyChangeState_Consumer )
		{
			UEDATX = 0x03; // ID
			UEDATX = (uint8_t)(USBKeys_ConsCtrl & 0x00FF);
			UEDATX = (uint8_t)(USBKeys_ConsCtrl >> 8);
			UEINTX = 0; // Finished with ID

			USBKeys_Changed &= ~USBKeyChangeState_Consumer; // Mark sent
		}

		// Standard HID Keyboard
		if ( USBKeys_Changed )
		{
			UEDATX = 0x01; // ID

			// Modifiers
			UEDATX = USBKeys_Modifiers;

			// 4-49 (first 6 bytes)
			for ( uint8_t byte = 0; byte < 6; byte++ )
				UEDATX = USBKeys_Keys[ byte ];

			// 51-155 (Middle 14 bytes)
			for ( uint8_t byte = 6; byte < 20; byte++ )
				UEDATX = USBKeys_Keys[ byte ];

			// 157-164 (Next byte)
			for ( uint8_t byte = 20; byte < 21; byte++ )
				UEDATX = USBKeys_Keys[ byte ];

			// 176-221 (last 6 bytes)
			for ( uint8_t byte = 21; byte < 27; byte++ )
				UEDATX = USBKeys_Keys[ byte ];

			UEINTX = 0; // Finished with ID

			USBKeys_Changed = USBKeyChangeState_None; // Mark sent
		}

		break;
	}

	USBKeys_Idle_Count = 0;
	SREG = intr_state;
}



// ----- USB Virtual Serial Port (CDC) Functions -----

// get the next character, or -1 if nothing received
int16_t usb_serial_getchar()
{
	uint8_t c, intr_state;

	// interrupts are disabled so these functions can be
	// used from the main program or interrupt context,
	// even both in the same program!
	intr_state = SREG;
	cli();
	if (!usb_configuration) {
		SREG = intr_state;
		return -1;
	}
	UENUM = CDC_RX_ENDPOINT;
	retry:
	c = UEINTX;
	if (!(c & (1<<RWAL))) {
		// no data in buffer
		if (c & (1<<RXOUTI)) {
			UEINTX = 0x6B;
			goto retry;
		}
		SREG = intr_state;
		return -2;
	}
	// take one byte out of the buffer
	c = UEDATX;
	// if buffer completely used, release it
	if (!(UEINTX & (1<<RWAL))) UEINTX = 0x6B;
	SREG = intr_state;
	return c;
}

// number of bytes available in the receive buffer
uint8_t usb_serial_available()
{
	uint8_t n=0, i, intr_state;

	intr_state = SREG;
	cli();
	if (usb_configuration) {
		UENUM = CDC_RX_ENDPOINT;
		n = UEBCLX;
		if (!n) {
			i = UEINTX;
			if (i & (1<<RXOUTI) && !(i & (1<<RWAL))) UEINTX = 0x6B;
		}
	}
	SREG = intr_state;
	return n;
}

// discard any buffered input
void usb_serial_flush_input()
{
	uint8_t intr_state;

	if (usb_configuration) {
		intr_state = SREG;
		cli();
		UENUM = CDC_RX_ENDPOINT;
		while ((UEINTX & (1<<RWAL))) {
			UEINTX = 0x6B;
		}
		SREG = intr_state;
	}
}

// transmit a character.  0 returned on success, -1 on error
int8_t usb_serial_putchar( uint8_t c )
{
	uint8_t timeout, intr_state;

	// if we're not online (enumerated and configured), error
	if (!usb_configuration) return -1;
	// interrupts are disabled so these functions can be
	// used from the main program or interrupt context,
	// even both in the same program!
	intr_state = SREG;
	cli();
	UENUM = CDC_TX_ENDPOINT;
	// if we gave up due to timeout before, don't wait again
	if (transmit_previous_timeout) {
		if (!(UEINTX & (1<<RWAL))) {
			SREG = intr_state;
			return -1;
		}
		transmit_previous_timeout = 0;
	}
	// wait for the FIFO to be ready to accept data
	timeout = UDFNUML + TRANSMIT_TIMEOUT;
	while (1) {
		// are we ready to transmit?
		if (UEINTX & (1<<RWAL)) break;
		SREG = intr_state;
		// have we waited too long?  This happens if the user
		// is not running an application that is listening
		if (UDFNUML == timeout) {
			transmit_previous_timeout = 1;
			return -1;
		}
		// has the USB gone offline?
		if (!usb_configuration) return -1;
		// get ready to try checking again
		intr_state = SREG;
		cli();
		UENUM = CDC_TX_ENDPOINT;
	}
	// actually write the byte into the FIFO
	UEDATX = c;
	// if this completed a packet, transmit it now!
	if (!(UEINTX & (1<<RWAL))) UEINTX = 0x3A;
	transmit_flush_timer = TRANSMIT_FLUSH_TIMEOUT;
	SREG = intr_state;
	return 0;
}


// transmit a character, but do not wait if the buffer is full,
//   0 returned on success, -1 on buffer full or error
int8_t usb_serial_putchar_nowait( uint8_t c )
{
	uint8_t intr_state;

	if (!usb_configuration) return -1;
	intr_state = SREG;
	cli();
	UENUM = CDC_TX_ENDPOINT;
	if (!(UEINTX & (1<<RWAL))) {
		// buffer is full
		SREG = intr_state;
		return -2;
	}
	// actually write the byte into the FIFO
	UEDATX = c;
		// if this completed a packet, transmit it now!
	if (!(UEINTX & (1<<RWAL))) UEINTX = 0x3A;
	transmit_flush_timer = TRANSMIT_FLUSH_TIMEOUT;
	SREG = intr_state;
	return 0;
}

// transmit a buffer.
//  0 returned on success, -1 on error
// This function is optimized for speed!  Each call takes approx 6.1 us overhead
// plus 0.25 us per byte.  12 Mbit/sec USB has 8.67 us per-packet overhead and
// takes 0.67 us per byte.  If called with 64 byte packet-size blocks, this function
// can transmit at full USB speed using 43% CPU time.  The maximum theoretical speed
// is 19 packets per USB frame, or 1216 kbytes/sec.  However, bulk endpoints have the
// lowest priority, so any other USB devices will likely reduce the speed.  Speed
// can also be limited by how quickly the PC-based software reads data, as the host
// controller in the PC will not allocate bandwitdh without a pending read request.
// (thanks to Victor Suarez for testing and feedback and initial code)

int8_t usb_serial_write( const char *buffer, uint16_t size )
{
	uint8_t timeout, intr_state, write_size;

	// if we're not online (enumerated and configured), error
	if (!usb_configuration) return -1;
	// interrupts are disabled so these functions can be
	// used from the main program or interrupt context,
	// even both in the same program!
	intr_state = SREG;
	cli();
	UENUM = CDC_TX_ENDPOINT;
	// if we gave up due to timeout before, don't wait again

	if (transmit_previous_timeout) {
		if (!(UEINTX & (1<<RWAL))) {
			SREG = intr_state;
			return -2;
		}
		transmit_previous_timeout = 0;
	}

	// each iteration of this loop transmits a packet
	while (size) {
		// wait for the FIFO to be ready to accept data
		timeout = UDFNUML + TRANSMIT_TIMEOUT;
		while (1) {
			// are we ready to transmit?
			if (UEINTX & (1<<RWAL)) break;
			SREG = intr_state;
			// have we waited too long?  This happens if the user
			// is not running an application that is listening
			if (UDFNUML == timeout) {
				transmit_previous_timeout = 1;
				return -3;
			}
			// has the USB gone offline?
			if (!usb_configuration) return -4;
			// get ready to try checking again
			intr_state = SREG;
			cli();
			UENUM = CDC_TX_ENDPOINT;
		}

		// compute how many bytes will fit into the next packet
		write_size = CDC_TX_SIZE - UEBCLX;
		if (write_size > size) write_size = size;
		size -= write_size;

		// write the packet
		switch (write_size) {
			#if (CDC_TX_SIZE == 64)
			case 64: UEDATX = *buffer++;
			case 63: UEDATX = *buffer++;
			case 62: UEDATX = *buffer++;
			case 61: UEDATX = *buffer++;
			case 60: UEDATX = *buffer++;
			case 59: UEDATX = *buffer++;
			case 58: UEDATX = *buffer++;
			case 57: UEDATX = *buffer++;
			case 56: UEDATX = *buffer++;
			case 55: UEDATX = *buffer++;
			case 54: UEDATX = *buffer++;
			case 53: UEDATX = *buffer++;
			case 52: UEDATX = *buffer++;
			case 51: UEDATX = *buffer++;
			case 50: UEDATX = *buffer++;
			case 49: UEDATX = *buffer++;
			case 48: UEDATX = *buffer++;
			case 47: UEDATX = *buffer++;
			case 46: UEDATX = *buffer++;
			case 45: UEDATX = *buffer++;
			case 44: UEDATX = *buffer++;
			case 43: UEDATX = *buffer++;
			case 42: UEDATX = *buffer++;
			case 41: UEDATX = *buffer++;
			case 40: UEDATX = *buffer++;
			case 39: UEDATX = *buffer++;
			case 38: UEDATX = *buffer++;
			case 37: UEDATX = *buffer++;
			case 36: UEDATX = *buffer++;
			case 35: UEDATX = *buffer++;
			case 34: UEDATX = *buffer++;
			case 33: UEDATX = *buffer++;
			#endif
			#if (CDC_TX_SIZE >= 32)
			case 32: UEDATX = *buffer++;
			case 31: UEDATX = *buffer++;
			case 30: UEDATX = *buffer++;
			case 29: UEDATX = *buffer++;
			case 28: UEDATX = *buffer++;
			case 27: UEDATX = *buffer++;
			case 26: UEDATX = *buffer++;
			case 25: UEDATX = *buffer++;
			case 24: UEDATX = *buffer++;
			case 23: UEDATX = *buffer++;
			case 22: UEDATX = *buffer++;
			case 21: UEDATX = *buffer++;
			case 20: UEDATX = *buffer++;
			case 19: UEDATX = *buffer++;
			case 18: UEDATX = *buffer++;
			case 17: UEDATX = *buffer++;
			#endif
			#if (CDC_TX_SIZE >= 16)
			case 16: UEDATX = *buffer++;
			case 15: UEDATX = *buffer++;
			case 14: UEDATX = *buffer++;
			case 13: UEDATX = *buffer++;
			case 12: UEDATX = *buffer++;
			case 11: UEDATX = *buffer++;
			case 10: UEDATX = *buffer++;
			case  9: UEDATX = *buffer++;
			#endif
			case  8: UEDATX = *buffer++;
			case  7: UEDATX = *buffer++;
			case  6: UEDATX = *buffer++;
			case  5: UEDATX = *buffer++;
			case  4: UEDATX = *buffer++;
			case  3: UEDATX = *buffer++;
			case  2: UEDATX = *buffer++;
			default:
			case  1: UEDATX = *buffer++;
			case  0: break;
		}
		// if this completed a packet, transmit it now!
		if (!(UEINTX & (1<<RWAL))) UEINTX = 0x3A;
		transmit_flush_timer = TRANSMIT_FLUSH_TIMEOUT;
		SREG = intr_state;
	}
	return 0;
}

// immediately transmit any buffered output.
// This doesn't actually transmit the data - that is impossible!
// USB devices only transmit when the host allows, so the best
// we can do is release the FIFO buffer for when the host wants it
void usb_serial_flush_output()
{
	uint8_t intr_state;

	intr_state = SREG;
	cli();
	if (transmit_flush_timer) {
		UENUM = CDC_TX_ENDPOINT;
		UEINTX = 0x3A;
		transmit_flush_timer = 0;
	}
	SREG = intr_state;
}

// functions to read the various async serial settings.  These
// aren't actually used by USB at all (communication is always
// at full USB speed), but they are set by the host so we can
// set them properly if we're converting the USB to a real serial
// communication
uint32_t usb_serial_get_baud()
{
	uint32_t *baud = (uint32_t*)cdc_line_coding;
	return *baud;
}
uint8_t usb_serial_get_stopbits()
{
	return cdc_line_coding[4];
}
uint8_t usb_serial_get_paritytype()
{
	return cdc_line_coding[5];
}
uint8_t usb_serial_get_numbits()
{
	return cdc_line_coding[6];
}
uint8_t usb_serial_get_control()
{
	return cdc_line_rtsdtr;
}

// write the control signals, DCD, DSR, RI, etc
// There is no CTS signal.  If software on the host has transmitted
// data to you but you haven't been calling the getchar function,
// it remains buffered (either here or on the host) and can not be
// lost because you weren't listening at the right time, like it
// would in real serial communication.
int8_t usb_serial_set_control( uint8_t signals )
{
	uint8_t intr_state;

	intr_state = SREG;
	cli();
	if (!usb_configuration) {
		// we're not enumerated/configured
		SREG = intr_state;
		return -1;
	}

	UENUM = CDC_ACM_ENDPOINT;
	if (!(UEINTX & (1<<RWAL))) {
		// unable to write
		// TODO; should this try to abort the previously
		// buffered message??
		SREG = intr_state;
		return -1;
	}
	UEDATX = 0xA1;
	UEDATX = 0x20;
	UEDATX = 0;
	UEDATX = 0;
	UEDATX = 0; // 0 seems to work nicely.  what if this is 1??
	UEDATX = 0;
	UEDATX = 1;
	UEDATX = 0;
	UEDATX = signals;
	UEINTX = 0x3A;
	SREG = intr_state;
	return 0;
}



// ----- General USB Functions -----

// Set the avr into firmware reload mode
void usb_device_reload()
{
	cli();
	// Disable watchdog, if enabled
	// Disable all peripherals

	UDCON = 1;
	USBCON = (1 << FRZCLK);  // Disable USB
	UCSR1B = 0;
	_delay_ms( 5 );

#if defined(__AVR_AT90USB162__)                // Teensy 1.0
	EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0;
	TIMSK0 = 0; TIMSK1 = 0; UCSR1B = 0;
	DDRB = 0; DDRC = 0; DDRD = 0;
	PORTB = 0; PORTC = 0; PORTD = 0;
	asm volatile("jmp 0x3E00");
#elif defined(__AVR_ATmega32U4__)              // Teensy 2.0
	EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; ADCSRA = 0;
	TIMSK0 = 0; TIMSK1 = 0; TIMSK3 = 0; TIMSK4 = 0; UCSR1B = 0; TWCR = 0;
	DDRB = 0; DDRC = 0; DDRD = 0; DDRE = 0; DDRF = 0; TWCR = 0;
	PORTB = 0; PORTC = 0; PORTD = 0; PORTE = 0; PORTF = 0;
	asm volatile("jmp 0x7E00");
#elif defined(__AVR_AT90USB646__)              // Teensy++ 1.0
	EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; ADCSRA = 0;
	TIMSK0 = 0; TIMSK1 = 0; TIMSK2 = 0; TIMSK3 = 0; UCSR1B = 0; TWCR = 0;
	DDRA = 0; DDRB = 0; DDRC = 0; DDRD = 0; DDRE = 0; DDRF = 0;
	PORTA = 0; PORTB = 0; PORTC = 0; PORTD = 0; PORTE = 0; PORTF = 0;
	asm volatile("jmp 0xFC00");
#elif defined(__AVR_AT90USB1286__)             // Teensy++ 2.0
	EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; ADCSRA = 0;
	TIMSK0 = 0; TIMSK1 = 0; TIMSK2 = 0; TIMSK3 = 0; UCSR1B = 0; TWCR = 0;
	DDRA = 0; DDRB = 0; DDRC = 0; DDRD = 0; DDRE = 0; DDRF = 0;
	PORTA = 0; PORTB = 0; PORTC = 0; PORTD = 0; PORTE = 0; PORTF = 0;
	asm volatile("jmp 0x1FC00");
#endif
}


// WDT Setup for software reset the chip
void wdt_init()
{
	MCUSR = 0;
	wdt_disable();
}


// initialize USB
uint8_t usb_init()
{
	// Check to see if a usb cable has been plugged in
	// XXX Not tested (also, not currently needed) -HaaTa
	//if ( USB0_STAT & (1 << 1)
	//      return 0;

	HW_CONFIG();
	USB_FREEZE();                           // enable USB
	PLL_CONFIG();                           // config PLL
	while (!(PLLCSR & (1<<PLOCK))) ;        // wait for PLL lock
	USB_CONFIG();                           // start USB clock
	UDCON = 0;                              // enable attach resistor
	usb_configuration = 0;
	UDIEN = (1<<EORSTE) | (1<<SOFE);
	sei();

	// Disable watchdog timer after possible software reset
	//wdt_init(); // XXX Not working...seems to be ok without this, not sure though

	return 1;
}

// return 0 if the USB is not configured, or the configuration
// number selected by the HOST
uint8_t usb_configured()
{
	return usb_configuration;
}

// USB Device Interrupt - handle all device-level events
// the transmit buffer flushing is triggered by the start of frame
//
ISR( USB_GEN_vect )
{
	uint8_t intbits, t_cdc;

	intbits = UDINT;
	UDINT = 0;
	if ( intbits & (1 << EORSTI) )
	{
		UENUM = 0;
		UECONX = 1;
		UECFG0X = EP_TYPE_CONTROL;
		UECFG1X = EP_SIZE(ENDPOINT0_SIZE) | EP_SINGLE_BUFFER;
		UEIENX = (1 << RXSTPE);
		usb_configuration = 0;
		cdc_line_rtsdtr = 0;
	}
	if ( (intbits & (1 << SOFI)) && usb_configuration )
	{
		t_cdc = transmit_flush_timer;
		if ( t_cdc )
		{
			transmit_flush_timer = --t_cdc;
			if ( !t_cdc )
			{
				UENUM = CDC_TX_ENDPOINT;
				UEINTX = 0x3A;
			}
		}
		static uint8_t div4 = 0;
		if ( USBKeys_Idle_Config && (++div4 & 3) == 0 )
		{
			USBKeys_Idle_Count++;
			if ( USBKeys_Idle_Count == USBKeys_Idle_Config )
			{
				// XXX TODO Is this even used? If so, when? -Jacob
				// From hasu's code, this section looks like it could fix the Mac SET_IDLE problem
				// Send normal keyboard interrupt packet(s)
				switch ( USBKeys_Protocol )
				{
				// Send boot keyboard interrupt packet(s)
				case 0: usb_keyboard_toHost();     break;
				// Send NKRO keyboard interrupts packet(s)
				//case 1: usb_nkrokeyboard_toHost(); break; // XXX Not valid anymore
				}
				print("IDLE");
			}
		}
	}
}



// Misc functions to wait for ready and send/receive packets
static inline void usb_wait_in_ready()
{
	while (!(UEINTX & (1<<TXINI))) ;
}
static inline void usb_send_in()
{
	UEINTX = ~(1<<TXINI);
}
static inline void usb_wait_receive_out()
{
	while (!(UEINTX & (1<<RXOUTI))) ;
}
static inline void usb_ack_out()
{
	UEINTX = ~(1<<RXOUTI);
}



// USB Endpoint Interrupt - endpoint 0 is handled here.  The
// other endpoints are manipulated by the user-callable
// functions, and the start-of-frame interrupt.
//
ISR( USB_COM_vect )
{
	uint8_t intbits;
	const uint8_t *list;
	const uint8_t *cfg;
	uint8_t i, n, len, en;
	uint8_t *p;
	uint8_t bmRequestType;
	uint8_t bRequest;
	uint16_t wValue;
	uint16_t wIndex;
	uint16_t wLength;
	uint16_t desc_val;
	const uint8_t *desc_addr;
	uint8_t desc_length;

	UENUM = 0;
	intbits = UEINTX;
	if (intbits & (1<<RXSTPI))
	{
		bmRequestType = UEDATX;
		bRequest = UEDATX;
		wValue = UEDATX;
		wValue |= (UEDATX << 8);
		wIndex = UEDATX;
		wIndex |= (UEDATX << 8);
		wLength = UEDATX;
		wLength |= (UEDATX << 8);
		UEINTX = ~((1<<RXSTPI) | (1<<RXOUTI) | (1<<TXINI));

		if ( bRequest == GET_DESCRIPTOR )
		{
			list = (const uint8_t *)descriptor_list;
			for ( i = 0; ; i++ )
			{
				if ( i >= NUM_DESC_LIST )
				{
					UECONX = (1 << STALLRQ) | (1 << EPEN);  //stall
					return;
				}
				desc_val = pgm_read_word(list);
				if ( desc_val != wValue )
				{
					list += sizeof( struct descriptor_list_struct );
					continue;
				}
				list += 2;
				desc_val = pgm_read_word(list);
				if ( desc_val != wIndex )
				{
					list += sizeof(struct descriptor_list_struct) - 2;
					continue;
				}
				list += 2;
				desc_addr = (const uint8_t *)pgm_read_word(list);
				list += 2;
				desc_length = pgm_read_byte(list);
				break;
			}
			len = (wLength < 256) ? wLength : 255;
			if (len > desc_length) len = desc_length;
			do {
				// wait for host ready for IN packet
				do {
					i = UEINTX;
				} while (!(i & ((1<<TXINI)|(1<<RXOUTI))));
				if (i & (1<<RXOUTI)) return;    // abort
				// send IN packet
				n = len < ENDPOINT0_SIZE ? len : ENDPOINT0_SIZE;
				for (i = n; i; i--) {
					UEDATX = pgm_read_byte(desc_addr++);
				}
				len -= n;
				usb_send_in();
			} while (len || n == ENDPOINT0_SIZE);
			return;
		}

		if (bRequest == SET_ADDRESS) {
			usb_send_in();
			usb_wait_in_ready();
			UDADDR = wValue | (1<<ADDEN);
			return;
		}

		if ( bRequest == SET_CONFIGURATION && bmRequestType == 0 )
		{
			usb_configuration = wValue;
			cdc_line_rtsdtr = 0;
			transmit_flush_timer = 0;
			usb_send_in();
			cfg = endpoint_config_table;
			// Setup each of the 6 additional endpoints (0th already configured)
			for ( i = 1; i < 6; i++ )
			{
				UENUM = i;
				en = pgm_read_byte(cfg++);
				UECONX = en;
				if (en)
				{
					UECFG0X = pgm_read_byte(cfg++);
					UECFG1X = pgm_read_byte(cfg++);
				}
			}
			UERST = 0x7E;
			UERST = 0;
			return;
		}

		if (bRequest == GET_CONFIGURATION && bmRequestType == 0x80) {
			usb_wait_in_ready();
			UEDATX = usb_configuration;
			usb_send_in();
			return;
		}

		if ( ( wIndex == KEYBOARD_INTERFACE      && USBKeys_Protocol == 0 )
		  || ( wIndex == KEYBOARD_NKRO_INTERFACE && USBKeys_Protocol == 1 ) )
		{
			if ( bmRequestType == 0xA1)
			{
				if ( bRequest == HID_GET_REPORT )
				{
					usb_wait_in_ready();

					// Send normal keyboard interrupt packet(s)
					switch ( USBKeys_Protocol )
					{
					// Send boot keyboard interrupt packet(s)
					case 0: usb_keyboard_toHost();     break;
					// Send NKRO keyboard interrupts packet(s)
					//case 1: usb_nkrokeyboard_toHost(); break; // XXX Not valid anymore
					}

					usb_send_in();
					return;
				}
				if ( bRequest == HID_GET_IDLE )
				{
					usb_wait_in_ready();
					UEDATX = USBKeys_Idle_Config;
					usb_send_in();
					return;
				}
				if ( bRequest == HID_GET_PROTOCOL )
				{
					usb_wait_in_ready();
					UEDATX = USBKeys_Protocol;
					usb_send_in();
					return;
				}
			}
			if ( bmRequestType == 0x21 )
			{
				if ( bRequest == HID_SET_REPORT )
				{
					usb_wait_receive_out();
					USBKeys_LEDs = UEDATX;
					usb_ack_out();
					usb_send_in();
					return;
				}
				if ( bRequest == HID_SET_IDLE )
				{
					usb_wait_in_ready();
					USBKeys_Idle_Config = (wValue >> 8);
					USBKeys_Idle_Count = 0;
					usb_send_in();
					//print("HID IDLE");
					return;
				}
				if ( bRequest == HID_SET_PROTOCOL )
				{
					usb_wait_in_ready();
					USBKeys_Protocol = wValue; // 0 - Boot Mode, 1 - NKRO Mode
					usb_send_in();
					//print("HID SET");
					return;
				}
			}
		}

		if (bRequest == CDC_GET_LINE_CODING && bmRequestType == 0xA1) {
			usb_wait_in_ready();
			p = cdc_line_coding;
			for (i=0; i<7; i++) {
				UEDATX = *p++;
			}
			usb_send_in();
			return;
		}

		if (bRequest == CDC_SET_LINE_CODING && bmRequestType == 0x21) {
			usb_wait_receive_out();
			p = cdc_line_coding;
			for (i=0; i<7; i++) {
				*p++ = UEDATX;
			}
			usb_ack_out();
			usb_send_in();
			return;
		}

		if (bRequest == CDC_SET_CONTROL_LINE_STATE && bmRequestType == 0x21) {
			cdc_line_rtsdtr = wValue;
			usb_wait_in_ready();
			usb_send_in();
			return;
		}

		if (bRequest == GET_STATUS) {
			usb_wait_in_ready();
			i = 0;
			if (bmRequestType == 0x82) {
				UENUM = wIndex;
				if (UECONX & (1<<STALLRQ)) i = 1;
				UENUM = 0;
			}
			UEDATX = i;
			UEDATX = 0;
			usb_send_in();
			return;
		}

		if ((bRequest == CLEAR_FEATURE || bRequest == SET_FEATURE)
		  && bmRequestType == 0x02 && wValue == 0) {
			i = wIndex & 0x7F;
			if (i >= 1 && i <= MAX_ENDPOINT) {
				usb_send_in();
				UENUM = i;
				if (bRequest == SET_FEATURE) {
					UECONX = (1<<STALLRQ)|(1<<EPEN);
				} else {
					UECONX = (1<<STALLRQC)|(1<<RSTDT)|(1<<EPEN);
					UERST = (1 << i);
					UERST = 0;
				}
				return;
			}
		}
	}
	UECONX = (1 << STALLRQ) | (1 << EPEN);  // stall
}