| 1 | |
| 2 | |
| 3 | * Released under the GPLv2 only.
|
| 4 |
|
| 5 |
|
| 6 | #include <linux/module.h>
|
| 7 | #include <linux/string.h>
|
| 8 | #include <linux/bitops.h>
|
| 9 | #include <linux/slab.h>
|
| 10 | #include <linux/log2.h>
|
| 11 | #include <linux/kmsan.h>
|
| 12 | #include <linux/usb.h>
|
| 13 | #include <linux/wait.h>
|
| 14 | #include <linux/usb/hcd.h>
|
| 15 | #include <linux/scatterlist.h>
|
| 16 |
|
| 17 | #define to_urb(d) container_of(d, struct urb, kref)
|
| 18 |
|
| 19 |
|
| 20 | static void urb_destroy(struct kref *kref)
|
| 21 | {
|
| 22 | struct urb *urb = to_urb(kref);
|
| 23 |
|
| 24 | if (urb->transfer_flags & URB_FREE_BUFFER)
|
| 25 | kfree(urb->transfer_buffer);
|
| 26 |
|
| 27 | kfree(urb);
|
| 28 | }
|
| 29 |
|
| 30 | |
| 31 | * usb_init_urb - initializes a urb so that it can be used by a USB driver
|
| 32 | * @urb: pointer to the urb to initialize
|
| 33 | *
|
| 34 | * Initializes a urb so that the USB subsystem can use it properly.
|
| 35 | *
|
| 36 | * If a urb is created with a call to usb_alloc_urb() it is not
|
| 37 | * necessary to call this function. Only use this if you allocate the
|
| 38 | * space for a struct urb on your own. If you call this function, be
|
| 39 | * careful when freeing the memory for your urb that it is no longer in
|
| 40 | * use by the USB core.
|
| 41 | *
|
| 42 | * Only use this function if you _really_ understand what you are doing.
|
| 43 |
|
| 44 | void usb_init_urb(struct urb *urb)
|
| 45 | {
|
| 46 | if (urb) {
|
| 47 | memset(urb, 0, sizeof(*urb));
|
| 48 | kref_init(&urb->kref);
|
| 49 | INIT_LIST_HEAD(&urb->urb_list);
|
| 50 | INIT_LIST_HEAD(&urb->anchor_list);
|
| 51 | }
|
| 52 | }
|
| 53 | EXPORT_SYMBOL_GPL(usb_init_urb);
|
| 54 |
|
| 55 | |
| 56 | * usb_alloc_urb - creates a new urb for a USB driver to use
|
| 57 | * @iso_packets: number of iso packets for this urb
|
| 58 | * @mem_flags: the type of memory to allocate, see kmalloc() for a list of
|
| 59 | * valid options for this.
|
| 60 | *
|
| 61 | * Creates an urb for the USB driver to use, initializes a few internal
|
| 62 | * structures, increments the usage counter, and returns a pointer to it.
|
| 63 | *
|
| 64 | * If the driver want to use this urb for interrupt, control, or bulk
|
| 65 | * endpoints, pass '0' as the number of iso packets.
|
| 66 | *
|
| 67 | * The driver must call usb_free_urb() when it is finished with the urb.
|
| 68 | *
|
| 69 | * Return: A pointer to the new urb, or %NULL if no memory is available.
|
| 70 |
|
| 71 | struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags)
|
| 72 | {
|
| 73 | struct urb *urb;
|
| 74 |
|
| 75 | urb = kmalloc_flex(*urb, iso_frame_desc, iso_packets, mem_flags);
|
| 76 | if (!urb)
|
| 77 | return NULL;
|
| 78 | usb_init_urb(urb);
|
| 79 | return urb;
|
| 80 | }
|
| 81 | EXPORT_SYMBOL_GPL(usb_alloc_urb);
|
| 82 |
|
| 83 | |
| 84 | * usb_free_urb - frees the memory used by a urb when all users of it are finished
|
| 85 | * @urb: pointer to the urb to free, may be NULL
|
| 86 | *
|
| 87 | * Must be called when a user of a urb is finished with it. When the last user
|
| 88 | * of the urb calls this function, the memory of the urb is freed.
|
| 89 | *
|
| 90 | * Note: The transfer buffer associated with the urb is not freed unless the
|
| 91 | * URB_FREE_BUFFER transfer flag is set.
|
| 92 |
|
| 93 | void usb_free_urb(struct urb *urb)
|
| 94 | {
|
| 95 | if (urb)
|
| 96 | kref_put(&urb->kref, urb_destroy);
|
| 97 | }
|
| 98 | EXPORT_SYMBOL_GPL(usb_free_urb);
|
| 99 |
|
| 100 | |
| 101 | * usb_get_urb - increments the reference count of the urb
|
| 102 | * @urb: pointer to the urb to modify, may be NULL
|
| 103 | *
|
| 104 | * This must be called whenever a urb is transferred from a device driver to a
|
| 105 | * host controller driver. This allows proper reference counting to happen
|
| 106 | * for urbs.
|
| 107 | *
|
| 108 | * Return: A pointer to the urb with the incremented reference counter.
|
| 109 |
|
| 110 | struct urb *usb_get_urb(struct urb *urb)
|
| 111 | {
|
| 112 | if (urb)
|
| 113 | kref_get(&urb->kref);
|
| 114 | return urb;
|
| 115 | }
|
| 116 | EXPORT_SYMBOL_GPL(usb_get_urb);
|
| 117 |
|
| 118 | |
| 119 | * usb_anchor_urb - anchors an URB while it is processed
|
| 120 | * @urb: pointer to the urb to anchor
|
| 121 | * @anchor: pointer to the anchor
|
| 122 | *
|
| 123 | * This can be called to have access to URBs which are to be executed
|
| 124 | * without bothering to track them
|
| 125 |
|
| 126 | void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor)
|
| 127 | {
|
| 128 | unsigned long flags;
|
| 129 |
|
| 130 | spin_lock_irqsave(&anchor->lock, flags);
|
| 131 | usb_get_urb(urb);
|
| 132 | list_add_tail(&urb->anchor_list, &anchor->urb_list);
|
| 133 | urb->anchor = anchor;
|
| 134 |
|
| 135 | if (unlikely(anchor->poisoned))
|
| 136 | atomic_inc(&urb->reject);
|
| 137 |
|
| 138 | spin_unlock_irqrestore(&anchor->lock, flags);
|
| 139 | }
|
| 140 | EXPORT_SYMBOL_GPL(usb_anchor_urb);
|
| 141 |
|
| 142 | static int usb_anchor_check_wakeup(struct usb_anchor *anchor)
|
| 143 | {
|
| 144 | return atomic_read(&anchor->suspend_wakeups) == 0 &&
|
| 145 | list_empty(&anchor->urb_list);
|
| 146 | }
|
| 147 |
|
| 148 |
|
| 149 | static void __usb_unanchor_urb(struct urb *urb, struct usb_anchor *anchor)
|
| 150 | {
|
| 151 | urb->anchor = NULL;
|
| 152 | list_del(&urb->anchor_list);
|
| 153 | usb_put_urb(urb);
|
| 154 | if (usb_anchor_check_wakeup(anchor))
|
| 155 | wake_up(&anchor->wait);
|
| 156 | }
|
| 157 |
|
| 158 | |
| 159 | * usb_unanchor_urb - unanchors an URB
|
| 160 | * @urb: pointer to the urb to anchor
|
| 161 | *
|
| 162 | * Call this to stop the system keeping track of this URB
|
| 163 |
|
| 164 | void usb_unanchor_urb(struct urb *urb)
|
| 165 | {
|
| 166 | unsigned long flags;
|
| 167 | struct usb_anchor *anchor;
|
| 168 |
|
| 169 | if (!urb)
|
| 170 | return;
|
| 171 |
|
| 172 | anchor = urb->anchor;
|
| 173 | if (!anchor)
|
| 174 | return;
|
| 175 |
|
| 176 | spin_lock_irqsave(&anchor->lock, flags);
|
| 177 | |
| 178 | * At this point, we could be competing with another thread which
|
| 179 | * has the same intention. To protect the urb from being unanchored
|
| 180 | * twice, only the winner of the race gets the job.
|
| 181 |
|
| 182 | if (likely(anchor == urb->anchor))
|
| 183 | __usb_unanchor_urb(urb, anchor);
|
| 184 | spin_unlock_irqrestore(&anchor->lock, flags);
|
| 185 | }
|
| 186 | EXPORT_SYMBOL_GPL(usb_unanchor_urb);
|
| 187 |
|
| 188 |
|
| 189 |
|
| 190 | static const int pipetypes[4] = {
|
| 191 | PIPE_CONTROL, PIPE_ISOCHRONOUS, PIPE_BULK, PIPE_INTERRUPT
|
| 192 | };
|
| 193 |
|
| 194 | |
| 195 | * usb_pipe_type_check - sanity check of a specific pipe for a usb device
|
| 196 | * @dev: struct usb_device to be checked
|
| 197 | * @pipe: pipe to check
|
| 198 | *
|
| 199 | * This performs a light-weight sanity check for the endpoint in the
|
| 200 | * given usb device. It returns 0 if the pipe is valid for the specific usb
|
| 201 | * device, otherwise a negative error code.
|
| 202 |
|
| 203 | int usb_pipe_type_check(struct usb_device *dev, unsigned int pipe)
|
| 204 | {
|
| 205 | const struct usb_host_endpoint *ep;
|
| 206 |
|
| 207 | ep = usb_pipe_endpoint(dev, pipe);
|
| 208 | if (!ep)
|
| 209 | return -EINVAL;
|
| 210 | if (usb_pipetype(pipe) != pipetypes[usb_endpoint_type(&ep->desc)])
|
| 211 | return -EINVAL;
|
| 212 | return 0;
|
| 213 | }
|
| 214 | EXPORT_SYMBOL_GPL(usb_pipe_type_check);
|
| 215 |
|
| 216 | |
| 217 | * usb_urb_ep_type_check - sanity check of endpoint in the given urb
|
| 218 | * @urb: urb to be checked
|
| 219 | *
|
| 220 | * This performs a light-weight sanity check for the endpoint in the
|
| 221 | * given urb. It returns 0 if the urb contains a valid endpoint, otherwise
|
| 222 | * a negative error code.
|
| 223 |
|
| 224 | int usb_urb_ep_type_check(const struct urb *urb)
|
| 225 | {
|
| 226 | return usb_pipe_type_check(urb->dev, urb->pipe);
|
| 227 | }
|
| 228 | EXPORT_SYMBOL_GPL(usb_urb_ep_type_check);
|
| 229 |
|
| 230 | |
| 231 | * usb_submit_urb - issue an asynchronous transfer request for an endpoint
|
| 232 | * @urb: pointer to the urb describing the request
|
| 233 | * @mem_flags: the type of memory to allocate, see kmalloc() for a list
|
| 234 | * of valid options for this.
|
| 235 | *
|
| 236 | * This submits a transfer request, and transfers control of the URB
|
| 237 | * describing that request to the USB subsystem. Request completion will
|
| 238 | * be indicated later, asynchronously, by calling the completion handler.
|
| 239 | * The three types of completion are success, error, and unlink
|
| 240 | * (a software-induced fault, also called "request cancellation").
|
| 241 | *
|
| 242 | * URBs may be submitted in interrupt context.
|
| 243 | *
|
| 244 | * The caller must have correctly initialized the URB before submitting
|
| 245 | * it. Functions such as usb_fill_bulk_urb() and usb_fill_control_urb() are
|
| 246 | * available to ensure that most fields are correctly initialized, for
|
| 247 | * the particular kind of transfer, although they will not initialize
|
| 248 | * any transfer flags.
|
| 249 | *
|
| 250 | * If the submission is successful, the complete() callback from the URB
|
| 251 | * will be called exactly once, when the USB core and Host Controller Driver
|
| 252 | * (HCD) are finished with the URB. When the completion function is called,
|
| 253 | * control of the URB is returned to the device driver which issued the
|
| 254 | * request. The completion handler may then immediately free or reuse that
|
| 255 | * URB.
|
| 256 | *
|
| 257 | * With few exceptions, USB device drivers should never access URB fields
|
| 258 | * provided by usbcore or the HCD until its complete() is called.
|
| 259 | * The exceptions relate to periodic transfer scheduling. For both
|
| 260 | * interrupt and isochronous urbs, as part of successful URB submission
|
| 261 | * urb->interval is modified to reflect the actual transfer period used
|
| 262 | * (normally some power of two units). And for isochronous urbs,
|
| 263 | * urb->start_frame is modified to reflect when the URB's transfers were
|
| 264 | * scheduled to start.
|
| 265 | *
|
| 266 | * Not all isochronous transfer scheduling policies will work, but most
|
| 267 | * host controller drivers should easily handle ISO queues going from now
|
| 268 | * until 10-200 msec into the future. Drivers should try to keep at
|
| 269 | * least one or two msec of data in the queue; many controllers require
|
| 270 | * that new transfers start at least 1 msec in the future when they are
|
| 271 | * added. If the driver is unable to keep up and the queue empties out,
|
| 272 | * the behavior for new submissions is governed by the URB_ISO_ASAP flag.
|
| 273 | * If the flag is set, or if the queue is idle, then the URB is always
|
| 274 | * assigned to the first available (and not yet expired) slot in the
|
| 275 | * endpoint's schedule. If the flag is not set and the queue is active
|
| 276 | * then the URB is always assigned to the next slot in the schedule
|
| 277 | * following the end of the endpoint's previous URB, even if that slot is
|
| 278 | * in the past. When a packet is assigned in this way to a slot that has
|
| 279 | * already expired, the packet is not transmitted and the corresponding
|
| 280 | * usb_iso_packet_descriptor's status field will return -EXDEV. If this
|
| 281 | * would happen to all the packets in the URB, submission fails with a
|
| 282 | * -EXDEV error code.
|
| 283 | *
|
| 284 | * For control endpoints, the synchronous usb_control_msg() call is
|
| 285 | * often used (in non-interrupt context) instead of this call.
|
| 286 | * That is often used through convenience wrappers, for the requests
|
| 287 | * that are standardized in the USB 2.0 specification. For bulk
|
| 288 | * endpoints, a synchronous usb_bulk_msg() call is available.
|
| 289 | *
|
| 290 | * Return:
|
| 291 | * 0 on successful submissions. A negative error number otherwise.
|
| 292 | *
|
| 293 | * Request Queuing:
|
| 294 | *
|
| 295 | * URBs may be submitted to endpoints before previous ones complete, to
|
| 296 | * minimize the impact of interrupt latencies and system overhead on data
|
| 297 | * throughput. With that queuing policy, an endpoint's queue would never
|
| 298 | * be empty. This is required for continuous isochronous data streams,
|
| 299 | * and may also be required for some kinds of interrupt transfers. Such
|
| 300 | * queuing also maximizes bandwidth utilization by letting USB controllers
|
| 301 | * start work on later requests before driver software has finished the
|
| 302 | * completion processing for earlier (successful) requests.
|
| 303 | *
|
| 304 | * As of Linux 2.6, all USB endpoint transfer queues support depths greater
|
| 305 | * than one. This was previously a HCD-specific behavior, except for ISO
|
| 306 | * transfers. Non-isochronous endpoint queues are inactive during cleanup
|
| 307 | * after faults (transfer errors or cancellation).
|
| 308 | *
|
| 309 | * Reserved Bandwidth Transfers:
|
| 310 | *
|
| 311 | * Periodic transfers (interrupt or isochronous) are performed repeatedly,
|
| 312 | * using the interval specified in the urb. Submitting the first urb to
|
| 313 | * the endpoint reserves the bandwidth necessary to make those transfers.
|
| 314 | * If the USB subsystem can't allocate sufficient bandwidth to perform
|
| 315 | * the periodic request, submitting such a periodic request should fail.
|
| 316 | *
|
| 317 | * For devices under xHCI, the bandwidth is reserved at configuration time, or
|
| 318 | * when the alt setting is selected. If there is not enough bus bandwidth, the
|
| 319 | * configuration/alt setting request will fail. Therefore, submissions to
|
| 320 | * periodic endpoints on devices under xHCI should never fail due to bandwidth
|
| 321 | * constraints.
|
| 322 | *
|
| 323 | * Device drivers must explicitly request that repetition, by ensuring that
|
| 324 | * some URB is always on the endpoint's queue (except possibly for short
|
| 325 | * periods during completion callbacks). When there is no longer an urb
|
| 326 | * queued, the endpoint's bandwidth reservation is canceled. This means
|
| 327 | * drivers can use their completion handlers to ensure they keep bandwidth
|
| 328 | * they need, by reinitializing and resubmitting the just-completed urb
|
| 329 | * until the driver longer needs that periodic bandwidth.
|
| 330 | *
|
| 331 | * Memory Flags:
|
| 332 | *
|
| 333 | * The general rules for how to decide which mem_flags to use
|
| 334 | * are the same as for kmalloc. There are four
|
| 335 | * different possible values; GFP_KERNEL, GFP_NOFS, GFP_NOIO and
|
| 336 | * GFP_ATOMIC.
|
| 337 | *
|
| 338 | * GFP_NOFS is not ever used, as it has not been implemented yet.
|
| 339 | *
|
| 340 | * GFP_ATOMIC is used when
|
| 341 | * (a) you are inside a completion handler, an interrupt, bottom half,
|
| 342 | * tasklet or timer, or
|
| 343 | * (b) you are holding a spinlock or rwlock (does not apply to
|
| 344 | * semaphores), or
|
| 345 | * (c) current->state != TASK_RUNNING, this is the case only after
|
| 346 | * you've changed it.
|
| 347 | *
|
| 348 | * GFP_NOIO is used in the block io path and error handling of storage
|
| 349 | * devices.
|
| 350 | *
|
| 351 | * All other situations use GFP_KERNEL.
|
| 352 | *
|
| 353 | * Some more specific rules for mem_flags can be inferred, such as
|
| 354 | * (1) start_xmit, timeout, and receive methods of network drivers must
|
| 355 | * use GFP_ATOMIC (they are called with a spinlock held);
|
| 356 | * (2) queuecommand methods of scsi drivers must use GFP_ATOMIC (also
|
| 357 | * called with a spinlock held);
|
| 358 | * (3) If you use a kernel thread with a network driver you must use
|
| 359 | * GFP_NOIO, unless (b) or (c) apply;
|
| 360 | * (4) after you have done a down() you can use GFP_KERNEL, unless (b) or (c)
|
| 361 | * apply or your are in a storage driver's block io path;
|
| 362 | * (5) USB probe and disconnect can use GFP_KERNEL unless (b) or (c) apply; and
|
| 363 | * (6) changing firmware on a running storage or net device uses
|
| 364 | * GFP_NOIO, unless b) or c) apply
|
| 365 | *
|
| 366 |
|
| 367 | int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
|
| 368 | {
|
| 369 | int xfertype, max;
|
| 370 | struct usb_device *dev;
|
| 371 | struct usb_host_endpoint *ep;
|
| 372 | int is_out;
|
| 373 | unsigned int allowed;
|
| 374 | bool is_eusb2_isoch_double;
|
| 375 |
|
| 376 | if (!urb || !urb->complete)
|
| 377 | return -EINVAL;
|
| 378 | if (urb->hcpriv) {
|
| 379 | WARN_ONCE(1, "URB %p submitted while active\n", urb);
|
| 380 | return -EBUSY;
|
| 381 | }
|
| 382 |
|
| 383 | dev = urb->dev;
|
| 384 | if ((!dev) || (dev->state < USB_STATE_UNAUTHENTICATED))
|
| 385 | return -ENODEV;
|
| 386 |
|
| 387 | |
| 388 | * will be required to set urb->ep directly and we will eliminate
|
| 389 | * urb->pipe.
|
| 390 |
|
| 391 | ep = usb_pipe_endpoint(dev, urb->pipe);
|
| 392 | if (!ep)
|
| 393 | return -ENOENT;
|
| 394 |
|
| 395 | urb->ep = ep;
|
| 396 | urb->status = -EINPROGRESS;
|
| 397 | urb->actual_length = 0;
|
| 398 |
|
| 399 | |
| 400 | * and don't need to duplicate tests
|
| 401 |
|
| 402 | xfertype = usb_endpoint_type(&ep->desc);
|
| 403 | if (xfertype == USB_ENDPOINT_XFER_CONTROL) {
|
| 404 | struct usb_ctrlrequest *setup =
|
| 405 | (struct usb_ctrlrequest *) urb->setup_packet;
|
| 406 |
|
| 407 | if (!setup)
|
| 408 | return -ENOEXEC;
|
| 409 | is_out = !(setup->bRequestType & USB_DIR_IN) ||
|
| 410 | !setup->wLength;
|
| 411 | dev_WARN_ONCE(&dev->dev, (usb_pipeout(urb->pipe) != is_out),
|
| 412 | "BOGUS control dir, pipe %x doesn't match bRequestType %x\n",
|
| 413 | urb->pipe, setup->bRequestType);
|
| 414 | if (le16_to_cpu(setup->wLength) != urb->transfer_buffer_length) {
|
| 415 | dev_dbg(&dev->dev, "BOGUS control len %d doesn't match transfer length %d\n",
|
| 416 | le16_to_cpu(setup->wLength),
|
| 417 | urb->transfer_buffer_length);
|
| 418 | return -EBADR;
|
| 419 | }
|
| 420 | } else {
|
| 421 | is_out = usb_endpoint_dir_out(&ep->desc);
|
| 422 | }
|
| 423 |
|
| 424 |
|
| 425 | urb->transfer_flags &= ~(URB_DIR_MASK | URB_DMA_MAP_SINGLE |
|
| 426 | URB_DMA_MAP_PAGE | URB_DMA_MAP_SG | URB_MAP_LOCAL |
|
| 427 | URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL |
|
| 428 | URB_DMA_SG_COMBINED);
|
| 429 | urb->transfer_flags |= (is_out ? URB_DIR_OUT : URB_DIR_IN);
|
| 430 | kmsan_handle_urb(urb, is_out);
|
| 431 |
|
| 432 | if (xfertype != USB_ENDPOINT_XFER_CONTROL &&
|
| 433 | dev->state < USB_STATE_CONFIGURED)
|
| 434 | return -ENODEV;
|
| 435 |
|
| 436 | max = usb_endpoint_maxp(&ep->desc);
|
| 437 | is_eusb2_isoch_double = usb_endpoint_is_hs_isoc_double(dev, ep);
|
| 438 | if (!max && !is_eusb2_isoch_double) {
|
| 439 | dev_dbg(&dev->dev,
|
| 440 | "bogus endpoint ep%d%s in %s (bad maxpacket %d)\n",
|
| 441 | usb_endpoint_num(&ep->desc), is_out ? "out" : "in",
|
| 442 | __func__, max);
|
| 443 | return -EMSGSIZE;
|
| 444 | }
|
| 445 |
|
| 446 | |
| 447 | * but drivers only control those sizes for ISO.
|
| 448 | * while we're checking, initialize return status.
|
| 449 |
|
| 450 | if (xfertype == USB_ENDPOINT_XFER_ISOC) {
|
| 451 | int n, len;
|
| 452 |
|
| 453 | |
| 454 | * 3 packets each
|
| 455 |
|
| 456 | if (dev->speed >= USB_SPEED_SUPER) {
|
| 457 | int burst = 1 + ep->ss_ep_comp.bMaxBurst;
|
| 458 | int mult = USB_SS_MULT(ep->ss_ep_comp.bmAttributes);
|
| 459 | max *= burst;
|
| 460 | max *= mult;
|
| 461 | }
|
| 462 |
|
| 463 | if (dev->speed == USB_SPEED_SUPER_PLUS &&
|
| 464 | USB_SS_SSP_ISOC_COMP(ep->ss_ep_comp.bmAttributes)) {
|
| 465 | struct usb_ssp_isoc_ep_comp_descriptor *isoc_ep_comp;
|
| 466 |
|
| 467 | isoc_ep_comp = &ep->ssp_isoc_ep_comp;
|
| 468 | max = le32_to_cpu(isoc_ep_comp->dwBytesPerInterval);
|
| 469 | }
|
| 470 |
|
| 471 |
|
| 472 | if (dev->speed == USB_SPEED_HIGH) {
|
| 473 | if (is_eusb2_isoch_double)
|
| 474 | max = le32_to_cpu(ep->eusb2_isoc_ep_comp.dwBytesPerInterval);
|
| 475 | else
|
| 476 | max *= usb_endpoint_maxp_mult(&ep->desc);
|
| 477 | }
|
| 478 |
|
| 479 | if (urb->number_of_packets <= 0)
|
| 480 | return -EINVAL;
|
| 481 | for (n = 0; n < urb->number_of_packets; n++) {
|
| 482 | len = urb->iso_frame_desc[n].length;
|
| 483 | if (len < 0 || len > max)
|
| 484 | return -EMSGSIZE;
|
| 485 | urb->iso_frame_desc[n].status = -EXDEV;
|
| 486 | urb->iso_frame_desc[n].actual_length = 0;
|
| 487 | }
|
| 488 | } else if (urb->num_sgs && !urb->dev->bus->no_sg_constraint) {
|
| 489 | struct scatterlist *sg;
|
| 490 | int i;
|
| 491 |
|
| 492 | for_each_sg(urb->sg, sg, urb->num_sgs - 1, i)
|
| 493 | if (sg->length % max)
|
| 494 | return -EINVAL;
|
| 495 | }
|
| 496 |
|
| 497 |
|
| 498 | if (urb->transfer_buffer_length > INT_MAX)
|
| 499 | return -EMSGSIZE;
|
| 500 |
|
| 501 | |
| 502 | * stuff that drivers shouldn't do, but which shouldn't
|
| 503 | * cause problems in HCDs if they get it wrong.
|
| 504 |
|
| 505 |
|
| 506 |
|
| 507 | if (usb_pipe_type_check(urb->dev, urb->pipe))
|
| 508 | dev_warn_once(&dev->dev, "BOGUS urb xfer, pipe %x != type %x\n",
|
| 509 | usb_pipetype(urb->pipe), pipetypes[xfertype]);
|
| 510 |
|
| 511 |
|
| 512 | allowed = (URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT | URB_DIR_MASK |
|
| 513 | URB_FREE_BUFFER);
|
| 514 | switch (xfertype) {
|
| 515 | case USB_ENDPOINT_XFER_BULK:
|
| 516 | case USB_ENDPOINT_XFER_INT:
|
| 517 | if (is_out)
|
| 518 | allowed |= URB_ZERO_PACKET;
|
| 519 | fallthrough;
|
| 520 | default:
|
| 521 | if (!is_out)
|
| 522 | allowed |= URB_SHORT_NOT_OK;
|
| 523 | break;
|
| 524 | case USB_ENDPOINT_XFER_ISOC:
|
| 525 | allowed |= URB_ISO_ASAP;
|
| 526 | break;
|
| 527 | }
|
| 528 | allowed &= urb->transfer_flags;
|
| 529 |
|
| 530 |
|
| 531 | if (allowed != urb->transfer_flags)
|
| 532 | dev_WARN(&dev->dev, "BOGUS urb flags, %x --> %x\n",
|
| 533 | urb->transfer_flags, allowed);
|
| 534 |
|
| 535 | |
| 536 | * Force periodic transfer intervals to be legal values that are
|
| 537 | * a power of two (so HCDs don't need to).
|
| 538 | *
|
| 539 | * FIXME want bus->{intr,iso}_sched_horizon values here. Each HC
|
| 540 | * supports different values... this uses EHCI/UHCI defaults (and
|
| 541 | * EHCI can use smaller non-default values).
|
| 542 |
|
| 543 | switch (xfertype) {
|
| 544 | case USB_ENDPOINT_XFER_ISOC:
|
| 545 | case USB_ENDPOINT_XFER_INT:
|
| 546 |
|
| 547 | if (urb->interval <= 0)
|
| 548 | return -EINVAL;
|
| 549 |
|
| 550 |
|
| 551 | switch (dev->speed) {
|
| 552 | case USB_SPEED_SUPER_PLUS:
|
| 553 | case USB_SPEED_SUPER:
|
| 554 |
|
| 555 | if (urb->interval > (1 << 15))
|
| 556 | return -EINVAL;
|
| 557 | max = 1 << 15;
|
| 558 | break;
|
| 559 | case USB_SPEED_HIGH:
|
| 560 |
|
| 561 | if (urb->interval > (1024 * 8))
|
| 562 | urb->interval = 1024 * 8;
|
| 563 | max = 1024 * 8;
|
| 564 | break;
|
| 565 | case USB_SPEED_FULL:
|
| 566 | case USB_SPEED_LOW:
|
| 567 | if (xfertype == USB_ENDPOINT_XFER_INT) {
|
| 568 | if (urb->interval > 255)
|
| 569 | return -EINVAL;
|
| 570 |
|
| 571 | max = 128;
|
| 572 | } else {
|
| 573 | if (urb->interval > 1024)
|
| 574 | urb->interval = 1024;
|
| 575 |
|
| 576 | max = 1024;
|
| 577 | }
|
| 578 | break;
|
| 579 | default:
|
| 580 | return -EINVAL;
|
| 581 | }
|
| 582 |
|
| 583 | urb->interval = min(max, 1 << ilog2(urb->interval));
|
| 584 | }
|
| 585 |
|
| 586 | return usb_hcd_submit_urb(urb, mem_flags);
|
| 587 | }
|
| 588 | EXPORT_SYMBOL_GPL(usb_submit_urb);
|
| 589 |
|
| 590 |
|
| 591 |
|
| 592 | |
| 593 | * usb_unlink_urb - abort/cancel a transfer request for an endpoint
|
| 594 | * @urb: pointer to urb describing a previously submitted request,
|
| 595 | * may be NULL
|
| 596 | *
|
| 597 | * This routine cancels an in-progress request. URBs complete only once
|
| 598 | * per submission, and may be canceled only once per submission.
|
| 599 | * Successful cancellation means termination of @urb will be expedited
|
| 600 | * and the completion handler will be called with a status code
|
| 601 | * indicating that the request has been canceled (rather than any other
|
| 602 | * code).
|
| 603 | *
|
| 604 | * Drivers should not call this routine or related routines, such as
|
| 605 | * usb_kill_urb(), after their disconnect method has returned. The
|
| 606 | * disconnect function should synchronize with a driver's I/O routines
|
| 607 | * to insure that all URB-related activity has completed before it returns.
|
| 608 | *
|
| 609 | * This request is asynchronous, however the HCD might call the ->complete()
|
| 610 | * callback during unlink. Therefore when drivers call usb_unlink_urb(), they
|
| 611 | * must not hold any locks that may be taken by the completion function.
|
| 612 | * Success is indicated by returning -EINPROGRESS, at which time the URB will
|
| 613 | * probably not yet have been given back to the device driver. When it is
|
| 614 | * eventually called, the completion function will see @urb->status ==
|
| 615 | * -ECONNRESET.
|
| 616 | * Failure is indicated by usb_unlink_urb() returning any other value.
|
| 617 | * Unlinking will fail when @urb is not currently "linked" (i.e., it was
|
| 618 | * never submitted, or it was unlinked before, or the hardware is already
|
| 619 | * finished with it), even if the completion handler has not yet run.
|
| 620 | *
|
| 621 | * The URB must not be deallocated while this routine is running. In
|
| 622 | * particular, when a driver calls this routine, it must insure that the
|
| 623 | * completion handler cannot deallocate the URB.
|
| 624 | *
|
| 625 | * Return: -EINPROGRESS on success. See description for other values on
|
| 626 | * failure.
|
| 627 | *
|
| 628 | * Unlinking and Endpoint Queues:
|
| 629 | *
|
| 630 | * [The behaviors and guarantees described below do not apply to virtual
|
| 631 | * root hubs but only to endpoint queues for physical USB devices.]
|
| 632 | *
|
| 633 | * Host Controller Drivers (HCDs) place all the URBs for a particular
|
| 634 | * endpoint in a queue. Normally the queue advances as the controller
|
| 635 | * hardware processes each request. But when an URB terminates with an
|
| 636 | * error its queue generally stops (see below), at least until that URB's
|
| 637 | * completion routine returns. It is guaranteed that a stopped queue
|
| 638 | * will not restart until all its unlinked URBs have been fully retired,
|
| 639 | * with their completion routines run, even if that's not until some time
|
| 640 | * after the original completion handler returns. The same behavior and
|
| 641 | * guarantee apply when an URB terminates because it was unlinked.
|
| 642 | *
|
| 643 | * Bulk and interrupt endpoint queues are guaranteed to stop whenever an
|
| 644 | * URB terminates with any sort of error, including -ECONNRESET, -ENOENT,
|
| 645 | * and -EREMOTEIO. Control endpoint queues behave the same way except
|
| 646 | * that they are not guaranteed to stop for -EREMOTEIO errors. Queues
|
| 647 | * for isochronous endpoints are treated differently, because they must
|
| 648 | * advance at fixed rates. Such queues do not stop when an URB
|
| 649 | * encounters an error or is unlinked. An unlinked isochronous URB may
|
| 650 | * leave a gap in the stream of packets; it is undefined whether such
|
| 651 | * gaps can be filled in.
|
| 652 | *
|
| 653 | * Note that early termination of an URB because a short packet was
|
| 654 | * received will generate a -EREMOTEIO error if and only if the
|
| 655 | * URB_SHORT_NOT_OK flag is set. By setting this flag, USB device
|
| 656 | * drivers can build deep queues for large or complex bulk transfers
|
| 657 | * and clean them up reliably after any sort of aborted transfer by
|
| 658 | * unlinking all pending URBs at the first fault.
|
| 659 | *
|
| 660 | * When a control URB terminates with an error other than -EREMOTEIO, it
|
| 661 | * is quite likely that the status stage of the transfer will not take
|
| 662 | * place.
|
| 663 |
|
| 664 | int usb_unlink_urb(struct urb *urb)
|
| 665 | {
|
| 666 | if (!urb)
|
| 667 | return -EINVAL;
|
| 668 | if (!urb->dev)
|
| 669 | return -ENODEV;
|
| 670 | if (!urb->ep)
|
| 671 | return -EIDRM;
|
| 672 | return usb_hcd_unlink_urb(urb, -ECONNRESET);
|
| 673 | }
|
| 674 | EXPORT_SYMBOL_GPL(usb_unlink_urb);
|
| 675 |
|
| 676 | |
| 677 | * usb_kill_urb - cancel a transfer request and wait for it to finish
|
| 678 | * @urb: pointer to URB describing a previously submitted request,
|
| 679 | * may be NULL
|
| 680 | *
|
| 681 | * This routine cancels an in-progress request. It is guaranteed that
|
| 682 | * upon return all completion handlers will have finished and the URB
|
| 683 | * will be totally idle and available for reuse. These features make
|
| 684 | * this an ideal way to stop I/O in a disconnect() callback or close()
|
| 685 | * function. If the request has not already finished or been unlinked
|
| 686 | * the completion handler will see urb->status == -ENOENT.
|
| 687 | *
|
| 688 | * While the routine is running, attempts to resubmit the URB will fail
|
| 689 | * with error -EPERM. Thus even if the URB's completion handler always
|
| 690 | * tries to resubmit, it will not succeed and the URB will become idle.
|
| 691 | *
|
| 692 | * The URB must not be deallocated while this routine is running. In
|
| 693 | * particular, when a driver calls this routine, it must insure that the
|
| 694 | * completion handler cannot deallocate the URB.
|
| 695 | *
|
| 696 | * This routine may not be used in an interrupt context (such as a bottom
|
| 697 | * half or a completion handler), or when holding a spinlock, or in other
|
| 698 | * situations where the caller can't schedule().
|
| 699 | *
|
| 700 | * This routine should not be called by a driver after its disconnect
|
| 701 | * method has returned.
|
| 702 |
|
| 703 | void usb_kill_urb(struct urb *urb)
|
| 704 | {
|
| 705 | might_sleep();
|
| 706 | if (!(urb && urb->dev && urb->ep))
|
| 707 | return;
|
| 708 | atomic_inc(&urb->reject);
|
| 709 | |
| 710 | * Order the write of urb->reject above before the read
|
| 711 | * of urb->use_count below. Pairs with the barriers in
|
| 712 | * __usb_hcd_giveback_urb() and usb_hcd_submit_urb().
|
| 713 |
|
| 714 | smp_mb__after_atomic();
|
| 715 |
|
| 716 | usb_hcd_unlink_urb(urb, -ENOENT);
|
| 717 | wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0);
|
| 718 |
|
| 719 | atomic_dec(&urb->reject);
|
| 720 | }
|
| 721 | EXPORT_SYMBOL_GPL(usb_kill_urb);
|
| 722 |
|
| 723 | |
| 724 | * usb_poison_urb - reliably kill a transfer and prevent further use of an URB
|
| 725 | * @urb: pointer to URB describing a previously submitted request,
|
| 726 | * may be NULL
|
| 727 | *
|
| 728 | * This routine cancels an in-progress request. It is guaranteed that
|
| 729 | * upon return all completion handlers will have finished and the URB
|
| 730 | * will be totally idle and cannot be reused. These features make
|
| 731 | * this an ideal way to stop I/O in a disconnect() callback.
|
| 732 | * If the request has not already finished or been unlinked
|
| 733 | * the completion handler will see urb->status == -ENOENT.
|
| 734 | *
|
| 735 | * After and while the routine runs, attempts to resubmit the URB will fail
|
| 736 | * with error -EPERM. Thus even if the URB's completion handler always
|
| 737 | * tries to resubmit, it will not succeed and the URB will become idle.
|
| 738 | *
|
| 739 | * The URB must not be deallocated while this routine is running. In
|
| 740 | * particular, when a driver calls this routine, it must insure that the
|
| 741 | * completion handler cannot deallocate the URB.
|
| 742 | *
|
| 743 | * This routine may not be used in an interrupt context (such as a bottom
|
| 744 | * half or a completion handler), or when holding a spinlock, or in other
|
| 745 | * situations where the caller can't schedule().
|
| 746 | *
|
| 747 | * This routine should not be called by a driver after its disconnect
|
| 748 | * method has returned.
|
| 749 |
|
| 750 | void usb_poison_urb(struct urb *urb)
|
| 751 | {
|
| 752 | might_sleep();
|
| 753 | if (!urb)
|
| 754 | return;
|
| 755 | atomic_inc(&urb->reject);
|
| 756 | |
| 757 | * Order the write of urb->reject above before the read
|
| 758 | * of urb->use_count below. Pairs with the barriers in
|
| 759 | * __usb_hcd_giveback_urb() and usb_hcd_submit_urb().
|
| 760 |
|
| 761 | smp_mb__after_atomic();
|
| 762 |
|
| 763 | if (!urb->dev || !urb->ep)
|
| 764 | return;
|
| 765 |
|
| 766 | usb_hcd_unlink_urb(urb, -ENOENT);
|
| 767 | wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0);
|
| 768 | }
|
| 769 | EXPORT_SYMBOL_GPL(usb_poison_urb);
|
| 770 |
|
| 771 | void usb_unpoison_urb(struct urb *urb)
|
| 772 | {
|
| 773 | if (!urb)
|
| 774 | return;
|
| 775 |
|
| 776 | atomic_dec(&urb->reject);
|
| 777 | }
|
| 778 | EXPORT_SYMBOL_GPL(usb_unpoison_urb);
|
| 779 |
|
| 780 | |
| 781 | * usb_block_urb - reliably prevent further use of an URB
|
| 782 | * @urb: pointer to URB to be blocked, may be NULL
|
| 783 | *
|
| 784 | * After the routine has run, attempts to resubmit the URB will fail
|
| 785 | * with error -EPERM. Thus even if the URB's completion handler always
|
| 786 | * tries to resubmit, it will not succeed and the URB will become idle.
|
| 787 | *
|
| 788 | * The URB must not be deallocated while this routine is running. In
|
| 789 | * particular, when a driver calls this routine, it must insure that the
|
| 790 | * completion handler cannot deallocate the URB.
|
| 791 |
|
| 792 | void usb_block_urb(struct urb *urb)
|
| 793 | {
|
| 794 | if (!urb)
|
| 795 | return;
|
| 796 |
|
| 797 | atomic_inc(&urb->reject);
|
| 798 | }
|
| 799 | EXPORT_SYMBOL_GPL(usb_block_urb);
|
| 800 |
|
| 801 | |
| 802 | * usb_kill_anchored_urbs - kill all URBs associated with an anchor
|
| 803 | * @anchor: anchor the requests are bound to
|
| 804 | *
|
| 805 | * This kills all outstanding URBs starting from the back of the queue,
|
| 806 | * with guarantee that no completer callbacks will take place from the
|
| 807 | * anchor after this function returns.
|
| 808 | *
|
| 809 | * This routine should not be called by a driver after its disconnect
|
| 810 | * method has returned.
|
| 811 |
|
| 812 | void usb_kill_anchored_urbs(struct usb_anchor *anchor)
|
| 813 | {
|
| 814 | struct urb *victim;
|
| 815 | int surely_empty;
|
| 816 |
|
| 817 | do {
|
| 818 | spin_lock_irq(&anchor->lock);
|
| 819 | while (!list_empty(&anchor->urb_list)) {
|
| 820 | victim = list_entry(anchor->urb_list.prev,
|
| 821 | struct urb, anchor_list);
|
| 822 |
|
| 823 | usb_get_urb(victim);
|
| 824 | spin_unlock_irq(&anchor->lock);
|
| 825 |
|
| 826 | usb_kill_urb(victim);
|
| 827 | usb_put_urb(victim);
|
| 828 | spin_lock_irq(&anchor->lock);
|
| 829 | }
|
| 830 | surely_empty = usb_anchor_check_wakeup(anchor);
|
| 831 |
|
| 832 | spin_unlock_irq(&anchor->lock);
|
| 833 | cpu_relax();
|
| 834 | } while (!surely_empty);
|
| 835 | }
|
| 836 | EXPORT_SYMBOL_GPL(usb_kill_anchored_urbs);
|
| 837 |
|
| 838 |
|
| 839 | |
| 840 | * usb_poison_anchored_urbs - cease all traffic from an anchor
|
| 841 | * @anchor: anchor the requests are bound to
|
| 842 | *
|
| 843 | * this allows all outstanding URBs to be poisoned starting
|
| 844 | * from the back of the queue. Newly added URBs will also be
|
| 845 | * poisoned
|
| 846 | *
|
| 847 | * This routine should not be called by a driver after its disconnect
|
| 848 | * method has returned.
|
| 849 |
|
| 850 | void usb_poison_anchored_urbs(struct usb_anchor *anchor)
|
| 851 | {
|
| 852 | struct urb *victim;
|
| 853 | int surely_empty;
|
| 854 |
|
| 855 | do {
|
| 856 | spin_lock_irq(&anchor->lock);
|
| 857 | anchor->poisoned = 1;
|
| 858 | while (!list_empty(&anchor->urb_list)) {
|
| 859 | victim = list_entry(anchor->urb_list.prev,
|
| 860 | struct urb, anchor_list);
|
| 861 |
|
| 862 | usb_get_urb(victim);
|
| 863 | spin_unlock_irq(&anchor->lock);
|
| 864 |
|
| 865 | usb_poison_urb(victim);
|
| 866 | usb_put_urb(victim);
|
| 867 | spin_lock_irq(&anchor->lock);
|
| 868 | }
|
| 869 | surely_empty = usb_anchor_check_wakeup(anchor);
|
| 870 |
|
| 871 | spin_unlock_irq(&anchor->lock);
|
| 872 | cpu_relax();
|
| 873 | } while (!surely_empty);
|
| 874 | }
|
| 875 | EXPORT_SYMBOL_GPL(usb_poison_anchored_urbs);
|
| 876 |
|
| 877 | |
| 878 | * usb_unpoison_anchored_urbs - let an anchor be used successfully again
|
| 879 | * @anchor: anchor the requests are bound to
|
| 880 | *
|
| 881 | * Reverses the effect of usb_poison_anchored_urbs
|
| 882 | * the anchor can be used normally after it returns
|
| 883 |
|
| 884 | void usb_unpoison_anchored_urbs(struct usb_anchor *anchor)
|
| 885 | {
|
| 886 | unsigned long flags;
|
| 887 | struct urb *lazarus;
|
| 888 |
|
| 889 | spin_lock_irqsave(&anchor->lock, flags);
|
| 890 | list_for_each_entry(lazarus, &anchor->urb_list, anchor_list) {
|
| 891 | usb_unpoison_urb(lazarus);
|
| 892 | }
|
| 893 | anchor->poisoned = 0;
|
| 894 | spin_unlock_irqrestore(&anchor->lock, flags);
|
| 895 | }
|
| 896 | EXPORT_SYMBOL_GPL(usb_unpoison_anchored_urbs);
|
| 897 |
|
| 898 | |
| 899 | * usb_anchor_suspend_wakeups
|
| 900 | * @anchor: the anchor you want to suspend wakeups on
|
| 901 | *
|
| 902 | * Call this to stop the last urb being unanchored from waking up any
|
| 903 | * usb_wait_anchor_empty_timeout waiters. This is used in the hcd urb give-
|
| 904 | * back path to delay waking up until after the completion handler has run.
|
| 905 |
|
| 906 | void usb_anchor_suspend_wakeups(struct usb_anchor *anchor)
|
| 907 | {
|
| 908 | if (anchor)
|
| 909 | atomic_inc(&anchor->suspend_wakeups);
|
| 910 | }
|
| 911 | EXPORT_SYMBOL_GPL(usb_anchor_suspend_wakeups);
|
| 912 |
|
| 913 | |
| 914 | * usb_anchor_resume_wakeups
|
| 915 | * @anchor: the anchor you want to resume wakeups on
|
| 916 | *
|
| 917 | * Allow usb_wait_anchor_empty_timeout waiters to be woken up again, and
|
| 918 | * wake up any current waiters if the anchor is empty.
|
| 919 |
|
| 920 | void usb_anchor_resume_wakeups(struct usb_anchor *anchor)
|
| 921 | {
|
| 922 | if (!anchor)
|
| 923 | return;
|
| 924 |
|
| 925 | atomic_dec(&anchor->suspend_wakeups);
|
| 926 | if (usb_anchor_check_wakeup(anchor))
|
| 927 | wake_up(&anchor->wait);
|
| 928 | }
|
| 929 | EXPORT_SYMBOL_GPL(usb_anchor_resume_wakeups);
|
| 930 |
|
| 931 | |
| 932 | * usb_wait_anchor_empty_timeout - wait for an anchor to be unused
|
| 933 | * @anchor: the anchor you want to become unused
|
| 934 | * @timeout: how long you are willing to wait in milliseconds
|
| 935 | *
|
| 936 | * Call this is you want to be sure all an anchor's
|
| 937 | * URBs have finished
|
| 938 | *
|
| 939 | * Return: Non-zero if the anchor became unused. Zero on timeout.
|
| 940 |
|
| 941 | int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor,
|
| 942 | unsigned int timeout)
|
| 943 | {
|
| 944 | return wait_event_timeout(anchor->wait,
|
| 945 | usb_anchor_check_wakeup(anchor),
|
| 946 | msecs_to_jiffies(timeout));
|
| 947 | }
|
| 948 | EXPORT_SYMBOL_GPL(usb_wait_anchor_empty_timeout);
|
| 949 |
|
| 950 | |
| 951 | * usb_get_from_anchor - get an anchor's oldest urb
|
| 952 | * @anchor: the anchor whose urb you want
|
| 953 | *
|
| 954 | * This will take the oldest urb from an anchor,
|
| 955 | * unanchor and return it
|
| 956 | *
|
| 957 | * Return: The oldest urb from @anchor, or %NULL if @anchor has no
|
| 958 | * urbs associated with it.
|
| 959 |
|
| 960 | struct urb *usb_get_from_anchor(struct usb_anchor *anchor)
|
| 961 | {
|
| 962 | struct urb *victim;
|
| 963 | unsigned long flags;
|
| 964 |
|
| 965 | spin_lock_irqsave(&anchor->lock, flags);
|
| 966 | if (!list_empty(&anchor->urb_list)) {
|
| 967 | victim = list_entry(anchor->urb_list.next, struct urb,
|
| 968 | anchor_list);
|
| 969 | usb_get_urb(victim);
|
| 970 | __usb_unanchor_urb(victim, anchor);
|
| 971 | } else {
|
| 972 | victim = NULL;
|
| 973 | }
|
| 974 | spin_unlock_irqrestore(&anchor->lock, flags);
|
| 975 |
|
| 976 | return victim;
|
| 977 | }
|
| 978 |
|
| 979 | EXPORT_SYMBOL_GPL(usb_get_from_anchor);
|
| 980 |
|
| 981 | |
| 982 | * usb_scuttle_anchored_urbs - unanchor all an anchor's urbs
|
| 983 | * @anchor: the anchor whose urbs you want to unanchor
|
| 984 | *
|
| 985 | * use this to get rid of all an anchor's urbs
|
| 986 |
|
| 987 | void usb_scuttle_anchored_urbs(struct usb_anchor *anchor)
|
| 988 | {
|
| 989 | struct urb *victim;
|
| 990 | unsigned long flags;
|
| 991 | int surely_empty;
|
| 992 |
|
| 993 | do {
|
| 994 | spin_lock_irqsave(&anchor->lock, flags);
|
| 995 | while (!list_empty(&anchor->urb_list)) {
|
| 996 | victim = list_entry(anchor->urb_list.prev,
|
| 997 | struct urb, anchor_list);
|
| 998 | __usb_unanchor_urb(victim, anchor);
|
| 999 | }
|
| 1000 | surely_empty = usb_anchor_check_wakeup(anchor);
|
| 1001 |
|
| 1002 | spin_unlock_irqrestore(&anchor->lock, flags);
|
| 1003 | cpu_relax();
|
| 1004 | } while (!surely_empty);
|
| 1005 | }
|
| 1006 |
|
| 1007 | EXPORT_SYMBOL_GPL(usb_scuttle_anchored_urbs);
|
| 1008 |
|
| 1009 | |
| 1010 | * usb_anchor_empty - is an anchor empty
|
| 1011 | * @anchor: the anchor you want to query
|
| 1012 | *
|
| 1013 | * Return: 1 if the anchor has no urbs associated with it.
|
| 1014 |
|
| 1015 | int usb_anchor_empty(struct usb_anchor *anchor)
|
| 1016 | {
|
| 1017 | return list_empty(&anchor->urb_list);
|
| 1018 | }
|
| 1019 |
|
| 1020 | EXPORT_SYMBOL_GPL(usb_anchor_empty);
|
| 1021 |
|