drivers/usb/storage/jumpshot.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Driver for Lexar "Jumpshot" Compact Flash reader
   4  *
   5  * jumpshot driver v0.1:
   6  *
   7  * First release
   8  *
   9  * Current development and maintenance by:
  10  *   (c) 2000 Jimmie Mayfield (mayfield+usb@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  * Developed with the assistance of:
  21  *
  22  *   (C) 2002 Alan Stern <stern@rowland.org>
  23  */
  24
  25  /*
  26   * This driver attempts to support the Lexar Jumpshot USB CompactFlash
  27   * reader.  Like many other USB CompactFlash readers, the Jumpshot contains
  28   * a USB-to-ATA chip.
  29   *
  30   * This driver supports reading and writing.  If you're truly paranoid,
  31   * however, you can force the driver into a write-protected state by setting
  32   * the WP enable bits in jumpshot_handle_mode_sense.  See the comments
  33   * in that routine.
  34   */
  35
  36 #include <linux/errno.h>
  37 #include <linux/module.h>
  38 #include <linux/slab.h>
  39
  40 #include <scsi/scsi.h>
  41 #include <scsi/scsi_cmnd.h>
  42
  43 #include "usb.h"
  44 #include "transport.h"
  45 #include "protocol.h"
  46 #include "debug.h"
  47 #include "scsiglue.h"
  48
  49 #define DRV_NAME "ums-jumpshot"
  50
  51 MODULE_DESCRIPTION("Driver for Lexar \"Jumpshot\" Compact Flash reader");
  52 MODULE_AUTHOR("Jimmie Mayfield <mayfield+usb@sackheads.org>");
  53 MODULE_LICENSE("GPL");
  54 MODULE_IMPORT_NS(USB_STORAGE);
  55
  56 /*
  57  * The table of devices
  58  */
  59 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
  60                     vendorName, productName, useProtocol, useTransport, \
  61                     initFunction, flags) \
  62 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
  63   .driver_info = (flags) }
  64
  65 static struct usb_device_id jumpshot_usb_ids[] = {
  66 #       include "unusual_jumpshot.h"
  67         { }             /* Terminating entry */
  68 };
  69 MODULE_DEVICE_TABLE(usb, jumpshot_usb_ids);
  70
  71 #undef UNUSUAL_DEV
  72
  73 /*
  74  * The flags table
  75  */
  76 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
  77                     vendor_name, product_name, use_protocol, use_transport, \
  78                     init_function, Flags) \
  79 { \
  80         .vendorName = vendor_name,      \
  81         .productName = product_name,    \
  82         .useProtocol = use_protocol,    \
  83         .useTransport = use_transport,  \
  84         .initFunction = init_function,  \
  85 }
  86
  87 static struct us_unusual_dev jumpshot_unusual_dev_list[] = {
  88 #       include "unusual_jumpshot.h"
  89         { }             /* Terminating entry */
  90 };
  91
  92 #undef UNUSUAL_DEV
  93
  94
  95 struct jumpshot_info {
  96    unsigned long   sectors;     /* total sector count */
  97    unsigned long   ssize;       /* sector size in bytes */
  98
  99    /* the following aren't used yet */
 100    unsigned char   sense_key;
 101    unsigned long   sense_asc;   /* additional sense code */
 102    unsigned long   sense_ascq;  /* additional sense code qualifier */
 103 };
 104
 105 static inline int jumpshot_bulk_read(struct us_data *us,
 106                                      unsigned char *data,
 107                                      unsigned int len)
 108 {
 109         if (len == 0)
 110                 return USB_STOR_XFER_GOOD;
 111
 112         usb_stor_dbg(us, "len = %d\n", len);
 113         return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 114                         data, len, NULL);
 115 }
 116
 117
 118 static inline int jumpshot_bulk_write(struct us_data *us,
 119                                       unsigned char *data,
 120                                       unsigned int len)
 121 {
 122         if (len == 0)
 123                 return USB_STOR_XFER_GOOD;
 124
 125         usb_stor_dbg(us, "len = %d\n", len);
 126         return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 127                         data, len, NULL);
 128 }
 129
 130
 131 static int jumpshot_get_status(struct us_data  *us)
 132 {
 133         int rc;
 134
 135         if (!us)
 136                 return USB_STOR_TRANSPORT_ERROR;
 137
 138         // send the setup
 139         rc = usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe,
 140                                    0, 0xA0, 0, 7, us->iobuf, 1);
 141
 142         if (rc != USB_STOR_XFER_GOOD)
 143                 return USB_STOR_TRANSPORT_ERROR;
 144
 145         if (us->iobuf[0] != 0x50) {
 146                 usb_stor_dbg(us, "0x%2x\n", us->iobuf[0]);
 147                 return USB_STOR_TRANSPORT_ERROR;
 148         }
 149
 150         return USB_STOR_TRANSPORT_GOOD;
 151 }
 152
 153 static int jumpshot_read_data(struct us_data *us,
 154                               struct jumpshot_info *info,
 155                               u32 sector,
 156                               u32 sectors)
 157 {
 158         unsigned char *command = us->iobuf;
 159         unsigned char *buffer;
 160         unsigned char  thistime;
 161         unsigned int totallen, alloclen;
 162         int len, result;
 163         unsigned int sg_offset = 0;
 164         struct scatterlist *sg = NULL;
 165
 166         // we're working in LBA mode.  according to the ATA spec,
 167         // we can support up to 28-bit addressing.  I don't know if Jumpshot
 168         // supports beyond 24-bit addressing.  It's kind of hard to test
 169         // since it requires > 8GB CF card.
 170
 171         if (sector > 0x0FFFFFFF)
 172                 return USB_STOR_TRANSPORT_ERROR;
 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                 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 | ((sector >> 24) & 0x0F);
 198                 command[6] = 0x20;
 199
 200                 // send the setup + command
 201                 result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
 202                                                0, 0x20, 0, 1, command, 7);
 203                 if (result != USB_STOR_XFER_GOOD)
 204                         goto leave;
 205
 206                 // read the result
 207                 result = jumpshot_bulk_read(us, buffer, len);
 208                 if (result != USB_STOR_XFER_GOOD)
 209                         goto leave;
 210
 211                 usb_stor_dbg(us, "%d bytes\n", len);
 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 jumpshot_write_data(struct us_data *us,
 231                                struct jumpshot_info *info,
 232                                u32 sector,
 233                                u32 sectors)
 234 {
 235         unsigned char *command = us->iobuf;
 236         unsigned char *buffer;
 237         unsigned char  thistime;
 238         unsigned int totallen, alloclen;
 239         int len, result, waitcount;
 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 Jumpshot
 245         // supports beyond 24-bit addressing.  It's kind of hard to test
 246         // since it requires > 8GB CF card.
 247         //
 248         if (sector > 0x0FFFFFFF)
 249                 return USB_STOR_TRANSPORT_ERROR;
 250
 251         totallen = sectors * info->ssize;
 252
 253         // Since we don't write more than 64 KB at a time, we have to create
 254         // a bounce buffer and move the data a piece at a time between the
 255         // bounce buffer and the actual transfer buffer.
 256
 257         alloclen = min(totallen, 65536u);
 258         buffer = kmalloc(alloclen, GFP_NOIO);
 259         if (buffer == NULL)
 260                 return USB_STOR_TRANSPORT_ERROR;
 261
 262         do {
 263                 // loop, never allocate or transfer more than 64k at once
 264                 // (min(128k, 255*info->ssize) is the real limit)
 265
 266                 len = min(totallen, alloclen);
 267                 thistime = (len / info->ssize) & 0xff;
 268
 269                 // Get the data from the transfer buffer
 270                 usb_stor_access_xfer_buf(buffer, len, us->srb,
 271                                 &sg, &sg_offset, FROM_XFER_BUF);
 272
 273                 command[0] = 0;
 274                 command[1] = thistime;
 275                 command[2] = sector & 0xFF;
 276                 command[3] = (sector >>  8) & 0xFF;
 277                 command[4] = (sector >> 16) & 0xFF;
 278
 279                 command[5] = 0xE0 | ((sector >> 24) & 0x0F);
 280                 command[6] = 0x30;
 281
 282                 // send the setup + command
 283                 result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
 284                         0, 0x20, 0, 1, command, 7);
 285                 if (result != USB_STOR_XFER_GOOD)
 286                         goto leave;
 287
 288                 // send the data
 289                 result = jumpshot_bulk_write(us, buffer, len);
 290                 if (result != USB_STOR_XFER_GOOD)
 291                         goto leave;
 292
 293                 // read the result.  apparently the bulk write can complete
 294                 // before the jumpshot drive is finished writing.  so we loop
 295                 // here until we get a good return code
 296                 waitcount = 0;
 297                 do {
 298                         result = jumpshot_get_status(us);
 299                         if (result != USB_STOR_TRANSPORT_GOOD) {
 300                                 // I have not experimented to find the smallest value.
 301                                 //
 302                                 msleep(50);
 303                         }
 304                 } while ((result != USB_STOR_TRANSPORT_GOOD) && (waitcount < 10));
 305
 306                 if (result != USB_STOR_TRANSPORT_GOOD)
 307                         usb_stor_dbg(us, "Gah!  Waitcount = 10.  Bad write!?\n");
 308
 309                 sector += thistime;
 310                 totallen -= len;
 311         } while (totallen > 0);
 312
 313         kfree(buffer);
 314         return result;
 315
 316  leave:
 317         kfree(buffer);
 318         return USB_STOR_TRANSPORT_ERROR;
 319 }
 320
 321 static int jumpshot_id_device(struct us_data *us,
 322                               struct jumpshot_info *info)
 323 {
 324         unsigned char *command = us->iobuf;
 325         unsigned char *reply;
 326         int      rc;
 327
 328         if (!info)
 329                 return USB_STOR_TRANSPORT_ERROR;
 330
 331         command[0] = 0xE0;
 332         command[1] = 0xEC;
 333         reply = kmalloc(512, GFP_NOIO);
 334         if (!reply)
 335                 return USB_STOR_TRANSPORT_ERROR;
 336
 337         // send the setup
 338         rc = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
 339                                    0, 0x20, 0, 6, command, 2);
 340
 341         if (rc != USB_STOR_XFER_GOOD) {
 342                 usb_stor_dbg(us, "Gah! send_control for read_capacity failed\n");
 343                 rc = USB_STOR_TRANSPORT_ERROR;
 344                 goto leave;
 345         }
 346
 347         // read the reply
 348         rc = jumpshot_bulk_read(us, reply, 512);
 349         if (rc != USB_STOR_XFER_GOOD) {
 350                 rc = USB_STOR_TRANSPORT_ERROR;
 351                 goto leave;
 352         }
 353
 354         info->sectors = ((u32)(reply[117]) << 24) |
 355                         ((u32)(reply[116]) << 16) |
 356                         ((u32)(reply[115]) <<  8) |
 357                         ((u32)(reply[114])      );
 358
 359         rc = USB_STOR_TRANSPORT_GOOD;
 360
 361  leave:
 362         kfree(reply);
 363         return rc;
 364 }
 365
 366 static int jumpshot_handle_mode_sense(struct us_data *us,
 367                                       struct scsi_cmnd * srb,
 368                                       int sense_6)
 369 {
 370         static unsigned char rw_err_page[12] = {
 371                 0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0
 372         };
 373         static unsigned char cache_page[12] = {
 374                 0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0
 375         };
 376         static unsigned char rbac_page[12] = {
 377                 0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0
 378         };
 379         static unsigned char timer_page[8] = {
 380                 0x1C, 0x6, 0, 0, 0, 0
 381         };
 382         unsigned char pc, page_code;
 383         unsigned int i = 0;
 384         struct jumpshot_info *info = (struct jumpshot_info *) (us->extra);
 385         unsigned char *ptr = us->iobuf;
 386
 387         pc = srb->cmnd[2] >> 6;
 388         page_code = srb->cmnd[2] & 0x3F;
 389
 390         switch (pc) {
 391            case 0x0:
 392                    usb_stor_dbg(us, "Current values\n");
 393                    break;
 394            case 0x1:
 395                    usb_stor_dbg(us, "Changeable values\n");
 396                    break;
 397            case 0x2:
 398                    usb_stor_dbg(us, "Default values\n");
 399                    break;
 400            case 0x3:
 401                    usb_stor_dbg(us, "Saves values\n");
 402                    break;
 403         }
 404
 405         memset(ptr, 0, 8);
 406         if (sense_6) {
 407                 ptr[2] = 0x00;          // WP enable: 0x80
 408                 i = 4;
 409         } else {
 410                 ptr[3] = 0x00;          // WP enable: 0x80
 411                 i = 8;
 412         }
 413
 414         switch (page_code) {
 415            case 0x0:
 416                 // vendor-specific mode
 417                 info->sense_key = 0x05;
 418                 info->sense_asc = 0x24;
 419                 info->sense_ascq = 0x00;
 420                 return USB_STOR_TRANSPORT_FAILED;
 421
 422            case 0x1:
 423                 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
 424                 i += sizeof(rw_err_page);
 425                 break;
 426
 427            case 0x8:
 428                 memcpy(ptr + i, cache_page, sizeof(cache_page));
 429                 i += sizeof(cache_page);
 430                 break;
 431
 432            case 0x1B:
 433                 memcpy(ptr + i, rbac_page, sizeof(rbac_page));
 434                 i += sizeof(rbac_page);
 435                 break;
 436
 437            case 0x1C:
 438                 memcpy(ptr + i, timer_page, sizeof(timer_page));
 439                 i += sizeof(timer_page);
 440                 break;
 441
 442            case 0x3F:
 443                 memcpy(ptr + i, timer_page, sizeof(timer_page));
 444                 i += sizeof(timer_page);
 445                 memcpy(ptr + i, rbac_page, sizeof(rbac_page));
 446                 i += sizeof(rbac_page);
 447                 memcpy(ptr + i, cache_page, sizeof(cache_page));
 448                 i += sizeof(cache_page);
 449                 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
 450                 i += sizeof(rw_err_page);
 451                 break;
 452         }
 453
 454         if (sense_6)
 455                 ptr[0] = i - 1;
 456         else
 457                 ((__be16 *) ptr)[0] = cpu_to_be16(i - 2);
 458         usb_stor_set_xfer_buf(ptr, i, srb);
 459
 460         return USB_STOR_TRANSPORT_GOOD;
 461 }
 462
 463
 464 static void jumpshot_info_destructor(void *extra)
 465 {
 466         // this routine is a placeholder...
 467         // currently, we don't allocate any extra blocks so we're okay
 468 }
 469
 470
 471
 472 // Transport for the Lexar 'Jumpshot'
 473 //
 474 static int jumpshot_transport(struct scsi_cmnd *srb, struct us_data *us)
 475 {
 476         struct jumpshot_info *info;
 477         int rc;
 478         unsigned long block, blocks;
 479         unsigned char *ptr = us->iobuf;
 480         static unsigned char inquiry_response[8] = {
 481                 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
 482         };
 483
 484         if (!us->extra) {
 485                 us->extra = kzalloc(sizeof(struct jumpshot_info), GFP_NOIO);
 486                 if (!us->extra)
 487                         return USB_STOR_TRANSPORT_ERROR;
 488
 489                 us->extra_destructor = jumpshot_info_destructor;
 490         }
 491
 492         info = (struct jumpshot_info *) (us->extra);
 493
 494         if (srb->cmnd[0] == INQUIRY) {
 495                 usb_stor_dbg(us, "INQUIRY - Returning bogus response\n");
 496                 memcpy(ptr, inquiry_response, sizeof(inquiry_response));
 497                 fill_inquiry_response(us, ptr, 36);
 498                 return USB_STOR_TRANSPORT_GOOD;
 499         }
 500
 501         if (srb->cmnd[0] == READ_CAPACITY) {
 502                 info->ssize = 0x200;  // hard coded 512 byte sectors as per ATA spec
 503
 504                 rc = jumpshot_get_status(us);
 505                 if (rc != USB_STOR_TRANSPORT_GOOD)
 506                         return rc;
 507
 508                 rc = jumpshot_id_device(us, info);
 509                 if (rc != USB_STOR_TRANSPORT_GOOD)
 510                         return rc;
 511
 512                 usb_stor_dbg(us, "READ_CAPACITY:  %ld sectors, %ld bytes per sector\n",
 513                              info->sectors, info->ssize);
 514
 515                 // build the reply
 516                 //
 517                 ((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1);
 518                 ((__be32 *) ptr)[1] = cpu_to_be32(info->ssize);
 519                 usb_stor_set_xfer_buf(ptr, 8, srb);
 520
 521                 return USB_STOR_TRANSPORT_GOOD;
 522         }
 523
 524         if (srb->cmnd[0] == MODE_SELECT_10) {
 525                 usb_stor_dbg(us, "Gah! MODE_SELECT_10\n");
 526                 return USB_STOR_TRANSPORT_ERROR;
 527         }
 528
 529         if (srb->cmnd[0] == READ_10) {
 530                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
 531                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
 532
 533                 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
 534
 535                 usb_stor_dbg(us, "READ_10: read block 0x%04lx  count %ld\n",
 536                              block, blocks);
 537                 return jumpshot_read_data(us, info, block, blocks);
 538         }
 539
 540         if (srb->cmnd[0] == READ_12) {
 541                 // I don't think we'll ever see a READ_12 but support it anyway...
 542                 //
 543                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
 544                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
 545
 546                 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
 547                          ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
 548
 549                 usb_stor_dbg(us, "READ_12: read block 0x%04lx  count %ld\n",
 550                              block, blocks);
 551                 return jumpshot_read_data(us, info, block, blocks);
 552         }
 553
 554         if (srb->cmnd[0] == WRITE_10) {
 555                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
 556                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
 557
 558                 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
 559
 560                 usb_stor_dbg(us, "WRITE_10: write block 0x%04lx  count %ld\n",
 561                              block, blocks);
 562                 return jumpshot_write_data(us, info, block, blocks);
 563         }
 564
 565         if (srb->cmnd[0] == WRITE_12) {
 566                 // I don't think we'll ever see a WRITE_12 but support it anyway...
 567                 //
 568                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
 569                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
 570
 571                 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
 572                          ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
 573
 574                 usb_stor_dbg(us, "WRITE_12: write block 0x%04lx  count %ld\n",
 575                              block, blocks);
 576                 return jumpshot_write_data(us, info, block, blocks);
 577         }
 578
 579
 580         if (srb->cmnd[0] == TEST_UNIT_READY) {
 581                 usb_stor_dbg(us, "TEST_UNIT_READY\n");
 582                 return jumpshot_get_status(us);
 583         }
 584
 585         if (srb->cmnd[0] == REQUEST_SENSE) {
 586                 usb_stor_dbg(us, "REQUEST_SENSE\n");
 587
 588                 memset(ptr, 0, 18);
 589                 ptr[0] = 0xF0;
 590                 ptr[2] = info->sense_key;
 591                 ptr[7] = 11;
 592                 ptr[12] = info->sense_asc;
 593                 ptr[13] = info->sense_ascq;
 594                 usb_stor_set_xfer_buf(ptr, 18, srb);
 595
 596                 return USB_STOR_TRANSPORT_GOOD;
 597         }
 598
 599         if (srb->cmnd[0] == MODE_SENSE) {
 600                 usb_stor_dbg(us, "MODE_SENSE_6 detected\n");
 601                 return jumpshot_handle_mode_sense(us, srb, 1);
 602         }
 603
 604         if (srb->cmnd[0] == MODE_SENSE_10) {
 605                 usb_stor_dbg(us, "MODE_SENSE_10 detected\n");
 606                 return jumpshot_handle_mode_sense(us, srb, 0);
 607         }
 608
 609         if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
 610                 /*
 611                  * sure.  whatever.  not like we can stop the user from popping
 612                  * the media out of the device (no locking doors, etc)
 613                  */
 614                 return USB_STOR_TRANSPORT_GOOD;
 615         }
 616
 617         if (srb->cmnd[0] == START_STOP) {
 618                 /*
 619                  * this is used by sd.c'check_scsidisk_media_change to detect
 620                  * media change
 621                  */
 622                 usb_stor_dbg(us, "START_STOP\n");
 623                 /*
 624                  * the first jumpshot_id_device after a media change returns
 625                  * an error (determined experimentally)
 626                  */
 627                 rc = jumpshot_id_device(us, info);
 628                 if (rc == USB_STOR_TRANSPORT_GOOD) {
 629                         info->sense_key = NO_SENSE;
 630                         srb->result = SUCCESS;
 631                 } else {
 632                         info->sense_key = UNIT_ATTENTION;
 633                         srb->result = SAM_STAT_CHECK_CONDITION;
 634                 }
 635                 return rc;
 636         }
 637
 638         usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n",
 639                      srb->cmnd[0], srb->cmnd[0]);
 640         info->sense_key = 0x05;
 641         info->sense_asc = 0x20;
 642         info->sense_ascq = 0x00;
 643         return USB_STOR_TRANSPORT_FAILED;
 644 }
 645
 646 static struct scsi_host_template jumpshot_host_template;
 647
 648 static int jumpshot_probe(struct usb_interface *intf,
 649                          const struct usb_device_id *id)
 650 {
 651         struct us_data *us;
 652         int result;
 653
 654         result = usb_stor_probe1(&us, intf, id,
 655                         (id - jumpshot_usb_ids) + jumpshot_unusual_dev_list,
 656                         &jumpshot_host_template);
 657         if (result)
 658                 return result;
 659
 660         us->transport_name  = "Lexar Jumpshot Control/Bulk";
 661         us->transport = jumpshot_transport;
 662         us->transport_reset = usb_stor_Bulk_reset;
 663         us->max_lun = 1;
 664
 665         result = usb_stor_probe2(us);
 666         return result;
 667 }
 668
 669 static struct usb_driver jumpshot_driver = {
 670         .name =         DRV_NAME,
 671         .probe =        jumpshot_probe,
 672         .disconnect =   usb_stor_disconnect,
 673         .suspend =      usb_stor_suspend,
 674         .resume =       usb_stor_resume,
 675         .reset_resume = usb_stor_reset_resume,
 676         .pre_reset =    usb_stor_pre_reset,
 677         .post_reset =   usb_stor_post_reset,
 678         .id_table =     jumpshot_usb_ids,
 679         .soft_unbind =  1,
 680         .no_dynamic_id = 1,
 681 };
 682
 683 module_usb_stor_driver(jumpshot_driver, jumpshot_host_template, DRV_NAME);