/* Copyright (c) 2010, Peter Barrett ** Sleep/Wakeup support added by Michael Dreher ** ** Permission to use, copy, modify, and/or distribute this software for ** any purpose with or without fee is hereby granted, provided that the ** above copyright notice and this permission notice appear in all copies. ** ** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL ** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED ** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR ** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES ** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ** SOFTWARE. */ #include "USBAPI.h" #include "PluggableUSB.h" #include #if defined(USBCON) /** Pulse generation counters to keep track of the number of milliseconds remaining for each pulse type */ #define TX_RX_LED_PULSE_MS 100 volatile u8 TxLEDPulse; /**< Milliseconds remaining for data Tx LED pulse */ volatile u8 RxLEDPulse; /**< Milliseconds remaining for data Rx LED pulse */ //================================================================== //================================================================== extern const u16 STRING_LANGUAGE[] PROGMEM; extern const u8 STRING_PRODUCT[] PROGMEM; extern const u8 STRING_MANUFACTURER[] PROGMEM; const u16 STRING_LANGUAGE[2] = { (3<<8) | (2+2), 0x0409 // English }; #ifndef USB_PRODUCT // If no product is provided, use USB IO Board #define USB_PRODUCT "USB IO Board" #endif const u8 STRING_PRODUCT[] PROGMEM = USB_PRODUCT; #if USB_VID == 0x2341 # if defined(USB_MANUFACTURER) # undef USB_MANUFACTURER # endif # define USB_MANUFACTURER "Arduino LLC" #elif USB_VID == 0x1b4f # if defined(USB_MANUFACTURER) # undef USB_MANUFACTURER # endif # define USB_MANUFACTURER "SparkFun" #elif !defined(USB_MANUFACTURER) // Fall through to unknown if no manufacturer name was provided in a macro # define USB_MANUFACTURER "Unknown" #endif const u8 STRING_MANUFACTURER[] PROGMEM = USB_MANUFACTURER; //================================================================== //================================================================== volatile u8 _usbConfiguration = 0; volatile u8 _usbCurrentStatus = 0; // meaning of bits see usb_20.pdf, Figure 9-4. Information Returned by a GetStatus() Request to a Device volatile u8 _usbSuspendState = 0; // copy of UDINT to check SUSPI and WAKEUPI bits static inline void WaitIN(void) { while (!(UEINTX & (1< len) { n = len; } { LockEP lock(ep); // Frame may have been released by the SOF interrupt handler if (!ReadWriteAllowed()) continue; len -= n; if (ep & TRANSFER_ZERO) { while (n--) Send8(0); } else if (ep & TRANSFER_PGM) { while (n--) Send8(pgm_read_byte(data++)); } else { while (n--) Send8(*data++); } if (sendZlp) { ReleaseTX(); sendZlp = false; } else if (!ReadWriteAllowed()) { // ...release if buffer is full... ReleaseTX(); if (len == 0) sendZlp = true; } else if ((len == 0) && (ep & TRANSFER_RELEASE)) { // ...or if forced with TRANSFER_RELEASE // XXX: TRANSFER_RELEASE is never used can be removed? ReleaseTX(); } } } TXLED1; // light the TX LED TxLEDPulse = TX_RX_LED_PULSE_MS; return r; } #define EP_SINGLE_64 0x32 // EP0 #define EP_DOUBLE_64 0x36 // Other endpoints #define EP_SINGLE_16 0x12 static inline u8 BankSizeMask(const uint8_t nbytes) { uint8_t mask = 0; for (uint8_t size = 8; size < 64; size <<= 1) { if (nbytes <= size) break; mask++; } return (mask << EPSIZE0); } static inline void InitEP(u8 index, u8 type, u8 size) { UENUM = index; // Select endpoint UECONX = (1<= USB_ENDPOINTS) return false; uint8_t size = ((1 << ALLOC) | ((nbanks > 1) ? (1 << EPBK0) : 0) | BankSizeMask(banksize)); InitEP(index, type, size); return UESTA0X & (1 << CFGOK); // Success } static void InitEndpoints() { InitEPSize(XINPUT_TX_ENDPOINT, EP_TYPE_INTERRUPT_IN, 1, 32); // Control Data Send InitEPSize(XINPUT_RX_ENDPOINT, EP_TYPE_INTERRUPT_OUT, 2, 32); // Control Data Receive InitEPSize(5, EP_TYPE_INTERRUPT_IN, 1, 32); // Expansion Interface NACK (avoid config reset) UERST = 0x7E; // Reset endpoints UERST = 0; // End reset SetEP(XINPUT_RX_ENDPOINT); // Select XInput RX endpoint (OUT) UEIENX |= (1 << RXOUTE); // Enable received "OUT" interrupt } static int _cmark; static int _cend; void InitControl(int end) { SetEP(0); _cmark = 0; _cend = end; } static bool SendControl(u8 d) { if (_cmark < _cend) { if (!WaitForINOrOUT()) return false; Send8(d); if (!((_cmark + 1) & 0x3F)) ClearIN(); // Fifo is full, release this packet } _cmark++; return true; } // Clipped by _cmark/_cend int USB_SendControl(u8 flags, const void* d, int len) { int sent = len; const u8* data = (const u8*)d; bool pgm = flags & TRANSFER_PGM; while (len--) { u8 c = pgm ? pgm_read_byte(data++) : *data++; if (!SendControl(c)) return -1; } return sent; } // Send a USB descriptor string. The string is stored in PROGMEM as a // plain ASCII string but is sent out as UTF-16 with the correct 2-byte // prefix static bool USB_SendStringDescriptor(const u8*string_P, u8 string_len, uint8_t flags) { SendControl(2 + string_len * 2); SendControl(3); bool pgm = flags & TRANSFER_PGM; for(u8 i = 0; i < string_len; i++) { bool r = SendControl(pgm ? pgm_read_byte(&string_P[i]) : string_P[i]); r &= SendControl(0); // high byte if(!r) { return false; } } return true; } // Does not timeout or cross fifo boundaries int USB_RecvControl(void* d, int len) { auto length = len; while(length) { // Dont receive more than the USB Control EP has to offer // Use fixed 64 because control EP always have 64 bytes even on 16u2. auto recvLength = length; if(recvLength > 64){ recvLength = 64; } // Write data to fit to the end (not the beginning) of the array WaitOUT(); Recv((u8*)d + len - length, recvLength); ClearOUT(); length -= recvLength; } return len; } // Construct a dynamic configuration descriptor // This really needs dynamic endpoint allocation etc // TODO static bool SendConfiguration(int maxlen) { InitControl(maxlen); USB_SendControl(TRANSFER_PGM, &USB_ConfigDescriptor, USB_ConfigDescriptorSize); return true; } static bool SendDescriptor(USBSetup& setup) { u8 t = setup.wValueH; if (USB_CONFIGURATION_DESCRIPTOR_TYPE == t) return SendConfiguration(setup.wLength); InitControl(setup.wLength); #ifdef PLUGGABLE_USB_ENABLED int ret = PluggableUSB().getDescriptor(setup); if (ret != 0) { return (ret > 0 ? true : false); } #endif const u8* desc_addr = 0; if (USB_DEVICE_DESCRIPTOR_TYPE == t) { desc_addr = (const u8*) &USB_DeviceDescriptor; } else if (USB_STRING_DESCRIPTOR_TYPE == t) { if (setup.wValueL == 0) { desc_addr = (const u8*)&STRING_LANGUAGE; } else if (setup.wValueL == IPRODUCT) { return USB_SendStringDescriptor(STRING_PRODUCT, strlen(USB_PRODUCT), TRANSFER_PGM); } else if (setup.wValueL == IMANUFACTURER) { return USB_SendStringDescriptor(STRING_MANUFACTURER, strlen(USB_MANUFACTURER), TRANSFER_PGM); } else if (setup.wValueL == ISERIAL) { #ifdef PLUGGABLE_USB_ENABLED char name[ISERIAL_MAX_LEN]; PluggableUSB().getShortName(name); return USB_SendStringDescriptor((uint8_t*)name, strlen(name), 0); #else return USB_SendStringDescriptor(STRING_SERIAL, strlen((char*)STRING_SERIAL), TRANSFER_PGM); #endif } else if (setup.wValueL == ISECURITY) { return USB_SendStringDescriptor(STRING_SECURITY, strlen((char*)STRING_SECURITY), TRANSFER_PGM); } else return false; } if (desc_addr == 0) return false; u8 desc_length = pgm_read_byte(desc_addr); USB_SendControl(TRANSFER_PGM,desc_addr,desc_length); return true; } // Endpoint interrupt ISR(USB_COM_vect) { SetEP(XINPUT_RX_ENDPOINT); // Select XInput RX endpoint (OUT) if (UEINTX & (1 << RXOUTI)) { // If data received... UEINTX &= ~(1 << RXOUTI); // Clear interrupt flag if (XInputUSB::RecvCallback != nullptr) { XInputUSB::RecvCallback(); // Call callback function if it exists } } SetEP(0); if (!ReceivedSetupInt()) return; USBSetup setup; Recv((u8*)&setup,8); ClearSetupInt(); u8 requestType = setup.bmRequestType; if (requestType & REQUEST_DEVICETOHOST) WaitIN(); else ClearIN(); bool ok = true; if (REQUEST_STANDARD == (requestType & REQUEST_TYPE)) { // Standard Requests u8 r = setup.bRequest; u16 wValue = setup.wValueL | (setup.wValueH << 8); if (GET_STATUS == r) { if (requestType == (REQUEST_DEVICETOHOST | REQUEST_STANDARD | REQUEST_DEVICE)) { Send8(_usbCurrentStatus); Send8(0); } else { // TODO: handle the HALT state of an endpoint here // see "Figure 9-6. Information Returned by a GetStatus() Request to an Endpoint" in usb_20.pdf for more information Send8(0); Send8(0); } } else if (CLEAR_FEATURE == r) { if((requestType == (REQUEST_HOSTTODEVICE | REQUEST_STANDARD | REQUEST_DEVICE)) && (wValue == DEVICE_REMOTE_WAKEUP)) { _usbCurrentStatus &= ~FEATURE_REMOTE_WAKEUP_ENABLED; } } else if (SET_FEATURE == r) { if((requestType == (REQUEST_HOSTTODEVICE | REQUEST_STANDARD | REQUEST_DEVICE)) && (wValue == DEVICE_REMOTE_WAKEUP)) { _usbCurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED; } } else if (SET_ADDRESS == r) { WaitIN(); UDADDR = setup.wValueL | (1<