Mike R / USBDevice

USB device stack, with KL25Z fixes for USB 3.0 hosts and sleep/resume interrupt handling

Dependents:   frdm_Slider_Keyboard idd_hw2_figlax_PanType idd_hw2_appachu_finger_chording idd_hw3_AngieWangAntonioDeLimaFernandesDanielLim_BladeSymphony ... more

Fork of USBDevice by mbed official

This is an overhauled version of the standard mbed USB device-side driver library, with bug fixes for KL25Z devices. It greatly improves reliability and stability of USB on the KL25Z, especially with devices using multiple endpoints concurrently.

I've had some nagging problems with the base mbed implementation for a long time, manifesting as occasional random disconnects that required rebooting the device. Recently (late 2015), I started implementing a USB device on the KL25Z that used multiple endpoints, and suddenly the nagging, occasional problems turned into frequent and predictable crashes. This forced me to delve into the USB stack and figure out what was really going on. Happily, the frequent crashes made it possible to track down and fix the problems. This new version is working very reliably in my testing - the random disconnects seem completely eradicated, even under very stressful conditions for the device.

Summary

  • Overall stability improvements
  • USB 3.0 host support
  • Stalled endpoint fixes
  • Sleep/resume notifications
  • Smaller memory footprint
  • General code cleanup

Update - 2/15/2016

My recent fixes introduced a new problem that made the initial connection fail most of the time on certain hosts. It's not clear if the common thread was a particular type of motherboard or USB chip set, or a specific version of Windows, or what, but several people ran into it. We tracked the problem down to the "stall" fixes in the earlier updates, which we now know weren't quite the right fixes after all. The latest update (2/15/2016) fixes this. It has new and improved "unstall" handling that so far works well with diverse hosts.

Race conditions and overall stability

The base mbed KL25Z implementation has a lot of problems with "race conditions" - timing problems that can happen when hardware interrupts occur at inopportune moments. The library shares a bunch of static variable data between interrupt handler context and regular application context. This isn't automatically a bad thing, but it does require careful coordination to make sure that the interrupt handler doesn't corrupt data that the other code was in the middle of updating when an interrupt occurs. The base mbed code, though, doesn't do any of the necessary coordination. This makes it kind of amazing that the base code worked at all for anyone, but I guess the interrupt rate is low enough in most applications that the glitch rate was below anyone's threshold to seriously investigate.

This overhaul adds the necessary coordination for the interrupt handlers to protect against these data corruptions. I think it's very solid now, and hopefully entirely free of the numerous race conditions in the old code. It's always hard to be certain that you've fixed every possible bug like this because they strike (effectively) at random, but I'm pretty confident: my test application was reliably able to trigger glitches in the base code in a matter of minutes, but the same application (with the overhauled library) now runs for days on end without dropping the connection.

Stalled endpoint fixes

USB has a standard way of handling communications errors called a "stall", which basically puts the connection into an error mode to let both sides know that they need to reset their internal states and sync up again. The original mbed version of the USB device library doesn't seem to have the necessary code to recover from this condition properly. The KL25Z hardware does some of the work, but it also seems to require the software to take some steps to "un-stall" the connection. (I keep saying "seems to" because the hardware reference material is very sketchy about all of this. Most of what I've figured out is from observing the device in action with a Windows host.) This new version adds code to do the necessary re-syncing and get the connection going again, automatically, and transparently to the user.

USB 3.0 Hosts

The original mbed code sometimes didn't work when connecting to hosts with USB 3.0 ports. This didn't affect every host, but it affected many of them. The common element seemed to be the Intel Haswell chip set on the host, but there may be other chip sets affected as well. In any case, the problem affected many PCs from the Windows 7 and 8 generation, as well as many Macs. It was possible to work around the problem by avoiding USB 3.0 ports - you could use a USB 2 port on the host, or plug a USB 2 hub between the host and device. But I wanted to just fix the problem and eliminate the need for such workarounds. This modified version of the library has such a fix, which so far has worked for everyone who's tried.

Sleep/resume notifications

