drivers/usb/storage/datafab.c

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