Mihail Stoyanov / USBDevice

Fork of the official USBDevice library

Fork of USBDevice by mbed official

USBMSD/USBMSD.cpp@73:8d28a0cb7b43, 2017-04-28 (annotated)

Committer:
screamer
Date:
Fri Apr 28 11:26:51 2017 +0100
Branch:
github-merge
Revision:
73:8d28a0cb7b43
Parent:
51:deafa44182d9 
Merge from mbed-os @ github

Who changed what in which revision?

UserRevisionLine numberNew contents of line
screamer 73:8d28a0cb7b43 1 /* Copyright (c) 2010-2011 mbed.org, MIT License
screamer 73:8d28a0cb7b43 2 *
screamer 73:8d28a0cb7b43 3 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
screamer 73:8d28a0cb7b43 4 * and associated documentation files (the "Software"), to deal in the Software without
screamer 73:8d28a0cb7b43 5 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
screamer 73:8d28a0cb7b43 6 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
screamer 73:8d28a0cb7b43 7 * Software is furnished to do so, subject to the following conditions:
screamer 73:8d28a0cb7b43 8 *
screamer 73:8d28a0cb7b43 9 * The above copyright notice and this permission notice shall be included in all copies or
screamer 73:8d28a0cb7b43 10 * substantial portions of the Software.
screamer 73:8d28a0cb7b43 11 *
screamer 73:8d28a0cb7b43 12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
screamer 73:8d28a0cb7b43 13 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
screamer 73:8d28a0cb7b43 14 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
screamer 73:8d28a0cb7b43 15 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
screamer 73:8d28a0cb7b43 16 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
screamer 73:8d28a0cb7b43 17 */
screamer 73:8d28a0cb7b43 18
screamer 73:8d28a0cb7b43 19 #include "stdint.h"
screamer 73:8d28a0cb7b43 20 #include "USBMSD.h"
screamer 73:8d28a0cb7b43 21
screamer 73:8d28a0cb7b43 22 #define DISK_OK 0x00
screamer 73:8d28a0cb7b43 23 #define NO_INIT 0x01
screamer 73:8d28a0cb7b43 24 #define NO_DISK 0x02
screamer 73:8d28a0cb7b43 25 #define WRITE_PROTECT 0x04
screamer 73:8d28a0cb7b43 26
screamer 73:8d28a0cb7b43 27 #define CBW_Signature 0x43425355
screamer 73:8d28a0cb7b43 28 #define CSW_Signature 0x53425355
screamer 73:8d28a0cb7b43 29
screamer 73:8d28a0cb7b43 30 // SCSI Commands
screamer 73:8d28a0cb7b43 31 #define TEST_UNIT_READY 0x00
screamer 73:8d28a0cb7b43 32 #define REQUEST_SENSE 0x03
screamer 73:8d28a0cb7b43 33 #define FORMAT_UNIT 0x04
screamer 73:8d28a0cb7b43 34 #define INQUIRY 0x12
screamer 73:8d28a0cb7b43 35 #define MODE_SELECT6 0x15
screamer 73:8d28a0cb7b43 36 #define MODE_SENSE6 0x1A
screamer 73:8d28a0cb7b43 37 #define START_STOP_UNIT 0x1B
screamer 73:8d28a0cb7b43 38 #define MEDIA_REMOVAL 0x1E
screamer 73:8d28a0cb7b43 39 #define READ_FORMAT_CAPACITIES 0x23
screamer 73:8d28a0cb7b43 40 #define READ_CAPACITY 0x25
screamer 73:8d28a0cb7b43 41 #define READ10 0x28
screamer 73:8d28a0cb7b43 42 #define WRITE10 0x2A
screamer 73:8d28a0cb7b43 43 #define VERIFY10 0x2F
screamer 73:8d28a0cb7b43 44 #define READ12 0xA8
screamer 73:8d28a0cb7b43 45 #define WRITE12 0xAA
screamer 73:8d28a0cb7b43 46 #define MODE_SELECT10 0x55
screamer 73:8d28a0cb7b43 47 #define MODE_SENSE10 0x5A
screamer 73:8d28a0cb7b43 48
screamer 73:8d28a0cb7b43 49 // MSC class specific requests
screamer 73:8d28a0cb7b43 50 #define MSC_REQUEST_RESET 0xFF
screamer 73:8d28a0cb7b43 51 #define MSC_REQUEST_GET_MAX_LUN 0xFE
screamer 73:8d28a0cb7b43 52
screamer 73:8d28a0cb7b43 53 #define DEFAULT_CONFIGURATION (1)
screamer 73:8d28a0cb7b43 54
screamer 73:8d28a0cb7b43 55 // max packet size
screamer 73:8d28a0cb7b43 56 #define MAX_PACKET MAX_PACKET_SIZE_EPBULK
screamer 73:8d28a0cb7b43 57
screamer 73:8d28a0cb7b43 58 // CSW Status
screamer 73:8d28a0cb7b43 59 enum Status {
screamer 73:8d28a0cb7b43 60 CSW_PASSED,
screamer 73:8d28a0cb7b43 61 CSW_FAILED,
screamer 73:8d28a0cb7b43 62 CSW_ERROR,
screamer 73:8d28a0cb7b43 63 };
screamer 73:8d28a0cb7b43 64
screamer 73:8d28a0cb7b43 65
screamer 73:8d28a0cb7b43 66 USBMSD::USBMSD(uint16_t vendor_id, uint16_t product_id, uint16_t product_release): USBDevice(vendor_id, product_id, product_release) {
screamer 73:8d28a0cb7b43 67 stage = READ_CBW;
screamer 73:8d28a0cb7b43 68 memset((void *)&cbw, 0, sizeof(CBW));
screamer 73:8d28a0cb7b43 69 memset((void *)&csw, 0, sizeof(CSW));
screamer 73:8d28a0cb7b43 70 page = NULL;
screamer 73:8d28a0cb7b43 71 }
screamer 73:8d28a0cb7b43 72
screamer 73:8d28a0cb7b43 73 USBMSD::~USBMSD() {
screamer 73:8d28a0cb7b43 74 disconnect();
screamer 73:8d28a0cb7b43 75 }
screamer 73:8d28a0cb7b43 76
screamer 73:8d28a0cb7b43 77
screamer 73:8d28a0cb7b43 78 // Called in ISR context to process a class specific request
screamer 73:8d28a0cb7b43 79 bool USBMSD::USBCallback_request(void) {
screamer 73:8d28a0cb7b43 80
screamer 73:8d28a0cb7b43 81 bool success = false;
screamer 73:8d28a0cb7b43 82 CONTROL_TRANSFER * transfer = getTransferPtr();
screamer 73:8d28a0cb7b43 83 static uint8_t maxLUN[1] = {0};
screamer 73:8d28a0cb7b43 84
screamer 73:8d28a0cb7b43 85 if (transfer->setup.bmRequestType.Type == CLASS_TYPE) {
screamer 73:8d28a0cb7b43 86 switch (transfer->setup.bRequest) {
screamer 73:8d28a0cb7b43 87 case MSC_REQUEST_RESET:
screamer 73:8d28a0cb7b43 88 reset();
screamer 73:8d28a0cb7b43 89 success = true;
screamer 73:8d28a0cb7b43 90 break;
screamer 73:8d28a0cb7b43 91 case MSC_REQUEST_GET_MAX_LUN:
screamer 73:8d28a0cb7b43 92 transfer->remaining = 1;
screamer 73:8d28a0cb7b43 93 transfer->ptr = maxLUN;
screamer 73:8d28a0cb7b43 94 transfer->direction = DEVICE_TO_HOST;
screamer 73:8d28a0cb7b43 95 success = true;
screamer 73:8d28a0cb7b43 96 break;
screamer 73:8d28a0cb7b43 97 default:
screamer 73:8d28a0cb7b43 98 break;
screamer 73:8d28a0cb7b43 99 }
screamer 73:8d28a0cb7b43 100 }
screamer 73:8d28a0cb7b43 101
screamer 73:8d28a0cb7b43 102 return success;
screamer 73:8d28a0cb7b43 103 }
screamer 73:8d28a0cb7b43 104
screamer 73:8d28a0cb7b43 105
screamer 73:8d28a0cb7b43 106 bool USBMSD::connect(bool blocking) {
screamer 73:8d28a0cb7b43 107 //disk initialization
screamer 73:8d28a0cb7b43 108 if (disk_status() & NO_INIT) {
screamer 73:8d28a0cb7b43 109 if (disk_initialize()) {
screamer 73:8d28a0cb7b43 110 return false;
screamer 73:8d28a0cb7b43 111 }
screamer 73:8d28a0cb7b43 112 }
screamer 73:8d28a0cb7b43 113
screamer 73:8d28a0cb7b43 114 // get number of blocks
screamer 73:8d28a0cb7b43 115 BlockCount = disk_sectors();
screamer 73:8d28a0cb7b43 116
screamer 73:8d28a0cb7b43 117 // get memory size
screamer 73:8d28a0cb7b43 118 MemorySize = disk_size();
screamer 73:8d28a0cb7b43 119
screamer 73:8d28a0cb7b43 120 if (BlockCount > 0) {
screamer 73:8d28a0cb7b43 121 BlockSize = MemorySize / BlockCount;
screamer 73:8d28a0cb7b43 122 if (BlockSize != 0) {
screamer 73:8d28a0cb7b43 123 free(page);
screamer 73:8d28a0cb7b43 124 page = (uint8_t *)malloc(BlockSize * sizeof(uint8_t));
screamer 73:8d28a0cb7b43 125 if (page == NULL)
screamer 73:8d28a0cb7b43 126 return false;
screamer 73:8d28a0cb7b43 127 }
screamer 73:8d28a0cb7b43 128 } else {
screamer 73:8d28a0cb7b43 129 return false;
screamer 73:8d28a0cb7b43 130 }
screamer 73:8d28a0cb7b43 131
screamer 73:8d28a0cb7b43 132 //connect the device
screamer 73:8d28a0cb7b43 133 USBDevice::connect(blocking);
screamer 73:8d28a0cb7b43 134 return true;
screamer 73:8d28a0cb7b43 135 }
screamer 73:8d28a0cb7b43 136
screamer 73:8d28a0cb7b43 137 void USBMSD::disconnect() {
screamer 73:8d28a0cb7b43 138 USBDevice::disconnect();
screamer 73:8d28a0cb7b43 139 //De-allocate MSD page size:
screamer 73:8d28a0cb7b43 140 free(page);
screamer 73:8d28a0cb7b43 141 page = NULL;
screamer 73:8d28a0cb7b43 142 }
screamer 73:8d28a0cb7b43 143
screamer 73:8d28a0cb7b43 144 void USBMSD::reset() {
screamer 73:8d28a0cb7b43 145 stage = READ_CBW;
screamer 73:8d28a0cb7b43 146 }
screamer 73:8d28a0cb7b43 147
screamer 73:8d28a0cb7b43 148
screamer 73:8d28a0cb7b43 149 // Called in ISR context called when a data is received
screamer 73:8d28a0cb7b43 150 bool USBMSD::EPBULK_OUT_callback() {
screamer 73:8d28a0cb7b43 151 uint32_t size = 0;
screamer 73:8d28a0cb7b43 152 uint8_t buf[MAX_PACKET_SIZE_EPBULK];
screamer 73:8d28a0cb7b43 153 readEP(EPBULK_OUT, buf, &size, MAX_PACKET_SIZE_EPBULK);
screamer 73:8d28a0cb7b43 154 switch (stage) {
screamer 73:8d28a0cb7b43 155 // the device has to decode the CBW received
screamer 73:8d28a0cb7b43 156 case READ_CBW:
screamer 73:8d28a0cb7b43 157 CBWDecode(buf, size);
screamer 73:8d28a0cb7b43 158 break;
screamer 73:8d28a0cb7b43 159
screamer 73:8d28a0cb7b43 160 // the device has to receive data from the host
screamer 73:8d28a0cb7b43 161 case PROCESS_CBW:
screamer 73:8d28a0cb7b43 162 switch (cbw.CB[0]) {
screamer 73:8d28a0cb7b43 163 case WRITE10:
screamer 73:8d28a0cb7b43 164 case WRITE12:
screamer 73:8d28a0cb7b43 165 memoryWrite(buf, size);
screamer 73:8d28a0cb7b43 166 break;
screamer 73:8d28a0cb7b43 167 case VERIFY10:
screamer 73:8d28a0cb7b43 168 memoryVerify(buf, size);
screamer 73:8d28a0cb7b43 169 break;
screamer 73:8d28a0cb7b43 170 }
screamer 73:8d28a0cb7b43 171 break;
screamer 73:8d28a0cb7b43 172
screamer 73:8d28a0cb7b43 173 // an error has occured: stall endpoint and send CSW
screamer 73:8d28a0cb7b43 174 default:
screamer 73:8d28a0cb7b43 175 stallEndpoint(EPBULK_OUT);
screamer 73:8d28a0cb7b43 176 csw.Status = CSW_ERROR;
screamer 73:8d28a0cb7b43 177 sendCSW();
screamer 73:8d28a0cb7b43 178 break;
screamer 73:8d28a0cb7b43 179 }
screamer 73:8d28a0cb7b43 180
screamer 73:8d28a0cb7b43 181 //reactivate readings on the OUT bulk endpoint
screamer 73:8d28a0cb7b43 182 readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
screamer 73:8d28a0cb7b43 183 return true;
screamer 73:8d28a0cb7b43 184 }
screamer 73:8d28a0cb7b43 185
screamer 73:8d28a0cb7b43 186 // Called in ISR context when a data has been transferred
screamer 73:8d28a0cb7b43 187 bool USBMSD::EPBULK_IN_callback() {
screamer 73:8d28a0cb7b43 188 switch (stage) {
screamer 73:8d28a0cb7b43 189
screamer 73:8d28a0cb7b43 190 // the device has to send data to the host
screamer 73:8d28a0cb7b43 191 case PROCESS_CBW:
screamer 73:8d28a0cb7b43 192 switch (cbw.CB[0]) {
screamer 73:8d28a0cb7b43 193 case READ10:
screamer 73:8d28a0cb7b43 194 case READ12:
screamer 73:8d28a0cb7b43 195 memoryRead();
screamer 73:8d28a0cb7b43 196 break;
screamer 73:8d28a0cb7b43 197 }
screamer 73:8d28a0cb7b43 198 break;
screamer 73:8d28a0cb7b43 199
screamer 73:8d28a0cb7b43 200 //the device has to send a CSW
screamer 73:8d28a0cb7b43 201 case SEND_CSW:
screamer 73:8d28a0cb7b43 202 sendCSW();
screamer 73:8d28a0cb7b43 203 break;
screamer 73:8d28a0cb7b43 204
screamer 73:8d28a0cb7b43 205 // the host has received the CSW -> we wait a CBW
screamer 73:8d28a0cb7b43 206 case WAIT_CSW:
screamer 73:8d28a0cb7b43 207 stage = READ_CBW;
screamer 73:8d28a0cb7b43 208 break;
screamer 73:8d28a0cb7b43 209
screamer 73:8d28a0cb7b43 210 // an error has occured
screamer 73:8d28a0cb7b43 211 default:
screamer 73:8d28a0cb7b43 212 stallEndpoint(EPBULK_IN);
screamer 73:8d28a0cb7b43 213 sendCSW();
screamer 73:8d28a0cb7b43 214 break;
screamer 73:8d28a0cb7b43 215 }
screamer 73:8d28a0cb7b43 216 return true;
screamer 73:8d28a0cb7b43 217 }
screamer 73:8d28a0cb7b43 218
screamer 73:8d28a0cb7b43 219
screamer 73:8d28a0cb7b43 220 void USBMSD::memoryWrite (uint8_t * buf, uint16_t size) {
screamer 73:8d28a0cb7b43 221
screamer 73:8d28a0cb7b43 222 if ((addr + size) > MemorySize) {
screamer 73:8d28a0cb7b43 223 size = MemorySize - addr;
screamer 73:8d28a0cb7b43 224 stage = ERROR;
screamer 73:8d28a0cb7b43 225 stallEndpoint(EPBULK_OUT);
screamer 73:8d28a0cb7b43 226 }
screamer 73:8d28a0cb7b43 227
screamer 73:8d28a0cb7b43 228 // we fill an array in RAM of 1 block before writing it in memory
screamer 73:8d28a0cb7b43 229 for (int i = 0; i < size; i++)
screamer 73:8d28a0cb7b43 230 page[addr%BlockSize + i] = buf[i];
screamer 73:8d28a0cb7b43 231
screamer 73:8d28a0cb7b43 232 // if the array is filled, write it in memory
screamer 73:8d28a0cb7b43 233 if (!((addr + size)%BlockSize)) {
screamer 73:8d28a0cb7b43 234 if (!(disk_status() & WRITE_PROTECT)) {
screamer 73:8d28a0cb7b43 235 disk_write(page, addr/BlockSize, 1);
screamer 73:8d28a0cb7b43 236 }
screamer 73:8d28a0cb7b43 237 }
screamer 73:8d28a0cb7b43 238
screamer 73:8d28a0cb7b43 239 addr += size;
screamer 73:8d28a0cb7b43 240 length -= size;
screamer 73:8d28a0cb7b43 241 csw.DataResidue -= size;
screamer 73:8d28a0cb7b43 242
screamer 73:8d28a0cb7b43 243 if ((!length) || (stage != PROCESS_CBW)) {
screamer 73:8d28a0cb7b43 244 csw.Status = (stage == ERROR) ? CSW_FAILED : CSW_PASSED;
screamer 73:8d28a0cb7b43 245 sendCSW();
screamer 73:8d28a0cb7b43 246 }
screamer 73:8d28a0cb7b43 247 }
screamer 73:8d28a0cb7b43 248
screamer 73:8d28a0cb7b43 249 void USBMSD::memoryVerify (uint8_t * buf, uint16_t size) {
screamer 73:8d28a0cb7b43 250 uint32_t n;
screamer 73:8d28a0cb7b43 251
screamer 73:8d28a0cb7b43 252 if ((addr + size) > MemorySize) {
screamer 73:8d28a0cb7b43 253 size = MemorySize - addr;
screamer 73:8d28a0cb7b43 254 stage = ERROR;
screamer 73:8d28a0cb7b43 255 stallEndpoint(EPBULK_OUT);
screamer 73:8d28a0cb7b43 256 }
screamer 73:8d28a0cb7b43 257
screamer 73:8d28a0cb7b43 258 // beginning of a new block -> load a whole block in RAM
screamer 73:8d28a0cb7b43 259 if (!(addr%BlockSize))
screamer 73:8d28a0cb7b43 260 disk_read(page, addr/BlockSize, 1);
screamer 73:8d28a0cb7b43 261
screamer 73:8d28a0cb7b43 262 // info are in RAM -> no need to re-read memory
screamer 73:8d28a0cb7b43 263 for (n = 0; n < size; n++) {
screamer 73:8d28a0cb7b43 264 if (page[addr%BlockSize + n] != buf[n]) {
screamer 73:8d28a0cb7b43 265 memOK = false;
screamer 73:8d28a0cb7b43 266 break;
screamer 73:8d28a0cb7b43 267 }
screamer 73:8d28a0cb7b43 268 }
screamer 73:8d28a0cb7b43 269
screamer 73:8d28a0cb7b43 270 addr += size;
screamer 73:8d28a0cb7b43 271 length -= size;
screamer 73:8d28a0cb7b43 272 csw.DataResidue -= size;
screamer 73:8d28a0cb7b43 273
screamer 73:8d28a0cb7b43 274 if ( !length || (stage != PROCESS_CBW)) {
screamer 73:8d28a0cb7b43 275 csw.Status = (memOK && (stage == PROCESS_CBW)) ? CSW_PASSED : CSW_FAILED;
screamer 73:8d28a0cb7b43 276 sendCSW();
screamer 73:8d28a0cb7b43 277 }
screamer 73:8d28a0cb7b43 278 }
screamer 73:8d28a0cb7b43 279
screamer 73:8d28a0cb7b43 280
screamer 73:8d28a0cb7b43 281 bool USBMSD::inquiryRequest (void) {
screamer 73:8d28a0cb7b43 282 uint8_t inquiry[] = { 0x00, 0x80, 0x00, 0x01,
screamer 73:8d28a0cb7b43 283 36 - 4, 0x80, 0x00, 0x00,
screamer 73:8d28a0cb7b43 284 'M', 'B', 'E', 'D', '.', 'O', 'R', 'G',
screamer 73:8d28a0cb7b43 285 'M', 'B', 'E', 'D', ' ', 'U', 'S', 'B', ' ', 'D', 'I', 'S', 'K', ' ', ' ', ' ',
screamer 73:8d28a0cb7b43 286 '1', '.', '0', ' ',
screamer 73:8d28a0cb7b43 287 };
screamer 73:8d28a0cb7b43 288 if (!write(inquiry, sizeof(inquiry))) {
screamer 73:8d28a0cb7b43 289 return false;
screamer 73:8d28a0cb7b43 290 }
screamer 73:8d28a0cb7b43 291 return true;
screamer 73:8d28a0cb7b43 292 }
screamer 73:8d28a0cb7b43 293
screamer 73:8d28a0cb7b43 294
screamer 73:8d28a0cb7b43 295 bool USBMSD::readFormatCapacity() {
screamer 73:8d28a0cb7b43 296 uint8_t capacity[] = { 0x00, 0x00, 0x00, 0x08,
screamer 73:8d28a0cb7b43 297 (uint8_t)((BlockCount >> 24) & 0xff),
screamer 73:8d28a0cb7b43 298 (uint8_t)((BlockCount >> 16) & 0xff),
screamer 73:8d28a0cb7b43 299 (uint8_t)((BlockCount >> 8) & 0xff),
screamer 73:8d28a0cb7b43 300 (uint8_t)((BlockCount >> 0) & 0xff),
screamer 73:8d28a0cb7b43 301
screamer 73:8d28a0cb7b43 302 0x02,
screamer 73:8d28a0cb7b43 303 (uint8_t)((BlockSize >> 16) & 0xff),
screamer 73:8d28a0cb7b43 304 (uint8_t)((BlockSize >> 8) & 0xff),
screamer 73:8d28a0cb7b43 305 (uint8_t)((BlockSize >> 0) & 0xff),
screamer 73:8d28a0cb7b43 306 };
screamer 73:8d28a0cb7b43 307 if (!write(capacity, sizeof(capacity))) {
screamer 73:8d28a0cb7b43 308 return false;
screamer 73:8d28a0cb7b43 309 }
screamer 73:8d28a0cb7b43 310 return true;
screamer 73:8d28a0cb7b43 311 }
screamer 73:8d28a0cb7b43 312
screamer 73:8d28a0cb7b43 313
screamer 73:8d28a0cb7b43 314 bool USBMSD::readCapacity (void) {
screamer 73:8d28a0cb7b43 315 uint8_t capacity[] = {
screamer 73:8d28a0cb7b43 316 (uint8_t)(((BlockCount - 1) >> 24) & 0xff),
screamer 73:8d28a0cb7b43 317 (uint8_t)(((BlockCount - 1) >> 16) & 0xff),
screamer 73:8d28a0cb7b43 318 (uint8_t)(((BlockCount - 1) >> 8) & 0xff),
screamer 73:8d28a0cb7b43 319 (uint8_t)(((BlockCount - 1) >> 0) & 0xff),
screamer 73:8d28a0cb7b43 320
screamer 73:8d28a0cb7b43 321 (uint8_t)((BlockSize >> 24) & 0xff),
screamer 73:8d28a0cb7b43 322 (uint8_t)((BlockSize >> 16) & 0xff),
screamer 73:8d28a0cb7b43 323 (uint8_t)((BlockSize >> 8) & 0xff),
screamer 73:8d28a0cb7b43 324 (uint8_t)((BlockSize >> 0) & 0xff),
screamer 73:8d28a0cb7b43 325 };
screamer 73:8d28a0cb7b43 326 if (!write(capacity, sizeof(capacity))) {
screamer 73:8d28a0cb7b43 327 return false;
screamer 73:8d28a0cb7b43 328 }
screamer 73:8d28a0cb7b43 329 return true;
screamer 73:8d28a0cb7b43 330 }
screamer 73:8d28a0cb7b43 331
screamer 73:8d28a0cb7b43 332 bool USBMSD::write (uint8_t * buf, uint16_t size) {
screamer 73:8d28a0cb7b43 333
screamer 73:8d28a0cb7b43 334 if (size >= cbw.DataLength) {
screamer 73:8d28a0cb7b43 335 size = cbw.DataLength;
screamer 73:8d28a0cb7b43 336 }
screamer 73:8d28a0cb7b43 337 stage = SEND_CSW;
screamer 73:8d28a0cb7b43 338
screamer 73:8d28a0cb7b43 339 if (!writeNB(EPBULK_IN, buf, size, MAX_PACKET_SIZE_EPBULK)) {
screamer 73:8d28a0cb7b43 340 return false;
screamer 73:8d28a0cb7b43 341 }
screamer 73:8d28a0cb7b43 342
screamer 73:8d28a0cb7b43 343 csw.DataResidue -= size;
screamer 73:8d28a0cb7b43 344 csw.Status = CSW_PASSED;
screamer 73:8d28a0cb7b43 345 return true;
screamer 73:8d28a0cb7b43 346 }
screamer 73:8d28a0cb7b43 347
screamer 73:8d28a0cb7b43 348
screamer 73:8d28a0cb7b43 349 bool USBMSD::modeSense6 (void) {
screamer 73:8d28a0cb7b43 350 uint8_t sense6[] = { 0x03, 0x00, 0x00, 0x00 };
screamer 73:8d28a0cb7b43 351 if (!write(sense6, sizeof(sense6))) {
screamer 73:8d28a0cb7b43 352 return false;
screamer 73:8d28a0cb7b43 353 }
screamer 73:8d28a0cb7b43 354 return true;
screamer 73:8d28a0cb7b43 355 }
screamer 73:8d28a0cb7b43 356
screamer 73:8d28a0cb7b43 357 void USBMSD::sendCSW() {
screamer 73:8d28a0cb7b43 358 csw.Signature = CSW_Signature;
screamer 73:8d28a0cb7b43 359 writeNB(EPBULK_IN, (uint8_t *)&csw, sizeof(CSW), MAX_PACKET_SIZE_EPBULK);
screamer 73:8d28a0cb7b43 360 stage = WAIT_CSW;
screamer 73:8d28a0cb7b43 361 }
screamer 73:8d28a0cb7b43 362
screamer 73:8d28a0cb7b43 363 bool USBMSD::requestSense (void) {
screamer 73:8d28a0cb7b43 364 uint8_t request_sense[] = {
screamer 73:8d28a0cb7b43 365 0x70,
screamer 73:8d28a0cb7b43 366 0x00,
screamer 73:8d28a0cb7b43 367 0x05, // Sense Key: illegal request
screamer 73:8d28a0cb7b43 368 0x00,
screamer 73:8d28a0cb7b43 369 0x00,
screamer 73:8d28a0cb7b43 370 0x00,
screamer 73:8d28a0cb7b43 371 0x00,
screamer 73:8d28a0cb7b43 372 0x0A,
screamer 73:8d28a0cb7b43 373 0x00,
screamer 73:8d28a0cb7b43 374 0x00,
screamer 73:8d28a0cb7b43 375 0x00,
screamer 73:8d28a0cb7b43 376 0x00,
screamer 73:8d28a0cb7b43 377 0x30,
screamer 73:8d28a0cb7b43 378 0x01,
screamer 73:8d28a0cb7b43 379 0x00,
screamer 73:8d28a0cb7b43 380 0x00,
screamer 73:8d28a0cb7b43 381 0x00,
screamer 73:8d28a0cb7b43 382 0x00,
screamer 73:8d28a0cb7b43 383 };
screamer 73:8d28a0cb7b43 384
screamer 73:8d28a0cb7b43 385 if (!write(request_sense, sizeof(request_sense))) {
screamer 73:8d28a0cb7b43 386 return false;
screamer 73:8d28a0cb7b43 387 }
screamer 73:8d28a0cb7b43 388
screamer 73:8d28a0cb7b43 389 return true;
screamer 73:8d28a0cb7b43 390 }
screamer 73:8d28a0cb7b43 391
screamer 73:8d28a0cb7b43 392 void USBMSD::fail() {
screamer 73:8d28a0cb7b43 393 csw.Status = CSW_FAILED;
screamer 73:8d28a0cb7b43 394 sendCSW();
screamer 73:8d28a0cb7b43 395 }
screamer 73:8d28a0cb7b43 396
screamer 73:8d28a0cb7b43 397
screamer 73:8d28a0cb7b43 398 void USBMSD::CBWDecode(uint8_t * buf, uint16_t size) {
screamer 73:8d28a0cb7b43 399 if (size == sizeof(cbw)) {
screamer 73:8d28a0cb7b43 400 memcpy((uint8_t *)&cbw, buf, size);
screamer 73:8d28a0cb7b43 401 if (cbw.Signature == CBW_Signature) {
screamer 73:8d28a0cb7b43 402 csw.Tag = cbw.Tag;
screamer 73:8d28a0cb7b43 403 csw.DataResidue = cbw.DataLength;
screamer 73:8d28a0cb7b43 404 if ((cbw.CBLength < 1) || (cbw.CBLength > 16) ) {
screamer 73:8d28a0cb7b43 405 fail();
screamer 73:8d28a0cb7b43 406 } else {
screamer 73:8d28a0cb7b43 407 switch (cbw.CB[0]) {
screamer 73:8d28a0cb7b43 408 case TEST_UNIT_READY:
screamer 73:8d28a0cb7b43 409 testUnitReady();
screamer 73:8d28a0cb7b43 410 break;
screamer 73:8d28a0cb7b43 411 case REQUEST_SENSE:
screamer 73:8d28a0cb7b43 412 requestSense();
screamer 73:8d28a0cb7b43 413 break;
screamer 73:8d28a0cb7b43 414 case INQUIRY:
screamer 73:8d28a0cb7b43 415 inquiryRequest();
screamer 73:8d28a0cb7b43 416 break;
screamer 73:8d28a0cb7b43 417 case MODE_SENSE6:
screamer 73:8d28a0cb7b43 418 modeSense6();
screamer 73:8d28a0cb7b43 419 break;
screamer 73:8d28a0cb7b43 420 case READ_FORMAT_CAPACITIES:
screamer 73:8d28a0cb7b43 421 readFormatCapacity();
screamer 73:8d28a0cb7b43 422 break;
screamer 73:8d28a0cb7b43 423 case READ_CAPACITY:
screamer 73:8d28a0cb7b43 424 readCapacity();
screamer 73:8d28a0cb7b43 425 break;
screamer 73:8d28a0cb7b43 426 case READ10:
screamer 73:8d28a0cb7b43 427 case READ12:
screamer 73:8d28a0cb7b43 428 if (infoTransfer()) {
screamer 73:8d28a0cb7b43 429 if ((cbw.Flags & 0x80)) {
screamer 73:8d28a0cb7b43 430 stage = PROCESS_CBW;
screamer 73:8d28a0cb7b43 431 memoryRead();
screamer 73:8d28a0cb7b43 432 } else {
screamer 73:8d28a0cb7b43 433 stallEndpoint(EPBULK_OUT);
screamer 73:8d28a0cb7b43 434 csw.Status = CSW_ERROR;
screamer 73:8d28a0cb7b43 435 sendCSW();
screamer 73:8d28a0cb7b43 436 }
screamer 73:8d28a0cb7b43 437 }
screamer 73:8d28a0cb7b43 438 break;
screamer 73:8d28a0cb7b43 439 case WRITE10:
screamer 73:8d28a0cb7b43 440 case WRITE12:
screamer 73:8d28a0cb7b43 441 if (infoTransfer()) {
screamer 73:8d28a0cb7b43 442 if (!(cbw.Flags & 0x80)) {
screamer 73:8d28a0cb7b43 443 stage = PROCESS_CBW;
screamer 73:8d28a0cb7b43 444 } else {
screamer 73:8d28a0cb7b43 445 stallEndpoint(EPBULK_IN);
screamer 73:8d28a0cb7b43 446 csw.Status = CSW_ERROR;
screamer 73:8d28a0cb7b43 447 sendCSW();
screamer 73:8d28a0cb7b43 448 }
screamer 73:8d28a0cb7b43 449 }
screamer 73:8d28a0cb7b43 450 break;
screamer 73:8d28a0cb7b43 451 case VERIFY10:
screamer 73:8d28a0cb7b43 452 if (!(cbw.CB[1] & 0x02)) {
screamer 73:8d28a0cb7b43 453 csw.Status = CSW_PASSED;
screamer 73:8d28a0cb7b43 454 sendCSW();
screamer 73:8d28a0cb7b43 455 break;
screamer 73:8d28a0cb7b43 456 }
screamer 73:8d28a0cb7b43 457 if (infoTransfer()) {
screamer 73:8d28a0cb7b43 458 if (!(cbw.Flags & 0x80)) {
screamer 73:8d28a0cb7b43 459 stage = PROCESS_CBW;
screamer 73:8d28a0cb7b43 460 memOK = true;
screamer 73:8d28a0cb7b43 461 } else {
screamer 73:8d28a0cb7b43 462 stallEndpoint(EPBULK_IN);
screamer 73:8d28a0cb7b43 463 csw.Status = CSW_ERROR;
screamer 73:8d28a0cb7b43 464 sendCSW();
screamer 73:8d28a0cb7b43 465 }
screamer 73:8d28a0cb7b43 466 }
screamer 73:8d28a0cb7b43 467 break;
screamer 73:8d28a0cb7b43 468 case MEDIA_REMOVAL:
screamer 73:8d28a0cb7b43 469 csw.Status = CSW_PASSED;
screamer 73:8d28a0cb7b43 470 sendCSW();
screamer 73:8d28a0cb7b43 471 break;
screamer 73:8d28a0cb7b43 472 default:
screamer 73:8d28a0cb7b43 473 fail();
screamer 73:8d28a0cb7b43 474 break;
screamer 73:8d28a0cb7b43 475 }
screamer 73:8d28a0cb7b43 476 }
screamer 73:8d28a0cb7b43 477 }
screamer 73:8d28a0cb7b43 478 }
screamer 73:8d28a0cb7b43 479 }
screamer 73:8d28a0cb7b43 480
screamer 73:8d28a0cb7b43 481 void USBMSD::testUnitReady (void) {
screamer 73:8d28a0cb7b43 482
screamer 73:8d28a0cb7b43 483 if (cbw.DataLength != 0) {
screamer 73:8d28a0cb7b43 484 if ((cbw.Flags & 0x80) != 0) {
screamer 73:8d28a0cb7b43 485 stallEndpoint(EPBULK_IN);
screamer 73:8d28a0cb7b43 486 } else {
screamer 73:8d28a0cb7b43 487 stallEndpoint(EPBULK_OUT);
screamer 73:8d28a0cb7b43 488 }
screamer 73:8d28a0cb7b43 489 }
screamer 73:8d28a0cb7b43 490
screamer 73:8d28a0cb7b43 491 csw.Status = CSW_PASSED;
screamer 73:8d28a0cb7b43 492 sendCSW();
screamer 73:8d28a0cb7b43 493 }
screamer 73:8d28a0cb7b43 494
screamer 73:8d28a0cb7b43 495
screamer 73:8d28a0cb7b43 496 void USBMSD::memoryRead (void) {
screamer 73:8d28a0cb7b43 497 uint32_t n;
screamer 73:8d28a0cb7b43 498
screamer 73:8d28a0cb7b43 499 n = (length > MAX_PACKET) ? MAX_PACKET : length;
screamer 73:8d28a0cb7b43 500
screamer 73:8d28a0cb7b43 501 if ((addr + n) > MemorySize) {
screamer 73:8d28a0cb7b43 502 n = MemorySize - addr;
screamer 73:8d28a0cb7b43 503 stage = ERROR;
screamer 73:8d28a0cb7b43 504 }
screamer 73:8d28a0cb7b43 505
screamer 73:8d28a0cb7b43 506 // we read an entire block
screamer 73:8d28a0cb7b43 507 if (!(addr%BlockSize))
screamer 73:8d28a0cb7b43 508 disk_read(page, addr/BlockSize, 1);
screamer 73:8d28a0cb7b43 509
screamer 73:8d28a0cb7b43 510 // write data which are in RAM
screamer 73:8d28a0cb7b43 511 writeNB(EPBULK_IN, &page[addr%BlockSize], n, MAX_PACKET_SIZE_EPBULK);
screamer 73:8d28a0cb7b43 512
screamer 73:8d28a0cb7b43 513 addr += n;
screamer 73:8d28a0cb7b43 514 length -= n;
screamer 73:8d28a0cb7b43 515
screamer 73:8d28a0cb7b43 516 csw.DataResidue -= n;
screamer 73:8d28a0cb7b43 517
screamer 73:8d28a0cb7b43 518 if ( !length || (stage != PROCESS_CBW)) {
screamer 73:8d28a0cb7b43 519 csw.Status = (stage == PROCESS_CBW) ? CSW_PASSED : CSW_FAILED;
screamer 73:8d28a0cb7b43 520 stage = (stage == PROCESS_CBW) ? SEND_CSW : stage;
screamer 73:8d28a0cb7b43 521 }
screamer 73:8d28a0cb7b43 522 }
screamer 73:8d28a0cb7b43 523
screamer 73:8d28a0cb7b43 524
screamer 73:8d28a0cb7b43 525 bool USBMSD::infoTransfer (void) {
screamer 73:8d28a0cb7b43 526 uint32_t n;
screamer 73:8d28a0cb7b43 527
screamer 73:8d28a0cb7b43 528 // Logical Block Address of First Block
screamer 73:8d28a0cb7b43 529 n = (cbw.CB[2] << 24) | (cbw.CB[3] << 16) | (cbw.CB[4] << 8) | (cbw.CB[5] << 0);
screamer 73:8d28a0cb7b43 530
screamer 73:8d28a0cb7b43 531 addr = n * BlockSize;
screamer 73:8d28a0cb7b43 532
screamer 73:8d28a0cb7b43 533 // Number of Blocks to transfer
screamer 73:8d28a0cb7b43 534 switch (cbw.CB[0]) {
screamer 73:8d28a0cb7b43 535 case READ10:
screamer 73:8d28a0cb7b43 536 case WRITE10:
screamer 73:8d28a0cb7b43 537 case VERIFY10:
screamer 73:8d28a0cb7b43 538 n = (cbw.CB[7] << 8) | (cbw.CB[8] << 0);
screamer 73:8d28a0cb7b43 539 break;
screamer 73:8d28a0cb7b43 540
screamer 73:8d28a0cb7b43 541 case READ12:
screamer 73:8d28a0cb7b43 542 case WRITE12:
screamer 73:8d28a0cb7b43 543 n = (cbw.CB[6] << 24) | (cbw.CB[7] << 16) | (cbw.CB[8] << 8) | (cbw.CB[9] << 0);
screamer 73:8d28a0cb7b43 544 break;
screamer 73:8d28a0cb7b43 545 }
screamer 73:8d28a0cb7b43 546
screamer 73:8d28a0cb7b43 547 length = n * BlockSize;
screamer 73:8d28a0cb7b43 548
screamer 73:8d28a0cb7b43 549 if (!cbw.DataLength) { // host requests no data
screamer 73:8d28a0cb7b43 550 csw.Status = CSW_FAILED;
screamer 73:8d28a0cb7b43 551 sendCSW();
screamer 73:8d28a0cb7b43 552 return false;
screamer 73:8d28a0cb7b43 553 }
screamer 73:8d28a0cb7b43 554
screamer 73:8d28a0cb7b43 555 if (cbw.DataLength != length) {
screamer 73:8d28a0cb7b43 556 if ((cbw.Flags & 0x80) != 0) {
screamer 73:8d28a0cb7b43 557 stallEndpoint(EPBULK_IN);
screamer 73:8d28a0cb7b43 558 } else {
screamer 73:8d28a0cb7b43 559 stallEndpoint(EPBULK_OUT);
screamer 73:8d28a0cb7b43 560 }
screamer 73:8d28a0cb7b43 561
screamer 73:8d28a0cb7b43 562 csw.Status = CSW_FAILED;
screamer 73:8d28a0cb7b43 563 sendCSW();
screamer 73:8d28a0cb7b43 564 return false;
screamer 73:8d28a0cb7b43 565 }
screamer 73:8d28a0cb7b43 566
screamer 73:8d28a0cb7b43 567 return true;
screamer 73:8d28a0cb7b43 568 }
screamer 73:8d28a0cb7b43 569
screamer 73:8d28a0cb7b43 570
screamer 73:8d28a0cb7b43 571
screamer 73:8d28a0cb7b43 572
screamer 73:8d28a0cb7b43 573
screamer 73:8d28a0cb7b43 574 // Called in ISR context
screamer 73:8d28a0cb7b43 575 // Set configuration. Return false if the
screamer 73:8d28a0cb7b43 576 // configuration is not supported.
screamer 73:8d28a0cb7b43 577 bool USBMSD::USBCallback_setConfiguration(uint8_t configuration) {
screamer 73:8d28a0cb7b43 578 if (configuration != DEFAULT_CONFIGURATION) {
screamer 73:8d28a0cb7b43 579 return false;
screamer 73:8d28a0cb7b43 580 }
screamer 73:8d28a0cb7b43 581
screamer 73:8d28a0cb7b43 582 // Configure endpoints > 0
screamer 73:8d28a0cb7b43 583 addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK);
screamer 73:8d28a0cb7b43 584 addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
screamer 73:8d28a0cb7b43 585
screamer 73:8d28a0cb7b43 586 //activate readings
screamer 73:8d28a0cb7b43 587 readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
screamer 73:8d28a0cb7b43 588 return true;
screamer 73:8d28a0cb7b43 589 }
screamer 73:8d28a0cb7b43 590
screamer 73:8d28a0cb7b43 591
screamer 73:8d28a0cb7b43 592 uint8_t * USBMSD::stringIinterfaceDesc() {
screamer 73:8d28a0cb7b43 593 static uint8_t stringIinterfaceDescriptor[] = {
screamer 73:8d28a0cb7b43 594 0x08, //bLength
screamer 73:8d28a0cb7b43 595 STRING_DESCRIPTOR, //bDescriptorType 0x03
screamer 73:8d28a0cb7b43 596 'M',0,'S',0,'D',0 //bString iInterface - MSD
screamer 73:8d28a0cb7b43 597 };
screamer 73:8d28a0cb7b43 598 return stringIinterfaceDescriptor;
screamer 73:8d28a0cb7b43 599 }
screamer 73:8d28a0cb7b43 600
screamer 73:8d28a0cb7b43 601 uint8_t * USBMSD::stringIproductDesc() {
screamer 73:8d28a0cb7b43 602 static uint8_t stringIproductDescriptor[] = {
screamer 73:8d28a0cb7b43 603 0x12, //bLength
screamer 73:8d28a0cb7b43 604 STRING_DESCRIPTOR, //bDescriptorType 0x03
screamer 73:8d28a0cb7b43 605 'M',0,'b',0,'e',0,'d',0,' ',0,'M',0,'S',0,'D',0 //bString iProduct - Mbed Audio
screamer 73:8d28a0cb7b43 606 };
screamer 73:8d28a0cb7b43 607 return stringIproductDescriptor;
screamer 73:8d28a0cb7b43 608 }
screamer 73:8d28a0cb7b43 609
screamer 73:8d28a0cb7b43 610
screamer 73:8d28a0cb7b43 611 uint8_t * USBMSD::configurationDesc() {
screamer 73:8d28a0cb7b43 612 static uint8_t configDescriptor[] = {
screamer 73:8d28a0cb7b43 613
screamer 73:8d28a0cb7b43 614 // Configuration 1
screamer 73:8d28a0cb7b43 615 9, // bLength
screamer 73:8d28a0cb7b43 616 2, // bDescriptorType
screamer 73:8d28a0cb7b43 617 LSB(9 + 9 + 7 + 7), // wTotalLength
screamer 73:8d28a0cb7b43 618 MSB(9 + 9 + 7 + 7),
screamer 73:8d28a0cb7b43 619 0x01, // bNumInterfaces
screamer 73:8d28a0cb7b43 620 0x01, // bConfigurationValue: 0x01 is used to select this configuration
screamer 73:8d28a0cb7b43 621 0x00, // iConfiguration: no string to describe this configuration
screamer 73:8d28a0cb7b43 622 0xC0, // bmAttributes
screamer 73:8d28a0cb7b43 623 100, // bMaxPower, device power consumption is 100 mA
screamer 73:8d28a0cb7b43 624
screamer 73:8d28a0cb7b43 625 // Interface 0, Alternate Setting 0, MSC Class
screamer 73:8d28a0cb7b43 626 9, // bLength
screamer 73:8d28a0cb7b43 627 4, // bDescriptorType
screamer 73:8d28a0cb7b43 628 0x00, // bInterfaceNumber
screamer 73:8d28a0cb7b43 629 0x00, // bAlternateSetting
screamer 73:8d28a0cb7b43 630 0x02, // bNumEndpoints
screamer 73:8d28a0cb7b43 631 0x08, // bInterfaceClass
screamer 73:8d28a0cb7b43 632 0x06, // bInterfaceSubClass
screamer 73:8d28a0cb7b43 633 0x50, // bInterfaceProtocol
screamer 73:8d28a0cb7b43 634 0x04, // iInterface
screamer 73:8d28a0cb7b43 635
screamer 73:8d28a0cb7b43 636 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
screamer 73:8d28a0cb7b43 637 7, // bLength
screamer 73:8d28a0cb7b43 638 5, // bDescriptorType
screamer 73:8d28a0cb7b43 639 PHY_TO_DESC(EPBULK_IN), // bEndpointAddress
screamer 73:8d28a0cb7b43 640 0x02, // bmAttributes (0x02=bulk)
screamer 73:8d28a0cb7b43 641 LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB)
screamer 73:8d28a0cb7b43 642 MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB)
screamer 73:8d28a0cb7b43 643 0, // bInterval
screamer 73:8d28a0cb7b43 644
screamer 73:8d28a0cb7b43 645 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
screamer 73:8d28a0cb7b43 646 7, // bLength
screamer 73:8d28a0cb7b43 647 5, // bDescriptorType
screamer 73:8d28a0cb7b43 648 PHY_TO_DESC(EPBULK_OUT), // bEndpointAddress
screamer 73:8d28a0cb7b43 649 0x02, // bmAttributes (0x02=bulk)
screamer 73:8d28a0cb7b43 650 LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB)
screamer 73:8d28a0cb7b43 651 MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB)
screamer 73:8d28a0cb7b43 652 0 // bInterval
screamer 73:8d28a0cb7b43 653 };
screamer 73:8d28a0cb7b43 654 return configDescriptor;
screamer 73:8d28a0cb7b43 655 }