forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2511 lines
75 KiB
2511 lines
75 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* message.c - synchronous message handling |
|
* |
|
* Released under the GPLv2 only. |
|
*/ |
|
|
|
#include <linux/acpi.h> |
|
#include <linux/pci.h> /* for scatterlist macros */ |
|
#include <linux/usb.h> |
|
#include <linux/module.h> |
|
#include <linux/slab.h> |
|
#include <linux/mm.h> |
|
#include <linux/timer.h> |
|
#include <linux/ctype.h> |
|
#include <linux/nls.h> |
|
#include <linux/device.h> |
|
#include <linux/scatterlist.h> |
|
#include <linux/usb/cdc.h> |
|
#include <linux/usb/quirks.h> |
|
#include <linux/usb/hcd.h> /* for usbcore internals */ |
|
#include <linux/usb/of.h> |
|
#include <asm/byteorder.h> |
|
|
|
#include "usb.h" |
|
|
|
static void cancel_async_set_config(struct usb_device *udev); |
|
|
|
struct api_context { |
|
struct completion done; |
|
int status; |
|
}; |
|
|
|
static void usb_api_blocking_completion(struct urb *urb) |
|
{ |
|
struct api_context *ctx = urb->context; |
|
|
|
ctx->status = urb->status; |
|
complete(&ctx->done); |
|
} |
|
|
|
|
|
/* |
|
* Starts urb and waits for completion or timeout. Note that this call |
|
* is NOT interruptible. Many device driver i/o requests should be |
|
* interruptible and therefore these drivers should implement their |
|
* own interruptible routines. |
|
*/ |
|
static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length) |
|
{ |
|
struct api_context ctx; |
|
unsigned long expire; |
|
int retval; |
|
|
|
init_completion(&ctx.done); |
|
urb->context = &ctx; |
|
urb->actual_length = 0; |
|
retval = usb_submit_urb(urb, GFP_NOIO); |
|
if (unlikely(retval)) |
|
goto out; |
|
|
|
expire = timeout ? msecs_to_jiffies(timeout) : MAX_SCHEDULE_TIMEOUT; |
|
if (!wait_for_completion_timeout(&ctx.done, expire)) { |
|
usb_kill_urb(urb); |
|
retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status); |
|
|
|
dev_dbg(&urb->dev->dev, |
|
"%s timed out on ep%d%s len=%u/%u\n", |
|
current->comm, |
|
usb_endpoint_num(&urb->ep->desc), |
|
usb_urb_dir_in(urb) ? "in" : "out", |
|
urb->actual_length, |
|
urb->transfer_buffer_length); |
|
} else |
|
retval = ctx.status; |
|
out: |
|
if (actual_length) |
|
*actual_length = urb->actual_length; |
|
|
|
usb_free_urb(urb); |
|
return retval; |
|
} |
|
|
|
/*-------------------------------------------------------------------*/ |
|
/* returns status (negative) or length (positive) */ |
|
static int usb_internal_control_msg(struct usb_device *usb_dev, |
|
unsigned int pipe, |
|
struct usb_ctrlrequest *cmd, |
|
void *data, int len, int timeout) |
|
{ |
|
struct urb *urb; |
|
int retv; |
|
int length; |
|
|
|
urb = usb_alloc_urb(0, GFP_NOIO); |
|
if (!urb) |
|
return -ENOMEM; |
|
|
|
usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data, |
|
len, usb_api_blocking_completion, NULL); |
|
|
|
retv = usb_start_wait_urb(urb, timeout, &length); |
|
if (retv < 0) |
|
return retv; |
|
else |
|
return length; |
|
} |
|
|
|
/** |
|
* usb_control_msg - Builds a control urb, sends it off and waits for completion |
|
* @dev: pointer to the usb device to send the message to |
|
* @pipe: endpoint "pipe" to send the message to |
|
* @request: USB message request value |
|
* @requesttype: USB message request type value |
|
* @value: USB message value |
|
* @index: USB message index value |
|
* @data: pointer to the data to send |
|
* @size: length in bytes of the data to send |
|
* @timeout: time in msecs to wait for the message to complete before timing |
|
* out (if 0 the wait is forever) |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* This function sends a simple control message to a specified endpoint and |
|
* waits for the message to complete, or timeout. |
|
* |
|
* Don't use this function from within an interrupt context. If you need |
|
* an asynchronous message, or need to send a message from within interrupt |
|
* context, use usb_submit_urb(). If a thread in your driver uses this call, |
|
* make sure your disconnect() method can wait for it to complete. Since you |
|
* don't have a handle on the URB used, you can't cancel the request. |
|
* |
|
* Return: If successful, the number of bytes transferred. Otherwise, a negative |
|
* error number. |
|
*/ |
|
int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request, |
|
__u8 requesttype, __u16 value, __u16 index, void *data, |
|
__u16 size, int timeout) |
|
{ |
|
struct usb_ctrlrequest *dr; |
|
int ret; |
|
|
|
dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO); |
|
if (!dr) |
|
return -ENOMEM; |
|
|
|
dr->bRequestType = requesttype; |
|
dr->bRequest = request; |
|
dr->wValue = cpu_to_le16(value); |
|
dr->wIndex = cpu_to_le16(index); |
|
dr->wLength = cpu_to_le16(size); |
|
|
|
ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout); |
|
|
|
/* Linger a bit, prior to the next control message. */ |
|
if (dev->quirks & USB_QUIRK_DELAY_CTRL_MSG) |
|
msleep(200); |
|
|
|
kfree(dr); |
|
|
|
return ret; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_control_msg); |
|
|
|
/** |
|
* usb_control_msg_send - Builds a control "send" message, sends it off and waits for completion |
|
* @dev: pointer to the usb device to send the message to |
|
* @endpoint: endpoint to send the message to |
|
* @request: USB message request value |
|
* @requesttype: USB message request type value |
|
* @value: USB message value |
|
* @index: USB message index value |
|
* @driver_data: pointer to the data to send |
|
* @size: length in bytes of the data to send |
|
* @timeout: time in msecs to wait for the message to complete before timing |
|
* out (if 0 the wait is forever) |
|
* @memflags: the flags for memory allocation for buffers |
|
* |
|
* Context: !in_interrupt () |
|
* |
|
* This function sends a control message to a specified endpoint that is not |
|
* expected to fill in a response (i.e. a "send message") and waits for the |
|
* message to complete, or timeout. |
|
* |
|
* Do not use this function from within an interrupt context. If you need |
|
* an asynchronous message, or need to send a message from within interrupt |
|
* context, use usb_submit_urb(). If a thread in your driver uses this call, |
|
* make sure your disconnect() method can wait for it to complete. Since you |
|
* don't have a handle on the URB used, you can't cancel the request. |
|
* |
|
* The data pointer can be made to a reference on the stack, or anywhere else, |
|
* as it will not be modified at all. This does not have the restriction that |
|
* usb_control_msg() has where the data pointer must be to dynamically allocated |
|
* memory (i.e. memory that can be successfully DMAed to a device). |
|
* |
|
* Return: If successful, 0 is returned, Otherwise, a negative error number. |
|
*/ |
|
int usb_control_msg_send(struct usb_device *dev, __u8 endpoint, __u8 request, |
|
__u8 requesttype, __u16 value, __u16 index, |
|
const void *driver_data, __u16 size, int timeout, |
|
gfp_t memflags) |
|
{ |
|
unsigned int pipe = usb_sndctrlpipe(dev, endpoint); |
|
int ret; |
|
u8 *data = NULL; |
|
|
|
if (size) { |
|
data = kmemdup(driver_data, size, memflags); |
|
if (!data) |
|
return -ENOMEM; |
|
} |
|
|
|
ret = usb_control_msg(dev, pipe, request, requesttype, value, index, |
|
data, size, timeout); |
|
kfree(data); |
|
|
|
if (ret < 0) |
|
return ret; |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_control_msg_send); |
|
|
|
/** |
|
* usb_control_msg_recv - Builds a control "receive" message, sends it off and waits for completion |
|
* @dev: pointer to the usb device to send the message to |
|
* @endpoint: endpoint to send the message to |
|
* @request: USB message request value |
|
* @requesttype: USB message request type value |
|
* @value: USB message value |
|
* @index: USB message index value |
|
* @driver_data: pointer to the data to be filled in by the message |
|
* @size: length in bytes of the data to be received |
|
* @timeout: time in msecs to wait for the message to complete before timing |
|
* out (if 0 the wait is forever) |
|
* @memflags: the flags for memory allocation for buffers |
|
* |
|
* Context: !in_interrupt () |
|
* |
|
* This function sends a control message to a specified endpoint that is |
|
* expected to fill in a response (i.e. a "receive message") and waits for the |
|
* message to complete, or timeout. |
|
* |
|
* Do not use this function from within an interrupt context. If you need |
|
* an asynchronous message, or need to send a message from within interrupt |
|
* context, use usb_submit_urb(). If a thread in your driver uses this call, |
|
* make sure your disconnect() method can wait for it to complete. Since you |
|
* don't have a handle on the URB used, you can't cancel the request. |
|
* |
|
* The data pointer can be made to a reference on the stack, or anywhere else |
|
* that can be successfully written to. This function does not have the |
|
* restriction that usb_control_msg() has where the data pointer must be to |
|
* dynamically allocated memory (i.e. memory that can be successfully DMAed to a |
|
* device). |
|
* |
|
* The "whole" message must be properly received from the device in order for |
|
* this function to be successful. If a device returns less than the expected |
|
* amount of data, then the function will fail. Do not use this for messages |
|
* where a variable amount of data might be returned. |
|
* |
|
* Return: If successful, 0 is returned, Otherwise, a negative error number. |
|
*/ |
|
int usb_control_msg_recv(struct usb_device *dev, __u8 endpoint, __u8 request, |
|
__u8 requesttype, __u16 value, __u16 index, |
|
void *driver_data, __u16 size, int timeout, |
|
gfp_t memflags) |
|
{ |
|
unsigned int pipe = usb_rcvctrlpipe(dev, endpoint); |
|
int ret; |
|
u8 *data; |
|
|
|
if (!size || !driver_data) |
|
return -EINVAL; |
|
|
|
data = kmalloc(size, memflags); |
|
if (!data) |
|
return -ENOMEM; |
|
|
|
ret = usb_control_msg(dev, pipe, request, requesttype, value, index, |
|
data, size, timeout); |
|
|
|
if (ret < 0) |
|
goto exit; |
|
|
|
if (ret == size) { |
|
memcpy(driver_data, data, size); |
|
ret = 0; |
|
} else { |
|
ret = -EREMOTEIO; |
|
} |
|
|
|
exit: |
|
kfree(data); |
|
return ret; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_control_msg_recv); |
|
|
|
/** |
|
* usb_interrupt_msg - Builds an interrupt urb, sends it off and waits for completion |
|
* @usb_dev: pointer to the usb device to send the message to |
|
* @pipe: endpoint "pipe" to send the message to |
|
* @data: pointer to the data to send |
|
* @len: length in bytes of the data to send |
|
* @actual_length: pointer to a location to put the actual length transferred |
|
* in bytes |
|
* @timeout: time in msecs to wait for the message to complete before |
|
* timing out (if 0 the wait is forever) |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* This function sends a simple interrupt message to a specified endpoint and |
|
* waits for the message to complete, or timeout. |
|
* |
|
* Don't use this function from within an interrupt context. If you need |
|
* an asynchronous message, or need to send a message from within interrupt |
|
* context, use usb_submit_urb() If a thread in your driver uses this call, |
|
* make sure your disconnect() method can wait for it to complete. Since you |
|
* don't have a handle on the URB used, you can't cancel the request. |
|
* |
|
* Return: |
|
* If successful, 0. Otherwise a negative error number. The number of actual |
|
* bytes transferred will be stored in the @actual_length parameter. |
|
*/ |
|
int usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe, |
|
void *data, int len, int *actual_length, int timeout) |
|
{ |
|
return usb_bulk_msg(usb_dev, pipe, data, len, actual_length, timeout); |
|
} |
|
EXPORT_SYMBOL_GPL(usb_interrupt_msg); |
|
|
|
/** |
|
* usb_bulk_msg - Builds a bulk urb, sends it off and waits for completion |
|
* @usb_dev: pointer to the usb device to send the message to |
|
* @pipe: endpoint "pipe" to send the message to |
|
* @data: pointer to the data to send |
|
* @len: length in bytes of the data to send |
|
* @actual_length: pointer to a location to put the actual length transferred |
|
* in bytes |
|
* @timeout: time in msecs to wait for the message to complete before |
|
* timing out (if 0 the wait is forever) |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* This function sends a simple bulk message to a specified endpoint |
|
* and waits for the message to complete, or timeout. |
|
* |
|
* Don't use this function from within an interrupt context. If you need |
|
* an asynchronous message, or need to send a message from within interrupt |
|
* context, use usb_submit_urb() If a thread in your driver uses this call, |
|
* make sure your disconnect() method can wait for it to complete. Since you |
|
* don't have a handle on the URB used, you can't cancel the request. |
|
* |
|
* Because there is no usb_interrupt_msg() and no USBDEVFS_INTERRUPT ioctl, |
|
* users are forced to abuse this routine by using it to submit URBs for |
|
* interrupt endpoints. We will take the liberty of creating an interrupt URB |
|
* (with the default interval) if the target is an interrupt endpoint. |
|
* |
|
* Return: |
|
* If successful, 0. Otherwise a negative error number. The number of actual |
|
* bytes transferred will be stored in the @actual_length parameter. |
|
* |
|
*/ |
|
int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe, |
|
void *data, int len, int *actual_length, int timeout) |
|
{ |
|
struct urb *urb; |
|
struct usb_host_endpoint *ep; |
|
|
|
ep = usb_pipe_endpoint(usb_dev, pipe); |
|
if (!ep || len < 0) |
|
return -EINVAL; |
|
|
|
urb = usb_alloc_urb(0, GFP_KERNEL); |
|
if (!urb) |
|
return -ENOMEM; |
|
|
|
if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == |
|
USB_ENDPOINT_XFER_INT) { |
|
pipe = (pipe & ~(3 << 30)) | (PIPE_INTERRUPT << 30); |
|
usb_fill_int_urb(urb, usb_dev, pipe, data, len, |
|
usb_api_blocking_completion, NULL, |
|
ep->desc.bInterval); |
|
} else |
|
usb_fill_bulk_urb(urb, usb_dev, pipe, data, len, |
|
usb_api_blocking_completion, NULL); |
|
|
|
return usb_start_wait_urb(urb, timeout, actual_length); |
|
} |
|
EXPORT_SYMBOL_GPL(usb_bulk_msg); |
|
|
|
/*-------------------------------------------------------------------*/ |
|
|
|
static void sg_clean(struct usb_sg_request *io) |
|
{ |
|
if (io->urbs) { |
|
while (io->entries--) |
|
usb_free_urb(io->urbs[io->entries]); |
|
kfree(io->urbs); |
|
io->urbs = NULL; |
|
} |
|
io->dev = NULL; |
|
} |
|
|
|
static void sg_complete(struct urb *urb) |
|
{ |
|
unsigned long flags; |
|
struct usb_sg_request *io = urb->context; |
|
int status = urb->status; |
|
|
|
spin_lock_irqsave(&io->lock, flags); |
|
|
|
/* In 2.5 we require hcds' endpoint queues not to progress after fault |
|
* reports, until the completion callback (this!) returns. That lets |
|
* device driver code (like this routine) unlink queued urbs first, |
|
* if it needs to, since the HC won't work on them at all. So it's |
|
* not possible for page N+1 to overwrite page N, and so on. |
|
* |
|
* That's only for "hard" faults; "soft" faults (unlinks) sometimes |
|
* complete before the HCD can get requests away from hardware, |
|
* though never during cleanup after a hard fault. |
|
*/ |
|
if (io->status |
|
&& (io->status != -ECONNRESET |
|
|| status != -ECONNRESET) |
|
&& urb->actual_length) { |
|
dev_err(io->dev->bus->controller, |
|
"dev %s ep%d%s scatterlist error %d/%d\n", |
|
io->dev->devpath, |
|
usb_endpoint_num(&urb->ep->desc), |
|
usb_urb_dir_in(urb) ? "in" : "out", |
|
status, io->status); |
|
/* BUG (); */ |
|
} |
|
|
|
if (io->status == 0 && status && status != -ECONNRESET) { |
|
int i, found, retval; |
|
|
|
io->status = status; |
|
|
|
/* the previous urbs, and this one, completed already. |
|
* unlink pending urbs so they won't rx/tx bad data. |
|
* careful: unlink can sometimes be synchronous... |
|
*/ |
|
spin_unlock_irqrestore(&io->lock, flags); |
|
for (i = 0, found = 0; i < io->entries; i++) { |
|
if (!io->urbs[i]) |
|
continue; |
|
if (found) { |
|
usb_block_urb(io->urbs[i]); |
|
retval = usb_unlink_urb(io->urbs[i]); |
|
if (retval != -EINPROGRESS && |
|
retval != -ENODEV && |
|
retval != -EBUSY && |
|
retval != -EIDRM) |
|
dev_err(&io->dev->dev, |
|
"%s, unlink --> %d\n", |
|
__func__, retval); |
|
} else if (urb == io->urbs[i]) |
|
found = 1; |
|
} |
|
spin_lock_irqsave(&io->lock, flags); |
|
} |
|
|
|
/* on the last completion, signal usb_sg_wait() */ |
|
io->bytes += urb->actual_length; |
|
io->count--; |
|
if (!io->count) |
|
complete(&io->complete); |
|
|
|
spin_unlock_irqrestore(&io->lock, flags); |
|
} |
|
|
|
|
|
/** |
|
* usb_sg_init - initializes scatterlist-based bulk/interrupt I/O request |
|
* @io: request block being initialized. until usb_sg_wait() returns, |
|
* treat this as a pointer to an opaque block of memory, |
|
* @dev: the usb device that will send or receive the data |
|
* @pipe: endpoint "pipe" used to transfer the data |
|
* @period: polling rate for interrupt endpoints, in frames or |
|
* (for high speed endpoints) microframes; ignored for bulk |
|
* @sg: scatterlist entries |
|
* @nents: how many entries in the scatterlist |
|
* @length: how many bytes to send from the scatterlist, or zero to |
|
* send every byte identified in the list. |
|
* @mem_flags: SLAB_* flags affecting memory allocations in this call |
|
* |
|
* This initializes a scatter/gather request, allocating resources such as |
|
* I/O mappings and urb memory (except maybe memory used by USB controller |
|
* drivers). |
|
* |
|
* The request must be issued using usb_sg_wait(), which waits for the I/O to |
|
* complete (or to be canceled) and then cleans up all resources allocated by |
|
* usb_sg_init(). |
|
* |
|
* The request may be canceled with usb_sg_cancel(), either before or after |
|
* usb_sg_wait() is called. |
|
* |
|
* Return: Zero for success, else a negative errno value. |
|
*/ |
|
int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev, |
|
unsigned pipe, unsigned period, struct scatterlist *sg, |
|
int nents, size_t length, gfp_t mem_flags) |
|
{ |
|
int i; |
|
int urb_flags; |
|
int use_sg; |
|
|
|
if (!io || !dev || !sg |
|
|| usb_pipecontrol(pipe) |
|
|| usb_pipeisoc(pipe) |
|
|| nents <= 0) |
|
return -EINVAL; |
|
|
|
spin_lock_init(&io->lock); |
|
io->dev = dev; |
|
io->pipe = pipe; |
|
|
|
if (dev->bus->sg_tablesize > 0) { |
|
use_sg = true; |
|
io->entries = 1; |
|
} else { |
|
use_sg = false; |
|
io->entries = nents; |
|
} |
|
|
|
/* initialize all the urbs we'll use */ |
|
io->urbs = kmalloc_array(io->entries, sizeof(*io->urbs), mem_flags); |
|
if (!io->urbs) |
|
goto nomem; |
|
|
|
urb_flags = URB_NO_INTERRUPT; |
|
if (usb_pipein(pipe)) |
|
urb_flags |= URB_SHORT_NOT_OK; |
|
|
|
for_each_sg(sg, sg, io->entries, i) { |
|
struct urb *urb; |
|
unsigned len; |
|
|
|
urb = usb_alloc_urb(0, mem_flags); |
|
if (!urb) { |
|
io->entries = i; |
|
goto nomem; |
|
} |
|
io->urbs[i] = urb; |
|
|
|
urb->dev = NULL; |
|
urb->pipe = pipe; |
|
urb->interval = period; |
|
urb->transfer_flags = urb_flags; |
|
urb->complete = sg_complete; |
|
urb->context = io; |
|
urb->sg = sg; |
|
|
|
if (use_sg) { |
|
/* There is no single transfer buffer */ |
|
urb->transfer_buffer = NULL; |
|
urb->num_sgs = nents; |
|
|
|
/* A length of zero means transfer the whole sg list */ |
|
len = length; |
|
if (len == 0) { |
|
struct scatterlist *sg2; |
|
int j; |
|
|
|
for_each_sg(sg, sg2, nents, j) |
|
len += sg2->length; |
|
} |
|
} else { |
|
/* |
|
* Some systems can't use DMA; they use PIO instead. |
|
* For their sakes, transfer_buffer is set whenever |
|
* possible. |
|
*/ |
|
if (!PageHighMem(sg_page(sg))) |
|
urb->transfer_buffer = sg_virt(sg); |
|
else |
|
urb->transfer_buffer = NULL; |
|
|
|
len = sg->length; |
|
if (length) { |
|
len = min_t(size_t, len, length); |
|
length -= len; |
|
if (length == 0) |
|
io->entries = i + 1; |
|
} |
|
} |
|
urb->transfer_buffer_length = len; |
|
} |
|
io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT; |
|
|
|
/* transaction state */ |
|
io->count = io->entries; |
|
io->status = 0; |
|
io->bytes = 0; |
|
init_completion(&io->complete); |
|
return 0; |
|
|
|
nomem: |
|
sg_clean(io); |
|
return -ENOMEM; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_sg_init); |
|
|
|
/** |
|
* usb_sg_wait - synchronously execute scatter/gather request |
|
* @io: request block handle, as initialized with usb_sg_init(). |
|
* some fields become accessible when this call returns. |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* This function blocks until the specified I/O operation completes. It |
|
* leverages the grouping of the related I/O requests to get good transfer |
|
* rates, by queueing the requests. At higher speeds, such queuing can |
|
* significantly improve USB throughput. |
|
* |
|
* There are three kinds of completion for this function. |
|
* |
|
* (1) success, where io->status is zero. The number of io->bytes |
|
* transferred is as requested. |
|
* (2) error, where io->status is a negative errno value. The number |
|
* of io->bytes transferred before the error is usually less |
|
* than requested, and can be nonzero. |
|
* (3) cancellation, a type of error with status -ECONNRESET that |
|
* is initiated by usb_sg_cancel(). |
|
* |
|
* When this function returns, all memory allocated through usb_sg_init() or |
|
* this call will have been freed. The request block parameter may still be |
|
* passed to usb_sg_cancel(), or it may be freed. It could also be |
|
* reinitialized and then reused. |
|
* |
|
* Data Transfer Rates: |
|
* |
|
* Bulk transfers are valid for full or high speed endpoints. |
|
* The best full speed data rate is 19 packets of 64 bytes each |
|
* per frame, or 1216 bytes per millisecond. |
|
* The best high speed data rate is 13 packets of 512 bytes each |
|
* per microframe, or 52 KBytes per millisecond. |
|
* |
|
* The reason to use interrupt transfers through this API would most likely |
|
* be to reserve high speed bandwidth, where up to 24 KBytes per millisecond |
|
* could be transferred. That capability is less useful for low or full |
|
* speed interrupt endpoints, which allow at most one packet per millisecond, |
|
* of at most 8 or 64 bytes (respectively). |
|
* |
|
* It is not necessary to call this function to reserve bandwidth for devices |
|
* under an xHCI host controller, as the bandwidth is reserved when the |
|
* configuration or interface alt setting is selected. |
|
*/ |
|
void usb_sg_wait(struct usb_sg_request *io) |
|
{ |
|
int i; |
|
int entries = io->entries; |
|
|
|
/* queue the urbs. */ |
|
spin_lock_irq(&io->lock); |
|
i = 0; |
|
while (i < entries && !io->status) { |
|
int retval; |
|
|
|
io->urbs[i]->dev = io->dev; |
|
spin_unlock_irq(&io->lock); |
|
|
|
retval = usb_submit_urb(io->urbs[i], GFP_NOIO); |
|
|
|
switch (retval) { |
|
/* maybe we retrying will recover */ |
|
case -ENXIO: /* hc didn't queue this one */ |
|
case -EAGAIN: |
|
case -ENOMEM: |
|
retval = 0; |
|
yield(); |
|
break; |
|
|
|
/* no error? continue immediately. |
|
* |
|
* NOTE: to work better with UHCI (4K I/O buffer may |
|
* need 3K of TDs) it may be good to limit how many |
|
* URBs are queued at once; N milliseconds? |
|
*/ |
|
case 0: |
|
++i; |
|
cpu_relax(); |
|
break; |
|
|
|
/* fail any uncompleted urbs */ |
|
default: |
|
io->urbs[i]->status = retval; |
|
dev_dbg(&io->dev->dev, "%s, submit --> %d\n", |
|
__func__, retval); |
|
usb_sg_cancel(io); |
|
} |
|
spin_lock_irq(&io->lock); |
|
if (retval && (io->status == 0 || io->status == -ECONNRESET)) |
|
io->status = retval; |
|
} |
|
io->count -= entries - i; |
|
if (io->count == 0) |
|
complete(&io->complete); |
|
spin_unlock_irq(&io->lock); |
|
|
|
/* OK, yes, this could be packaged as non-blocking. |
|
* So could the submit loop above ... but it's easier to |
|
* solve neither problem than to solve both! |
|
*/ |
|
wait_for_completion(&io->complete); |
|
|
|
sg_clean(io); |
|
} |
|
EXPORT_SYMBOL_GPL(usb_sg_wait); |
|
|
|
/** |
|
* usb_sg_cancel - stop scatter/gather i/o issued by usb_sg_wait() |
|
* @io: request block, initialized with usb_sg_init() |
|
* |
|
* This stops a request after it has been started by usb_sg_wait(). |
|
* It can also prevents one initialized by usb_sg_init() from starting, |
|
* so that call just frees resources allocated to the request. |
|
*/ |
|
void usb_sg_cancel(struct usb_sg_request *io) |
|
{ |
|
unsigned long flags; |
|
int i, retval; |
|
|
|
spin_lock_irqsave(&io->lock, flags); |
|
if (io->status || io->count == 0) { |
|
spin_unlock_irqrestore(&io->lock, flags); |
|
return; |
|
} |
|
/* shut everything down */ |
|
io->status = -ECONNRESET; |
|
io->count++; /* Keep the request alive until we're done */ |
|
spin_unlock_irqrestore(&io->lock, flags); |
|
|
|
for (i = io->entries - 1; i >= 0; --i) { |
|
usb_block_urb(io->urbs[i]); |
|
|
|
retval = usb_unlink_urb(io->urbs[i]); |
|
if (retval != -EINPROGRESS |
|
&& retval != -ENODEV |
|
&& retval != -EBUSY |
|
&& retval != -EIDRM) |
|
dev_warn(&io->dev->dev, "%s, unlink --> %d\n", |
|
__func__, retval); |
|
} |
|
|
|
spin_lock_irqsave(&io->lock, flags); |
|
io->count--; |
|
if (!io->count) |
|
complete(&io->complete); |
|
spin_unlock_irqrestore(&io->lock, flags); |
|
} |
|
EXPORT_SYMBOL_GPL(usb_sg_cancel); |
|
|
|
/*-------------------------------------------------------------------*/ |
|
|
|
/** |
|
* usb_get_descriptor - issues a generic GET_DESCRIPTOR request |
|
* @dev: the device whose descriptor is being retrieved |
|
* @type: the descriptor type (USB_DT_*) |
|
* @index: the number of the descriptor |
|
* @buf: where to put the descriptor |
|
* @size: how big is "buf"? |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* Gets a USB descriptor. Convenience functions exist to simplify |
|
* getting some types of descriptors. Use |
|
* usb_get_string() or usb_string() for USB_DT_STRING. |
|
* Device (USB_DT_DEVICE) and configuration descriptors (USB_DT_CONFIG) |
|
* are part of the device structure. |
|
* In addition to a number of USB-standard descriptors, some |
|
* devices also use class-specific or vendor-specific descriptors. |
|
* |
|
* This call is synchronous, and may not be used in an interrupt context. |
|
* |
|
* Return: The number of bytes received on success, or else the status code |
|
* returned by the underlying usb_control_msg() call. |
|
*/ |
|
int usb_get_descriptor(struct usb_device *dev, unsigned char type, |
|
unsigned char index, void *buf, int size) |
|
{ |
|
int i; |
|
int result; |
|
|
|
memset(buf, 0, size); /* Make sure we parse really received data */ |
|
|
|
for (i = 0; i < 3; ++i) { |
|
/* retry on length 0 or error; some devices are flakey */ |
|
result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), |
|
USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, |
|
(type << 8) + index, 0, buf, size, |
|
USB_CTRL_GET_TIMEOUT); |
|
if (result <= 0 && result != -ETIMEDOUT) |
|
continue; |
|
if (result > 1 && ((u8 *)buf)[1] != type) { |
|
result = -ENODATA; |
|
continue; |
|
} |
|
break; |
|
} |
|
return result; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_get_descriptor); |
|
|
|
/** |
|
* usb_get_string - gets a string descriptor |
|
* @dev: the device whose string descriptor is being retrieved |
|
* @langid: code for language chosen (from string descriptor zero) |
|
* @index: the number of the descriptor |
|
* @buf: where to put the string |
|
* @size: how big is "buf"? |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* Retrieves a string, encoded using UTF-16LE (Unicode, 16 bits per character, |
|
* in little-endian byte order). |
|
* The usb_string() function will often be a convenient way to turn |
|
* these strings into kernel-printable form. |
|
* |
|
* Strings may be referenced in device, configuration, interface, or other |
|
* descriptors, and could also be used in vendor-specific ways. |
|
* |
|
* This call is synchronous, and may not be used in an interrupt context. |
|
* |
|
* Return: The number of bytes received on success, or else the status code |
|
* returned by the underlying usb_control_msg() call. |
|
*/ |
|
static int usb_get_string(struct usb_device *dev, unsigned short langid, |
|
unsigned char index, void *buf, int size) |
|
{ |
|
int i; |
|
int result; |
|
|
|
for (i = 0; i < 3; ++i) { |
|
/* retry on length 0 or stall; some devices are flakey */ |
|
result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), |
|
USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, |
|
(USB_DT_STRING << 8) + index, langid, buf, size, |
|
USB_CTRL_GET_TIMEOUT); |
|
if (result == 0 || result == -EPIPE) |
|
continue; |
|
if (result > 1 && ((u8 *) buf)[1] != USB_DT_STRING) { |
|
result = -ENODATA; |
|
continue; |
|
} |
|
break; |
|
} |
|
return result; |
|
} |
|
|
|
static void usb_try_string_workarounds(unsigned char *buf, int *length) |
|
{ |
|
int newlength, oldlength = *length; |
|
|
|
for (newlength = 2; newlength + 1 < oldlength; newlength += 2) |
|
if (!isprint(buf[newlength]) || buf[newlength + 1]) |
|
break; |
|
|
|
if (newlength > 2) { |
|
buf[0] = newlength; |
|
*length = newlength; |
|
} |
|
} |
|
|
|
static int usb_string_sub(struct usb_device *dev, unsigned int langid, |
|
unsigned int index, unsigned char *buf) |
|
{ |
|
int rc; |
|
|
|
/* Try to read the string descriptor by asking for the maximum |
|
* possible number of bytes */ |
|
if (dev->quirks & USB_QUIRK_STRING_FETCH_255) |
|
rc = -EIO; |
|
else |
|
rc = usb_get_string(dev, langid, index, buf, 255); |
|
|
|
/* If that failed try to read the descriptor length, then |
|
* ask for just that many bytes */ |
|
if (rc < 2) { |
|
rc = usb_get_string(dev, langid, index, buf, 2); |
|
if (rc == 2) |
|
rc = usb_get_string(dev, langid, index, buf, buf[0]); |
|
} |
|
|
|
if (rc >= 2) { |
|
if (!buf[0] && !buf[1]) |
|
usb_try_string_workarounds(buf, &rc); |
|
|
|
/* There might be extra junk at the end of the descriptor */ |
|
if (buf[0] < rc) |
|
rc = buf[0]; |
|
|
|
rc = rc - (rc & 1); /* force a multiple of two */ |
|
} |
|
|
|
if (rc < 2) |
|
rc = (rc < 0 ? rc : -EINVAL); |
|
|
|
return rc; |
|
} |
|
|
|
static int usb_get_langid(struct usb_device *dev, unsigned char *tbuf) |
|
{ |
|
int err; |
|
|
|
if (dev->have_langid) |
|
return 0; |
|
|
|
if (dev->string_langid < 0) |
|
return -EPIPE; |
|
|
|
err = usb_string_sub(dev, 0, 0, tbuf); |
|
|
|
/* If the string was reported but is malformed, default to english |
|
* (0x0409) */ |
|
if (err == -ENODATA || (err > 0 && err < 4)) { |
|
dev->string_langid = 0x0409; |
|
dev->have_langid = 1; |
|
dev_err(&dev->dev, |
|
"language id specifier not provided by device, defaulting to English\n"); |
|
return 0; |
|
} |
|
|
|
/* In case of all other errors, we assume the device is not able to |
|
* deal with strings at all. Set string_langid to -1 in order to |
|
* prevent any string to be retrieved from the device */ |
|
if (err < 0) { |
|
dev_info(&dev->dev, "string descriptor 0 read error: %d\n", |
|
err); |
|
dev->string_langid = -1; |
|
return -EPIPE; |
|
} |
|
|
|
/* always use the first langid listed */ |
|
dev->string_langid = tbuf[2] | (tbuf[3] << 8); |
|
dev->have_langid = 1; |
|
dev_dbg(&dev->dev, "default language 0x%04x\n", |
|
dev->string_langid); |
|
return 0; |
|
} |
|
|
|
/** |
|
* usb_string - returns UTF-8 version of a string descriptor |
|
* @dev: the device whose string descriptor is being retrieved |
|
* @index: the number of the descriptor |
|
* @buf: where to put the string |
|
* @size: how big is "buf"? |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* This converts the UTF-16LE encoded strings returned by devices, from |
|
* usb_get_string_descriptor(), to null-terminated UTF-8 encoded ones |
|
* that are more usable in most kernel contexts. Note that this function |
|
* chooses strings in the first language supported by the device. |
|
* |
|
* This call is synchronous, and may not be used in an interrupt context. |
|
* |
|
* Return: length of the string (>= 0) or usb_control_msg status (< 0). |
|
*/ |
|
int usb_string(struct usb_device *dev, int index, char *buf, size_t size) |
|
{ |
|
unsigned char *tbuf; |
|
int err; |
|
|
|
if (dev->state == USB_STATE_SUSPENDED) |
|
return -EHOSTUNREACH; |
|
if (size <= 0 || !buf) |
|
return -EINVAL; |
|
buf[0] = 0; |
|
if (index <= 0 || index >= 256) |
|
return -EINVAL; |
|
tbuf = kmalloc(256, GFP_NOIO); |
|
if (!tbuf) |
|
return -ENOMEM; |
|
|
|
err = usb_get_langid(dev, tbuf); |
|
if (err < 0) |
|
goto errout; |
|
|
|
err = usb_string_sub(dev, dev->string_langid, index, tbuf); |
|
if (err < 0) |
|
goto errout; |
|
|
|
size--; /* leave room for trailing NULL char in output buffer */ |
|
err = utf16s_to_utf8s((wchar_t *) &tbuf[2], (err - 2) / 2, |
|
UTF16_LITTLE_ENDIAN, buf, size); |
|
buf[err] = 0; |
|
|
|
if (tbuf[1] != USB_DT_STRING) |
|
dev_dbg(&dev->dev, |
|
"wrong descriptor type %02x for string %d (\"%s\")\n", |
|
tbuf[1], index, buf); |
|
|
|
errout: |
|
kfree(tbuf); |
|
return err; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_string); |
|
|
|
/* one UTF-8-encoded 16-bit character has at most three bytes */ |
|
#define MAX_USB_STRING_SIZE (127 * 3 + 1) |
|
|
|
/** |
|
* usb_cache_string - read a string descriptor and cache it for later use |
|
* @udev: the device whose string descriptor is being read |
|
* @index: the descriptor index |
|
* |
|
* Return: A pointer to a kmalloc'ed buffer containing the descriptor string, |
|
* or %NULL if the index is 0 or the string could not be read. |
|
*/ |
|
char *usb_cache_string(struct usb_device *udev, int index) |
|
{ |
|
char *buf; |
|
char *smallbuf = NULL; |
|
int len; |
|
|
|
if (index <= 0) |
|
return NULL; |
|
|
|
buf = kmalloc(MAX_USB_STRING_SIZE, GFP_NOIO); |
|
if (buf) { |
|
len = usb_string(udev, index, buf, MAX_USB_STRING_SIZE); |
|
if (len > 0) { |
|
smallbuf = kmalloc(++len, GFP_NOIO); |
|
if (!smallbuf) |
|
return buf; |
|
memcpy(smallbuf, buf, len); |
|
} |
|
kfree(buf); |
|
} |
|
return smallbuf; |
|
} |
|
|
|
/* |
|
* usb_get_device_descriptor - (re)reads the device descriptor (usbcore) |
|
* @dev: the device whose device descriptor is being updated |
|
* @size: how much of the descriptor to read |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* Updates the copy of the device descriptor stored in the device structure, |
|
* which dedicates space for this purpose. |
|
* |
|
* Not exported, only for use by the core. If drivers really want to read |
|
* the device descriptor directly, they can call usb_get_descriptor() with |
|
* type = USB_DT_DEVICE and index = 0. |
|
* |
|
* This call is synchronous, and may not be used in an interrupt context. |
|
* |
|
* Return: The number of bytes received on success, or else the status code |
|
* returned by the underlying usb_control_msg() call. |
|
*/ |
|
int usb_get_device_descriptor(struct usb_device *dev, unsigned int size) |
|
{ |
|
struct usb_device_descriptor *desc; |
|
int ret; |
|
|
|
if (size > sizeof(*desc)) |
|
return -EINVAL; |
|
desc = kmalloc(sizeof(*desc), GFP_NOIO); |
|
if (!desc) |
|
return -ENOMEM; |
|
|
|
ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, size); |
|
if (ret >= 0) |
|
memcpy(&dev->descriptor, desc, size); |
|
kfree(desc); |
|
return ret; |
|
} |
|
|
|
/* |
|
* usb_set_isoch_delay - informs the device of the packet transmit delay |
|
* @dev: the device whose delay is to be informed |
|
* Context: task context, might sleep |
|
* |
|
* Since this is an optional request, we don't bother if it fails. |
|
*/ |
|
int usb_set_isoch_delay(struct usb_device *dev) |
|
{ |
|
/* skip hub devices */ |
|
if (dev->descriptor.bDeviceClass == USB_CLASS_HUB) |
|
return 0; |
|
|
|
/* skip non-SS/non-SSP devices */ |
|
if (dev->speed < USB_SPEED_SUPER) |
|
return 0; |
|
|
|
return usb_control_msg_send(dev, 0, |
|
USB_REQ_SET_ISOCH_DELAY, |
|
USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE, |
|
dev->hub_delay, 0, NULL, 0, |
|
USB_CTRL_SET_TIMEOUT, |
|
GFP_NOIO); |
|
} |
|
|
|
/** |
|
* usb_get_status - issues a GET_STATUS call |
|
* @dev: the device whose status is being checked |
|
* @recip: USB_RECIP_*; for device, interface, or endpoint |
|
* @type: USB_STATUS_TYPE_*; for standard or PTM status types |
|
* @target: zero (for device), else interface or endpoint number |
|
* @data: pointer to two bytes of bitmap data |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* Returns device, interface, or endpoint status. Normally only of |
|
* interest to see if the device is self powered, or has enabled the |
|
* remote wakeup facility; or whether a bulk or interrupt endpoint |
|
* is halted ("stalled"). |
|
* |
|
* Bits in these status bitmaps are set using the SET_FEATURE request, |
|
* and cleared using the CLEAR_FEATURE request. The usb_clear_halt() |
|
* function should be used to clear halt ("stall") status. |
|
* |
|
* This call is synchronous, and may not be used in an interrupt context. |
|
* |
|
* Returns 0 and the status value in *@data (in host byte order) on success, |
|
* or else the status code from the underlying usb_control_msg() call. |
|
*/ |
|
int usb_get_status(struct usb_device *dev, int recip, int type, int target, |
|
void *data) |
|
{ |
|
int ret; |
|
void *status; |
|
int length; |
|
|
|
switch (type) { |
|
case USB_STATUS_TYPE_STANDARD: |
|
length = 2; |
|
break; |
|
case USB_STATUS_TYPE_PTM: |
|
if (recip != USB_RECIP_DEVICE) |
|
return -EINVAL; |
|
|
|
length = 4; |
|
break; |
|
default: |
|
return -EINVAL; |
|
} |
|
|
|
status = kmalloc(length, GFP_KERNEL); |
|
if (!status) |
|
return -ENOMEM; |
|
|
|
ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), |
|
USB_REQ_GET_STATUS, USB_DIR_IN | recip, USB_STATUS_TYPE_STANDARD, |
|
target, status, length, USB_CTRL_GET_TIMEOUT); |
|
|
|
switch (ret) { |
|
case 4: |
|
if (type != USB_STATUS_TYPE_PTM) { |
|
ret = -EIO; |
|
break; |
|
} |
|
|
|
*(u32 *) data = le32_to_cpu(*(__le32 *) status); |
|
ret = 0; |
|
break; |
|
case 2: |
|
if (type != USB_STATUS_TYPE_STANDARD) { |
|
ret = -EIO; |
|
break; |
|
} |
|
|
|
*(u16 *) data = le16_to_cpu(*(__le16 *) status); |
|
ret = 0; |
|
break; |
|
default: |
|
ret = -EIO; |
|
} |
|
|
|
kfree(status); |
|
return ret; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_get_status); |
|
|
|
/** |
|
* usb_clear_halt - tells device to clear endpoint halt/stall condition |
|
* @dev: device whose endpoint is halted |
|
* @pipe: endpoint "pipe" being cleared |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* This is used to clear halt conditions for bulk and interrupt endpoints, |
|
* as reported by URB completion status. Endpoints that are halted are |
|
* sometimes referred to as being "stalled". Such endpoints are unable |
|
* to transmit or receive data until the halt status is cleared. Any URBs |
|
* queued for such an endpoint should normally be unlinked by the driver |
|
* before clearing the halt condition, as described in sections 5.7.5 |
|
* and 5.8.5 of the USB 2.0 spec. |
|
* |
|
* Note that control and isochronous endpoints don't halt, although control |
|
* endpoints report "protocol stall" (for unsupported requests) using the |
|
* same status code used to report a true stall. |
|
* |
|
* This call is synchronous, and may not be used in an interrupt context. |
|
* |
|
* Return: Zero on success, or else the status code returned by the |
|
* underlying usb_control_msg() call. |
|
*/ |
|
int usb_clear_halt(struct usb_device *dev, int pipe) |
|
{ |
|
int result; |
|
int endp = usb_pipeendpoint(pipe); |
|
|
|
if (usb_pipein(pipe)) |
|
endp |= USB_DIR_IN; |
|
|
|
/* we don't care if it wasn't halted first. in fact some devices |
|
* (like some ibmcam model 1 units) seem to expect hosts to make |
|
* this request for iso endpoints, which can't halt! |
|
*/ |
|
result = usb_control_msg_send(dev, 0, |
|
USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, |
|
USB_ENDPOINT_HALT, endp, NULL, 0, |
|
USB_CTRL_SET_TIMEOUT, GFP_NOIO); |
|
|
|
/* don't un-halt or force to DATA0 except on success */ |
|
if (result) |
|
return result; |
|
|
|
/* NOTE: seems like Microsoft and Apple don't bother verifying |
|
* the clear "took", so some devices could lock up if you check... |
|
* such as the Hagiwara FlashGate DUAL. So we won't bother. |
|
* |
|
* NOTE: make sure the logic here doesn't diverge much from |
|
* the copy in usb-storage, for as long as we need two copies. |
|
*/ |
|
|
|
usb_reset_endpoint(dev, endp); |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_clear_halt); |
|
|
|
static int create_intf_ep_devs(struct usb_interface *intf) |
|
{ |
|
struct usb_device *udev = interface_to_usbdev(intf); |
|
struct usb_host_interface *alt = intf->cur_altsetting; |
|
int i; |
|
|
|
if (intf->ep_devs_created || intf->unregistering) |
|
return 0; |
|
|
|
for (i = 0; i < alt->desc.bNumEndpoints; ++i) |
|
(void) usb_create_ep_devs(&intf->dev, &alt->endpoint[i], udev); |
|
intf->ep_devs_created = 1; |
|
return 0; |
|
} |
|
|
|
static void remove_intf_ep_devs(struct usb_interface *intf) |
|
{ |
|
struct usb_host_interface *alt = intf->cur_altsetting; |
|
int i; |
|
|
|
if (!intf->ep_devs_created) |
|
return; |
|
|
|
for (i = 0; i < alt->desc.bNumEndpoints; ++i) |
|
usb_remove_ep_devs(&alt->endpoint[i]); |
|
intf->ep_devs_created = 0; |
|
} |
|
|
|
void usb_fixup_endpoint(struct usb_device *dev, int epaddr, int interval) |
|
{ |
|
unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK; |
|
struct usb_host_endpoint *ep; |
|
|
|
if (usb_endpoint_out(epaddr)) |
|
ep = dev->ep_out[epnum]; |
|
else |
|
ep = dev->ep_in[epnum]; |
|
|
|
if (ep && usb_endpoint_xfer_int(&ep->desc)) |
|
usb_hcd_fixup_endpoint(dev, ep, interval); |
|
} |
|
EXPORT_SYMBOL_GPL(usb_fixup_endpoint); |
|
|
|
/** |
|
* usb_disable_endpoint -- Disable an endpoint by address |
|
* @dev: the device whose endpoint is being disabled |
|
* @epaddr: the endpoint's address. Endpoint number for output, |
|
* endpoint number + USB_DIR_IN for input |
|
* @reset_hardware: flag to erase any endpoint state stored in the |
|
* controller hardware |
|
* |
|
* Disables the endpoint for URB submission and nukes all pending URBs. |
|
* If @reset_hardware is set then also deallocates hcd/hardware state |
|
* for the endpoint. |
|
*/ |
|
void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr, |
|
bool reset_hardware) |
|
{ |
|
unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK; |
|
struct usb_host_endpoint *ep; |
|
|
|
if (!dev) |
|
return; |
|
|
|
if (usb_endpoint_out(epaddr)) { |
|
ep = dev->ep_out[epnum]; |
|
if (reset_hardware && epnum != 0) |
|
dev->ep_out[epnum] = NULL; |
|
} else { |
|
ep = dev->ep_in[epnum]; |
|
if (reset_hardware && epnum != 0) |
|
dev->ep_in[epnum] = NULL; |
|
} |
|
if (ep) { |
|
ep->enabled = 0; |
|
usb_hcd_flush_endpoint(dev, ep); |
|
if (reset_hardware) |
|
usb_hcd_disable_endpoint(dev, ep); |
|
} |
|
} |
|
|
|
/** |
|
* usb_reset_endpoint - Reset an endpoint's state. |
|
* @dev: the device whose endpoint is to be reset |
|
* @epaddr: the endpoint's address. Endpoint number for output, |
|
* endpoint number + USB_DIR_IN for input |
|
* |
|
* Resets any host-side endpoint state such as the toggle bit, |
|
* sequence number or current window. |
|
*/ |
|
void usb_reset_endpoint(struct usb_device *dev, unsigned int epaddr) |
|
{ |
|
unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK; |
|
struct usb_host_endpoint *ep; |
|
|
|
if (usb_endpoint_out(epaddr)) |
|
ep = dev->ep_out[epnum]; |
|
else |
|
ep = dev->ep_in[epnum]; |
|
if (ep) |
|
usb_hcd_reset_endpoint(dev, ep); |
|
} |
|
EXPORT_SYMBOL_GPL(usb_reset_endpoint); |
|
|
|
|
|
/** |
|
* usb_disable_interface -- Disable all endpoints for an interface |
|
* @dev: the device whose interface is being disabled |
|
* @intf: pointer to the interface descriptor |
|
* @reset_hardware: flag to erase any endpoint state stored in the |
|
* controller hardware |
|
* |
|
* Disables all the endpoints for the interface's current altsetting. |
|
*/ |
|
void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf, |
|
bool reset_hardware) |
|
{ |
|
struct usb_host_interface *alt = intf->cur_altsetting; |
|
int i; |
|
|
|
for (i = 0; i < alt->desc.bNumEndpoints; ++i) { |
|
usb_disable_endpoint(dev, |
|
alt->endpoint[i].desc.bEndpointAddress, |
|
reset_hardware); |
|
} |
|
} |
|
|
|
/* |
|
* usb_disable_device_endpoints -- Disable all endpoints for a device |
|
* @dev: the device whose endpoints are being disabled |
|
* @skip_ep0: 0 to disable endpoint 0, 1 to skip it. |
|
*/ |
|
static void usb_disable_device_endpoints(struct usb_device *dev, int skip_ep0) |
|
{ |
|
struct usb_hcd *hcd = bus_to_hcd(dev->bus); |
|
int i; |
|
|
|
if (hcd->driver->check_bandwidth) { |
|
/* First pass: Cancel URBs, leave endpoint pointers intact. */ |
|
for (i = skip_ep0; i < 16; ++i) { |
|
usb_disable_endpoint(dev, i, false); |
|
usb_disable_endpoint(dev, i + USB_DIR_IN, false); |
|
} |
|
/* Remove endpoints from the host controller internal state */ |
|
mutex_lock(hcd->bandwidth_mutex); |
|
usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL); |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
} |
|
/* Second pass: remove endpoint pointers */ |
|
for (i = skip_ep0; i < 16; ++i) { |
|
usb_disable_endpoint(dev, i, true); |
|
usb_disable_endpoint(dev, i + USB_DIR_IN, true); |
|
} |
|
} |
|
|
|
/** |
|
* usb_disable_device - Disable all the endpoints for a USB device |
|
* @dev: the device whose endpoints are being disabled |
|
* @skip_ep0: 0 to disable endpoint 0, 1 to skip it. |
|
* |
|
* Disables all the device's endpoints, potentially including endpoint 0. |
|
* Deallocates hcd/hardware state for the endpoints (nuking all or most |
|
* pending urbs) and usbcore state for the interfaces, so that usbcore |
|
* must usb_set_configuration() before any interfaces could be used. |
|
*/ |
|
void usb_disable_device(struct usb_device *dev, int skip_ep0) |
|
{ |
|
int i; |
|
|
|
/* getting rid of interfaces will disconnect |
|
* any drivers bound to them (a key side effect) |
|
*/ |
|
if (dev->actconfig) { |
|
/* |
|
* FIXME: In order to avoid self-deadlock involving the |
|
* bandwidth_mutex, we have to mark all the interfaces |
|
* before unregistering any of them. |
|
*/ |
|
for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) |
|
dev->actconfig->interface[i]->unregistering = 1; |
|
|
|
for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) { |
|
struct usb_interface *interface; |
|
|
|
/* remove this interface if it has been registered */ |
|
interface = dev->actconfig->interface[i]; |
|
if (!device_is_registered(&interface->dev)) |
|
continue; |
|
dev_dbg(&dev->dev, "unregistering interface %s\n", |
|
dev_name(&interface->dev)); |
|
remove_intf_ep_devs(interface); |
|
device_del(&interface->dev); |
|
} |
|
|
|
/* Now that the interfaces are unbound, nobody should |
|
* try to access them. |
|
*/ |
|
for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) { |
|
put_device(&dev->actconfig->interface[i]->dev); |
|
dev->actconfig->interface[i] = NULL; |
|
} |
|
|
|
usb_disable_usb2_hardware_lpm(dev); |
|
usb_unlocked_disable_lpm(dev); |
|
usb_disable_ltm(dev); |
|
|
|
dev->actconfig = NULL; |
|
if (dev->state == USB_STATE_CONFIGURED) |
|
usb_set_device_state(dev, USB_STATE_ADDRESS); |
|
} |
|
|
|
dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__, |
|
skip_ep0 ? "non-ep0" : "all"); |
|
|
|
usb_disable_device_endpoints(dev, skip_ep0); |
|
} |
|
|
|
/** |
|
* usb_enable_endpoint - Enable an endpoint for USB communications |
|
* @dev: the device whose interface is being enabled |
|
* @ep: the endpoint |
|
* @reset_ep: flag to reset the endpoint state |
|
* |
|
* Resets the endpoint state if asked, and sets dev->ep_{in,out} pointers. |
|
* For control endpoints, both the input and output sides are handled. |
|
*/ |
|
void usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep, |
|
bool reset_ep) |
|
{ |
|
int epnum = usb_endpoint_num(&ep->desc); |
|
int is_out = usb_endpoint_dir_out(&ep->desc); |
|
int is_control = usb_endpoint_xfer_control(&ep->desc); |
|
|
|
if (reset_ep) |
|
usb_hcd_reset_endpoint(dev, ep); |
|
if (is_out || is_control) |
|
dev->ep_out[epnum] = ep; |
|
if (!is_out || is_control) |
|
dev->ep_in[epnum] = ep; |
|
ep->enabled = 1; |
|
} |
|
|
|
/** |
|
* usb_enable_interface - Enable all the endpoints for an interface |
|
* @dev: the device whose interface is being enabled |
|
* @intf: pointer to the interface descriptor |
|
* @reset_eps: flag to reset the endpoints' state |
|
* |
|
* Enables all the endpoints for the interface's current altsetting. |
|
*/ |
|
void usb_enable_interface(struct usb_device *dev, |
|
struct usb_interface *intf, bool reset_eps) |
|
{ |
|
struct usb_host_interface *alt = intf->cur_altsetting; |
|
int i; |
|
|
|
for (i = 0; i < alt->desc.bNumEndpoints; ++i) |
|
usb_enable_endpoint(dev, &alt->endpoint[i], reset_eps); |
|
} |
|
|
|
/** |
|
* usb_set_interface - Makes a particular alternate setting be current |
|
* @dev: the device whose interface is being updated |
|
* @interface: the interface being updated |
|
* @alternate: the setting being chosen. |
|
* |
|
* Context: task context, might sleep. |
|
* |
|
* This is used to enable data transfers on interfaces that may not |
|
* be enabled by default. Not all devices support such configurability. |
|
* Only the driver bound to an interface may change its setting. |
|
* |
|
* Within any given configuration, each interface may have several |
|
* alternative settings. These are often used to control levels of |
|
* bandwidth consumption. For example, the default setting for a high |
|
* speed interrupt endpoint may not send more than 64 bytes per microframe, |
|
* while interrupt transfers of up to 3KBytes per microframe are legal. |
|
* Also, isochronous endpoints may never be part of an |
|
* interface's default setting. To access such bandwidth, alternate |
|
* interface settings must be made current. |
|
* |
|
* Note that in the Linux USB subsystem, bandwidth associated with |
|
* an endpoint in a given alternate setting is not reserved until an URB |
|
* is submitted that needs that bandwidth. Some other operating systems |
|
* allocate bandwidth early, when a configuration is chosen. |
|
* |
|
* xHCI reserves bandwidth and configures the alternate setting in |
|
* usb_hcd_alloc_bandwidth(). If it fails the original interface altsetting |
|
* may be disabled. Drivers cannot rely on any particular alternate |
|
* setting being in effect after a failure. |
|
* |
|
* This call is synchronous, and may not be used in an interrupt context. |
|
* Also, drivers must not change altsettings while urbs are scheduled for |
|
* endpoints in that interface; all such urbs must first be completed |
|
* (perhaps forced by unlinking). |
|
* |
|
* Return: Zero on success, or else the status code returned by the |
|
* underlying usb_control_msg() call. |
|
*/ |
|
int usb_set_interface(struct usb_device *dev, int interface, int alternate) |
|
{ |
|
struct usb_interface *iface; |
|
struct usb_host_interface *alt; |
|
struct usb_hcd *hcd = bus_to_hcd(dev->bus); |
|
int i, ret, manual = 0; |
|
unsigned int epaddr; |
|
unsigned int pipe; |
|
|
|
if (dev->state == USB_STATE_SUSPENDED) |
|
return -EHOSTUNREACH; |
|
|
|
iface = usb_ifnum_to_if(dev, interface); |
|
if (!iface) { |
|
dev_dbg(&dev->dev, "selecting invalid interface %d\n", |
|
interface); |
|
return -EINVAL; |
|
} |
|
if (iface->unregistering) |
|
return -ENODEV; |
|
|
|
alt = usb_altnum_to_altsetting(iface, alternate); |
|
if (!alt) { |
|
dev_warn(&dev->dev, "selecting invalid altsetting %d\n", |
|
alternate); |
|
return -EINVAL; |
|
} |
|
/* |
|
* usb3 hosts configure the interface in usb_hcd_alloc_bandwidth, |
|
* including freeing dropped endpoint ring buffers. |
|
* Make sure the interface endpoints are flushed before that |
|
*/ |
|
usb_disable_interface(dev, iface, false); |
|
|
|
/* Make sure we have enough bandwidth for this alternate interface. |
|
* Remove the current alt setting and add the new alt setting. |
|
*/ |
|
mutex_lock(hcd->bandwidth_mutex); |
|
/* Disable LPM, and re-enable it once the new alt setting is installed, |
|
* so that the xHCI driver can recalculate the U1/U2 timeouts. |
|
*/ |
|
if (usb_disable_lpm(dev)) { |
|
dev_err(&iface->dev, "%s Failed to disable LPM\n", __func__); |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
return -ENOMEM; |
|
} |
|
/* Changing alt-setting also frees any allocated streams */ |
|
for (i = 0; i < iface->cur_altsetting->desc.bNumEndpoints; i++) |
|
iface->cur_altsetting->endpoint[i].streams = 0; |
|
|
|
ret = usb_hcd_alloc_bandwidth(dev, NULL, iface->cur_altsetting, alt); |
|
if (ret < 0) { |
|
dev_info(&dev->dev, "Not enough bandwidth for altsetting %d\n", |
|
alternate); |
|
usb_enable_lpm(dev); |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
return ret; |
|
} |
|
|
|
if (dev->quirks & USB_QUIRK_NO_SET_INTF) |
|
ret = -EPIPE; |
|
else |
|
ret = usb_control_msg_send(dev, 0, |
|
USB_REQ_SET_INTERFACE, |
|
USB_RECIP_INTERFACE, alternate, |
|
interface, NULL, 0, 5000, |
|
GFP_NOIO); |
|
|
|
/* 9.4.10 says devices don't need this and are free to STALL the |
|
* request if the interface only has one alternate setting. |
|
*/ |
|
if (ret == -EPIPE && iface->num_altsetting == 1) { |
|
dev_dbg(&dev->dev, |
|
"manual set_interface for iface %d, alt %d\n", |
|
interface, alternate); |
|
manual = 1; |
|
} else if (ret) { |
|
/* Re-instate the old alt setting */ |
|
usb_hcd_alloc_bandwidth(dev, NULL, alt, iface->cur_altsetting); |
|
usb_enable_lpm(dev); |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
return ret; |
|
} |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
|
|
/* FIXME drivers shouldn't need to replicate/bugfix the logic here |
|
* when they implement async or easily-killable versions of this or |
|
* other "should-be-internal" functions (like clear_halt). |
|
* should hcd+usbcore postprocess control requests? |
|
*/ |
|
|
|
/* prevent submissions using previous endpoint settings */ |
|
if (iface->cur_altsetting != alt) { |
|
remove_intf_ep_devs(iface); |
|
usb_remove_sysfs_intf_files(iface); |
|
} |
|
usb_disable_interface(dev, iface, true); |
|
|
|
iface->cur_altsetting = alt; |
|
|
|
/* Now that the interface is installed, re-enable LPM. */ |
|
usb_unlocked_enable_lpm(dev); |
|
|
|
/* If the interface only has one altsetting and the device didn't |
|
* accept the request, we attempt to carry out the equivalent action |
|
* by manually clearing the HALT feature for each endpoint in the |
|
* new altsetting. |
|
*/ |
|
if (manual) { |
|
for (i = 0; i < alt->desc.bNumEndpoints; i++) { |
|
epaddr = alt->endpoint[i].desc.bEndpointAddress; |
|
pipe = __create_pipe(dev, |
|
USB_ENDPOINT_NUMBER_MASK & epaddr) | |
|
(usb_endpoint_out(epaddr) ? |
|
USB_DIR_OUT : USB_DIR_IN); |
|
|
|
usb_clear_halt(dev, pipe); |
|
} |
|
} |
|
|
|
/* 9.1.1.5: reset toggles for all endpoints in the new altsetting |
|
* |
|
* Note: |
|
* Despite EP0 is always present in all interfaces/AS, the list of |
|
* endpoints from the descriptor does not contain EP0. Due to its |
|
* omnipresence one might expect EP0 being considered "affected" by |
|
* any SetInterface request and hence assume toggles need to be reset. |
|
* However, EP0 toggles are re-synced for every individual transfer |
|
* during the SETUP stage - hence EP0 toggles are "don't care" here. |
|
* (Likewise, EP0 never "halts" on well designed devices.) |
|
*/ |
|
usb_enable_interface(dev, iface, true); |
|
if (device_is_registered(&iface->dev)) { |
|
usb_create_sysfs_intf_files(iface); |
|
create_intf_ep_devs(iface); |
|
} |
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_set_interface); |
|
|
|
/** |
|
* usb_reset_configuration - lightweight device reset |
|
* @dev: the device whose configuration is being reset |
|
* |
|
* This issues a standard SET_CONFIGURATION request to the device using |
|
* the current configuration. The effect is to reset most USB-related |
|
* state in the device, including interface altsettings (reset to zero), |
|
* endpoint halts (cleared), and endpoint state (only for bulk and interrupt |
|
* endpoints). Other usbcore state is unchanged, including bindings of |
|
* usb device drivers to interfaces. |
|
* |
|
* Because this affects multiple interfaces, avoid using this with composite |
|
* (multi-interface) devices. Instead, the driver for each interface may |
|
* use usb_set_interface() on the interfaces it claims. Be careful though; |
|
* some devices don't support the SET_INTERFACE request, and others won't |
|
* reset all the interface state (notably endpoint state). Resetting the whole |
|
* configuration would affect other drivers' interfaces. |
|
* |
|
* The caller must own the device lock. |
|
* |
|
* Return: Zero on success, else a negative error code. |
|
* |
|
* If this routine fails the device will probably be in an unusable state |
|
* with endpoints disabled, and interfaces only partially enabled. |
|
*/ |
|
int usb_reset_configuration(struct usb_device *dev) |
|
{ |
|
int i, retval; |
|
struct usb_host_config *config; |
|
struct usb_hcd *hcd = bus_to_hcd(dev->bus); |
|
|
|
if (dev->state == USB_STATE_SUSPENDED) |
|
return -EHOSTUNREACH; |
|
|
|
/* caller must have locked the device and must own |
|
* the usb bus readlock (so driver bindings are stable); |
|
* calls during probe() are fine |
|
*/ |
|
|
|
usb_disable_device_endpoints(dev, 1); /* skip ep0*/ |
|
|
|
config = dev->actconfig; |
|
retval = 0; |
|
mutex_lock(hcd->bandwidth_mutex); |
|
/* Disable LPM, and re-enable it once the configuration is reset, so |
|
* that the xHCI driver can recalculate the U1/U2 timeouts. |
|
*/ |
|
if (usb_disable_lpm(dev)) { |
|
dev_err(&dev->dev, "%s Failed to disable LPM\n", __func__); |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
return -ENOMEM; |
|
} |
|
|
|
/* xHCI adds all endpoints in usb_hcd_alloc_bandwidth */ |
|
retval = usb_hcd_alloc_bandwidth(dev, config, NULL, NULL); |
|
if (retval < 0) { |
|
usb_enable_lpm(dev); |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
return retval; |
|
} |
|
retval = usb_control_msg_send(dev, 0, USB_REQ_SET_CONFIGURATION, 0, |
|
config->desc.bConfigurationValue, 0, |
|
NULL, 0, USB_CTRL_SET_TIMEOUT, |
|
GFP_NOIO); |
|
if (retval) { |
|
usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL); |
|
usb_enable_lpm(dev); |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
return retval; |
|
} |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
|
|
/* re-init hc/hcd interface/endpoint state */ |
|
for (i = 0; i < config->desc.bNumInterfaces; i++) { |
|
struct usb_interface *intf = config->interface[i]; |
|
struct usb_host_interface *alt; |
|
|
|
alt = usb_altnum_to_altsetting(intf, 0); |
|
|
|
/* No altsetting 0? We'll assume the first altsetting. |
|
* We could use a GetInterface call, but if a device is |
|
* so non-compliant that it doesn't have altsetting 0 |
|
* then I wouldn't trust its reply anyway. |
|
*/ |
|
if (!alt) |
|
alt = &intf->altsetting[0]; |
|
|
|
if (alt != intf->cur_altsetting) { |
|
remove_intf_ep_devs(intf); |
|
usb_remove_sysfs_intf_files(intf); |
|
} |
|
intf->cur_altsetting = alt; |
|
usb_enable_interface(dev, intf, true); |
|
if (device_is_registered(&intf->dev)) { |
|
usb_create_sysfs_intf_files(intf); |
|
create_intf_ep_devs(intf); |
|
} |
|
} |
|
/* Now that the interfaces are installed, re-enable LPM. */ |
|
usb_unlocked_enable_lpm(dev); |
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_reset_configuration); |
|
|
|
static void usb_release_interface(struct device *dev) |
|
{ |
|
struct usb_interface *intf = to_usb_interface(dev); |
|
struct usb_interface_cache *intfc = |
|
altsetting_to_usb_interface_cache(intf->altsetting); |
|
|
|
kref_put(&intfc->ref, usb_release_interface_cache); |
|
usb_put_dev(interface_to_usbdev(intf)); |
|
of_node_put(dev->of_node); |
|
kfree(intf); |
|
} |
|
|
|
/* |
|
* usb_deauthorize_interface - deauthorize an USB interface |
|
* |
|
* @intf: USB interface structure |
|
*/ |
|
void usb_deauthorize_interface(struct usb_interface *intf) |
|
{ |
|
struct device *dev = &intf->dev; |
|
|
|
device_lock(dev->parent); |
|
|
|
if (intf->authorized) { |
|
device_lock(dev); |
|
intf->authorized = 0; |
|
device_unlock(dev); |
|
|
|
usb_forced_unbind_intf(intf); |
|
} |
|
|
|
device_unlock(dev->parent); |
|
} |
|
|
|
/* |
|
* usb_authorize_interface - authorize an USB interface |
|
* |
|
* @intf: USB interface structure |
|
*/ |
|
void usb_authorize_interface(struct usb_interface *intf) |
|
{ |
|
struct device *dev = &intf->dev; |
|
|
|
if (!intf->authorized) { |
|
device_lock(dev); |
|
intf->authorized = 1; /* authorize interface */ |
|
device_unlock(dev); |
|
} |
|
} |
|
|
|
static int usb_if_uevent(struct device *dev, struct kobj_uevent_env *env) |
|
{ |
|
struct usb_device *usb_dev; |
|
struct usb_interface *intf; |
|
struct usb_host_interface *alt; |
|
|
|
intf = to_usb_interface(dev); |
|
usb_dev = interface_to_usbdev(intf); |
|
alt = intf->cur_altsetting; |
|
|
|
if (add_uevent_var(env, "INTERFACE=%d/%d/%d", |
|
alt->desc.bInterfaceClass, |
|
alt->desc.bInterfaceSubClass, |
|
alt->desc.bInterfaceProtocol)) |
|
return -ENOMEM; |
|
|
|
if (add_uevent_var(env, |
|
"MODALIAS=usb:" |
|
"v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02Xin%02X", |
|
le16_to_cpu(usb_dev->descriptor.idVendor), |
|
le16_to_cpu(usb_dev->descriptor.idProduct), |
|
le16_to_cpu(usb_dev->descriptor.bcdDevice), |
|
usb_dev->descriptor.bDeviceClass, |
|
usb_dev->descriptor.bDeviceSubClass, |
|
usb_dev->descriptor.bDeviceProtocol, |
|
alt->desc.bInterfaceClass, |
|
alt->desc.bInterfaceSubClass, |
|
alt->desc.bInterfaceProtocol, |
|
alt->desc.bInterfaceNumber)) |
|
return -ENOMEM; |
|
|
|
return 0; |
|
} |
|
|
|
struct device_type usb_if_device_type = { |
|
.name = "usb_interface", |
|
.release = usb_release_interface, |
|
.uevent = usb_if_uevent, |
|
}; |
|
|
|
static struct usb_interface_assoc_descriptor *find_iad(struct usb_device *dev, |
|
struct usb_host_config *config, |
|
u8 inum) |
|
{ |
|
struct usb_interface_assoc_descriptor *retval = NULL; |
|
struct usb_interface_assoc_descriptor *intf_assoc; |
|
int first_intf; |
|
int last_intf; |
|
int i; |
|
|
|
for (i = 0; (i < USB_MAXIADS && config->intf_assoc[i]); i++) { |
|
intf_assoc = config->intf_assoc[i]; |
|
if (intf_assoc->bInterfaceCount == 0) |
|
continue; |
|
|
|
first_intf = intf_assoc->bFirstInterface; |
|
last_intf = first_intf + (intf_assoc->bInterfaceCount - 1); |
|
if (inum >= first_intf && inum <= last_intf) { |
|
if (!retval) |
|
retval = intf_assoc; |
|
else |
|
dev_err(&dev->dev, "Interface #%d referenced" |
|
" by multiple IADs\n", inum); |
|
} |
|
} |
|
|
|
return retval; |
|
} |
|
|
|
|
|
/* |
|
* Internal function to queue a device reset |
|
* See usb_queue_reset_device() for more details |
|
*/ |
|
static void __usb_queue_reset_device(struct work_struct *ws) |
|
{ |
|
int rc; |
|
struct usb_interface *iface = |
|
container_of(ws, struct usb_interface, reset_ws); |
|
struct usb_device *udev = interface_to_usbdev(iface); |
|
|
|
rc = usb_lock_device_for_reset(udev, iface); |
|
if (rc >= 0) { |
|
usb_reset_device(udev); |
|
usb_unlock_device(udev); |
|
} |
|
usb_put_intf(iface); /* Undo _get_ in usb_queue_reset_device() */ |
|
} |
|
|
|
|
|
/* |
|
* usb_set_configuration - Makes a particular device setting be current |
|
* @dev: the device whose configuration is being updated |
|
* @configuration: the configuration being chosen. |
|
* |
|
* Context: task context, might sleep. Caller holds device lock. |
|
* |
|
* This is used to enable non-default device modes. Not all devices |
|
* use this kind of configurability; many devices only have one |
|
* configuration. |
|
* |
|
* @configuration is the value of the configuration to be installed. |
|
* According to the USB spec (e.g. section 9.1.1.5), configuration values |
|
* must be non-zero; a value of zero indicates that the device in |
|
* unconfigured. However some devices erroneously use 0 as one of their |
|
* configuration values. To help manage such devices, this routine will |
|
* accept @configuration = -1 as indicating the device should be put in |
|
* an unconfigured state. |
|
* |
|
* USB device configurations may affect Linux interoperability, |
|
* power consumption and the functionality available. For example, |
|
* the default configuration is limited to using 100mA of bus power, |
|
* so that when certain device functionality requires more power, |
|
* and the device is bus powered, that functionality should be in some |
|
* non-default device configuration. Other device modes may also be |
|
* reflected as configuration options, such as whether two ISDN |
|
* channels are available independently; and choosing between open |
|
* standard device protocols (like CDC) or proprietary ones. |
|
* |
|
* Note that a non-authorized device (dev->authorized == 0) will only |
|
* be put in unconfigured mode. |
|
* |
|
* Note that USB has an additional level of device configurability, |
|
* associated with interfaces. That configurability is accessed using |
|
* usb_set_interface(). |
|
* |
|
* This call is synchronous. The calling context must be able to sleep, |
|
* must own the device lock, and must not hold the driver model's USB |
|
* bus mutex; usb interface driver probe() methods cannot use this routine. |
|
* |
|
* Returns zero on success, or else the status code returned by the |
|
* underlying call that failed. On successful completion, each interface |
|
* in the original device configuration has been destroyed, and each one |
|
* in the new configuration has been probed by all relevant usb device |
|
* drivers currently known to the kernel. |
|
*/ |
|
int usb_set_configuration(struct usb_device *dev, int configuration) |
|
{ |
|
int i, ret; |
|
struct usb_host_config *cp = NULL; |
|
struct usb_interface **new_interfaces = NULL; |
|
struct usb_hcd *hcd = bus_to_hcd(dev->bus); |
|
int n, nintf; |
|
|
|
if (dev->authorized == 0 || configuration == -1) |
|
configuration = 0; |
|
else { |
|
for (i = 0; i < dev->descriptor.bNumConfigurations; i++) { |
|
if (dev->config[i].desc.bConfigurationValue == |
|
configuration) { |
|
cp = &dev->config[i]; |
|
break; |
|
} |
|
} |
|
} |
|
if ((!cp && configuration != 0)) |
|
return -EINVAL; |
|
|
|
/* The USB spec says configuration 0 means unconfigured. |
|
* But if a device includes a configuration numbered 0, |
|
* we will accept it as a correctly configured state. |
|
* Use -1 if you really want to unconfigure the device. |
|
*/ |
|
if (cp && configuration == 0) |
|
dev_warn(&dev->dev, "config 0 descriptor??\n"); |
|
|
|
/* Allocate memory for new interfaces before doing anything else, |
|
* so that if we run out then nothing will have changed. */ |
|
n = nintf = 0; |
|
if (cp) { |
|
nintf = cp->desc.bNumInterfaces; |
|
new_interfaces = kmalloc_array(nintf, sizeof(*new_interfaces), |
|
GFP_NOIO); |
|
if (!new_interfaces) |
|
return -ENOMEM; |
|
|
|
for (; n < nintf; ++n) { |
|
new_interfaces[n] = kzalloc( |
|
sizeof(struct usb_interface), |
|
GFP_NOIO); |
|
if (!new_interfaces[n]) { |
|
ret = -ENOMEM; |
|
free_interfaces: |
|
while (--n >= 0) |
|
kfree(new_interfaces[n]); |
|
kfree(new_interfaces); |
|
return ret; |
|
} |
|
} |
|
|
|
i = dev->bus_mA - usb_get_max_power(dev, cp); |
|
if (i < 0) |
|
dev_warn(&dev->dev, "new config #%d exceeds power " |
|
"limit by %dmA\n", |
|
configuration, -i); |
|
} |
|
|
|
/* Wake up the device so we can send it the Set-Config request */ |
|
ret = usb_autoresume_device(dev); |
|
if (ret) |
|
goto free_interfaces; |
|
|
|
/* if it's already configured, clear out old state first. |
|
* getting rid of old interfaces means unbinding their drivers. |
|
*/ |
|
if (dev->state != USB_STATE_ADDRESS) |
|
usb_disable_device(dev, 1); /* Skip ep0 */ |
|
|
|
/* Get rid of pending async Set-Config requests for this device */ |
|
cancel_async_set_config(dev); |
|
|
|
/* Make sure we have bandwidth (and available HCD resources) for this |
|
* configuration. Remove endpoints from the schedule if we're dropping |
|
* this configuration to set configuration 0. After this point, the |
|
* host controller will not allow submissions to dropped endpoints. If |
|
* this call fails, the device state is unchanged. |
|
*/ |
|
mutex_lock(hcd->bandwidth_mutex); |
|
/* Disable LPM, and re-enable it once the new configuration is |
|
* installed, so that the xHCI driver can recalculate the U1/U2 |
|
* timeouts. |
|
*/ |
|
if (dev->actconfig && usb_disable_lpm(dev)) { |
|
dev_err(&dev->dev, "%s Failed to disable LPM\n", __func__); |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
ret = -ENOMEM; |
|
goto free_interfaces; |
|
} |
|
ret = usb_hcd_alloc_bandwidth(dev, cp, NULL, NULL); |
|
if (ret < 0) { |
|
if (dev->actconfig) |
|
usb_enable_lpm(dev); |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
usb_autosuspend_device(dev); |
|
goto free_interfaces; |
|
} |
|
|
|
/* |
|
* Initialize the new interface structures and the |
|
* hc/hcd/usbcore interface/endpoint state. |
|
*/ |
|
for (i = 0; i < nintf; ++i) { |
|
struct usb_interface_cache *intfc; |
|
struct usb_interface *intf; |
|
struct usb_host_interface *alt; |
|
u8 ifnum; |
|
|
|
cp->interface[i] = intf = new_interfaces[i]; |
|
intfc = cp->intf_cache[i]; |
|
intf->altsetting = intfc->altsetting; |
|
intf->num_altsetting = intfc->num_altsetting; |
|
intf->authorized = !!HCD_INTF_AUTHORIZED(hcd); |
|
kref_get(&intfc->ref); |
|
|
|
alt = usb_altnum_to_altsetting(intf, 0); |
|
|
|
/* No altsetting 0? We'll assume the first altsetting. |
|
* We could use a GetInterface call, but if a device is |
|
* so non-compliant that it doesn't have altsetting 0 |
|
* then I wouldn't trust its reply anyway. |
|
*/ |
|
if (!alt) |
|
alt = &intf->altsetting[0]; |
|
|
|
ifnum = alt->desc.bInterfaceNumber; |
|
intf->intf_assoc = find_iad(dev, cp, ifnum); |
|
intf->cur_altsetting = alt; |
|
usb_enable_interface(dev, intf, true); |
|
intf->dev.parent = &dev->dev; |
|
if (usb_of_has_combined_node(dev)) { |
|
device_set_of_node_from_dev(&intf->dev, &dev->dev); |
|
} else { |
|
intf->dev.of_node = usb_of_get_interface_node(dev, |
|
configuration, ifnum); |
|
} |
|
ACPI_COMPANION_SET(&intf->dev, ACPI_COMPANION(&dev->dev)); |
|
intf->dev.driver = NULL; |
|
intf->dev.bus = &usb_bus_type; |
|
intf->dev.type = &usb_if_device_type; |
|
intf->dev.groups = usb_interface_groups; |
|
INIT_WORK(&intf->reset_ws, __usb_queue_reset_device); |
|
intf->minor = -1; |
|
device_initialize(&intf->dev); |
|
pm_runtime_no_callbacks(&intf->dev); |
|
dev_set_name(&intf->dev, "%d-%s:%d.%d", dev->bus->busnum, |
|
dev->devpath, configuration, ifnum); |
|
usb_get_dev(dev); |
|
} |
|
kfree(new_interfaces); |
|
|
|
ret = usb_control_msg_send(dev, 0, USB_REQ_SET_CONFIGURATION, 0, |
|
configuration, 0, NULL, 0, |
|
USB_CTRL_SET_TIMEOUT, GFP_NOIO); |
|
if (ret && cp) { |
|
/* |
|
* All the old state is gone, so what else can we do? |
|
* The device is probably useless now anyway. |
|
*/ |
|
usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL); |
|
for (i = 0; i < nintf; ++i) { |
|
usb_disable_interface(dev, cp->interface[i], true); |
|
put_device(&cp->interface[i]->dev); |
|
cp->interface[i] = NULL; |
|
} |
|
cp = NULL; |
|
} |
|
|
|
dev->actconfig = cp; |
|
mutex_unlock(hcd->bandwidth_mutex); |
|
|
|
if (!cp) { |
|
usb_set_device_state(dev, USB_STATE_ADDRESS); |
|
|
|
/* Leave LPM disabled while the device is unconfigured. */ |
|
usb_autosuspend_device(dev); |
|
return ret; |
|
} |
|
usb_set_device_state(dev, USB_STATE_CONFIGURED); |
|
|
|
if (cp->string == NULL && |
|
!(dev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS)) |
|
cp->string = usb_cache_string(dev, cp->desc.iConfiguration); |
|
/* Uncomment this define to enable the HS Electrical Test support */ |
|
#define DWC_HS_ELECT_TST 1 |
|
#ifdef DWC_HS_ELECT_TST |
|
/* Here we implement the HS Electrical Test support. The |
|
* tester uses a vendor ID of 0x1A0A to indicate we should |
|
* run a special test sequence. The product ID tells us |
|
* which sequence to run. We invoke the test sequence by |
|
* sending a non-standard SetFeature command to our root |
|
* hub port. Our dwc_otg_hcd_hub_control() routine will |
|
* recognize the command and perform the desired test |
|
* sequence. |
|
*/ |
|
if (dev->descriptor.idVendor == 0x1A0A) { |
|
/* HSOTG Electrical Test */ |
|
dev_warn(&dev->dev, "VID from HSOTG Electrical Test Fixture\n"); |
|
|
|
if (dev->bus && dev->bus->root_hub) { |
|
struct usb_device *hdev = dev->bus->root_hub; |
|
dev_warn(&dev->dev, "Got PID 0x%x\n", dev->descriptor.idProduct); |
|
|
|
switch (dev->descriptor.idProduct) { |
|
case 0x0101: /* TEST_SE0_NAK */ |
|
dev_warn(&dev->dev, "TEST_SE0_NAK\n"); |
|
usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), |
|
USB_REQ_SET_FEATURE, USB_RT_PORT, |
|
USB_PORT_FEAT_TEST, 0x300, NULL, 0, HZ); |
|
break; |
|
|
|
case 0x0102: /* TEST_J */ |
|
dev_warn(&dev->dev, "TEST_J\n"); |
|
usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), |
|
USB_REQ_SET_FEATURE, USB_RT_PORT, |
|
USB_PORT_FEAT_TEST, 0x100, NULL, 0, HZ); |
|
break; |
|
|
|
case 0x0103: /* TEST_K */ |
|
dev_warn(&dev->dev, "TEST_K\n"); |
|
usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), |
|
USB_REQ_SET_FEATURE, USB_RT_PORT, |
|
USB_PORT_FEAT_TEST, 0x200, NULL, 0, HZ); |
|
break; |
|
|
|
case 0x0104: /* TEST_PACKET */ |
|
dev_warn(&dev->dev, "TEST_PACKET\n"); |
|
usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), |
|
USB_REQ_SET_FEATURE, USB_RT_PORT, |
|
USB_PORT_FEAT_TEST, 0x400, NULL, 0, HZ); |
|
break; |
|
|
|
case 0x0105: /* TEST_FORCE_ENABLE */ |
|
dev_warn(&dev->dev, "TEST_FORCE_ENABLE\n"); |
|
usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), |
|
USB_REQ_SET_FEATURE, USB_RT_PORT, |
|
USB_PORT_FEAT_TEST, 0x500, NULL, 0, HZ); |
|
break; |
|
|
|
case 0x0106: /* HS_HOST_PORT_SUSPEND_RESUME */ |
|
dev_warn(&dev->dev, "HS_HOST_PORT_SUSPEND_RESUME\n"); |
|
usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), |
|
USB_REQ_SET_FEATURE, USB_RT_PORT, |
|
USB_PORT_FEAT_TEST, 0x600, NULL, 0, 40 * HZ); |
|
break; |
|
|
|
case 0x0107: /* SINGLE_STEP_GET_DEVICE_DESCRIPTOR setup */ |
|
dev_warn(&dev->dev, "SINGLE_STEP_GET_DEVICE_DESCRIPTOR setup\n"); |
|
usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), |
|
USB_REQ_SET_FEATURE, USB_RT_PORT, |
|
USB_PORT_FEAT_TEST, 0x700, NULL, 0, 40 * HZ); |
|
break; |
|
|
|
case 0x0108: /* SINGLE_STEP_GET_DEVICE_DESCRIPTOR execute */ |
|
dev_warn(&dev->dev, "SINGLE_STEP_GET_DEVICE_DESCRIPTOR execute\n"); |
|
usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), |
|
USB_REQ_SET_FEATURE, USB_RT_PORT, |
|
USB_PORT_FEAT_TEST, 0x800, NULL, 0, 40 * HZ); |
|
} |
|
} |
|
} |
|
#endif /* DWC_HS_ELECT_TST */ |
|
|
|
/* Now that the interfaces are installed, re-enable LPM. */ |
|
usb_unlocked_enable_lpm(dev); |
|
/* Enable LTM if it was turned off by usb_disable_device. */ |
|
usb_enable_ltm(dev); |
|
|
|
/* Now that all the interfaces are set up, register them |
|
* to trigger binding of drivers to interfaces. probe() |
|
* routines may install different altsettings and may |
|
* claim() any interfaces not yet bound. Many class drivers |
|
* need that: CDC, audio, video, etc. |
|
*/ |
|
for (i = 0; i < nintf; ++i) { |
|
struct usb_interface *intf = cp->interface[i]; |
|
|
|
if (intf->dev.of_node && |
|
!of_device_is_available(intf->dev.of_node)) { |
|
dev_info(&dev->dev, "skipping disabled interface %d\n", |
|
intf->cur_altsetting->desc.bInterfaceNumber); |
|
continue; |
|
} |
|
|
|
dev_dbg(&dev->dev, |
|
"adding %s (config #%d, interface %d)\n", |
|
dev_name(&intf->dev), configuration, |
|
intf->cur_altsetting->desc.bInterfaceNumber); |
|
device_enable_async_suspend(&intf->dev); |
|
ret = device_add(&intf->dev); |
|
if (ret != 0) { |
|
dev_err(&dev->dev, "device_add(%s) --> %d\n", |
|
dev_name(&intf->dev), ret); |
|
continue; |
|
} |
|
create_intf_ep_devs(intf); |
|
} |
|
|
|
usb_autosuspend_device(dev); |
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_set_configuration); |
|
|
|
static LIST_HEAD(set_config_list); |
|
static DEFINE_SPINLOCK(set_config_lock); |
|
|
|
struct set_config_request { |
|
struct usb_device *udev; |
|
int config; |
|
struct work_struct work; |
|
struct list_head node; |
|
}; |
|
|
|
/* Worker routine for usb_driver_set_configuration() */ |
|
static void driver_set_config_work(struct work_struct *work) |
|
{ |
|
struct set_config_request *req = |
|
container_of(work, struct set_config_request, work); |
|
struct usb_device *udev = req->udev; |
|
|
|
usb_lock_device(udev); |
|
spin_lock(&set_config_lock); |
|
list_del(&req->node); |
|
spin_unlock(&set_config_lock); |
|
|
|
if (req->config >= -1) /* Is req still valid? */ |
|
usb_set_configuration(udev, req->config); |
|
usb_unlock_device(udev); |
|
usb_put_dev(udev); |
|
kfree(req); |
|
} |
|
|
|
/* Cancel pending Set-Config requests for a device whose configuration |
|
* was just changed |
|
*/ |
|
static void cancel_async_set_config(struct usb_device *udev) |
|
{ |
|
struct set_config_request *req; |
|
|
|
spin_lock(&set_config_lock); |
|
list_for_each_entry(req, &set_config_list, node) { |
|
if (req->udev == udev) |
|
req->config = -999; /* Mark as cancelled */ |
|
} |
|
spin_unlock(&set_config_lock); |
|
} |
|
|
|
/** |
|
* usb_driver_set_configuration - Provide a way for drivers to change device configurations |
|
* @udev: the device whose configuration is being updated |
|
* @config: the configuration being chosen. |
|
* Context: In process context, must be able to sleep |
|
* |
|
* Device interface drivers are not allowed to change device configurations. |
|
* This is because changing configurations will destroy the interface the |
|
* driver is bound to and create new ones; it would be like a floppy-disk |
|
* driver telling the computer to replace the floppy-disk drive with a |
|
* tape drive! |
|
* |
|
* Still, in certain specialized circumstances the need may arise. This |
|
* routine gets around the normal restrictions by using a work thread to |
|
* submit the change-config request. |
|
* |
|
* Return: 0 if the request was successfully queued, error code otherwise. |
|
* The caller has no way to know whether the queued request will eventually |
|
* succeed. |
|
*/ |
|
int usb_driver_set_configuration(struct usb_device *udev, int config) |
|
{ |
|
struct set_config_request *req; |
|
|
|
req = kmalloc(sizeof(*req), GFP_KERNEL); |
|
if (!req) |
|
return -ENOMEM; |
|
req->udev = udev; |
|
req->config = config; |
|
INIT_WORK(&req->work, driver_set_config_work); |
|
|
|
spin_lock(&set_config_lock); |
|
list_add(&req->node, &set_config_list); |
|
spin_unlock(&set_config_lock); |
|
|
|
usb_get_dev(udev); |
|
schedule_work(&req->work); |
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(usb_driver_set_configuration); |
|
|
|
/** |
|
* cdc_parse_cdc_header - parse the extra headers present in CDC devices |
|
* @hdr: the place to put the results of the parsing |
|
* @intf: the interface for which parsing is requested |
|
* @buffer: pointer to the extra headers to be parsed |
|
* @buflen: length of the extra headers |
|
* |
|
* This evaluates the extra headers present in CDC devices which |
|
* bind the interfaces for data and control and provide details |
|
* about the capabilities of the device. |
|
* |
|
* Return: number of descriptors parsed or -EINVAL |
|
* if the header is contradictory beyond salvage |
|
*/ |
|
|
|
int cdc_parse_cdc_header(struct usb_cdc_parsed_header *hdr, |
|
struct usb_interface *intf, |
|
u8 *buffer, |
|
int buflen) |
|
{ |
|
/* duplicates are ignored */ |
|
struct usb_cdc_union_desc *union_header = NULL; |
|
|
|
/* duplicates are not tolerated */ |
|
struct usb_cdc_header_desc *header = NULL; |
|
struct usb_cdc_ether_desc *ether = NULL; |
|
struct usb_cdc_mdlm_detail_desc *detail = NULL; |
|
struct usb_cdc_mdlm_desc *desc = NULL; |
|
|
|
unsigned int elength; |
|
int cnt = 0; |
|
|
|
memset(hdr, 0x00, sizeof(struct usb_cdc_parsed_header)); |
|
hdr->phonet_magic_present = false; |
|
while (buflen > 0) { |
|
elength = buffer[0]; |
|
if (!elength) { |
|
dev_err(&intf->dev, "skipping garbage byte\n"); |
|
elength = 1; |
|
goto next_desc; |
|
} |
|
if ((buflen < elength) || (elength < 3)) { |
|
dev_err(&intf->dev, "invalid descriptor buffer length\n"); |
|
break; |
|
} |
|
if (buffer[1] != USB_DT_CS_INTERFACE) { |
|
dev_err(&intf->dev, "skipping garbage\n"); |
|
goto next_desc; |
|
} |
|
|
|
switch (buffer[2]) { |
|
case USB_CDC_UNION_TYPE: /* we've found it */ |
|
if (elength < sizeof(struct usb_cdc_union_desc)) |
|
goto next_desc; |
|
if (union_header) { |
|
dev_err(&intf->dev, "More than one union descriptor, skipping ...\n"); |
|
goto next_desc; |
|
} |
|
union_header = (struct usb_cdc_union_desc *)buffer; |
|
break; |
|
case USB_CDC_COUNTRY_TYPE: |
|
if (elength < sizeof(struct usb_cdc_country_functional_desc)) |
|
goto next_desc; |
|
hdr->usb_cdc_country_functional_desc = |
|
(struct usb_cdc_country_functional_desc *)buffer; |
|
break; |
|
case USB_CDC_HEADER_TYPE: |
|
if (elength != sizeof(struct usb_cdc_header_desc)) |
|
goto next_desc; |
|
if (header) |
|
return -EINVAL; |
|
header = (struct usb_cdc_header_desc *)buffer; |
|
break; |
|
case USB_CDC_ACM_TYPE: |
|
if (elength < sizeof(struct usb_cdc_acm_descriptor)) |
|
goto next_desc; |
|
hdr->usb_cdc_acm_descriptor = |
|
(struct usb_cdc_acm_descriptor *)buffer; |
|
break; |
|
case USB_CDC_ETHERNET_TYPE: |
|
if (elength != sizeof(struct usb_cdc_ether_desc)) |
|
goto next_desc; |
|
if (ether) |
|
return -EINVAL; |
|
ether = (struct usb_cdc_ether_desc *)buffer; |
|
break; |
|
case USB_CDC_CALL_MANAGEMENT_TYPE: |
|
if (elength < sizeof(struct usb_cdc_call_mgmt_descriptor)) |
|
goto next_desc; |
|
hdr->usb_cdc_call_mgmt_descriptor = |
|
(struct usb_cdc_call_mgmt_descriptor *)buffer; |
|
break; |
|
case USB_CDC_DMM_TYPE: |
|
if (elength < sizeof(struct usb_cdc_dmm_desc)) |
|
goto next_desc; |
|
hdr->usb_cdc_dmm_desc = |
|
(struct usb_cdc_dmm_desc *)buffer; |
|
break; |
|
case USB_CDC_MDLM_TYPE: |
|
if (elength < sizeof(struct usb_cdc_mdlm_desc)) |
|
goto next_desc; |
|
if (desc) |
|
return -EINVAL; |
|
desc = (struct usb_cdc_mdlm_desc *)buffer; |
|
break; |
|
case USB_CDC_MDLM_DETAIL_TYPE: |
|
if (elength < sizeof(struct usb_cdc_mdlm_detail_desc)) |
|
goto next_desc; |
|
if (detail) |
|
return -EINVAL; |
|
detail = (struct usb_cdc_mdlm_detail_desc *)buffer; |
|
break; |
|
case USB_CDC_NCM_TYPE: |
|
if (elength < sizeof(struct usb_cdc_ncm_desc)) |
|
goto next_desc; |
|
hdr->usb_cdc_ncm_desc = (struct usb_cdc_ncm_desc *)buffer; |
|
break; |
|
case USB_CDC_MBIM_TYPE: |
|
if (elength < sizeof(struct usb_cdc_mbim_desc)) |
|
goto next_desc; |
|
|
|
hdr->usb_cdc_mbim_desc = (struct usb_cdc_mbim_desc *)buffer; |
|
break; |
|
case USB_CDC_MBIM_EXTENDED_TYPE: |
|
if (elength < sizeof(struct usb_cdc_mbim_extended_desc)) |
|
break; |
|
hdr->usb_cdc_mbim_extended_desc = |
|
(struct usb_cdc_mbim_extended_desc *)buffer; |
|
break; |
|
case CDC_PHONET_MAGIC_NUMBER: |
|
hdr->phonet_magic_present = true; |
|
break; |
|
default: |
|
/* |
|
* there are LOTS more CDC descriptors that |
|
* could legitimately be found here. |
|
*/ |
|
dev_dbg(&intf->dev, "Ignoring descriptor: type %02x, length %ud\n", |
|
buffer[2], elength); |
|
goto next_desc; |
|
} |
|
cnt++; |
|
next_desc: |
|
buflen -= elength; |
|
buffer += elength; |
|
} |
|
hdr->usb_cdc_union_desc = union_header; |
|
hdr->usb_cdc_header_desc = header; |
|
hdr->usb_cdc_mdlm_detail_desc = detail; |
|
hdr->usb_cdc_mdlm_desc = desc; |
|
hdr->usb_cdc_ether_desc = ether; |
|
return cnt; |
|
} |
|
|
|
EXPORT_SYMBOL(cdc_parse_cdc_header);
|
|
|