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