drivers/usb/storage/scsiglue.c

   1 /* Driver for USB Mass Storage compliant devices
   2  * SCSI layer glue code
   3  *
   4  * $Id: scsiglue.c,v 1.24 2001/11/11 03:33:58 mdharm Exp $
   5  *
   6  * Current development and maintenance by:
   7  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
   8  *
   9  * Developed with the assistance of:
  10  *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
  11  *   (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
  12  *
  13  * Initial work by:
  14  *   (c) 1999 Michael Gee (michael@linuxspecific.com)
  15  *
  16  * This driver is based on the 'USB Mass Storage Class' document. This
  17  * describes in detail the protocol used to communicate with such
  18  * devices.  Clearly, the designers had SCSI and ATAPI commands in
  19  * mind when they created this document.  The commands are all very
  20  * similar to commands in the SCSI-II and ATAPI specifications.
  21  *
  22  * It is important to note that in a number of cases this class
  23  * exhibits class-specific exemptions from the USB specification.
  24  * Notably the usage of NAK, STALL and ACK differs from the norm, in
  25  * that they are used to communicate wait, failed and OK on commands.
  26  *
  27  * Also, for certain devices, the interrupt endpoint is used to convey
  28  * status of a command.
  29  *
  30  * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
  31  * information about this driver.
  32  *
  33  * This program is free software; you can redistribute it and/or modify it
  34  * under the terms of the GNU General Public License as published by the
  35  * Free Software Foundation; either version 2, or (at your option) any
  36  * later version.
  37  *
  38  * This program is distributed in the hope that it will be useful, but
  39  * WITHOUT ANY WARRANTY; without even the implied warranty of
  40  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  41  * General Public License for more details.
  42  *
  43  * You should have received a copy of the GNU General Public License along
  44  * with this program; if not, write to the Free Software Foundation, Inc.,
  45  * 675 Mass Ave, Cambridge, MA 02139, USA.
  46  */
  47 #include "scsiglue.h"
  48 #include "usb.h"
  49 #include "debug.h"
  50 #include "transport.h"
  51
  52 #include <linux/slab.h>
  53
  54 /*
  55  * kernel thread actions
  56  */
  57
  58 #define US_ACT_COMMAND          1
  59 #define US_ACT_DEVICE_RESET     2
  60 #define US_ACT_BUS_RESET        3
  61 #define US_ACT_HOST_RESET       4
  62 #define US_ACT_EXIT             5
  63
  64 /***********************************************************************
  65  * Host functions
  66  ***********************************************************************/
  67
  68 static const char* host_info(struct Scsi_Host *host)
  69 {
  70         return "SCSI emulation for USB Mass Storage devices";
  71 }
  72
  73 /* detect a virtual adapter (always works) */
  74 static int detect(struct SHT *sht)
  75 {
  76         struct us_data *us;
  77         char local_name[32];
  78         /* Note: this function gets called with io_request_lock spinlock helt! */
  79         /* This is not nice at all, but how else are we to get the
  80          * data here? */
  81         us = (struct us_data *)sht->proc_dir;
  82
  83         /* set up the name of our subdirectory under /proc/scsi/ */
  84         sprintf(local_name, "usb-storage-%d", us->host_number);
  85         sht->proc_name = kmalloc (strlen(local_name) + 1, GFP_ATOMIC);
  86         if (!sht->proc_name)
  87                 return 0;
  88         strcpy(sht->proc_name, local_name);
  89
  90         /* we start with no /proc directory entry */
  91         sht->proc_dir = NULL;
  92
  93         /* register the host */
  94         us->host = scsi_register(sht, sizeof(us));
  95         if (us->host) {
  96                 us->host->hostdata[0] = (unsigned long)us;
  97                 us->host_no = us->host->host_no;
  98                 return 1;
  99         }
 100
 101         /* odd... didn't register properly.  Abort and free pointers */
 102         kfree(sht->proc_name);
 103         sht->proc_name = NULL;
 104         return 0;
 105 }
 106
 107 /* Release all resources used by the virtual host
 108  *
 109  * NOTE: There is no contention here, because we're already deregistered
 110  * the driver and we're doing each virtual host in turn, not in parallel
 111  */
 112 static int release(struct Scsi_Host *psh)
 113 {
 114         struct us_data *us = (struct us_data *)psh->hostdata[0];
 115
 116         US_DEBUGP("release() called for host %s\n", us->htmplt.name);
 117
 118         /* Kill the control threads
 119          *
 120          * Enqueue the command, wake up the thread, and wait for
 121          * notification that it's exited.
 122          */
 123         US_DEBUGP("-- sending US_ACT_EXIT command to thread\n");
 124         us->action = US_ACT_EXIT;
 125
 126         up(&(us->sema));
 127         wait_for_completion(&(us->notify));
 128
 129         /* remove the pointer to the data structure we were using */
 130         psh->hostdata[0] = (unsigned long)NULL;
 131
 132         /* we always have a successful release */
 133         return 0;
 134 }
 135
 136 /* run command */
 137 static int command( Scsi_Cmnd *srb )
 138 {
 139         US_DEBUGP("Bad use of us_command\n");
 140
 141         return DID_BAD_TARGET << 16;
 142 }
 143
 144 /* run command */
 145 static int queuecommand( Scsi_Cmnd *srb , void (*done)(Scsi_Cmnd *))
 146 {
 147         struct us_data *us = (struct us_data *)srb->host->hostdata[0];
 148         unsigned long flags;
 149
 150         US_DEBUGP("queuecommand() called\n");
 151         srb->host_scribble = (unsigned char *)us;
 152
 153         /* get exclusive access to the structures we want */
 154         spin_lock_irqsave(&(us->queue_exclusion), flags);
 155
 156         /* enqueue the command */
 157         us->queue_srb = srb;
 158         srb->scsi_done = done;
 159         us->action = US_ACT_COMMAND;
 160
 161         /* release the lock on the structure */
 162         spin_unlock_irqrestore(&(us->queue_exclusion), flags);
 163
 164         /* wake up the process task */
 165         up(&(us->sema));
 166
 167         return 0;
 168 }
 169
 170 /***********************************************************************
 171  * Error handling functions
 172  ***********************************************************************/
 173
 174 /* Command abort */
 175 static int command_abort( Scsi_Cmnd *srb )
 176 {
 177         struct us_data *us = (struct us_data *)srb->host->hostdata[0];
 178
 179         US_DEBUGP("command_abort() called\n");
 180
 181         /* if we're stuck waiting for an IRQ, simulate it */
 182         if (atomic_read(us->ip_wanted)) {
 183                 US_DEBUGP("-- simulating missing IRQ\n");
 184                 up(&(us->ip_waitq));
 185         }
 186
 187         /* if the device has been removed, this worked */
 188         if (!us->pusb_dev) {
 189                 US_DEBUGP("-- device removed already\n");
 190                 return SUCCESS;
 191         }
 192
 193         /* if we have an urb pending, let's wake the control thread up */
 194         if (!us->current_done.done) {
 195                 atomic_inc(&us->abortcnt);
 196                 spin_unlock_irq(&io_request_lock);
 197                 /* cancel the URB -- this will automatically wake the thread */
 198                 usb_unlink_urb(us->current_urb);
 199
 200                 /* wait for us to be done */
 201                 wait_for_completion(&(us->notify));
 202                 spin_lock_irq(&io_request_lock);
 203                 atomic_dec(&us->abortcnt);
 204                 return SUCCESS;
 205         }
 206
 207         US_DEBUGP ("-- nothing to abort\n");
 208         return FAILED;
 209 }
 210
 211 /* This invokes the transport reset mechanism to reset the state of the
 212  * device */
 213 static int device_reset( Scsi_Cmnd *srb )
 214 {
 215         struct us_data *us = (struct us_data *)srb->host->hostdata[0];
 216         int rc;
 217
 218         US_DEBUGP("device_reset() called\n" );
 219
 220         spin_unlock_irq(&io_request_lock);
 221         down(&(us->dev_semaphore));
 222         if (!us->pusb_dev) {
 223                 up(&(us->dev_semaphore));
 224                 spin_lock_irq(&io_request_lock);
 225                 return SUCCESS;
 226         }
 227         rc = us->transport_reset(us);
 228         up(&(us->dev_semaphore));
 229         spin_lock_irq(&io_request_lock);
 230         return rc;
 231 }
 232
 233 /* This resets the device port, and simulates the device
 234  * disconnect/reconnect for all drivers which have claimed other
 235  * interfaces. */
 236 static int bus_reset( Scsi_Cmnd *srb )
 237 {
 238         struct us_data *us = (struct us_data *)srb->host->hostdata[0];
 239         int i;
 240         int result;
 241
 242         /* we use the usb_reset_device() function to handle this for us */
 243         US_DEBUGP("bus_reset() called\n");
 244
 245         spin_unlock_irq(&io_request_lock);
 246
 247         down(&(us->dev_semaphore));
 248
 249         /* if the device has been removed, this worked */
 250         if (!us->pusb_dev) {
 251                 US_DEBUGP("-- device removed already\n");
 252                 up(&(us->dev_semaphore));
 253                 spin_lock_irq(&io_request_lock);
 254                 return SUCCESS;
 255         }
 256
 257         /* The USB subsystem doesn't handle synchronisation between
 258          * a device's several drivers. Therefore we reset only devices
 259          * with just one interface, which we of course own. */
 260         if (us->pusb_dev->actconfig->bNumInterfaces != 1) {
 261                 printk(KERN_NOTICE "usb-storage: "
 262                     "Refusing to reset a multi-interface device\n");
 263                 up(&(us->dev_semaphore));
 264                 spin_lock_irq(&io_request_lock);
 265                 /* XXX Don't just return success, make sure current cmd fails */
 266                 return SUCCESS;
 267         }
 268
 269         /* release the IRQ, if we have one */
 270         if (us->irq_urb) {
 271                 US_DEBUGP("-- releasing irq URB\n");
 272                 result = usb_unlink_urb(us->irq_urb);
 273                 US_DEBUGP("-- usb_unlink_urb() returned %d\n", result);
 274         }
 275
 276         /* attempt to reset the port */
 277         if (usb_reset_device(us->pusb_dev) < 0) {
 278                 /*
 279                  * Do not return errors, or else the error handler might
 280                  * invoke host_reset, which is not implemented.
 281                  */
 282                 goto bail_out;
 283         }
 284
 285         /* FIXME: This needs to lock out driver probing while it's working
 286          * or we can have race conditions */
 287         for (i = 0; i < us->pusb_dev->actconfig->bNumInterfaces; i++) {
 288                 struct usb_interface *intf =
 289                         &us->pusb_dev->actconfig->interface[i];
 290                 const struct usb_device_id *id;
 291
 292                 /* if this is an unclaimed interface, skip it */
 293                 if (!intf->driver) {
 294                         continue;
 295                 }
 296
 297                 US_DEBUGP("Examinging driver %s...", intf->driver->name);
 298                 /* skip interfaces which we've claimed */
 299                 if (intf->driver == &usb_storage_driver) {
 300                         US_DEBUGPX("skipping ourselves.\n");
 301                         continue;
 302                 }
 303
 304                 /* simulate a disconnect and reconnect for all interfaces */
 305                 US_DEBUGPX("simulating disconnect/reconnect.\n");
 306                 down(&intf->driver->serialize);
 307                 intf->driver->disconnect(us->pusb_dev, intf->private_data);
 308                 id = usb_match_id(us->pusb_dev, intf, intf->driver->id_table);
 309                 intf->driver->probe(us->pusb_dev, i, id);
 310                 up(&intf->driver->serialize);
 311         }
 312
 313 bail_out:
 314         /* re-allocate the IRQ URB and submit it to restore connectivity
 315          * for CBI devices
 316          */
 317         if (us->protocol == US_PR_CBI) {
 318                 us->irq_urb->dev = us->pusb_dev;
 319                 result = usb_submit_urb(us->irq_urb);
 320                 US_DEBUGP("usb_submit_urb() returns %d\n", result);
 321         }
 322
 323         up(&(us->dev_semaphore));
 324
 325         spin_lock_irq(&io_request_lock);
 326
 327         US_DEBUGP("bus_reset() complete\n");
 328         return SUCCESS;
 329 }
 330
 331 /* FIXME: This doesn't do anything right now */
 332 static int host_reset( Scsi_Cmnd *srb )
 333 {
 334         printk(KERN_CRIT "usb-storage: host_reset() requested but not implemented\n" );
 335         return FAILED;
 336 }
 337
 338 /***********************************************************************
 339  * /proc/scsi/ functions
 340  ***********************************************************************/
 341
 342 /* we use this macro to help us write into the buffer */
 343 #undef SPRINTF
 344 #define SPRINTF(args...) \
 345         do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
 346
 347 static int proc_info (char *buffer, char **start, off_t offset, int length,
 348                 int hostno, int inout)
 349 {
 350         struct us_data *us;
 351         char *pos = buffer;
 352
 353         /* if someone is sending us data, just throw it away */
 354         if (inout)
 355                 return length;
 356
 357         /* lock the data structures */
 358         down(&us_list_semaphore);
 359
 360         /* find our data from hostno */
 361         us = us_list;
 362         while (us) {
 363                 if (us->host_no == hostno)
 364                         break;
 365                 us = us->next;
 366         }
 367
 368         /* release our lock on the data structures */
 369         up(&us_list_semaphore);
 370
 371         /* if we couldn't find it, we return an error */
 372         if (!us) {
 373                 return -ESRCH;
 374         }
 375
 376         /* print the controller name */
 377         SPRINTF("   Host scsi%d: usb-storage\n", hostno);
 378
 379         /* print product, vendor, and serial number strings */
 380         SPRINTF("       Vendor: %s\n", us->vendor);
 381         SPRINTF("      Product: %s\n", us->product);
 382         SPRINTF("Serial Number: %s\n", us->serial);
 383
 384         /* show the protocol and transport */
 385         SPRINTF("     Protocol: %s\n", us->protocol_name);
 386         SPRINTF("    Transport: %s\n", us->transport_name);
 387
 388         /* show the GUID of the device */
 389         SPRINTF("         GUID: " GUID_FORMAT "\n", GUID_ARGS(us->guid));
 390         SPRINTF("     Attached: %s\n", us->pusb_dev ? "Yes" : "No");
 391
 392         /*
 393          * Calculate start of next buffer, and return value.
 394          */
 395         *start = buffer + offset;
 396
 397         if ((pos - buffer) < offset)
 398                 return (0);
 399         else if ((pos - buffer - offset) < length)
 400                 return (pos - buffer - offset);
 401         else
 402                 return (length);
 403 }
 404
 405 /*
 406  * this defines our 'host'
 407  */
 408
 409 Scsi_Host_Template usb_stor_host_template = {
 410         name:                   "usb-storage",
 411         proc_info:              proc_info,
 412         info:                   host_info,
 413
 414         detect:                 detect,
 415         release:                release,
 416         command:                command,
 417         queuecommand:           queuecommand,
 418
 419         eh_abort_handler:       command_abort,
 420         eh_device_reset_handler:device_reset,
 421         eh_bus_reset_handler:   bus_reset,
 422         eh_host_reset_handler:  host_reset,
 423
 424         can_queue:              1,
 425         this_id:                -1,
 426
 427         sg_tablesize:           SG_ALL,
 428         cmd_per_lun:            1,
 429         present:                0,
 430         unchecked_isa_dma:      FALSE,
 431         use_clustering:         TRUE,
 432         use_new_eh_code:        TRUE,
 433         emulated:               TRUE
 434 };
 435
 436 unsigned char usb_stor_sense_notready[18] = {
 437         [0]     = 0x70,                     /* current error */
 438         [2]     = 0x02,                     /* not ready */
 439         [5]     = 0x0a,                     /* additional length */
 440         [10]    = 0x04,                     /* not ready */
 441         [11]    = 0x03                      /* manual intervention */
 442 };
 443
 444 #define USB_STOR_SCSI_SENSE_HDRSZ 4
 445 #define USB_STOR_SCSI_SENSE_10_HDRSZ 8
 446
 447 struct usb_stor_scsi_sense_hdr
 448 {
 449   __u8* dataLength;
 450   __u8* mediumType;
 451   __u8* devSpecParms;
 452   __u8* blkDescLength;
 453 };
 454
 455 typedef struct usb_stor_scsi_sense_hdr Usb_Stor_Scsi_Sense_Hdr;
 456
 457 union usb_stor_scsi_sense_hdr_u
 458 {
 459   Usb_Stor_Scsi_Sense_Hdr hdr;
 460   __u8* array[USB_STOR_SCSI_SENSE_HDRSZ];
 461 };
 462
 463 typedef union usb_stor_scsi_sense_hdr_u Usb_Stor_Scsi_Sense_Hdr_u;
 464
 465 struct usb_stor_scsi_sense_hdr_10
 466 {
 467   __u8* dataLengthMSB;
 468   __u8* dataLengthLSB;
 469   __u8* mediumType;
 470   __u8* devSpecParms;
 471   __u8* reserved1;
 472   __u8* reserved2;
 473   __u8* blkDescLengthMSB;
 474   __u8* blkDescLengthLSB;
 475 };
 476
 477 typedef struct usb_stor_scsi_sense_hdr_10 Usb_Stor_Scsi_Sense_Hdr_10;
 478
 479 union usb_stor_scsi_sense_hdr_10_u
 480 {
 481   Usb_Stor_Scsi_Sense_Hdr_10 hdr;
 482   __u8* array[USB_STOR_SCSI_SENSE_10_HDRSZ];
 483 };
 484
 485 typedef union usb_stor_scsi_sense_hdr_10_u Usb_Stor_Scsi_Sense_Hdr_10_u;
 486
 487 void usb_stor_scsiSenseParseBuffer( Scsi_Cmnd* , Usb_Stor_Scsi_Sense_Hdr_u*,
 488                                     Usb_Stor_Scsi_Sense_Hdr_10_u*, int* );
 489
 490 int usb_stor_scsiSense10to6( Scsi_Cmnd* the10 )
 491 {
 492   __u8 *buffer=0;
 493   int outputBufferSize = 0;
 494   int length=0;
 495   struct scatterlist *sg = 0;
 496   int i=0, j=0, element=0;
 497   Usb_Stor_Scsi_Sense_Hdr_u the6Locations;
 498   Usb_Stor_Scsi_Sense_Hdr_10_u the10Locations;
 499   int sb=0,si=0,db=0,di=0;
 500   int sgLength=0;
 501
 502   US_DEBUGP("-- converting 10 byte sense data to 6 byte\n");
 503   the10->cmnd[0] = the10->cmnd[0] & 0xBF;
 504
 505   /* Determine buffer locations */
 506   usb_stor_scsiSenseParseBuffer( the10, &the6Locations, &the10Locations,
 507                                  &length );
 508
 509   /* Work out minimum buffer to output */
 510   outputBufferSize = *the10Locations.hdr.dataLengthLSB;
 511   outputBufferSize += USB_STOR_SCSI_SENSE_HDRSZ;
 512
 513   /* Check to see if we need to trucate the output */
 514   if ( outputBufferSize > length )
 515     {
 516       printk( KERN_WARNING USB_STORAGE
 517               "Had to truncate MODE_SENSE_10 buffer into MODE_SENSE.\n" );
 518       printk( KERN_WARNING USB_STORAGE
 519               "outputBufferSize is %d and length is %d.\n",
 520               outputBufferSize, length );
 521     }
 522   outputBufferSize = length;
 523
 524   /* Data length */
 525   if ( *the10Locations.hdr.dataLengthMSB != 0 ) /* MSB must be zero */
 526     {
 527       printk( KERN_WARNING USB_STORAGE
 528               "Command will be truncated to fit in SENSE6 buffer.\n" );
 529       *the6Locations.hdr.dataLength = 0xff;
 530     }
 531   else
 532     {
 533       *the6Locations.hdr.dataLength = *the10Locations.hdr.dataLengthLSB;
 534     }
 535
 536   /* Medium type and DevSpecific parms */
 537   *the6Locations.hdr.mediumType = *the10Locations.hdr.mediumType;
 538   *the6Locations.hdr.devSpecParms = *the10Locations.hdr.devSpecParms;
 539
 540   /* Block descriptor length */
 541   if ( *the10Locations.hdr.blkDescLengthMSB != 0 ) /* MSB must be zero */
 542     {
 543       printk( KERN_WARNING USB_STORAGE
 544               "Command will be truncated to fit in SENSE6 buffer.\n" );
 545       *the6Locations.hdr.blkDescLength = 0xff;
 546     }
 547   else
 548     {
 549       *the6Locations.hdr.blkDescLength = *the10Locations.hdr.blkDescLengthLSB;
 550     }
 551
 552   if ( the10->use_sg == 0 )
 553     {
 554       buffer = the10->request_buffer;
 555       /* Copy the rest of the data */
 556       memmove( &(buffer[USB_STOR_SCSI_SENSE_HDRSZ]),
 557                &(buffer[USB_STOR_SCSI_SENSE_10_HDRSZ]),
 558                outputBufferSize - USB_STOR_SCSI_SENSE_HDRSZ );
 559       /* initialise last bytes left in buffer due to smaller header */
 560       memset( &(buffer[outputBufferSize
 561             -(USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ)]),
 562               0,
 563               USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ );
 564     }
 565   else
 566     {
 567       sg = (struct scatterlist *) the10->request_buffer;
 568       /* scan through this scatterlist and figure out starting positions */
 569       for ( i=0; i < the10->use_sg; i++)
 570         {
 571           sgLength = sg[i].length;
 572           for ( j=0; j<sgLength; j++ )
 573             {
 574               /* get to end of header */
 575               if ( element == USB_STOR_SCSI_SENSE_HDRSZ )
 576                 {
 577                   db=i;
 578                   di=j;
 579                 }
 580               if ( element == USB_STOR_SCSI_SENSE_10_HDRSZ )
 581                 {
 582                   sb=i;
 583                   si=j;
 584                   /* we've found both sets now, exit loops */
 585                   j=sgLength;
 586                   i=the10->use_sg;
 587                 }
 588               element++;
 589             }
 590         }
 591
 592       /* Now we know where to start the copy from */
 593       element = USB_STOR_SCSI_SENSE_HDRSZ;
 594       while ( element < outputBufferSize
 595               -(USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ) )
 596         {
 597           /* check limits */
 598           if ( sb >= the10->use_sg ||
 599                si >= sg[sb].length ||
 600                db >= the10->use_sg ||
 601                di >= sg[db].length )
 602             {
 603               printk( KERN_ERR USB_STORAGE
 604                       "Buffer overrun averted, this shouldn't happen!\n" );
 605               break;
 606             }
 607
 608           /* copy one byte */
 609           sg[db].address[di] = sg[sb].address[si];
 610
 611           /* get next destination */
 612           if ( sg[db].length-1 == di )
 613             {
 614               db++;
 615               di=0;
 616             }
 617           else
 618             {
 619               di++;
 620             }
 621
 622           /* get next source */
 623           if ( sg[sb].length-1 == si )
 624             {
 625               sb++;
 626               si=0;
 627             }
 628           else
 629             {
 630               si++;
 631             }
 632
 633           element++;
 634         }
 635       /* zero the remaining bytes */
 636       while ( element < outputBufferSize )
 637         {
 638           /* check limits */
 639           if ( db >= the10->use_sg ||
 640                di >= sg[db].length )
 641             {
 642               printk( KERN_ERR USB_STORAGE
 643                       "Buffer overrun averted, this shouldn't happen!\n" );
 644               break;
 645             }
 646
 647           sg[db].address[di] = 0;
 648
 649           /* get next destination */
 650           if ( sg[db].length-1 == di )
 651             {
 652               db++;
 653               di=0;
 654             }
 655           else
 656             {
 657               di++;
 658             }
 659           element++;
 660         }
 661     }
 662
 663   /* All done any everything was fine */
 664   return 0;
 665 }
 666
 667 int usb_stor_scsiSense6to10( Scsi_Cmnd* the6 )
 668 {
 669   /* will be used to store part of buffer */
 670   __u8 tempBuffer[USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ],
 671     *buffer=0;
 672   int outputBufferSize = 0;
 673   int length=0;
 674   struct scatterlist *sg = 0;
 675   int i=0, j=0, element=0;
 676   Usb_Stor_Scsi_Sense_Hdr_u the6Locations;
 677   Usb_Stor_Scsi_Sense_Hdr_10_u the10Locations;
 678   int sb=0,si=0,db=0,di=0;
 679   int lsb=0,lsi=0,ldb=0,ldi=0;
 680
 681   US_DEBUGP("-- converting 6 byte sense data to 10 byte\n");
 682   the6->cmnd[0] = the6->cmnd[0] | 0x40;
 683
 684   /* Determine buffer locations */
 685   usb_stor_scsiSenseParseBuffer( the6, &the6Locations, &the10Locations,
 686                                  &length );
 687
 688   /* Work out minimum buffer to output */
 689   outputBufferSize = *the6Locations.hdr.dataLength;
 690   outputBufferSize += USB_STOR_SCSI_SENSE_10_HDRSZ;
 691
 692   /* Check to see if we need to trucate the output */
 693   if ( outputBufferSize > length )
 694     {
 695       printk( KERN_WARNING USB_STORAGE
 696               "Had to truncate MODE_SENSE into MODE_SENSE_10 buffer.\n" );
 697       printk( KERN_WARNING USB_STORAGE
 698               "outputBufferSize is %d and length is %d.\n",
 699               outputBufferSize, length );
 700     }
 701   outputBufferSize = length;
 702
 703   /* Block descriptor length - save these before overwriting */
 704   tempBuffer[2] = *the10Locations.hdr.blkDescLengthMSB;
 705   tempBuffer[3] = *the10Locations.hdr.blkDescLengthLSB;
 706   *the10Locations.hdr.blkDescLengthLSB = *the6Locations.hdr.blkDescLength;
 707   *the10Locations.hdr.blkDescLengthMSB = 0;
 708
 709   /* reserved - save these before overwriting */
 710   tempBuffer[0] = *the10Locations.hdr.reserved1;
 711   tempBuffer[1] = *the10Locations.hdr.reserved2;
 712   *the10Locations.hdr.reserved1 = *the10Locations.hdr.reserved2 = 0;
 713
 714   /* Medium type and DevSpecific parms */
 715   *the10Locations.hdr.devSpecParms = *the6Locations.hdr.devSpecParms;
 716   *the10Locations.hdr.mediumType = *the6Locations.hdr.mediumType;
 717
 718   /* Data length */
 719   *the10Locations.hdr.dataLengthLSB = *the6Locations.hdr.dataLength;
 720   *the10Locations.hdr.dataLengthMSB = 0;
 721
 722   if ( !the6->use_sg )
 723     {
 724       buffer = the6->request_buffer;
 725       /* Copy the rest of the data */
 726       memmove( &(buffer[USB_STOR_SCSI_SENSE_10_HDRSZ]),
 727               &(buffer[USB_STOR_SCSI_SENSE_HDRSZ]),
 728               outputBufferSize-USB_STOR_SCSI_SENSE_10_HDRSZ );
 729       /* Put the first four bytes (after header) in place */
 730       memcpy( &(buffer[USB_STOR_SCSI_SENSE_10_HDRSZ]),
 731               tempBuffer,
 732               USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ );
 733     }
 734   else
 735     {
 736       sg = (struct scatterlist *) the6->request_buffer;
 737       /* scan through this scatterlist and figure out ending positions */
 738       for ( i=0; i < the6->use_sg; i++)
 739         {
 740           for ( j=0; j<sg[i].length; j++ )
 741             {
 742               /* get to end of header */
 743               if ( element == USB_STOR_SCSI_SENSE_HDRSZ )
 744                 {
 745                   ldb=i;
 746                   ldi=j;
 747                 }
 748               if ( element == USB_STOR_SCSI_SENSE_10_HDRSZ )
 749                 {
 750                   lsb=i;
 751                   lsi=j;
 752                   /* we've found both sets now, exit loops */
 753                   j=sg[i].length;
 754                   i=the6->use_sg;
 755                   break;
 756                 }
 757               element++;
 758             }
 759         }
 760       /* scan through this scatterlist and figure out starting positions */
 761       element = length-1;
 762       /* destination is the last element */
 763       db=the6->use_sg-1;
 764       di=sg[db].length-1;
 765       for ( i=the6->use_sg-1; i >= 0; i--)
 766         {
 767           for ( j=sg[i].length-1; j>=0; j-- )
 768             {
 769               /* get to end of header and find source for copy */
 770               if ( element == length - 1
 771                    - (USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ) )
 772                 {
 773                   sb=i;
 774                   si=j;
 775                   /* we've found both sets now, exit loops */
 776                   j=-1;
 777                   i=-1;
 778                 }
 779               element--;
 780             }
 781         }
 782       /* Now we know where to start the copy from */
 783       element = length-1
 784         - (USB_STOR_SCSI_SENSE_10_HDRSZ-USB_STOR_SCSI_SENSE_HDRSZ);
 785       while ( element >= USB_STOR_SCSI_SENSE_10_HDRSZ )
 786         {
 787           /* check limits */
 788           if ( ( sb <= lsb && si < lsi ) ||
 789                ( db <= ldb && di < ldi ) )
 790             {
 791               printk( KERN_ERR USB_STORAGE
 792                       "Buffer overrun averted, this shouldn't happen!\n" );
 793               break;
 794             }
 795
 796           /* copy one byte */
 797           sg[db].address[di] = sg[sb].address[si];
 798
 799           /* get next destination */
 800           if ( di == 0 )
 801             {
 802               db--;
 803               di=sg[db].length-1;
 804             }
 805           else
 806             {
 807               di--;
 808             }
 809
 810           /* get next source */
 811           if ( si == 0 )
 812             {
 813               sb--;
 814               si=sg[sb].length-1;
 815             }
 816           else
 817             {
 818               si--;
 819             }
 820
 821           element--;
 822         }
 823       /* copy the remaining four bytes */
 824       while ( element >= USB_STOR_SCSI_SENSE_HDRSZ )
 825         {
 826           /* check limits */
 827           if ( db <= ldb && di < ldi )
 828             {
 829               printk( KERN_ERR USB_STORAGE
 830                       "Buffer overrun averted, this shouldn't happen!\n" );
 831               break;
 832             }
 833
 834           sg[db].address[di] = tempBuffer[element-USB_STOR_SCSI_SENSE_HDRSZ];
 835
 836           /* get next destination */
 837           if ( di == 0 )
 838             {
 839               db--;
 840               di=sg[db].length-1;
 841             }
 842           else
 843             {
 844               di--;
 845             }
 846           element--;
 847         }
 848     }
 849
 850   /* All done and everything was fine */
 851   return 0;
 852 }
 853
 854 void usb_stor_scsiSenseParseBuffer( Scsi_Cmnd* srb, Usb_Stor_Scsi_Sense_Hdr_u* the6,
 855                                Usb_Stor_Scsi_Sense_Hdr_10_u* the10,
 856                                int* length_p )
 857
 858 {
 859   int i = 0, j=0, element=0;
 860   struct scatterlist *sg = 0;
 861   int length = 0;
 862   __u8* buffer=0;
 863
 864   /* are we scatter-gathering? */
 865   if ( srb->use_sg != 0 )
 866     {
 867       /* loop over all the scatter gather structures and
 868        * get pointer to the data members in the headers
 869        * (also work out the length while we're here)
 870        */
 871       sg = (struct scatterlist *) srb->request_buffer;
 872       for (i = 0; i < srb->use_sg; i++)
 873         {
 874           length += sg[i].length;
 875           /* We only do the inner loop for the headers */
 876           if ( element < USB_STOR_SCSI_SENSE_10_HDRSZ )
 877             {
 878               /* scan through this scatterlist */
 879               for ( j=0; j<sg[i].length; j++ )
 880                 {
 881                   if ( element < USB_STOR_SCSI_SENSE_HDRSZ )
 882                     {
 883                       /* fill in the pointers for both header types */
 884                       the6->array[element] = &(sg[i].address[j]);
 885                       the10->array[element] = &(sg[i].address[j]);
 886                     }
 887                   else if ( element < USB_STOR_SCSI_SENSE_10_HDRSZ )
 888                     {
 889                       /* only the longer headers still cares now */
 890                       the10->array[element] = &(sg[i].address[j]);
 891                     }
 892                   /* increase element counter */
 893                   element++;
 894                 }
 895             }
 896         }
 897     }
 898   else
 899     {
 900       length = srb->request_bufflen;
 901       buffer = srb->request_buffer;
 902       if ( length < USB_STOR_SCSI_SENSE_10_HDRSZ )
 903         printk( KERN_ERR USB_STORAGE
 904                 "Buffer length smaller than header!!" );
 905       for( i=0; i<USB_STOR_SCSI_SENSE_10_HDRSZ; i++ )
 906         {
 907           if ( i < USB_STOR_SCSI_SENSE_HDRSZ )
 908             {
 909               the6->array[i] = &(buffer[i]);
 910               the10->array[i] = &(buffer[i]);
 911             }
 912           else
 913             {
 914               the10->array[i] = &(buffer[i]);
 915             }
 916         }
 917     }
 918
 919   /* Set value of length passed in */
 920   *length_p = length;
 921 }
 922