Sebastian Andrzej Siewior | e220ff7 | 2012-09-06 20:11:06 +0200 | [diff] [blame] | 1 | /* |
| 2 | * usb/gadget/config.c -- simplify building config descriptors |
| 3 | * |
| 4 | * Copyright (C) 2003 David Brownell |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | */ |
| 11 | |
| 12 | #include <linux/errno.h> |
| 13 | #include <linux/slab.h> |
| 14 | #include <linux/kernel.h> |
| 15 | #include <linux/list.h> |
| 16 | #include <linux/string.h> |
| 17 | #include <linux/device.h> |
| 18 | |
| 19 | #include <linux/usb/ch9.h> |
| 20 | #include <linux/usb/gadget.h> |
| 21 | |
| 22 | |
| 23 | /** |
| 24 | * usb_descriptor_fillbuf - fill buffer with descriptors |
| 25 | * @buf: Buffer to be filled |
| 26 | * @buflen: Size of buf |
| 27 | * @src: Array of descriptor pointers, terminated by null pointer. |
| 28 | * |
| 29 | * Copies descriptors into the buffer, returning the length or a |
| 30 | * negative error code if they can't all be copied. Useful when |
| 31 | * assembling descriptors for an associated set of interfaces used |
| 32 | * as part of configuring a composite device; or in other cases where |
| 33 | * sets of descriptors need to be marshaled. |
| 34 | */ |
| 35 | int |
| 36 | usb_descriptor_fillbuf(void *buf, unsigned buflen, |
| 37 | const struct usb_descriptor_header **src) |
| 38 | { |
| 39 | u8 *dest = buf; |
| 40 | |
| 41 | if (!src) |
| 42 | return -EINVAL; |
| 43 | |
| 44 | /* fill buffer from src[] until null descriptor ptr */ |
| 45 | for (; NULL != *src; src++) { |
| 46 | unsigned len = (*src)->bLength; |
| 47 | |
| 48 | if (len > buflen) |
| 49 | return -EINVAL; |
| 50 | memcpy(dest, *src, len); |
| 51 | buflen -= len; |
| 52 | dest += len; |
| 53 | } |
| 54 | return dest - (u8 *)buf; |
| 55 | } |
| 56 | |
| 57 | |
| 58 | /** |
| 59 | * usb_gadget_config_buf - builts a complete configuration descriptor |
| 60 | * @config: Header for the descriptor, including characteristics such |
| 61 | * as power requirements and number of interfaces. |
| 62 | * @desc: Null-terminated vector of pointers to the descriptors (interface, |
| 63 | * endpoint, etc) defining all functions in this device configuration. |
| 64 | * @buf: Buffer for the resulting configuration descriptor. |
| 65 | * @length: Length of buffer. If this is not big enough to hold the |
| 66 | * entire configuration descriptor, an error code will be returned. |
| 67 | * |
| 68 | * This copies descriptors into the response buffer, building a descriptor |
| 69 | * for that configuration. It returns the buffer length or a negative |
| 70 | * status code. The config.wTotalLength field is set to match the length |
| 71 | * of the result, but other descriptor fields (including power usage and |
| 72 | * interface count) must be set by the caller. |
| 73 | * |
| 74 | * Gadget drivers could use this when constructing a config descriptor |
| 75 | * in response to USB_REQ_GET_DESCRIPTOR. They will need to patch the |
| 76 | * resulting bDescriptorType value if USB_DT_OTHER_SPEED_CONFIG is needed. |
| 77 | */ |
| 78 | int usb_gadget_config_buf( |
| 79 | const struct usb_config_descriptor *config, |
| 80 | void *buf, |
| 81 | unsigned length, |
| 82 | const struct usb_descriptor_header **desc |
| 83 | ) |
| 84 | { |
| 85 | struct usb_config_descriptor *cp = buf; |
| 86 | int len; |
| 87 | |
| 88 | /* config descriptor first */ |
| 89 | if (length < USB_DT_CONFIG_SIZE || !desc) |
| 90 | return -EINVAL; |
| 91 | *cp = *config; |
| 92 | |
| 93 | /* then interface/endpoint/class/vendor/... */ |
| 94 | len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (u8*)buf, |
| 95 | length - USB_DT_CONFIG_SIZE, desc); |
| 96 | if (len < 0) |
| 97 | return len; |
| 98 | len += USB_DT_CONFIG_SIZE; |
| 99 | if (len > 0xffff) |
| 100 | return -EINVAL; |
| 101 | |
| 102 | /* patch up the config descriptor */ |
| 103 | cp->bLength = USB_DT_CONFIG_SIZE; |
| 104 | cp->bDescriptorType = USB_DT_CONFIG; |
| 105 | cp->wTotalLength = cpu_to_le16(len); |
| 106 | cp->bmAttributes |= USB_CONFIG_ATT_ONE; |
| 107 | return len; |
| 108 | } |
| 109 | |
| 110 | /** |
| 111 | * usb_copy_descriptors - copy a vector of USB descriptors |
| 112 | * @src: null-terminated vector to copy |
| 113 | * Context: initialization code, which may sleep |
| 114 | * |
| 115 | * This makes a copy of a vector of USB descriptors. Its primary use |
| 116 | * is to support usb_function objects which can have multiple copies, |
| 117 | * each needing different descriptors. Functions may have static |
| 118 | * tables of descriptors, which are used as templates and customized |
| 119 | * with identifiers (for interfaces, strings, endpoints, and more) |
| 120 | * as needed by a given function instance. |
| 121 | */ |
| 122 | struct usb_descriptor_header ** |
| 123 | usb_copy_descriptors(struct usb_descriptor_header **src) |
| 124 | { |
| 125 | struct usb_descriptor_header **tmp; |
| 126 | unsigned bytes; |
| 127 | unsigned n_desc; |
| 128 | void *mem; |
| 129 | struct usb_descriptor_header **ret; |
| 130 | |
| 131 | /* count descriptors and their sizes; then add vector size */ |
| 132 | for (bytes = 0, n_desc = 0, tmp = src; *tmp; tmp++, n_desc++) |
| 133 | bytes += (*tmp)->bLength; |
| 134 | bytes += (n_desc + 1) * sizeof(*tmp); |
| 135 | |
| 136 | mem = kmalloc(bytes, GFP_KERNEL); |
| 137 | if (!mem) |
| 138 | return NULL; |
| 139 | |
| 140 | /* fill in pointers starting at "tmp", |
| 141 | * to descriptors copied starting at "mem"; |
| 142 | * and return "ret" |
| 143 | */ |
| 144 | tmp = mem; |
| 145 | ret = mem; |
| 146 | mem += (n_desc + 1) * sizeof(*tmp); |
| 147 | while (*src) { |
| 148 | memcpy(mem, *src, (*src)->bLength); |
| 149 | *tmp = mem; |
| 150 | tmp++; |
| 151 | mem += (*src)->bLength; |
| 152 | src++; |
| 153 | } |
| 154 | *tmp = NULL; |
| 155 | |
| 156 | return ret; |
| 157 | } |
| 158 | |