2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/init.h>
|
2007-08-03 02:04:52 +07:00
|
|
|
#include <linux/log2.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/usb.h>
|
2007-05-25 18:40:56 +07:00
|
|
|
#include <linux/wait.h>
|
2010-04-25 04:21:52 +07:00
|
|
|
#include <linux/usb/hcd.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#define to_urb(d) container_of(d, struct urb, kref)
|
|
|
|
|
2008-07-29 21:18:47 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static void urb_destroy(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct urb *urb = to_urb(kref);
|
2007-05-25 18:40:56 +07:00
|
|
|
|
2007-06-13 13:02:11 +07:00
|
|
|
if (urb->transfer_flags & URB_FREE_BUFFER)
|
|
|
|
kfree(urb->transfer_buffer);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(urb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_init_urb - initializes a urb so that it can be used by a USB driver
|
|
|
|
* @urb: pointer to the urb to initialize
|
|
|
|
*
|
|
|
|
* Initializes a urb so that the USB subsystem can use it properly.
|
|
|
|
*
|
|
|
|
* If a urb is created with a call to usb_alloc_urb() it is not
|
|
|
|
* necessary to call this function. Only use this if you allocate the
|
|
|
|
* space for a struct urb on your own. If you call this function, be
|
|
|
|
* careful when freeing the memory for your urb that it is no longer in
|
|
|
|
* use by the USB core.
|
|
|
|
*
|
|
|
|
* Only use this function if you _really_ understand what you are doing.
|
|
|
|
*/
|
|
|
|
void usb_init_urb(struct urb *urb)
|
|
|
|
{
|
|
|
|
if (urb) {
|
|
|
|
memset(urb, 0, sizeof(*urb));
|
|
|
|
kref_init(&urb->kref);
|
2007-05-25 18:40:56 +07:00
|
|
|
INIT_LIST_HEAD(&urb->anchor_list);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
2008-01-26 00:12:21 +07:00
|
|
|
EXPORT_SYMBOL_GPL(usb_init_urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_alloc_urb - creates a new urb for a USB driver to use
|
|
|
|
* @iso_packets: number of iso packets for this urb
|
|
|
|
* @mem_flags: the type of memory to allocate, see kmalloc() for a list of
|
|
|
|
* valid options for this.
|
|
|
|
*
|
|
|
|
* Creates an urb for the USB driver to use, initializes a few internal
|
|
|
|
* structures, incrementes the usage counter, and returns a pointer to it.
|
|
|
|
*
|
|
|
|
* If no memory is available, NULL is returned.
|
|
|
|
*
|
|
|
|
* If the driver want to use this urb for interrupt, control, or bulk
|
|
|
|
* endpoints, pass '0' as the number of iso packets.
|
|
|
|
*
|
|
|
|
* The driver must call usb_free_urb() when it is finished with the urb.
|
|
|
|
*/
|
2005-10-21 14:21:58 +07:00
|
|
|
struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct urb *urb;
|
|
|
|
|
2006-09-14 02:38:41 +07:00
|
|
|
urb = kmalloc(sizeof(struct urb) +
|
2005-04-17 05:20:36 +07:00
|
|
|
iso_packets * sizeof(struct usb_iso_packet_descriptor),
|
|
|
|
mem_flags);
|
|
|
|
if (!urb) {
|
2008-08-14 23:37:34 +07:00
|
|
|
printk(KERN_ERR "alloc_urb: kmalloc failed\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
usb_init_urb(urb);
|
|
|
|
return urb;
|
|
|
|
}
|
2008-01-26 00:12:21 +07:00
|
|
|
EXPORT_SYMBOL_GPL(usb_alloc_urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_free_urb - frees the memory used by a urb when all users of it are finished
|
|
|
|
* @urb: pointer to the urb to free, may be NULL
|
|
|
|
*
|
|
|
|
* Must be called when a user of a urb is finished with it. When the last user
|
|
|
|
* of the urb calls this function, the memory of the urb is freed.
|
|
|
|
*
|
2008-11-09 13:10:30 +07:00
|
|
|
* Note: The transfer buffer associated with the urb is not freed unless the
|
|
|
|
* URB_FREE_BUFFER transfer flag is set.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
void usb_free_urb(struct urb *urb)
|
|
|
|
{
|
|
|
|
if (urb)
|
|
|
|
kref_put(&urb->kref, urb_destroy);
|
|
|
|
}
|
2008-01-26 00:12:21 +07:00
|
|
|
EXPORT_SYMBOL_GPL(usb_free_urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_get_urb - increments the reference count of the urb
|
|
|
|
* @urb: pointer to the urb to modify, may be NULL
|
|
|
|
*
|
|
|
|
* This must be called whenever a urb is transferred from a device driver to a
|
|
|
|
* host controller driver. This allows proper reference counting to happen
|
|
|
|
* for urbs.
|
|
|
|
*
|
|
|
|
* A pointer to the urb with the incremented reference counter is returned.
|
|
|
|
*/
|
2008-01-31 06:21:33 +07:00
|
|
|
struct urb *usb_get_urb(struct urb *urb)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
if (urb)
|
|
|
|
kref_get(&urb->kref);
|
|
|
|
return urb;
|
|
|
|
}
|
2008-01-26 00:12:21 +07:00
|
|
|
EXPORT_SYMBOL_GPL(usb_get_urb);
|
2007-05-25 18:40:56 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_anchor_urb - anchors an URB while it is processed
|
|
|
|
* @urb: pointer to the urb to anchor
|
|
|
|
* @anchor: pointer to the anchor
|
|
|
|
*
|
|
|
|
* This can be called to have access to URBs which are to be executed
|
|
|
|
* without bothering to track them
|
|
|
|
*/
|
|
|
|
void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&anchor->lock, flags);
|
|
|
|
usb_get_urb(urb);
|
|
|
|
list_add_tail(&urb->anchor_list, &anchor->urb_list);
|
|
|
|
urb->anchor = anchor;
|
2008-07-29 21:18:47 +07:00
|
|
|
|
|
|
|
if (unlikely(anchor->poisoned)) {
|
2008-12-12 20:38:45 +07:00
|
|
|
atomic_inc(&urb->reject);
|
2008-07-29 21:18:47 +07:00
|
|
|
}
|
|
|
|
|
2007-05-25 18:40:56 +07:00
|
|
|
spin_unlock_irqrestore(&anchor->lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_anchor_urb);
|
|
|
|
|
2010-08-03 07:32:28 +07:00
|
|
|
/* Callers must hold anchor->lock */
|
|
|
|
static void __usb_unanchor_urb(struct urb *urb, struct usb_anchor *anchor)
|
|
|
|
{
|
|
|
|
urb->anchor = NULL;
|
|
|
|
list_del(&urb->anchor_list);
|
|
|
|
usb_put_urb(urb);
|
|
|
|
if (list_empty(&anchor->urb_list))
|
|
|
|
wake_up(&anchor->wait);
|
|
|
|
}
|
|
|
|
|
2007-05-25 18:40:56 +07:00
|
|
|
/**
|
|
|
|
* usb_unanchor_urb - unanchors an URB
|
|
|
|
* @urb: pointer to the urb to anchor
|
|
|
|
*
|
|
|
|
* Call this to stop the system keeping track of this URB
|
|
|
|
*/
|
|
|
|
void usb_unanchor_urb(struct urb *urb)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct usb_anchor *anchor;
|
|
|
|
|
|
|
|
if (!urb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
anchor = urb->anchor;
|
|
|
|
if (!anchor)
|
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&anchor->lock, flags);
|
2010-08-03 07:32:28 +07:00
|
|
|
/*
|
|
|
|
* At this point, we could be competing with another thread which
|
|
|
|
* has the same intention. To protect the urb from being unanchored
|
|
|
|
* twice, only the winner of the race gets the job.
|
|
|
|
*/
|
|
|
|
if (likely(anchor == urb->anchor))
|
|
|
|
__usb_unanchor_urb(urb, anchor);
|
2007-05-25 18:40:56 +07:00
|
|
|
spin_unlock_irqrestore(&anchor->lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_unanchor_urb);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*-------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_submit_urb - issue an asynchronous transfer request for an endpoint
|
|
|
|
* @urb: pointer to the urb describing the request
|
|
|
|
* @mem_flags: the type of memory to allocate, see kmalloc() for a list
|
|
|
|
* of valid options for this.
|
|
|
|
*
|
|
|
|
* This submits a transfer request, and transfers control of the URB
|
|
|
|
* describing that request to the USB subsystem. Request completion will
|
|
|
|
* be indicated later, asynchronously, by calling the completion handler.
|
|
|
|
* The three types of completion are success, error, and unlink
|
2008-01-31 06:21:33 +07:00
|
|
|
* (a software-induced fault, also called "request cancellation").
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* URBs may be submitted in interrupt context.
|
|
|
|
*
|
|
|
|
* The caller must have correctly initialized the URB before submitting
|
|
|
|
* it. Functions such as usb_fill_bulk_urb() and usb_fill_control_urb() are
|
|
|
|
* available to ensure that most fields are correctly initialized, for
|
|
|
|
* the particular kind of transfer, although they will not initialize
|
|
|
|
* any transfer flags.
|
|
|
|
*
|
|
|
|
* Successful submissions return 0; otherwise this routine returns a
|
|
|
|
* negative error number. If the submission is successful, the complete()
|
|
|
|
* callback from the URB will be called exactly once, when the USB core and
|
|
|
|
* Host Controller Driver (HCD) are finished with the URB. When the completion
|
|
|
|
* function is called, control of the URB is returned to the device
|
|
|
|
* driver which issued the request. The completion handler may then
|
|
|
|
* immediately free or reuse that URB.
|
|
|
|
*
|
|
|
|
* With few exceptions, USB device drivers should never access URB fields
|
|
|
|
* provided by usbcore or the HCD until its complete() is called.
|
|
|
|
* The exceptions relate to periodic transfer scheduling. For both
|
|
|
|
* interrupt and isochronous urbs, as part of successful URB submission
|
|
|
|
* urb->interval is modified to reflect the actual transfer period used
|
|
|
|
* (normally some power of two units). And for isochronous urbs,
|
|
|
|
* urb->start_frame is modified to reflect when the URB's transfers were
|
|
|
|
* scheduled to start. Not all isochronous transfer scheduling policies
|
|
|
|
* will work, but most host controller drivers should easily handle ISO
|
|
|
|
* queues going from now until 10-200 msec into the future.
|
|
|
|
*
|
|
|
|
* For control endpoints, the synchronous usb_control_msg() call is
|
|
|
|
* often used (in non-interrupt context) instead of this call.
|
|
|
|
* That is often used through convenience wrappers, for the requests
|
|
|
|
* that are standardized in the USB 2.0 specification. For bulk
|
|
|
|
* endpoints, a synchronous usb_bulk_msg() call is available.
|
|
|
|
*
|
|
|
|
* Request Queuing:
|
|
|
|
*
|
|
|
|
* URBs may be submitted to endpoints before previous ones complete, to
|
|
|
|
* minimize the impact of interrupt latencies and system overhead on data
|
|
|
|
* throughput. With that queuing policy, an endpoint's queue would never
|
|
|
|
* be empty. This is required for continuous isochronous data streams,
|
|
|
|
* and may also be required for some kinds of interrupt transfers. Such
|
|
|
|
* queuing also maximizes bandwidth utilization by letting USB controllers
|
|
|
|
* start work on later requests before driver software has finished the
|
|
|
|
* completion processing for earlier (successful) requests.
|
|
|
|
*
|
|
|
|
* As of Linux 2.6, all USB endpoint transfer queues support depths greater
|
|
|
|
* than one. This was previously a HCD-specific behavior, except for ISO
|
|
|
|
* transfers. Non-isochronous endpoint queues are inactive during cleanup
|
2005-05-04 08:07:24 +07:00
|
|
|
* after faults (transfer errors or cancellation).
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* Reserved Bandwidth Transfers:
|
|
|
|
*
|
|
|
|
* Periodic transfers (interrupt or isochronous) are performed repeatedly,
|
|
|
|
* using the interval specified in the urb. Submitting the first urb to
|
|
|
|
* the endpoint reserves the bandwidth necessary to make those transfers.
|
|
|
|
* If the USB subsystem can't allocate sufficient bandwidth to perform
|
|
|
|
* the periodic request, submitting such a periodic request should fail.
|
|
|
|
*
|
USB: Support for bandwidth allocation.
Originally, the USB core had no support for allocating bandwidth when a
particular configuration or alternate setting for an interface was
selected. Instead, the device driver's URB submission would fail if
there was not enough bandwidth for a periodic endpoint. Drivers could
work around this, by using the scatter-gather list API to guarantee
bandwidth.
This patch adds host controller API to allow the USB core to allocate or
deallocate bandwidth for an endpoint. Endpoints are added to or dropped
from a copy of the current schedule by calling add_endpoint() or
drop_endpoint(), and then the schedule is atomically evaluated with a
call to check_bandwidth(). This allows all the endpoints for a new
configuration or alternate setting to be added at the same time that the
endpoints from the old configuration or alt setting are dropped.
Endpoints must be added to the schedule before any URBs are submitted to
them. The HCD must be allowed to reject a new configuration or alt
setting before the control transfer is sent to the device requesting the
change. It may reject the change because there is not enough bandwidth,
not enough internal resources (such as memory on an embedded host
controller), or perhaps even for security reasons in a virtualized
environment.
If the call to check_bandwidth() fails, the USB core must call
reset_bandwidth(). This causes the schedule to be reverted back to the
state it was in just after the last successful check_bandwidth() call.
If the call succeeds, the host controller driver (and hardware) will have
changed its internal state to match the new configuration or alternate
setting. The USB core can then issue a control transfer to the device to
change the configuration or alt setting. This allows the core to test new
configurations or alternate settings before unbinding drivers bound to
interfaces in the old configuration.
WIP:
The USB core must add endpoints from all interfaces in a configuration
to the schedule, because a driver may claim that interface at any time.
A slight optimization might be to add the endpoints to the schedule once
a driver claims that interface. FIXME
This patch does not cover changing alternate settings, but it does
handle a configuration change or de-configuration. FIXME
The code for managing the schedule is currently HCD specific. A generic
scheduling algorithm could be added for host controllers without
built-in scheduling support. For now, if a host controller does not
define the check_bandwidth() function, the call to
usb_hcd_check_bandwidth() will always succeed.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-28 09:58:26 +07:00
|
|
|
* For devices under xHCI, the bandwidth is reserved at configuration time, or
|
|
|
|
* when the alt setting is selected. If there is not enough bus bandwidth, the
|
|
|
|
* configuration/alt setting request will fail. Therefore, submissions to
|
|
|
|
* periodic endpoints on devices under xHCI should never fail due to bandwidth
|
|
|
|
* constraints.
|
|
|
|
*
|
2005-04-17 05:20:36 +07:00
|
|
|
* Device drivers must explicitly request that repetition, by ensuring that
|
|
|
|
* some URB is always on the endpoint's queue (except possibly for short
|
|
|
|
* periods during completion callacks). When there is no longer an urb
|
|
|
|
* queued, the endpoint's bandwidth reservation is canceled. This means
|
|
|
|
* drivers can use their completion handlers to ensure they keep bandwidth
|
|
|
|
* they need, by reinitializing and resubmitting the just-completed urb
|
|
|
|
* until the driver longer needs that periodic bandwidth.
|
|
|
|
*
|
|
|
|
* Memory Flags:
|
|
|
|
*
|
|
|
|
* The general rules for how to decide which mem_flags to use
|
|
|
|
* are the same as for kmalloc. There are four
|
|
|
|
* different possible values; GFP_KERNEL, GFP_NOFS, GFP_NOIO and
|
|
|
|
* GFP_ATOMIC.
|
|
|
|
*
|
|
|
|
* GFP_NOFS is not ever used, as it has not been implemented yet.
|
|
|
|
*
|
|
|
|
* GFP_ATOMIC is used when
|
|
|
|
* (a) you are inside a completion handler, an interrupt, bottom half,
|
|
|
|
* tasklet or timer, or
|
|
|
|
* (b) you are holding a spinlock or rwlock (does not apply to
|
|
|
|
* semaphores), or
|
|
|
|
* (c) current->state != TASK_RUNNING, this is the case only after
|
|
|
|
* you've changed it.
|
2008-01-31 06:21:33 +07:00
|
|
|
*
|
2005-04-17 05:20:36 +07:00
|
|
|
* GFP_NOIO is used in the block io path and error handling of storage
|
|
|
|
* devices.
|
|
|
|
*
|
|
|
|
* All other situations use GFP_KERNEL.
|
|
|
|
*
|
|
|
|
* Some more specific rules for mem_flags can be inferred, such as
|
|
|
|
* (1) start_xmit, timeout, and receive methods of network drivers must
|
|
|
|
* use GFP_ATOMIC (they are called with a spinlock held);
|
|
|
|
* (2) queuecommand methods of scsi drivers must use GFP_ATOMIC (also
|
|
|
|
* called with a spinlock held);
|
|
|
|
* (3) If you use a kernel thread with a network driver you must use
|
|
|
|
* GFP_NOIO, unless (b) or (c) apply;
|
|
|
|
* (4) after you have done a down() you can use GFP_KERNEL, unless (b) or (c)
|
|
|
|
* apply or your are in a storage driver's block io path;
|
|
|
|
* (5) USB probe and disconnect can use GFP_KERNEL unless (b) or (c) apply; and
|
|
|
|
* (6) changing firmware on a running storage or net device uses
|
|
|
|
* GFP_NOIO, unless b) or c) apply
|
|
|
|
*
|
|
|
|
*/
|
2005-10-21 14:21:58 +07:00
|
|
|
int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-07-31 04:04:37 +07:00
|
|
|
int xfertype, max;
|
|
|
|
struct usb_device *dev;
|
|
|
|
struct usb_host_endpoint *ep;
|
|
|
|
int is_out;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (!urb || urb->hcpriv || !urb->complete)
|
|
|
|
return -EINVAL;
|
2008-01-31 06:21:33 +07:00
|
|
|
dev = urb->dev;
|
2009-02-18 21:43:47 +07:00
|
|
|
if ((!dev) || (dev->state < USB_STATE_UNAUTHENTICATED))
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
2007-07-31 04:04:37 +07:00
|
|
|
/* For now, get the endpoint from the pipe. Eventually drivers
|
|
|
|
* will be required to set urb->ep directly and we will eliminate
|
|
|
|
* urb->pipe.
|
|
|
|
*/
|
2010-05-01 02:11:29 +07:00
|
|
|
ep = usb_pipe_endpoint(dev, urb->pipe);
|
2007-07-31 04:04:37 +07:00
|
|
|
if (!ep)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
urb->ep = ep;
|
2005-04-17 05:20:36 +07:00
|
|
|
urb->status = -EINPROGRESS;
|
|
|
|
urb->actual_length = 0;
|
|
|
|
|
|
|
|
/* Lots of sanity checks, so HCDs can rely on clean data
|
|
|
|
* and don't need to duplicate tests
|
|
|
|
*/
|
2007-07-31 04:04:37 +07:00
|
|
|
xfertype = usb_endpoint_type(&ep->desc);
|
2007-07-31 04:06:16 +07:00
|
|
|
if (xfertype == USB_ENDPOINT_XFER_CONTROL) {
|
|
|
|
struct usb_ctrlrequest *setup =
|
|
|
|
(struct usb_ctrlrequest *) urb->setup_packet;
|
|
|
|
|
|
|
|
if (!setup)
|
|
|
|
return -ENOEXEC;
|
|
|
|
is_out = !(setup->bRequestType & USB_DIR_IN) ||
|
|
|
|
!setup->wLength;
|
|
|
|
} else {
|
|
|
|
is_out = usb_endpoint_dir_out(&ep->desc);
|
|
|
|
}
|
|
|
|
|
2010-04-03 00:27:28 +07:00
|
|
|
/* Clear the internal flags and cache the direction for later use */
|
|
|
|
urb->transfer_flags &= ~(URB_DIR_MASK | URB_DMA_MAP_SINGLE |
|
|
|
|
URB_DMA_MAP_PAGE | URB_DMA_MAP_SG | URB_MAP_LOCAL |
|
|
|
|
URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL |
|
|
|
|
URB_DMA_SG_COMBINED);
|
|
|
|
urb->transfer_flags |= (is_out ? URB_DIR_OUT : URB_DIR_IN);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-31 04:04:37 +07:00
|
|
|
if (xfertype != USB_ENDPOINT_XFER_CONTROL &&
|
|
|
|
dev->state < USB_STATE_CONFIGURED)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
2011-08-23 17:12:03 +07:00
|
|
|
max = usb_endpoint_maxp(&ep->desc);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (max <= 0) {
|
|
|
|
dev_dbg(&dev->dev,
|
|
|
|
"bogus endpoint ep%d%s in %s (bad maxpacket %d)\n",
|
2007-07-31 04:04:37 +07:00
|
|
|
usb_endpoint_num(&ep->desc), is_out ? "out" : "in",
|
2008-03-04 07:08:34 +07:00
|
|
|
__func__, max);
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* periodic transfers limit size per frame/uframe,
|
|
|
|
* but drivers only control those sizes for ISO.
|
|
|
|
* while we're checking, initialize return status.
|
|
|
|
*/
|
2007-07-31 04:04:37 +07:00
|
|
|
if (xfertype == USB_ENDPOINT_XFER_ISOC) {
|
2005-04-17 05:20:36 +07:00
|
|
|
int n, len;
|
|
|
|
|
2011-03-01 09:11:27 +07:00
|
|
|
/* SuperSpeed isoc endpoints have up to 16 bursts of up to
|
|
|
|
* 3 packets each
|
|
|
|
*/
|
|
|
|
if (dev->speed == USB_SPEED_SUPER) {
|
|
|
|
int burst = 1 + ep->ss_ep_comp.bMaxBurst;
|
|
|
|
int mult = USB_SS_MULT(ep->ss_ep_comp.bmAttributes);
|
|
|
|
max *= burst;
|
|
|
|
max *= mult;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* "high bandwidth" mode, 1-3 packets/uframe? */
|
|
|
|
if (dev->speed == USB_SPEED_HIGH) {
|
|
|
|
int mult = 1 + ((max >> 11) & 0x03);
|
|
|
|
max &= 0x07ff;
|
|
|
|
max *= mult;
|
|
|
|
}
|
|
|
|
|
2008-01-31 06:21:33 +07:00
|
|
|
if (urb->number_of_packets <= 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
for (n = 0; n < urb->number_of_packets; n++) {
|
2007-01-24 03:55:28 +07:00
|
|
|
len = urb->iso_frame_desc[n].length;
|
2008-01-31 06:21:33 +07:00
|
|
|
if (len < 0 || len > max)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EMSGSIZE;
|
2007-01-24 03:55:28 +07:00
|
|
|
urb->iso_frame_desc[n].status = -EXDEV;
|
|
|
|
urb->iso_frame_desc[n].actual_length = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* the I/O buffer must be mapped/unmapped, except when length=0 */
|
2009-03-13 18:19:18 +07:00
|
|
|
if (urb->transfer_buffer_length > INT_MAX)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
/* stuff that drivers shouldn't do, but which shouldn't
|
|
|
|
* cause problems in HCDs if they get it wrong.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
unsigned int orig_flags = urb->transfer_flags;
|
|
|
|
unsigned int allowed;
|
2009-12-12 04:20:20 +07:00
|
|
|
static int pipetypes[4] = {
|
|
|
|
PIPE_CONTROL, PIPE_ISOCHRONOUS, PIPE_BULK, PIPE_INTERRUPT
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Check that the pipe's type matches the endpoint's type */
|
2010-08-31 04:50:20 +07:00
|
|
|
if (usb_pipetype(urb->pipe) != pipetypes[xfertype]) {
|
|
|
|
dev_err(&dev->dev, "BOGUS urb xfer, pipe %x != type %x\n",
|
|
|
|
usb_pipetype(urb->pipe), pipetypes[xfertype]);
|
2009-12-12 04:20:20 +07:00
|
|
|
return -EPIPE; /* The most suitable error code :-) */
|
2010-08-31 04:50:20 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* enforce simple/standard policy */
|
2010-03-06 03:10:17 +07:00
|
|
|
allowed = (URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT | URB_DIR_MASK |
|
|
|
|
URB_FREE_BUFFER);
|
2007-07-31 04:04:37 +07:00
|
|
|
switch (xfertype) {
|
|
|
|
case USB_ENDPOINT_XFER_BULK:
|
2005-04-17 05:20:36 +07:00
|
|
|
if (is_out)
|
|
|
|
allowed |= URB_ZERO_PACKET;
|
|
|
|
/* FALLTHROUGH */
|
2007-07-31 04:04:37 +07:00
|
|
|
case USB_ENDPOINT_XFER_CONTROL:
|
2005-04-17 05:20:36 +07:00
|
|
|
allowed |= URB_NO_FSBR; /* only affects UHCI */
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
default: /* all non-iso endpoints */
|
|
|
|
if (!is_out)
|
|
|
|
allowed |= URB_SHORT_NOT_OK;
|
|
|
|
break;
|
2007-07-31 04:04:37 +07:00
|
|
|
case USB_ENDPOINT_XFER_ISOC:
|
2005-04-17 05:20:36 +07:00
|
|
|
allowed |= URB_ISO_ASAP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
urb->transfer_flags &= allowed;
|
|
|
|
|
|
|
|
/* fail if submitter gave bogus flags */
|
|
|
|
if (urb->transfer_flags != orig_flags) {
|
2008-08-14 23:37:34 +07:00
|
|
|
dev_err(&dev->dev, "BOGUS urb flags, %x --> %x\n",
|
2005-04-17 05:20:36 +07:00
|
|
|
orig_flags, urb->transfer_flags);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* Force periodic transfer intervals to be legal values that are
|
|
|
|
* a power of two (so HCDs don't need to).
|
|
|
|
*
|
|
|
|
* FIXME want bus->{intr,iso}_sched_horizon values here. Each HC
|
|
|
|
* supports different values... this uses EHCI/UHCI defaults (and
|
|
|
|
* EHCI can use smaller non-default values).
|
|
|
|
*/
|
2007-07-31 04:04:37 +07:00
|
|
|
switch (xfertype) {
|
|
|
|
case USB_ENDPOINT_XFER_ISOC:
|
|
|
|
case USB_ENDPOINT_XFER_INT:
|
2005-04-17 05:20:36 +07:00
|
|
|
/* too small? */
|
2009-08-18 22:11:24 +07:00
|
|
|
switch (dev->speed) {
|
2010-01-15 02:08:04 +07:00
|
|
|
case USB_SPEED_WIRELESS:
|
2009-08-18 22:11:24 +07:00
|
|
|
if (urb->interval < 6)
|
|
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (urb->interval <= 0)
|
|
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
/* too big? */
|
|
|
|
switch (dev->speed) {
|
2009-04-28 09:54:10 +07:00
|
|
|
case USB_SPEED_SUPER: /* units are 125us */
|
|
|
|
/* Handle up to 2^(16-1) microframes */
|
|
|
|
if (urb->interval > (1 << 15))
|
|
|
|
return -EINVAL;
|
|
|
|
max = 1 << 15;
|
2010-03-17 02:55:44 +07:00
|
|
|
break;
|
2010-01-15 02:08:04 +07:00
|
|
|
case USB_SPEED_WIRELESS:
|
2009-08-18 22:11:24 +07:00
|
|
|
if (urb->interval > 16)
|
|
|
|
return -EINVAL;
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
case USB_SPEED_HIGH: /* units are microframes */
|
2008-01-31 06:21:33 +07:00
|
|
|
/* NOTE usb handles 2^15 */
|
2005-04-17 05:20:36 +07:00
|
|
|
if (urb->interval > (1024 * 8))
|
|
|
|
urb->interval = 1024 * 8;
|
2007-07-31 04:04:37 +07:00
|
|
|
max = 1024 * 8;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case USB_SPEED_FULL: /* units are frames/msec */
|
|
|
|
case USB_SPEED_LOW:
|
2007-07-31 04:04:37 +07:00
|
|
|
if (xfertype == USB_ENDPOINT_XFER_INT) {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (urb->interval > 255)
|
|
|
|
return -EINVAL;
|
2008-01-31 06:21:33 +07:00
|
|
|
/* NOTE ohci only handles up to 32 */
|
2007-07-31 04:04:37 +07:00
|
|
|
max = 128;
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
|
|
|
if (urb->interval > 1024)
|
|
|
|
urb->interval = 1024;
|
2008-01-31 06:21:33 +07:00
|
|
|
/* NOTE usb and ohci handle up to 2^15 */
|
2007-07-31 04:04:37 +07:00
|
|
|
max = 1024;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-01-15 02:08:04 +07:00
|
|
|
if (dev->speed != USB_SPEED_WIRELESS) {
|
2009-08-18 22:11:24 +07:00
|
|
|
/* Round down to a power of 2, no more than max */
|
|
|
|
urb->interval = min(max, 1 << ilog2(urb->interval));
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-01-24 03:55:28 +07:00
|
|
|
return usb_hcd_submit_urb(urb, mem_flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-01-26 00:12:21 +07:00
|
|
|
EXPORT_SYMBOL_GPL(usb_submit_urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_unlink_urb - abort/cancel a transfer request for an endpoint
|
|
|
|
* @urb: pointer to urb describing a previously submitted request,
|
|
|
|
* may be NULL
|
|
|
|
*
|
2007-07-14 02:47:16 +07:00
|
|
|
* This routine cancels an in-progress request. URBs complete only once
|
|
|
|
* per submission, and may be canceled only once per submission.
|
|
|
|
* Successful cancellation means termination of @urb will be expedited
|
|
|
|
* and the completion handler will be called with a status code
|
|
|
|
* indicating that the request has been canceled (rather than any other
|
|
|
|
* code).
|
|
|
|
*
|
2008-10-22 02:28:46 +07:00
|
|
|
* Drivers should not call this routine or related routines, such as
|
|
|
|
* usb_kill_urb() or usb_unlink_anchored_urbs(), after their disconnect
|
|
|
|
* method has returned. The disconnect function should synchronize with
|
|
|
|
* a driver's I/O routines to insure that all URB-related activity has
|
|
|
|
* completed before it returns.
|
|
|
|
*
|
2007-07-14 02:47:16 +07:00
|
|
|
* This request is always asynchronous. Success is indicated by
|
|
|
|
* returning -EINPROGRESS, at which time the URB will probably not yet
|
|
|
|
* have been given back to the device driver. When it is eventually
|
|
|
|
* called, the completion function will see @urb->status == -ECONNRESET.
|
|
|
|
* Failure is indicated by usb_unlink_urb() returning any other value.
|
|
|
|
* Unlinking will fail when @urb is not currently "linked" (i.e., it was
|
|
|
|
* never submitted, or it was unlinked before, or the hardware is already
|
|
|
|
* finished with it), even if the completion handler has not yet run.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* Unlinking and Endpoint Queues:
|
|
|
|
*
|
2007-07-14 02:47:16 +07:00
|
|
|
* [The behaviors and guarantees described below do not apply to virtual
|
|
|
|
* root hubs but only to endpoint queues for physical USB devices.]
|
|
|
|
*
|
2005-04-17 05:20:36 +07:00
|
|
|
* Host Controller Drivers (HCDs) place all the URBs for a particular
|
|
|
|
* endpoint in a queue. Normally the queue advances as the controller
|
2005-04-19 07:39:30 +07:00
|
|
|
* hardware processes each request. But when an URB terminates with an
|
2007-07-14 02:47:16 +07:00
|
|
|
* error its queue generally stops (see below), at least until that URB's
|
|
|
|
* completion routine returns. It is guaranteed that a stopped queue
|
|
|
|
* will not restart until all its unlinked URBs have been fully retired,
|
|
|
|
* with their completion routines run, even if that's not until some time
|
|
|
|
* after the original completion handler returns. The same behavior and
|
|
|
|
* guarantee apply when an URB terminates because it was unlinked.
|
|
|
|
*
|
|
|
|
* Bulk and interrupt endpoint queues are guaranteed to stop whenever an
|
|
|
|
* URB terminates with any sort of error, including -ECONNRESET, -ENOENT,
|
|
|
|
* and -EREMOTEIO. Control endpoint queues behave the same way except
|
|
|
|
* that they are not guaranteed to stop for -EREMOTEIO errors. Queues
|
|
|
|
* for isochronous endpoints are treated differently, because they must
|
|
|
|
* advance at fixed rates. Such queues do not stop when an URB
|
|
|
|
* encounters an error or is unlinked. An unlinked isochronous URB may
|
|
|
|
* leave a gap in the stream of packets; it is undefined whether such
|
|
|
|
* gaps can be filled in.
|
|
|
|
*
|
|
|
|
* Note that early termination of an URB because a short packet was
|
|
|
|
* received will generate a -EREMOTEIO error if and only if the
|
|
|
|
* URB_SHORT_NOT_OK flag is set. By setting this flag, USB device
|
|
|
|
* drivers can build deep queues for large or complex bulk transfers
|
|
|
|
* and clean them up reliably after any sort of aborted transfer by
|
|
|
|
* unlinking all pending URBs at the first fault.
|
|
|
|
*
|
|
|
|
* When a control URB terminates with an error other than -EREMOTEIO, it
|
|
|
|
* is quite likely that the status stage of the transfer will not take
|
|
|
|
* place.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
int usb_unlink_urb(struct urb *urb)
|
|
|
|
{
|
|
|
|
if (!urb)
|
|
|
|
return -EINVAL;
|
2007-08-03 02:04:52 +07:00
|
|
|
if (!urb->dev)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENODEV;
|
2007-08-03 02:04:52 +07:00
|
|
|
if (!urb->ep)
|
|
|
|
return -EIDRM;
|
2006-08-30 22:27:36 +07:00
|
|
|
return usb_hcd_unlink_urb(urb, -ECONNRESET);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-01-26 00:12:21 +07:00
|
|
|
EXPORT_SYMBOL_GPL(usb_unlink_urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_kill_urb - cancel a transfer request and wait for it to finish
|
|
|
|
* @urb: pointer to URB describing a previously submitted request,
|
|
|
|
* may be NULL
|
|
|
|
*
|
|
|
|
* This routine cancels an in-progress request. It is guaranteed that
|
|
|
|
* upon return all completion handlers will have finished and the URB
|
|
|
|
* will be totally idle and available for reuse. These features make
|
|
|
|
* this an ideal way to stop I/O in a disconnect() callback or close()
|
|
|
|
* function. If the request has not already finished or been unlinked
|
|
|
|
* the completion handler will see urb->status == -ENOENT.
|
|
|
|
*
|
|
|
|
* While the routine is running, attempts to resubmit the URB will fail
|
|
|
|
* with error -EPERM. Thus even if the URB's completion handler always
|
|
|
|
* tries to resubmit, it will not succeed and the URB will become idle.
|
|
|
|
*
|
|
|
|
* This routine may not be used in an interrupt context (such as a bottom
|
|
|
|
* half or a completion handler), or when holding a spinlock, or in other
|
|
|
|
* situations where the caller can't schedule().
|
2008-10-22 02:28:46 +07:00
|
|
|
*
|
|
|
|
* This routine should not be called by a driver after its disconnect
|
|
|
|
* method has returned.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
void usb_kill_urb(struct urb *urb)
|
|
|
|
{
|
2006-01-24 05:17:21 +07:00
|
|
|
might_sleep();
|
2007-08-03 02:04:52 +07:00
|
|
|
if (!(urb && urb->dev && urb->ep))
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
2008-12-12 20:38:45 +07:00
|
|
|
atomic_inc(&urb->reject);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-08-30 22:27:36 +07:00
|
|
|
usb_hcd_unlink_urb(urb, -ENOENT);
|
2005-04-17 05:20:36 +07:00
|
|
|
wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0);
|
|
|
|
|
2008-12-12 20:38:45 +07:00
|
|
|
atomic_dec(&urb->reject);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-01-26 00:12:21 +07:00
|
|
|
EXPORT_SYMBOL_GPL(usb_kill_urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-29 20:26:15 +07:00
|
|
|
/**
|
|
|
|
* usb_poison_urb - reliably kill a transfer and prevent further use of an URB
|
|
|
|
* @urb: pointer to URB describing a previously submitted request,
|
|
|
|
* may be NULL
|
|
|
|
*
|
|
|
|
* This routine cancels an in-progress request. It is guaranteed that
|
|
|
|
* upon return all completion handlers will have finished and the URB
|
|
|
|
* will be totally idle and cannot be reused. These features make
|
|
|
|
* this an ideal way to stop I/O in a disconnect() callback.
|
|
|
|
* If the request has not already finished or been unlinked
|
|
|
|
* the completion handler will see urb->status == -ENOENT.
|
|
|
|
*
|
|
|
|
* After and while the routine runs, attempts to resubmit the URB will fail
|
|
|
|
* with error -EPERM. Thus even if the URB's completion handler always
|
|
|
|
* tries to resubmit, it will not succeed and the URB will become idle.
|
|
|
|
*
|
|
|
|
* This routine may not be used in an interrupt context (such as a bottom
|
|
|
|
* half or a completion handler), or when holding a spinlock, or in other
|
|
|
|
* situations where the caller can't schedule().
|
2008-10-22 02:28:46 +07:00
|
|
|
*
|
|
|
|
* This routine should not be called by a driver after its disconnect
|
|
|
|
* method has returned.
|
2008-07-29 20:26:15 +07:00
|
|
|
*/
|
|
|
|
void usb_poison_urb(struct urb *urb)
|
|
|
|
{
|
|
|
|
might_sleep();
|
|
|
|
if (!(urb && urb->dev && urb->ep))
|
|
|
|
return;
|
2008-12-12 20:38:45 +07:00
|
|
|
atomic_inc(&urb->reject);
|
2008-07-29 20:26:15 +07:00
|
|
|
|
|
|
|
usb_hcd_unlink_urb(urb, -ENOENT);
|
|
|
|
wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_poison_urb);
|
|
|
|
|
|
|
|
void usb_unpoison_urb(struct urb *urb)
|
|
|
|
{
|
|
|
|
if (!urb)
|
|
|
|
return;
|
|
|
|
|
2008-12-12 20:38:45 +07:00
|
|
|
atomic_dec(&urb->reject);
|
2008-07-29 20:26:15 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_unpoison_urb);
|
|
|
|
|
2007-05-25 18:40:56 +07:00
|
|
|
/**
|
|
|
|
* usb_kill_anchored_urbs - cancel transfer requests en masse
|
|
|
|
* @anchor: anchor the requests are bound to
|
|
|
|
*
|
|
|
|
* this allows all outstanding URBs to be killed starting
|
|
|
|
* from the back of the queue
|
2008-10-22 02:28:46 +07:00
|
|
|
*
|
|
|
|
* This routine should not be called by a driver after its disconnect
|
|
|
|
* method has returned.
|
2007-05-25 18:40:56 +07:00
|
|
|
*/
|
|
|
|
void usb_kill_anchored_urbs(struct usb_anchor *anchor)
|
|
|
|
{
|
|
|
|
struct urb *victim;
|
|
|
|
|
|
|
|
spin_lock_irq(&anchor->lock);
|
|
|
|
while (!list_empty(&anchor->urb_list)) {
|
2008-01-31 06:21:33 +07:00
|
|
|
victim = list_entry(anchor->urb_list.prev, struct urb,
|
|
|
|
anchor_list);
|
2007-05-25 18:40:56 +07:00
|
|
|
/* we must make sure the URB isn't freed before we kill it*/
|
|
|
|
usb_get_urb(victim);
|
|
|
|
spin_unlock_irq(&anchor->lock);
|
|
|
|
/* this will unanchor the URB */
|
|
|
|
usb_kill_urb(victim);
|
|
|
|
usb_put_urb(victim);
|
|
|
|
spin_lock_irq(&anchor->lock);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&anchor->lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_kill_anchored_urbs);
|
|
|
|
|
2008-07-29 21:18:47 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_poison_anchored_urbs - cease all traffic from an anchor
|
|
|
|
* @anchor: anchor the requests are bound to
|
|
|
|
*
|
|
|
|
* this allows all outstanding URBs to be poisoned starting
|
|
|
|
* from the back of the queue. Newly added URBs will also be
|
|
|
|
* poisoned
|
2008-10-22 02:28:46 +07:00
|
|
|
*
|
|
|
|
* This routine should not be called by a driver after its disconnect
|
|
|
|
* method has returned.
|
2008-07-29 21:18:47 +07:00
|
|
|
*/
|
|
|
|
void usb_poison_anchored_urbs(struct usb_anchor *anchor)
|
|
|
|
{
|
|
|
|
struct urb *victim;
|
|
|
|
|
|
|
|
spin_lock_irq(&anchor->lock);
|
|
|
|
anchor->poisoned = 1;
|
|
|
|
while (!list_empty(&anchor->urb_list)) {
|
|
|
|
victim = list_entry(anchor->urb_list.prev, struct urb,
|
|
|
|
anchor_list);
|
|
|
|
/* we must make sure the URB isn't freed before we kill it*/
|
|
|
|
usb_get_urb(victim);
|
|
|
|
spin_unlock_irq(&anchor->lock);
|
|
|
|
/* this will unanchor the URB */
|
|
|
|
usb_poison_urb(victim);
|
|
|
|
usb_put_urb(victim);
|
|
|
|
spin_lock_irq(&anchor->lock);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&anchor->lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_poison_anchored_urbs);
|
2008-10-22 02:28:46 +07:00
|
|
|
|
2008-12-18 15:17:49 +07:00
|
|
|
/**
|
|
|
|
* usb_unpoison_anchored_urbs - let an anchor be used successfully again
|
|
|
|
* @anchor: anchor the requests are bound to
|
|
|
|
*
|
|
|
|
* Reverses the effect of usb_poison_anchored_urbs
|
|
|
|
* the anchor can be used normally after it returns
|
|
|
|
*/
|
|
|
|
void usb_unpoison_anchored_urbs(struct usb_anchor *anchor)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct urb *lazarus;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&anchor->lock, flags);
|
|
|
|
list_for_each_entry(lazarus, &anchor->urb_list, anchor_list) {
|
|
|
|
usb_unpoison_urb(lazarus);
|
|
|
|
}
|
|
|
|
anchor->poisoned = 0;
|
|
|
|
spin_unlock_irqrestore(&anchor->lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_unpoison_anchored_urbs);
|
2008-04-10 19:07:37 +07:00
|
|
|
/**
|
|
|
|
* usb_unlink_anchored_urbs - asynchronously cancel transfer requests en masse
|
|
|
|
* @anchor: anchor the requests are bound to
|
|
|
|
*
|
|
|
|
* this allows all outstanding URBs to be unlinked starting
|
|
|
|
* from the back of the queue. This function is asynchronous.
|
|
|
|
* The unlinking is just tiggered. It may happen after this
|
|
|
|
* function has returned.
|
2008-10-22 02:28:46 +07:00
|
|
|
*
|
|
|
|
* This routine should not be called by a driver after its disconnect
|
|
|
|
* method has returned.
|
2008-04-10 19:07:37 +07:00
|
|
|
*/
|
|
|
|
void usb_unlink_anchored_urbs(struct usb_anchor *anchor)
|
|
|
|
{
|
|
|
|
struct urb *victim;
|
|
|
|
|
2010-08-03 07:32:28 +07:00
|
|
|
while ((victim = usb_get_from_anchor(anchor)) != NULL) {
|
2008-04-10 19:07:37 +07:00
|
|
|
usb_unlink_urb(victim);
|
2008-08-18 21:36:52 +07:00
|
|
|
usb_put_urb(victim);
|
2008-04-10 19:07:37 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_unlink_anchored_urbs);
|
|
|
|
|
2007-05-25 18:40:56 +07:00
|
|
|
/**
|
|
|
|
* usb_wait_anchor_empty_timeout - wait for an anchor to be unused
|
|
|
|
* @anchor: the anchor you want to become unused
|
|
|
|
* @timeout: how long you are willing to wait in milliseconds
|
|
|
|
*
|
|
|
|
* Call this is you want to be sure all an anchor's
|
|
|
|
* URBs have finished
|
|
|
|
*/
|
|
|
|
int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor,
|
|
|
|
unsigned int timeout)
|
|
|
|
{
|
|
|
|
return wait_event_timeout(anchor->wait, list_empty(&anchor->urb_list),
|
|
|
|
msecs_to_jiffies(timeout));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_wait_anchor_empty_timeout);
|
2008-08-26 03:40:25 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_get_from_anchor - get an anchor's oldest urb
|
|
|
|
* @anchor: the anchor whose urb you want
|
|
|
|
*
|
|
|
|
* this will take the oldest urb from an anchor,
|
|
|
|
* unanchor and return it
|
|
|
|
*/
|
|
|
|
struct urb *usb_get_from_anchor(struct usb_anchor *anchor)
|
|
|
|
{
|
|
|
|
struct urb *victim;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&anchor->lock, flags);
|
|
|
|
if (!list_empty(&anchor->urb_list)) {
|
|
|
|
victim = list_entry(anchor->urb_list.next, struct urb,
|
|
|
|
anchor_list);
|
|
|
|
usb_get_urb(victim);
|
2010-08-03 07:32:28 +07:00
|
|
|
__usb_unanchor_urb(victim, anchor);
|
2008-08-26 03:40:25 +07:00
|
|
|
} else {
|
|
|
|
victim = NULL;
|
|
|
|
}
|
2010-08-03 07:32:28 +07:00
|
|
|
spin_unlock_irqrestore(&anchor->lock, flags);
|
2008-08-26 03:40:25 +07:00
|
|
|
|
|
|
|
return victim;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(usb_get_from_anchor);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_scuttle_anchored_urbs - unanchor all an anchor's urbs
|
|
|
|
* @anchor: the anchor whose urbs you want to unanchor
|
|
|
|
*
|
|
|
|
* use this to get rid of all an anchor's urbs
|
|
|
|
*/
|
|
|
|
void usb_scuttle_anchored_urbs(struct usb_anchor *anchor)
|
|
|
|
{
|
|
|
|
struct urb *victim;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&anchor->lock, flags);
|
|
|
|
while (!list_empty(&anchor->urb_list)) {
|
|
|
|
victim = list_entry(anchor->urb_list.prev, struct urb,
|
|
|
|
anchor_list);
|
2010-08-03 07:32:28 +07:00
|
|
|
__usb_unanchor_urb(victim, anchor);
|
2008-08-26 03:40:25 +07:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&anchor->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(usb_scuttle_anchored_urbs);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_anchor_empty - is an anchor empty
|
|
|
|
* @anchor: the anchor you want to query
|
|
|
|
*
|
|
|
|
* returns 1 if the anchor has no urbs associated with it
|
|
|
|
*/
|
|
|
|
int usb_anchor_empty(struct usb_anchor *anchor)
|
|
|
|
{
|
|
|
|
return list_empty(&anchor->urb_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(usb_anchor_empty);
|
|
|
|
|