This modified version also contains an innocuous change to the KL25Z USB HAL code to handle sleep and resume interrupts with calls to suspendStateChanged(). The original KL25Z code omitted these calls (and in fact didn't even enable the interrupts), but I think this was an unintentional oversight - the notifier function is part of the generic API, and other supported boards all implement it. I use this feature in my own application so that I can distinguish sleep mode from actual disconnects and handle the two conditions correctly.

Smaller memory footprint

The base mbed version of the code allocates twice as much memory for USB buffers as it really needed to. It looks like the original developers intended to implement the KL25Z USB hardware's built-in double-buffering mechanism, but they ultimately abandoned that effort. But they left in the double memory allocation. This version removes that and allocates only what's actually needed. The USB buffers aren't that big (128 bytes per endpoint), so this doesn't save a ton of memory, but even a little memory is pretty precious on this machine given that it only has 16K.

(I did look into adding the double-buffering support that the original developers abandoned, but after some experimentation I decided they were right to skip it. It just doesn't seem to mesh well with the design of the rest of the mbed USB code. I think it would take a major rewrite to make it work, and it doesn't seem worth the effort given that most applications don't need it - it would only benefit applications that are moving so much data through USB that they're pushing the limits of the CPU. And even for those, I think it would be a lot simpler to build a purely software-based buffer rotation mechanism.)

General code cleanup

The KL25Z HAL code in this version has greatly expanded commentary and a lot of general cleanup. Some of the hardware constants were given the wrong symbolic names (e.g., EVEN and ODD were reversed), and many were just missing (written as hard-coded numbers without explanation). I fixed the misnomers and added symbolic names for formerly anonymous numbers. Hopefully the next person who has to overhaul this code will at least have an easier time understanding what I thought I was doing!

USBDevice/USBDevice.cpp@54:2e181d51495a, 2017-03-17 (annotated)

Committer:
mjr
Date:
Fri Mar 17 22:01:47 2017 +0000
Revision:
54:2e181d51495a
Parent:
53:c8110529c24b 
Comments

Who changed what in which revision?

UserRevisionLine numberNew contents of line
samux 1:80ab0d068708 1 /* Copyright (c) 2010-2011 mbed.org, MIT License
samux 1:80ab0d068708 2 *
samux 1:80ab0d068708 3 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
samux 1:80ab0d068708 4 * and associated documentation files (the "Software"), to deal in the Software without
samux 1:80ab0d068708 5 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
samux 1:80ab0d068708 6 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
samux 1:80ab0d068708 7 * Software is furnished to do so, subject to the following conditions:
samux 1:80ab0d068708 8 *
samux 1:80ab0d068708 9 * The above copyright notice and this permission notice shall be included in all copies or
samux 1:80ab0d068708 10 * substantial portions of the Software.
samux 1:80ab0d068708 11 *
samux 1:80ab0d068708 12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
samux 1:80ab0d068708 13 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
samux 1:80ab0d068708 14 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
samux 1:80ab0d068708 15 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
samux 1:80ab0d068708 16 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
samux 1:80ab0d068708 17 */
samux 1:80ab0d068708 18
samux 1:80ab0d068708 19 #include "stdint.h"
samux 1:80ab0d068708 20
samux 1:80ab0d068708 21 #include "USBEndpoints.h"
samux 1:80ab0d068708 22 #include "USBDevice.h"
samux 1:80ab0d068708 23 #include "USBDescriptor.h"
samux 1:80ab0d068708 24
mjr 50:946bc763c068 25 //#define DEBUG_WITH_PRINTF
mjr 50:946bc763c068 26 #ifdef DEBUG_WITH_PRINTF
mjr 50:946bc763c068 27 // debug printf; does a regular printf() in debug mode, nothing in
mjr 50:946bc763c068 28 // normal mode. Note that many of our routines are called in ISR
mjr 50:946bc763c068 29 // context, so printf should really never be used here. But in
mjr 50:946bc763c068 30 // practice we can get away with it enough that it can be helpful
mjr 50:946bc763c068 31 // as a limited debugging tool.
mjr 37:c5ac4ccf6597 32 #define printd(fmt, ...) printf(fmt, __VA_ARGS__)
mjr 37:c5ac4ccf6597 33 #else
mjr 37:c5ac4ccf6597 34 #define printd(fmt, ...)
mjr 37:c5ac4ccf6597 35 #endif
samux 1:80ab0d068708 36
mjr 50:946bc763c068 37 // Makeshift HAL debug instrumentation. This is a safer and better
mjr 50:946bc763c068 38 // alternative to printf() that gathers event information in a
mjr 50:946bc763c068 39 // circular buffer for later useoutside of interrupt context, such
mjr 50:946bc763c068 40 // as printf() display at intervals in the main program loop.
mjr 50:946bc763c068 41 //
mjr 50:946bc763c068 42 // Timing is critical to USB, so debug instrumentation is inherently
mjr 50:946bc763c068 43 // problematic in that it can affect the timing and thereby change
mjr 50:946bc763c068 44 // the behavior of what we're trying to debug. Small timing changes
mjr 50:946bc763c068 45 // can create new errors that wouldn't be there otherwise, or even
mjr 50:946bc763c068 46 // accidentally fix the bug were trying to find (e.g., by changing
mjr 50:946bc763c068 47 // the timing enough to avoid a race condition). To minimize these
mjr 50:946bc763c068 48 // effects, we use a small buffer and very terse event codes -
mjr 50:946bc763c068 49 // generally one character per event. That makes for a cryptic
mjr 50:946bc763c068 50 // debug log, but it results in almost zero timing effects, allowing
mjr 50:946bc763c068 51 // us to see a more faithful version of the subject program.
mjr 50:946bc763c068 52 //
mjr 50:946bc763c068 53 // NB: Implemented only for KL25Z.
mjr 50:946bc763c068 54 //#define DEBUG_WITH_EVENTS
mjr 50:946bc763c068 55 #ifdef DEBUG_WITH_EVENTS
mjr 50:946bc763c068 56 extern void HAL_DEBUG_EVENT(char c);
mjr 50:946bc763c068 57 extern void HAL_DEBUG_EVENT(char a, char b);
mjr 50:946bc763c068 58 extern void HAL_DEBUG_EVENT(char a, char b, char c);
mjr 50:946bc763c068 59 extern void HAL_DEBUG_EVENT(const char *s);
mjr 50:946bc763c068 60 extern void HAL_DEBUG_EVENTF(const char *f, ...);
mjr 50:946bc763c068 61 #else
mjr 50:946bc763c068 62 #define HAL_DEBUG_EVENT(...)
mjr 50:946bc763c068 63 #define HAL_DEBUG_EVENTF(...)
mjr 50:946bc763c068 64 #endif
mjr 50:946bc763c068 65
samux 1:80ab0d068708 66 /* Device status */
samux 1:80ab0d068708 67 #define DEVICE_STATUS_SELF_POWERED (1U<<0)
samux 1:80ab0d068708 68 #define DEVICE_STATUS_REMOTE_WAKEUP (1U<<1)
samux 1:80ab0d068708 69
samux 1:80ab0d068708 70 /* Endpoint status */
samux 1:80ab0d068708 71 #define ENDPOINT_STATUS_HALT (1U<<0)
samux 1:80ab0d068708 72
samux 1:80ab0d068708 73 /* Standard feature selectors */
samux 1:80ab0d068708 74 #define DEVICE_REMOTE_WAKEUP (1)
samux 1:80ab0d068708 75 #define ENDPOINT_HALT (0)
samux 1:80ab0d068708 76
samux 1:80ab0d068708 77 /* Macro to convert wIndex endpoint number to physical endpoint number */
samux 1:80ab0d068708 78 #define WINDEX_TO_PHYSICAL(endpoint) (((endpoint & 0x0f) << 1) + \
samux 1:80ab0d068708 79 ((endpoint & 0x80) ? 1 : 0))
samux 1:80ab0d068708 80
samux 1:80ab0d068708 81 bool USBDevice::requestGetDescriptor(void)
samux 1:80ab0d068708 82 {
mjr 54:2e181d51495a 83 const uint8_t *p;
samux 1:80ab0d068708 84 bool success = false;
mjr 37:c5ac4ccf6597 85 printd("get descr: type: %d\r\n", DESCRIPTOR_TYPE(transfer.setup.wValue));
samux 1:80ab0d068708 86 switch (DESCRIPTOR_TYPE(transfer.setup.wValue))
samux 1:80ab0d068708 87 {
mjr 50:946bc763c068 88 case DEVICE_DESCRIPTOR:
mjr 54:2e181d51495a 89 if ((p = deviceDesc()) != NULL)
mjr 50:946bc763c068 90 {
mjr 54:2e181d51495a 91 if (p[0] == DEVICE_DESCRIPTOR_LENGTH && p[1] == DEVICE_DESCRIPTOR)
samux 1:80ab0d068708 92 {
mjr 50:946bc763c068 93 printd("device descr\r\n");
mjr 50:946bc763c068 94 transfer.remaining = DEVICE_DESCRIPTOR_LENGTH;
mjr 54:2e181d51495a 95 transfer.ptr = p;
mjr 50:946bc763c068 96 transfer.direction = DEVICE_TO_HOST;
mjr 50:946bc763c068 97 success = true;
mjr 50:946bc763c068 98 }
mjr 50:946bc763c068 99 }
mjr 50:946bc763c068 100 break;
samux 1:80ab0d068708 101
mjr 50:946bc763c068 102 case CONFIGURATION_DESCRIPTOR:
mjr 54:2e181d51495a 103 if ((p = configurationDesc()) != NULL)
mjr 50:946bc763c068 104 {
mjr 54:2e181d51495a 105 if (p[0] == CONFIGURATION_DESCRIPTOR_LENGTH && p[1] == CONFIGURATION_DESCRIPTOR)
samux 1:80ab0d068708 106 {
mjr 50:946bc763c068 107 printd("conf descr request\r\n");
mjr 50:946bc763c068 108
mjr 50:946bc763c068 109 /* Get wTotalLength */
mjr 54:2e181d51495a 110 transfer.remaining = p[2] | (p[3] << 8);
mjr 54:2e181d51495a 111 transfer.ptr = p;
mjr 50:946bc763c068 112 transfer.direction = DEVICE_TO_HOST;
mjr 50:946bc763c068 113 success = true;
samux 1:80ab0d068708 114 }
mjr 50:946bc763c068 115 }
mjr 50:946bc763c068 116 break;
mjr 50:946bc763c068 117
mjr 50:946bc763c068 118 case STRING_DESCRIPTOR:
mjr 50:946bc763c068 119 printd("str descriptor\r\n");
mjr 50:946bc763c068 120 switch (DESCRIPTOR_INDEX(transfer.setup.wValue))
mjr 50:946bc763c068 121 {
mjr 50:946bc763c068 122 case STRING_OFFSET_LANGID:
mjr 50:946bc763c068 123 printd("1\r\n");
mjr 50:946bc763c068 124 transfer.ptr = stringLangidDesc();
mjr 54:2e181d51495a 125 transfer.remaining = transfer.ptr[0];
mjr 50:946bc763c068 126 transfer.direction = DEVICE_TO_HOST;
mjr 50:946bc763c068 127 success = true;
mjr 37:c5ac4ccf6597 128 break;
mjr 37:c5ac4ccf6597 129
mjr 50:946bc763c068 130 case STRING_OFFSET_IMANUFACTURER:
mjr 50:946bc763c068 131 printd("2\r\n");
mjr 50:946bc763c068 132 transfer.ptr = stringImanufacturerDesc();
mjr 54:2e181d51495a 133 transfer.remaining = transfer.ptr[0];
mjr 50:946bc763c068 134 transfer.direction = DEVICE_TO_HOST;
mjr 50:946bc763c068 135 success = true;
mjr 50:946bc763c068 136 break;
mjr 50:946bc763c068 137
mjr 50:946bc763c068 138 case STRING_OFFSET_IPRODUCT:
mjr 50:946bc763c068 139 printd("3\r\n");
mjr 50:946bc763c068 140 transfer.ptr = stringIproductDesc();
mjr 54:2e181d51495a 141 transfer.remaining = transfer.ptr[0];
mjr 50:946bc763c068 142 transfer.direction = DEVICE_TO_HOST;
mjr 50:946bc763c068 143 success = true;
mjr 50:946bc763c068 144 break;
mjr 50:946bc763c068 145
mjr 50:946bc763c068 146 case STRING_OFFSET_ISERIAL:
mjr 50:946bc763c068 147 printd("4\r\n");
mjr 50:946bc763c068 148 transfer.ptr = stringIserialDesc();
mjr 54:2e181d51495a 149 transfer.remaining = transfer.ptr[0];
mjr 50:946bc763c068 150 transfer.direction = DEVICE_TO_HOST;
mjr 50:946bc763c068 151 success = true;
samux 1:80ab0d068708 152 break;
mjr 37:c5ac4ccf6597 153
mjr 50:946bc763c068 154 case STRING_OFFSET_ICONFIGURATION:
mjr 50:946bc763c068 155 printd("5\r\n");
mjr 50:946bc763c068 156 transfer.ptr = stringIConfigurationDesc();
mjr 54:2e181d51495a 157 transfer.remaining = transfer.ptr[0];
mjr 50:946bc763c068 158 transfer.direction = DEVICE_TO_HOST;
mjr 50:946bc763c068 159 success = true;
mjr 50:946bc763c068 160 break;
mjr 50:946bc763c068 161
mjr 50:946bc763c068 162 case STRING_OFFSET_IINTERFACE:
mjr 50:946bc763c068 163 printd("6\r\n");
mjr 50:946bc763c068 164 transfer.ptr = stringIinterfaceDesc();
mjr 54:2e181d51495a 165 transfer.remaining = transfer.ptr[0];
mjr 50:946bc763c068 166 transfer.direction = DEVICE_TO_HOST;
mjr 50:946bc763c068 167 success = true;
samux 1:80ab0d068708 168 break;
mjr 50:946bc763c068 169 }
mjr 50:946bc763c068 170 break;
mjr 50:946bc763c068 171
mjr 50:946bc763c068 172 case INTERFACE_DESCRIPTOR:
mjr 50:946bc763c068 173 printd("interface descr\r\n");
mjr 50:946bc763c068 174 break;
mjr 50:946bc763c068 175
mjr 50:946bc763c068 176 case ENDPOINT_DESCRIPTOR:
mjr 50:946bc763c068 177 /* TODO: Support is optional, not implemented here */
mjr 50:946bc763c068 178 printd("endpoint descr\r\n");
mjr 50:946bc763c068 179 break;
mjr 50:946bc763c068 180
mjr 50:946bc763c068 181 default:
mjr 50:946bc763c068 182 printd("ERROR - unknown descriptor type in GET DESCRIPTOR\r\n");
mjr 50:946bc763c068 183 break;
samux 1:80ab0d068708 184 }
samux 1:80ab0d068708 185
samux 1:80ab0d068708 186 return success;
samux 1:80ab0d068708 187 }
samux 1:80ab0d068708 188
samux 1:80ab0d068708 189 void USBDevice::decodeSetupPacket(uint8_t *data, SETUP_PACKET *packet)
samux 1:80ab0d068708 190 {
samux 1:80ab0d068708 191 /* Fill in the elements of a SETUP_PACKET structure from raw data */
samux 1:80ab0d068708 192 packet->bmRequestType.dataTransferDirection = (data[0] & 0x80) >> 7;
samux 1:80ab0d068708 193 packet->bmRequestType.Type = (data[0] & 0x60) >> 5;
samux 1:80ab0d068708 194 packet->bmRequestType.Recipient = data[0] & 0x1f;
samux 1:80ab0d068708 195 packet->bRequest = data[1];
samux 1:80ab0d068708 196 packet->wValue = (data[2] | (uint16_t)data[3] << 8);
samux 1:80ab0d068708 197 packet->wIndex = (data[4] | (uint16_t)data[5] << 8);
samux 1:80ab0d068708 198 packet->wLength = (data[6] | (uint16_t)data[7] << 8);
samux 1:80ab0d068708 199 }
samux 1:80ab0d068708 200
samux 1:80ab0d068708 201
samux 1:80ab0d068708 202 bool USBDevice::controlOut(void)
samux 1:80ab0d068708 203 {
samux 1:80ab0d068708 204 /* Control transfer data OUT stage */
samux 1:80ab0d068708 205 uint8_t buffer[MAX_PACKET_SIZE_EP0];
samux 1:80ab0d068708 206 uint32_t packetSize;
samux 1:80ab0d068708 207
samux 1:80ab0d068708 208 /* Check we should be transferring data OUT */
samux 1:80ab0d068708 209 if (transfer.direction != HOST_TO_DEVICE)
samux 1:80ab0d068708 210 {
mjr 30:2f8f4c3822a1 211 #if defined(TARGET_KL25Z) | defined(TARGET_KL46Z) | defined(TARGET_K20D5M) | defined(TARGET_K64F)
mjr 29:b502c11a3dff 212 /*
mjr 29:b502c11a3dff 213 * We seem to have a pending device-to-host transfer. The host must have
mjr 29:b502c11a3dff 214 * sent a new control request without waiting for us to finish processing
mjr 29:b502c11a3dff 215 * the previous one. This appears to happen when we're connected to certain
mjr 50:946bc763c068 216 * USB 3.0 host chip sets. Do a zero-length send and return failure to tell
mjr 50:946bc763c068 217 * the host we're not ready for the new request. That'll make it resend.
mjr 29:b502c11a3dff 218 */
mjr 50:946bc763c068 219 EP0write(NULL, 0);
mjr 31:81f57ea86f8f 220
mjr 36:20bb47609697 221 /* execute our pending transfer */
mjr 31:81f57ea86f8f 222 controlIn();
mjr 31:81f57ea86f8f 223
mjr 48:b225d025ca1d 224 /* indicate failure */
mjr 48:b225d025ca1d 225 return false;
mjr 29:b502c11a3dff 226 #else
mjr 31:81f57ea86f8f 227 /* for other platforms, count on the HAL to handle this case */
mjr 31:81f57ea86f8f 228 return false;
mjr 29:b502c11a3dff 229 #endif
samux 1:80ab0d068708 230 }
samux 1:80ab0d068708 231
samux 1:80ab0d068708 232 /* Read from endpoint */
samux 1:80ab0d068708 233 packetSize = EP0getReadResult(buffer);
samux 1:80ab0d068708 234
samux 1:80ab0d068708 235 /* Check if transfer size is valid */
samux 1:80ab0d068708 236 if (packetSize > transfer.remaining)
samux 1:80ab0d068708 237 {
samux 1:80ab0d068708 238 /* Too big */
samux 1:80ab0d068708 239 return false;
samux 1:80ab0d068708 240 }
samux 1:80ab0d068708 241
samux 1:80ab0d068708 242 /* Update transfer */
samux 1:80ab0d068708 243 transfer.ptr += packetSize;
samux 1:80ab0d068708 244 transfer.remaining -= packetSize;
samux 1:80ab0d068708 245
samux 1:80ab0d068708 246 /* Check if transfer has completed */
samux 1:80ab0d068708 247 if (transfer.remaining == 0)
samux 1:80ab0d068708 248 {
samux 1:80ab0d068708 249 /* Transfer completed */
samux 1:80ab0d068708 250 if (transfer.notify)
samux 1:80ab0d068708 251 {
samux 1:80ab0d068708 252 /* Notify class layer. */
samux 1:80ab0d068708 253 USBCallback_requestCompleted(buffer, packetSize);
samux 1:80ab0d068708 254 transfer.notify = false;
samux 1:80ab0d068708 255 }
mjr 50:946bc763c068 256
samux 1:80ab0d068708 257 /* Status stage */
samux 1:80ab0d068708 258 EP0write(NULL, 0);
samux 1:80ab0d068708 259 }
samux 1:80ab0d068708 260 else
samux 1:80ab0d068708 261 {
samux 1:80ab0d068708 262 EP0read();
samux 1:80ab0d068708 263 }
samux 1:80ab0d068708 264
samux 1:80ab0d068708 265 return true;
samux 1:80ab0d068708 266 }
samux 1:80ab0d068708 267
samux 1:80ab0d068708 268 bool USBDevice::controlIn(void)
samux 1:80ab0d068708 269 {
samux 1:80ab0d068708 270 /* Control transfer data IN stage */
samux 1:80ab0d068708 271 uint32_t packetSize;
samux 1:80ab0d068708 272
samux 1:80ab0d068708 273 /* Check if transfer has completed (status stage transactions */
samux 1:80ab0d068708 274 /* also have transfer.remaining == 0) */
samux 1:80ab0d068708 275 if (transfer.remaining == 0)
samux 1:80ab0d068708 276 {
samux 1:80ab0d068708 277 if (transfer.zlp)
samux 1:80ab0d068708 278 {
samux 1:80ab0d068708 279 /* Send zero length packet */
samux 1:80ab0d068708 280 EP0write(NULL, 0);
samux 1:80ab0d068708 281 transfer.zlp = false;
samux 1:80ab0d068708 282 }
samux 1:80ab0d068708 283
samux 1:80ab0d068708 284 /* Transfer completed */
samux 1:80ab0d068708 285 if (transfer.notify)
samux 1:80ab0d068708 286 {
samux 1:80ab0d068708 287 /* Notify class layer. */
samux 1:80ab0d068708 288 USBCallback_requestCompleted(NULL, 0);
samux 1:80ab0d068708 289 transfer.notify = false;
samux 1:80ab0d068708 290 }
samux 1:80ab0d068708 291
mjr 51:666cc4fedd3f 292 EP0read();
samux 8:335f2506f422 293 EP0readStage();
samux 1:80ab0d068708 294
samux 1:80ab0d068708 295 /* Completed */
samux 1:80ab0d068708 296 return true;
samux 1:80ab0d068708 297 }
samux 1:80ab0d068708 298
samux 1:80ab0d068708 299 /* Check we should be transferring data IN */
samux 1:80ab0d068708 300 if (transfer.direction != DEVICE_TO_HOST)
samux 1:80ab0d068708 301 {
samux 1:80ab0d068708 302 return false;
samux 1:80ab0d068708 303 }
samux 1:80ab0d068708 304
samux 1:80ab0d068708 305 packetSize = transfer.remaining;
samux 1:80ab0d068708 306
samux 1:80ab0d068708 307 if (packetSize > MAX_PACKET_SIZE_EP0)
samux 1:80ab0d068708 308 {
samux 1:80ab0d068708 309 packetSize = MAX_PACKET_SIZE_EP0;
samux 1:80ab0d068708 310 }
samux 1:80ab0d068708 311
samux 1:80ab0d068708 312 /* Write to endpoint */
samux 1:80ab0d068708 313 EP0write(transfer.ptr, packetSize);
samux 1:80ab0d068708 314
samux 1:80ab0d068708 315 /* Update transfer */
samux 1:80ab0d068708 316 transfer.ptr += packetSize;
samux 1:80ab0d068708 317 transfer.remaining -= packetSize;
mjr 36:20bb47609697 318
mjr 36:20bb47609697 319 /* success */
samux 1:80ab0d068708 320 return true;
samux 1:80ab0d068708 321 }
samux 1:80ab0d068708 322
samux 1:80ab0d068708 323 bool USBDevice::requestSetAddress(void)
samux 1:80ab0d068708 324 {
samux 1:80ab0d068708 325 /* Set the device address */
samux 1:80ab0d068708 326 setAddress(transfer.setup.wValue);
samux 1:80ab0d068708 327
samux 1:80ab0d068708 328 if (transfer.setup.wValue == 0)
samux 1:80ab0d068708 329 {
mjr 50:946bc763c068 330 setDeviceState(DEFAULT);
samux 1:80ab0d068708 331 }
samux 1:80ab0d068708 332 else
samux 1:80ab0d068708 333 {
mjr 50:946bc763c068 334 setDeviceState(ADDRESS);
samux 1:80ab0d068708 335 }
samux 1:80ab0d068708 336
samux 1:80ab0d068708 337 return true;
samux 1:80ab0d068708 338 }
samux 1:80ab0d068708 339
samux 1:80ab0d068708 340 bool USBDevice::requestSetConfiguration(void)
samux 1:80ab0d068708 341 {
mjr 50:946bc763c068 342 /* Set the device configuration */
samux 1:80ab0d068708 343 device.configuration = transfer.setup.wValue;
samux 1:80ab0d068708 344 if (device.configuration == 0)
samux 1:80ab0d068708 345 {
samux 1:80ab0d068708 346 /* Not configured */
samux 1:80ab0d068708 347 unconfigureDevice();
mjr 50:946bc763c068 348 setDeviceState(ADDRESS);
samux 1:80ab0d068708 349 }
samux 1:80ab0d068708 350 else
samux 1:80ab0d068708 351 {
samux 1:80ab0d068708 352 if (USBCallback_setConfiguration(device.configuration))
samux 1:80ab0d068708 353 {
samux 1:80ab0d068708 354 /* Valid configuration */
samux 1:80ab0d068708 355 configureDevice();
mjr 50:946bc763c068 356 setDeviceState(CONFIGURED);
samux 1:80ab0d068708 357 }
samux 1:80ab0d068708 358 else
samux 1:80ab0d068708 359 {
samux 1:80ab0d068708 360 return false;
samux 1:80ab0d068708 361 }
samux 1:80ab0d068708 362 }
samux 1:80ab0d068708 363
samux 1:80ab0d068708 364 return true;
samux 1:80ab0d068708 365 }
samux 1:80ab0d068708 366
samux 1:80ab0d068708 367 bool USBDevice::requestGetConfiguration(void)
samux 1:80ab0d068708 368 {
samux 1:80ab0d068708 369 /* Send the device configuration */
samux 1:80ab0d068708 370 transfer.ptr = &device.configuration;
samux 1:80ab0d068708 371 transfer.remaining = sizeof(device.configuration);
samux 1:80ab0d068708 372 transfer.direction = DEVICE_TO_HOST;
samux 1:80ab0d068708 373 return true;
samux 1:80ab0d068708 374 }
samux 1:80ab0d068708 375
mjr 53:c8110529c24b 376 /* Return the currently selected alternate for an interface */
samux 1:80ab0d068708 377 bool USBDevice::requestGetInterface(void)
samux 1:80ab0d068708 378 {
mjr 53:c8110529c24b 379 /* we must be configured first */
samux 1:80ab0d068708 380 if (device.state != CONFIGURED)
samux 1:80ab0d068708 381 return false;
mjr 53:c8110529c24b 382
mjr 53:c8110529c24b 383 /* ask the callback for an alternate; use 0 by default */
mjr 53:c8110529c24b 384 static uint8_t alt;
mjr 53:c8110529c24b 385 if (!USBCallback_getInterface(transfer.setup.wIndex, &alt))
mjr 53:c8110529c24b 386 alt = 0;
mjr 53:c8110529c24b 387
mjr 53:c8110529c24b 388 /* return the alternate */
mjr 53:c8110529c24b 389 transfer.ptr = &alt;
mjr 53:c8110529c24b 390 transfer.remaining = sizeof(alt);
samux 1:80ab0d068708 391 transfer.direction = DEVICE_TO_HOST;
samux 1:80ab0d068708 392 return true;
samux 1:80ab0d068708 393 }
samux 1:80ab0d068708 394
mjr 53:c8110529c24b 395 /* Set the current alternate for an interface */
samux 1:80ab0d068708 396 bool USBDevice::requestSetInterface(void)
samux 1:80ab0d068708 397 {
mjr 53:c8110529c24b 398 /* handle it through the callback */
mjr 53:c8110529c24b 399 return USBCallback_setInterface(transfer.setup.wIndex, transfer.setup.wValue);
samux 1:80ab0d068708 400 }
samux 1:80ab0d068708 401
samux 1:80ab0d068708 402 bool USBDevice::requestSetFeature()
samux 1:80ab0d068708 403 {
samux 1:80ab0d068708 404 bool success = false;
samux 1:80ab0d068708 405
samux 1:80ab0d068708 406 if (device.state != CONFIGURED)
samux 1:80ab0d068708 407 {
samux 1:80ab0d068708 408 /* Endpoint or interface must be zero */
samux 1:80ab0d068708 409 if (transfer.setup.wIndex != 0)
samux 1:80ab0d068708 410 {
samux 1:80ab0d068708 411 return false;
samux 1:80ab0d068708 412 }
samux 1:80ab0d068708 413 }
samux 1:80ab0d068708 414
samux 1:80ab0d068708 415 switch (transfer.setup.bmRequestType.Recipient)
samux 1:80ab0d068708 416 {
samux 1:80ab0d068708 417 case DEVICE_RECIPIENT:
samux 1:80ab0d068708 418 /* TODO: Remote wakeup feature not supported */
samux 1:80ab0d068708 419 break;
samux 1:80ab0d068708 420 case ENDPOINT_RECIPIENT:
samux 1:80ab0d068708 421 if (transfer.setup.wValue == ENDPOINT_HALT)
samux 1:80ab0d068708 422 {
samux 1:80ab0d068708 423 /* TODO: We should check that the endpoint number is valid */
samux 1:80ab0d068708 424 stallEndpoint(
samux 1:80ab0d068708 425 WINDEX_TO_PHYSICAL(transfer.setup.wIndex));
samux 1:80ab0d068708 426 success = true;
samux 1:80ab0d068708 427 }
samux 1:80ab0d068708 428 break;
samux 1:80ab0d068708 429 default:
samux 1:80ab0d068708 430 break;
samux 1:80ab0d068708 431 }
samux 1:80ab0d068708 432
samux 1:80ab0d068708 433 return success;
samux 1:80ab0d068708 434 }
samux 1:80ab0d068708 435
samux 1:80ab0d068708 436 bool USBDevice::requestClearFeature()
samux 1:80ab0d068708 437 {
samux 1:80ab0d068708 438 bool success = false;
samux 1:80ab0d068708 439
samux 1:80ab0d068708 440 if (device.state != CONFIGURED)
samux 1:80ab0d068708 441 {
samux 1:80ab0d068708 442 /* Endpoint or interface must be zero */
samux 1:80ab0d068708 443 if (transfer.setup.wIndex != 0)
samux 1:80ab0d068708 444 {
samux 1:80ab0d068708 445 return false;
samux 1:80ab0d068708 446 }
samux 1:80ab0d068708 447 }
samux 1:80ab0d068708 448
samux 1:80ab0d068708 449 switch (transfer.setup.bmRequestType.Recipient)
samux 1:80ab0d068708 450 {
samux 1:80ab0d068708 451 case DEVICE_RECIPIENT:
samux 1:80ab0d068708 452 /* TODO: Remote wakeup feature not supported */
samux 1:80ab0d068708 453 break;
samux 1:80ab0d068708 454 case ENDPOINT_RECIPIENT:
samux 1:80ab0d068708 455 /* TODO: We should check that the endpoint number is valid */
samux 1:80ab0d068708 456 if (transfer.setup.wValue == ENDPOINT_HALT)
samux 1:80ab0d068708 457 {
samux 1:80ab0d068708 458 unstallEndpoint( WINDEX_TO_PHYSICAL(transfer.setup.wIndex));
samux 1:80ab0d068708 459 success = true;
samux 1:80ab0d068708 460 }
samux 1:80ab0d068708 461 break;
samux 1:80ab0d068708 462 default:
samux 1:80ab0d068708 463 break;
samux 1:80ab0d068708 464 }
samux 1:80ab0d068708 465
samux 1:80ab0d068708 466 return success;
samux 1:80ab0d068708 467 }
samux 1:80ab0d068708 468
samux 1:80ab0d068708 469 bool USBDevice::requestGetStatus(void)
samux 1:80ab0d068708 470 {
samux 1:80ab0d068708 471 static uint16_t status;
samux 1:80ab0d068708 472 bool success = false;
samux 1:80ab0d068708 473
samux 1:80ab0d068708 474 if (device.state != CONFIGURED)
samux 1:80ab0d068708 475 {
samux 1:80ab0d068708 476 /* Endpoint or interface must be zero */
samux 1:80ab0d068708 477 if (transfer.setup.wIndex != 0)
samux 1:80ab0d068708 478 return false;
samux 1:80ab0d068708 479 }
samux 1:80ab0d068708 480
samux 1:80ab0d068708 481 switch (transfer.setup.bmRequestType.Recipient)
samux 1:80ab0d068708 482 {
mjr 50:946bc763c068 483 case DEVICE_RECIPIENT:
mjr 50:946bc763c068 484 /* TODO: Currently only supports self powered devices */
mjr 50:946bc763c068 485 status = DEVICE_STATUS_SELF_POWERED;
mjr 50:946bc763c068 486 success = true;
mjr 50:946bc763c068 487 break;
mjr 50:946bc763c068 488
mjr 50:946bc763c068 489 case INTERFACE_RECIPIENT:
mjr 50:946bc763c068 490 status = 0;
mjr 50:946bc763c068 491 success = true;
mjr 50:946bc763c068 492 break;
mjr 50:946bc763c068 493
mjr 50:946bc763c068 494 case ENDPOINT_RECIPIENT:
mjr 50:946bc763c068 495 /* TODO: We should check that the endpoint number is valid */
mjr 50:946bc763c068 496 if (getEndpointStallState(WINDEX_TO_PHYSICAL(transfer.setup.wIndex)))
mjr 50:946bc763c068 497 {
mjr 50:946bc763c068 498 status = ENDPOINT_STATUS_HALT;
mjr 50:946bc763c068 499 }
mjr 50:946bc763c068 500 else
mjr 50:946bc763c068 501 {
samux 1:80ab0d068708 502 status = 0;
mjr 50:946bc763c068 503 }
mjr 50:946bc763c068 504 success = true;
mjr 50:946bc763c068 505 break;
mjr 50:946bc763c068 506
mjr 50:946bc763c068 507 default:
mjr 50:946bc763c068 508 break;
samux 1:80ab0d068708 509 }
samux 1:80ab0d068708 510
samux 1:80ab0d068708 511 if (success)
samux 1:80ab0d068708 512 {
mbed_official 25:7c72828865f3 513 /* Send the status */
samux 1:80ab0d068708 514 transfer.ptr = (uint8_t *)&status; /* Assumes little endian */
samux 1:80ab0d068708 515 transfer.remaining = sizeof(status);
samux 1:80ab0d068708 516 transfer.direction = DEVICE_TO_HOST;
samux 1:80ab0d068708 517 }
mbed_official 25:7c72828865f3 518
samux 1:80ab0d068708 519 return success;
samux 1:80ab0d068708 520 }
samux 1:80ab0d068708 521
samux 1:80ab0d068708 522 bool USBDevice::requestSetup(void)
samux 1:80ab0d068708 523 {
samux 1:80ab0d068708 524 bool success = false;
samux 1:80ab0d068708 525
samux 1:80ab0d068708 526 /* Process standard requests */
samux 1:80ab0d068708 527 if ((transfer.setup.bmRequestType.Type == STANDARD_TYPE))
samux 1:80ab0d068708 528 {
samux 1:80ab0d068708 529 switch (transfer.setup.bRequest)
samux 1:80ab0d068708 530 {
mjr 50:946bc763c068 531 case GET_STATUS:
mjr 50:946bc763c068 532 success = requestGetStatus();
mjr 50:946bc763c068 533 break;
mjr 50:946bc763c068 534
mjr 50:946bc763c068 535 case CLEAR_FEATURE:
mjr 50:946bc763c068 536 success = requestClearFeature();
mjr 50:946bc763c068 537 break;
mjr 50:946bc763c068 538
mjr 50:946bc763c068 539 case SET_FEATURE:
mjr 50:946bc763c068 540 success = requestSetFeature();
mjr 50:946bc763c068 541 break;
mjr 50:946bc763c068 542
mjr 50:946bc763c068 543 case SET_ADDRESS:
mjr 50:946bc763c068 544 success = requestSetAddress();
mjr 50:946bc763c068 545 break;
mjr 50:946bc763c068 546
mjr 50:946bc763c068 547 case GET_DESCRIPTOR:
mjr 50:946bc763c068 548 success = requestGetDescriptor();
mjr 50:946bc763c068 549 break;
mjr 50:946bc763c068 550
mjr 50:946bc763c068 551 case SET_DESCRIPTOR:
mjr 50:946bc763c068 552 /* TODO: Support is optional, not implemented here */
mjr 50:946bc763c068 553 success = false;
mjr 50:946bc763c068 554 break;
mjr 50:946bc763c068 555
mjr 50:946bc763c068 556 case GET_CONFIGURATION:
mjr 50:946bc763c068 557 success = requestGetConfiguration();
mjr 50:946bc763c068 558 break;
mjr 50:946bc763c068 559
mjr 50:946bc763c068 560 case SET_CONFIGURATION:
mjr 50:946bc763c068 561 success = requestSetConfiguration();
mjr 50:946bc763c068 562 break;
mjr 50:946bc763c068 563
mjr 50:946bc763c068 564 case GET_INTERFACE:
mjr 50:946bc763c068 565 success = requestGetInterface();
mjr 50:946bc763c068 566 break;
mjr 50:946bc763c068 567
mjr 50:946bc763c068 568 case SET_INTERFACE:
mjr 50:946bc763c068 569 success = requestSetInterface();
mjr 50:946bc763c068 570 break;
mjr 50:946bc763c068 571
mjr 50:946bc763c068 572 default:
mjr 50:946bc763c068 573 break;
samux 1:80ab0d068708 574 }
samux 1:80ab0d068708 575 }
samux 1:80ab0d068708 576
samux 1:80ab0d068708 577 return success;
samux 1:80ab0d068708 578 }
samux 1:80ab0d068708 579
samux 1:80ab0d068708 580 bool USBDevice::controlSetup(void)
samux 1:80ab0d068708 581 {
samux 1:80ab0d068708 582 bool success = false;
samux 1:80ab0d068708 583
samux 1:80ab0d068708 584 /* Control transfer setup stage */
samux 1:80ab0d068708 585 uint8_t buffer[MAX_PACKET_SIZE_EP0];
samux 1:80ab0d068708 586
samux 1:80ab0d068708 587 EP0setup(buffer);
samux 1:80ab0d068708 588
samux 1:80ab0d068708 589 /* Initialise control transfer state */
samux 1:80ab0d068708 590 decodeSetupPacket(buffer, &transfer.setup);
samux 1:80ab0d068708 591 transfer.ptr = NULL;
samux 1:80ab0d068708 592 transfer.remaining = 0;
mjr 36:20bb47609697 593 transfer.direction = HOST_TO_DEVICE;
samux 1:80ab0d068708 594 transfer.zlp = false;
samux 1:80ab0d068708 595 transfer.notify = false;
mbed_official 25:7c72828865f3 596
mjr 37:c5ac4ccf6597 597 printd("dataTransferDirection: %d\r\nType: %d\r\nRecipient: %d\r\nbRequest: %d\r\nwValue: %d\r\nwIndex: %d\r\nwLength: %d\r\n",
mjr 37:c5ac4ccf6597 598 transfer.setup.bmRequestType.dataTransferDirection,
mjr 37:c5ac4ccf6597 599 transfer.setup.bmRequestType.Type,
mjr 37:c5ac4ccf6597 600 transfer.setup.bmRequestType.Recipient,
mjr 37:c5ac4ccf6597 601 transfer.setup.bRequest,
mjr 37:c5ac4ccf6597 602 transfer.setup.wValue,
mjr 37:c5ac4ccf6597 603 transfer.setup.wIndex,
mjr 37:c5ac4ccf6597 604 transfer.setup.wLength);
samux 1:80ab0d068708 605
samux 1:80ab0d068708 606 /* Class / vendor specific */
samux 1:80ab0d068708 607 success = USBCallback_request();
samux 1:80ab0d068708 608
samux 1:80ab0d068708 609 if (!success)
samux 1:80ab0d068708 610 {
samux 1:80ab0d068708 611 /* Standard requests */
samux 1:80ab0d068708 612 if (!requestSetup())
samux 1:80ab0d068708 613 {
mjr 37:c5ac4ccf6597 614 printd("requestSetup() failed: type=%d, req=%d\r\n", (int)transfer.setup.bmRequestType.Type, (int)transfer.setup.bRequest);
samux 1:80ab0d068708 615 return false;
samux 1:80ab0d068708 616 }
samux 1:80ab0d068708 617 }
samux 1:80ab0d068708 618
samux 1:80ab0d068708 619 /* Check transfer size and direction */
mjr 36:20bb47609697 620 if (transfer.setup.wLength > 0)
samux 1:80ab0d068708 621 {
mjr 48:b225d025ca1d 622 if (transfer.setup.bmRequestType.dataTransferDirection == DEVICE_TO_HOST)
samux 1:80ab0d068708 623 {
samux 1:80ab0d068708 624 /* IN data stage is required */
samux 1:80ab0d068708 625 if (transfer.direction != DEVICE_TO_HOST)
samux 1:80ab0d068708 626 {
mjr 37:c5ac4ccf6597 627 printd("controlSetup transfer direction wrong 1\r\n");
samux 1:80ab0d068708 628 return false;
samux 1:80ab0d068708 629 }
samux 1:80ab0d068708 630
samux 1:80ab0d068708 631 /* Transfer must be less than or equal to the size */
samux 1:80ab0d068708 632 /* requested by the host */
samux 1:80ab0d068708 633 if (transfer.remaining > transfer.setup.wLength)
samux 1:80ab0d068708 634 transfer.remaining = transfer.setup.wLength;
samux 1:80ab0d068708 635 }
samux 1:80ab0d068708 636 else
samux 1:80ab0d068708 637 {
mbed_official 25:7c72828865f3 638
samux 1:80ab0d068708 639 /* OUT data stage is required */
samux 1:80ab0d068708 640 if (transfer.direction != HOST_TO_DEVICE)
samux 1:80ab0d068708 641 {
mjr 37:c5ac4ccf6597 642 printd("controlSetup transfer direction wrong 2: type=%d, req=%d\r\n", (int)transfer.setup.bmRequestType.Type, (int)transfer.setup.bRequest);
samux 1:80ab0d068708 643 return false;
samux 1:80ab0d068708 644 }
samux 1:80ab0d068708 645
samux 1:80ab0d068708 646 /* Transfer must be equal to the size requested by the host */
samux 1:80ab0d068708 647 if (transfer.remaining != transfer.setup.wLength)
samux 1:80ab0d068708 648 {
mjr 37:c5ac4ccf6597 649 printd("controlSetup remaining length wrong: return len=%d, type=%d, req=%d, wvalue=%d, windex=%x, wlength=%d\r\n",
mjr 37:c5ac4ccf6597 650 transfer.remaining, transfer.setup.bmRequestType.Type, transfer.setup.bRequest, transfer.setup.wValue, transfer.setup.wIndex, transfer.setup.wLength);
samux 1:80ab0d068708 651 return false;
samux 1:80ab0d068708 652 }
samux 1:80ab0d068708 653 }
samux 1:80ab0d068708 654 }
samux 1:80ab0d068708 655 else
samux 1:80ab0d068708 656 {
samux 1:80ab0d068708 657 /* No data stage; transfer size must be zero */
samux 1:80ab0d068708 658 if (transfer.remaining != 0)
samux 1:80ab0d068708 659 {
mjr 37:c5ac4ccf6597 660 printd("controlSetup remaining length must be zero: return len=%d, type=%d, req=%d, wvalue=%d, windex=%x, wlength=%d\r\n",
mjr 37:c5ac4ccf6597 661 (int)transfer.remaining, (int)transfer.setup.bmRequestType.Type, (int)transfer.setup.bRequest, (int)transfer.setup.wValue, (int)transfer.setup.wIndex, (int)transfer.setup.wLength);
samux 1:80ab0d068708 662 return false;
samux 1:80ab0d068708 663 }
samux 1:80ab0d068708 664 }
samux 1:80ab0d068708 665
samux 1:80ab0d068708 666 /* Data or status stage if applicable */
mjr 36:20bb47609697 667 if (transfer.setup.wLength > 0)
samux 1:80ab0d068708 668 {
mjr 50:946bc763c068 669 if (transfer.setup.bmRequestType.dataTransferDirection == DEVICE_TO_HOST)
samux 1:80ab0d068708 670 {
samux 1:80ab0d068708 671 /* Check if we'll need to send a zero length packet at */
samux 1:80ab0d068708 672 /* the end of this transfer */
mjr 50:946bc763c068 673 if (transfer.setup.wLength >= transfer.remaining)
samux 1:80ab0d068708 674 {
samux 1:80ab0d068708 675 /* Device wishes to transfer less than host requested */
samux 1:80ab0d068708 676 if ((transfer.remaining % MAX_PACKET_SIZE_EP0) == 0)
samux 1:80ab0d068708 677 {
samux 1:80ab0d068708 678 /* Transfer is a multiple of EP0 max packet size */
samux 1:80ab0d068708 679 transfer.zlp = true;
samux 1:80ab0d068708 680 }
samux 1:80ab0d068708 681 }
samux 1:80ab0d068708 682
samux 1:80ab0d068708 683 /* IN stage */
samux 1:80ab0d068708 684 controlIn();
samux 1:80ab0d068708 685 }
samux 1:80ab0d068708 686 else
samux 1:80ab0d068708 687 {
samux 1:80ab0d068708 688 /* OUT stage */
samux 1:80ab0d068708 689 EP0read();
samux 1:80ab0d068708 690 }
samux 1:80ab0d068708 691 }
samux 1:80ab0d068708 692 else
samux 1:80ab0d068708 693 {
samux 1:80ab0d068708 694 /* Status stage */
samux 1:80ab0d068708 695 EP0write(NULL, 0);
samux 1:80ab0d068708 696 }
samux 1:80ab0d068708 697
samux 1:80ab0d068708 698 return true;
samux 1:80ab0d068708 699 }
samux 1:80ab0d068708 700
samux 1:80ab0d068708 701 void USBDevice::busReset(void)
samux 1:80ab0d068708 702 {
mjr 50:946bc763c068 703 // reset the device state
mjr 50:946bc763c068 704 memset(&device, 0, sizeof(device));
mjr 50:946bc763c068 705 setDeviceState(DEFAULT);
samux 1:80ab0d068708 706 device.configuration = 0;
samux 1:80ab0d068708 707 device.suspended = false;
samux 1:80ab0d068708 708
mjr 50:946bc763c068 709 // reset the transfer state
mjr 50:946bc763c068 710 memset(&transfer, 0, sizeof(transfer));
mjr 50:946bc763c068 711
samux 1:80ab0d068708 712 /* Call class / vendor specific busReset function */
samux 1:80ab0d068708 713 USBCallback_busReset();
samux 1:80ab0d068708 714 }
samux 1:80ab0d068708 715
samux 1:80ab0d068708 716 void USBDevice::EP0setupCallback(void)
samux 1:80ab0d068708 717 {
samux 1:80ab0d068708 718 /* Endpoint 0 setup event */
samux 1:80ab0d068708 719 if (!controlSetup())
samux 1:80ab0d068708 720 {
samux 1:80ab0d068708 721 /* Protocol stall */
samux 1:80ab0d068708 722 EP0stall();
samux 1:80ab0d068708 723 }
samux 1:80ab0d068708 724 }
samux 1:80ab0d068708 725
samux 1:80ab0d068708 726 void USBDevice::EP0out(void)
samux 1:80ab0d068708 727 {
samux 1:80ab0d068708 728 /* Endpoint 0 OUT data event */
samux 1:80ab0d068708 729 if (!controlOut())
samux 1:80ab0d068708 730 {
mjr 29:b502c11a3dff 731 /* Protocol stall; this will stall both endpoints */
samux 1:80ab0d068708 732 EP0stall();
samux 1:80ab0d068708 733 }
samux 1:80ab0d068708 734 }
samux 1:80ab0d068708 735
samux 1:80ab0d068708 736 void USBDevice::EP0in(void)
samux 1:80ab0d068708 737 {
samux 1:80ab0d068708 738 /* Endpoint 0 IN data event */
mjr 48:b225d025ca1d 739 printd("EP0IN\r\n");
samux 1:80ab0d068708 740 if (!controlIn())
samux 1:80ab0d068708 741 {
samux 1:80ab0d068708 742 /* Protocol stall; this will stall both endpoints */
samux 1:80ab0d068708 743 EP0stall();
samux 1:80ab0d068708 744 }
samux 1:80ab0d068708 745 }
samux 1:80ab0d068708 746
samux 1:80ab0d068708 747 bool USBDevice::configured(void)
samux 1:80ab0d068708 748 {
samux 1:80ab0d068708 749 /* Returns true if device is in the CONFIGURED state */
samux 1:80ab0d068708 750 return (device.state == CONFIGURED);
samux 1:80ab0d068708 751 }
samux 1:80ab0d068708 752
mbed_official 18:78bdbce94509 753 void USBDevice::connect(bool blocking)
samux 1:80ab0d068708 754 {
samux 1:80ab0d068708 755 /* Connect device */
samux 1:80ab0d068708 756 USBHAL::connect();
mbed_official 25:7c72828865f3 757
mbed_official 18:78bdbce94509 758 if (blocking) {
mjr 37:c5ac4ccf6597 759 /* Block until configured */
mjr 37:c5ac4ccf6597 760 while (!configured()) { }
mbed_official 18:78bdbce94509 761 }
samux 1:80ab0d068708 762 }
samux 1:80ab0d068708 763
samux 1:80ab0d068708 764 void USBDevice::disconnect(void)
samux 1:80ab0d068708 765 {
samux 1:80ab0d068708 766 /* Disconnect device */
samux 1:80ab0d068708 767 USBHAL::disconnect();
mbed_official 26:8ef73dd868a0 768
mbed_official 26:8ef73dd868a0 769 /* Set initial device state */
mjr 50:946bc763c068 770 setDeviceState(POWERED);
mbed_official 26:8ef73dd868a0 771 device.configuration = 0;
mbed_official 26:8ef73dd868a0 772 device.suspended = false;
samux 1:80ab0d068708 773 }
samux 1:80ab0d068708 774
samux 1:80ab0d068708 775 CONTROL_TRANSFER * USBDevice::getTransferPtr(void)
samux 1:80ab0d068708 776 {
samux 1:80ab0d068708 777 return &transfer;
samux 1:80ab0d068708 778 }
samux 1:80ab0d068708 779
samux 1:80ab0d068708 780 bool USBDevice::addEndpoint(uint8_t endpoint, uint32_t maxPacket)
samux 1:80ab0d068708 781 {
samux 1:80ab0d068708 782 return realiseEndpoint(endpoint, maxPacket, 0);
samux 1:80ab0d068708 783 }
samux 1:80ab0d068708 784
samux 1:80ab0d068708 785 bool USBDevice::addRateFeedbackEndpoint(uint8_t endpoint, uint32_t maxPacket)
samux 1:80ab0d068708 786 {
samux 1:80ab0d068708 787 /* For interrupt endpoints only */
samux 1:80ab0d068708 788 return realiseEndpoint(endpoint, maxPacket, RATE_FEEDBACK_MODE);
samux 1:80ab0d068708 789 }
samux 1:80ab0d068708 790
mjr 54:2e181d51495a 791 /*
mjr 54:2e181d51495a 792 * Find a descriptor within the list of descriptors following a
mjr 54:2e181d51495a 793 * configuration descriptor
mjr 54:2e181d51495a 794 */
mjr 49:03527ce6840e 795 const uint8_t *USBDevice::findDescriptor(uint8_t descriptorType, int idx)
samux 1:80ab0d068708 796 {
mjr 54:2e181d51495a 797 /* get the start of the configuration descriptor */
mjr 54:2e181d51495a 798 const uint8_t *ptr = configurationDesc();
mjr 54:2e181d51495a 799 if (ptr == NULL)
samux 1:80ab0d068708 800 return NULL;
samux 1:80ab0d068708 801
mjr 54:2e181d51495a 802 /* make sure it matches the expected length for a config descriptor */
mjr 54:2e181d51495a 803 if (ptr[0] != CONFIGURATION_DESCRIPTOR_LENGTH
mjr 54:2e181d51495a 804 || ptr[1] != CONFIGURATION_DESCRIPTOR)
samux 1:80ab0d068708 805 return NULL;
samux 1:80ab0d068708 806
mjr 54:2e181d51495a 807 /* figure the total length of the descriptor */
mjr 54:2e181d51495a 808 uint16_t wTotalLength = ptr[2] | (ptr[3] << 8);
mjr 54:2e181d51495a 809 const uint8_t *endPtr = ptr + wTotalLength;
samux 1:80ab0d068708 810
samux 1:80ab0d068708 811 /* Check there are some more descriptors to follow */
mjr 53:c8110529c24b 812 /* (+2 is for bLength and bDescriptorType of next descriptor) */
mjr 53:c8110529c24b 813 if (wTotalLength <= (CONFIGURATION_DESCRIPTOR_LENGTH + 2))
bogdanm 11:eeb3cbbaa996 814 return NULL;
samux 1:80ab0d068708 815
samux 1:80ab0d068708 816 /* Start at first descriptor after the configuration descriptor */
mjr 54:2e181d51495a 817 ptr += CONFIGURATION_DESCRIPTOR_LENGTH;
samux 1:80ab0d068708 818
mjr 53:c8110529c24b 819 /* Scan until we find the idx'th descriptor of the specified type */
samux 1:80ab0d068708 820 do {
samux 1:80ab0d068708 821 if (ptr[1] /* bDescriptorType */ == descriptorType)
samux 1:80ab0d068708 822 {
mjr 33:b0a3f6b27b07 823 // Found - if the index has reached zero, it's the one we're
mjr 33:b0a3f6b27b07 824 // looking for; if not, just decrement the index and keep looking.
mjr 33:b0a3f6b27b07 825 if (idx == 0)
mjr 33:b0a3f6b27b07 826 return ptr;
mjr 33:b0a3f6b27b07 827 else
mjr 33:b0a3f6b27b07 828 --idx;
samux 1:80ab0d068708 829 }
samux 1:80ab0d068708 830
samux 1:80ab0d068708 831 /* Skip to next descriptor */
samux 1:80ab0d068708 832 ptr += ptr[0]; /* bLength */
mjr 54:2e181d51495a 833 } while (ptr < endPtr);
samux 1:80ab0d068708 834
samux 1:80ab0d068708 835 /* Reached end of the descriptors - not found */
samux 1:80ab0d068708 836 return NULL;
samux 1:80ab0d068708 837 }
samux 1:80ab0d068708 838
samux 1:80ab0d068708 839
samux 1:80ab0d068708 840 void USBDevice::connectStateChanged(unsigned int connected)
samux 1:80ab0d068708 841 {
samux 1:80ab0d068708 842 }
samux 1:80ab0d068708 843
samux 1:80ab0d068708 844 void USBDevice::suspendStateChanged(unsigned int suspended)
samux 1:80ab0d068708 845 {
samux 1:80ab0d068708 846 }
samux 1:80ab0d068708 847
mjr 50:946bc763c068 848 void USBDevice::sleepStateChanged(unsigned int sleep)
mjr 50:946bc763c068 849 {
mjr 50:946bc763c068 850 }
mjr 50:946bc763c068 851
samux 1:80ab0d068708 852
samux 1:80ab0d068708 853 USBDevice::USBDevice(uint16_t vendor_id, uint16_t product_id, uint16_t product_release){
mbed_official 25:7c72828865f3 854 VENDOR_ID = vendor_id;
mbed_official 25:7c72828865f3 855 PRODUCT_ID = product_id;
samux 1:80ab0d068708 856 PRODUCT_RELEASE = product_release;
samux 1:80ab0d068708 857
samux 1:80ab0d068708 858 /* Set initial device state */
mjr 50:946bc763c068 859 setDeviceState(POWERED);
samux 1:80ab0d068708 860 device.configuration = 0;
samux 1:80ab0d068708 861 device.suspended = false;
samux 1:80ab0d068708 862 };
samux 1:80ab0d068708 863
samux 1:80ab0d068708 864
samux 1:80ab0d068708 865 bool USBDevice::readStart(uint8_t endpoint, uint32_t maxSize)
samux 1:80ab0d068708 866 {
samux 1:80ab0d068708 867 return endpointRead(endpoint, maxSize) == EP_PENDING;
samux 1:80ab0d068708 868 }
samux 1:80ab0d068708 869
samux 1:80ab0d068708 870
samux 1:80ab0d068708 871 bool USBDevice::write(uint8_t endpoint, uint8_t * buffer, uint32_t size, uint32_t maxSize)
samux 1:80ab0d068708 872 {
samux 1:80ab0d068708 873 EP_STATUS result;
samux 1:80ab0d068708 874
samux 1:80ab0d068708 875 if (size > maxSize)
samux 1:80ab0d068708 876 {
samux 1:80ab0d068708 877 return false;
samux 1:80ab0d068708 878 }
mbed_official 25:7c72828865f3 879
mbed_official 25:7c72828865f3 880
samux 1:80ab0d068708 881 if(!configured()) {
samux 1:80ab0d068708 882 return false;
samux 1:80ab0d068708 883 }
mbed_official 25:7c72828865f3 884
samux 1:80ab0d068708 885 /* Send report */
mjr 48:b225d025ca1d 886 result = endpointWrite(endpoint, buffer, size);
samux 1:80ab0d068708 887
samux 1:80ab0d068708 888 if (result != EP_PENDING)
samux 1:80ab0d068708 889 {
samux 1:80ab0d068708 890 return false;
samux 1:80ab0d068708 891 }
samux 1:80ab0d068708 892
samux 1:80ab0d068708 893 /* Wait for completion */
samux 1:80ab0d068708 894 do {
samux 1:80ab0d068708 895 result = endpointWriteResult(endpoint);
samux 1:80ab0d068708 896 } while ((result == EP_PENDING) && configured());
samux 1:80ab0d068708 897
samux 1:80ab0d068708 898 return (result == EP_COMPLETED);
samux 1:80ab0d068708 899 }
samux 1:80ab0d068708 900
samux 1:80ab0d068708 901
samux 1:80ab0d068708 902 bool USBDevice::writeNB(uint8_t endpoint, uint8_t * buffer, uint32_t size, uint32_t maxSize)
samux 1:80ab0d068708 903 {
samux 1:80ab0d068708 904 EP_STATUS result;
samux 1:80ab0d068708 905
samux 1:80ab0d068708 906 if (size > maxSize)
samux 1:80ab0d068708 907 {
samux 1:80ab0d068708 908 return false;
samux 1:80ab0d068708 909 }
mbed_official 25:7c72828865f3 910
samux 1:80ab0d068708 911 if(!configured()) {
samux 1:80ab0d068708 912 return false;
samux 1:80ab0d068708 913 }
samux 1:80ab0d068708 914
samux 1:80ab0d068708 915 /* Send report */
samux 1:80ab0d068708 916 result = endpointWrite(endpoint, buffer, size);
samux 1:80ab0d068708 917
samux 1:80ab0d068708 918 if (result != EP_PENDING)
samux 1:80ab0d068708 919 {
samux 1:80ab0d068708 920 return false;
samux 1:80ab0d068708 921 }
samux 1:80ab0d068708 922
samux 1:80ab0d068708 923 result = endpointWriteResult(endpoint);
samux 1:80ab0d068708 924
samux 1:80ab0d068708 925 return (result == EP_COMPLETED);
samux 1:80ab0d068708 926 }
samux 1:80ab0d068708 927
mjr 32:a8eb758f4074 928 bool USBDevice::writeTO(uint8_t endpoint, uint8_t * buffer, uint32_t size, uint32_t maxSize, int timeout_ms)
mjr 32:a8eb758f4074 929 {
mjr 32:a8eb758f4074 930 EP_STATUS result;
mjr 32:a8eb758f4074 931
mjr 32:a8eb758f4074 932 if (size > maxSize)
mjr 32:a8eb758f4074 933 {
mjr 32:a8eb758f4074 934 return false;
mjr 32:a8eb758f4074 935 }
mjr 32:a8eb758f4074 936
mjr 48:b225d025ca1d 937 if(!configured()) {
mjr 48:b225d025ca1d 938 return false;
mjr 48:b225d025ca1d 939 }
mjr 32:a8eb758f4074 940
mjr 48:b225d025ca1d 941 /* Send report */
mjr 48:b225d025ca1d 942 result = endpointWrite(endpoint, buffer, size);
mjr 48:b225d025ca1d 943
mjr 48:b225d025ca1d 944 if (result != EP_PENDING)
mjr 48:b225d025ca1d 945 {
mjr 32:a8eb758f4074 946 return false;
mjr 32:a8eb758f4074 947 }
mjr 34:884405d998bb 948
mjr 34:884405d998bb 949 /* set up a timer for monitoring the timeout period */
mjr 34:884405d998bb 950 Timer t;
mjr 34:884405d998bb 951 t.start();
mjr 32:a8eb758f4074 952
mjr 32:a8eb758f4074 953 /* Wait for completion or timeout */
mjr 32:a8eb758f4074 954 do {
mjr 32:a8eb758f4074 955 result = endpointWriteResult(endpoint);
mjr 32:a8eb758f4074 956 } while ((result == EP_PENDING) && configured() && t.read_ms() < timeout_ms);
mjr 32:a8eb758f4074 957
mjr 32:a8eb758f4074 958 return (result == EP_COMPLETED);
mjr 32:a8eb758f4074 959 }
mjr 32:a8eb758f4074 960
samux 1:80ab0d068708 961 bool USBDevice::readEP(uint8_t endpoint, uint8_t * buffer, uint32_t * size, uint32_t maxSize)
samux 1:80ab0d068708 962 {
samux 1:80ab0d068708 963 EP_STATUS result;
mbed_official 25:7c72828865f3 964
samux 1:80ab0d068708 965 if(!configured()) {
samux 1:80ab0d068708 966 return false;
samux 1:80ab0d068708 967 }
samux 1:80ab0d068708 968
samux 1:80ab0d068708 969 /* Wait for completion */
samux 1:80ab0d068708 970 do {
samux 1:80ab0d068708 971 result = endpointReadResult(endpoint, buffer, size);
samux 1:80ab0d068708 972 } while ((result == EP_PENDING) && configured());
samux 1:80ab0d068708 973
samux 1:80ab0d068708 974 return (result == EP_COMPLETED);
samux 1:80ab0d068708 975 }
samux 1:80ab0d068708 976
samux 1:80ab0d068708 977
samux 1:80ab0d068708 978 bool USBDevice::readEP_NB(uint8_t endpoint, uint8_t * buffer, uint32_t * size, uint32_t maxSize)
samux 1:80ab0d068708 979 {
samux 1:80ab0d068708 980 EP_STATUS result;
mbed_official 25:7c72828865f3 981
samux 1:80ab0d068708 982 if(!configured()) {
samux 1:80ab0d068708 983 return false;
samux 1:80ab0d068708 984 }
samux 1:80ab0d068708 985
samux 1:80ab0d068708 986 result = endpointReadResult(endpoint, buffer, size);
mbed_official 25:7c72828865f3 987
samux 1:80ab0d068708 988 return (result == EP_COMPLETED);
samux 1:80ab0d068708 989 }
samux 1:80ab0d068708 990
samux 1:80ab0d068708 991
samux 1:80ab0d068708 992
mjr 49:03527ce6840e 993 const uint8_t *USBDevice::deviceDesc() {
mjr 49:03527ce6840e 994 static const uint8_t deviceDescriptor[] = {
samux 1:80ab0d068708 995 DEVICE_DESCRIPTOR_LENGTH, /* bLength */
samux 1:80ab0d068708 996 DEVICE_DESCRIPTOR, /* bDescriptorType */
samux 1:80ab0d068708 997 LSB(USB_VERSION_2_0), /* bcdUSB (LSB) */
samux 1:80ab0d068708 998 MSB(USB_VERSION_2_0), /* bcdUSB (MSB) */
samux 1:80ab0d068708 999 0x00, /* bDeviceClass */
samux 1:80ab0d068708 1000 0x00, /* bDeviceSubClass */
samux 1:80ab0d068708 1001 0x00, /* bDeviceprotocol */
samux 1:80ab0d068708 1002 MAX_PACKET_SIZE_EP0, /* bMaxPacketSize0 */
bogdanm 11:eeb3cbbaa996 1003 (uint8_t)(LSB(VENDOR_ID)), /* idVendor (LSB) */
bogdanm 11:eeb3cbbaa996 1004 (uint8_t)(MSB(VENDOR_ID)), /* idVendor (MSB) */
bogdanm 11:eeb3cbbaa996 1005 (uint8_t)(LSB(PRODUCT_ID)), /* idProduct (LSB) */
bogdanm 11:eeb3cbbaa996 1006 (uint8_t)(MSB(PRODUCT_ID)), /* idProduct (MSB) */
bogdanm 11:eeb3cbbaa996 1007 (uint8_t)(LSB(PRODUCT_RELEASE)), /* bcdDevice (LSB) */
bogdanm 11:eeb3cbbaa996 1008 (uint8_t)(MSB(PRODUCT_RELEASE)), /* bcdDevice (MSB) */
samux 1:80ab0d068708 1009 STRING_OFFSET_IMANUFACTURER, /* iManufacturer */
samux 1:80ab0d068708 1010 STRING_OFFSET_IPRODUCT, /* iProduct */
samux 1:80ab0d068708 1011 STRING_OFFSET_ISERIAL, /* iSerialNumber */
samux 1:80ab0d068708 1012 0x01 /* bNumConfigurations */
samux 1:80ab0d068708 1013 };
samux 1:80ab0d068708 1014 return deviceDescriptor;
samux 1:80ab0d068708 1015 }
samux 1:80ab0d068708 1016
mjr 49:03527ce6840e 1017 const uint8_t *USBDevice::stringLangidDesc() {
mjr 49:03527ce6840e 1018 static const uint8_t stringLangidDescriptor[] = {
samux 1:80ab0d068708 1019 0x04, /*bLength*/
samux 1:80ab0d068708 1020 STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
mbed_official 17:bbd6dac92961 1021 0x09,0x04, /*bString Lang ID - 0x0409 - English*/
samux 1:80ab0d068708 1022 };
samux 1:80ab0d068708 1023 return stringLangidDescriptor;
samux 1:80ab0d068708 1024 }
samux 1:80ab0d068708 1025
mjr 49:03527ce6840e 1026 const uint8_t *USBDevice::stringImanufacturerDesc() {
mjr 49:03527ce6840e 1027 static const uint8_t stringImanufacturerDescriptor[] = {
samux 1:80ab0d068708 1028 0x12, /*bLength*/
samux 1:80ab0d068708 1029 STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
samux 1:80ab0d068708 1030 'm',0,'b',0,'e',0,'d',0,'.',0,'o',0,'r',0,'g',0, /*bString iManufacturer - mbed.org*/
samux 1:80ab0d068708 1031 };
samux 1:80ab0d068708 1032 return stringImanufacturerDescriptor;
samux 1:80ab0d068708 1033 }
samux 1:80ab0d068708 1034
mjr 49:03527ce6840e 1035 const uint8_t *USBDevice::stringIserialDesc() {
mjr 49:03527ce6840e 1036 static const uint8_t stringIserialDescriptor[] = {
samux 1:80ab0d068708 1037 0x16, /*bLength*/
samux 1:80ab0d068708 1038 STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
samux 1:80ab0d068708 1039 '0',0,'1',0,'2',0,'3',0,'4',0,'5',0,'6',0,'7',0,'8',0,'9',0, /*bString iSerial - 0123456789*/
samux 1:80ab0d068708 1040 };
samux 1:80ab0d068708 1041 return stringIserialDescriptor;
samux 1:80ab0d068708 1042 }
samux 1:80ab0d068708 1043
mjr 49:03527ce6840e 1044 const uint8_t *USBDevice::stringIConfigurationDesc() {
mjr 49:03527ce6840e 1045 static const uint8_t stringIconfigurationDescriptor[] = {
samux 1:80ab0d068708 1046 0x06, /*bLength*/
samux 1:80ab0d068708 1047 STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
samux 1:80ab0d068708 1048 '0',0,'1',0, /*bString iConfiguration - 01*/
samux 1:80ab0d068708 1049 };
samux 1:80ab0d068708 1050 return stringIconfigurationDescriptor;
samux 1:80ab0d068708 1051 }
samux 1:80ab0d068708 1052
mjr 49:03527ce6840e 1053 const uint8_t *USBDevice::stringIinterfaceDesc() {
mjr 49:03527ce6840e 1054 static const uint8_t stringIinterfaceDescriptor[] = {
samux 1:80ab0d068708 1055 0x08, /*bLength*/
samux 1:80ab0d068708 1056 STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
samux 1:80ab0d068708 1057 'U',0,'S',0,'B',0, /*bString iInterface - USB*/
samux 1:80ab0d068708 1058 };
samux 1:80ab0d068708 1059 return stringIinterfaceDescriptor;
samux 1:80ab0d068708 1060 }
samux 1:80ab0d068708 1061
mjr 49:03527ce6840e 1062 const uint8_t *USBDevice::stringIproductDesc() {
mjr 49:03527ce6840e 1063 static const uint8_t stringIproductDescriptor[] = {
samux 1:80ab0d068708 1064 0x16, /*bLength*/
samux 1:80ab0d068708 1065 STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
samux 1:80ab0d068708 1066 'U',0,'S',0,'B',0,' ',0,'D',0,'E',0,'V',0,'I',0,'C',0,'E',0 /*bString iProduct - USB DEVICE*/
samux 1:80ab0d068708 1067 };
samux 1:80ab0d068708 1068 return stringIproductDescriptor;
samux 1:80ab0d068708 1069 }