1 /* Driver for Datafab USB Compact Flash reader 2 * 3 * $Id: datafab.c,v 1.7 2002/02/25 00:40:13 mdharm Exp $ 4 * 5 * datafab driver v0.1: 6 * 7 * First release 8 * 9 * Current development and maintenance by: 10 * (c) 2000 Jimmie Mayfield (mayfield+datafab@sackheads.org) 11 * 12 * Many thanks to Robert Baruch for the SanDisk SmartMedia reader driver 13 * which I used as a template for this driver. 14 * 15 * Some bugfixes and scatter-gather code by Gregory P. Smith 16 * (greg-usb@electricrain.com) 17 * 18 * Fix for media change by Joerg Schneider (js@joergschneider.com) 19 * 20 * Other contributors: 21 * (c) 2002 Alan Stern <stern@rowland.org> 22 * 23 * This program is free software; you can redistribute it and/or modify it 24 * under the terms of the GNU General Public License as published by the 25 * Free Software Foundation; either version 2, or (at your option) any 26 * later version. 27 * 28 * This program is distributed in the hope that it will be useful, but 29 * WITHOUT ANY WARRANTY; without even the implied warranty of 30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 31 * General Public License for more details. 32 * 33 * You should have received a copy of the GNU General Public License along 34 * with this program; if not, write to the Free Software Foundation, Inc., 35 * 675 Mass Ave, Cambridge, MA 02139, USA. 36 */ 37 38 /* 39 * This driver attempts to support USB CompactFlash reader/writer devices 40 * based on Datafab USB-to-ATA chips. It was specifically developed for the 41 * Datafab MDCFE-B USB CompactFlash reader but has since been found to work 42 * with a variety of Datafab-based devices from a number of manufacturers. 43 * I've received a report of this driver working with a Datafab-based 44 * SmartMedia device though please be aware that I'm personally unable to 45 * test SmartMedia support. 46 * 47 * This driver supports reading and writing. If you're truly paranoid, 48 * however, you can force the driver into a write-protected state by setting 49 * the WP enable bits in datafab_handle_mode_sense(). See the comments 50 * in that routine. 51 */ 52 53 #include <linux/sched.h> 54 #include <linux/errno.h> 55 #include <linux/slab.h> 56 57 #include <scsi/scsi.h> 58 #include <scsi/scsi_cmnd.h> 59 60 #include "usb.h" 61 #include "transport.h" 62 #include "protocol.h" 63 #include "debug.h" 64 #include "datafab.h" 65 66 static int datafab_determine_lun(struct us_data *us, 67 struct datafab_info *info); 68 69 70 static inline int 71 datafab_bulk_read(struct us_data *us, unsigned char *data, unsigned int len) { 72 if (len == 0) 73 return USB_STOR_XFER_GOOD; 74 75 US_DEBUGP("datafab_bulk_read: len = %d\n", len); 76 return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 77 data, len, NULL); 78 } 79 80 81 static inline int 82 datafab_bulk_write(struct us_data *us, unsigned char *data, unsigned int len) { 83 if (len == 0) 84 return USB_STOR_XFER_GOOD; 85 86 US_DEBUGP("datafab_bulk_write: len = %d\n", len); 87 return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 88 data, len, NULL); 89 } 90 91 92 static int datafab_read_data(struct us_data *us, 93 struct datafab_info *info, 94 u32 sector, 95 u32 sectors) 96 { 97 unsigned char *command = us->iobuf; 98 unsigned char *buffer; 99 unsigned char thistime; 100 unsigned int totallen, alloclen; 101 int len, result; 102 unsigned int sg_idx = 0, sg_offset = 0; 103 104 // we're working in LBA mode. according to the ATA spec, 105 // we can support up to 28-bit addressing. I don't know if Datafab 106 // supports beyond 24-bit addressing. It's kind of hard to test 107 // since it requires > 8GB CF card. 108 // 109 if (sectors > 0x0FFFFFFF) 110 return USB_STOR_TRANSPORT_ERROR; 111 112 if (info->lun == -1) { 113 result = datafab_determine_lun(us, info); 114 if (result != USB_STOR_TRANSPORT_GOOD) 115 return result; 116 } 117 118 totallen = sectors * info->ssize; 119 120 // Since we don't read more than 64 KB at a time, we have to create 121 // a bounce buffer and move the data a piece at a time between the 122 // bounce buffer and the actual transfer buffer. 123 124 alloclen = min(totallen, 65536u); 125 buffer = kmalloc(alloclen, GFP_NOIO); 126 if (buffer == NULL) 127 return USB_STOR_TRANSPORT_ERROR; 128 129 do { 130 // loop, never allocate or transfer more than 64k at once 131 // (min(128k, 255*info->ssize) is the real limit) 132 133 len = min(totallen, alloclen); 134 thistime = (len / info->ssize) & 0xff; 135 136 command[0] = 0; 137 command[1] = thistime; 138 command[2] = sector & 0xFF; 139 command[3] = (sector >> 8) & 0xFF; 140 command[4] = (sector >> 16) & 0xFF; 141 142 command[5] = 0xE0 + (info->lun << 4); 143 command[5] |= (sector >> 24) & 0x0F; 144 command[6] = 0x20; 145 command[7] = 0x01; 146 147 // send the read command 148 result = datafab_bulk_write(us, command, 8); 149 if (result != USB_STOR_XFER_GOOD) 150 goto leave; 151 152 // read the result 153 result = datafab_bulk_read(us, buffer, len); 154 if (result != USB_STOR_XFER_GOOD) 155 goto leave; 156 157 // Store the data in the transfer buffer 158 usb_stor_access_xfer_buf(buffer, len, us->srb, 159 &sg_idx, &sg_offset, TO_XFER_BUF); 160 161 sector += thistime; 162 totallen -= len; 163 } while (totallen > 0); 164 165 kfree(buffer); 166 return USB_STOR_TRANSPORT_GOOD; 167 168 leave: 169 kfree(buffer); 170 return USB_STOR_TRANSPORT_ERROR; 171 } 172 173 174 static int datafab_write_data(struct us_data *us, 175 struct datafab_info *info, 176 u32 sector, 177 u32 sectors) 178 { 179 unsigned char *command = us->iobuf; 180 unsigned char *reply = us->iobuf; 181 unsigned char *buffer; 182 unsigned char thistime; 183 unsigned int totallen, alloclen; 184 int len, result; 185 unsigned int sg_idx = 0, sg_offset = 0; 186 187 // we're working in LBA mode. according to the ATA spec, 188 // we can support up to 28-bit addressing. I don't know if Datafab 189 // supports beyond 24-bit addressing. It's kind of hard to test 190 // since it requires > 8GB CF card. 191 // 192 if (sectors > 0x0FFFFFFF) 193 return USB_STOR_TRANSPORT_ERROR; 194 195 if (info->lun == -1) { 196 result = datafab_determine_lun(us, info); 197 if (result != USB_STOR_TRANSPORT_GOOD) 198 return result; 199 } 200 201 totallen = sectors * info->ssize; 202 203 // Since we don't write more than 64 KB at a time, we have to create 204 // a bounce buffer and move the data a piece at a time between the 205 // bounce buffer and the actual transfer buffer. 206 207 alloclen = min(totallen, 65536u); 208 buffer = kmalloc(alloclen, GFP_NOIO); 209 if (buffer == NULL) 210 return USB_STOR_TRANSPORT_ERROR; 211 212 do { 213 // loop, never allocate or transfer more than 64k at once 214 // (min(128k, 255*info->ssize) is the real limit) 215 216 len = min(totallen, alloclen); 217 thistime = (len / info->ssize) & 0xff; 218 219 // Get the data from the transfer buffer 220 usb_stor_access_xfer_buf(buffer, len, us->srb, 221 &sg_idx, &sg_offset, FROM_XFER_BUF); 222 223 command[0] = 0; 224 command[1] = thistime; 225 command[2] = sector & 0xFF; 226 command[3] = (sector >> 8) & 0xFF; 227 command[4] = (sector >> 16) & 0xFF; 228 229 command[5] = 0xE0 + (info->lun << 4); 230 command[5] |= (sector >> 24) & 0x0F; 231 command[6] = 0x30; 232 command[7] = 0x02; 233 234 // send the command 235 result = datafab_bulk_write(us, command, 8); 236 if (result != USB_STOR_XFER_GOOD) 237 goto leave; 238 239 // send the data 240 result = datafab_bulk_write(us, buffer, len); 241 if (result != USB_STOR_XFER_GOOD) 242 goto leave; 243 244 // read the result 245 result = datafab_bulk_read(us, reply, 2); 246 if (result != USB_STOR_XFER_GOOD) 247 goto leave; 248 249 if (reply[0] != 0x50 && reply[1] != 0) { 250 US_DEBUGP("datafab_write_data: Gah! " 251 "write return code: %02x %02x\n", 252 reply[0], reply[1]); 253 result = USB_STOR_TRANSPORT_ERROR; 254 goto leave; 255 } 256 257 sector += thistime; 258 totallen -= len; 259 } while (totallen > 0); 260 261 kfree(buffer); 262 return USB_STOR_TRANSPORT_GOOD; 263 264 leave: 265 kfree(buffer); 266 return USB_STOR_TRANSPORT_ERROR; 267 } 268 269 270 static int datafab_determine_lun(struct us_data *us, 271 struct datafab_info *info) 272 { 273 // Dual-slot readers can be thought of as dual-LUN devices. 274 // We need to determine which card slot is being used. 275 // We'll send an IDENTIFY DEVICE command and see which LUN responds... 276 // 277 // There might be a better way of doing this? 278 279 static unsigned char scommand[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 }; 280 unsigned char *command = us->iobuf; 281 unsigned char *buf; 282 int count = 0, rc; 283 284 if (!us || !info) 285 return USB_STOR_TRANSPORT_ERROR; 286 287 memcpy(command, scommand, 8); 288 buf = kmalloc(512, GFP_NOIO); 289 if (!buf) 290 return USB_STOR_TRANSPORT_ERROR; 291 292 US_DEBUGP("datafab_determine_lun: locating...\n"); 293 294 // we'll try 3 times before giving up... 295 // 296 while (count++ < 3) { 297 command[5] = 0xa0; 298 299 rc = datafab_bulk_write(us, command, 8); 300 if (rc != USB_STOR_XFER_GOOD) { 301 rc = USB_STOR_TRANSPORT_ERROR; 302 goto leave; 303 } 304 305 rc = datafab_bulk_read(us, buf, 512); 306 if (rc == USB_STOR_XFER_GOOD) { 307 info->lun = 0; 308 rc = USB_STOR_TRANSPORT_GOOD; 309 goto leave; 310 } 311 312 command[5] = 0xb0; 313 314 rc = datafab_bulk_write(us, command, 8); 315 if (rc != USB_STOR_XFER_GOOD) { 316 rc = USB_STOR_TRANSPORT_ERROR; 317 goto leave; 318 } 319 320 rc = datafab_bulk_read(us, buf, 512); 321 if (rc == USB_STOR_XFER_GOOD) { 322 info->lun = 1; 323 rc = USB_STOR_TRANSPORT_GOOD; 324 goto leave; 325 } 326 327 msleep(20); 328 } 329 330 rc = USB_STOR_TRANSPORT_ERROR; 331 332 leave: 333 kfree(buf); 334 return rc; 335 } 336 337 static int datafab_id_device(struct us_data *us, 338 struct datafab_info *info) 339 { 340 // this is a variation of the ATA "IDENTIFY DEVICE" command...according 341 // to the ATA spec, 'Sector Count' isn't used but the Windows driver 342 // sets this bit so we do too... 343 // 344 static unsigned char scommand[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 }; 345 unsigned char *command = us->iobuf; 346 unsigned char *reply; 347 int rc; 348 349 if (!us || !info) 350 return USB_STOR_TRANSPORT_ERROR; 351 352 if (info->lun == -1) { 353 rc = datafab_determine_lun(us, info); 354 if (rc != USB_STOR_TRANSPORT_GOOD) 355 return rc; 356 } 357 358 memcpy(command, scommand, 8); 359 reply = kmalloc(512, GFP_NOIO); 360 if (!reply) 361 return USB_STOR_TRANSPORT_ERROR; 362 363 command[5] += (info->lun << 4); 364 365 rc = datafab_bulk_write(us, command, 8); 366 if (rc != USB_STOR_XFER_GOOD) { 367 rc = USB_STOR_TRANSPORT_ERROR; 368 goto leave; 369 } 370 371 // we'll go ahead and extract the media capacity while we're here... 372 // 373 rc = datafab_bulk_read(us, reply, 512); 374 if (rc == USB_STOR_XFER_GOOD) { 375 // capacity is at word offset 57-58 376 // 377 info->sectors = ((u32)(reply[117]) << 24) | 378 ((u32)(reply[116]) << 16) | 379 ((u32)(reply[115]) << 8) | 380 ((u32)(reply[114]) ); 381 rc = USB_STOR_TRANSPORT_GOOD; 382 goto leave; 383 } 384 385 rc = USB_STOR_TRANSPORT_ERROR; 386 387 leave: 388 kfree(reply); 389 return rc; 390 } 391 392 393 static int datafab_handle_mode_sense(struct us_data *us, 394 struct scsi_cmnd * srb, 395 int sense_6) 396 { 397 static unsigned char rw_err_page[12] = { 398 0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0 399 }; 400 static unsigned char cache_page[12] = { 401 0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0 402 }; 403 static unsigned char rbac_page[12] = { 404 0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0 405 }; 406 static unsigned char timer_page[8] = { 407 0x1C, 0x6, 0, 0, 0, 0 408 }; 409 unsigned char pc, page_code; 410 unsigned int i = 0; 411 struct datafab_info *info = (struct datafab_info *) (us->extra); 412 unsigned char *ptr = us->iobuf; 413 414 // most of this stuff is just a hack to get things working. the 415 // datafab reader doesn't present a SCSI interface so we 416 // fudge the SCSI commands... 417 // 418 419 pc = srb->cmnd[2] >> 6; 420 page_code = srb->cmnd[2] & 0x3F; 421 422 switch (pc) { 423 case 0x0: 424 US_DEBUGP("datafab_handle_mode_sense: Current values\n"); 425 break; 426 case 0x1: 427 US_DEBUGP("datafab_handle_mode_sense: Changeable values\n"); 428 break; 429 case 0x2: 430 US_DEBUGP("datafab_handle_mode_sense: Default values\n"); 431 break; 432 case 0x3: 433 US_DEBUGP("datafab_handle_mode_sense: Saves values\n"); 434 break; 435 } 436 437 memset(ptr, 0, 8); 438 if (sense_6) { 439 ptr[2] = 0x00; // WP enable: 0x80 440 i = 4; 441 } else { 442 ptr[3] = 0x00; // WP enable: 0x80 443 i = 8; 444 } 445 446 switch (page_code) { 447 default: 448 // vendor-specific mode 449 info->sense_key = 0x05; 450 info->sense_asc = 0x24; 451 info->sense_ascq = 0x00; 452 return USB_STOR_TRANSPORT_FAILED; 453 454 case 0x1: 455 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); 456 i += sizeof(rw_err_page); 457 break; 458 459 case 0x8: 460 memcpy(ptr + i, cache_page, sizeof(cache_page)); 461 i += sizeof(cache_page); 462 break; 463 464 case 0x1B: 465 memcpy(ptr + i, rbac_page, sizeof(rbac_page)); 466 i += sizeof(rbac_page); 467 break; 468 469 case 0x1C: 470 memcpy(ptr + i, timer_page, sizeof(timer_page)); 471 i += sizeof(timer_page); 472 break; 473 474 case 0x3F: // retrieve all pages 475 memcpy(ptr + i, timer_page, sizeof(timer_page)); 476 i += sizeof(timer_page); 477 memcpy(ptr + i, rbac_page, sizeof(rbac_page)); 478 i += sizeof(rbac_page); 479 memcpy(ptr + i, cache_page, sizeof(cache_page)); 480 i += sizeof(cache_page); 481 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); 482 i += sizeof(rw_err_page); 483 break; 484 } 485 486 if (sense_6) 487 ptr[0] = i - 1; 488 else 489 ((__be16 *) ptr)[0] = cpu_to_be16(i - 2); 490 usb_stor_set_xfer_buf(ptr, i, srb); 491 492 return USB_STOR_TRANSPORT_GOOD; 493 } 494 495 static void datafab_info_destructor(void *extra) 496 { 497 // this routine is a placeholder... 498 // currently, we don't allocate any extra memory so we're okay 499 } 500 501 502 // Transport for the Datafab MDCFE-B 503 // 504 int datafab_transport(struct scsi_cmnd * srb, struct us_data *us) 505 { 506 struct datafab_info *info; 507 int rc; 508 unsigned long block, blocks; 509 unsigned char *ptr = us->iobuf; 510 static unsigned char inquiry_reply[8] = { 511 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00 512 }; 513 514 if (!us->extra) { 515 us->extra = kzalloc(sizeof(struct datafab_info), GFP_NOIO); 516 if (!us->extra) { 517 US_DEBUGP("datafab_transport: Gah! " 518 "Can't allocate storage for Datafab info struct!\n"); 519 return USB_STOR_TRANSPORT_ERROR; 520 } 521 us->extra_destructor = datafab_info_destructor; 522 ((struct datafab_info *)us->extra)->lun = -1; 523 } 524 525 info = (struct datafab_info *) (us->extra); 526 527 if (srb->cmnd[0] == INQUIRY) { 528 US_DEBUGP("datafab_transport: INQUIRY. Returning bogus response"); 529 memcpy(ptr, inquiry_reply, sizeof(inquiry_reply)); 530 fill_inquiry_response(us, ptr, 36); 531 return USB_STOR_TRANSPORT_GOOD; 532 } 533 534 if (srb->cmnd[0] == READ_CAPACITY) { 535 info->ssize = 0x200; // hard coded 512 byte sectors as per ATA spec 536 rc = datafab_id_device(us, info); 537 if (rc != USB_STOR_TRANSPORT_GOOD) 538 return rc; 539 540 US_DEBUGP("datafab_transport: READ_CAPACITY: %ld sectors, %ld bytes per sector\n", 541 info->sectors, info->ssize); 542 543 // build the reply 544 // we need the last sector, not the number of sectors 545 ((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1); 546 ((__be32 *) ptr)[1] = cpu_to_be32(info->ssize); 547 usb_stor_set_xfer_buf(ptr, 8, srb); 548 549 return USB_STOR_TRANSPORT_GOOD; 550 } 551 552 if (srb->cmnd[0] == MODE_SELECT_10) { 553 US_DEBUGP("datafab_transport: Gah! MODE_SELECT_10.\n"); 554 return USB_STOR_TRANSPORT_ERROR; 555 } 556 557 // don't bother implementing READ_6 or WRITE_6. 558 // 559 if (srb->cmnd[0] == READ_10) { 560 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 561 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 562 563 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); 564 565 US_DEBUGP("datafab_transport: READ_10: read block 0x%04lx count %ld\n", block, blocks); 566 return datafab_read_data(us, info, block, blocks); 567 } 568 569 if (srb->cmnd[0] == READ_12) { 570 // we'll probably never see a READ_12 but we'll do it anyway... 571 // 572 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 573 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 574 575 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | 576 ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); 577 578 US_DEBUGP("datafab_transport: READ_12: read block 0x%04lx count %ld\n", block, blocks); 579 return datafab_read_data(us, info, block, blocks); 580 } 581 582 if (srb->cmnd[0] == WRITE_10) { 583 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 584 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 585 586 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); 587 588 US_DEBUGP("datafab_transport: WRITE_10: write block 0x%04lx count %ld\n", block, blocks); 589 return datafab_write_data(us, info, block, blocks); 590 } 591 592 if (srb->cmnd[0] == WRITE_12) { 593 // we'll probably never see a WRITE_12 but we'll do it anyway... 594 // 595 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 596 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 597 598 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | 599 ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); 600 601 US_DEBUGP("datafab_transport: WRITE_12: write block 0x%04lx count %ld\n", block, blocks); 602 return datafab_write_data(us, info, block, blocks); 603 } 604 605 if (srb->cmnd[0] == TEST_UNIT_READY) { 606 US_DEBUGP("datafab_transport: TEST_UNIT_READY.\n"); 607 return datafab_id_device(us, info); 608 } 609 610 if (srb->cmnd[0] == REQUEST_SENSE) { 611 US_DEBUGP("datafab_transport: REQUEST_SENSE. Returning faked response\n"); 612 613 // this response is pretty bogus right now. eventually if necessary 614 // we can set the correct sense data. so far though it hasn't been 615 // necessary 616 // 617 memset(ptr, 0, 18); 618 ptr[0] = 0xF0; 619 ptr[2] = info->sense_key; 620 ptr[7] = 11; 621 ptr[12] = info->sense_asc; 622 ptr[13] = info->sense_ascq; 623 usb_stor_set_xfer_buf(ptr, 18, srb); 624 625 return USB_STOR_TRANSPORT_GOOD; 626 } 627 628 if (srb->cmnd[0] == MODE_SENSE) { 629 US_DEBUGP("datafab_transport: MODE_SENSE_6 detected\n"); 630 return datafab_handle_mode_sense(us, srb, 1); 631 } 632 633 if (srb->cmnd[0] == MODE_SENSE_10) { 634 US_DEBUGP("datafab_transport: MODE_SENSE_10 detected\n"); 635 return datafab_handle_mode_sense(us, srb, 0); 636 } 637 638 if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { 639 // sure. whatever. not like we can stop the user from 640 // popping the media out of the device (no locking doors, etc) 641 // 642 return USB_STOR_TRANSPORT_GOOD; 643 } 644 645 if (srb->cmnd[0] == START_STOP) { 646 /* this is used by sd.c'check_scsidisk_media_change to detect 647 media change */ 648 US_DEBUGP("datafab_transport: START_STOP.\n"); 649 /* the first datafab_id_device after a media change returns 650 an error (determined experimentally) */ 651 rc = datafab_id_device(us, info); 652 if (rc == USB_STOR_TRANSPORT_GOOD) { 653 info->sense_key = NO_SENSE; 654 srb->result = SUCCESS; 655 } else { 656 info->sense_key = UNIT_ATTENTION; 657 srb->result = SAM_STAT_CHECK_CONDITION; 658 } 659 return rc; 660 } 661 662 US_DEBUGP("datafab_transport: Gah! Unknown command: %d (0x%x)\n", 663 srb->cmnd[0], srb->cmnd[0]); 664 info->sense_key = 0x05; 665 info->sense_asc = 0x20; 666 info->sense_ascq = 0x00; 667 return USB_STOR_TRANSPORT_FAILED; 668 } 669