2 * message.c - synchronous message handling
5 #include <linux/pci.h> /* for scatterlist macros */
7 #include <linux/module.h>
8 #include <linux/slab.h>
9 #include <linux/init.h>
11 #include <linux/timer.h>
12 #include <linux/ctype.h>
13 #include <linux/device.h>
14 #include <linux/scatterlist.h>
15 #include <linux/usb/quirks.h>
16 #include <asm/byteorder.h>
18 #include "hcd.h" /* for usbcore internals */
22 struct completion done;
26 static void usb_api_blocking_completion(struct urb *urb)
28 struct api_context *ctx = urb->context;
30 ctx->status = urb->status;
36 * Starts urb and waits for completion or timeout. Note that this call
37 * is NOT interruptible. Many device driver i/o requests should be
38 * interruptible and therefore these drivers should implement their
39 * own interruptible routines.
41 static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length)
43 struct api_context ctx;
47 init_completion(&ctx.done);
49 urb->actual_length = 0;
50 retval = usb_submit_urb(urb, GFP_NOIO);
54 expire = timeout ? msecs_to_jiffies(timeout) : MAX_SCHEDULE_TIMEOUT;
55 if (!wait_for_completion_timeout(&ctx.done, expire)) {
57 retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status);
59 dev_dbg(&urb->dev->dev,
60 "%s timed out on ep%d%s len=%d/%d\n",
62 usb_endpoint_num(&urb->ep->desc),
63 usb_urb_dir_in(urb) ? "in" : "out",
65 urb->transfer_buffer_length);
70 *actual_length = urb->actual_length;
76 /*-------------------------------------------------------------------*/
77 /* returns status (negative) or length (positive) */
78 static int usb_internal_control_msg(struct usb_device *usb_dev,
80 struct usb_ctrlrequest *cmd,
81 void *data, int len, int timeout)
87 urb = usb_alloc_urb(0, GFP_NOIO);
91 usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data,
92 len, usb_api_blocking_completion, NULL);
94 retv = usb_start_wait_urb(urb, timeout, &length);
102 * usb_control_msg - Builds a control urb, sends it off and waits for completion
103 * @dev: pointer to the usb device to send the message to
104 * @pipe: endpoint "pipe" to send the message to
105 * @request: USB message request value
106 * @requesttype: USB message request type value
107 * @value: USB message value
108 * @index: USB message index value
109 * @data: pointer to the data to send
110 * @size: length in bytes of the data to send
111 * @timeout: time in msecs to wait for the message to complete before timing
112 * out (if 0 the wait is forever)
114 * Context: !in_interrupt ()
116 * This function sends a simple control message to a specified endpoint and
117 * waits for the message to complete, or timeout.
119 * If successful, it returns the number of bytes transferred, otherwise a
120 * negative error number.
122 * Don't use this function from within an interrupt context, like a bottom half
123 * handler. If you need an asynchronous message, or need to send a message
124 * from within interrupt context, use usb_submit_urb().
125 * If a thread in your driver uses this call, make sure your disconnect()
126 * method can wait for it to complete. Since you don't have a handle on the
127 * URB used, you can't cancel the request.
129 int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
130 __u8 requesttype, __u16 value, __u16 index, void *data,
131 __u16 size, int timeout)
133 struct usb_ctrlrequest *dr;
136 dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
140 dr->bRequestType = requesttype;
141 dr->bRequest = request;
142 dr->wValue = cpu_to_le16(value);
143 dr->wIndex = cpu_to_le16(index);
144 dr->wLength = cpu_to_le16(size);
146 /* dbg("usb_control_msg"); */
148 ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout);
154 EXPORT_SYMBOL_GPL(usb_control_msg);
157 * usb_interrupt_msg - Builds an interrupt urb, sends it off and waits for completion
158 * @usb_dev: pointer to the usb device to send the message to
159 * @pipe: endpoint "pipe" to send the message to
160 * @data: pointer to the data to send
161 * @len: length in bytes of the data to send
162 * @actual_length: pointer to a location to put the actual length transferred
164 * @timeout: time in msecs to wait for the message to complete before
165 * timing out (if 0 the wait is forever)
167 * Context: !in_interrupt ()
169 * This function sends a simple interrupt message to a specified endpoint and
170 * waits for the message to complete, or timeout.
172 * If successful, it returns 0, otherwise a negative error number. The number
173 * of actual bytes transferred will be stored in the actual_length paramater.
175 * Don't use this function from within an interrupt context, like a bottom half
176 * handler. If you need an asynchronous message, or need to send a message
177 * from within interrupt context, use usb_submit_urb() If a thread in your
178 * driver uses this call, make sure your disconnect() method can wait for it to
179 * complete. Since you don't have a handle on the URB used, you can't cancel
182 int usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe,
183 void *data, int len, int *actual_length, int timeout)
185 return usb_bulk_msg(usb_dev, pipe, data, len, actual_length, timeout);
187 EXPORT_SYMBOL_GPL(usb_interrupt_msg);
190 * usb_bulk_msg - Builds a bulk urb, sends it off and waits for completion
191 * @usb_dev: pointer to the usb device to send the message to
192 * @pipe: endpoint "pipe" to send the message to
193 * @data: pointer to the data to send
194 * @len: length in bytes of the data to send
195 * @actual_length: pointer to a location to put the actual length transferred
197 * @timeout: time in msecs to wait for the message to complete before
198 * timing out (if 0 the wait is forever)
200 * Context: !in_interrupt ()
202 * This function sends a simple bulk message to a specified endpoint
203 * and waits for the message to complete, or timeout.
205 * If successful, it returns 0, otherwise a negative error number. The number
206 * of actual bytes transferred will be stored in the actual_length paramater.
208 * Don't use this function from within an interrupt context, like a bottom half
209 * handler. If you need an asynchronous message, or need to send a message
210 * from within interrupt context, use usb_submit_urb() If a thread in your
211 * driver uses this call, make sure your disconnect() method can wait for it to
212 * complete. Since you don't have a handle on the URB used, you can't cancel
215 * Because there is no usb_interrupt_msg() and no USBDEVFS_INTERRUPT ioctl,
216 * users are forced to abuse this routine by using it to submit URBs for
217 * interrupt endpoints. We will take the liberty of creating an interrupt URB
218 * (with the default interval) if the target is an interrupt endpoint.
220 int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
221 void *data, int len, int *actual_length, int timeout)
224 struct usb_host_endpoint *ep;
226 ep = (usb_pipein(pipe) ? usb_dev->ep_in : usb_dev->ep_out)
227 [usb_pipeendpoint(pipe)];
231 urb = usb_alloc_urb(0, GFP_KERNEL);
235 if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
236 USB_ENDPOINT_XFER_INT) {
237 pipe = (pipe & ~(3 << 30)) | (PIPE_INTERRUPT << 30);
238 usb_fill_int_urb(urb, usb_dev, pipe, data, len,
239 usb_api_blocking_completion, NULL,
242 usb_fill_bulk_urb(urb, usb_dev, pipe, data, len,
243 usb_api_blocking_completion, NULL);
245 return usb_start_wait_urb(urb, timeout, actual_length);
247 EXPORT_SYMBOL_GPL(usb_bulk_msg);
249 /*-------------------------------------------------------------------*/
251 static void sg_clean(struct usb_sg_request *io)
254 while (io->entries--)
255 usb_free_urb(io->urbs [io->entries]);
259 if (io->dev->dev.dma_mask != NULL)
260 usb_buffer_unmap_sg(io->dev, usb_pipein(io->pipe),
265 static void sg_complete(struct urb *urb)
267 struct usb_sg_request *io = urb->context;
268 int status = urb->status;
270 spin_lock(&io->lock);
272 /* In 2.5 we require hcds' endpoint queues not to progress after fault
273 * reports, until the completion callback (this!) returns. That lets
274 * device driver code (like this routine) unlink queued urbs first,
275 * if it needs to, since the HC won't work on them at all. So it's
276 * not possible for page N+1 to overwrite page N, and so on.
278 * That's only for "hard" faults; "soft" faults (unlinks) sometimes
279 * complete before the HCD can get requests away from hardware,
280 * though never during cleanup after a hard fault.
283 && (io->status != -ECONNRESET
284 || status != -ECONNRESET)
285 && urb->actual_length) {
286 dev_err(io->dev->bus->controller,
287 "dev %s ep%d%s scatterlist error %d/%d\n",
289 usb_endpoint_num(&urb->ep->desc),
290 usb_urb_dir_in(urb) ? "in" : "out",
295 if (io->status == 0 && status && status != -ECONNRESET) {
296 int i, found, retval;
300 /* the previous urbs, and this one, completed already.
301 * unlink pending urbs so they won't rx/tx bad data.
302 * careful: unlink can sometimes be synchronous...
304 spin_unlock(&io->lock);
305 for (i = 0, found = 0; i < io->entries; i++) {
306 if (!io->urbs [i] || !io->urbs [i]->dev)
309 retval = usb_unlink_urb(io->urbs [i]);
310 if (retval != -EINPROGRESS &&
313 dev_err(&io->dev->dev,
314 "%s, unlink --> %d\n",
316 } else if (urb == io->urbs [i])
319 spin_lock(&io->lock);
323 /* on the last completion, signal usb_sg_wait() */
324 io->bytes += urb->actual_length;
327 complete(&io->complete);
329 spin_unlock(&io->lock);
334 * usb_sg_init - initializes scatterlist-based bulk/interrupt I/O request
335 * @io: request block being initialized. until usb_sg_wait() returns,
336 * treat this as a pointer to an opaque block of memory,
337 * @dev: the usb device that will send or receive the data
338 * @pipe: endpoint "pipe" used to transfer the data
339 * @period: polling rate for interrupt endpoints, in frames or
340 * (for high speed endpoints) microframes; ignored for bulk
341 * @sg: scatterlist entries
342 * @nents: how many entries in the scatterlist
343 * @length: how many bytes to send from the scatterlist, or zero to
344 * send every byte identified in the list.
345 * @mem_flags: SLAB_* flags affecting memory allocations in this call
347 * Returns zero for success, else a negative errno value. This initializes a
348 * scatter/gather request, allocating resources such as I/O mappings and urb
349 * memory (except maybe memory used by USB controller drivers).
351 * The request must be issued using usb_sg_wait(), which waits for the I/O to
352 * complete (or to be canceled) and then cleans up all resources allocated by
355 * The request may be canceled with usb_sg_cancel(), either before or after
356 * usb_sg_wait() is called.
358 int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
359 unsigned pipe, unsigned period, struct scatterlist *sg,
360 int nents, size_t length, gfp_t mem_flags)
366 if (!io || !dev || !sg
367 || usb_pipecontrol(pipe)
368 || usb_pipeisoc(pipe)
372 spin_lock_init(&io->lock);
378 /* not all host controllers use DMA (like the mainstream pci ones);
379 * they can use PIO (sl811) or be software over another transport.
381 dma = (dev->dev.dma_mask != NULL);
383 io->entries = usb_buffer_map_sg(dev, usb_pipein(pipe),
388 /* initialize all the urbs we'll use */
389 if (io->entries <= 0)
392 io->urbs = kmalloc(io->entries * sizeof *io->urbs, mem_flags);
396 urb_flags = URB_NO_INTERRUPT;
398 urb_flags |= URB_NO_TRANSFER_DMA_MAP;
399 if (usb_pipein(pipe))
400 urb_flags |= URB_SHORT_NOT_OK;
402 for_each_sg(sg, sg, io->entries, i) {
405 io->urbs[i] = usb_alloc_urb(0, mem_flags);
411 io->urbs[i]->dev = NULL;
412 io->urbs[i]->pipe = pipe;
413 io->urbs[i]->interval = period;
414 io->urbs[i]->transfer_flags = urb_flags;
416 io->urbs[i]->complete = sg_complete;
417 io->urbs[i]->context = io;
420 * Some systems need to revert to PIO when DMA is temporarily
421 * unavailable. For their sakes, both transfer_buffer and
422 * transfer_dma are set when possible. However this can only
423 * work on systems without:
425 * - HIGHMEM, since DMA buffers located in high memory are
426 * not directly addressable by the CPU for PIO;
428 * - IOMMU, since dma_map_sg() is allowed to use an IOMMU to
429 * make virtually discontiguous buffers be "dma-contiguous"
430 * so that PIO and DMA need diferent numbers of URBs.
432 * So when HIGHMEM or IOMMU are in use, transfer_buffer is NULL
433 * to prevent stale pointers and to help spot bugs.
436 io->urbs[i]->transfer_dma = sg_dma_address(sg);
437 len = sg_dma_len(sg);
438 #if defined(CONFIG_HIGHMEM) || defined(CONFIG_GART_IOMMU)
439 io->urbs[i]->transfer_buffer = NULL;
441 io->urbs[i]->transfer_buffer = sg_virt(sg);
444 /* hc may use _only_ transfer_buffer */
445 io->urbs[i]->transfer_buffer = sg_virt(sg);
450 len = min_t(unsigned, len, length);
455 io->urbs[i]->transfer_buffer_length = len;
457 io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT;
459 /* transaction state */
460 io->count = io->entries;
463 init_completion(&io->complete);
470 EXPORT_SYMBOL_GPL(usb_sg_init);
473 * usb_sg_wait - synchronously execute scatter/gather request
474 * @io: request block handle, as initialized with usb_sg_init().
475 * some fields become accessible when this call returns.
476 * Context: !in_interrupt ()
478 * This function blocks until the specified I/O operation completes. It
479 * leverages the grouping of the related I/O requests to get good transfer
480 * rates, by queueing the requests. At higher speeds, such queuing can
481 * significantly improve USB throughput.
483 * There are three kinds of completion for this function.
484 * (1) success, where io->status is zero. The number of io->bytes
485 * transferred is as requested.
486 * (2) error, where io->status is a negative errno value. The number
487 * of io->bytes transferred before the error is usually less
488 * than requested, and can be nonzero.
489 * (3) cancellation, a type of error with status -ECONNRESET that
490 * is initiated by usb_sg_cancel().
492 * When this function returns, all memory allocated through usb_sg_init() or
493 * this call will have been freed. The request block parameter may still be
494 * passed to usb_sg_cancel(), or it may be freed. It could also be
495 * reinitialized and then reused.
497 * Data Transfer Rates:
499 * Bulk transfers are valid for full or high speed endpoints.
500 * The best full speed data rate is 19 packets of 64 bytes each
501 * per frame, or 1216 bytes per millisecond.
502 * The best high speed data rate is 13 packets of 512 bytes each
503 * per microframe, or 52 KBytes per millisecond.
505 * The reason to use interrupt transfers through this API would most likely
506 * be to reserve high speed bandwidth, where up to 24 KBytes per millisecond
507 * could be transferred. That capability is less useful for low or full
508 * speed interrupt endpoints, which allow at most one packet per millisecond,
509 * of at most 8 or 64 bytes (respectively).
511 void usb_sg_wait(struct usb_sg_request *io)
514 int entries = io->entries;
516 /* queue the urbs. */
517 spin_lock_irq(&io->lock);
519 while (i < entries && !io->status) {
522 io->urbs[i]->dev = io->dev;
523 retval = usb_submit_urb(io->urbs [i], GFP_ATOMIC);
525 /* after we submit, let completions or cancelations fire;
526 * we handshake using io->status.
528 spin_unlock_irq(&io->lock);
530 /* maybe we retrying will recover */
531 case -ENXIO: /* hc didn't queue this one */
534 io->urbs[i]->dev = NULL;
539 /* no error? continue immediately.
541 * NOTE: to work better with UHCI (4K I/O buffer may
542 * need 3K of TDs) it may be good to limit how many
543 * URBs are queued at once; N milliseconds?
550 /* fail any uncompleted urbs */
552 io->urbs[i]->dev = NULL;
553 io->urbs[i]->status = retval;
554 dev_dbg(&io->dev->dev, "%s, submit --> %d\n",
558 spin_lock_irq(&io->lock);
559 if (retval && (io->status == 0 || io->status == -ECONNRESET))
562 io->count -= entries - i;
564 complete(&io->complete);
565 spin_unlock_irq(&io->lock);
567 /* OK, yes, this could be packaged as non-blocking.
568 * So could the submit loop above ... but it's easier to
569 * solve neither problem than to solve both!
571 wait_for_completion(&io->complete);
575 EXPORT_SYMBOL_GPL(usb_sg_wait);
578 * usb_sg_cancel - stop scatter/gather i/o issued by usb_sg_wait()
579 * @io: request block, initialized with usb_sg_init()
581 * This stops a request after it has been started by usb_sg_wait().
582 * It can also prevents one initialized by usb_sg_init() from starting,
583 * so that call just frees resources allocated to the request.
585 void usb_sg_cancel(struct usb_sg_request *io)
589 spin_lock_irqsave(&io->lock, flags);
591 /* shut everything down, if it didn't already */
595 io->status = -ECONNRESET;
596 spin_unlock(&io->lock);
597 for (i = 0; i < io->entries; i++) {
600 if (!io->urbs [i]->dev)
602 retval = usb_unlink_urb(io->urbs [i]);
603 if (retval != -EINPROGRESS && retval != -EBUSY)
604 dev_warn(&io->dev->dev, "%s, unlink --> %d\n",
607 spin_lock(&io->lock);
609 spin_unlock_irqrestore(&io->lock, flags);
611 EXPORT_SYMBOL_GPL(usb_sg_cancel);
613 /*-------------------------------------------------------------------*/
616 * usb_get_descriptor - issues a generic GET_DESCRIPTOR request
617 * @dev: the device whose descriptor is being retrieved
618 * @type: the descriptor type (USB_DT_*)
619 * @index: the number of the descriptor
620 * @buf: where to put the descriptor
621 * @size: how big is "buf"?
622 * Context: !in_interrupt ()
624 * Gets a USB descriptor. Convenience functions exist to simplify
625 * getting some types of descriptors. Use
626 * usb_get_string() or usb_string() for USB_DT_STRING.
627 * Device (USB_DT_DEVICE) and configuration descriptors (USB_DT_CONFIG)
628 * are part of the device structure.
629 * In addition to a number of USB-standard descriptors, some
630 * devices also use class-specific or vendor-specific descriptors.
632 * This call is synchronous, and may not be used in an interrupt context.
634 * Returns the number of bytes received on success, or else the status code
635 * returned by the underlying usb_control_msg() call.
637 int usb_get_descriptor(struct usb_device *dev, unsigned char type,
638 unsigned char index, void *buf, int size)
643 memset(buf, 0, size); /* Make sure we parse really received data */
645 for (i = 0; i < 3; ++i) {
646 /* retry on length 0 or error; some devices are flakey */
647 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
648 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
649 (type << 8) + index, 0, buf, size,
650 USB_CTRL_GET_TIMEOUT);
651 if (result <= 0 && result != -ETIMEDOUT)
653 if (result > 1 && ((u8 *)buf)[1] != type) {
661 EXPORT_SYMBOL_GPL(usb_get_descriptor);
664 * usb_get_string - gets a string descriptor
665 * @dev: the device whose string descriptor is being retrieved
666 * @langid: code for language chosen (from string descriptor zero)
667 * @index: the number of the descriptor
668 * @buf: where to put the string
669 * @size: how big is "buf"?
670 * Context: !in_interrupt ()
672 * Retrieves a string, encoded using UTF-16LE (Unicode, 16 bits per character,
673 * in little-endian byte order).
674 * The usb_string() function will often be a convenient way to turn
675 * these strings into kernel-printable form.
677 * Strings may be referenced in device, configuration, interface, or other
678 * descriptors, and could also be used in vendor-specific ways.
680 * This call is synchronous, and may not be used in an interrupt context.
682 * Returns the number of bytes received on success, or else the status code
683 * returned by the underlying usb_control_msg() call.
685 static int usb_get_string(struct usb_device *dev, unsigned short langid,
686 unsigned char index, void *buf, int size)
691 for (i = 0; i < 3; ++i) {
692 /* retry on length 0 or stall; some devices are flakey */
693 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
694 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
695 (USB_DT_STRING << 8) + index, langid, buf, size,
696 USB_CTRL_GET_TIMEOUT);
697 if (!(result == 0 || result == -EPIPE))
703 static void usb_try_string_workarounds(unsigned char *buf, int *length)
705 int newlength, oldlength = *length;
707 for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
708 if (!isprint(buf[newlength]) || buf[newlength + 1])
717 static int usb_string_sub(struct usb_device *dev, unsigned int langid,
718 unsigned int index, unsigned char *buf)
722 /* Try to read the string descriptor by asking for the maximum
723 * possible number of bytes */
724 if (dev->quirks & USB_QUIRK_STRING_FETCH_255)
727 rc = usb_get_string(dev, langid, index, buf, 255);
729 /* If that failed try to read the descriptor length, then
730 * ask for just that many bytes */
732 rc = usb_get_string(dev, langid, index, buf, 2);
734 rc = usb_get_string(dev, langid, index, buf, buf[0]);
738 if (!buf[0] && !buf[1])
739 usb_try_string_workarounds(buf, &rc);
741 /* There might be extra junk at the end of the descriptor */
745 rc = rc - (rc & 1); /* force a multiple of two */
749 rc = (rc < 0 ? rc : -EINVAL);
755 * usb_string - returns ISO 8859-1 version of a string descriptor
756 * @dev: the device whose string descriptor is being retrieved
757 * @index: the number of the descriptor
758 * @buf: where to put the string
759 * @size: how big is "buf"?
760 * Context: !in_interrupt ()
762 * This converts the UTF-16LE encoded strings returned by devices, from
763 * usb_get_string_descriptor(), to null-terminated ISO-8859-1 encoded ones
764 * that are more usable in most kernel contexts. Note that all characters
765 * in the chosen descriptor that can't be encoded using ISO-8859-1
766 * are converted to the question mark ("?") character, and this function
767 * chooses strings in the first language supported by the device.
769 * The ASCII (or, redundantly, "US-ASCII") character set is the seven-bit
770 * subset of ISO 8859-1. ISO-8859-1 is the eight-bit subset of Unicode,
771 * and is appropriate for use many uses of English and several other
772 * Western European languages. (But it doesn't include the "Euro" symbol.)
774 * This call is synchronous, and may not be used in an interrupt context.
776 * Returns length of the string (>= 0) or usb_control_msg status (< 0).
778 int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
784 if (dev->state == USB_STATE_SUSPENDED)
785 return -EHOSTUNREACH;
786 if (size <= 0 || !buf || !index)
789 tbuf = kmalloc(256, GFP_NOIO);
793 /* get langid for strings if it's not yet known */
794 if (!dev->have_langid) {
795 err = usb_string_sub(dev, 0, 0, tbuf);
798 "string descriptor 0 read error: %d\n",
801 } else if (err < 4) {
802 dev_err(&dev->dev, "string descriptor 0 too short\n");
806 dev->have_langid = 1;
807 dev->string_langid = tbuf[2] | (tbuf[3] << 8);
808 /* always use the first langid listed */
809 dev_dbg(&dev->dev, "default language 0x%04x\n",
814 err = usb_string_sub(dev, dev->string_langid, index, tbuf);
818 size--; /* leave room for trailing NULL char in output buffer */
819 for (idx = 0, u = 2; u < err; u += 2) {
822 if (tbuf[u+1]) /* high byte */
823 buf[idx++] = '?'; /* non ISO-8859-1 character */
825 buf[idx++] = tbuf[u];
830 if (tbuf[1] != USB_DT_STRING)
832 "wrong descriptor type %02x for string %d (\"%s\")\n",
833 tbuf[1], index, buf);
839 EXPORT_SYMBOL_GPL(usb_string);
842 * usb_cache_string - read a string descriptor and cache it for later use
843 * @udev: the device whose string descriptor is being read
844 * @index: the descriptor index
846 * Returns a pointer to a kmalloc'ed buffer containing the descriptor string,
847 * or NULL if the index is 0 or the string could not be read.
849 char *usb_cache_string(struct usb_device *udev, int index)
852 char *smallbuf = NULL;
858 buf = kmalloc(256, GFP_KERNEL);
860 len = usb_string(udev, index, buf, 256);
862 smallbuf = kmalloc(++len, GFP_KERNEL);
865 memcpy(smallbuf, buf, len);
873 * usb_get_device_descriptor - (re)reads the device descriptor (usbcore)
874 * @dev: the device whose device descriptor is being updated
875 * @size: how much of the descriptor to read
876 * Context: !in_interrupt ()
878 * Updates the copy of the device descriptor stored in the device structure,
879 * which dedicates space for this purpose.
881 * Not exported, only for use by the core. If drivers really want to read
882 * the device descriptor directly, they can call usb_get_descriptor() with
883 * type = USB_DT_DEVICE and index = 0.
885 * This call is synchronous, and may not be used in an interrupt context.
887 * Returns the number of bytes received on success, or else the status code
888 * returned by the underlying usb_control_msg() call.
890 int usb_get_device_descriptor(struct usb_device *dev, unsigned int size)
892 struct usb_device_descriptor *desc;
895 if (size > sizeof(*desc))
897 desc = kmalloc(sizeof(*desc), GFP_NOIO);
901 ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, size);
903 memcpy(&dev->descriptor, desc, size);
909 * usb_get_status - issues a GET_STATUS call
910 * @dev: the device whose status is being checked
911 * @type: USB_RECIP_*; for device, interface, or endpoint
912 * @target: zero (for device), else interface or endpoint number
913 * @data: pointer to two bytes of bitmap data
914 * Context: !in_interrupt ()
916 * Returns device, interface, or endpoint status. Normally only of
917 * interest to see if the device is self powered, or has enabled the
918 * remote wakeup facility; or whether a bulk or interrupt endpoint
919 * is halted ("stalled").
921 * Bits in these status bitmaps are set using the SET_FEATURE request,
922 * and cleared using the CLEAR_FEATURE request. The usb_clear_halt()
923 * function should be used to clear halt ("stall") status.
925 * This call is synchronous, and may not be used in an interrupt context.
927 * Returns the number of bytes received on success, or else the status code
928 * returned by the underlying usb_control_msg() call.
930 int usb_get_status(struct usb_device *dev, int type, int target, void *data)
933 u16 *status = kmalloc(sizeof(*status), GFP_KERNEL);
938 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
939 USB_REQ_GET_STATUS, USB_DIR_IN | type, 0, target, status,
940 sizeof(*status), USB_CTRL_GET_TIMEOUT);
942 *(u16 *)data = *status;
946 EXPORT_SYMBOL_GPL(usb_get_status);
949 * usb_clear_halt - tells device to clear endpoint halt/stall condition
950 * @dev: device whose endpoint is halted
951 * @pipe: endpoint "pipe" being cleared
952 * Context: !in_interrupt ()
954 * This is used to clear halt conditions for bulk and interrupt endpoints,
955 * as reported by URB completion status. Endpoints that are halted are
956 * sometimes referred to as being "stalled". Such endpoints are unable
957 * to transmit or receive data until the halt status is cleared. Any URBs
958 * queued for such an endpoint should normally be unlinked by the driver
959 * before clearing the halt condition, as described in sections 5.7.5
960 * and 5.8.5 of the USB 2.0 spec.
962 * Note that control and isochronous endpoints don't halt, although control
963 * endpoints report "protocol stall" (for unsupported requests) using the
964 * same status code used to report a true stall.
966 * This call is synchronous, and may not be used in an interrupt context.
968 * Returns zero on success, or else the status code returned by the
969 * underlying usb_control_msg() call.
971 int usb_clear_halt(struct usb_device *dev, int pipe)
974 int endp = usb_pipeendpoint(pipe);
976 if (usb_pipein(pipe))
979 /* we don't care if it wasn't halted first. in fact some devices
980 * (like some ibmcam model 1 units) seem to expect hosts to make
981 * this request for iso endpoints, which can't halt!
983 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
984 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT,
985 USB_ENDPOINT_HALT, endp, NULL, 0,
986 USB_CTRL_SET_TIMEOUT);
988 /* don't un-halt or force to DATA0 except on success */
992 /* NOTE: seems like Microsoft and Apple don't bother verifying
993 * the clear "took", so some devices could lock up if you check...
994 * such as the Hagiwara FlashGate DUAL. So we won't bother.
996 * NOTE: make sure the logic here doesn't diverge much from
997 * the copy in usb-storage, for as long as we need two copies.
1000 /* toggle was reset by the clear */
1001 usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
1005 EXPORT_SYMBOL_GPL(usb_clear_halt);
1007 static int create_intf_ep_devs(struct usb_interface *intf)
1009 struct usb_device *udev = interface_to_usbdev(intf);
1010 struct usb_host_interface *alt = intf->cur_altsetting;
1013 if (intf->ep_devs_created || intf->unregistering)
1016 for (i = 0; i < alt->desc.bNumEndpoints; ++i)
1017 (void) usb_create_ep_devs(&intf->dev, &alt->endpoint[i], udev);
1018 intf->ep_devs_created = 1;
1022 static void remove_intf_ep_devs(struct usb_interface *intf)
1024 struct usb_host_interface *alt = intf->cur_altsetting;
1027 if (!intf->ep_devs_created)
1030 for (i = 0; i < alt->desc.bNumEndpoints; ++i)
1031 usb_remove_ep_devs(&alt->endpoint[i]);
1032 intf->ep_devs_created = 0;
1036 * usb_disable_endpoint -- Disable an endpoint by address
1037 * @dev: the device whose endpoint is being disabled
1038 * @epaddr: the endpoint's address. Endpoint number for output,
1039 * endpoint number + USB_DIR_IN for input
1041 * Deallocates hcd/hardware state for this endpoint ... and nukes all
1044 * If the HCD hasn't registered a disable() function, this sets the
1045 * endpoint's maxpacket size to 0 to prevent further submissions.
1047 void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr)
1049 unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK;
1050 struct usb_host_endpoint *ep;
1055 if (usb_endpoint_out(epaddr)) {
1056 ep = dev->ep_out[epnum];
1057 dev->ep_out[epnum] = NULL;
1059 ep = dev->ep_in[epnum];
1060 dev->ep_in[epnum] = NULL;
1064 usb_hcd_flush_endpoint(dev, ep);
1065 usb_hcd_disable_endpoint(dev, ep);
1070 * usb_disable_interface -- Disable all endpoints for an interface
1071 * @dev: the device whose interface is being disabled
1072 * @intf: pointer to the interface descriptor
1074 * Disables all the endpoints for the interface's current altsetting.
1076 void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf)
1078 struct usb_host_interface *alt = intf->cur_altsetting;
1081 for (i = 0; i < alt->desc.bNumEndpoints; ++i) {
1082 usb_disable_endpoint(dev,
1083 alt->endpoint[i].desc.bEndpointAddress);
1088 * usb_disable_device - Disable all the endpoints for a USB device
1089 * @dev: the device whose endpoints are being disabled
1090 * @skip_ep0: 0 to disable endpoint 0, 1 to skip it.
1092 * Disables all the device's endpoints, potentially including endpoint 0.
1093 * Deallocates hcd/hardware state for the endpoints (nuking all or most
1094 * pending urbs) and usbcore state for the interfaces, so that usbcore
1095 * must usb_set_configuration() before any interfaces could be used.
1097 void usb_disable_device(struct usb_device *dev, int skip_ep0)
1101 dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
1102 skip_ep0 ? "non-ep0" : "all");
1103 for (i = skip_ep0; i < 16; ++i) {
1104 usb_disable_endpoint(dev, i);
1105 usb_disable_endpoint(dev, i + USB_DIR_IN);
1107 dev->toggle[0] = dev->toggle[1] = 0;
1109 /* getting rid of interfaces will disconnect
1110 * any drivers bound to them (a key side effect)
1112 if (dev->actconfig) {
1113 for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
1114 struct usb_interface *interface;
1116 /* remove this interface if it has been registered */
1117 interface = dev->actconfig->interface[i];
1118 if (!device_is_registered(&interface->dev))
1120 dev_dbg(&dev->dev, "unregistering interface %s\n",
1121 dev_name(&interface->dev));
1122 interface->unregistering = 1;
1123 remove_intf_ep_devs(interface);
1124 device_del(&interface->dev);
1127 /* Now that the interfaces are unbound, nobody should
1128 * try to access them.
1130 for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
1131 put_device(&dev->actconfig->interface[i]->dev);
1132 dev->actconfig->interface[i] = NULL;
1134 dev->actconfig = NULL;
1135 if (dev->state == USB_STATE_CONFIGURED)
1136 usb_set_device_state(dev, USB_STATE_ADDRESS);
1141 * usb_enable_endpoint - Enable an endpoint for USB communications
1142 * @dev: the device whose interface is being enabled
1145 * Resets the endpoint toggle, and sets dev->ep_{in,out} pointers.
1146 * For control endpoints, both the input and output sides are handled.
1148 void usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep)
1150 int epnum = usb_endpoint_num(&ep->desc);
1151 int is_out = usb_endpoint_dir_out(&ep->desc);
1152 int is_control = usb_endpoint_xfer_control(&ep->desc);
1154 if (is_out || is_control) {
1155 usb_settoggle(dev, epnum, 1, 0);
1156 dev->ep_out[epnum] = ep;
1158 if (!is_out || is_control) {
1159 usb_settoggle(dev, epnum, 0, 0);
1160 dev->ep_in[epnum] = ep;
1166 * usb_enable_interface - Enable all the endpoints for an interface
1167 * @dev: the device whose interface is being enabled
1168 * @intf: pointer to the interface descriptor
1170 * Enables all the endpoints for the interface's current altsetting.
1172 static void usb_enable_interface(struct usb_device *dev,
1173 struct usb_interface *intf)
1175 struct usb_host_interface *alt = intf->cur_altsetting;
1178 for (i = 0; i < alt->desc.bNumEndpoints; ++i)
1179 usb_enable_endpoint(dev, &alt->endpoint[i]);
1183 * usb_set_interface - Makes a particular alternate setting be current
1184 * @dev: the device whose interface is being updated
1185 * @interface: the interface being updated
1186 * @alternate: the setting being chosen.
1187 * Context: !in_interrupt ()
1189 * This is used to enable data transfers on interfaces that may not
1190 * be enabled by default. Not all devices support such configurability.
1191 * Only the driver bound to an interface may change its setting.
1193 * Within any given configuration, each interface may have several
1194 * alternative settings. These are often used to control levels of
1195 * bandwidth consumption. For example, the default setting for a high
1196 * speed interrupt endpoint may not send more than 64 bytes per microframe,
1197 * while interrupt transfers of up to 3KBytes per microframe are legal.
1198 * Also, isochronous endpoints may never be part of an
1199 * interface's default setting. To access such bandwidth, alternate
1200 * interface settings must be made current.
1202 * Note that in the Linux USB subsystem, bandwidth associated with
1203 * an endpoint in a given alternate setting is not reserved until an URB
1204 * is submitted that needs that bandwidth. Some other operating systems
1205 * allocate bandwidth early, when a configuration is chosen.
1207 * This call is synchronous, and may not be used in an interrupt context.
1208 * Also, drivers must not change altsettings while urbs are scheduled for
1209 * endpoints in that interface; all such urbs must first be completed
1210 * (perhaps forced by unlinking).
1212 * Returns zero on success, or else the status code returned by the
1213 * underlying usb_control_msg() call.
1215 int usb_set_interface(struct usb_device *dev, int interface, int alternate)
1217 struct usb_interface *iface;
1218 struct usb_host_interface *alt;
1221 unsigned int epaddr;
1224 if (dev->state == USB_STATE_SUSPENDED)
1225 return -EHOSTUNREACH;
1227 iface = usb_ifnum_to_if(dev, interface);
1229 dev_dbg(&dev->dev, "selecting invalid interface %d\n",
1234 alt = usb_altnum_to_altsetting(iface, alternate);
1236 dev_warn(&dev->dev, "selecting invalid altsetting %d",
1241 if (dev->quirks & USB_QUIRK_NO_SET_INTF)
1244 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1245 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
1246 alternate, interface, NULL, 0, 5000);
1248 /* 9.4.10 says devices don't need this and are free to STALL the
1249 * request if the interface only has one alternate setting.
1251 if (ret == -EPIPE && iface->num_altsetting == 1) {
1253 "manual set_interface for iface %d, alt %d\n",
1254 interface, alternate);
1259 /* FIXME drivers shouldn't need to replicate/bugfix the logic here
1260 * when they implement async or easily-killable versions of this or
1261 * other "should-be-internal" functions (like clear_halt).
1262 * should hcd+usbcore postprocess control requests?
1265 /* prevent submissions using previous endpoint settings */
1266 if (iface->cur_altsetting != alt) {
1267 remove_intf_ep_devs(iface);
1268 usb_remove_sysfs_intf_files(iface);
1270 usb_disable_interface(dev, iface);
1272 iface->cur_altsetting = alt;
1274 /* If the interface only has one altsetting and the device didn't
1275 * accept the request, we attempt to carry out the equivalent action
1276 * by manually clearing the HALT feature for each endpoint in the
1282 for (i = 0; i < alt->desc.bNumEndpoints; i++) {
1283 epaddr = alt->endpoint[i].desc.bEndpointAddress;
1284 pipe = __create_pipe(dev,
1285 USB_ENDPOINT_NUMBER_MASK & epaddr) |
1286 (usb_endpoint_out(epaddr) ?
1287 USB_DIR_OUT : USB_DIR_IN);
1289 usb_clear_halt(dev, pipe);
1293 /* 9.1.1.5: reset toggles for all endpoints in the new altsetting
1296 * Despite EP0 is always present in all interfaces/AS, the list of
1297 * endpoints from the descriptor does not contain EP0. Due to its
1298 * omnipresence one might expect EP0 being considered "affected" by
1299 * any SetInterface request and hence assume toggles need to be reset.
1300 * However, EP0 toggles are re-synced for every individual transfer
1301 * during the SETUP stage - hence EP0 toggles are "don't care" here.
1302 * (Likewise, EP0 never "halts" on well designed devices.)
1304 usb_enable_interface(dev, iface);
1305 if (device_is_registered(&iface->dev)) {
1306 usb_create_sysfs_intf_files(iface);
1307 create_intf_ep_devs(iface);
1311 EXPORT_SYMBOL_GPL(usb_set_interface);
1314 * usb_reset_configuration - lightweight device reset
1315 * @dev: the device whose configuration is being reset
1317 * This issues a standard SET_CONFIGURATION request to the device using
1318 * the current configuration. The effect is to reset most USB-related
1319 * state in the device, including interface altsettings (reset to zero),
1320 * endpoint halts (cleared), and data toggle (only for bulk and interrupt
1321 * endpoints). Other usbcore state is unchanged, including bindings of
1322 * usb device drivers to interfaces.
1324 * Because this affects multiple interfaces, avoid using this with composite
1325 * (multi-interface) devices. Instead, the driver for each interface may
1326 * use usb_set_interface() on the interfaces it claims. Be careful though;
1327 * some devices don't support the SET_INTERFACE request, and others won't
1328 * reset all the interface state (notably data toggles). Resetting the whole
1329 * configuration would affect other drivers' interfaces.
1331 * The caller must own the device lock.
1333 * Returns zero on success, else a negative error code.
1335 int usb_reset_configuration(struct usb_device *dev)
1338 struct usb_host_config *config;
1340 if (dev->state == USB_STATE_SUSPENDED)
1341 return -EHOSTUNREACH;
1343 /* caller must have locked the device and must own
1344 * the usb bus readlock (so driver bindings are stable);
1345 * calls during probe() are fine
1348 for (i = 1; i < 16; ++i) {
1349 usb_disable_endpoint(dev, i);
1350 usb_disable_endpoint(dev, i + USB_DIR_IN);
1353 config = dev->actconfig;
1354 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1355 USB_REQ_SET_CONFIGURATION, 0,
1356 config->desc.bConfigurationValue, 0,
1357 NULL, 0, USB_CTRL_SET_TIMEOUT);
1361 dev->toggle[0] = dev->toggle[1] = 0;
1363 /* re-init hc/hcd interface/endpoint state */
1364 for (i = 0; i < config->desc.bNumInterfaces; i++) {
1365 struct usb_interface *intf = config->interface[i];
1366 struct usb_host_interface *alt;
1368 alt = usb_altnum_to_altsetting(intf, 0);
1370 /* No altsetting 0? We'll assume the first altsetting.
1371 * We could use a GetInterface call, but if a device is
1372 * so non-compliant that it doesn't have altsetting 0
1373 * then I wouldn't trust its reply anyway.
1376 alt = &intf->altsetting[0];
1378 if (alt != intf->cur_altsetting) {
1379 remove_intf_ep_devs(intf);
1380 usb_remove_sysfs_intf_files(intf);
1382 intf->cur_altsetting = alt;
1383 usb_enable_interface(dev, intf);
1384 if (device_is_registered(&intf->dev)) {
1385 usb_create_sysfs_intf_files(intf);
1386 create_intf_ep_devs(intf);
1391 EXPORT_SYMBOL_GPL(usb_reset_configuration);
1393 static void usb_release_interface(struct device *dev)
1395 struct usb_interface *intf = to_usb_interface(dev);
1396 struct usb_interface_cache *intfc =
1397 altsetting_to_usb_interface_cache(intf->altsetting);
1399 kref_put(&intfc->ref, usb_release_interface_cache);
1403 #ifdef CONFIG_HOTPLUG
1404 static int usb_if_uevent(struct device *dev, struct kobj_uevent_env *env)
1406 struct usb_device *usb_dev;
1407 struct usb_interface *intf;
1408 struct usb_host_interface *alt;
1410 intf = to_usb_interface(dev);
1411 usb_dev = interface_to_usbdev(intf);
1412 alt = intf->cur_altsetting;
1414 if (add_uevent_var(env, "INTERFACE=%d/%d/%d",
1415 alt->desc.bInterfaceClass,
1416 alt->desc.bInterfaceSubClass,
1417 alt->desc.bInterfaceProtocol))
1420 if (add_uevent_var(env,
1422 "v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
1423 le16_to_cpu(usb_dev->descriptor.idVendor),
1424 le16_to_cpu(usb_dev->descriptor.idProduct),
1425 le16_to_cpu(usb_dev->descriptor.bcdDevice),
1426 usb_dev->descriptor.bDeviceClass,
1427 usb_dev->descriptor.bDeviceSubClass,
1428 usb_dev->descriptor.bDeviceProtocol,
1429 alt->desc.bInterfaceClass,
1430 alt->desc.bInterfaceSubClass,
1431 alt->desc.bInterfaceProtocol))
1439 static int usb_if_uevent(struct device *dev, struct kobj_uevent_env *env)
1443 #endif /* CONFIG_HOTPLUG */
1445 struct device_type usb_if_device_type = {
1446 .name = "usb_interface",
1447 .release = usb_release_interface,
1448 .uevent = usb_if_uevent,
1451 static struct usb_interface_assoc_descriptor *find_iad(struct usb_device *dev,
1452 struct usb_host_config *config,
1455 struct usb_interface_assoc_descriptor *retval = NULL;
1456 struct usb_interface_assoc_descriptor *intf_assoc;
1461 for (i = 0; (i < USB_MAXIADS && config->intf_assoc[i]); i++) {
1462 intf_assoc = config->intf_assoc[i];
1463 if (intf_assoc->bInterfaceCount == 0)
1466 first_intf = intf_assoc->bFirstInterface;
1467 last_intf = first_intf + (intf_assoc->bInterfaceCount - 1);
1468 if (inum >= first_intf && inum <= last_intf) {
1470 retval = intf_assoc;
1472 dev_err(&dev->dev, "Interface #%d referenced"
1473 " by multiple IADs\n", inum);
1482 * Internal function to queue a device reset
1484 * This is initialized into the workstruct in 'struct
1485 * usb_device->reset_ws' that is launched by
1486 * message.c:usb_set_configuration() when initializing each 'struct
1489 * It is safe to get the USB device without reference counts because
1490 * the life cycle of @iface is bound to the life cycle of @udev. Then,
1491 * this function will be ran only if @iface is alive (and before
1492 * freeing it any scheduled instances of it will have been cancelled).
1494 * We need to set a flag (usb_dev->reset_running) because when we call
1495 * the reset, the interfaces might be unbound. The current interface
1496 * cannot try to remove the queued work as it would cause a deadlock
1497 * (you cannot remove your work from within your executing
1498 * workqueue). This flag lets it know, so that
1499 * usb_cancel_queued_reset() doesn't try to do it.
1501 * See usb_queue_reset_device() for more details
1503 void __usb_queue_reset_device(struct work_struct *ws)
1506 struct usb_interface *iface =
1507 container_of(ws, struct usb_interface, reset_ws);
1508 struct usb_device *udev = interface_to_usbdev(iface);
1510 rc = usb_lock_device_for_reset(udev, iface);
1512 iface->reset_running = 1;
1513 usb_reset_device(udev);
1514 iface->reset_running = 0;
1515 usb_unlock_device(udev);
1521 * usb_set_configuration - Makes a particular device setting be current
1522 * @dev: the device whose configuration is being updated
1523 * @configuration: the configuration being chosen.
1524 * Context: !in_interrupt(), caller owns the device lock
1526 * This is used to enable non-default device modes. Not all devices
1527 * use this kind of configurability; many devices only have one
1530 * @configuration is the value of the configuration to be installed.
1531 * According to the USB spec (e.g. section 9.1.1.5), configuration values
1532 * must be non-zero; a value of zero indicates that the device in
1533 * unconfigured. However some devices erroneously use 0 as one of their
1534 * configuration values. To help manage such devices, this routine will
1535 * accept @configuration = -1 as indicating the device should be put in
1536 * an unconfigured state.
1538 * USB device configurations may affect Linux interoperability,
1539 * power consumption and the functionality available. For example,
1540 * the default configuration is limited to using 100mA of bus power,
1541 * so that when certain device functionality requires more power,
1542 * and the device is bus powered, that functionality should be in some
1543 * non-default device configuration. Other device modes may also be
1544 * reflected as configuration options, such as whether two ISDN
1545 * channels are available independently; and choosing between open
1546 * standard device protocols (like CDC) or proprietary ones.
1548 * Note that a non-authorized device (dev->authorized == 0) will only
1549 * be put in unconfigured mode.
1551 * Note that USB has an additional level of device configurability,
1552 * associated with interfaces. That configurability is accessed using
1553 * usb_set_interface().
1555 * This call is synchronous. The calling context must be able to sleep,
1556 * must own the device lock, and must not hold the driver model's USB
1557 * bus mutex; usb interface driver probe() methods cannot use this routine.
1559 * Returns zero on success, or else the status code returned by the
1560 * underlying call that failed. On successful completion, each interface
1561 * in the original device configuration has been destroyed, and each one
1562 * in the new configuration has been probed by all relevant usb device
1563 * drivers currently known to the kernel.
1565 int usb_set_configuration(struct usb_device *dev, int configuration)
1568 struct usb_host_config *cp = NULL;
1569 struct usb_interface **new_interfaces = NULL;
1572 if (dev->authorized == 0 || configuration == -1)
1575 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
1576 if (dev->config[i].desc.bConfigurationValue ==
1578 cp = &dev->config[i];
1583 if ((!cp && configuration != 0))
1586 /* The USB spec says configuration 0 means unconfigured.
1587 * But if a device includes a configuration numbered 0,
1588 * we will accept it as a correctly configured state.
1589 * Use -1 if you really want to unconfigure the device.
1591 if (cp && configuration == 0)
1592 dev_warn(&dev->dev, "config 0 descriptor??\n");
1594 /* Allocate memory for new interfaces before doing anything else,
1595 * so that if we run out then nothing will have changed. */
1598 nintf = cp->desc.bNumInterfaces;
1599 new_interfaces = kmalloc(nintf * sizeof(*new_interfaces),
1601 if (!new_interfaces) {
1602 dev_err(&dev->dev, "Out of memory\n");
1606 for (; n < nintf; ++n) {
1607 new_interfaces[n] = kzalloc(
1608 sizeof(struct usb_interface),
1610 if (!new_interfaces[n]) {
1611 dev_err(&dev->dev, "Out of memory\n");
1615 kfree(new_interfaces[n]);
1616 kfree(new_interfaces);
1621 i = dev->bus_mA - cp->desc.bMaxPower * 2;
1623 dev_warn(&dev->dev, "new config #%d exceeds power "
1628 /* Wake up the device so we can send it the Set-Config request */
1629 ret = usb_autoresume_device(dev);
1631 goto free_interfaces;
1633 /* if it's already configured, clear out old state first.
1634 * getting rid of old interfaces means unbinding their drivers.
1636 if (dev->state != USB_STATE_ADDRESS)
1637 usb_disable_device(dev, 1); /* Skip ep0 */
1639 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1640 USB_REQ_SET_CONFIGURATION, 0, configuration, 0,
1641 NULL, 0, USB_CTRL_SET_TIMEOUT);
1643 /* All the old state is gone, so what else can we do?
1644 * The device is probably useless now anyway.
1649 dev->actconfig = cp;
1651 usb_set_device_state(dev, USB_STATE_ADDRESS);
1652 usb_autosuspend_device(dev);
1653 goto free_interfaces;
1655 usb_set_device_state(dev, USB_STATE_CONFIGURED);
1657 /* Initialize the new interface structures and the
1658 * hc/hcd/usbcore interface/endpoint state.
1660 for (i = 0; i < nintf; ++i) {
1661 struct usb_interface_cache *intfc;
1662 struct usb_interface *intf;
1663 struct usb_host_interface *alt;
1665 cp->interface[i] = intf = new_interfaces[i];
1666 intfc = cp->intf_cache[i];
1667 intf->altsetting = intfc->altsetting;
1668 intf->num_altsetting = intfc->num_altsetting;
1669 intf->intf_assoc = find_iad(dev, cp, i);
1670 kref_get(&intfc->ref);
1672 alt = usb_altnum_to_altsetting(intf, 0);
1674 /* No altsetting 0? We'll assume the first altsetting.
1675 * We could use a GetInterface call, but if a device is
1676 * so non-compliant that it doesn't have altsetting 0
1677 * then I wouldn't trust its reply anyway.
1680 alt = &intf->altsetting[0];
1682 intf->cur_altsetting = alt;
1683 usb_enable_interface(dev, intf);
1684 intf->dev.parent = &dev->dev;
1685 intf->dev.driver = NULL;
1686 intf->dev.bus = &usb_bus_type;
1687 intf->dev.type = &usb_if_device_type;
1688 intf->dev.groups = usb_interface_groups;
1689 intf->dev.dma_mask = dev->dev.dma_mask;
1690 INIT_WORK(&intf->reset_ws, __usb_queue_reset_device);
1691 device_initialize(&intf->dev);
1692 mark_quiesced(intf);
1693 dev_set_name(&intf->dev, "%d-%s:%d.%d",
1694 dev->bus->busnum, dev->devpath,
1695 configuration, alt->desc.bInterfaceNumber);
1697 kfree(new_interfaces);
1699 if (cp->string == NULL)
1700 cp->string = usb_cache_string(dev, cp->desc.iConfiguration);
1702 /* Now that all the interfaces are set up, register them
1703 * to trigger binding of drivers to interfaces. probe()
1704 * routines may install different altsettings and may
1705 * claim() any interfaces not yet bound. Many class drivers
1706 * need that: CDC, audio, video, etc.
1708 for (i = 0; i < nintf; ++i) {
1709 struct usb_interface *intf = cp->interface[i];
1712 "adding %s (config #%d, interface %d)\n",
1713 dev_name(&intf->dev), configuration,
1714 intf->cur_altsetting->desc.bInterfaceNumber);
1715 ret = device_add(&intf->dev);
1717 dev_err(&dev->dev, "device_add(%s) --> %d\n",
1718 dev_name(&intf->dev), ret);
1721 create_intf_ep_devs(intf);
1724 usb_autosuspend_device(dev);
1728 struct set_config_request {
1729 struct usb_device *udev;
1731 struct work_struct work;
1734 /* Worker routine for usb_driver_set_configuration() */
1735 static void driver_set_config_work(struct work_struct *work)
1737 struct set_config_request *req =
1738 container_of(work, struct set_config_request, work);
1740 usb_lock_device(req->udev);
1741 usb_set_configuration(req->udev, req->config);
1742 usb_unlock_device(req->udev);
1743 usb_put_dev(req->udev);
1748 * usb_driver_set_configuration - Provide a way for drivers to change device configurations
1749 * @udev: the device whose configuration is being updated
1750 * @config: the configuration being chosen.
1751 * Context: In process context, must be able to sleep
1753 * Device interface drivers are not allowed to change device configurations.
1754 * This is because changing configurations will destroy the interface the
1755 * driver is bound to and create new ones; it would be like a floppy-disk
1756 * driver telling the computer to replace the floppy-disk drive with a
1759 * Still, in certain specialized circumstances the need may arise. This
1760 * routine gets around the normal restrictions by using a work thread to
1761 * submit the change-config request.
1763 * Returns 0 if the request was succesfully queued, error code otherwise.
1764 * The caller has no way to know whether the queued request will eventually
1767 int usb_driver_set_configuration(struct usb_device *udev, int config)
1769 struct set_config_request *req;
1771 req = kmalloc(sizeof(*req), GFP_KERNEL);
1775 req->config = config;
1776 INIT_WORK(&req->work, driver_set_config_work);
1779 schedule_work(&req->work);
1782 EXPORT_SYMBOL_GPL(usb_driver_set_configuration);