diff options
Diffstat (limited to 'tmk_core/protocol/vusb/usbdrv')
| -rw-r--r-- | tmk_core/protocol/vusb/usbdrv/oddebug.c | 22 | ||||
| -rw-r--r-- | tmk_core/protocol/vusb/usbdrv/oddebug.h | 114 | ||||
| -rw-r--r-- | tmk_core/protocol/vusb/usbdrv/usbconfig-prototype.h | 86 | ||||
| -rw-r--r-- | tmk_core/protocol/vusb/usbdrv/usbdrv.c | 673 | ||||
| -rw-r--r-- | tmk_core/protocol/vusb/usbdrv/usbdrv.h | 487 |
5 files changed, 684 insertions, 698 deletions
diff --git a/tmk_core/protocol/vusb/usbdrv/oddebug.c b/tmk_core/protocol/vusb/usbdrv/oddebug.c index 945457c1f4..bcd28ff014 100644 --- a/tmk_core/protocol/vusb/usbdrv/oddebug.c +++ b/tmk_core/protocol/vusb/usbdrv/oddebug.c @@ -12,34 +12,30 @@ #if DEBUG_LEVEL > 0 -#warning "Never compile production devices with debugging enabled" +# warning "Never compile production devices with debugging enabled" -static void uartPutc(char c) -{ - while(!(ODDBG_USR & (1 << ODDBG_UDRE))); /* wait for data register empty */ +static void uartPutc(char c) { + while (!(ODDBG_USR & (1 << ODDBG_UDRE))) + ; /* wait for data register empty */ ODDBG_UDR = c; } -static uchar hexAscii(uchar h) -{ +static uchar hexAscii(uchar h) { h &= 0xf; - if(h >= 10) - h += 'a' - (uchar)10 - '0'; + if (h >= 10) h += 'a' - (uchar)10 - '0'; h += '0'; return h; } -static void printHex(uchar c) -{ +static void printHex(uchar c) { uartPutc(hexAscii(c >> 4)); uartPutc(hexAscii(c)); } -void odDebug(uchar prefix, uchar *data, uchar len) -{ +void odDebug(uchar prefix, uchar *data, uchar len) { printHex(prefix); uartPutc(':'); - while(len--){ + while (len--) { uartPutc(' '); printHex(*data++); } diff --git a/tmk_core/protocol/vusb/usbdrv/oddebug.h b/tmk_core/protocol/vusb/usbdrv/oddebug.h index d61309daac..f93f338794 100644 --- a/tmk_core/protocol/vusb/usbdrv/oddebug.h +++ b/tmk_core/protocol/vusb/usbdrv/oddebug.h @@ -23,39 +23,38 @@ A debug log consists of a label ('prefix') to indicate which debug log created the output and a memory block to dump in hex ('data' and 'len'). */ - #ifndef F_CPU -# define F_CPU 12000000 /* 12 MHz */ +# define F_CPU 12000000 /* 12 MHz */ #endif /* make sure we have the UART defines: */ #include "usbportability.h" #ifndef uchar -# define uchar unsigned char +# define uchar unsigned char #endif #if DEBUG_LEVEL > 0 && !(defined TXEN || defined TXEN0) /* no UART in device */ -# warning "Debugging disabled because device has no UART" -# undef DEBUG_LEVEL +# warning "Debugging disabled because device has no UART" +# undef DEBUG_LEVEL #endif #ifndef DEBUG_LEVEL -# define DEBUG_LEVEL 0 +# define DEBUG_LEVEL 0 #endif /* ------------------------------------------------------------------------- */ #if DEBUG_LEVEL > 0 -# define DBG1(prefix, data, len) odDebug(prefix, data, len) +# define DBG1(prefix, data, len) odDebug(prefix, data, len) #else -# define DBG1(prefix, data, len) +# define DBG1(prefix, data, len) #endif #if DEBUG_LEVEL > 1 -# define DBG2(prefix, data, len) odDebug(prefix, data, len) +# define DBG2(prefix, data, len) odDebug(prefix, data, len) #else -# define DBG2(prefix, data, len) +# define DBG2(prefix, data, len) #endif /* ------------------------------------------------------------------------- */ @@ -65,57 +64,56 @@ extern void odDebug(uchar prefix, uchar *data, uchar len); /* Try to find our control registers; ATMEL likes to rename these */ -#if defined UBRR -# define ODDBG_UBRR UBRR -#elif defined UBRRL -# define ODDBG_UBRR UBRRL -#elif defined UBRR0 -# define ODDBG_UBRR UBRR0 -#elif defined UBRR0L -# define ODDBG_UBRR UBRR0L -#endif - -#if defined UCR -# define ODDBG_UCR UCR -#elif defined UCSRB -# define ODDBG_UCR UCSRB -#elif defined UCSR0B -# define ODDBG_UCR UCSR0B -#endif - -#if defined TXEN -# define ODDBG_TXEN TXEN -#else -# define ODDBG_TXEN TXEN0 -#endif - -#if defined USR -# define ODDBG_USR USR -#elif defined UCSRA -# define ODDBG_USR UCSRA -#elif defined UCSR0A -# define ODDBG_USR UCSR0A -#endif - -#if defined UDRE -# define ODDBG_UDRE UDRE -#else -# define ODDBG_UDRE UDRE0 -#endif - -#if defined UDR -# define ODDBG_UDR UDR -#elif defined UDR0 -# define ODDBG_UDR UDR0 -#endif - -static inline void odDebugInit(void) -{ - ODDBG_UCR |= (1<<ODDBG_TXEN); +# if defined UBRR +# define ODDBG_UBRR UBRR +# elif defined UBRRL +# define ODDBG_UBRR UBRRL +# elif defined UBRR0 +# define ODDBG_UBRR UBRR0 +# elif defined UBRR0L +# define ODDBG_UBRR UBRR0L +# endif + +# if defined UCR +# define ODDBG_UCR UCR +# elif defined UCSRB +# define ODDBG_UCR UCSRB +# elif defined UCSR0B +# define ODDBG_UCR UCSR0B +# endif + +# if defined TXEN +# define ODDBG_TXEN TXEN +# else +# define ODDBG_TXEN TXEN0 +# endif + +# if defined USR +# define ODDBG_USR USR +# elif defined UCSRA +# define ODDBG_USR UCSRA +# elif defined UCSR0A +# define ODDBG_USR UCSR0A +# endif + +# if defined UDRE +# define ODDBG_UDRE UDRE +# else +# define ODDBG_UDRE UDRE0 +# endif + +# if defined UDR +# define ODDBG_UDR UDR +# elif defined UDR0 +# define ODDBG_UDR UDR0 +# endif + +static inline void odDebugInit(void) { + ODDBG_UCR |= (1 << ODDBG_TXEN); ODDBG_UBRR = F_CPU / (19200 * 16L) - 1; } #else -# define odDebugInit() +# define odDebugInit() #endif /* ------------------------------------------------------------------------- */ diff --git a/tmk_core/protocol/vusb/usbdrv/usbconfig-prototype.h b/tmk_core/protocol/vusb/usbdrv/usbconfig-prototype.h index 847710e2a0..020ea51474 100644 --- a/tmk_core/protocol/vusb/usbdrv/usbconfig-prototype.h +++ b/tmk_core/protocol/vusb/usbdrv/usbconfig-prototype.h @@ -26,15 +26,15 @@ section at the end of this file). /* ---------------------------- Hardware Config ---------------------------- */ -#define USB_CFG_IOPORTNAME D +#define USB_CFG_IOPORTNAME D /* This is the port where the USB bus is connected. When you configure it to * "B", the registers PORTB, PINB and DDRB will be used. */ -#define USB_CFG_DMINUS_BIT 4 +#define USB_CFG_DMINUS_BIT 4 /* This is the bit number in USB_CFG_IOPORT where the USB D- line is connected. * This may be any bit in the port. */ -#define USB_CFG_DPLUS_BIT 2 +#define USB_CFG_DPLUS_BIT 2 /* This is the bit number in USB_CFG_IOPORT where the USB D+ line is connected. * This may be any bit in the port. Please note that D+ must also be connected * to interrupt pin INT0! [You can also use other interrupts, see section @@ -43,7 +43,7 @@ section at the end of this file). * interrupt, the USB interrupt will also be triggered at Start-Of-Frame * markers every millisecond.] */ -#define USB_CFG_CLOCK_KHZ (F_CPU/1000) +#define USB_CFG_CLOCK_KHZ (F_CPU / 1000) /* Clock rate of the AVR in kHz. Legal values are 12000, 12800, 15000, 16000, * 16500, 18000 and 20000. The 12.8 MHz and 16.5 MHz versions of the code * require no crystal, they tolerate +/- 1% deviation from the nominal @@ -52,7 +52,7 @@ section at the end of this file). * Since F_CPU should be defined to your actual clock rate anyway, you should * not need to modify this setting. */ -#define USB_CFG_CHECK_CRC 0 +#define USB_CFG_CHECK_CRC 0 /* Define this to 1 if you want that the driver checks integrity of incoming * data packets (CRC checks). CRC checks cost quite a bit of code size and are * currently only available for 18 MHz crystal clock. You must choose @@ -75,18 +75,18 @@ section at the end of this file). /* --------------------------- Functional Range ---------------------------- */ -#define USB_CFG_HAVE_INTRIN_ENDPOINT 0 +#define USB_CFG_HAVE_INTRIN_ENDPOINT 0 /* Define this to 1 if you want to compile a version with two endpoints: The * default control endpoint 0 and an interrupt-in endpoint (any other endpoint * number). */ -#define USB_CFG_HAVE_INTRIN_ENDPOINT3 0 +#define USB_CFG_HAVE_INTRIN_ENDPOINT3 0 /* Define this to 1 if you want to compile a version with three endpoints: The * default control endpoint 0, an interrupt-in endpoint 3 (or the number * configured below) and a catch-all default interrupt-in endpoint as above. * You must also define USB_CFG_HAVE_INTRIN_ENDPOINT to 1 for this feature. */ -#define USB_CFG_EP3_NUMBER 3 +#define USB_CFG_EP3_NUMBER 3 /* If the so-called endpoint 3 is used, it can now be configured to any other * endpoint number (except 0) with this macro. Default if undefined is 3. */ @@ -96,13 +96,13 @@ section at the end of this file). * Since the token is toggled BEFORE sending any data, the first packet is * sent with the oposite value of this configuration! */ -#define USB_CFG_IMPLEMENT_HALT 0 +#define USB_CFG_IMPLEMENT_HALT 0 /* Define this to 1 if you also want to implement the ENDPOINT_HALT feature * for endpoint 1 (interrupt endpoint). Although you may not need this feature, * it is required by the standard. We have made it a config option because it * bloats the code considerably. */ -#define USB_CFG_SUPPRESS_INTR_CODE 0 +#define USB_CFG_SUPPRESS_INTR_CODE 0 /* Define this to 1 if you want to declare interrupt-in endpoints, but don't * want to send any data over them. If this macro is defined to 1, functions * usbSetInterrupt() and usbSetInterrupt3() are omitted. This is useful if @@ -110,48 +110,48 @@ section at the end of this file). * (e.g. HID), but never want to send any data. This option saves a couple * of bytes in flash memory and the transmit buffers in RAM. */ -#define USB_CFG_INTR_POLL_INTERVAL 10 +#define USB_CFG_INTR_POLL_INTERVAL 10 /* If you compile a version with endpoint 1 (interrupt-in), this is the poll * interval. The value is in milliseconds and must not be less than 10 ms for * low speed devices. */ -#define USB_CFG_IS_SELF_POWERED 0 +#define USB_CFG_IS_SELF_POWERED 0 /* Define this to 1 if the device has its own power supply. Set it to 0 if the * device is powered from the USB bus. */ -#define USB_CFG_MAX_BUS_POWER 100 +#define USB_CFG_MAX_BUS_POWER 100 /* Set this variable to the maximum USB bus power consumption of your device. * The value is in milliamperes. [It will be divided by two since USB * communicates power requirements in units of 2 mA.] */ -#define USB_CFG_IMPLEMENT_FN_WRITE 0 +#define USB_CFG_IMPLEMENT_FN_WRITE 0 /* Set this to 1 if you want usbFunctionWrite() to be called for control-out * transfers. Set it to 0 if you don't need it and want to save a couple of * bytes. */ -#define USB_CFG_IMPLEMENT_FN_READ 0 +#define USB_CFG_IMPLEMENT_FN_READ 0 /* Set this to 1 if you need to send control replies which are generated * "on the fly" when usbFunctionRead() is called. If you only want to send * data from a static buffer, set it to 0 and return the data from * usbFunctionSetup(). This saves a couple of bytes. */ -#define USB_CFG_IMPLEMENT_FN_WRITEOUT 0 +#define USB_CFG_IMPLEMENT_FN_WRITEOUT 0 /* Define this to 1 if you want to use interrupt-out (or bulk out) endpoints. * You must implement the function usbFunctionWriteOut() which receives all * interrupt/bulk data sent to any endpoint other than 0. The endpoint number * can be found in 'usbRxToken'. */ -#define USB_CFG_HAVE_FLOWCONTROL 0 +#define USB_CFG_HAVE_FLOWCONTROL 0 /* Define this to 1 if you want flowcontrol over USB data. See the definition * of the macros usbDisableAllRequests() and usbEnableAllRequests() in * usbdrv.h. */ -#define USB_CFG_DRIVER_FLASH_PAGE 0 +#define USB_CFG_DRIVER_FLASH_PAGE 0 /* If the device has more than 64 kBytes of flash, define this to the 64 k page * where the driver's constants (descriptors) are located. Or in other words: * Define this to 1 for boot loaders on the ATMega128. */ -#define USB_CFG_LONG_TRANSFERS 0 +#define USB_CFG_LONG_TRANSFERS 0 /* Define this to 1 if you want to send/receive blocks of more than 254 bytes * in a single control-in or control-out transfer. Note that the capability * for long transfers increases the driver size. @@ -172,7 +172,7 @@ section at the end of this file). /* This macro (if defined) is executed when a USB SET_ADDRESS request was * received. */ -#define USB_COUNT_SOF 0 +#define USB_COUNT_SOF 0 /* define this macro to 1 if you need the global variable "usbSofCount" which * counts SOF packets. This feature requires that the hardware interrupt is * connected to D- instead of D+. @@ -196,7 +196,7 @@ section at the end of this file). * Please note that Start Of Frame detection works only if D- is wired to the * interrupt, not D+. THIS IS DIFFERENT THAN MOST EXAMPLES! */ -#define USB_CFG_CHECK_DATA_TOGGLING 0 +#define USB_CFG_CHECK_DATA_TOGGLING 0 /* define this macro to 1 if you want to filter out duplicate data packets * sent by the host. Duplicates occur only as a consequence of communication * errors, when the host does not receive an ACK. Please note that you need to @@ -204,11 +204,11 @@ section at the end of this file). * usbFunctionWrite(). Use the global usbCurrentDataToken and a static variable * for each control- and out-endpoint to check for duplicate packets. */ -#define USB_CFG_HAVE_MEASURE_FRAME_LENGTH 0 +#define USB_CFG_HAVE_MEASURE_FRAME_LENGTH 0 /* define this macro to 1 if you want the function usbMeasureFrameLength() * compiled in. This function can be used to calibrate the AVR's RC oscillator. */ -#define USB_USE_FAST_CRC 0 +#define USB_USE_FAST_CRC 0 /* The assembler module has two implementations for the CRC algorithm. One is * faster, the other is smaller. This CRC routine is only used for transmitted * messages where timing is not critical. The faster routine needs 31 cycles @@ -219,7 +219,7 @@ section at the end of this file). /* -------------------------- Device Description --------------------------- */ -#define USB_CFG_VENDOR_ID 0xc0, 0x16 /* = 0x16c0 = 5824 = voti.nl */ +#define USB_CFG_VENDOR_ID 0xc0, 0x16 /* = 0x16c0 = 5824 = voti.nl */ /* USB vendor ID for the device, low byte first. If you have registered your * own Vendor ID, define it here. Otherwise you may use one of obdev's free * shared VID/PID pairs. Be sure to read USB-IDs-for-free.txt for rules! @@ -228,7 +228,7 @@ section at the end of this file). * with libusb: 0x16c0/0x5dc. Use this VID/PID pair ONLY if you understand * the implications! */ -#define USB_CFG_DEVICE_ID 0xdc, 0x05 /* = 0x05dc = 1500 */ +#define USB_CFG_DEVICE_ID 0xdc, 0x05 /* = 0x05dc = 1500 */ /* This is the ID of the product, low byte first. It is interpreted in the * scope of the vendor ID. If you have registered your own VID with usb.org * or if you have licensed a PID from somebody else, define it here. Otherwise @@ -239,10 +239,10 @@ section at the end of this file). * with libusb: 0x16c0/0x5dc. Use this VID/PID pair ONLY if you understand * the implications! */ -#define USB_CFG_DEVICE_VERSION 0x00, 0x01 +#define USB_CFG_DEVICE_VERSION 0x00, 0x01 /* Version number of the device: Minor number first, then major number. */ -#define USB_CFG_VENDOR_NAME 'o', 'b', 'd', 'e', 'v', '.', 'a', 't' +#define USB_CFG_VENDOR_NAME 'o', 'b', 'd', 'e', 'v', '.', 'a', 't' #define USB_CFG_VENDOR_NAME_LEN 8 /* These two values define the vendor name returned by the USB device. The name * must be given as a list of characters under single quotes. The characters @@ -252,7 +252,7 @@ section at the end of this file). * obdev's free shared VID/PID pair. See the file USB-IDs-for-free.txt for * details. */ -#define USB_CFG_DEVICE_NAME 'T', 'e', 'm', 'p', 'l', 'a', 't', 'e' +#define USB_CFG_DEVICE_NAME 'T', 'e', 'm', 'p', 'l', 'a', 't', 'e' #define USB_CFG_DEVICE_NAME_LEN 8 /* Same as above for the device name. If you don't want a device name, undefine * the macros. See the file USB-IDs-for-free.txt before you assign a name if @@ -267,14 +267,14 @@ section at the end of this file). * to fine tune control over USB descriptors such as the string descriptor * for the serial number. */ -#define USB_CFG_DEVICE_CLASS 0xff /* set to 0 if deferred to interface */ -#define USB_CFG_DEVICE_SUBCLASS 0 +#define USB_CFG_DEVICE_CLASS 0xff /* set to 0 if deferred to interface */ +#define USB_CFG_DEVICE_SUBCLASS 0 /* See USB specification if you want to conform to an existing device class. * Class 0xff is "vendor specific". */ -#define USB_CFG_INTERFACE_CLASS 0 /* define class here if not at device level */ -#define USB_CFG_INTERFACE_SUBCLASS 0 -#define USB_CFG_INTERFACE_PROTOCOL 0 +#define USB_CFG_INTERFACE_CLASS 0 /* define class here if not at device level */ +#define USB_CFG_INTERFACE_SUBCLASS 0 +#define USB_CFG_INTERFACE_PROTOCOL 0 /* See USB specification if you want to conform to an existing device class or * protocol. The following classes must be set at interface level: * HID class is 3, no subclass and protocol required (but may be useful!) @@ -345,16 +345,16 @@ section at the end of this file). * }; */ -#define USB_CFG_DESCR_PROPS_DEVICE 0 -#define USB_CFG_DESCR_PROPS_CONFIGURATION 0 -#define USB_CFG_DESCR_PROPS_STRINGS 0 -#define USB_CFG_DESCR_PROPS_STRING_0 0 -#define USB_CFG_DESCR_PROPS_STRING_VENDOR 0 -#define USB_CFG_DESCR_PROPS_STRING_PRODUCT 0 -#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0 -#define USB_CFG_DESCR_PROPS_HID 0 -#define USB_CFG_DESCR_PROPS_HID_REPORT 0 -#define USB_CFG_DESCR_PROPS_UNKNOWN 0 +#define USB_CFG_DESCR_PROPS_DEVICE 0 +#define USB_CFG_DESCR_PROPS_CONFIGURATION 0 +#define USB_CFG_DESCR_PROPS_STRINGS 0 +#define USB_CFG_DESCR_PROPS_STRING_0 0 +#define USB_CFG_DESCR_PROPS_STRING_VENDOR 0 +#define USB_CFG_DESCR_PROPS_STRING_PRODUCT 0 +#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0 +#define USB_CFG_DESCR_PROPS_HID 0 +#define USB_CFG_DESCR_PROPS_HID_REPORT 0 +#define USB_CFG_DESCR_PROPS_UNKNOWN 0 /* ----------------------- Optional MCU Description ------------------------ */ diff --git a/tmk_core/protocol/vusb/usbdrv/usbdrv.c b/tmk_core/protocol/vusb/usbdrv/usbdrv.c index 30cdc9dcfc..f69198b1b9 100644 --- a/tmk_core/protocol/vusb/usbdrv/usbdrv.c +++ b/tmk_core/protocol/vusb/usbdrv/usbdrv.c @@ -21,36 +21,36 @@ documentation of the entire driver. /* ------------------------------------------------------------------------- */ /* raw USB registers / interface to assembler code: */ -uchar usbRxBuf[2*USB_BUFSIZE]; /* raw RX buffer: PID, 8 bytes data, 2 bytes CRC */ -uchar usbInputBufOffset; /* offset in usbRxBuf used for low level receiving */ -uchar usbDeviceAddr; /* assigned during enumeration, defaults to 0 */ -uchar usbNewDeviceAddr; /* device ID which should be set after status phase */ -uchar usbConfiguration; /* currently selected configuration. Administered by driver, but not used */ -volatile schar usbRxLen; /* = 0; number of bytes in usbRxBuf; 0 means free, -1 for flow control */ -uchar usbCurrentTok; /* last token received or endpoint number for last OUT token if != 0 */ -uchar usbRxToken; /* token for data we received; or endpont number for last OUT */ -volatile uchar usbTxLen = USBPID_NAK; /* number of bytes to transmit with next IN token or handshake token */ -uchar usbTxBuf[USB_BUFSIZE];/* data to transmit with next IN, free if usbTxLen contains handshake token */ +uchar usbRxBuf[2 * USB_BUFSIZE]; /* raw RX buffer: PID, 8 bytes data, 2 bytes CRC */ +uchar usbInputBufOffset; /* offset in usbRxBuf used for low level receiving */ +uchar usbDeviceAddr; /* assigned during enumeration, defaults to 0 */ +uchar usbNewDeviceAddr; /* device ID which should be set after status phase */ +uchar usbConfiguration; /* currently selected configuration. Administered by driver, but not used */ +volatile schar usbRxLen; /* = 0; number of bytes in usbRxBuf; 0 means free, -1 for flow control */ +uchar usbCurrentTok; /* last token received or endpoint number for last OUT token if != 0 */ +uchar usbRxToken; /* token for data we received; or endpont number for last OUT */ +volatile uchar usbTxLen = USBPID_NAK; /* number of bytes to transmit with next IN token or handshake token */ +uchar usbTxBuf[USB_BUFSIZE]; /* data to transmit with next IN, free if usbTxLen contains handshake token */ #if USB_COUNT_SOF -volatile uchar usbSofCount; /* incremented by assembler module every SOF */ +volatile uchar usbSofCount; /* incremented by assembler module every SOF */ #endif #if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE -usbTxStatus_t usbTxStatus1; -# if USB_CFG_HAVE_INTRIN_ENDPOINT3 -usbTxStatus_t usbTxStatus3; -# endif +usbTxStatus_t usbTxStatus1; +# if USB_CFG_HAVE_INTRIN_ENDPOINT3 +usbTxStatus_t usbTxStatus3; +# endif #endif #if USB_CFG_CHECK_DATA_TOGGLING -uchar usbCurrentDataToken;/* when we check data toggling to ignore duplicate packets */ +uchar usbCurrentDataToken; /* when we check data toggling to ignore duplicate packets */ #endif /* USB status registers / not shared with asm code */ -uchar *usbMsgPtr; /* data to transmit next -- ROM or RAM address */ -static usbMsgLen_t usbMsgLen = USB_NO_MSG; /* remaining number of bytes */ -static uchar usbMsgFlags; /* flag values see below */ +uchar * usbMsgPtr; /* data to transmit next -- ROM or RAM address */ +static usbMsgLen_t usbMsgLen = USB_NO_MSG; /* remaining number of bytes */ +static uchar usbMsgFlags; /* flag values see below */ -#define USB_FLG_MSGPTR_IS_ROM (1<<6) -#define USB_FLG_USE_USER_RW (1<<7) +#define USB_FLG_MSGPTR_IS_ROM (1 << 6) +#define USB_FLG_USE_USER_RW (1 << 7) /* optimizing hints: @@ -64,196 +64,174 @@ optimizing hints: #if USB_CFG_DESCR_PROPS_STRINGS == 0 -#if USB_CFG_DESCR_PROPS_STRING_0 == 0 -#undef USB_CFG_DESCR_PROPS_STRING_0 -#define USB_CFG_DESCR_PROPS_STRING_0 sizeof(usbDescriptorString0) -const PROGMEM char usbDescriptorString0[] = { /* language descriptor */ +# if USB_CFG_DESCR_PROPS_STRING_0 == 0 +# undef USB_CFG_DESCR_PROPS_STRING_0 +# define USB_CFG_DESCR_PROPS_STRING_0 sizeof(usbDescriptorString0) +const PROGMEM char usbDescriptorString0[] = { + /* language descriptor */ 4, /* sizeof(usbDescriptorString0): length of descriptor in bytes */ 3, /* descriptor type */ 0x09, 0x04, /* language index (0x0409 = US-English) */ }; -#endif +# endif -#if USB_CFG_DESCR_PROPS_STRING_VENDOR == 0 && USB_CFG_VENDOR_NAME_LEN -#undef USB_CFG_DESCR_PROPS_STRING_VENDOR -#define USB_CFG_DESCR_PROPS_STRING_VENDOR sizeof(usbDescriptorStringVendor) -const PROGMEM int usbDescriptorStringVendor[] = { - USB_STRING_DESCRIPTOR_HEADER(USB_CFG_VENDOR_NAME_LEN), - USB_CFG_VENDOR_NAME -}; -#endif +# if USB_CFG_DESCR_PROPS_STRING_VENDOR == 0 && USB_CFG_VENDOR_NAME_LEN +# undef USB_CFG_DESCR_PROPS_STRING_VENDOR +# define USB_CFG_DESCR_PROPS_STRING_VENDOR sizeof(usbDescriptorStringVendor) +const PROGMEM int usbDescriptorStringVendor[] = {USB_STRING_DESCRIPTOR_HEADER(USB_CFG_VENDOR_NAME_LEN), USB_CFG_VENDOR_NAME}; +# endif -#if USB_CFG_DESCR_PROPS_STRING_PRODUCT == 0 && USB_CFG_DEVICE_NAME_LEN -#undef USB_CFG_DESCR_PROPS_STRING_PRODUCT -#define USB_CFG_DESCR_PROPS_STRING_PRODUCT sizeof(usbDescriptorStringDevice) -const PROGMEM int usbDescriptorStringDevice[] = { - USB_STRING_DESCRIPTOR_HEADER(USB_CFG_DEVICE_NAME_LEN), - USB_CFG_DEVICE_NAME -}; -#endif +# if USB_CFG_DESCR_PROPS_STRING_PRODUCT == 0 && USB_CFG_DEVICE_NAME_LEN +# undef USB_CFG_DESCR_PROPS_STRING_PRODUCT +# define USB_CFG_DESCR_PROPS_STRING_PRODUCT sizeof(usbDescriptorStringDevice) +const PROGMEM int usbDescriptorStringDevice[] = {USB_STRING_DESCRIPTOR_HEADER(USB_CFG_DEVICE_NAME_LEN), USB_CFG_DEVICE_NAME}; +# endif -#if USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER == 0 && USB_CFG_SERIAL_NUMBER_LEN -#undef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER -#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER sizeof(usbDescriptorStringSerialNumber) -const PROGMEM int usbDescriptorStringSerialNumber[] = { - USB_STRING_DESCRIPTOR_HEADER(USB_CFG_SERIAL_NUMBER_LEN), - USB_CFG_SERIAL_NUMBER -}; -#endif +# if USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER == 0 && USB_CFG_SERIAL_NUMBER_LEN +# undef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER +# define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER sizeof(usbDescriptorStringSerialNumber) +const PROGMEM int usbDescriptorStringSerialNumber[] = {USB_STRING_DESCRIPTOR_HEADER(USB_CFG_SERIAL_NUMBER_LEN), USB_CFG_SERIAL_NUMBER}; +# endif -#endif /* USB_CFG_DESCR_PROPS_STRINGS == 0 */ +#endif /* USB_CFG_DESCR_PROPS_STRINGS == 0 */ /* --------------------------- Device Descriptor --------------------------- */ #if USB_CFG_DESCR_PROPS_DEVICE == 0 -#undef USB_CFG_DESCR_PROPS_DEVICE -#define USB_CFG_DESCR_PROPS_DEVICE sizeof(usbDescriptorDevice) -const PROGMEM char usbDescriptorDevice[] = { /* USB device descriptor */ - 18, /* sizeof(usbDescriptorDevice): length of descriptor in bytes */ - USBDESCR_DEVICE, /* descriptor type */ - 0x10, 0x01, /* USB version supported */ - USB_CFG_DEVICE_CLASS, - USB_CFG_DEVICE_SUBCLASS, - 0, /* protocol */ - 8, /* max packet size */ +# undef USB_CFG_DESCR_PROPS_DEVICE +# define USB_CFG_DESCR_PROPS_DEVICE sizeof(usbDescriptorDevice) +const PROGMEM char usbDescriptorDevice[] = { + /* USB device descriptor */ + 18, /* sizeof(usbDescriptorDevice): length of descriptor in bytes */ + USBDESCR_DEVICE, /* descriptor type */ + 0x10, 0x01, /* USB version supported */ + USB_CFG_DEVICE_CLASS, USB_CFG_DEVICE_SUBCLASS, 0, /* protocol */ + 8, /* max packet size */ /* the following two casts affect the first byte of the constant only, but * that's sufficient to avoid a warning with the default values. */ - (char)USB_CFG_VENDOR_ID,/* 2 bytes */ - (char)USB_CFG_DEVICE_ID,/* 2 bytes */ - USB_CFG_DEVICE_VERSION, /* 2 bytes */ - USB_CFG_DESCR_PROPS_STRING_VENDOR != 0 ? 1 : 0, /* manufacturer string index */ - USB_CFG_DESCR_PROPS_STRING_PRODUCT != 0 ? 2 : 0, /* product string index */ - USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER != 0 ? 3 : 0, /* serial number string index */ - 1, /* number of configurations */ + (char)USB_CFG_VENDOR_ID, /* 2 bytes */ + (char)USB_CFG_DEVICE_ID, /* 2 bytes */ + USB_CFG_DEVICE_VERSION, /* 2 bytes */ + USB_CFG_DESCR_PROPS_STRING_VENDOR != 0 ? 1 : 0, /* manufacturer string index */ + USB_CFG_DESCR_PROPS_STRING_PRODUCT != 0 ? 2 : 0, /* product string index */ + USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER != 0 ? 3 : 0, /* serial number string index */ + 1, /* number of configurations */ }; #endif /* ----------------------- Configuration Descriptor ------------------------ */ #if USB_CFG_DESCR_PROPS_HID_REPORT != 0 && USB_CFG_DESCR_PROPS_HID == 0 -#undef USB_CFG_DESCR_PROPS_HID -#define USB_CFG_DESCR_PROPS_HID 9 /* length of HID descriptor in config descriptor below */ +# undef USB_CFG_DESCR_PROPS_HID +# define USB_CFG_DESCR_PROPS_HID 9 /* length of HID descriptor in config descriptor below */ #endif #if USB_CFG_DESCR_PROPS_CONFIGURATION == 0 -#undef USB_CFG_DESCR_PROPS_CONFIGURATION -#define USB_CFG_DESCR_PROPS_CONFIGURATION sizeof(usbDescriptorConfiguration) -PROGMEM char usbDescriptorConfiguration[] = { /* USB configuration descriptor */ - 9, /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */ - USBDESCR_CONFIG, /* descriptor type */ - 18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 + - (USB_CFG_DESCR_PROPS_HID & 0xff), 0, - /* total length of data returned (including inlined descriptors) */ - 1, /* number of interfaces in this configuration */ - 1, /* index of this configuration */ - 0, /* configuration name string index */ -#if USB_CFG_IS_SELF_POWERED - (1 << 7) | USBATTR_SELFPOWER, /* attributes */ -#else - (1 << 7), /* attributes */ -#endif - USB_CFG_MAX_BUS_POWER/2, /* max USB current in 2mA units */ -/* interface descriptor follows inline: */ - 9, /* sizeof(usbDescrInterface): length of descriptor in bytes */ - USBDESCR_INTERFACE, /* descriptor type */ - 0, /* index of this interface */ - 0, /* alternate setting for this interface */ - USB_CFG_HAVE_INTRIN_ENDPOINT + USB_CFG_HAVE_INTRIN_ENDPOINT3, /* endpoints excl 0: number of endpoint descriptors to follow */ - USB_CFG_INTERFACE_CLASS, - USB_CFG_INTERFACE_SUBCLASS, - USB_CFG_INTERFACE_PROTOCOL, - 0, /* string index for interface */ -#if (USB_CFG_DESCR_PROPS_HID & 0xff) /* HID descriptor */ - 9, /* sizeof(usbDescrHID): length of descriptor in bytes */ - USBDESCR_HID, /* descriptor type: HID */ - 0x01, 0x01, /* BCD representation of HID version */ - 0x00, /* target country code */ - 0x01, /* number of HID Report (or other HID class) Descriptor infos to follow */ - 0x22, /* descriptor type: report */ - USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH, 0, /* total length of report descriptor */ -#endif -#if USB_CFG_HAVE_INTRIN_ENDPOINT /* endpoint descriptor for endpoint 1 */ - 7, /* sizeof(usbDescrEndpoint) */ - USBDESCR_ENDPOINT, /* descriptor type = endpoint */ - (char)0x81, /* IN endpoint number 1 */ - 0x03, /* attrib: Interrupt endpoint */ - 8, 0, /* maximum packet size */ - USB_CFG_INTR_POLL_INTERVAL, /* in ms */ -#endif -#if USB_CFG_HAVE_INTRIN_ENDPOINT3 /* endpoint descriptor for endpoint 3 */ - 7, /* sizeof(usbDescrEndpoint) */ - USBDESCR_ENDPOINT, /* descriptor type = endpoint */ +# undef USB_CFG_DESCR_PROPS_CONFIGURATION +# define USB_CFG_DESCR_PROPS_CONFIGURATION sizeof(usbDescriptorConfiguration) +PROGMEM char usbDescriptorConfiguration[] = { + /* USB configuration descriptor */ + 9, /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */ + USBDESCR_CONFIG, /* descriptor type */ + 18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 + (USB_CFG_DESCR_PROPS_HID & 0xff), 0, + /* total length of data returned (including inlined descriptors) */ + 1, /* number of interfaces in this configuration */ + 1, /* index of this configuration */ + 0, /* configuration name string index */ +# if USB_CFG_IS_SELF_POWERED + (1 << 7) | USBATTR_SELFPOWER, /* attributes */ +# else + (1 << 7), /* attributes */ +# endif + USB_CFG_MAX_BUS_POWER / 2, /* max USB current in 2mA units */ + /* interface descriptor follows inline: */ + 9, /* sizeof(usbDescrInterface): length of descriptor in bytes */ + USBDESCR_INTERFACE, /* descriptor type */ + 0, /* index of this interface */ + 0, /* alternate setting for this interface */ + USB_CFG_HAVE_INTRIN_ENDPOINT + USB_CFG_HAVE_INTRIN_ENDPOINT3, /* endpoints excl 0: number of endpoint descriptors to follow */ + USB_CFG_INTERFACE_CLASS, USB_CFG_INTERFACE_SUBCLASS, USB_CFG_INTERFACE_PROTOCOL, 0, /* string index for interface */ +# if (USB_CFG_DESCR_PROPS_HID & 0xff) /* HID descriptor */ + 9, /* sizeof(usbDescrHID): length of descriptor in bytes */ + USBDESCR_HID, /* descriptor type: HID */ + 0x01, 0x01, /* BCD representation of HID version */ + 0x00, /* target country code */ + 0x01, /* number of HID Report (or other HID class) Descriptor infos to follow */ + 0x22, /* descriptor type: report */ + USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH, 0, /* total length of report descriptor */ +# endif +# if USB_CFG_HAVE_INTRIN_ENDPOINT /* endpoint descriptor for endpoint 1 */ + 7, /* sizeof(usbDescrEndpoint) */ + USBDESCR_ENDPOINT, /* descriptor type = endpoint */ + (char)0x81, /* IN endpoint number 1 */ + 0x03, /* attrib: Interrupt endpoint */ + 8, 0, /* maximum packet size */ + USB_CFG_INTR_POLL_INTERVAL, /* in ms */ +# endif +# if USB_CFG_HAVE_INTRIN_ENDPOINT3 /* endpoint descriptor for endpoint 3 */ + 7, /* sizeof(usbDescrEndpoint) */ + USBDESCR_ENDPOINT, /* descriptor type = endpoint */ (char)(0x80 | USB_CFG_EP3_NUMBER), /* IN endpoint number 3 */ - 0x03, /* attrib: Interrupt endpoint */ - 8, 0, /* maximum packet size */ - USB_CFG_INTR_POLL_INTERVAL, /* in ms */ -#endif + 0x03, /* attrib: Interrupt endpoint */ + 8, 0, /* maximum packet size */ + USB_CFG_INTR_POLL_INTERVAL, /* in ms */ +# endif }; #endif /* ------------------------------------------------------------------------- */ -static inline void usbResetDataToggling(void) -{ +static inline void usbResetDataToggling(void) { #if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE - USB_SET_DATATOKEN1(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */ -# if USB_CFG_HAVE_INTRIN_ENDPOINT3 - USB_SET_DATATOKEN3(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */ -# endif + USB_SET_DATATOKEN1(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */ +# if USB_CFG_HAVE_INTRIN_ENDPOINT3 + USB_SET_DATATOKEN3(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */ +# endif #endif } -static inline void usbResetStall(void) -{ +static inline void usbResetStall(void) { #if USB_CFG_IMPLEMENT_HALT && USB_CFG_HAVE_INTRIN_ENDPOINT - usbTxLen1 = USBPID_NAK; -#if USB_CFG_HAVE_INTRIN_ENDPOINT3 - usbTxLen3 = USBPID_NAK; -#endif + usbTxLen1 = USBPID_NAK; +# if USB_CFG_HAVE_INTRIN_ENDPOINT3 + usbTxLen3 = USBPID_NAK; +# endif #endif } /* ------------------------------------------------------------------------- */ #if !USB_CFG_SUPPRESS_INTR_CODE -#if USB_CFG_HAVE_INTRIN_ENDPOINT -static void usbGenericSetInterrupt(uchar *data, uchar len, usbTxStatus_t *txStatus) -{ -uchar *p; -char i; - -#if USB_CFG_IMPLEMENT_HALT - if(usbTxLen1 == USBPID_STALL) - return; -#endif - if(txStatus->len & 0x10){ /* packet buffer was empty */ +# if USB_CFG_HAVE_INTRIN_ENDPOINT +static void usbGenericSetInterrupt(uchar *data, uchar len, usbTxStatus_t *txStatus) { + uchar *p; + char i; + +# if USB_CFG_IMPLEMENT_HALT + if (usbTxLen1 == USBPID_STALL) return; +# endif + if (txStatus->len & 0x10) { /* packet buffer was empty */ txStatus->buffer[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* toggle token */ - }else{ + } else { txStatus->len = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */ } p = txStatus->buffer + 1; i = len; - do{ /* if len == 0, we still copy 1 byte, but that's no problem */ + do { /* if len == 0, we still copy 1 byte, but that's no problem */ *p++ = *data++; - }while(--i > 0); /* loop control at the end is 2 bytes shorter than at beginning */ + } while (--i > 0); /* loop control at the end is 2 bytes shorter than at beginning */ usbCrc16Append(&txStatus->buffer[1], len); - txStatus->len = len + 4; /* len must be given including sync byte */ + txStatus->len = len + 4; /* len must be given including sync byte */ DBG2(0x21 + (((int)txStatus >> 3) & 3), txStatus->buffer, len + 3); } -USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len) -{ - usbGenericSetInterrupt(data, len, &usbTxStatus1); -} -#endif +USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len) { usbGenericSetInterrupt(data, len, &usbTxStatus1); } +# endif -#if USB_CFG_HAVE_INTRIN_ENDPOINT3 -USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len) -{ - usbGenericSetInterrupt(data, len, &usbTxStatus3); -} -#endif +# if USB_CFG_HAVE_INTRIN_ENDPOINT3 +USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len) { usbGenericSetInterrupt(data, len, &usbTxStatus3); } +# endif #endif /* USB_CFG_SUPPRESS_INTR_CODE */ /* ------------------ utilities for code following below ------------------- */ @@ -264,26 +242,58 @@ USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len) * cases. */ #if USB_CFG_USE_SWITCH_STATEMENT -# define SWITCH_START(cmd) switch(cmd){{ -# define SWITCH_CASE(value) }break; case (value):{ -# define SWITCH_CASE2(v1,v2) }break; case (v1): case(v2):{ -# define SWITCH_CASE3(v1,v2,v3) }break; case (v1): case(v2): case(v3):{ -# define SWITCH_DEFAULT }break; default:{ -# define SWITCH_END }} +# define SWITCH_START(cmd) \ + switch (cmd) { \ + { +# define SWITCH_CASE(value) \ + } \ + break; \ + case (value): { +# define SWITCH_CASE2(v1, v2) \ + } \ + break; \ + case (v1): \ + case (v2): { +# define SWITCH_CASE3(v1, v2, v3) \ + } \ + break; \ + case (v1): \ + case (v2): \ + case (v3): { +# define SWITCH_DEFAULT \ + } \ + break; \ + default: { +# define SWITCH_END \ + } \ + } #else -# define SWITCH_START(cmd) {uchar _cmd = cmd; if(0){ -# define SWITCH_CASE(value) }else if(_cmd == (value)){ -# define SWITCH_CASE2(v1,v2) }else if(_cmd == (v1) || _cmd == (v2)){ -# define SWITCH_CASE3(v1,v2,v3) }else if(_cmd == (v1) || _cmd == (v2) || (_cmd == v3)){ -# define SWITCH_DEFAULT }else{ -# define SWITCH_END }} +# define SWITCH_START(cmd) \ + { \ + uchar _cmd = cmd; \ + if (0) { +# define SWITCH_CASE(value) \ + } \ + else if (_cmd == (value)) { +# define SWITCH_CASE2(v1, v2) \ + } \ + else if (_cmd == (v1) || _cmd == (v2)) { +# define SWITCH_CASE3(v1, v2, v3) \ + } \ + else if (_cmd == (v1) || _cmd == (v2) || (_cmd == v3)) { +# define SWITCH_DEFAULT \ + } \ + else { +# define SWITCH_END \ + } \ + } #endif #ifndef USB_RX_USER_HOOK -#define USB_RX_USER_HOOK(data, len) +# define USB_RX_USER_HOOK(data, len) #endif #ifndef USB_SET_ADDRESS_HOOK -#define USB_SET_ADDRESS_HOOK() +# define USB_SET_ADDRESS_HOOK() #endif /* ------------------------------------------------------------------------- */ @@ -293,62 +303,59 @@ USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len) * This may cause problems with undefined symbols if compiled without * optimizing! */ -#define GET_DESCRIPTOR(cfgProp, staticName) \ - if(cfgProp){ \ - if((cfgProp) & USB_PROP_IS_RAM) \ - flags = 0; \ - if((cfgProp) & USB_PROP_IS_DYNAMIC){ \ - len = usbFunctionDescriptor(rq); \ - }else{ \ - len = USB_PROP_LENGTH(cfgProp); \ - usbMsgPtr = (uchar *)(staticName); \ - } \ +#define GET_DESCRIPTOR(cfgProp, staticName) \ + if (cfgProp) { \ + if ((cfgProp)&USB_PROP_IS_RAM) flags = 0; \ + if ((cfgProp)&USB_PROP_IS_DYNAMIC) { \ + len = usbFunctionDescriptor(rq); \ + } else { \ + len = USB_PROP_LENGTH(cfgProp); \ + usbMsgPtr = (uchar *)(staticName); \ + } \ } /* usbDriverDescriptor() is similar to usbFunctionDescriptor(), but used * internally for all types of descriptors. */ -static inline usbMsgLen_t usbDriverDescriptor(usbRequest_t *rq) -{ -usbMsgLen_t len = 0; -uchar flags = USB_FLG_MSGPTR_IS_ROM; +static inline usbMsgLen_t usbDriverDescriptor(usbRequest_t *rq) { + usbMsgLen_t len = 0; + uchar flags = USB_FLG_MSGPTR_IS_ROM; SWITCH_START(rq->wValue.bytes[1]) - SWITCH_CASE(USBDESCR_DEVICE) /* 1 */ - GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_DEVICE, usbDescriptorDevice) - SWITCH_CASE(USBDESCR_CONFIG) /* 2 */ - GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_CONFIGURATION, usbDescriptorConfiguration) - SWITCH_CASE(USBDESCR_STRING) /* 3 */ + SWITCH_CASE(USBDESCR_DEVICE) /* 1 */ + GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_DEVICE, usbDescriptorDevice) + SWITCH_CASE(USBDESCR_CONFIG) /* 2 */ + GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_CONFIGURATION, usbDescriptorConfiguration) + SWITCH_CASE(USBDESCR_STRING) /* 3 */ #if USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC - if(USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_RAM) - flags = 0; + if (USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_RAM) flags = 0; + len = usbFunctionDescriptor(rq); +#else /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */ + SWITCH_START(rq->wValue.bytes[0]) + SWITCH_CASE(0) + GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_0, usbDescriptorString0) + SWITCH_CASE(1) + GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_VENDOR, usbDescriptorStringVendor) + SWITCH_CASE(2) + GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_PRODUCT, usbDescriptorStringDevice) + SWITCH_CASE(3) + GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER, usbDescriptorStringSerialNumber) + SWITCH_DEFAULT + if (USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC) { len = usbFunctionDescriptor(rq); -#else /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */ - SWITCH_START(rq->wValue.bytes[0]) - SWITCH_CASE(0) - GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_0, usbDescriptorString0) - SWITCH_CASE(1) - GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_VENDOR, usbDescriptorStringVendor) - SWITCH_CASE(2) - GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_PRODUCT, usbDescriptorStringDevice) - SWITCH_CASE(3) - GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER, usbDescriptorStringSerialNumber) - SWITCH_DEFAULT - if(USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC){ - len = usbFunctionDescriptor(rq); - } - SWITCH_END -#endif /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */ -#if USB_CFG_DESCR_PROPS_HID_REPORT /* only support HID descriptors if enabled */ - SWITCH_CASE(USBDESCR_HID) /* 0x21 */ - GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID, usbDescriptorConfiguration + 18) - SWITCH_CASE(USBDESCR_HID_REPORT)/* 0x22 */ - GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID_REPORT, usbDescriptorHidReport) + } + SWITCH_END +#endif /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */ +#if USB_CFG_DESCR_PROPS_HID_REPORT /* only support HID descriptors if enabled */ + SWITCH_CASE(USBDESCR_HID) /* 0x21 */ + GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID, usbDescriptorConfiguration + 18) + SWITCH_CASE(USBDESCR_HID_REPORT) /* 0x22 */ + GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID_REPORT, usbDescriptorHidReport) #endif SWITCH_DEFAULT - if(USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC){ - len = usbFunctionDescriptor(rq); - } + if (USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC) { + len = usbFunctionDescriptor(rq); + } SWITCH_END usbMsgFlags = flags; return len; @@ -359,56 +366,53 @@ uchar flags = USB_FLG_MSGPTR_IS_ROM; /* usbDriverSetup() is similar to usbFunctionSetup(), but it's used for * standard requests instead of class and custom requests. */ -static inline usbMsgLen_t usbDriverSetup(usbRequest_t *rq) -{ -uchar len = 0, *dataPtr = usbTxBuf + 9; /* there are 2 bytes free space at the end of the buffer */ -uchar value = rq->wValue.bytes[0]; +static inline usbMsgLen_t usbDriverSetup(usbRequest_t *rq) { + uchar len = 0, *dataPtr = usbTxBuf + 9; /* there are 2 bytes free space at the end of the buffer */ + uchar value = rq->wValue.bytes[0]; #if USB_CFG_IMPLEMENT_HALT -uchar index = rq->wIndex.bytes[0]; + uchar index = rq->wIndex.bytes[0]; #endif dataPtr[0] = 0; /* default reply common to USBRQ_GET_STATUS and USBRQ_GET_INTERFACE */ SWITCH_START(rq->bRequest) - SWITCH_CASE(USBRQ_GET_STATUS) /* 0 */ - uchar recipient = rq->bmRequestType & USBRQ_RCPT_MASK; /* assign arith ops to variables to enforce byte size */ - if(USB_CFG_IS_SELF_POWERED && recipient == USBRQ_RCPT_DEVICE) - dataPtr[0] = USB_CFG_IS_SELF_POWERED; + SWITCH_CASE(USBRQ_GET_STATUS) /* 0 */ + uchar recipient = rq->bmRequestType & USBRQ_RCPT_MASK; /* assign arith ops to variables to enforce byte size */ + if (USB_CFG_IS_SELF_POWERED && recipient == USBRQ_RCPT_DEVICE) dataPtr[0] = USB_CFG_IS_SELF_POWERED; #if USB_CFG_IMPLEMENT_HALT - if(recipient == USBRQ_RCPT_ENDPOINT && index == 0x81) /* request status for endpoint 1 */ - dataPtr[0] = usbTxLen1 == USBPID_STALL; + if (recipient == USBRQ_RCPT_ENDPOINT && index == 0x81) /* request status for endpoint 1 */ + dataPtr[0] = usbTxLen1 == USBPID_STALL; #endif - dataPtr[1] = 0; - len = 2; + dataPtr[1] = 0; + len = 2; #if USB_CFG_IMPLEMENT_HALT - SWITCH_CASE2(USBRQ_CLEAR_FEATURE, USBRQ_SET_FEATURE) /* 1, 3 */ - if(value == 0 && index == 0x81){ /* feature 0 == HALT for endpoint == 1 */ - usbTxLen1 = rq->bRequest == USBRQ_CLEAR_FEATURE ? USBPID_NAK : USBPID_STALL; - usbResetDataToggling(); - } + SWITCH_CASE2(USBRQ_CLEAR_FEATURE, USBRQ_SET_FEATURE) /* 1, 3 */ + if (value == 0 && index == 0x81) { /* feature 0 == HALT for endpoint == 1 */ + usbTxLen1 = rq->bRequest == USBRQ_CLEAR_FEATURE ? USBPID_NAK : USBPID_STALL; + usbResetDataToggling(); + } #endif - SWITCH_CASE(USBRQ_SET_ADDRESS) /* 5 */ - usbNewDeviceAddr = value; - USB_SET_ADDRESS_HOOK(); - SWITCH_CASE(USBRQ_GET_DESCRIPTOR) /* 6 */ - len = usbDriverDescriptor(rq); - goto skipMsgPtrAssignment; - SWITCH_CASE(USBRQ_GET_CONFIGURATION) /* 8 */ - dataPtr = &usbConfiguration; /* send current configuration value */ - len = 1; - SWITCH_CASE(USBRQ_SET_CONFIGURATION) /* 9 */ - usbConfiguration = value; - usbResetStall(); - SWITCH_CASE(USBRQ_GET_INTERFACE) /* 10 */ - len = 1; + SWITCH_CASE(USBRQ_SET_ADDRESS) /* 5 */ + usbNewDeviceAddr = value; + USB_SET_ADDRESS_HOOK(); + SWITCH_CASE(USBRQ_GET_DESCRIPTOR) /* 6 */ + len = usbDriverDescriptor(rq); + goto skipMsgPtrAssignment; + SWITCH_CASE(USBRQ_GET_CONFIGURATION) /* 8 */ + dataPtr = &usbConfiguration; /* send current configuration value */ + len = 1; + SWITCH_CASE(USBRQ_SET_CONFIGURATION) /* 9 */ + usbConfiguration = value; + usbResetStall(); + SWITCH_CASE(USBRQ_GET_INTERFACE) /* 10 */ + len = 1; #if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE - SWITCH_CASE(USBRQ_SET_INTERFACE) /* 11 */ - usbResetDataToggling(); - usbResetStall(); + SWITCH_CASE(USBRQ_SET_INTERFACE) /* 11 */ + usbResetDataToggling(); + usbResetStall(); #endif - SWITCH_DEFAULT /* 7=SET_DESCRIPTOR, 12=SYNC_FRAME */ + SWITCH_DEFAULT /* 7=SET_DESCRIPTOR, 12=SYNC_FRAME */ /* Should we add an optional hook here? */ - SWITCH_END - usbMsgPtr = dataPtr; + SWITCH_END usbMsgPtr = dataPtr; skipMsgPtrAssignment: return len; } @@ -419,65 +423,64 @@ skipMsgPtrAssignment: * routine. It distinguishes between SETUP and DATA packets and processes * them accordingly. */ -static inline void usbProcessRx(uchar *data, uchar len) -{ -usbRequest_t *rq = (void *)data; - -/* usbRxToken can be: - * 0x2d 00101101 (USBPID_SETUP for setup data) - * 0xe1 11100001 (USBPID_OUT: data phase of setup transfer) - * 0...0x0f for OUT on endpoint X - */ +static inline void usbProcessRx(uchar *data, uchar len) { + usbRequest_t *rq = (void *)data; + + /* usbRxToken can be: + * 0x2d 00101101 (USBPID_SETUP for setup data) + * 0xe1 11100001 (USBPID_OUT: data phase of setup transfer) + * 0...0x0f for OUT on endpoint X + */ DBG2(0x10 + (usbRxToken & 0xf), data, len + 2); /* SETUP=1d, SETUP-DATA=11, OUTx=1x */ USB_RX_USER_HOOK(data, len) #if USB_CFG_IMPLEMENT_FN_WRITEOUT - if(usbRxToken < 0x10){ /* OUT to endpoint != 0: endpoint number in usbRxToken */ + if (usbRxToken < 0x10) { /* OUT to endpoint != 0: endpoint number in usbRxToken */ usbFunctionWriteOut(data, len); return; } #endif - if(usbRxToken == (uchar)USBPID_SETUP){ - if(len != 8) /* Setup size must be always 8 bytes. Ignore otherwise. */ + if (usbRxToken == (uchar)USBPID_SETUP) { + if (len != 8) /* Setup size must be always 8 bytes. Ignore otherwise. */ return; usbMsgLen_t replyLen; - usbTxBuf[0] = USBPID_DATA0; /* initialize data toggling */ - usbTxLen = USBPID_NAK; /* abort pending transmit */ + usbTxBuf[0] = USBPID_DATA0; /* initialize data toggling */ + usbTxLen = USBPID_NAK; /* abort pending transmit */ usbMsgFlags = 0; - uchar type = rq->bmRequestType & USBRQ_TYPE_MASK; - if(type != USBRQ_TYPE_STANDARD){ /* standard requests are handled by driver */ + uchar type = rq->bmRequestType & USBRQ_TYPE_MASK; + if (type != USBRQ_TYPE_STANDARD) { /* standard requests are handled by driver */ replyLen = usbFunctionSetup(data); - }else{ + } else { replyLen = usbDriverSetup(rq); } #if USB_CFG_IMPLEMENT_FN_READ || USB_CFG_IMPLEMENT_FN_WRITE - if(replyLen == USB_NO_MSG){ /* use user-supplied read/write function */ + if (replyLen == USB_NO_MSG) { /* use user-supplied read/write function */ /* do some conditioning on replyLen, but on IN transfers only */ - if((rq->bmRequestType & USBRQ_DIR_MASK) != USBRQ_DIR_HOST_TO_DEVICE){ - if(sizeof(replyLen) < sizeof(rq->wLength.word)){ /* help compiler with optimizing */ + if ((rq->bmRequestType & USBRQ_DIR_MASK) != USBRQ_DIR_HOST_TO_DEVICE) { + if (sizeof(replyLen) < sizeof(rq->wLength.word)) { /* help compiler with optimizing */ replyLen = rq->wLength.bytes[0]; - }else{ + } else { replyLen = rq->wLength.word; } } usbMsgFlags = USB_FLG_USE_USER_RW; - }else /* The 'else' prevents that we limit a replyLen of USB_NO_MSG to the maximum transfer len. */ + } else /* The 'else' prevents that we limit a replyLen of USB_NO_MSG to the maximum transfer len. */ #endif - if(sizeof(replyLen) < sizeof(rq->wLength.word)){ /* help compiler with optimizing */ - if(!rq->wLength.bytes[1] && replyLen > rq->wLength.bytes[0]) /* limit length to max */ + if (sizeof(replyLen) < sizeof(rq->wLength.word)) { /* help compiler with optimizing */ + if (!rq->wLength.bytes[1] && replyLen > rq->wLength.bytes[0]) /* limit length to max */ replyLen = rq->wLength.bytes[0]; - }else{ - if(replyLen > rq->wLength.word) /* limit length to max */ + } else { + if (replyLen > rq->wLength.word) /* limit length to max */ replyLen = rq->wLength.word; } usbMsgLen = replyLen; - }else{ /* usbRxToken must be USBPID_OUT, which means data phase of setup (control-out) */ + } else { /* usbRxToken must be USBPID_OUT, which means data phase of setup (control-out) */ #if USB_CFG_IMPLEMENT_FN_WRITE - if(usbMsgFlags & USB_FLG_USE_USER_RW){ + if (usbMsgFlags & USB_FLG_USE_USER_RW) { uchar rval = usbFunctionWrite(data, len); - if(rval == 0xff){ /* an error occurred */ + if (rval == 0xff) { /* an error occurred */ usbTxLen = USBPID_STALL; - }else if(rval != 0){ /* This was the final package */ - usbMsgLen = 0; /* answer with a zero-sized data packet */ + } else if (rval != 0) { /* This was the final package */ + usbMsgLen = 0; /* answer with a zero-sized data packet */ } } #endif @@ -489,26 +492,25 @@ usbRequest_t *rq = (void *)data; /* This function is similar to usbFunctionRead(), but it's also called for * data handled automatically by the driver (e.g. descriptor reads). */ -static uchar usbDeviceRead(uchar *data, uchar len) -{ - if(len > 0){ /* don't bother app with 0 sized reads */ +static uchar usbDeviceRead(uchar *data, uchar len) { + if (len > 0) { /* don't bother app with 0 sized reads */ #if USB_CFG_IMPLEMENT_FN_READ - if(usbMsgFlags & USB_FLG_USE_USER_RW){ + if (usbMsgFlags & USB_FLG_USE_USER_RW) { len = usbFunctionRead(data, len); - }else + } else #endif { uchar i = len, *r = usbMsgPtr; - if(usbMsgFlags & USB_FLG_MSGPTR_IS_ROM){ /* ROM data */ - do{ - uchar c = USB_READ_FLASH(r); /* assign to char size variable to enforce byte ops */ + if (usbMsgFlags & USB_FLG_MSGPTR_IS_ROM) { /* ROM data */ + do { + uchar c = USB_READ_FLASH(r); /* assign to char size variable to enforce byte ops */ *data++ = c; r++; - }while(--i); - }else{ /* RAM data */ - do{ + } while (--i); + } else { /* RAM data */ + do { *data++ = *r++; - }while(--i); + } while (--i); } usbMsgPtr = r; } @@ -521,39 +523,36 @@ static uchar usbDeviceRead(uchar *data, uchar len) /* usbBuildTxBlock() is called when we have data to transmit and the * interrupt routine's transmit buffer is empty. */ -static inline void usbBuildTxBlock(void) -{ -usbMsgLen_t wantLen; -uchar len; +static inline void usbBuildTxBlock(void) { + usbMsgLen_t wantLen; + uchar len; wantLen = usbMsgLen; - if(wantLen > 8) - wantLen = 8; + if (wantLen > 8) wantLen = 8; usbMsgLen -= wantLen; usbTxBuf[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* DATA toggling */ len = usbDeviceRead(usbTxBuf + 1, wantLen); - if(len <= 8){ /* valid data packet */ + if (len <= 8) { /* valid data packet */ usbCrc16Append(&usbTxBuf[1], len); - len += 4; /* length including sync byte */ - if(len < 12) /* a partial package identifies end of message */ + len += 4; /* length including sync byte */ + if (len < 12) /* a partial package identifies end of message */ usbMsgLen = USB_NO_MSG; - }else{ - len = USBPID_STALL; /* stall the endpoint */ + } else { + len = USBPID_STALL; /* stall the endpoint */ usbMsgLen = USB_NO_MSG; } usbTxLen = len; - DBG2(0x20, usbTxBuf, len-1); + DBG2(0x20, usbTxBuf, len - 1); } /* ------------------------------------------------------------------------- */ -static inline void usbHandleResetHook(uchar notResetState) -{ +static inline void usbHandleResetHook(uchar notResetState) { #ifdef USB_RESET_HOOK -static uchar wasReset; -uchar isReset = !notResetState; + static uchar wasReset; + uchar isReset = !notResetState; - if(wasReset != isReset){ + if (wasReset != isReset) { USB_RESET_HOOK(isReset); wasReset = isReset; } @@ -562,40 +561,39 @@ uchar isReset = !notResetState; /* ------------------------------------------------------------------------- */ -USB_PUBLIC void usbPoll(void) -{ -schar len; -uchar i; +USB_PUBLIC void usbPoll(void) { + schar len; + uchar i; len = usbRxLen - 3; - if(len >= 0){ -/* We could check CRC16 here -- but ACK has already been sent anyway. If you - * need data integrity checks with this driver, check the CRC in your app - * code and report errors back to the host. Since the ACK was already sent, - * retries must be handled on application level. - * unsigned crc = usbCrc16(buffer + 1, usbRxLen - 3); - */ + if (len >= 0) { + /* We could check CRC16 here -- but ACK has already been sent anyway. If you + * need data integrity checks with this driver, check the CRC in your app + * code and report errors back to the host. Since the ACK was already sent, + * retries must be handled on application level. + * unsigned crc = usbCrc16(buffer + 1, usbRxLen - 3); + */ usbProcessRx(usbRxBuf + USB_BUFSIZE + 1 - usbInputBufOffset, len); #if USB_CFG_HAVE_FLOWCONTROL - if(usbRxLen > 0) /* only mark as available if not inactivated */ + if (usbRxLen > 0) /* only mark as available if not inactivated */ usbRxLen = 0; #else - usbRxLen = 0; /* mark rx buffer as available */ + usbRxLen = 0; /* mark rx buffer as available */ #endif } - if(usbTxLen & 0x10){ /* transmit system idle */ - if(usbMsgLen != USB_NO_MSG){ /* transmit data pending? */ + if (usbTxLen & 0x10) { /* transmit system idle */ + if (usbMsgLen != USB_NO_MSG) { /* transmit data pending? */ usbBuildTxBlock(); } } - for(i = 20; i > 0; i--){ + for (i = 20; i > 0; i--) { uchar usbLineStatus = USBIN & USBMASK; - if(usbLineStatus != 0) /* SE0 has ended */ + if (usbLineStatus != 0) /* SE0 has ended */ goto isNotReset; } /* RESET condition, called multiple times during reset */ usbNewDeviceAddr = 0; - usbDeviceAddr = 0; + usbDeviceAddr = 0; usbResetStall(); DBG1(0xff, 0, 0); isNotReset: @@ -604,8 +602,7 @@ isNotReset: /* ------------------------------------------------------------------------- */ -USB_PUBLIC void usbInit(void) -{ +USB_PUBLIC void usbInit(void) { #if USB_INTR_CFG_SET != 0 USB_INTR_CFG |= USB_INTR_CFG_SET; #endif @@ -616,9 +613,9 @@ USB_PUBLIC void usbInit(void) usbResetDataToggling(); #if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE usbTxLen1 = USBPID_NAK; -#if USB_CFG_HAVE_INTRIN_ENDPOINT3 +# if USB_CFG_HAVE_INTRIN_ENDPOINT3 usbTxLen3 = USBPID_NAK; -#endif +# endif #endif } diff --git a/tmk_core/protocol/vusb/usbdrv/usbdrv.h b/tmk_core/protocol/vusb/usbdrv/usbdrv.h index 42fe163720..88a1bce76e 100644 --- a/tmk_core/protocol/vusb/usbdrv/usbdrv.h +++ b/tmk_core/protocol/vusb/usbdrv/usbdrv.h @@ -122,7 +122,7 @@ USB messages, even if they address another (low-speed) device on the same bus. /* --------------------------- Module Interface ---------------------------- */ /* ------------------------------------------------------------------------- */ -#define USBDRV_VERSION 20100715 +#define USBDRV_VERSION 20100715 /* This define uniquely identifies a driver version. It is a decimal number * constructed from the driver's release date in the form YYYYMMDD. If the * driver's behavior or interface changes, you can use this constant to @@ -130,9 +130,8 @@ USB messages, even if they address another (low-speed) device on the same bus. * older than 2006-01-25. */ - #ifndef USB_PUBLIC -#define USB_PUBLIC +# define USB_PUBLIC #endif /* USB_PUBLIC is used as declaration attribute for all functions exported by * the USB driver. The default is no attribute (see above). You may define it @@ -142,28 +141,28 @@ USB messages, even if they address another (low-speed) device on the same bus. */ #ifndef __ASSEMBLER__ -#ifndef uchar -#define uchar unsigned char -#endif -#ifndef schar -#define schar signed char -#endif +# ifndef uchar +# define uchar unsigned char +# endif +# ifndef schar +# define schar signed char +# endif /* shortcuts for well defined 8 bit integer types */ -#if USB_CFG_LONG_TRANSFERS /* if more than 254 bytes transfer size required */ -# define usbMsgLen_t unsigned -#else -# define usbMsgLen_t uchar -#endif +# if USB_CFG_LONG_TRANSFERS /* if more than 254 bytes transfer size required */ +# define usbMsgLen_t unsigned +# else +# define usbMsgLen_t uchar +# endif /* usbMsgLen_t is the data type used for transfer lengths. By default, it is * defined to uchar, allowing a maximum of 254 bytes (255 is reserved for * USB_NO_MSG below). If the usbconfig.h defines USB_CFG_LONG_TRANSFERS to 1, * a 16 bit data type is used, allowing up to 16384 bytes (the rest is used * for flags in the descriptor configuration). */ -#define USB_NO_MSG ((usbMsgLen_t)-1) /* constant meaning "no message" */ +# define USB_NO_MSG ((usbMsgLen_t)-1) /* constant meaning "no message" */ -struct usbRequest; /* forward declaration */ +struct usbRequest; /* forward declaration */ USB_PUBLIC void usbInit(void); /* This function must be called before interrupts are enabled and the main @@ -216,7 +215,7 @@ USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq); * usbFunctionSetup() above, but it is called only to request USB descriptor * data. See the documentation of usbFunctionSetup() above for more info. */ -#if USB_CFG_HAVE_INTRIN_ENDPOINT +# if USB_CFG_HAVE_INTRIN_ENDPOINT USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len); /* This function sets the message which will be sent during the next interrupt * IN transfer. The message is copied to an internal buffer and must not exceed @@ -224,19 +223,19 @@ USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len); * interrupt status to the host. * If you need to transfer more bytes, use a control read after the interrupt. */ -#define usbInterruptIsReady() (usbTxLen1 & 0x10) +# define usbInterruptIsReady() (usbTxLen1 & 0x10) /* This macro indicates whether the last interrupt message has already been * sent. If you set a new interrupt message before the old was sent, the * message already buffered will be lost. */ -#if USB_CFG_HAVE_INTRIN_ENDPOINT3 +# if USB_CFG_HAVE_INTRIN_ENDPOINT3 USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len); -#define usbInterruptIsReady3() (usbTxLen3 & 0x10) +# define usbInterruptIsReady3() (usbTxLen3 & 0x10) /* Same as above for endpoint 3 */ -#endif -#endif /* USB_CFG_HAVE_INTRIN_ENDPOINT */ -#if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* simplified interface for backward compatibility */ -#define usbHidReportDescriptor usbDescriptorHidReport +# endif +# endif /* USB_CFG_HAVE_INTRIN_ENDPOINT */ +# if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* simplified interface for backward compatibility */ +# define usbHidReportDescriptor usbDescriptorHidReport /* should be declared as: PROGMEM char usbHidReportDescriptor[]; */ /* If you implement an HID device, you need to provide a report descriptor. * The HID report descriptor syntax is a bit complex. If you understand how @@ -244,8 +243,8 @@ USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len); * Descriptor Tool from usb.org, see http://www.usb.org/developers/hidpage/. * Otherwise you should probably start with a working example. */ -#endif /* USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH */ -#if USB_CFG_IMPLEMENT_FN_WRITE +# endif /* USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH */ +# if USB_CFG_IMPLEMENT_FN_WRITE USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len); /* This function is called by the driver to provide a control transfer's * payload data (control-out). It is called in chunks of up to 8 bytes. The @@ -262,8 +261,8 @@ USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len); * In order to get usbFunctionWrite() called, define USB_CFG_IMPLEMENT_FN_WRITE * to 1 in usbconfig.h and return 0xff in usbFunctionSetup().. */ -#endif /* USB_CFG_IMPLEMENT_FN_WRITE */ -#if USB_CFG_IMPLEMENT_FN_READ +# endif /* USB_CFG_IMPLEMENT_FN_WRITE */ +# if USB_CFG_IMPLEMENT_FN_READ USB_PUBLIC uchar usbFunctionRead(uchar *data, uchar len); /* This function is called by the driver to ask the application for a control * transfer's payload data (control-in). It is called in chunks of up to 8 @@ -274,26 +273,24 @@ USB_PUBLIC uchar usbFunctionRead(uchar *data, uchar len); * In order to get usbFunctionRead() called, define USB_CFG_IMPLEMENT_FN_READ * to 1 in usbconfig.h and return 0xff in usbFunctionSetup().. */ -#endif /* USB_CFG_IMPLEMENT_FN_READ */ +# endif /* USB_CFG_IMPLEMENT_FN_READ */ -extern uchar usbRxToken; /* may be used in usbFunctionWriteOut() below */ -#if USB_CFG_IMPLEMENT_FN_WRITEOUT +extern uchar usbRxToken; /* may be used in usbFunctionWriteOut() below */ +# if USB_CFG_IMPLEMENT_FN_WRITEOUT USB_PUBLIC void usbFunctionWriteOut(uchar *data, uchar len); /* This function is called by the driver when data is received on an interrupt- * or bulk-out endpoint. The endpoint number can be found in the global * variable usbRxToken. You must define USB_CFG_IMPLEMENT_FN_WRITEOUT to 1 in * usbconfig.h to get this function called. */ -#endif /* USB_CFG_IMPLEMENT_FN_WRITEOUT */ -#ifdef USB_CFG_PULLUP_IOPORTNAME -#define usbDeviceConnect() ((USB_PULLUP_DDR |= (1<<USB_CFG_PULLUP_BIT)), \ - (USB_PULLUP_OUT |= (1<<USB_CFG_PULLUP_BIT))) -#define usbDeviceDisconnect() ((USB_PULLUP_DDR &= ~(1<<USB_CFG_PULLUP_BIT)), \ - (USB_PULLUP_OUT &= ~(1<<USB_CFG_PULLUP_BIT))) -#else /* USB_CFG_PULLUP_IOPORTNAME */ -#define usbDeviceConnect() (USBDDR &= ~(1<<USBMINUS)) -#define usbDeviceDisconnect() (USBDDR |= (1<<USBMINUS)) -#endif /* USB_CFG_PULLUP_IOPORTNAME */ +# endif /* USB_CFG_IMPLEMENT_FN_WRITEOUT */ +# ifdef USB_CFG_PULLUP_IOPORTNAME +# define usbDeviceConnect() ((USB_PULLUP_DDR |= (1 << USB_CFG_PULLUP_BIT)), (USB_PULLUP_OUT |= (1 << USB_CFG_PULLUP_BIT))) +# define usbDeviceDisconnect() ((USB_PULLUP_DDR &= ~(1 << USB_CFG_PULLUP_BIT)), (USB_PULLUP_OUT &= ~(1 << USB_CFG_PULLUP_BIT))) +# else /* USB_CFG_PULLUP_IOPORTNAME */ +# define usbDeviceConnect() (USBDDR &= ~(1 << USBMINUS)) +# define usbDeviceDisconnect() (USBDDR |= (1 << USBMINUS)) +# endif /* USB_CFG_PULLUP_IOPORTNAME */ /* The macros usbDeviceConnect() and usbDeviceDisconnect() (intended to look * like a function) connect resp. disconnect the device from the host's USB. * If the constants USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT are defined @@ -307,7 +304,7 @@ USB_PUBLIC void usbFunctionWriteOut(uchar *data, uchar len); * or use cli() to disable interrupts globally. */ extern unsigned usbCrc16(unsigned data, uchar len); -#define usbCrc16(data, len) usbCrc16((unsigned)(data), len) +# define usbCrc16(data, len) usbCrc16((unsigned)(data), len) /* This function calculates the binary complement of the data CRC used in * USB data packets. The value is used to build raw transmit packets. * You may want to use this function for data checksums or to verify received @@ -315,12 +312,12 @@ extern unsigned usbCrc16(unsigned data, uchar len); * tiny memory model. */ extern unsigned usbCrc16Append(unsigned data, uchar len); -#define usbCrc16Append(data, len) usbCrc16Append((unsigned)(data), len) +# define usbCrc16Append(data, len) usbCrc16Append((unsigned)(data), len) /* This function is equivalent to usbCrc16() above, except that it appends * the 2 bytes CRC (lowbyte first) in the 'data' buffer after reading 'len' * bytes. */ -#if USB_CFG_HAVE_MEASURE_FRAME_LENGTH +# if USB_CFG_HAVE_MEASURE_FRAME_LENGTH extern unsigned usbMeasureFrameLength(void); /* This function MUST be called IMMEDIATELY AFTER USB reset and measures 1/7 of * the number of CPU cycles during one USB frame minus one low speed bit @@ -329,59 +326,58 @@ extern unsigned usbMeasureFrameLength(void); * calling this function. * This can be used to calibrate the AVR's RC oscillator. */ -#endif -extern uchar usbConfiguration; +# endif +extern uchar usbConfiguration; /* This value contains the current configuration set by the host. The driver * allows setting and querying of this variable with the USB SET_CONFIGURATION * and GET_CONFIGURATION requests, but does not use it otherwise. * You may want to reflect the "configured" status with a LED on the device or * switch on high power parts of the circuit only if the device is configured. */ -#if USB_COUNT_SOF -extern volatile uchar usbSofCount; +# if USB_COUNT_SOF +extern volatile uchar usbSofCount; /* This variable is incremented on every SOF packet. It is only available if * the macro USB_COUNT_SOF is defined to a value != 0. */ -#endif -#if USB_CFG_CHECK_DATA_TOGGLING -extern uchar usbCurrentDataToken; +# endif +# if USB_CFG_CHECK_DATA_TOGGLING +extern uchar usbCurrentDataToken; /* This variable can be checked in usbFunctionWrite() and usbFunctionWriteOut() * to ignore duplicate packets. */ -#endif +# endif -#define USB_STRING_DESCRIPTOR_HEADER(stringLength) ((2*(stringLength)+2) | (3<<8)) +# define USB_STRING_DESCRIPTOR_HEADER(stringLength) ((2 * (stringLength) + 2) | (3 << 8)) /* This macro builds a descriptor header for a string descriptor given the * string's length. See usbdrv.c for an example how to use it. */ -#if USB_CFG_HAVE_FLOWCONTROL -extern volatile schar usbRxLen; -#define usbDisableAllRequests() usbRxLen = -1 +# if USB_CFG_HAVE_FLOWCONTROL +extern volatile schar usbRxLen; +# define usbDisableAllRequests() usbRxLen = -1 /* Must be called from usbFunctionWrite(). This macro disables all data input * from the USB interface. Requests from the host are answered with a NAK * while they are disabled. */ -#define usbEnableAllRequests() usbRxLen = 0 +# define usbEnableAllRequests() usbRxLen = 0 /* May only be called if requests are disabled. This macro enables input from * the USB interface after it has been disabled with usbDisableAllRequests(). */ -#define usbAllRequestsAreDisabled() (usbRxLen < 0) +# define usbAllRequestsAreDisabled() (usbRxLen < 0) /* Use this macro to find out whether requests are disabled. It may be needed * to ensure that usbEnableAllRequests() is never called when requests are * enabled. */ -#endif +# endif -#define USB_SET_DATATOKEN1(token) usbTxBuf1[0] = token -#define USB_SET_DATATOKEN3(token) usbTxBuf3[0] = token +# define USB_SET_DATATOKEN1(token) usbTxBuf1[0] = token +# define USB_SET_DATATOKEN3(token) usbTxBuf3[0] = token /* These two macros can be used by application software to reset data toggling * for interrupt-in endpoints 1 and 3. Since the token is toggled BEFORE * sending data, you must set the opposite value of the token which should come * first. */ -#endif /* __ASSEMBLER__ */ - +#endif /* __ASSEMBLER__ */ /* ------------------------------------------------------------------------- */ /* ----------------- Definitions for Descriptor Properties ----------------- */ @@ -390,57 +386,57 @@ extern volatile schar usbRxLen; * about the various methods to define USB descriptors. If you do nothing, * the default descriptors will be used. */ -#define USB_PROP_IS_DYNAMIC (1 << 14) +#define USB_PROP_IS_DYNAMIC (1 << 14) /* If this property is set for a descriptor, usbFunctionDescriptor() will be * used to obtain the particular descriptor. Data directly returned via * usbMsgPtr are FLASH data by default, combine (OR) with USB_PROP_IS_RAM to * return RAM data. */ -#define USB_PROP_IS_RAM (1 << 15) +#define USB_PROP_IS_RAM (1 << 15) /* If this property is set for a descriptor, the data is read from RAM * memory instead of Flash. The property is used for all methods to provide * external descriptors. */ -#define USB_PROP_LENGTH(len) ((len) & 0x3fff) +#define USB_PROP_LENGTH(len) ((len)&0x3fff) /* If a static external descriptor is used, this is the total length of the * descriptor in bytes. */ /* all descriptors which may have properties: */ #ifndef USB_CFG_DESCR_PROPS_DEVICE -#define USB_CFG_DESCR_PROPS_DEVICE 0 +# define USB_CFG_DESCR_PROPS_DEVICE 0 #endif #ifndef USB_CFG_DESCR_PROPS_CONFIGURATION -#define USB_CFG_DESCR_PROPS_CONFIGURATION 0 +# define USB_CFG_DESCR_PROPS_CONFIGURATION 0 #endif #ifndef USB_CFG_DESCR_PROPS_STRINGS -#define USB_CFG_DESCR_PROPS_STRINGS 0 +# define USB_CFG_DESCR_PROPS_STRINGS 0 #endif #ifndef USB_CFG_DESCR_PROPS_STRING_0 -#define USB_CFG_DESCR_PROPS_STRING_0 0 +# define USB_CFG_DESCR_PROPS_STRING_0 0 #endif #ifndef USB_CFG_DESCR_PROPS_STRING_VENDOR -#define USB_CFG_DESCR_PROPS_STRING_VENDOR 0 +# define USB_CFG_DESCR_PROPS_STRING_VENDOR 0 #endif #ifndef USB_CFG_DESCR_PROPS_STRING_PRODUCT -#define USB_CFG_DESCR_PROPS_STRING_PRODUCT 0 +# define USB_CFG_DESCR_PROPS_STRING_PRODUCT 0 #endif #ifndef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER -#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0 +# define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0 #endif #ifndef USB_CFG_DESCR_PROPS_HID -#define USB_CFG_DESCR_PROPS_HID 0 +# define USB_CFG_DESCR_PROPS_HID 0 #endif #if !(USB_CFG_DESCR_PROPS_HID_REPORT) -# undef USB_CFG_DESCR_PROPS_HID_REPORT -# if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* do some backward compatibility tricks */ -# define USB_CFG_DESCR_PROPS_HID_REPORT USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH -# else -# define USB_CFG_DESCR_PROPS_HID_REPORT 0 -# endif +# undef USB_CFG_DESCR_PROPS_HID_REPORT +# if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* do some backward compatibility tricks */ +# define USB_CFG_DESCR_PROPS_HID_REPORT USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH +# else +# define USB_CFG_DESCR_PROPS_HID_REPORT 0 +# endif #endif #ifndef USB_CFG_DESCR_PROPS_UNKNOWN -#define USB_CFG_DESCR_PROPS_UNKNOWN 0 +# define USB_CFG_DESCR_PROPS_UNKNOWN 0 #endif /* ------------------ forward declaration of descriptors ------------------- */ @@ -449,46 +445,46 @@ extern volatile schar usbRxLen; */ #ifndef __ASSEMBLER__ extern -#if !(USB_CFG_DESCR_PROPS_DEVICE & USB_PROP_IS_RAM) -PROGMEM -#endif -const char usbDescriptorDevice[]; +# if !(USB_CFG_DESCR_PROPS_DEVICE & USB_PROP_IS_RAM) + PROGMEM +# endif + const char usbDescriptorDevice[]; extern -#if !(USB_CFG_DESCR_PROPS_CONFIGURATION & USB_PROP_IS_RAM) -PROGMEM -#endif -const char usbDescriptorConfiguration[]; +# if !(USB_CFG_DESCR_PROPS_CONFIGURATION & USB_PROP_IS_RAM) + PROGMEM +# endif + const char usbDescriptorConfiguration[]; extern -#if !(USB_CFG_DESCR_PROPS_HID_REPORT & USB_PROP_IS_RAM) -PROGMEM -#endif -const char usbDescriptorHidReport[]; +# if !(USB_CFG_DESCR_PROPS_HID_REPORT & USB_PROP_IS_RAM) + PROGMEM +# endif + const char usbDescriptorHidReport[]; extern -#if !(USB_CFG_DESCR_PROPS_STRING_0 & USB_PROP_IS_RAM) -PROGMEM -#endif -const char usbDescriptorString0[]; +# if !(USB_CFG_DESCR_PROPS_STRING_0 & USB_PROP_IS_RAM) + PROGMEM +# endif + const char usbDescriptorString0[]; extern -#if !(USB_CFG_DESCR_PROPS_STRING_VENDOR & USB_PROP_IS_RAM) -PROGMEM -#endif -const int usbDescriptorStringVendor[]; +# if !(USB_CFG_DESCR_PROPS_STRING_VENDOR & USB_PROP_IS_RAM) + PROGMEM +# endif + const int usbDescriptorStringVendor[]; extern -#if !(USB_CFG_DESCR_PROPS_STRING_PRODUCT & USB_PROP_IS_RAM) -PROGMEM -#endif -const int usbDescriptorStringDevice[]; +# if !(USB_CFG_DESCR_PROPS_STRING_PRODUCT & USB_PROP_IS_RAM) + PROGMEM +# endif + const int usbDescriptorStringDevice[]; extern -#if !(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER & USB_PROP_IS_RAM) -PROGMEM -#endif -const int usbDescriptorStringSerialNumber[]; +# if !(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER & USB_PROP_IS_RAM) + PROGMEM +# endif + const int usbDescriptorStringSerialNumber[]; #endif /* __ASSEMBLER__ */ @@ -496,12 +492,12 @@ const int usbDescriptorStringSerialNumber[]; /* ------------------------ General Purpose Macros ------------------------- */ /* ------------------------------------------------------------------------- */ -#define USB_CONCAT(a, b) a ## b -#define USB_CONCAT_EXPANDED(a, b) USB_CONCAT(a, b) +#define USB_CONCAT(a, b) a##b +#define USB_CONCAT_EXPANDED(a, b) USB_CONCAT(a, b) -#define USB_OUTPORT(name) USB_CONCAT(PORT, name) -#define USB_INPORT(name) USB_CONCAT(PIN, name) -#define USB_DDRPORT(name) USB_CONCAT(DDR, name) +#define USB_OUTPORT(name) USB_CONCAT(PORT, name) +#define USB_INPORT(name) USB_CONCAT(PIN, name) +#define USB_DDRPORT(name) USB_CONCAT(DDR, name) /* The double-define trick above lets us concatenate strings which are * defined by macros. */ @@ -511,7 +507,7 @@ const int usbDescriptorStringSerialNumber[]; /* ------------------------------------------------------------------------- */ #if !defined __ASSEMBLER__ && (!defined USB_CFG_VENDOR_ID || !defined USB_CFG_DEVICE_ID) -#warning "You should define USB_CFG_VENDOR_ID and USB_CFG_DEVICE_ID in usbconfig.h" +# warning "You should define USB_CFG_VENDOR_ID and USB_CFG_DEVICE_ID in usbconfig.h" /* If the user has not defined IDs, we default to obdev's free IDs. * See USB-IDs-for-free.txt for details. */ @@ -519,96 +515,96 @@ const int usbDescriptorStringSerialNumber[]; /* make sure we have a VID and PID defined, byte order is lowbyte, highbyte */ #ifndef USB_CFG_VENDOR_ID -# define USB_CFG_VENDOR_ID 0xc0, 0x16 /* = 0x16c0 = 5824 = voti.nl */ +# define USB_CFG_VENDOR_ID 0xc0, 0x16 /* = 0x16c0 = 5824 = voti.nl */ #endif #ifndef USB_CFG_DEVICE_ID -# if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH -# define USB_CFG_DEVICE_ID 0xdf, 0x05 /* = 0x5df = 1503, shared PID for HIDs */ -# elif USB_CFG_INTERFACE_CLASS == 2 -# define USB_CFG_DEVICE_ID 0xe1, 0x05 /* = 0x5e1 = 1505, shared PID for CDC Modems */ -# else -# define USB_CFG_DEVICE_ID 0xdc, 0x05 /* = 0x5dc = 1500, obdev's free PID */ -# endif +# if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH +# define USB_CFG_DEVICE_ID 0xdf, 0x05 /* = 0x5df = 1503, shared PID for HIDs */ +# elif USB_CFG_INTERFACE_CLASS == 2 +# define USB_CFG_DEVICE_ID 0xe1, 0x05 /* = 0x5e1 = 1505, shared PID for CDC Modems */ +# else +# define USB_CFG_DEVICE_ID 0xdc, 0x05 /* = 0x5dc = 1500, obdev's free PID */ +# endif #endif /* Derive Output, Input and DataDirection ports from port names */ #ifndef USB_CFG_IOPORTNAME -#error "You must define USB_CFG_IOPORTNAME in usbconfig.h, see usbconfig-prototype.h" +# error "You must define USB_CFG_IOPORTNAME in usbconfig.h, see usbconfig-prototype.h" #endif -#define USBOUT USB_OUTPORT(USB_CFG_IOPORTNAME) -#define USB_PULLUP_OUT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME) -#define USBIN USB_INPORT(USB_CFG_IOPORTNAME) -#define USBDDR USB_DDRPORT(USB_CFG_IOPORTNAME) -#define USB_PULLUP_DDR USB_DDRPORT(USB_CFG_PULLUP_IOPORTNAME) +#define USBOUT USB_OUTPORT(USB_CFG_IOPORTNAME) +#define USB_PULLUP_OUT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME) +#define USBIN USB_INPORT(USB_CFG_IOPORTNAME) +#define USBDDR USB_DDRPORT(USB_CFG_IOPORTNAME) +#define USB_PULLUP_DDR USB_DDRPORT(USB_CFG_PULLUP_IOPORTNAME) -#define USBMINUS USB_CFG_DMINUS_BIT -#define USBPLUS USB_CFG_DPLUS_BIT -#define USBIDLE (1<<USB_CFG_DMINUS_BIT) /* value representing J state */ -#define USBMASK ((1<<USB_CFG_DPLUS_BIT) | (1<<USB_CFG_DMINUS_BIT)) /* mask for USB I/O bits */ +#define USBMINUS USB_CFG_DMINUS_BIT +#define USBPLUS USB_CFG_DPLUS_BIT +#define USBIDLE (1 << USB_CFG_DMINUS_BIT) /* value representing J state */ +#define USBMASK ((1 << USB_CFG_DPLUS_BIT) | (1 << USB_CFG_DMINUS_BIT)) /* mask for USB I/O bits */ /* defines for backward compatibility with older driver versions: */ -#define USB_CFG_IOPORT USB_OUTPORT(USB_CFG_IOPORTNAME) +#define USB_CFG_IOPORT USB_OUTPORT(USB_CFG_IOPORTNAME) #ifdef USB_CFG_PULLUP_IOPORTNAME -#define USB_CFG_PULLUP_IOPORT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME) +# define USB_CFG_PULLUP_IOPORT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME) #endif -#ifndef USB_CFG_EP3_NUMBER /* if not defined in usbconfig.h */ -#define USB_CFG_EP3_NUMBER 3 +#ifndef USB_CFG_EP3_NUMBER /* if not defined in usbconfig.h */ +# define USB_CFG_EP3_NUMBER 3 #endif #ifndef USB_CFG_HAVE_INTRIN_ENDPOINT3 -#define USB_CFG_HAVE_INTRIN_ENDPOINT3 0 +# define USB_CFG_HAVE_INTRIN_ENDPOINT3 0 #endif -#define USB_BUFSIZE 11 /* PID, 8 bytes data, 2 bytes CRC */ +#define USB_BUFSIZE 11 /* PID, 8 bytes data, 2 bytes CRC */ /* ----- Try to find registers and bits responsible for ext interrupt 0 ----- */ -#ifndef USB_INTR_CFG /* allow user to override our default */ -# if defined EICRA -# define USB_INTR_CFG EICRA -# else -# define USB_INTR_CFG MCUCR -# endif -#endif -#ifndef USB_INTR_CFG_SET /* allow user to override our default */ -# if defined(USB_COUNT_SOF) || defined(USB_SOF_HOOK) -# define USB_INTR_CFG_SET (1 << ISC01) /* cfg for falling edge */ - /* If any SOF logic is used, the interrupt must be wired to D- where - * we better trigger on falling edge - */ -# else -# define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01)) /* cfg for rising edge */ -# endif -#endif -#ifndef USB_INTR_CFG_CLR /* allow user to override our default */ -# define USB_INTR_CFG_CLR 0 /* no bits to clear */ -#endif - -#ifndef USB_INTR_ENABLE /* allow user to override our default */ -# if defined GIMSK -# define USB_INTR_ENABLE GIMSK -# elif defined EIMSK -# define USB_INTR_ENABLE EIMSK -# else -# define USB_INTR_ENABLE GICR -# endif +#ifndef USB_INTR_CFG /* allow user to override our default */ +# if defined EICRA +# define USB_INTR_CFG EICRA +# else +# define USB_INTR_CFG MCUCR +# endif +#endif +#ifndef USB_INTR_CFG_SET /* allow user to override our default */ +# if defined(USB_COUNT_SOF) || defined(USB_SOF_HOOK) +# define USB_INTR_CFG_SET (1 << ISC01) /* cfg for falling edge */ + /* If any SOF logic is used, the interrupt must be wired to D- where + * we better trigger on falling edge + */ +# else +# define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01)) /* cfg for rising edge */ +# endif +#endif +#ifndef USB_INTR_CFG_CLR /* allow user to override our default */ +# define USB_INTR_CFG_CLR 0 /* no bits to clear */ +#endif + +#ifndef USB_INTR_ENABLE /* allow user to override our default */ +# if defined GIMSK +# define USB_INTR_ENABLE GIMSK +# elif defined EIMSK +# define USB_INTR_ENABLE EIMSK +# else +# define USB_INTR_ENABLE GICR +# endif #endif #ifndef USB_INTR_ENABLE_BIT /* allow user to override our default */ -# define USB_INTR_ENABLE_BIT INT0 +# define USB_INTR_ENABLE_BIT INT0 #endif -#ifndef USB_INTR_PENDING /* allow user to override our default */ -# if defined EIFR -# define USB_INTR_PENDING EIFR -# else -# define USB_INTR_PENDING GIFR -# endif +#ifndef USB_INTR_PENDING /* allow user to override our default */ +# if defined EIFR +# define USB_INTR_PENDING EIFR +# else +# define USB_INTR_PENDING GIFR +# endif #endif -#ifndef USB_INTR_PENDING_BIT /* allow user to override our default */ -# define USB_INTR_PENDING_BIT INTF0 +#ifndef USB_INTR_PENDING_BIT /* allow user to override our default */ +# define USB_INTR_PENDING_BIT INTF0 #endif /* @@ -628,46 +624,45 @@ at90s1200, attiny11, attiny12, attiny15, attiny28: these have no RAM /* ------------------------------------------------------------------------- */ /* USB Token values */ -#define USBPID_SETUP 0x2d -#define USBPID_OUT 0xe1 -#define USBPID_IN 0x69 -#define USBPID_DATA0 0xc3 -#define USBPID_DATA1 0x4b +#define USBPID_SETUP 0x2d +#define USBPID_OUT 0xe1 +#define USBPID_IN 0x69 +#define USBPID_DATA0 0xc3 +#define USBPID_DATA1 0x4b -#define USBPID_ACK 0xd2 -#define USBPID_NAK 0x5a -#define USBPID_STALL 0x1e +#define USBPID_ACK 0xd2 +#define USBPID_NAK 0x5a +#define USBPID_STALL 0x1e #ifndef USB_INITIAL_DATATOKEN -#define USB_INITIAL_DATATOKEN USBPID_DATA1 +# define USB_INITIAL_DATATOKEN USBPID_DATA1 #endif #ifndef __ASSEMBLER__ -typedef struct usbTxStatus{ - volatile uchar len; - uchar buffer[USB_BUFSIZE]; -}usbTxStatus_t; - -extern usbTxStatus_t usbTxStatus1, usbTxStatus3; -#define usbTxLen1 usbTxStatus1.len -#define usbTxBuf1 usbTxStatus1.buffer -#define usbTxLen3 usbTxStatus3.len -#define usbTxBuf3 usbTxStatus3.buffer - - -typedef union usbWord{ - unsigned word; - uchar bytes[2]; -}usbWord_t; - -typedef struct usbRequest{ - uchar bmRequestType; - uchar bRequest; - usbWord_t wValue; - usbWord_t wIndex; - usbWord_t wLength; -}usbRequest_t; +typedef struct usbTxStatus { + volatile uchar len; + uchar buffer[USB_BUFSIZE]; +} usbTxStatus_t; + +extern usbTxStatus_t usbTxStatus1, usbTxStatus3; +# define usbTxLen1 usbTxStatus1.len +# define usbTxBuf1 usbTxStatus1.buffer +# define usbTxLen3 usbTxStatus3.len +# define usbTxBuf3 usbTxStatus3.buffer + +typedef union usbWord { + unsigned word; + uchar bytes[2]; +} usbWord_t; + +typedef struct usbRequest { + uchar bmRequestType; + uchar bRequest; + usbWord_t wValue; + usbWord_t wIndex; + usbWord_t wLength; +} usbRequest_t; /* This structure matches the 8 byte setup request */ #endif @@ -679,56 +674,56 @@ typedef struct usbRequest{ */ /* USB setup recipient values */ -#define USBRQ_RCPT_MASK 0x1f -#define USBRQ_RCPT_DEVICE 0 -#define USBRQ_RCPT_INTERFACE 1 -#define USBRQ_RCPT_ENDPOINT 2 +#define USBRQ_RCPT_MASK 0x1f +#define USBRQ_RCPT_DEVICE 0 +#define USBRQ_RCPT_INTERFACE 1 +#define USBRQ_RCPT_ENDPOINT 2 /* USB request type values */ -#define USBRQ_TYPE_MASK 0x60 -#define USBRQ_TYPE_STANDARD (0<<5) -#define USBRQ_TYPE_CLASS (1<<5) -#define USBRQ_TYPE_VENDOR (2<<5) +#define USBRQ_TYPE_MASK 0x60 +#define USBRQ_TYPE_STANDARD (0 << 5) +#define USBRQ_TYPE_CLASS (1 << 5) +#define USBRQ_TYPE_VENDOR (2 << 5) /* USB direction values: */ -#define USBRQ_DIR_MASK 0x80 -#define USBRQ_DIR_HOST_TO_DEVICE (0<<7) -#define USBRQ_DIR_DEVICE_TO_HOST (1<<7) +#define USBRQ_DIR_MASK 0x80 +#define USBRQ_DIR_HOST_TO_DEVICE (0 << 7) +#define USBRQ_DIR_DEVICE_TO_HOST (1 << 7) /* USB Standard Requests */ -#define USBRQ_GET_STATUS 0 -#define USBRQ_CLEAR_FEATURE 1 -#define USBRQ_SET_FEATURE 3 -#define USBRQ_SET_ADDRESS 5 -#define USBRQ_GET_DESCRIPTOR 6 -#define USBRQ_SET_DESCRIPTOR 7 +#define USBRQ_GET_STATUS 0 +#define USBRQ_CLEAR_FEATURE 1 +#define USBRQ_SET_FEATURE 3 +#define USBRQ_SET_ADDRESS 5 +#define USBRQ_GET_DESCRIPTOR 6 +#define USBRQ_SET_DESCRIPTOR 7 #define USBRQ_GET_CONFIGURATION 8 #define USBRQ_SET_CONFIGURATION 9 -#define USBRQ_GET_INTERFACE 10 -#define USBRQ_SET_INTERFACE 11 -#define USBRQ_SYNCH_FRAME 12 +#define USBRQ_GET_INTERFACE 10 +#define USBRQ_SET_INTERFACE 11 +#define USBRQ_SYNCH_FRAME 12 /* USB descriptor constants */ -#define USBDESCR_DEVICE 1 -#define USBDESCR_CONFIG 2 -#define USBDESCR_STRING 3 -#define USBDESCR_INTERFACE 4 -#define USBDESCR_ENDPOINT 5 -#define USBDESCR_HID 0x21 -#define USBDESCR_HID_REPORT 0x22 -#define USBDESCR_HID_PHYS 0x23 +#define USBDESCR_DEVICE 1 +#define USBDESCR_CONFIG 2 +#define USBDESCR_STRING 3 +#define USBDESCR_INTERFACE 4 +#define USBDESCR_ENDPOINT 5 +#define USBDESCR_HID 0x21 +#define USBDESCR_HID_REPORT 0x22 +#define USBDESCR_HID_PHYS 0x23 //#define USBATTR_BUSPOWER 0x80 // USB 1.1 does not define this value any more -#define USBATTR_SELFPOWER 0x40 -#define USBATTR_REMOTEWAKE 0x20 +#define USBATTR_SELFPOWER 0x40 +#define USBATTR_REMOTEWAKE 0x20 /* USB HID Requests */ -#define USBRQ_HID_GET_REPORT 0x01 -#define USBRQ_HID_GET_IDLE 0x02 -#define USBRQ_HID_GET_PROTOCOL 0x03 -#define USBRQ_HID_SET_REPORT 0x09 -#define USBRQ_HID_SET_IDLE 0x0a -#define USBRQ_HID_SET_PROTOCOL 0x0b +#define USBRQ_HID_GET_REPORT 0x01 +#define USBRQ_HID_GET_IDLE 0x02 +#define USBRQ_HID_GET_PROTOCOL 0x03 +#define USBRQ_HID_SET_REPORT 0x09 +#define USBRQ_HID_SET_IDLE 0x0a +#define USBRQ_HID_SET_PROTOCOL 0x0b /* ------------------------------------------------------------------------- */ |