target/linux/generic-2.4/patches/228-more_usb_fixes.patch

   1 diff -ur linux.old/drivers/scsi/hosts.c linux.dev/drivers/scsi/hosts.c
   2 --- linux.old/drivers/scsi/hosts.c      2003-06-13 16:51:36.000000000 +0200
   3 +++ linux.dev/drivers/scsi/hosts.c      2006-07-30 12:34:30.000000000 +0200
   4 @@ -107,8 +107,21 @@
   5      if (shn) shn->host_registered = 0;
   6      /* else {} : This should not happen, we should panic here... */
   7
   8 +    /* If we are removing the last host registered, it is safe to reuse
   9 +     * its host number (this avoids "holes" at boot time) (DB)
  10 +     * It is also safe to reuse those of numbers directly below which have
  11 +     * been released earlier (to avoid some holes in numbering).
  12 +     */
  13 +    if(sh->host_no == max_scsi_hosts - 1) {
  14 +       while(--max_scsi_hosts >= next_scsi_host) {
  15 +           shpnt = scsi_hostlist;
  16 +           while(shpnt && shpnt->host_no != max_scsi_hosts - 1)
  17 +               shpnt = shpnt->next;
  18 +           if(shpnt)
  19 +               break;
  20 +       }
  21 +    }
  22      next_scsi_host--;
  23 -
  24      kfree((char *) sh);
  25  }
  26
  27 diff -ur linux.old/drivers/usb/hcd.c linux.dev/drivers/usb/hcd.c
  28 --- linux.old/drivers/usb/hcd.c 2004-04-14 15:05:32.000000000 +0200
  29 +++ linux.dev/drivers/usb/hcd.c 2006-07-30 11:49:06.000000000 +0200
  30 @@ -1105,7 +1105,8 @@
  31                 break;
  32         case PIPE_BULK:
  33                 allowed |= USB_DISABLE_SPD | USB_QUEUE_BULK
  34 -                               | USB_ZERO_PACKET | URB_NO_INTERRUPT;
  35 +                               | USB_ZERO_PACKET | URB_NO_INTERRUPT
  36 +                       | URB_NO_TRANSFER_DMA_MAP;
  37                 break;
  38         case PIPE_INTERRUPT:
  39                 allowed |= USB_DISABLE_SPD;
  40 @@ -1212,7 +1213,8 @@
  41                                         urb->setup_packet,
  42                                         sizeof (struct usb_ctrlrequest),
  43                                         PCI_DMA_TODEVICE);
  44 -               if (urb->transfer_buffer_length != 0)
  45 +               if (urb->transfer_buffer_length != 0
  46 +                       && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
  47                         urb->transfer_dma = pci_map_single (
  48                                         hcd->pdev,
  49                                         urb->transfer_buffer,
  50 diff -ur linux.old/drivers/usb/host/ehci-hcd.c linux.dev/drivers/usb/host/ehci-hcd.c
  51 --- linux.old/drivers/usb/host/ehci-hcd.c       2006-07-30 11:31:57.000000000 +0200
  52 +++ linux.dev/drivers/usb/host/ehci-hcd.c       2006-07-30 11:48:14.000000000 +0200
  53 @@ -399,6 +399,27 @@
  54                 ehci_mem_cleanup (ehci);
  55                 return retval;
  56         }
  57 +
  58 +{
  59 +       int misc_reg;
  60 +       u32 vendor_id;
  61 +
  62 +       pci_read_config_dword (ehci->hcd.pdev, PCI_VENDOR_ID, &vendor_id);
  63 +       if (vendor_id == 0x31041106) {
  64 +               /* VIA 6212 */
  65 +               printk(KERN_INFO "EHCI: Enabling VIA 6212 workarounds\n", misc_reg);
  66 +               pci_read_config_byte(ehci->hcd.pdev, 0x49, &misc_reg);
  67 +               misc_reg &= ~0x20;
  68 +               pci_write_config_byte(ehci->hcd.pdev, 0x49, misc_reg);
  69 +               pci_read_config_byte(ehci->hcd.pdev, 0x49, &misc_reg);
  70 +
  71 +               pci_read_config_byte(ehci->hcd.pdev, 0x4b, &misc_reg);
  72 +               misc_reg |= 0x20;
  73 +               pci_write_config_byte(ehci->hcd.pdev, 0x4b, misc_reg);
  74 +               pci_read_config_byte(ehci->hcd.pdev, 0x4b, &misc_reg);
  75 +       }
  76 +}
  77 +
  78         writel (INTR_MASK, &ehci->regs->intr_enable);
  79         writel (ehci->periodic_dma, &ehci->regs->frame_list);
  80
  81 diff -ur linux.old/drivers/usb/host/ehci-q.c linux.dev/drivers/usb/host/ehci-q.c
  82 --- linux.old/drivers/usb/host/ehci-q.c 2006-07-30 11:31:57.000000000 +0200
  83 +++ linux.dev/drivers/usb/host/ehci-q.c 2006-07-30 12:10:15.000000000 +0200
  84 @@ -791,6 +791,8 @@
  85                         writel (cmd, &ehci->regs->command);
  86                         ehci->hcd.state = USB_STATE_RUNNING;
  87                         /* posted write need not be known to HC yet ... */
  88 +
  89 +                       timer_action (ehci, TIMER_IO_WATCHDOG);
  90                 }
  91         }
  92
  93 diff -ur linux.old/drivers/usb/host/usb-uhci.c linux.dev/drivers/usb/host/usb-uhci.c
  94 --- linux.old/drivers/usb/host/usb-uhci.c       2004-11-17 12:54:21.000000000 +0100
  95 +++ linux.dev/drivers/usb/host/usb-uhci.c       2006-07-30 12:10:16.000000000 +0200
  96 @@ -2491,7 +2491,7 @@
  97                         ((urb_priv_t*)urb->hcpriv)->flags=0;
  98                 }
  99
 100 -               if ((urb->status != -ECONNABORTED) && (urb->status != ECONNRESET) &&
 101 +               if ((urb->status != -ECONNABORTED) && (urb->status != -ECONNRESET) &&
 102                             (urb->status != -ENOENT)) {
 103
 104                         urb->status = -EINPROGRESS;
 105 @@ -3034,6 +3034,21 @@
 106
 107         pci_set_master(dev);
 108
 109 +       {
 110 +               u8 misc_reg;
 111 +               u32 vendor_id;
 112 +
 113 +               pci_read_config_dword (dev, PCI_VENDOR_ID, &vendor_id);
 114 +               if (vendor_id == 0x30381106) {
 115 +                       /* VIA 6212 */
 116 +                       printk(KERN_INFO "UHCI: Enabling VIA 6212 workarounds\n");
 117 +                       pci_read_config_byte(dev, 0x41, &misc_reg);
 118 +                       misc_reg &= ~0x10;
 119 +                       pci_write_config_byte(dev, 0x41, misc_reg);
 120 +                       pci_read_config_byte(dev, 0x41, &misc_reg);
 121 +               }
 122 +       }
 123 +
 124         /* Search for the IO base address.. */
 125         for (i = 0; i < 6; i++) {
 126
 127 diff -ur linux.old/drivers/usb/storage/transport.c linux.dev/drivers/usb/storage/transport.c
 128 --- linux.old/drivers/usb/storage/transport.c   2005-04-04 03:42:19.000000000 +0200
 129 +++ linux.dev/drivers/usb/storage/transport.c   2006-07-30 12:22:56.000000000 +0200
 130 @@ -54,6 +54,22 @@
 131  #include <linux/sched.h>
 132  #include <linux/errno.h>
 133  #include <linux/slab.h>
 134 +#include <linux/pci.h>
 135 +#include "../hcd.h"
 136 +
 137 +/* These definitions mirror those in pci.h, so they can be used
 138 + * interchangeably with their PCI_ counterparts */
 139 +enum dma_data_direction {
 140 +       DMA_BIDIRECTIONAL = 0,
 141 +       DMA_TO_DEVICE = 1,
 142 +       DMA_FROM_DEVICE = 2,
 143 +       DMA_NONE = 3,
 144 +};
 145 +
 146 +#define dma_map_sg(d,s,n,dir) pci_map_sg(d,s,n,dir)
 147 +#define dma_unmap_sg(d,s,n,dir) pci_unmap_sg(d,s,n,dir)
 148 +
 149 +
 150
 151  /***********************************************************************
 152   * Helper routines
 153 @@ -554,6 +570,543 @@
 154         return US_BULK_TRANSFER_SHORT;
 155  }
 156
 157 +/*-------------------------------------------------------------------*/
 158 +/**
 159 + * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
 160 + * @dev: device to which the scatterlist will be mapped
 161 + * @pipe: endpoint defining the mapping direction
 162 + * @sg: the scatterlist to unmap
 163 + * @n_hw_ents: the positive return value from usb_buffer_map_sg
 164 + *
 165 + * Reverses the effect of usb_buffer_map_sg().
 166 + */
 167 +static void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe,
 168 +               struct scatterlist *sg, int n_hw_ents)
 169 +{
 170 +       struct usb_bus *bus;
 171 +       struct usb_hcd *hcd;
 172 +       struct pci_dev *pdev;
 173 +
 174 +       if (!dev
 175 +                       || !(bus = dev->bus)
 176 +                       || !(hcd = bus->hcpriv)
 177 +                       || !(pdev = hcd->pdev)
 178 +                       || !pdev->dma_mask)
 179 +               return;
 180 +
 181 +       dma_unmap_sg (pdev, sg, n_hw_ents,
 182 +                       usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 183 +}
 184 +
 185 +/**
 186 + * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
 187 + * @dev: device to which the scatterlist will be mapped
 188 + * @pipe: endpoint defining the mapping direction
 189 + * @sg: the scatterlist to map
 190 + * @nents: the number of entries in the scatterlist
 191 + *
 192 + * Return value is either < 0 (indicating no buffers could be mapped), or
 193 + * the number of DMA mapping array entries in the scatterlist.
 194 + *
 195 + * The caller is responsible for placing the resulting DMA addresses from
 196 + * the scatterlist into URB transfer buffer pointers, and for setting the
 197 + * URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs.
 198 + *
 199 + * Top I/O rates come from queuing URBs, instead of waiting for each one
 200 + * to complete before starting the next I/O.   This is particularly easy
 201 + * to do with scatterlists.  Just allocate and submit one URB for each DMA
 202 + * mapping entry returned, stopping on the first error or when all succeed.
 203 + * Better yet, use the usb_sg_*() calls, which do that (and more) for you.
 204 + *
 205 + * This call would normally be used when translating scatterlist requests,
 206 + * rather than usb_buffer_map(), since on some hardware (with IOMMUs) it
 207 + * may be able to coalesce mappings for improved I/O efficiency.
 208 + *
 209 + * Reverse the effect of this call with usb_buffer_unmap_sg().
 210 + */
 211 +static int usb_buffer_map_sg (struct usb_device *dev, unsigned pipe,
 212 +               struct scatterlist *sg, int nents)
 213 +{
 214 +       struct usb_bus          *bus;
 215 +       struct usb_hcd *hcd;
 216 +       struct pci_dev *pdev;
 217 +
 218 +       if (!dev
 219 +                       || usb_pipecontrol (pipe)
 220 +                       || !(bus = dev->bus)
 221 +                       || !(hcd = bus->hcpriv)
 222 +                       || !(pdev = hcd->pdev)
 223 +                       || !pdev->dma_mask)
 224 +               return -1;
 225 +
 226 +       // FIXME generic api broken like pci, can't report errors
 227 +       return dma_map_sg (pdev, sg, nents,
 228 +                       usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 229 +}
 230 +
 231 +static void sg_clean (struct usb_sg_request *io)
 232 +{
 233 +       struct usb_hcd *hcd = io->dev->bus->hcpriv;
 234 +       struct pci_dev *pdev = hcd->pdev;
 235 +
 236 +       if (io->urbs) {
 237 +               while (io->entries--)
 238 +                       usb_free_urb (io->urbs [io->entries]);
 239 +               kfree (io->urbs);
 240 +               io->urbs = 0;
 241 +       }
 242 +       if (pdev->dma_mask != 0)
 243 +               usb_buffer_unmap_sg (io->dev, io->pipe, io->sg, io->nents);
 244 +       io->dev = 0;
 245 +}
 246 +
 247 +static void sg_complete (struct urb *urb)
 248 +{
 249 +       struct usb_sg_request   *io = (struct usb_sg_request *) urb->context;
 250 +
 251 +       spin_lock (&io->lock);
 252 +
 253 +       /* In 2.5 we require hcds' endpoint queues not to progress after fault
 254 +        * reports, until the completion callback (this!) returns.  That lets
 255 +        * device driver code (like this routine) unlink queued urbs first,
 256 +        * if it needs to, since the HC won't work on them at all.  So it's
 257 +        * not possible for page N+1 to overwrite page N, and so on.
 258 +        *
 259 +        * That's only for "hard" faults; "soft" faults (unlinks) sometimes
 260 +        * complete before the HCD can get requests away from hardware,
 261 +        * though never during cleanup after a hard fault.
 262 +        */
 263 +       if (io->status
 264 +                       && (io->status != -ECONNRESET
 265 +                               || urb->status != -ECONNRESET)
 266 +                       && urb->actual_length) {
 267 +               US_DEBUGP("Error: %s ep%d%s scatterlist error %d/%d\n",
 268 +                       io->dev->devpath,
 269 +                       usb_pipeendpoint (urb->pipe),
 270 +                       usb_pipein (urb->pipe) ? "in" : "out",
 271 +                       urb->status, io->status);
 272 +               // BUG ();
 273 +       }
 274 +
 275 +       if (urb->status && urb->status != -ECONNRESET) {
 276 +               int             i, found, status;
 277 +
 278 +               io->status = urb->status;
 279 +
 280 +               /* the previous urbs, and this one, completed already.
 281 +                * unlink pending urbs so they won't rx/tx bad data.
 282 +                */
 283 +               for (i = 0, found = 0; i < io->entries; i++) {
 284 +                       if (!io->urbs [i])
 285 +                               continue;
 286 +                       if (found) {
 287 +                               status = usb_unlink_urb (io->urbs [i]);
 288 +                               if (status != -EINPROGRESS && status != -EBUSY)
 289 +                                       US_DEBUGP("Error: %s, unlink --> %d\n", __FUNCTION__, status);
 290 +                       } else if (urb == io->urbs [i])
 291 +                               found = 1;
 292 +               }
 293 +       }
 294 +       urb->dev = 0;
 295 +
 296 +       /* on the last completion, signal usb_sg_wait() */
 297 +       io->bytes += urb->actual_length;
 298 +       io->count--;
 299 +       if (!io->count)
 300 +               complete (&io->complete);
 301 +
 302 +       spin_unlock (&io->lock);
 303 +}
 304 +
 305 +/**
 306 + * usb_sg_init - initializes scatterlist-based bulk/interrupt I/O request
 307 + * @io: request block being initialized.  until usb_sg_wait() returns,
 308 + *     treat this as a pointer to an opaque block of memory,
 309 + * @dev: the usb device that will send or receive the data
 310 + * @pipe: endpoint "pipe" used to transfer the data
 311 + * @period: polling rate for interrupt endpoints, in frames or
 312 + *     (for high speed endpoints) microframes; ignored for bulk
 313 + * @sg: scatterlist entries
 314 + * @nents: how many entries in the scatterlist
 315 + * @length: how many bytes to send from the scatterlist, or zero to
 316 + *     send every byte identified in the list.
 317 + * @mem_flags: SLAB_* flags affecting memory allocations in this call
 318 + *
 319 + * Returns zero for success, else a negative errno value.  This initializes a
 320 + * scatter/gather request, allocating resources such as I/O mappings and urb
 321 + * memory (except maybe memory used by USB controller drivers).
 322 + *
 323 + * The request must be issued using usb_sg_wait(), which waits for the I/O to
 324 + * complete (or to be canceled) and then cleans up all resources allocated by
 325 + * usb_sg_init().
 326 + *
 327 + * The request may be canceled with usb_sg_cancel(), either before or after
 328 + * usb_sg_wait() is called.
 329 + */
 330 +int usb_sg_init (
 331 +       struct usb_sg_request   *io,
 332 +       struct usb_device       *dev,
 333 +       unsigned                pipe,
 334 +       unsigned                period,
 335 +       struct scatterlist      *sg,
 336 +       int                     nents,
 337 +       size_t                  length,
 338 +       int                     mem_flags
 339 +)
 340 +{
 341 +       int                     i;
 342 +       int                     urb_flags;
 343 +       int                     dma;
 344 +       struct usb_hcd *hcd;
 345 +
 346 +       hcd = dev->bus->hcpriv;
 347 +
 348 +       if (!io || !dev || !sg
 349 +                       || usb_pipecontrol (pipe)
 350 +                       || usb_pipeisoc (pipe)
 351 +                       || nents <= 0)
 352 +               return -EINVAL;
 353 +
 354 +       spin_lock_init (&io->lock);
 355 +       io->dev = dev;
 356 +       io->pipe = pipe;
 357 +       io->sg = sg;
 358 +       io->nents = nents;
 359 +
 360 +       /* not all host controllers use DMA (like the mainstream pci ones);
 361 +        * they can use PIO (sl811) or be software over another transport.
 362 +        */
 363 +       dma = (hcd->pdev->dma_mask != 0);
 364 +       if (dma)
 365 +               io->entries = usb_buffer_map_sg (dev, pipe, sg, nents);
 366 +       else
 367 +               io->entries = nents;
 368 +
 369 +       /* initialize all the urbs we'll use */
 370 +       if (io->entries <= 0)
 371 +               return io->entries;
 372 +
 373 +       io->count = 0;
 374 +       io->urbs = kmalloc (io->entries * sizeof *io->urbs, mem_flags);
 375 +       if (!io->urbs)
 376 +               goto nomem;
 377 +
 378 +       urb_flags = USB_ASYNC_UNLINK | URB_NO_INTERRUPT | URB_NO_TRANSFER_DMA_MAP;
 379 +       if (usb_pipein (pipe))
 380 +               urb_flags |= URB_SHORT_NOT_OK;
 381 +
 382 +       for (i = 0; i < io->entries; i++, io->count = i) {
 383 +               unsigned                len;
 384 +
 385 +               io->urbs [i] = usb_alloc_urb (0);
 386 +               if (!io->urbs [i]) {
 387 +                       io->entries = i;
 388 +                       goto nomem;
 389 +               }
 390 +
 391 +               io->urbs [i]->dev = 0;
 392 +               io->urbs [i]->pipe = pipe;
 393 +               io->urbs [i]->interval = period;
 394 +               io->urbs [i]->transfer_flags = urb_flags;
 395 +
 396 +               io->urbs [i]->complete = sg_complete;
 397 +               io->urbs [i]->context = io;
 398 +               io->urbs [i]->status = -EINPROGRESS;
 399 +               io->urbs [i]->actual_length = 0;
 400 +
 401 +               if (dma) {
 402 +                       /* hc may use _only_ transfer_dma */
 403 +                       io->urbs [i]->transfer_dma = sg_dma_address (sg + i);
 404 +                       len = sg_dma_len (sg + i);
 405 +               } else {
 406 +                       /* hc may use _only_ transfer_buffer */
 407 +                       io->urbs [i]->transfer_buffer =
 408 +                               page_address (sg [i].page) + sg [i].offset;
 409 +                       len = sg [i].length;
 410 +               }
 411 +
 412 +               if (length) {
 413 +                       len = min_t (unsigned, len, length);
 414 +                       length -= len;
 415 +                       if (length == 0)
 416 +                               io->entries = i + 1;
 417 +               }
 418 +               io->urbs [i]->transfer_buffer_length = len;
 419 +       }
 420 +       io->urbs [--i]->transfer_flags &= ~URB_NO_INTERRUPT;
 421 +
 422 +       /* transaction state */
 423 +       io->status = 0;
 424 +       io->bytes = 0;
 425 +       init_completion (&io->complete);
 426 +       return 0;
 427 +
 428 +nomem:
 429 +       sg_clean (io);
 430 +       return -ENOMEM;
 431 +}
 432 +
 433 +/**
 434 + * usb_sg_cancel - stop scatter/gather i/o issued by usb_sg_wait()
 435 + * @io: request block, initialized with usb_sg_init()
 436 + *
 437 + * This stops a request after it has been started by usb_sg_wait().
 438 + * It can also prevents one initialized by usb_sg_init() from starting,
 439 + * so that call just frees resources allocated to the request.
 440 + */
 441 +void usb_sg_cancel (struct usb_sg_request *io)
 442 +{
 443 +       unsigned long   flags;
 444 +
 445 +       spin_lock_irqsave (&io->lock, flags);
 446 +
 447 +       /* shut everything down, if it didn't already */
 448 +       if (!io->status) {
 449 +               int     i;
 450 +
 451 +               io->status = -ECONNRESET;
 452 +               for (i = 0; i < io->entries; i++) {
 453 +                       int     retval;
 454 +
 455 +                       if (!io->urbs [i]->dev)
 456 +                               continue;
 457 +                       retval = usb_unlink_urb (io->urbs [i]);
 458 +                       if (retval != -EINPROGRESS && retval != -EBUSY)
 459 +                               US_DEBUGP("WARNING: %s, unlink --> %d\n", __FUNCTION__, retval);
 460 +               }
 461 +       }
 462 +       spin_unlock_irqrestore (&io->lock, flags);
 463 +}
 464 +
 465 +/**
 466 + * usb_sg_wait - synchronously execute scatter/gather request
 467 + * @io: request block handle, as initialized with usb_sg_init().
 468 + *     some fields become accessible when this call returns.
 469 + * Context: !in_interrupt ()
 470 + *
 471 + * This function blocks until the specified I/O operation completes.  It
 472 + * leverages the grouping of the related I/O requests to get good transfer
 473 + * rates, by queueing the requests.  At higher speeds, such queuing can
 474 + * significantly improve USB throughput.
 475 + *
 476 + * There are three kinds of completion for this function.
 477 + * (1) success, where io->status is zero.  The number of io->bytes
 478 + *     transferred is as requested.
 479 + * (2) error, where io->status is a negative errno value.  The number
 480 + *     of io->bytes transferred before the error is usually less
 481 + *     than requested, and can be nonzero.
 482 + * (3) cancelation, a type of error with status -ECONNRESET that
 483 + *     is initiated by usb_sg_cancel().
 484 + *
 485 + * When this function returns, all memory allocated through usb_sg_init() or
 486 + * this call will have been freed.  The request block parameter may still be
 487 + * passed to usb_sg_cancel(), or it may be freed.  It could also be
 488 + * reinitialized and then reused.
 489 + *
 490 + * Data Transfer Rates:
 491 + *
 492 + * Bulk transfers are valid for full or high speed endpoints.
 493 + * The best full speed data rate is 19 packets of 64 bytes each
 494 + * per frame, or 1216 bytes per millisecond.
 495 + * The best high speed data rate is 13 packets of 512 bytes each
 496 + * per microframe, or 52 KBytes per millisecond.
 497 + *
 498 + * The reason to use interrupt transfers through this API would most likely
 499 + * be to reserve high speed bandwidth, where up to 24 KBytes per millisecond
 500 + * could be transferred.  That capability is less useful for low or full
 501 + * speed interrupt endpoints, which allow at most one packet per millisecond,
 502 + * of at most 8 or 64 bytes (respectively).
 503 + */
 504 +void usb_sg_wait (struct usb_sg_request *io)
 505 +{
 506 +       int             i, entries = io->entries;
 507 +
 508 +       /* queue the urbs.  */
 509 +       spin_lock_irq (&io->lock);
 510 +       for (i = 0; i < entries && !io->status; i++) {
 511 +               int     retval;
 512 +
 513 +               io->urbs [i]->dev = io->dev;
 514 +               retval = usb_submit_urb (io->urbs [i]);
 515 +
 516 +               /* after we submit, let completions or cancelations fire;
 517 +                * we handshake using io->status.
 518 +                */
 519 +               spin_unlock_irq (&io->lock);
 520 +               switch (retval) {
 521 +                       /* maybe we retrying will recover */
 522 +               case -ENXIO:    // hc didn't queue this one
 523 +               case -EAGAIN:
 524 +               case -ENOMEM:
 525 +                       io->urbs [i]->dev = 0;
 526 +                       retval = 0;
 527 +                       i--;
 528 +                       yield ();
 529 +                       break;
 530 +
 531 +                       /* no error? continue immediately.
 532 +                        *
 533 +                        * NOTE: to work better with UHCI (4K I/O buffer may
 534 +                        * need 3K of TDs) it may be good to limit how many
 535 +                        * URBs are queued at once; N milliseconds?
 536 +                        */
 537 +               case 0:
 538 +                       cpu_relax ();
 539 +                       break;
 540 +
 541 +                       /* fail any uncompleted urbs */
 542 +               default:
 543 +                       spin_lock_irq (&io->lock);
 544 +                       io->count -= entries - i;
 545 +                       if (io->status == -EINPROGRESS)
 546 +                               io->status = retval;
 547 +                       if (io->count == 0)
 548 +                               complete (&io->complete);
 549 +                       spin_unlock_irq (&io->lock);
 550 +
 551 +                       io->urbs [i]->dev = 0;
 552 +                       io->urbs [i]->status = retval;
 553 +
 554 +                       US_DEBUGP("%s, submit --> %d\n", __FUNCTION__, retval);
 555 +                       usb_sg_cancel (io);
 556 +               }
 557 +               spin_lock_irq (&io->lock);
 558 +               if (retval && io->status == -ECONNRESET)
 559 +                       io->status = retval;
 560 +       }
 561 +       spin_unlock_irq (&io->lock);
 562 +
 563 +       /* OK, yes, this could be packaged as non-blocking.
 564 +        * So could the submit loop above ... but it's easier to
 565 +        * solve neither problem than to solve both!
 566 +        */
 567 +       wait_for_completion (&io->complete);
 568 +
 569 +       sg_clean (io);
 570 +}
 571 +
 572 +/*
 573 + * Interpret the results of a URB transfer
 574 + *
 575 + * This function prints appropriate debugging messages, clears halts on
 576 + * non-control endpoints, and translates the status to the corresponding
 577 + * USB_STOR_XFER_xxx return code.
 578 + */
 579 +static int interpret_urb_result(struct us_data *us, unsigned int pipe,
 580 +               unsigned int length, int result, unsigned int partial)
 581 +{
 582 +       US_DEBUGP("Status code %d; transferred %u/%u\n",
 583 +                       result, partial, length);
 584 +       switch (result) {
 585 +
 586 +       /* no error code; did we send all the data? */
 587 +       case 0:
 588 +               if (partial != length) {
 589 +                       US_DEBUGP("-- short transfer\n");
 590 +                       return USB_STOR_XFER_SHORT;
 591 +               }
 592 +
 593 +               US_DEBUGP("-- transfer complete\n");
 594 +               return USB_STOR_XFER_GOOD;
 595 +
 596 +       /* stalled */
 597 +       case -EPIPE:
 598 +               /* for control endpoints, (used by CB[I]) a stall indicates
 599 +                * a failed command */
 600 +               if (usb_pipecontrol(pipe)) {
 601 +                       US_DEBUGP("-- stall on control pipe\n");
 602 +                       return USB_STOR_XFER_STALLED;
 603 +               }
 604 +
 605 +               /* for other sorts of endpoint, clear the stall */
 606 +               US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
 607 +               if (usb_stor_clear_halt(us, pipe) < 0)
 608 +                       return USB_STOR_XFER_ERROR;
 609 +               return USB_STOR_XFER_STALLED;
 610 +
 611 +       /* timeout or excessively long NAK */
 612 +       case -ETIMEDOUT:
 613 +               US_DEBUGP("-- timeout or NAK\n");
 614 +               return USB_STOR_XFER_ERROR;
 615 +
 616 +       /* babble - the device tried to send more than we wanted to read */
 617 +       case -EOVERFLOW:
 618 +               US_DEBUGP("-- babble\n");
 619 +               return USB_STOR_XFER_LONG;
 620 +
 621 +       /* the transfer was cancelled by abort, disconnect, or timeout */
 622 +       case -ECONNRESET:
 623 +               US_DEBUGP("-- transfer cancelled\n");
 624 +               return USB_STOR_XFER_ERROR;
 625 +
 626 +       /* short scatter-gather read transfer */
 627 +       case -EREMOTEIO:
 628 +               US_DEBUGP("-- short read transfer\n");
 629 +               return USB_STOR_XFER_SHORT;
 630 +
 631 +       /* abort or disconnect in progress */
 632 +       case -EIO:
 633 +               US_DEBUGP("-- abort or disconnect in progress\n");
 634 +               return USB_STOR_XFER_ERROR;
 635 +
 636 +       /* the catch-all error case */
 637 +       default:
 638 +               US_DEBUGP("-- unknown error\n");
 639 +               return USB_STOR_XFER_ERROR;
 640 +       }
 641 +}
 642 +
 643 +/*
 644 + * Transfer a scatter-gather list via bulk transfer
 645 + *
 646 + * This function does basically the same thing as usb_stor_bulk_msg()
 647 + * above, but it uses the usbcore scatter-gather library.
 648 + */
 649 +int usb_stor_bulk_transfer_sglist(struct us_data *us, unsigned int pipe,
 650 +               struct scatterlist *sg, int num_sg, unsigned int length,
 651 +               unsigned int *act_len)
 652 +{
 653 +       int result;
 654 +
 655 +       /* don't submit s-g requests during abort/disconnect processing */
 656 +       if (us->flags & ABORTING_OR_DISCONNECTING)
 657 +               return USB_STOR_XFER_ERROR;
 658 +
 659 +       /* initialize the scatter-gather request block */
 660 +       US_DEBUGP("%s: xfer %u bytes, %d entries\n", __FUNCTION__,
 661 +                       length, num_sg);
 662 +       result = usb_sg_init(&us->current_sg, us->pusb_dev, pipe, 0,
 663 +                       sg, num_sg, length, SLAB_NOIO);
 664 +       if (result) {
 665 +               US_DEBUGP("usb_sg_init returned %d\n", result);
 666 +               return USB_STOR_XFER_ERROR;
 667 +       }
 668 +
 669 +       /* since the block has been initialized successfully, it's now
 670 +        * okay to cancel it */
 671 +       set_bit(US_FLIDX_SG_ACTIVE, &us->flags);
 672 +
 673 +       /* did an abort/disconnect occur during the submission? */
 674 +       if (us->flags & ABORTING_OR_DISCONNECTING) {
 675 +
 676 +               /* cancel the request, if it hasn't been cancelled already */
 677 +               if (test_and_clear_bit(US_FLIDX_SG_ACTIVE, &us->flags)) {
 678 +                       US_DEBUGP("-- cancelling sg request\n");
 679 +                       usb_sg_cancel(&us->current_sg);
 680 +               }
 681 +       }
 682 +
 683 +       /* wait for the completion of the transfer */
 684 +       usb_sg_wait(&us->current_sg);
 685 +       clear_bit(US_FLIDX_SG_ACTIVE, &us->flags);
 686 +
 687 +       result = us->current_sg.status;
 688 +       if (act_len)
 689 +               *act_len = us->current_sg.bytes;
 690 +       return interpret_urb_result(us, pipe, length, result,
 691 +                       us->current_sg.bytes);
 692 +}
 693 +
 694  /*
 695   * Transfer an entire SCSI command's worth of data payload over the bulk
 696   * pipe.
 697 @@ -569,6 +1122,8 @@
 698         struct scatterlist *sg;
 699         unsigned int total_transferred = 0;
 700         unsigned int transfer_amount;
 701 +       unsigned int partial;
 702 +       unsigned int pipe;
 703
 704         /* calculate how much we want to transfer */
 705         transfer_amount = usb_stor_transfer_length(srb);
 706 @@ -585,23 +1140,34 @@
 707                  * make the appropriate requests for each, until done
 708                  */
 709                 sg = (struct scatterlist *) srb->request_buffer;
 710 -               for (i = 0; i < srb->use_sg; i++) {
 711 -
 712 -                       /* transfer the lesser of the next buffer or the
 713 -                        * remaining data */
 714 -                       if (transfer_amount - total_transferred >=
 715 -                                       sg[i].length) {
 716 -                               result = usb_stor_transfer_partial(us,
 717 -                                               sg[i].address, sg[i].length);
 718 -                               total_transferred += sg[i].length;
 719 -                       } else
 720 -                               result = usb_stor_transfer_partial(us,
 721 -                                               sg[i].address,
 722 -                                               transfer_amount - total_transferred);
 723 -
 724 -                       /* if we get an error, end the loop here */
 725 -                       if (result)
 726 -                               break;
 727 +               if (us->pusb_dev->speed == USB_SPEED_HIGH) {
 728 +                       /* calculate the appropriate pipe information */
 729 +                       if (us->srb->sc_data_direction == SCSI_DATA_READ)
 730 +                               pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
 731 +                       else
 732 +                               pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
 733 +                       /* use the usb core scatter-gather primitives */
 734 +                       result = usb_stor_bulk_transfer_sglist(us, pipe,
 735 +                                       sg, srb->use_sg, transfer_amount, &partial);
 736 +               } else {
 737 +                       for (i = 0; i < srb->use_sg; i++) {
 738 +
 739 +                               /* transfer the lesser of the next buffer or the
 740 +                                * remaining data */
 741 +                               if (transfer_amount - total_transferred >=
 742 +                                               sg[i].length) {
 743 +                                       result = usb_stor_transfer_partial(us,
 744 +                                                       sg[i].address, sg[i].length);
 745 +                                       total_transferred += sg[i].length;
 746 +                               } else
 747 +                                       result = usb_stor_transfer_partial(us,
 748 +                                                       sg[i].address,
 749 +                                                       transfer_amount - total_transferred);
 750 +
 751 +                               /* if we get an error, end the loop here */
 752 +                               if (result)
 753 +                                       break;
 754 +                       }
 755                 }
 756         }
 757         else
 758 diff -ur linux.old/drivers/usb/storage/transport.h linux.dev/drivers/usb/storage/transport.h
 759 --- linux.old/drivers/usb/storage/transport.h   2003-08-25 13:44:42.000000000 +0200
 760 +++ linux.dev/drivers/usb/storage/transport.h   2006-07-30 12:10:16.000000000 +0200
 761 @@ -127,6 +127,16 @@
 762  #define US_BULK_TRANSFER_ABORTED       3  /* transfer canceled             */
 763
 764  /*
 765 + * usb_stor_bulk_transfer_xxx() return codes, in order of severity
 766 + */
 767 +
 768 +#define USB_STOR_XFER_GOOD             0       /* good transfer                 */
 769 +#define USB_STOR_XFER_SHORT            1       /* transferred less than expected */
 770 +#define USB_STOR_XFER_STALLED  2       /* endpoint stalled              */
 771 +#define USB_STOR_XFER_LONG             3       /* device tried to send too much */
 772 +#define USB_STOR_XFER_ERROR            4       /* transfer died in the middle   */
 773 +
 774 +/*
 775   * Transport return codes
 776   */
 777
 778 diff -ur linux.old/drivers/usb/storage/usb.h linux.dev/drivers/usb/storage/usb.h
 779 --- linux.old/drivers/usb/storage/usb.h 2005-04-04 03:42:20.000000000 +0200
 780 +++ linux.dev/drivers/usb/storage/usb.h 2006-07-30 12:11:06.000000000 +0200
 781 @@ -111,6 +111,60 @@
 782  typedef void (*proto_cmnd)(Scsi_Cmnd*, struct us_data*);
 783  typedef void (*extra_data_destructor)(void *);  /* extra data destructor   */
 784
 785 +/* Dynamic flag definitions: used in set_bit() etc. */
 786 +#define US_FLIDX_URB_ACTIVE    18  /* 0x00040000  current_urb is in use  */
 787 +#define US_FLIDX_SG_ACTIVE     19  /* 0x00080000  current_sg is in use   */
 788 +#define US_FLIDX_ABORTING      20  /* 0x00100000  abort is in progress   */
 789 +#define US_FLIDX_DISCONNECTING 21  /* 0x00200000  disconnect in progress */
 790 +#define ABORTING_OR_DISCONNECTING      ((1UL << US_FLIDX_ABORTING) | \
 791 +                                        (1UL << US_FLIDX_DISCONNECTING))
 792 +#define US_FLIDX_RESETTING     22  /* 0x00400000  device reset in progress */
 793 +
 794 +/* processing state machine states */
 795 +#define US_STATE_IDLE          1
 796 +#define US_STATE_RUNNING       2
 797 +#define US_STATE_RESETTING     3
 798 +#define US_STATE_ABORTING      4
 799 +
 800 +/**
 801 + * struct usb_sg_request - support for scatter/gather I/O
 802 + * @status: zero indicates success, else negative errno
 803 + * @bytes: counts bytes transferred.
 804 + *
 805 + * These requests are initialized using usb_sg_init(), and then are used
 806 + * as request handles passed to usb_sg_wait() or usb_sg_cancel().  Most
 807 + * members of the request object aren't for driver access.
 808 + *
 809 + * The status and bytecount values are valid only after usb_sg_wait()
 810 + * returns.  If the status is zero, then the bytecount matches the total
 811 + * from the request.
 812 + *
 813 + * After an error completion, drivers may need to clear a halt condition
 814 + * on the endpoint.
 815 + */
 816 +struct usb_sg_request {
 817 +       int                     status;
 818 +       size_t                  bytes;
 819 +
 820 +       /*
 821 +        * members below are private to usbcore,
 822 +        * and are not provided for driver access!
 823 +        */
 824 +       spinlock_t              lock;
 825 +
 826 +       struct usb_device       *dev;
 827 +       int                     pipe;
 828 +       struct scatterlist      *sg;
 829 +       int                     nents;
 830 +
 831 +       int                     entries;
 832 +       struct urb              **urbs;
 833 +
 834 +       int                     count;
 835 +       struct completion       complete;
 836 +};
 837 +
 838 +
 839  /* we allocate one of these for every device that we remember */
 840  struct us_data {
 841         struct us_data          *next;           /* next device */
 842 @@ -171,6 +225,7 @@
 843         struct urb              *current_urb;    /* non-int USB requests */
 844         struct completion       current_done;    /* the done flag        */
 845         unsigned int            tag;             /* tag for bulk CBW/CSW */
 846 +       struct usb_sg_request   current_sg;  /* scatter-gather req.  */
 847
 848         /* the semaphore for sleeping the control thread */
 849         struct semaphore        sema;            /* to sleep thread on   */
 850 diff -ur linux.old/include/linux/usb.h linux.dev/include/linux/usb.h
 851 --- linux.old/include/linux/usb.h       2004-11-17 12:54:22.000000000 +0100
 852 +++ linux.dev/include/linux/usb.h       2006-07-30 12:19:19.000000000 +0200
 853 @@ -483,6 +483,8 @@
 854  #define URB_NO_INTERRUPT       0x0080  /* HINT: no non-error interrupt needed */
 855                                         /* ... less overhead for QUEUE_BULK */
 856  #define USB_TIMEOUT_KILLED     0x1000  // only set by HCD!
 857 +#define URB_NO_TRANSFER_DMA_MAP        0x0400  /* urb->transfer_dma valid on submit */
 858 +#define URB_NO_SETUP_DMA_MAP   0x0800  /* urb->setup_dma valid on submit */
 859
 860  struct iso_packet_descriptor
 861  {