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!

Committer:
mjr
Date:
Fri Mar 17 22:01:47 2017 +0000
Revision:
54:2e181d51495a
Parent:
49:03527ce6840e
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
samux 1:80ab0d068708 20 #ifndef USBMSD_H
samux 1:80ab0d068708 21 #define USBMSD_H
samux 1:80ab0d068708 22
samux 1:80ab0d068708 23 /* These headers are included for child class. */
samux 1:80ab0d068708 24 #include "USBEndpoints.h"
samux 1:80ab0d068708 25 #include "USBDescriptor.h"
samux 1:80ab0d068708 26 #include "USBDevice_Types.h"
samux 1:80ab0d068708 27
samux 1:80ab0d068708 28 #include "USBDevice.h"
samux 1:80ab0d068708 29
samux 1:80ab0d068708 30 /**
samux 1:80ab0d068708 31 * USBMSD class: generic class in order to use all kinds of blocks storage chip
samux 1:80ab0d068708 32 *
samux 1:80ab0d068708 33 * Introduction
samux 1:80ab0d068708 34 *
samux 1:80ab0d068708 35 * The USBMSD implements the MSD protocol. It permits to access a memory chip (flash, sdcard,...)
samux 1:80ab0d068708 36 * from a computer over USB. But this class doesn't work standalone, you need to subclass this class
samux 1:80ab0d068708 37 * and define virtual functions which are called in USBMSD.
samux 1:80ab0d068708 38 *
samux 1:80ab0d068708 39 * How to use this class with your chip ?
samux 1:80ab0d068708 40 *
samux 1:80ab0d068708 41 * You have to inherit and define some pure virtual functions (mandatory step):
samux 1:80ab0d068708 42 * - virtual int disk_read(char * data, int block): function to read a block
samux 1:80ab0d068708 43 * - virtual int disk_write(const char * data, int block): function to write a block
samux 1:80ab0d068708 44 * - virtual int disk_initialize(): function to initialize the memory
samux 1:80ab0d068708 45 * - virtual int disk_sectors(): return the number of blocks
samux 1:80ab0d068708 46 * - virtual int disk_size(): return the memory size
samux 1:80ab0d068708 47 * - virtual int disk_status(): return the status of the storage chip (0: OK, 1: not initialized, 2: no medium in the drive, 4: write protection)
samux 1:80ab0d068708 48 *
samux 1:80ab0d068708 49 * All functions names are compatible with the fat filesystem library. So you can imagine using your own class with
samux 1:80ab0d068708 50 * USBMSD and the fat filesystem library in the same program. Just be careful because there are two different parts which
samux 1:80ab0d068708 51 * will access the sd card. You can do a master/slave system using the disk_status method.
samux 1:80ab0d068708 52 *
samux 1:80ab0d068708 53 * Once these functions defined, you can call connect() (at the end of the constructor of your class for instance)
samux 1:80ab0d068708 54 * of USBMSD to connect your mass storage device. connect() will first call disk_status() to test the status of the disk.
samux 1:80ab0d068708 55 * If disk_status() returns 1 (disk not initialized), then disk_initialize() is called. After this step, connect() will collect information
samux 1:80ab0d068708 56 * such as the number of blocks and the memory size.
samux 1:80ab0d068708 57 */
samux 1:80ab0d068708 58 class USBMSD: public USBDevice {
samux 1:80ab0d068708 59 public:
samux 1:80ab0d068708 60
samux 1:80ab0d068708 61 /**
samux 1:80ab0d068708 62 * Constructor
samux 1:80ab0d068708 63 *
samux 1:80ab0d068708 64 * @param vendor_id Your vendor_id
samux 1:80ab0d068708 65 * @param product_id Your product_id
samux 1:80ab0d068708 66 * @param product_release Your preoduct_release
samux 1:80ab0d068708 67 */
samux 1:80ab0d068708 68 USBMSD(uint16_t vendor_id = 0x0703, uint16_t product_id = 0x0104, uint16_t product_release = 0x0001);
samux 1:80ab0d068708 69
samux 1:80ab0d068708 70 /**
samux 1:80ab0d068708 71 * Connect the USB MSD device. Establish disk initialization before really connect the device.
samux 1:80ab0d068708 72 *
mbed_official 18:78bdbce94509 73 * @param blocking if not configured
samux 1:80ab0d068708 74 * @returns true if successful
samux 1:80ab0d068708 75 */
mbed_official 18:78bdbce94509 76 bool connect(bool blocking = true);
samux 1:80ab0d068708 77
bogdanm 14:d495202c90f4 78 /**
bogdanm 14:d495202c90f4 79 * Disconnect the USB MSD device.
bogdanm 14:d495202c90f4 80 */
bogdanm 14:d495202c90f4 81 void disconnect();
mbed_official 25:7c72828865f3 82
bogdanm 14:d495202c90f4 83 /**
bogdanm 14:d495202c90f4 84 * Destructor
bogdanm 14:d495202c90f4 85 */
bogdanm 14:d495202c90f4 86 ~USBMSD();
samux 1:80ab0d068708 87
samux 1:80ab0d068708 88 protected:
samux 1:80ab0d068708 89
samux 1:80ab0d068708 90 /*
samux 1:80ab0d068708 91 * read a block on a storage chip
samux 1:80ab0d068708 92 *
samux 1:80ab0d068708 93 * @param data pointer where will be stored read data
samux 1:80ab0d068708 94 * @param block block number
samux 1:80ab0d068708 95 * @returns 0 if successful
samux 1:80ab0d068708 96 */
samux 7:f8f057664123 97 virtual int disk_read(uint8_t * data, uint64_t block) = 0;
samux 1:80ab0d068708 98
samux 1:80ab0d068708 99 /*
samux 1:80ab0d068708 100 * write a block on a storage chip
samux 1:80ab0d068708 101 *
samux 1:80ab0d068708 102 * @param data data to write
samux 1:80ab0d068708 103 * @param block block number
samux 1:80ab0d068708 104 * @returns 0 if successful
samux 1:80ab0d068708 105 */
samux 7:f8f057664123 106 virtual int disk_write(const uint8_t * data, uint64_t block) = 0;
samux 1:80ab0d068708 107
samux 1:80ab0d068708 108 /*
samux 1:80ab0d068708 109 * Disk initilization
samux 1:80ab0d068708 110 */
samux 1:80ab0d068708 111 virtual int disk_initialize() = 0;
samux 1:80ab0d068708 112
samux 1:80ab0d068708 113 /*
samux 1:80ab0d068708 114 * Return the number of blocks
samux 1:80ab0d068708 115 *
samux 1:80ab0d068708 116 * @returns number of blocks
samux 1:80ab0d068708 117 */
samux 7:f8f057664123 118 virtual uint64_t disk_sectors() = 0;
samux 1:80ab0d068708 119
samux 1:80ab0d068708 120 /*
samux 1:80ab0d068708 121 * Return memory size
samux 1:80ab0d068708 122 *
samux 1:80ab0d068708 123 * @returns memory size
samux 1:80ab0d068708 124 */
samux 7:f8f057664123 125 virtual uint64_t disk_size() = 0;
samux 1:80ab0d068708 126
samux 1:80ab0d068708 127
samux 1:80ab0d068708 128 /*
samux 1:80ab0d068708 129 * To check the status of the storage chip
samux 1:80ab0d068708 130 *
samux 1:80ab0d068708 131 * @returns status: 0: OK, 1: disk not initialized, 2: no medium in the drive, 4: write protected
samux 1:80ab0d068708 132 */
samux 1:80ab0d068708 133 virtual int disk_status() = 0;
samux 1:80ab0d068708 134
samux 1:80ab0d068708 135 /*
samux 1:80ab0d068708 136 * Get string product descriptor
samux 1:80ab0d068708 137 *
samux 1:80ab0d068708 138 * @returns pointer to the string product descriptor
samux 1:80ab0d068708 139 */
mjr 49:03527ce6840e 140 virtual const uint8_t *stringIproductDesc();
samux 1:80ab0d068708 141
samux 1:80ab0d068708 142 /*
samux 1:80ab0d068708 143 * Get string interface descriptor
samux 1:80ab0d068708 144 *
samux 1:80ab0d068708 145 * @returns pointer to the string interface descriptor
samux 1:80ab0d068708 146 */
mjr 49:03527ce6840e 147 virtual const uint8_t *stringIinterfaceDesc();
samux 1:80ab0d068708 148
samux 1:80ab0d068708 149 /*
samux 1:80ab0d068708 150 * Get configuration descriptor
samux 1:80ab0d068708 151 *
samux 1:80ab0d068708 152 * @returns pointer to the configuration descriptor
samux 1:80ab0d068708 153 */
mjr 49:03527ce6840e 154 virtual const uint8_t *configurationDesc();
samux 1:80ab0d068708 155
samux 1:80ab0d068708 156 /*
samux 1:80ab0d068708 157 * Callback called when a packet is received
samux 1:80ab0d068708 158 */
samux 1:80ab0d068708 159 virtual bool EP2_OUT_callback();
samux 1:80ab0d068708 160
samux 1:80ab0d068708 161 /*
samux 1:80ab0d068708 162 * Callback called when a packet has been sent
samux 1:80ab0d068708 163 */
samux 1:80ab0d068708 164 virtual bool EP2_IN_callback();
samux 1:80ab0d068708 165
samux 1:80ab0d068708 166 /*
samux 1:80ab0d068708 167 * Set configuration of device. Add endpoints
samux 1:80ab0d068708 168 */
samux 1:80ab0d068708 169 virtual bool USBCallback_setConfiguration(uint8_t configuration);
samux 1:80ab0d068708 170
samux 1:80ab0d068708 171 /*
samux 1:80ab0d068708 172 * Callback called to process class specific requests
samux 1:80ab0d068708 173 */
samux 1:80ab0d068708 174 virtual bool USBCallback_request();
samux 1:80ab0d068708 175
samux 1:80ab0d068708 176
samux 1:80ab0d068708 177 private:
samux 1:80ab0d068708 178
samux 1:80ab0d068708 179 // MSC Bulk-only Stage
samux 1:80ab0d068708 180 enum Stage {
samux 1:80ab0d068708 181 READ_CBW, // wait a CBW
samux 1:80ab0d068708 182 ERROR, // error
samux 1:80ab0d068708 183 PROCESS_CBW, // process a CBW request
samux 1:80ab0d068708 184 SEND_CSW, // send a CSW
samux 1:80ab0d068708 185 WAIT_CSW, // wait that a CSW has been effectively sent
samux 1:80ab0d068708 186 };
samux 1:80ab0d068708 187
samux 1:80ab0d068708 188 // Bulk-only CBW
emilmont 10:1e3d126a322b 189 typedef struct {
samux 1:80ab0d068708 190 uint32_t Signature;
samux 1:80ab0d068708 191 uint32_t Tag;
samux 1:80ab0d068708 192 uint32_t DataLength;
samux 1:80ab0d068708 193 uint8_t Flags;
samux 1:80ab0d068708 194 uint8_t LUN;
samux 1:80ab0d068708 195 uint8_t CBLength;
samux 1:80ab0d068708 196 uint8_t CB[16];
bogdanm 11:eeb3cbbaa996 197 } PACKED CBW;
samux 1:80ab0d068708 198
samux 1:80ab0d068708 199 // Bulk-only CSW
emilmont 10:1e3d126a322b 200 typedef struct {
samux 1:80ab0d068708 201 uint32_t Signature;
samux 1:80ab0d068708 202 uint32_t Tag;
samux 1:80ab0d068708 203 uint32_t DataResidue;
samux 1:80ab0d068708 204 uint8_t Status;
bogdanm 11:eeb3cbbaa996 205 } PACKED CSW;
samux 1:80ab0d068708 206
samux 1:80ab0d068708 207 //state of the bulk-only state machine
samux 1:80ab0d068708 208 Stage stage;
samux 1:80ab0d068708 209
samux 1:80ab0d068708 210 // current CBW
samux 1:80ab0d068708 211 CBW cbw;
samux 1:80ab0d068708 212
samux 1:80ab0d068708 213 // CSW which will be sent
samux 1:80ab0d068708 214 CSW csw;
samux 1:80ab0d068708 215
samux 1:80ab0d068708 216 // addr where will be read or written data
samux 1:80ab0d068708 217 uint32_t addr;
samux 1:80ab0d068708 218
samux 1:80ab0d068708 219 // length of a reading or writing
samux 1:80ab0d068708 220 uint32_t length;
samux 1:80ab0d068708 221
samux 1:80ab0d068708 222 // memory OK (after a memoryVerify)
samux 1:80ab0d068708 223 bool memOK;
samux 1:80ab0d068708 224
samux 1:80ab0d068708 225 // cache in RAM before writing in memory. Useful also to read a block.
samux 1:80ab0d068708 226 uint8_t * page;
samux 1:80ab0d068708 227
samux 1:80ab0d068708 228 int BlockSize;
samux 7:f8f057664123 229 uint64_t MemorySize;
samux 7:f8f057664123 230 uint64_t BlockCount;
samux 1:80ab0d068708 231
samux 1:80ab0d068708 232 void CBWDecode(uint8_t * buf, uint16_t size);
samux 1:80ab0d068708 233 void sendCSW (void);
samux 1:80ab0d068708 234 bool inquiryRequest (void);
samux 1:80ab0d068708 235 bool write (uint8_t * buf, uint16_t size);
samux 1:80ab0d068708 236 bool readFormatCapacity();
samux 1:80ab0d068708 237 bool readCapacity (void);
samux 1:80ab0d068708 238 bool infoTransfer (void);
samux 1:80ab0d068708 239 void memoryRead (void);
samux 1:80ab0d068708 240 bool modeSense6 (void);
samux 1:80ab0d068708 241 void testUnitReady (void);
samux 1:80ab0d068708 242 bool requestSense (void);
samux 1:80ab0d068708 243 void memoryVerify (uint8_t * buf, uint16_t size);
samux 1:80ab0d068708 244 void memoryWrite (uint8_t * buf, uint16_t size);
samux 1:80ab0d068708 245 void reset();
samux 1:80ab0d068708 246 void fail();
samux 1:80ab0d068708 247 };
samux 1:80ab0d068708 248
samux 8:335f2506f422 249 #endif