From 93f6749e06b70ba81e15f8b77e5a18675dacddfe Mon Sep 17 00:00:00 2001 From: skullY Date: Fri, 30 Aug 2019 11:19:03 -0700 Subject: clang-format changes --- tmk_core/protocol/vusb/main.c | 42 +- tmk_core/protocol/vusb/sendchar_usart.c | 12 +- tmk_core/protocol/vusb/usbdrv/oddebug.c | 22 +- tmk_core/protocol/vusb/usbdrv/oddebug.h | 114 ++-- .../protocol/vusb/usbdrv/usbconfig-prototype.h | 86 +-- tmk_core/protocol/vusb/usbdrv/usbdrv.c | 673 ++++++++++----------- tmk_core/protocol/vusb/usbdrv/usbdrv.h | 487 ++++++++------- tmk_core/protocol/vusb/vusb.c | 498 +++++++-------- tmk_core/protocol/vusb/vusb.h | 3 +- 9 files changed, 937 insertions(+), 1000 deletions(-) (limited to 'tmk_core/protocol/vusb') diff --git a/tmk_core/protocol/vusb/main.c b/tmk_core/protocol/vusb/main.c index 86c2188c87..f8322d94ac 100644 --- a/tmk_core/protocol/vusb/main.c +++ b/tmk_core/protocol/vusb/main.c @@ -21,19 +21,16 @@ #include "uart.h" #include "debug.h" - #define UART_BAUD_RATE 115200 - /* This is from main.c of USBaspLoader */ -static void initForUsbConnectivity(void) -{ +static void initForUsbConnectivity(void) { uint8_t i = 0; usbInit(); /* enforce USB re-enumerate: */ - usbDeviceDisconnect(); /* do this while interrupts are disabled */ - while(--i){ /* fake USB disconnect for > 250 ms */ + usbDeviceDisconnect(); /* do this while interrupts are disabled */ + while (--i) { /* fake USB disconnect for > 250 ms */ wdt_reset(); _delay_ms(1); } @@ -41,8 +38,7 @@ static void initForUsbConnectivity(void) sei(); } -int main(void) -{ +int main(void) { bool suspended = false; #if USB_COUNT_SOF uint16_t last_timer = timer_read(); @@ -68,26 +64,26 @@ int main(void) while (1) { #if USB_COUNT_SOF if (usbSofCount != 0) { - suspended = false; + suspended = false; usbSofCount = 0; - last_timer = timer_read(); + last_timer = timer_read(); } else { // Suspend when no SOF in 3ms-10ms(7.1.7.4 Suspending of USB1.1) if (timer_elapsed(last_timer) > 5) { suspended = true; -/* - uart_putchar('S'); - _delay_ms(1); - cli(); - set_sleep_mode(SLEEP_MODE_PWR_DOWN); - sleep_enable(); - sleep_bod_disable(); - sei(); - sleep_cpu(); - sleep_disable(); - _delay_ms(10); - uart_putchar('W'); -*/ + /* + uart_putchar('S'); + _delay_ms(1); + cli(); + set_sleep_mode(SLEEP_MODE_PWR_DOWN); + sleep_enable(); + sleep_bod_disable(); + sei(); + sleep_cpu(); + sleep_disable(); + _delay_ms(10); + uart_putchar('W'); + */ } } #endif diff --git a/tmk_core/protocol/vusb/sendchar_usart.c b/tmk_core/protocol/vusb/sendchar_usart.c index 8d24f87d1e..42bd9ee363 100644 --- a/tmk_core/protocol/vusb/sendchar_usart.c +++ b/tmk_core/protocol/vusb/sendchar_usart.c @@ -6,18 +6,14 @@ #include "oddebug.h" #include "sendchar.h" - #if DEBUG_LEVEL > 0 /* from oddebug.c */ -int8_t sendchar(uint8_t c) -{ - while(!(ODDBG_USR & (1 << ODDBG_UDRE))); /* wait for data register empty */ +int8_t sendchar(uint8_t c) { + while (!(ODDBG_USR & (1 << ODDBG_UDRE))) + ; /* wait for data register empty */ ODDBG_UDR = c; return 1; } #else -int8_t sendchar(uint8_t c) -{ - return 1; -} +int8_t sendchar(uint8_t c) { return 1; } #endif 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<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<. #include "bootloader.h" #include - static uint8_t vusb_keyboard_leds = 0; -static uint8_t vusb_idle_rate = 0; +static uint8_t vusb_idle_rate = 0; /* Keyboard report send buffer */ #define KBUF_SIZE 16 static report_keyboard_t kbuf[KBUF_SIZE]; -static uint8_t kbuf_head = 0; -static uint8_t kbuf_tail = 0; +static uint8_t kbuf_head = 0; +static uint8_t kbuf_tail = 0; typedef struct { - uint8_t modifier; - uint8_t reserved; - uint8_t keycode[6]; + uint8_t modifier; + uint8_t reserved; + uint8_t keycode[6]; } keyboard_report_t; -static keyboard_report_t keyboard_report; // sent to PC +static keyboard_report_t keyboard_report; // sent to PC #define VUSB_TRANSFER_KEYBOARD_MAX_TRIES 10 /* transfer keyboard report from buffer */ -void vusb_transfer_keyboard(void) -{ +void vusb_transfer_keyboard(void) { for (int i = 0; i < VUSB_TRANSFER_KEYBOARD_MAX_TRIES; i++) { if (usbInterruptIsReady()) { if (kbuf_head != kbuf_tail) { usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t)); kbuf_tail = (kbuf_tail + 1) % KBUF_SIZE; if (debug_keyboard) { - print("V-USB: kbuf["); pdec(kbuf_tail); print("->"); pdec(kbuf_head); print("]("); + print("V-USB: kbuf["); + pdec(kbuf_tail); + print("->"); + pdec(kbuf_head); + print("]("); phex((kbuf_head < kbuf_tail) ? (KBUF_SIZE - kbuf_tail + kbuf_head) : (kbuf_head - kbuf_tail)); print(")\n"); } @@ -70,39 +72,26 @@ void vusb_transfer_keyboard(void) } } - /*------------------------------------------------------------------* * Host driver *------------------------------------------------------------------*/ static uint8_t keyboard_leds(void); -static void send_keyboard(report_keyboard_t *report); -static void send_mouse(report_mouse_t *report); -static void send_system(uint16_t data); -static void send_consumer(uint16_t data); - -static host_driver_t driver = { - keyboard_leds, - send_keyboard, - send_mouse, - send_system, - send_consumer -}; +static void send_keyboard(report_keyboard_t *report); +static void send_mouse(report_mouse_t *report); +static void send_system(uint16_t data); +static void send_consumer(uint16_t data); -host_driver_t *vusb_driver(void) -{ - return &driver; -} +static host_driver_t driver = {keyboard_leds, send_keyboard, send_mouse, send_system, send_consumer}; -static uint8_t keyboard_leds(void) { - return vusb_keyboard_leds; -} +host_driver_t *vusb_driver(void) { return &driver; } + +static uint8_t keyboard_leds(void) { return vusb_keyboard_leds; } -static void send_keyboard(report_keyboard_t *report) -{ +static void send_keyboard(report_keyboard_t *report) { uint8_t next = (kbuf_head + 1) % KBUF_SIZE; if (next != kbuf_tail) { kbuf[kbuf_head] = *report; - kbuf_head = next; + kbuf_head = next; } else { debug("kbuf: full\n"); } @@ -112,119 +101,97 @@ static void send_keyboard(report_keyboard_t *report) vusb_transfer_keyboard(); } - typedef struct { - uint8_t report_id; + uint8_t report_id; report_mouse_t report; -} __attribute__ ((packed)) vusb_mouse_report_t; - -static void send_mouse(report_mouse_t *report) -{ - vusb_mouse_report_t r = { - .report_id = REPORT_ID_MOUSE, - .report = *report - }; +} __attribute__((packed)) vusb_mouse_report_t; + +static void send_mouse(report_mouse_t *report) { + vusb_mouse_report_t r = {.report_id = REPORT_ID_MOUSE, .report = *report}; if (usbInterruptIsReady3()) { usbSetInterrupt3((void *)&r, sizeof(vusb_mouse_report_t)); } } - typedef struct { uint8_t report_id; uint16_t usage; -} __attribute__ ((packed)) report_extra_t; +} __attribute__((packed)) report_extra_t; -static void send_system(uint16_t data) -{ +static void send_system(uint16_t data) { static uint16_t last_data = 0; if (data == last_data) return; last_data = data; - report_extra_t report = { - .report_id = REPORT_ID_SYSTEM, - .usage = data - }; + report_extra_t report = {.report_id = REPORT_ID_SYSTEM, .usage = data}; if (usbInterruptIsReady3()) { usbSetInterrupt3((void *)&report, sizeof(report)); } } -static void send_consumer(uint16_t data) -{ +static void send_consumer(uint16_t data) { static uint16_t last_data = 0; if (data == last_data) return; last_data = data; - report_extra_t report = { - .report_id = REPORT_ID_CONSUMER, - .usage = data - }; + report_extra_t report = {.report_id = REPORT_ID_CONSUMER, .usage = data}; if (usbInterruptIsReady3()) { usbSetInterrupt3((void *)&report, sizeof(report)); } } - - /*------------------------------------------------------------------* * Request from host * *------------------------------------------------------------------*/ static struct { - uint16_t len; - enum { - NONE, - BOOTLOADER, - SET_LED - } kind; + uint16_t len; + enum { NONE, BOOTLOADER, SET_LED } kind; } last_req; -usbMsgLen_t usbFunctionSetup(uchar data[8]) -{ -usbRequest_t *rq = (void *)data; +usbMsgLen_t usbFunctionSetup(uchar data[8]) { + usbRequest_t *rq = (void *)data; - if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){ /* class request type */ - if(rq->bRequest == USBRQ_HID_GET_REPORT){ + if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) { /* class request type */ + if (rq->bRequest == USBRQ_HID_GET_REPORT) { debug("GET_REPORT:"); /* we only have one report type, so don't look at wValue */ usbMsgPtr = (void *)&keyboard_report; return sizeof(keyboard_report); - }else if(rq->bRequest == USBRQ_HID_GET_IDLE){ + } else if (rq->bRequest == USBRQ_HID_GET_IDLE) { debug("GET_IDLE: "); - //debug_hex(vusb_idle_rate); + // debug_hex(vusb_idle_rate); usbMsgPtr = &vusb_idle_rate; return 1; - }else if(rq->bRequest == USBRQ_HID_SET_IDLE){ + } else if (rq->bRequest == USBRQ_HID_SET_IDLE) { vusb_idle_rate = rq->wValue.bytes[1]; debug("SET_IDLE: "); debug_hex(vusb_idle_rate); - }else if(rq->bRequest == USBRQ_HID_SET_REPORT){ + } else if (rq->bRequest == USBRQ_HID_SET_REPORT) { debug("SET_REPORT: "); // Report Type: 0x02(Out)/ReportID: 0x00(none) && Interface: 0(keyboard) if (rq->wValue.word == 0x0200 && rq->wIndex.word == 0) { debug("SET_LED: "); last_req.kind = SET_LED; - last_req.len = rq->wLength.word; + last_req.len = rq->wLength.word; #ifdef BOOTLOADER_SIZE - } else if(rq->wValue.word == 0x0301) { + } else if (rq->wValue.word == 0x0301) { last_req.kind = BOOTLOADER; - last_req.len = rq->wLength.word; + last_req.len = rq->wLength.word; #endif } - return USB_NO_MSG; // to get data in usbFunctionWrite + return USB_NO_MSG; // to get data in usbFunctionWrite } else { debug("UNKNOWN:"); } - }else{ + } else { debug("VENDOR:"); /* no vendor specific requests implemented */ } debug("\n"); - return 0; /* default for not implemented requests: return no data back to host */ + return 0; /* default for not implemented requests: return no data back to host */ } -uchar usbFunctionWrite(uchar *data, uchar len) -{ +uchar usbFunctionWrite(uchar *data, uchar len) { if (last_req.len == 0) { return -1; } @@ -234,7 +201,7 @@ uchar usbFunctionWrite(uchar *data, uchar len) debug_hex(data[0]); debug("\n"); vusb_keyboard_leds = data[0]; - last_req.len = 0; + last_req.len = 0; return 1; break; case BOOTLOADER: @@ -250,8 +217,6 @@ uchar usbFunctionWrite(uchar *data, uchar len) return 1; } - - /*------------------------------------------------------------------* * Descriptors * *------------------------------------------------------------------*/ @@ -262,38 +227,38 @@ uchar usbFunctionWrite(uchar *data, uchar len) * from an example in HID spec appendix */ const PROGMEM uchar keyboard_hid_report[] = { - 0x05, 0x01, // Usage Page (Generic Desktop), - 0x09, 0x06, // Usage (Keyboard), - 0xA1, 0x01, // Collection (Application), - 0x75, 0x01, // Report Size (1), - 0x95, 0x08, // Report Count (8), - 0x05, 0x07, // Usage Page (Key Codes), - 0x19, 0xE0, // Usage Minimum (224), - 0x29, 0xE7, // Usage Maximum (231), - 0x15, 0x00, // Logical Minimum (0), - 0x25, 0x01, // Logical Maximum (1), - 0x81, 0x02, // Input (Data, Variable, Absolute), ;Modifier byte - 0x95, 0x01, // Report Count (1), - 0x75, 0x08, // Report Size (8), - 0x81, 0x03, // Input (Constant), ;Reserved byte - 0x95, 0x05, // Report Count (5), - 0x75, 0x01, // Report Size (1), - 0x05, 0x08, // Usage Page (LEDs), - 0x19, 0x01, // Usage Minimum (1), - 0x29, 0x05, // Usage Maximum (5), - 0x91, 0x02, // Output (Data, Variable, Absolute), ;LED report - 0x95, 0x01, // Report Count (1), - 0x75, 0x03, // Report Size (3), - 0x91, 0x03, // Output (Constant), ;LED report padding - 0x95, 0x06, // Report Count (6), - 0x75, 0x08, // Report Size (8), - 0x15, 0x00, // Logical Minimum (0), - 0x26, 0xFF, 0x00, // Logical Maximum(255), - 0x05, 0x07, // Usage Page (Key Codes), - 0x19, 0x00, // Usage Minimum (0), - 0x29, 0xFF, // Usage Maximum (255), - 0x81, 0x00, // Input (Data, Array), - 0xc0 // End Collection + 0x05, 0x01, // Usage Page (Generic Desktop), + 0x09, 0x06, // Usage (Keyboard), + 0xA1, 0x01, // Collection (Application), + 0x75, 0x01, // Report Size (1), + 0x95, 0x08, // Report Count (8), + 0x05, 0x07, // Usage Page (Key Codes), + 0x19, 0xE0, // Usage Minimum (224), + 0x29, 0xE7, // Usage Maximum (231), + 0x15, 0x00, // Logical Minimum (0), + 0x25, 0x01, // Logical Maximum (1), + 0x81, 0x02, // Input (Data, Variable, Absolute), ;Modifier byte + 0x95, 0x01, // Report Count (1), + 0x75, 0x08, // Report Size (8), + 0x81, 0x03, // Input (Constant), ;Reserved byte + 0x95, 0x05, // Report Count (5), + 0x75, 0x01, // Report Size (1), + 0x05, 0x08, // Usage Page (LEDs), + 0x19, 0x01, // Usage Minimum (1), + 0x29, 0x05, // Usage Maximum (5), + 0x91, 0x02, // Output (Data, Variable, Absolute), ;LED report + 0x95, 0x01, // Report Count (1), + 0x75, 0x03, // Report Size (3), + 0x91, 0x03, // Output (Constant), ;LED report padding + 0x95, 0x06, // Report Count (6), + 0x75, 0x08, // Report Size (8), + 0x15, 0x00, // Logical Minimum (0), + 0x26, 0xFF, 0x00, // Logical Maximum(255), + 0x05, 0x07, // Usage Page (Key Codes), + 0x19, 0x00, // Usage Minimum (0), + 0x29, 0xFF, // Usage Maximum (255), + 0x81, 0x00, // Input (Data, Array), + 0xc0 // End Collection }; /* @@ -306,196 +271,191 @@ const PROGMEM uchar keyboard_hid_report[] = { */ const PROGMEM uchar mouse_hid_report[] = { /* mouse */ - 0x05, 0x01, // USAGE_PAGE (Generic Desktop) - 0x09, 0x02, // USAGE (Mouse) - 0xa1, 0x01, // COLLECTION (Application) - 0x85, REPORT_ID_MOUSE, // REPORT_ID (1) - 0x09, 0x01, // USAGE (Pointer) - 0xa1, 0x00, // COLLECTION (Physical) - // ---------------------------- Buttons - 0x05, 0x09, // USAGE_PAGE (Button) - 0x19, 0x01, // USAGE_MINIMUM (Button 1) - 0x29, 0x05, // USAGE_MAXIMUM (Button 5) - 0x15, 0x00, // LOGICAL_MINIMUM (0) - 0x25, 0x01, // LOGICAL_MAXIMUM (1) - 0x75, 0x01, // REPORT_SIZE (1) - 0x95, 0x05, // REPORT_COUNT (5) - 0x81, 0x02, // INPUT (Data,Var,Abs) - 0x75, 0x03, // REPORT_SIZE (3) - 0x95, 0x01, // REPORT_COUNT (1) - 0x81, 0x03, // INPUT (Cnst,Var,Abs) - // ---------------------------- X,Y position - 0x05, 0x01, // USAGE_PAGE (Generic Desktop) - 0x09, 0x30, // USAGE (X) - 0x09, 0x31, // USAGE (Y) - 0x15, 0x81, // LOGICAL_MINIMUM (-127) - 0x25, 0x7f, // LOGICAL_MAXIMUM (127) - 0x75, 0x08, // REPORT_SIZE (8) - 0x95, 0x02, // REPORT_COUNT (2) - 0x81, 0x06, // INPUT (Data,Var,Rel) - // ---------------------------- Vertical wheel - 0x09, 0x38, // USAGE (Wheel) - 0x15, 0x81, // LOGICAL_MINIMUM (-127) - 0x25, 0x7f, // LOGICAL_MAXIMUM (127) - 0x35, 0x00, // PHYSICAL_MINIMUM (0) - reset physical - 0x45, 0x00, // PHYSICAL_MAXIMUM (0) - 0x75, 0x08, // REPORT_SIZE (8) - 0x95, 0x01, // REPORT_COUNT (1) - 0x81, 0x06, // INPUT (Data,Var,Rel) - // ---------------------------- Horizontal wheel - 0x05, 0x0c, // USAGE_PAGE (Consumer Devices) - 0x0a, 0x38, 0x02, // USAGE (AC Pan) - 0x15, 0x81, // LOGICAL_MINIMUM (-127) - 0x25, 0x7f, // LOGICAL_MAXIMUM (127) - 0x75, 0x08, // REPORT_SIZE (8) - 0x95, 0x01, // REPORT_COUNT (1) - 0x81, 0x06, // INPUT (Data,Var,Rel) - 0xc0, // END_COLLECTION - 0xc0, // END_COLLECTION + 0x05, 0x01, // USAGE_PAGE (Generic Desktop) + 0x09, 0x02, // USAGE (Mouse) + 0xa1, 0x01, // COLLECTION (Application) + 0x85, REPORT_ID_MOUSE, // REPORT_ID (1) + 0x09, 0x01, // USAGE (Pointer) + 0xa1, 0x00, // COLLECTION (Physical) + // ---------------------------- Buttons + 0x05, 0x09, // USAGE_PAGE (Button) + 0x19, 0x01, // USAGE_MINIMUM (Button 1) + 0x29, 0x05, // USAGE_MAXIMUM (Button 5) + 0x15, 0x00, // LOGICAL_MINIMUM (0) + 0x25, 0x01, // LOGICAL_MAXIMUM (1) + 0x75, 0x01, // REPORT_SIZE (1) + 0x95, 0x05, // REPORT_COUNT (5) + 0x81, 0x02, // INPUT (Data,Var,Abs) + 0x75, 0x03, // REPORT_SIZE (3) + 0x95, 0x01, // REPORT_COUNT (1) + 0x81, 0x03, // INPUT (Cnst,Var,Abs) + // ---------------------------- X,Y position + 0x05, 0x01, // USAGE_PAGE (Generic Desktop) + 0x09, 0x30, // USAGE (X) + 0x09, 0x31, // USAGE (Y) + 0x15, 0x81, // LOGICAL_MINIMUM (-127) + 0x25, 0x7f, // LOGICAL_MAXIMUM (127) + 0x75, 0x08, // REPORT_SIZE (8) + 0x95, 0x02, // REPORT_COUNT (2) + 0x81, 0x06, // INPUT (Data,Var,Rel) + // ---------------------------- Vertical wheel + 0x09, 0x38, // USAGE (Wheel) + 0x15, 0x81, // LOGICAL_MINIMUM (-127) + 0x25, 0x7f, // LOGICAL_MAXIMUM (127) + 0x35, 0x00, // PHYSICAL_MINIMUM (0) - reset physical + 0x45, 0x00, // PHYSICAL_MAXIMUM (0) + 0x75, 0x08, // REPORT_SIZE (8) + 0x95, 0x01, // REPORT_COUNT (1) + 0x81, 0x06, // INPUT (Data,Var,Rel) + // ---------------------------- Horizontal wheel + 0x05, 0x0c, // USAGE_PAGE (Consumer Devices) + 0x0a, 0x38, 0x02, // USAGE (AC Pan) + 0x15, 0x81, // LOGICAL_MINIMUM (-127) + 0x25, 0x7f, // LOGICAL_MAXIMUM (127) + 0x75, 0x08, // REPORT_SIZE (8) + 0x95, 0x01, // REPORT_COUNT (1) + 0x81, 0x06, // INPUT (Data,Var,Rel) + 0xc0, // END_COLLECTION + 0xc0, // END_COLLECTION /* system control */ - 0x05, 0x01, // USAGE_PAGE (Generic Desktop) - 0x09, 0x80, // USAGE (System Control) - 0xa1, 0x01, // COLLECTION (Application) - 0x85, REPORT_ID_SYSTEM, // REPORT_ID (2) - 0x15, 0x01, // LOGICAL_MINIMUM (0x1) - 0x26, 0xb7, 0x00, // LOGICAL_MAXIMUM (0xb7) - 0x19, 0x01, // USAGE_MINIMUM (0x1) - 0x29, 0xb7, // USAGE_MAXIMUM (0xb7) - 0x75, 0x10, // REPORT_SIZE (16) - 0x95, 0x01, // REPORT_COUNT (1) - 0x81, 0x00, // INPUT (Data,Array,Abs) - 0xc0, // END_COLLECTION + 0x05, 0x01, // USAGE_PAGE (Generic Desktop) + 0x09, 0x80, // USAGE (System Control) + 0xa1, 0x01, // COLLECTION (Application) + 0x85, REPORT_ID_SYSTEM, // REPORT_ID (2) + 0x15, 0x01, // LOGICAL_MINIMUM (0x1) + 0x26, 0xb7, 0x00, // LOGICAL_MAXIMUM (0xb7) + 0x19, 0x01, // USAGE_MINIMUM (0x1) + 0x29, 0xb7, // USAGE_MAXIMUM (0xb7) + 0x75, 0x10, // REPORT_SIZE (16) + 0x95, 0x01, // REPORT_COUNT (1) + 0x81, 0x00, // INPUT (Data,Array,Abs) + 0xc0, // END_COLLECTION /* consumer */ - 0x05, 0x0c, // USAGE_PAGE (Consumer Devices) - 0x09, 0x01, // USAGE (Consumer Control) - 0xa1, 0x01, // COLLECTION (Application) - 0x85, REPORT_ID_CONSUMER, // REPORT_ID (3) - 0x15, 0x01, // LOGICAL_MINIMUM (0x1) - 0x26, 0x9c, 0x02, // LOGICAL_MAXIMUM (0x29c) - 0x19, 0x01, // USAGE_MINIMUM (0x1) - 0x2a, 0x9c, 0x02, // USAGE_MAXIMUM (0x29c) - 0x75, 0x10, // REPORT_SIZE (16) - 0x95, 0x01, // REPORT_COUNT (1) - 0x81, 0x00, // INPUT (Data,Array,Abs) - 0xc0, // END_COLLECTION + 0x05, 0x0c, // USAGE_PAGE (Consumer Devices) + 0x09, 0x01, // USAGE (Consumer Control) + 0xa1, 0x01, // COLLECTION (Application) + 0x85, REPORT_ID_CONSUMER, // REPORT_ID (3) + 0x15, 0x01, // LOGICAL_MINIMUM (0x1) + 0x26, 0x9c, 0x02, // LOGICAL_MAXIMUM (0x29c) + 0x19, 0x01, // USAGE_MINIMUM (0x1) + 0x2a, 0x9c, 0x02, // USAGE_MAXIMUM (0x29c) + 0x75, 0x10, // REPORT_SIZE (16) + 0x95, 0x01, // REPORT_COUNT (1) + 0x81, 0x00, // INPUT (Data,Array,Abs) + 0xc0, // END_COLLECTION }; - -/* +/* * Descriptor for compite device: Keyboard + Mouse - * + * * contains: device, interface, HID and endpoint descriptors */ #if USB_CFG_DESCR_PROPS_CONFIGURATION -const PROGMEM char usbDescriptorConfiguration[] = { /* USB configuration descriptor */ - 9, /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */ - USBDESCR_CONFIG, /* descriptor type */ +const PROGMEM char usbDescriptorConfiguration[] = { + /* USB configuration descriptor */ + 9, /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */ + USBDESCR_CONFIG, /* descriptor type */ 9 + (9 + 9 + 7) + (9 + 9 + 7), 0, - //18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 + 9, 0, - /* total length of data returned (including inlined descriptors) */ - 2, /* 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 */ + // 18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 + 9, 0, + /* total length of data returned (including inlined descriptors) */ + 2, /* 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 */ /* * Keyboard interface */ /* Interface descriptor */ - 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, /* 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 */ + 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, /* 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 */ /* 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 */ - sizeof(keyboard_hid_report), 0, /* total length of report descriptor */ - /* Endpoint descriptor */ -#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 + 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 */ + sizeof(keyboard_hid_report), 0, /* total length of report descriptor */ +/* Endpoint descriptor */ +# 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 /* * Mouse interface */ /* Interface descriptor */ - 9, /* sizeof(usbDescrInterface): length of descriptor in bytes */ - USBDESCR_INTERFACE, /* descriptor type */ - 1, /* index of this interface */ - 0, /* alternate setting for this interface */ + 9, /* sizeof(usbDescrInterface): length of descriptor in bytes */ + USBDESCR_INTERFACE, /* descriptor type */ + 1, /* index of this interface */ + 0, /* alternate setting for this interface */ USB_CFG_HAVE_INTRIN_ENDPOINT3, /* endpoints excl 0: number of endpoint descriptors to follow */ - 0x03, /* CLASS: HID */ - 0, /* SUBCLASS: none */ - 0, /* PROTOCOL: none */ - 0, /* string index for interface */ + 0x03, /* CLASS: HID */ + 0, /* SUBCLASS: none */ + 0, /* PROTOCOL: none */ + 0, /* string index for interface */ /* 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 */ - sizeof(mouse_hid_report), 0, /* total length of report descriptor */ -#if USB_CFG_HAVE_INTRIN_ENDPOINT3 /* endpoint descriptor for endpoint 3 */ + 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 */ + sizeof(mouse_hid_report), 0, /* total length of report descriptor */ +# if USB_CFG_HAVE_INTRIN_ENDPOINT3 /* endpoint descriptor for endpoint 3 */ /* Endpoint descriptor */ - 7, /* sizeof(usbDescrEndpoint) */ - USBDESCR_ENDPOINT, /* descriptor type = endpoint */ + 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 - -USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq) -{ +USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq) { usbMsgLen_t len = 0; -/* - debug("usbFunctionDescriptor: "); - debug_hex(rq->bmRequestType); debug(" "); - debug_hex(rq->bRequest); debug(" "); - debug_hex16(rq->wValue.word); debug(" "); - debug_hex16(rq->wIndex.word); debug(" "); - debug_hex16(rq->wLength.word); debug("\n"); -*/ + /* + debug("usbFunctionDescriptor: "); + debug_hex(rq->bmRequestType); debug(" "); + debug_hex(rq->bRequest); debug(" "); + debug_hex16(rq->wValue.word); debug(" "); + debug_hex16(rq->wIndex.word); debug(" "); + debug_hex16(rq->wLength.word); debug("\n"); + */ switch (rq->wValue.bytes[1]) { #if USB_CFG_DESCR_PROPS_CONFIGURATION case USBDESCR_CONFIG: usbMsgPtr = (unsigned char *)usbDescriptorConfiguration; - len = sizeof(usbDescriptorConfiguration); + len = sizeof(usbDescriptorConfiguration); break; #endif case USBDESCR_HID: switch (rq->wValue.bytes[0]) { case 0: usbMsgPtr = (unsigned char *)(usbDescriptorConfiguration + 9 + 9); - len = 9; + len = 9; break; case 1: usbMsgPtr = (unsigned char *)(usbDescriptorConfiguration + 9 + (9 + 9 + 7) + 9); - len = 9; + len = 9; break; } break; @@ -504,15 +464,15 @@ USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq) switch (rq->wIndex.word) { case 0: usbMsgPtr = (unsigned char *)keyboard_hid_report; - len = sizeof(keyboard_hid_report); + len = sizeof(keyboard_hid_report); break; case 1: usbMsgPtr = (unsigned char *)mouse_hid_report; - len = sizeof(mouse_hid_report); + len = sizeof(mouse_hid_report); break; } break; } - //debug("desc len: "); debug_hex(len); debug("\n"); + // debug("desc len: "); debug_hex(len); debug("\n"); return len; } diff --git a/tmk_core/protocol/vusb/vusb.h b/tmk_core/protocol/vusb/vusb.h index 5accf233be..7e3f8c394d 100644 --- a/tmk_core/protocol/vusb/vusb.h +++ b/tmk_core/protocol/vusb/vusb.h @@ -20,8 +20,7 @@ along with this program. If not, see . #include "host_driver.h" - host_driver_t *vusb_driver(void); -void vusb_transfer_keyboard(void); +void vusb_transfer_keyboard(void); #endif -- cgit v1.2.3