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/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 ++++++++------- 5 files changed, 684 insertions(+), 698 deletions(-) (limited to 'tmk_core/protocol/vusb/usbdrv') 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<