blob: cb4950cf1cdcb69307c60ee948af30d372e0f29b [file] [log] [blame]
Greg Kroah-Hartman5fd54ac2017-11-03 11:28:30 +01001// SPDX-License-Identifier: GPL-2.0+
David Brownell40982be2008-06-19 17:52:58 -07002/*
3 * composite.c - infrastructure for Composite USB Gadgets
4 *
5 * Copyright (C) 2006-2008 David Brownell
David Brownell40982be2008-06-19 17:52:58 -07006 */
7
8/* #define VERBOSE_DEBUG */
9
10#include <linux/kallsyms.h>
11#include <linux/kernel.h>
12#include <linux/slab.h>
Paul Gortmaker6eb0de82011-07-03 16:09:31 -040013#include <linux/module.h>
David Brownell40982be2008-06-19 17:52:58 -070014#include <linux/device.h>
Michal Nazarewiczad1a8102010-08-12 17:43:46 +020015#include <linux/utsname.h>
David Brownell40982be2008-06-19 17:52:58 -070016
17#include <linux/usb/composite.h>
Macpaul Lin53e62422015-07-09 15:18:42 +080018#include <linux/usb/otg.h>
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +030019#include <asm/unaligned.h>
David Brownell40982be2008-06-19 17:52:58 -070020
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +020021#include "u_os_desc.h"
22
Andrzej Pietrasiewicz19824d52014-05-08 14:06:22 +020023/**
24 * struct usb_os_string - represents OS String to be reported by a gadget
25 * @bLength: total length of the entire descritor, always 0x12
26 * @bDescriptorType: USB_DT_STRING
27 * @qwSignature: the OS String proper
28 * @bMS_VendorCode: code used by the host for subsequent requests
29 * @bPad: not used, must be zero
30 */
31struct usb_os_string {
32 __u8 bLength;
33 __u8 bDescriptorType;
34 __u8 qwSignature[OS_STRING_QW_SIGN_LEN];
35 __u8 bMS_VendorCode;
36 __u8 bPad;
37} __packed;
38
David Brownell40982be2008-06-19 17:52:58 -070039/*
40 * The code in this file is utility code, used to build a gadget driver
41 * from one or more "function" drivers, one or more "configuration"
42 * objects, and a "usb_composite_driver" by gluing them together along
43 * with the relevant device-wide data.
44 */
45
Sebastian Andrzej Siewior9bb28592012-12-23 21:10:22 +010046static struct usb_gadget_strings **get_containers_gs(
47 struct usb_gadget_string_container *uc)
48{
49 return (struct usb_gadget_strings **)uc->stash;
50}
51
Tatyana Brokhman48767a42011-06-28 16:33:49 +030052/**
John Younf3bdbe32016-02-05 17:07:03 -080053 * function_descriptors() - get function descriptors for speed
54 * @f: the function
55 * @speed: the speed
56 *
57 * Returns the descriptors or NULL if not set.
58 */
59static struct usb_descriptor_header **
60function_descriptors(struct usb_function *f,
61 enum usb_device_speed speed)
62{
63 struct usb_descriptor_header **descriptors;
64
Felipe Balbi08782632016-04-22 14:53:47 +030065 /*
66 * NOTE: we try to help gadget drivers which might not be setting
67 * max_speed appropriately.
68 */
69
John Younf3bdbe32016-02-05 17:07:03 -080070 switch (speed) {
71 case USB_SPEED_SUPER_PLUS:
72 descriptors = f->ssp_descriptors;
Felipe Balbi08782632016-04-22 14:53:47 +030073 if (descriptors)
74 break;
75 /* FALLTHROUGH */
John Younf3bdbe32016-02-05 17:07:03 -080076 case USB_SPEED_SUPER:
77 descriptors = f->ss_descriptors;
Felipe Balbi08782632016-04-22 14:53:47 +030078 if (descriptors)
79 break;
80 /* FALLTHROUGH */
John Younf3bdbe32016-02-05 17:07:03 -080081 case USB_SPEED_HIGH:
82 descriptors = f->hs_descriptors;
Felipe Balbi08782632016-04-22 14:53:47 +030083 if (descriptors)
84 break;
85 /* FALLTHROUGH */
John Younf3bdbe32016-02-05 17:07:03 -080086 default:
87 descriptors = f->fs_descriptors;
88 }
89
Felipe Balbi08782632016-04-22 14:53:47 +030090 /*
91 * if we can't find any descriptors at all, then this gadget deserves to
92 * Oops with a NULL pointer dereference
93 */
94
John Younf3bdbe32016-02-05 17:07:03 -080095 return descriptors;
96}
97
98/**
Tatyana Brokhman48767a42011-06-28 16:33:49 +030099 * next_ep_desc() - advance to the next EP descriptor
100 * @t: currect pointer within descriptor array
101 *
102 * Return: next EP descriptor or NULL
103 *
104 * Iterate over @t until either EP descriptor found or
105 * NULL (that indicates end of list) encountered
106 */
107static struct usb_descriptor_header**
108next_ep_desc(struct usb_descriptor_header **t)
109{
110 for (; *t; t++) {
111 if ((*t)->bDescriptorType == USB_DT_ENDPOINT)
112 return t;
113 }
114 return NULL;
115}
116
117/*
118 * for_each_ep_desc()- iterate over endpoint descriptors in the
119 * descriptors list
120 * @start: pointer within descriptor array.
121 * @ep_desc: endpoint descriptor to use as the loop cursor
122 */
123#define for_each_ep_desc(start, ep_desc) \
124 for (ep_desc = next_ep_desc(start); \
125 ep_desc; ep_desc = next_ep_desc(ep_desc+1))
126
127/**
128 * config_ep_by_speed() - configures the given endpoint
129 * according to gadget speed.
130 * @g: pointer to the gadget
131 * @f: usb function
132 * @_ep: the endpoint to configure
133 *
134 * Return: error code, 0 on success
135 *
136 * This function chooses the right descriptors for a given
137 * endpoint according to gadget speed and saves it in the
138 * endpoint desc field. If the endpoint already has a descriptor
139 * assigned to it - overwrites it with currently corresponding
140 * descriptor. The endpoint maxpacket field is updated according
141 * to the chosen descriptor.
142 * Note: the supplied function should hold all the descriptors
143 * for supported speeds
144 */
145int config_ep_by_speed(struct usb_gadget *g,
146 struct usb_function *f,
147 struct usb_ep *_ep)
148{
149 struct usb_endpoint_descriptor *chosen_desc = NULL;
150 struct usb_descriptor_header **speed_desc = NULL;
151
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300152 struct usb_ss_ep_comp_descriptor *comp_desc = NULL;
153 int want_comp_desc = 0;
154
Tatyana Brokhman48767a42011-06-28 16:33:49 +0300155 struct usb_descriptor_header **d_spd; /* cursor for speed desc */
156
157 if (!g || !f || !_ep)
158 return -EIO;
159
160 /* select desired speed */
161 switch (g->speed) {
John Youn4eb8e32d2016-02-05 17:07:30 -0800162 case USB_SPEED_SUPER_PLUS:
163 if (gadget_is_superspeed_plus(g)) {
164 speed_desc = f->ssp_descriptors;
165 want_comp_desc = 1;
166 break;
167 }
Gustavo A. R. Silva624916a2017-10-25 12:22:50 -0500168 /* fall through */
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300169 case USB_SPEED_SUPER:
170 if (gadget_is_superspeed(g)) {
171 speed_desc = f->ss_descriptors;
172 want_comp_desc = 1;
173 break;
174 }
Gustavo A. R. Silva624916a2017-10-25 12:22:50 -0500175 /* fall through */
Tatyana Brokhman48767a42011-06-28 16:33:49 +0300176 case USB_SPEED_HIGH:
177 if (gadget_is_dualspeed(g)) {
178 speed_desc = f->hs_descriptors;
179 break;
180 }
Gustavo A. R. Silva624916a2017-10-25 12:22:50 -0500181 /* fall through */
Tatyana Brokhman48767a42011-06-28 16:33:49 +0300182 default:
Sebastian Andrzej Siewior10287ba2012-10-22 22:15:06 +0200183 speed_desc = f->fs_descriptors;
Tatyana Brokhman48767a42011-06-28 16:33:49 +0300184 }
185 /* find descriptors */
186 for_each_ep_desc(speed_desc, d_spd) {
187 chosen_desc = (struct usb_endpoint_descriptor *)*d_spd;
188 if (chosen_desc->bEndpointAddress == _ep->address)
189 goto ep_found;
190 }
191 return -EIO;
192
193ep_found:
194 /* commit results */
Felipe Balbi9ad58772016-09-28 14:17:38 +0300195 _ep->maxpacket = usb_endpoint_maxp(chosen_desc);
Tatyana Brokhman48767a42011-06-28 16:33:49 +0300196 _ep->desc = chosen_desc;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300197 _ep->comp_desc = NULL;
198 _ep->maxburst = 0;
Felipe Balbieaa496f2016-09-28 12:33:31 +0300199 _ep->mult = 1;
200
201 if (g->speed == USB_SPEED_HIGH && (usb_endpoint_xfer_isoc(_ep->desc) ||
202 usb_endpoint_xfer_int(_ep->desc)))
203 _ep->mult = usb_endpoint_maxp_mult(_ep->desc);
204
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300205 if (!want_comp_desc)
206 return 0;
Tatyana Brokhman48767a42011-06-28 16:33:49 +0300207
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300208 /*
209 * Companion descriptor should follow EP descriptor
210 * USB 3.0 spec, #9.6.7
211 */
212 comp_desc = (struct usb_ss_ep_comp_descriptor *)*(++d_spd);
213 if (!comp_desc ||
214 (comp_desc->bDescriptorType != USB_DT_SS_ENDPOINT_COMP))
215 return -EIO;
216 _ep->comp_desc = comp_desc;
John Youn4eb8e32d2016-02-05 17:07:30 -0800217 if (g->speed >= USB_SPEED_SUPER) {
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300218 switch (usb_endpoint_type(_ep->desc)) {
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300219 case USB_ENDPOINT_XFER_ISOC:
220 /* mult: bits 1:0 of bmAttributes */
Felipe Balbieaa496f2016-09-28 12:33:31 +0300221 _ep->mult = (comp_desc->bmAttributes & 0x3) + 1;
Gustavo A. R. Silva624916a2017-10-25 12:22:50 -0500222 /* fall through */
Paul Zimmerman9e878a62012-01-16 13:24:38 -0800223 case USB_ENDPOINT_XFER_BULK:
224 case USB_ENDPOINT_XFER_INT:
Felipe Balbib785ea72012-06-06 10:20:23 +0300225 _ep->maxburst = comp_desc->bMaxBurst + 1;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300226 break;
227 default:
Colin Ian Kingb2fc0592017-11-14 16:18:28 +0000228 if (comp_desc->bMaxBurst != 0) {
229 struct usb_composite_dev *cdev;
230
231 cdev = get_gadget_data(g);
Felipe Balbib785ea72012-06-06 10:20:23 +0300232 ERROR(cdev, "ep0 bMaxBurst must be 0\n");
Colin Ian Kingb2fc0592017-11-14 16:18:28 +0000233 }
Felipe Balbib785ea72012-06-06 10:20:23 +0300234 _ep->maxburst = 1;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300235 break;
236 }
237 }
Tatyana Brokhman48767a42011-06-28 16:33:49 +0300238 return 0;
239}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +0200240EXPORT_SYMBOL_GPL(config_ep_by_speed);
David Brownell40982be2008-06-19 17:52:58 -0700241
242/**
243 * usb_add_function() - add a function to a configuration
244 * @config: the configuration
245 * @function: the function being added
246 * Context: single threaded during gadget setup
247 *
248 * After initialization, each configuration must have one or more
249 * functions added to it. Adding a function involves calling its @bind()
250 * method to allocate resources such as interface and string identifiers
251 * and endpoints.
252 *
253 * This function returns the value of the function's bind(), which is
254 * zero for success else a negative errno value.
255 */
Michal Nazarewicz28824b12010-05-05 12:53:13 +0200256int usb_add_function(struct usb_configuration *config,
David Brownell40982be2008-06-19 17:52:58 -0700257 struct usb_function *function)
258{
259 int value = -EINVAL;
260
261 DBG(config->cdev, "adding '%s'/%p to config '%s'/%p\n",
262 function->name, function,
263 config->label, config);
264
265 if (!function->set_alt || !function->disable)
266 goto done;
267
268 function->config = config;
269 list_add_tail(&function->list, &config->functions);
270
Robert Baldygad5bb9b82015-05-04 14:55:13 +0200271 if (function->bind_deactivated) {
272 value = usb_function_deactivate(function);
273 if (value)
274 goto done;
275 }
276
David Brownell40982be2008-06-19 17:52:58 -0700277 /* REVISIT *require* function->bind? */
278 if (function->bind) {
279 value = function->bind(config, function);
280 if (value < 0) {
281 list_del(&function->list);
282 function->config = NULL;
283 }
284 } else
285 value = 0;
286
287 /* We allow configurations that don't work at both speeds.
288 * If we run into a lowspeed Linux system, treat it the same
289 * as full speed ... it's the function drivers that will need
290 * to avoid bulk and ISO transfers.
291 */
Sebastian Andrzej Siewior10287ba2012-10-22 22:15:06 +0200292 if (!config->fullspeed && function->fs_descriptors)
David Brownell40982be2008-06-19 17:52:58 -0700293 config->fullspeed = true;
294 if (!config->highspeed && function->hs_descriptors)
295 config->highspeed = true;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300296 if (!config->superspeed && function->ss_descriptors)
297 config->superspeed = true;
John Youn554eead2016-02-05 17:06:35 -0800298 if (!config->superspeed_plus && function->ssp_descriptors)
299 config->superspeed_plus = true;
David Brownell40982be2008-06-19 17:52:58 -0700300
301done:
302 if (value)
303 DBG(config->cdev, "adding '%s'/%p --> %d\n",
304 function->name, function, value);
305 return value;
306}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +0200307EXPORT_SYMBOL_GPL(usb_add_function);
David Brownell40982be2008-06-19 17:52:58 -0700308
Sebastian Andrzej Siewiorb47357782012-12-23 21:10:05 +0100309void usb_remove_function(struct usb_configuration *c, struct usb_function *f)
310{
311 if (f->disable)
312 f->disable(f);
313
314 bitmap_zero(f->endpoints, 32);
315 list_del(&f->list);
316 if (f->unbind)
317 f->unbind(c, f);
Felipe Balbi0e3e9752017-06-06 14:47:29 +0300318
319 if (f->bind_deactivated)
320 usb_function_activate(f);
Sebastian Andrzej Siewiorb47357782012-12-23 21:10:05 +0100321}
322EXPORT_SYMBOL_GPL(usb_remove_function);
323
David Brownell40982be2008-06-19 17:52:58 -0700324/**
David Brownell60beed92008-08-18 17:38:22 -0700325 * usb_function_deactivate - prevent function and gadget enumeration
326 * @function: the function that isn't yet ready to respond
327 *
328 * Blocks response of the gadget driver to host enumeration by
329 * preventing the data line pullup from being activated. This is
330 * normally called during @bind() processing to change from the
331 * initial "ready to respond" state, or when a required resource
332 * becomes available.
333 *
334 * For example, drivers that serve as a passthrough to a userspace
335 * daemon can block enumeration unless that daemon (such as an OBEX,
336 * MTP, or print server) is ready to handle host requests.
337 *
338 * Not all systems support software control of their USB peripheral
339 * data pullups.
340 *
341 * Returns zero on success, else negative errno.
342 */
343int usb_function_deactivate(struct usb_function *function)
344{
345 struct usb_composite_dev *cdev = function->config->cdev;
Felipe Balbib2bdf3a2009-02-12 15:09:47 +0200346 unsigned long flags;
David Brownell60beed92008-08-18 17:38:22 -0700347 int status = 0;
348
Felipe Balbib2bdf3a2009-02-12 15:09:47 +0200349 spin_lock_irqsave(&cdev->lock, flags);
David Brownell60beed92008-08-18 17:38:22 -0700350
351 if (cdev->deactivations == 0)
Robert Baldyga56012502015-05-04 14:55:12 +0200352 status = usb_gadget_deactivate(cdev->gadget);
David Brownell60beed92008-08-18 17:38:22 -0700353 if (status == 0)
354 cdev->deactivations++;
355
Felipe Balbib2bdf3a2009-02-12 15:09:47 +0200356 spin_unlock_irqrestore(&cdev->lock, flags);
David Brownell60beed92008-08-18 17:38:22 -0700357 return status;
358}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +0200359EXPORT_SYMBOL_GPL(usb_function_deactivate);
David Brownell60beed92008-08-18 17:38:22 -0700360
361/**
362 * usb_function_activate - allow function and gadget enumeration
363 * @function: function on which usb_function_activate() was called
364 *
365 * Reverses effect of usb_function_deactivate(). If no more functions
366 * are delaying their activation, the gadget driver will respond to
367 * host enumeration procedures.
368 *
369 * Returns zero on success, else negative errno.
370 */
371int usb_function_activate(struct usb_function *function)
372{
373 struct usb_composite_dev *cdev = function->config->cdev;
Michael Grzeschik4fefe9f62012-07-19 00:20:11 +0200374 unsigned long flags;
David Brownell60beed92008-08-18 17:38:22 -0700375 int status = 0;
376
Michael Grzeschik4fefe9f62012-07-19 00:20:11 +0200377 spin_lock_irqsave(&cdev->lock, flags);
David Brownell60beed92008-08-18 17:38:22 -0700378
379 if (WARN_ON(cdev->deactivations == 0))
380 status = -EINVAL;
381 else {
382 cdev->deactivations--;
383 if (cdev->deactivations == 0)
Robert Baldyga56012502015-05-04 14:55:12 +0200384 status = usb_gadget_activate(cdev->gadget);
David Brownell60beed92008-08-18 17:38:22 -0700385 }
386
Michael Grzeschik4fefe9f62012-07-19 00:20:11 +0200387 spin_unlock_irqrestore(&cdev->lock, flags);
David Brownell60beed92008-08-18 17:38:22 -0700388 return status;
389}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +0200390EXPORT_SYMBOL_GPL(usb_function_activate);
David Brownell60beed92008-08-18 17:38:22 -0700391
392/**
David Brownell40982be2008-06-19 17:52:58 -0700393 * usb_interface_id() - allocate an unused interface ID
394 * @config: configuration associated with the interface
395 * @function: function handling the interface
396 * Context: single threaded during gadget setup
397 *
398 * usb_interface_id() is called from usb_function.bind() callbacks to
399 * allocate new interface IDs. The function driver will then store that
400 * ID in interface, association, CDC union, and other descriptors. It
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300401 * will also handle any control requests targeted at that interface,
David Brownell40982be2008-06-19 17:52:58 -0700402 * particularly changing its altsetting via set_alt(). There may
403 * also be class-specific or vendor-specific requests to handle.
404 *
405 * All interface identifier should be allocated using this routine, to
406 * ensure that for example different functions don't wrongly assign
407 * different meanings to the same identifier. Note that since interface
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300408 * identifiers are configuration-specific, functions used in more than
David Brownell40982be2008-06-19 17:52:58 -0700409 * one configuration (or more than once in a given configuration) need
410 * multiple versions of the relevant descriptors.
411 *
412 * Returns the interface ID which was allocated; or -ENODEV if no
413 * more interface IDs can be allocated.
414 */
Michal Nazarewicz28824b12010-05-05 12:53:13 +0200415int usb_interface_id(struct usb_configuration *config,
David Brownell40982be2008-06-19 17:52:58 -0700416 struct usb_function *function)
417{
418 unsigned id = config->next_interface_id;
419
420 if (id < MAX_CONFIG_INTERFACES) {
421 config->interface[id] = function;
422 config->next_interface_id = id + 1;
423 return id;
424 }
425 return -ENODEV;
426}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +0200427EXPORT_SYMBOL_GPL(usb_interface_id);
David Brownell40982be2008-06-19 17:52:58 -0700428
Sebastian Andrzej Siewior8f900a92012-12-03 20:07:05 +0100429static u8 encode_bMaxPower(enum usb_device_speed speed,
430 struct usb_configuration *c)
431{
432 unsigned val;
433
434 if (c->MaxPower)
435 val = c->MaxPower;
436 else
437 val = CONFIG_USB_GADGET_VBUS_DRAW;
438 if (!val)
439 return 0;
Jack Phamc7244172020-01-30 19:10:35 -0800440 if (speed < USB_SPEED_SUPER)
Jack Phama2035412020-01-30 19:10:36 -0800441 return min(val, 500U) / 2;
Jack Phamc7244172020-01-30 19:10:35 -0800442 else
Jack Phama2035412020-01-30 19:10:36 -0800443 /*
444 * USB 3.x supports up to 900mA, but since 900 isn't divisible
445 * by 8 the integral division will effectively cap to 896mA.
446 */
447 return min(val, 900U) / 8;
Sebastian Andrzej Siewior8f900a92012-12-03 20:07:05 +0100448}
449
David Brownell40982be2008-06-19 17:52:58 -0700450static int config_buf(struct usb_configuration *config,
451 enum usb_device_speed speed, void *buf, u8 type)
452{
453 struct usb_config_descriptor *c = buf;
454 void *next = buf + USB_DT_CONFIG_SIZE;
Sebastian Andrzej Siewiore13f17f2012-09-10 15:01:51 +0200455 int len;
David Brownell40982be2008-06-19 17:52:58 -0700456 struct usb_function *f;
457 int status;
458
Sebastian Andrzej Siewiore13f17f2012-09-10 15:01:51 +0200459 len = USB_COMP_EP0_BUFSIZ - USB_DT_CONFIG_SIZE;
David Brownell40982be2008-06-19 17:52:58 -0700460 /* write the config descriptor */
461 c = buf;
462 c->bLength = USB_DT_CONFIG_SIZE;
463 c->bDescriptorType = type;
464 /* wTotalLength is written later */
465 c->bNumInterfaces = config->next_interface_id;
466 c->bConfigurationValue = config->bConfigurationValue;
467 c->iConfiguration = config->iConfiguration;
468 c->bmAttributes = USB_CONFIG_ATT_ONE | config->bmAttributes;
Sebastian Andrzej Siewior8f900a92012-12-03 20:07:05 +0100469 c->bMaxPower = encode_bMaxPower(speed, config);
David Brownell40982be2008-06-19 17:52:58 -0700470
471 /* There may be e.g. OTG descriptors */
472 if (config->descriptors) {
473 status = usb_descriptor_fillbuf(next, len,
474 config->descriptors);
475 if (status < 0)
476 return status;
477 len -= status;
478 next += status;
479 }
480
481 /* add each function's descriptors */
482 list_for_each_entry(f, &config->functions, list) {
483 struct usb_descriptor_header **descriptors;
484
John Younf3bdbe32016-02-05 17:07:03 -0800485 descriptors = function_descriptors(f, speed);
David Brownell40982be2008-06-19 17:52:58 -0700486 if (!descriptors)
487 continue;
488 status = usb_descriptor_fillbuf(next, len,
489 (const struct usb_descriptor_header **) descriptors);
490 if (status < 0)
491 return status;
492 len -= status;
493 next += status;
494 }
495
496 len = next - buf;
497 c->wTotalLength = cpu_to_le16(len);
498 return len;
499}
500
501static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
502{
503 struct usb_gadget *gadget = cdev->gadget;
504 struct usb_configuration *c;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +0200505 struct list_head *pos;
David Brownell40982be2008-06-19 17:52:58 -0700506 u8 type = w_value >> 8;
507 enum usb_device_speed speed = USB_SPEED_UNKNOWN;
508
John Youneae58202016-02-05 17:07:17 -0800509 if (gadget->speed >= USB_SPEED_SUPER)
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300510 speed = gadget->speed;
511 else if (gadget_is_dualspeed(gadget)) {
512 int hs = 0;
David Brownell40982be2008-06-19 17:52:58 -0700513 if (gadget->speed == USB_SPEED_HIGH)
514 hs = 1;
515 if (type == USB_DT_OTHER_SPEED_CONFIG)
516 hs = !hs;
517 if (hs)
518 speed = USB_SPEED_HIGH;
519
520 }
521
522 /* This is a lookup by config *INDEX* */
523 w_value &= 0xff;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +0200524
525 pos = &cdev->configs;
526 c = cdev->os_desc_config;
527 if (c)
528 goto check_config;
529
530 while ((pos = pos->next) != &cdev->configs) {
531 c = list_entry(pos, typeof(*c), list);
532
533 /* skip OS Descriptors config which is handled separately */
534 if (c == cdev->os_desc_config)
535 continue;
536
537check_config:
David Brownell40982be2008-06-19 17:52:58 -0700538 /* ignore configs that won't work at this speed */
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300539 switch (speed) {
John Youneae58202016-02-05 17:07:17 -0800540 case USB_SPEED_SUPER_PLUS:
541 if (!c->superspeed_plus)
542 continue;
543 break;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300544 case USB_SPEED_SUPER:
545 if (!c->superspeed)
546 continue;
547 break;
548 case USB_SPEED_HIGH:
David Brownell40982be2008-06-19 17:52:58 -0700549 if (!c->highspeed)
550 continue;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300551 break;
552 default:
David Brownell40982be2008-06-19 17:52:58 -0700553 if (!c->fullspeed)
554 continue;
555 }
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300556
David Brownell40982be2008-06-19 17:52:58 -0700557 if (w_value == 0)
558 return config_buf(c, speed, cdev->req->buf, type);
559 w_value--;
560 }
561 return -EINVAL;
562}
563
564static int count_configs(struct usb_composite_dev *cdev, unsigned type)
565{
566 struct usb_gadget *gadget = cdev->gadget;
567 struct usb_configuration *c;
568 unsigned count = 0;
569 int hs = 0;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300570 int ss = 0;
John Youna4afd012016-02-05 17:06:49 -0800571 int ssp = 0;
David Brownell40982be2008-06-19 17:52:58 -0700572
573 if (gadget_is_dualspeed(gadget)) {
574 if (gadget->speed == USB_SPEED_HIGH)
575 hs = 1;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300576 if (gadget->speed == USB_SPEED_SUPER)
577 ss = 1;
John Youna4afd012016-02-05 17:06:49 -0800578 if (gadget->speed == USB_SPEED_SUPER_PLUS)
579 ssp = 1;
David Brownell40982be2008-06-19 17:52:58 -0700580 if (type == USB_DT_DEVICE_QUALIFIER)
581 hs = !hs;
582 }
583 list_for_each_entry(c, &cdev->configs, list) {
584 /* ignore configs that won't work at this speed */
John Youna4afd012016-02-05 17:06:49 -0800585 if (ssp) {
586 if (!c->superspeed_plus)
587 continue;
588 } else if (ss) {
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300589 if (!c->superspeed)
590 continue;
591 } else if (hs) {
David Brownell40982be2008-06-19 17:52:58 -0700592 if (!c->highspeed)
593 continue;
594 } else {
595 if (!c->fullspeed)
596 continue;
597 }
598 count++;
599 }
600 return count;
601}
602
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300603/**
604 * bos_desc() - prepares the BOS descriptor.
605 * @cdev: pointer to usb_composite device to generate the bos
606 * descriptor for
607 *
608 * This function generates the BOS (Binary Device Object)
609 * descriptor and its device capabilities descriptors. The BOS
610 * descriptor should be supported by a SuperSpeed device.
611 */
612static int bos_desc(struct usb_composite_dev *cdev)
613{
614 struct usb_ext_cap_descriptor *usb_ext;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300615 struct usb_dcd_config_params dcd_config_params;
616 struct usb_bos_descriptor *bos = cdev->req->buf;
Thinh Nguyencca38542019-08-19 18:36:12 -0700617 unsigned int besl = 0;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300618
619 bos->bLength = USB_DT_BOS_SIZE;
620 bos->bDescriptorType = USB_DT_BOS;
621
622 bos->wTotalLength = cpu_to_le16(USB_DT_BOS_SIZE);
623 bos->bNumDeviceCaps = 0;
624
Thinh Nguyencca38542019-08-19 18:36:12 -0700625 /* Get Controller configuration */
626 if (cdev->gadget->ops->get_config_params) {
627 cdev->gadget->ops->get_config_params(cdev->gadget,
628 &dcd_config_params);
629 } else {
630 dcd_config_params.besl_baseline =
631 USB_DEFAULT_BESL_UNSPECIFIED;
632 dcd_config_params.besl_deep =
633 USB_DEFAULT_BESL_UNSPECIFIED;
634 dcd_config_params.bU1devExitLat =
635 USB_DEFAULT_U1_DEV_EXIT_LAT;
636 dcd_config_params.bU2DevExitLat =
637 cpu_to_le16(USB_DEFAULT_U2_DEV_EXIT_LAT);
638 }
639
640 if (dcd_config_params.besl_baseline != USB_DEFAULT_BESL_UNSPECIFIED)
641 besl = USB_BESL_BASELINE_VALID |
642 USB_SET_BESL_BASELINE(dcd_config_params.besl_baseline);
643
644 if (dcd_config_params.besl_deep != USB_DEFAULT_BESL_UNSPECIFIED)
645 besl |= USB_BESL_DEEP_VALID |
646 USB_SET_BESL_DEEP(dcd_config_params.besl_deep);
647
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300648 /*
649 * A SuperSpeed device shall include the USB2.0 extension descriptor
650 * and shall support LPM when operating in USB2.0 HS mode.
651 */
652 usb_ext = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
653 bos->bNumDeviceCaps++;
654 le16_add_cpu(&bos->wTotalLength, USB_DT_USB_EXT_CAP_SIZE);
655 usb_ext->bLength = USB_DT_USB_EXT_CAP_SIZE;
656 usb_ext->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
657 usb_ext->bDevCapabilityType = USB_CAP_TYPE_EXT;
Thinh Nguyencca38542019-08-19 18:36:12 -0700658 usb_ext->bmAttributes = cpu_to_le32(USB_LPM_SUPPORT |
659 USB_BESL_SUPPORT | besl);
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300660
661 /*
662 * The Superspeed USB Capability descriptor shall be implemented by all
663 * SuperSpeed devices.
664 */
John Youn0b67a6b2017-04-28 12:55:14 +0400665 if (gadget_is_superspeed(cdev->gadget)) {
666 struct usb_ss_cap_descriptor *ss_cap;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300667
John Youn0b67a6b2017-04-28 12:55:14 +0400668 ss_cap = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
669 bos->bNumDeviceCaps++;
670 le16_add_cpu(&bos->wTotalLength, USB_DT_USB_SS_CAP_SIZE);
671 ss_cap->bLength = USB_DT_USB_SS_CAP_SIZE;
672 ss_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
673 ss_cap->bDevCapabilityType = USB_SS_CAP_TYPE;
674 ss_cap->bmAttributes = 0; /* LTM is not supported yet */
675 ss_cap->wSpeedSupported = cpu_to_le16(USB_LOW_SPEED_OPERATION |
676 USB_FULL_SPEED_OPERATION |
677 USB_HIGH_SPEED_OPERATION |
678 USB_5GBPS_OPERATION);
679 ss_cap->bFunctionalitySupport = USB_LOW_SPEED_OPERATION;
John Youn0b67a6b2017-04-28 12:55:14 +0400680 ss_cap->bU1devExitLat = dcd_config_params.bU1devExitLat;
681 ss_cap->bU2DevExitLat = dcd_config_params.bU2DevExitLat;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300682 }
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300683
John Younf228a8d2016-02-05 17:05:53 -0800684 /* The SuperSpeedPlus USB Device Capability descriptor */
685 if (gadget_is_superspeed_plus(cdev->gadget)) {
686 struct usb_ssp_cap_descriptor *ssp_cap;
687
688 ssp_cap = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
689 bos->bNumDeviceCaps++;
690
691 /*
692 * Report typical values.
693 */
694
695 le16_add_cpu(&bos->wTotalLength, USB_DT_USB_SSP_CAP_SIZE(1));
696 ssp_cap->bLength = USB_DT_USB_SSP_CAP_SIZE(1);
697 ssp_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
698 ssp_cap->bDevCapabilityType = USB_SSP_CAP_TYPE;
John Youn138b8632016-04-08 14:46:31 -0700699 ssp_cap->bReserved = 0;
700 ssp_cap->wReserved = 0;
John Younf228a8d2016-02-05 17:05:53 -0800701
702 /* SSAC = 1 (2 attributes) */
703 ssp_cap->bmAttributes = cpu_to_le32(1);
704
705 /* Min RX/TX Lane Count = 1 */
John Youn08f8cab2016-03-28 16:12:24 -0700706 ssp_cap->wFunctionalitySupport =
707 cpu_to_le16((1 << 8) | (1 << 12));
John Younf228a8d2016-02-05 17:05:53 -0800708
709 /*
710 * bmSublinkSpeedAttr[0]:
711 * ST = Symmetric, RX
712 * LSE = 3 (Gbps)
713 * LP = 1 (SuperSpeedPlus)
714 * LSM = 10 (10 Gbps)
715 */
716 ssp_cap->bmSublinkSpeedAttr[0] =
John Youn08f8cab2016-03-28 16:12:24 -0700717 cpu_to_le32((3 << 4) | (1 << 14) | (0xa << 16));
John Younf228a8d2016-02-05 17:05:53 -0800718 /*
719 * bmSublinkSpeedAttr[1] =
720 * ST = Symmetric, TX
721 * LSE = 3 (Gbps)
722 * LP = 1 (SuperSpeedPlus)
723 * LSM = 10 (10 Gbps)
724 */
725 ssp_cap->bmSublinkSpeedAttr[1] =
John Youn08f8cab2016-03-28 16:12:24 -0700726 cpu_to_le32((3 << 4) | (1 << 14) |
727 (0xa << 16) | (1 << 7));
John Younf228a8d2016-02-05 17:05:53 -0800728 }
729
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300730 return le16_to_cpu(bos->wTotalLength);
731}
732
David Brownell40982be2008-06-19 17:52:58 -0700733static void device_qual(struct usb_composite_dev *cdev)
734{
735 struct usb_qualifier_descriptor *qual = cdev->req->buf;
736
737 qual->bLength = sizeof(*qual);
738 qual->bDescriptorType = USB_DT_DEVICE_QUALIFIER;
739 /* POLICY: same bcdUSB and device type info at both speeds */
740 qual->bcdUSB = cdev->desc.bcdUSB;
741 qual->bDeviceClass = cdev->desc.bDeviceClass;
742 qual->bDeviceSubClass = cdev->desc.bDeviceSubClass;
743 qual->bDeviceProtocol = cdev->desc.bDeviceProtocol;
744 /* ASSUME same EP0 fifo size at both speeds */
Sebastian Andrzej Siewior765f5b82011-06-23 14:26:11 +0200745 qual->bMaxPacketSize0 = cdev->gadget->ep0->maxpacket;
David Brownell40982be2008-06-19 17:52:58 -0700746 qual->bNumConfigurations = count_configs(cdev, USB_DT_DEVICE_QUALIFIER);
David Lopoc24f4222008-07-01 13:14:17 -0700747 qual->bRESERVED = 0;
David Brownell40982be2008-06-19 17:52:58 -0700748}
749
750/*-------------------------------------------------------------------------*/
751
752static void reset_config(struct usb_composite_dev *cdev)
753{
754 struct usb_function *f;
755
756 DBG(cdev, "reset config\n");
757
758 list_for_each_entry(f, &cdev->config->functions, list) {
759 if (f->disable)
760 f->disable(f);
Laurent Pinchart52426582009-10-21 00:03:38 +0200761
762 bitmap_zero(f->endpoints, 32);
David Brownell40982be2008-06-19 17:52:58 -0700763 }
764 cdev->config = NULL;
Michael Grzeschik2bac51a2013-11-11 23:43:32 +0100765 cdev->delayed_status = 0;
David Brownell40982be2008-06-19 17:52:58 -0700766}
767
768static int set_config(struct usb_composite_dev *cdev,
769 const struct usb_ctrlrequest *ctrl, unsigned number)
770{
771 struct usb_gadget *gadget = cdev->gadget;
772 struct usb_configuration *c = NULL;
773 int result = -EINVAL;
774 unsigned power = gadget_is_otg(gadget) ? 8 : 100;
775 int tmp;
776
David Brownell40982be2008-06-19 17:52:58 -0700777 if (number) {
778 list_for_each_entry(c, &cdev->configs, list) {
779 if (c->bConfigurationValue == number) {
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300780 /*
781 * We disable the FDs of the previous
782 * configuration only if the new configuration
783 * is a valid one
784 */
785 if (cdev->config)
786 reset_config(cdev);
David Brownell40982be2008-06-19 17:52:58 -0700787 result = 0;
788 break;
789 }
790 }
791 if (result < 0)
792 goto done;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300793 } else { /* Zero configuration value - need to reset the config */
794 if (cdev->config)
795 reset_config(cdev);
David Brownell40982be2008-06-19 17:52:58 -0700796 result = 0;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300797 }
David Brownell40982be2008-06-19 17:52:58 -0700798
Joel Stanley1cbfb8c2019-09-30 22:44:34 +0930799 DBG(cdev, "%s config #%d: %s\n",
800 usb_speed_string(gadget->speed),
801 number, c ? c->label : "unconfigured");
David Brownell40982be2008-06-19 17:52:58 -0700802
803 if (!c)
804 goto done;
805
Peter Chen6027f312014-04-29 13:26:28 +0800806 usb_gadget_set_state(gadget, USB_STATE_CONFIGURED);
David Brownell40982be2008-06-19 17:52:58 -0700807 cdev->config = c;
808
809 /* Initialize all interfaces by setting them to altsetting zero. */
810 for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
811 struct usb_function *f = c->interface[tmp];
Laurent Pinchart52426582009-10-21 00:03:38 +0200812 struct usb_descriptor_header **descriptors;
David Brownell40982be2008-06-19 17:52:58 -0700813
814 if (!f)
815 break;
816
Laurent Pinchart52426582009-10-21 00:03:38 +0200817 /*
818 * Record which endpoints are used by the function. This is used
819 * to dispatch control requests targeted at that endpoint to the
820 * function's setup callback instead of the current
821 * configuration's setup callback.
822 */
John Younf3bdbe32016-02-05 17:07:03 -0800823 descriptors = function_descriptors(f, gadget->speed);
Laurent Pinchart52426582009-10-21 00:03:38 +0200824
825 for (; *descriptors; ++descriptors) {
826 struct usb_endpoint_descriptor *ep;
827 int addr;
828
829 if ((*descriptors)->bDescriptorType != USB_DT_ENDPOINT)
830 continue;
831
832 ep = (struct usb_endpoint_descriptor *)*descriptors;
833 addr = ((ep->bEndpointAddress & 0x80) >> 3)
834 | (ep->bEndpointAddress & 0x0f);
835 set_bit(addr, f->endpoints);
836 }
837
David Brownell40982be2008-06-19 17:52:58 -0700838 result = f->set_alt(f, tmp, 0);
839 if (result < 0) {
840 DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
841 tmp, f->name, f, result);
842
843 reset_config(cdev);
844 goto done;
845 }
Roger Quadros1b9ba002011-05-09 13:08:06 +0300846
847 if (result == USB_GADGET_DELAYED_STATUS) {
848 DBG(cdev,
849 "%s: interface %d (%s) requested delayed status\n",
850 __func__, tmp, f->name);
851 cdev->delayed_status++;
852 DBG(cdev, "delayed_status count %d\n",
853 cdev->delayed_status);
854 }
David Brownell40982be2008-06-19 17:52:58 -0700855 }
856
857 /* when we return, be sure our power usage is valid */
Sebastian Andrzej Siewior8f900a92012-12-03 20:07:05 +0100858 power = c->MaxPower ? c->MaxPower : CONFIG_USB_GADGET_VBUS_DRAW;
Jack Phama2035412020-01-30 19:10:36 -0800859 if (gadget->speed < USB_SPEED_SUPER)
860 power = min(power, 500U);
861 else
862 power = min(power, 900U);
David Brownell40982be2008-06-19 17:52:58 -0700863done:
Thinh Nguyen5e5caf42020-02-03 18:05:32 -0800864 if (power <= USB_SELF_POWER_VBUS_MAX_DRAW)
865 usb_gadget_set_selfpowered(gadget);
866 else
867 usb_gadget_clear_selfpowered(gadget);
868
David Brownell40982be2008-06-19 17:52:58 -0700869 usb_gadget_vbus_draw(gadget, power);
Roger Quadros1b9ba002011-05-09 13:08:06 +0300870 if (result >= 0 && cdev->delayed_status)
871 result = USB_GADGET_DELAYED_STATUS;
David Brownell40982be2008-06-19 17:52:58 -0700872 return result;
873}
874
Sebastian Andrzej Siewiorde53c252012-12-23 21:10:00 +0100875int usb_add_config_only(struct usb_composite_dev *cdev,
876 struct usb_configuration *config)
877{
878 struct usb_configuration *c;
879
880 if (!config->bConfigurationValue)
881 return -EINVAL;
882
883 /* Prevent duplicate configuration identifiers */
884 list_for_each_entry(c, &cdev->configs, list) {
885 if (c->bConfigurationValue == config->bConfigurationValue)
886 return -EBUSY;
887 }
888
889 config->cdev = cdev;
890 list_add_tail(&config->list, &cdev->configs);
891
892 INIT_LIST_HEAD(&config->functions);
893 config->next_interface_id = 0;
894 memset(config->interface, 0, sizeof(config->interface));
895
896 return 0;
897}
898EXPORT_SYMBOL_GPL(usb_add_config_only);
899
David Brownell40982be2008-06-19 17:52:58 -0700900/**
901 * usb_add_config() - add a configuration to a device.
902 * @cdev: wraps the USB gadget
903 * @config: the configuration, with bConfigurationValue assigned
Uwe Kleine-Königc9bfff92010-08-12 17:43:55 +0200904 * @bind: the configuration's bind function
David Brownell40982be2008-06-19 17:52:58 -0700905 * Context: single threaded during gadget setup
906 *
Uwe Kleine-Königc9bfff92010-08-12 17:43:55 +0200907 * One of the main tasks of a composite @bind() routine is to
David Brownell40982be2008-06-19 17:52:58 -0700908 * add each of the configurations it supports, using this routine.
909 *
Uwe Kleine-Königc9bfff92010-08-12 17:43:55 +0200910 * This function returns the value of the configuration's @bind(), which
David Brownell40982be2008-06-19 17:52:58 -0700911 * is zero for success else a negative errno value. Binding configurations
912 * assigns global resources including string IDs, and per-configuration
913 * resources such as interface IDs and endpoints.
914 */
Michal Nazarewicz28824b12010-05-05 12:53:13 +0200915int usb_add_config(struct usb_composite_dev *cdev,
Uwe Kleine-Königc9bfff92010-08-12 17:43:55 +0200916 struct usb_configuration *config,
917 int (*bind)(struct usb_configuration *))
David Brownell40982be2008-06-19 17:52:58 -0700918{
919 int status = -EINVAL;
Sebastian Andrzej Siewiorde53c252012-12-23 21:10:00 +0100920
921 if (!bind)
922 goto done;
David Brownell40982be2008-06-19 17:52:58 -0700923
924 DBG(cdev, "adding config #%u '%s'/%p\n",
925 config->bConfigurationValue,
926 config->label, config);
927
Sebastian Andrzej Siewiorde53c252012-12-23 21:10:00 +0100928 status = usb_add_config_only(cdev, config);
929 if (status)
David Brownell40982be2008-06-19 17:52:58 -0700930 goto done;
931
Uwe Kleine-Königc9bfff92010-08-12 17:43:55 +0200932 status = bind(config);
David Brownell40982be2008-06-19 17:52:58 -0700933 if (status < 0) {
Yongsul Oh124ef382012-03-20 10:38:38 +0900934 while (!list_empty(&config->functions)) {
935 struct usb_function *f;
936
937 f = list_first_entry(&config->functions,
938 struct usb_function, list);
939 list_del(&f->list);
940 if (f->unbind) {
941 DBG(cdev, "unbind function '%s'/%p\n",
942 f->name, f);
943 f->unbind(config, f);
944 /* may free memory for "f" */
945 }
946 }
David Brownell40982be2008-06-19 17:52:58 -0700947 list_del(&config->list);
948 config->cdev = NULL;
949 } else {
950 unsigned i;
951
John Youncd69cbe2016-02-05 17:07:44 -0800952 DBG(cdev, "cfg %d/%p speeds:%s%s%s%s\n",
David Brownell40982be2008-06-19 17:52:58 -0700953 config->bConfigurationValue, config,
John Youncd69cbe2016-02-05 17:07:44 -0800954 config->superspeed_plus ? " superplus" : "",
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +0300955 config->superspeed ? " super" : "",
David Brownell40982be2008-06-19 17:52:58 -0700956 config->highspeed ? " high" : "",
957 config->fullspeed
958 ? (gadget_is_dualspeed(cdev->gadget)
959 ? " full"
960 : " full/low")
961 : "");
962
963 for (i = 0; i < MAX_CONFIG_INTERFACES; i++) {
964 struct usb_function *f = config->interface[i];
965
966 if (!f)
967 continue;
968 DBG(cdev, " interface %d = %s/%p\n",
969 i, f->name, f);
970 }
971 }
972
Robert Baldygaf871cb92015-09-16 12:10:39 +0200973 /* set_alt(), or next bind(), sets up ep->claimed as needed */
David Brownell40982be2008-06-19 17:52:58 -0700974 usb_ep_autoconfig_reset(cdev->gadget);
975
976done:
977 if (status)
978 DBG(cdev, "added config '%s'/%u --> %d\n", config->label,
979 config->bConfigurationValue, status);
980 return status;
981}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +0200982EXPORT_SYMBOL_GPL(usb_add_config);
David Brownell40982be2008-06-19 17:52:58 -0700983
Benoit Goby51cce6f2012-05-10 10:07:57 +0200984static void remove_config(struct usb_composite_dev *cdev,
985 struct usb_configuration *config)
986{
987 while (!list_empty(&config->functions)) {
988 struct usb_function *f;
989
990 f = list_first_entry(&config->functions,
991 struct usb_function, list);
Felipe Balbi0e3e9752017-06-06 14:47:29 +0300992
993 usb_remove_function(config, f);
Benoit Goby51cce6f2012-05-10 10:07:57 +0200994 }
995 list_del(&config->list);
996 if (config->unbind) {
997 DBG(cdev, "unbind config '%s'/%p\n", config->label, config);
998 config->unbind(config);
999 /* may free memory for "c" */
1000 }
1001}
1002
1003/**
1004 * usb_remove_config() - remove a configuration from a device.
1005 * @cdev: wraps the USB gadget
1006 * @config: the configuration
1007 *
1008 * Drivers must call usb_gadget_disconnect before calling this function
1009 * to disconnect the device from the host and make sure the host will not
1010 * try to enumerate the device while we are changing the config list.
1011 */
1012void usb_remove_config(struct usb_composite_dev *cdev,
1013 struct usb_configuration *config)
1014{
1015 unsigned long flags;
1016
1017 spin_lock_irqsave(&cdev->lock, flags);
1018
1019 if (cdev->config == config)
1020 reset_config(cdev);
1021
1022 spin_unlock_irqrestore(&cdev->lock, flags);
1023
1024 remove_config(cdev, config);
1025}
1026
David Brownell40982be2008-06-19 17:52:58 -07001027/*-------------------------------------------------------------------------*/
1028
1029/* We support strings in multiple languages ... string descriptor zero
1030 * says which languages are supported. The typical case will be that
Diego Violaad4676a2015-05-31 15:52:41 -03001031 * only one language (probably English) is used, with i18n handled on
David Brownell40982be2008-06-19 17:52:58 -07001032 * the host side.
1033 */
1034
1035static void collect_langs(struct usb_gadget_strings **sp, __le16 *buf)
1036{
1037 const struct usb_gadget_strings *s;
Dan Carpenter20c5e742012-04-17 09:30:22 +03001038 __le16 language;
David Brownell40982be2008-06-19 17:52:58 -07001039 __le16 *tmp;
1040
1041 while (*sp) {
1042 s = *sp;
1043 language = cpu_to_le16(s->language);
1044 for (tmp = buf; *tmp && tmp < &buf[126]; tmp++) {
1045 if (*tmp == language)
1046 goto repeat;
1047 }
1048 *tmp++ = language;
1049repeat:
1050 sp++;
1051 }
1052}
1053
1054static int lookup_string(
1055 struct usb_gadget_strings **sp,
1056 void *buf,
1057 u16 language,
1058 int id
1059)
1060{
1061 struct usb_gadget_strings *s;
1062 int value;
1063
1064 while (*sp) {
1065 s = *sp++;
1066 if (s->language != language)
1067 continue;
1068 value = usb_gadget_get_string(s, id, buf);
1069 if (value > 0)
1070 return value;
1071 }
1072 return -EINVAL;
1073}
1074
1075static int get_string(struct usb_composite_dev *cdev,
1076 void *buf, u16 language, int id)
1077{
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02001078 struct usb_composite_driver *composite = cdev->driver;
Sebastian Andrzej Siewior9bb28592012-12-23 21:10:22 +01001079 struct usb_gadget_string_container *uc;
David Brownell40982be2008-06-19 17:52:58 -07001080 struct usb_configuration *c;
1081 struct usb_function *f;
1082 int len;
1083
Diego Violaad4676a2015-05-31 15:52:41 -03001084 /* Yes, not only is USB's i18n support probably more than most
David Brownell40982be2008-06-19 17:52:58 -07001085 * folk will ever care about ... also, it's all supported here.
1086 * (Except for UTF8 support for Unicode's "Astral Planes".)
1087 */
1088
1089 /* 0 == report all available language codes */
1090 if (id == 0) {
1091 struct usb_string_descriptor *s = buf;
1092 struct usb_gadget_strings **sp;
1093
1094 memset(s, 0, 256);
1095 s->bDescriptorType = USB_DT_STRING;
1096
1097 sp = composite->strings;
1098 if (sp)
1099 collect_langs(sp, s->wData);
1100
1101 list_for_each_entry(c, &cdev->configs, list) {
1102 sp = c->strings;
1103 if (sp)
1104 collect_langs(sp, s->wData);
1105
1106 list_for_each_entry(f, &c->functions, list) {
1107 sp = f->strings;
1108 if (sp)
1109 collect_langs(sp, s->wData);
1110 }
1111 }
Sebastian Andrzej Siewior27a466332012-12-23 21:10:23 +01001112 list_for_each_entry(uc, &cdev->gstrings, list) {
1113 struct usb_gadget_strings **sp;
1114
1115 sp = get_containers_gs(uc);
1116 collect_langs(sp, s->wData);
1117 }
David Brownell40982be2008-06-19 17:52:58 -07001118
Roel Kluin417b57b2009-08-06 16:09:51 -07001119 for (len = 0; len <= 126 && s->wData[len]; len++)
David Brownell40982be2008-06-19 17:52:58 -07001120 continue;
1121 if (!len)
1122 return -EINVAL;
1123
1124 s->bLength = 2 * (len + 1);
1125 return s->bLength;
1126 }
1127
Andrzej Pietrasiewicz19824d52014-05-08 14:06:22 +02001128 if (cdev->use_os_string && language == 0 && id == OS_STRING_IDX) {
1129 struct usb_os_string *b = buf;
1130 b->bLength = sizeof(*b);
1131 b->bDescriptorType = USB_DT_STRING;
1132 compiletime_assert(
1133 sizeof(b->qwSignature) == sizeof(cdev->qw_sign),
1134 "qwSignature size must be equal to qw_sign");
1135 memcpy(&b->qwSignature, cdev->qw_sign, sizeof(b->qwSignature));
1136 b->bMS_VendorCode = cdev->b_vendor_code;
1137 b->bPad = 0;
1138 return sizeof(*b);
1139 }
1140
Sebastian Andrzej Siewior9bb28592012-12-23 21:10:22 +01001141 list_for_each_entry(uc, &cdev->gstrings, list) {
1142 struct usb_gadget_strings **sp;
1143
1144 sp = get_containers_gs(uc);
1145 len = lookup_string(sp, buf, language, id);
1146 if (len > 0)
1147 return len;
1148 }
1149
Michal Nazarewiczad1a8102010-08-12 17:43:46 +02001150 /* String IDs are device-scoped, so we look up each string
1151 * table we're told about. These lookups are infrequent;
1152 * simpler-is-better here.
David Brownell40982be2008-06-19 17:52:58 -07001153 */
1154 if (composite->strings) {
1155 len = lookup_string(composite->strings, buf, language, id);
1156 if (len > 0)
1157 return len;
1158 }
1159 list_for_each_entry(c, &cdev->configs, list) {
1160 if (c->strings) {
1161 len = lookup_string(c->strings, buf, language, id);
1162 if (len > 0)
1163 return len;
1164 }
1165 list_for_each_entry(f, &c->functions, list) {
1166 if (!f->strings)
1167 continue;
1168 len = lookup_string(f->strings, buf, language, id);
1169 if (len > 0)
1170 return len;
1171 }
1172 }
1173 return -EINVAL;
1174}
1175
1176/**
1177 * usb_string_id() - allocate an unused string ID
1178 * @cdev: the device whose string descriptor IDs are being allocated
1179 * Context: single threaded during gadget setup
1180 *
1181 * @usb_string_id() is called from bind() callbacks to allocate
1182 * string IDs. Drivers for functions, configurations, or gadgets will
1183 * then store that ID in the appropriate descriptors and string table.
1184 *
Michal Nazarewiczf2adc4f2010-06-16 12:07:59 +02001185 * All string identifier should be allocated using this,
1186 * @usb_string_ids_tab() or @usb_string_ids_n() routine, to ensure
1187 * that for example different functions don't wrongly assign different
1188 * meanings to the same identifier.
David Brownell40982be2008-06-19 17:52:58 -07001189 */
Michal Nazarewicz28824b12010-05-05 12:53:13 +02001190int usb_string_id(struct usb_composite_dev *cdev)
David Brownell40982be2008-06-19 17:52:58 -07001191{
1192 if (cdev->next_string_id < 254) {
Michal Nazarewiczf2adc4f2010-06-16 12:07:59 +02001193 /* string id 0 is reserved by USB spec for list of
1194 * supported languages */
1195 /* 255 reserved as well? -- mina86 */
David Brownell40982be2008-06-19 17:52:58 -07001196 cdev->next_string_id++;
1197 return cdev->next_string_id;
1198 }
1199 return -ENODEV;
1200}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +02001201EXPORT_SYMBOL_GPL(usb_string_id);
David Brownell40982be2008-06-19 17:52:58 -07001202
Michal Nazarewiczf2adc4f2010-06-16 12:07:59 +02001203/**
1204 * usb_string_ids() - allocate unused string IDs in batch
1205 * @cdev: the device whose string descriptor IDs are being allocated
1206 * @str: an array of usb_string objects to assign numbers to
1207 * Context: single threaded during gadget setup
1208 *
1209 * @usb_string_ids() is called from bind() callbacks to allocate
1210 * string IDs. Drivers for functions, configurations, or gadgets will
1211 * then copy IDs from the string table to the appropriate descriptors
1212 * and string table for other languages.
1213 *
1214 * All string identifier should be allocated using this,
1215 * @usb_string_id() or @usb_string_ids_n() routine, to ensure that for
1216 * example different functions don't wrongly assign different meanings
1217 * to the same identifier.
1218 */
1219int usb_string_ids_tab(struct usb_composite_dev *cdev, struct usb_string *str)
1220{
1221 int next = cdev->next_string_id;
1222
1223 for (; str->s; ++str) {
1224 if (unlikely(next >= 254))
1225 return -ENODEV;
1226 str->id = ++next;
1227 }
1228
1229 cdev->next_string_id = next;
1230
1231 return 0;
1232}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +02001233EXPORT_SYMBOL_GPL(usb_string_ids_tab);
Michal Nazarewiczf2adc4f2010-06-16 12:07:59 +02001234
Sebastian Andrzej Siewior9bb28592012-12-23 21:10:22 +01001235static struct usb_gadget_string_container *copy_gadget_strings(
1236 struct usb_gadget_strings **sp, unsigned n_gstrings,
1237 unsigned n_strings)
1238{
1239 struct usb_gadget_string_container *uc;
1240 struct usb_gadget_strings **gs_array;
1241 struct usb_gadget_strings *gs;
1242 struct usb_string *s;
1243 unsigned mem;
1244 unsigned n_gs;
1245 unsigned n_s;
1246 void *stash;
1247
1248 mem = sizeof(*uc);
1249 mem += sizeof(void *) * (n_gstrings + 1);
1250 mem += sizeof(struct usb_gadget_strings) * n_gstrings;
1251 mem += sizeof(struct usb_string) * (n_strings + 1) * (n_gstrings);
1252 uc = kmalloc(mem, GFP_KERNEL);
1253 if (!uc)
1254 return ERR_PTR(-ENOMEM);
1255 gs_array = get_containers_gs(uc);
1256 stash = uc->stash;
1257 stash += sizeof(void *) * (n_gstrings + 1);
1258 for (n_gs = 0; n_gs < n_gstrings; n_gs++) {
1259 struct usb_string *org_s;
1260
1261 gs_array[n_gs] = stash;
1262 gs = gs_array[n_gs];
1263 stash += sizeof(struct usb_gadget_strings);
1264 gs->language = sp[n_gs]->language;
1265 gs->strings = stash;
1266 org_s = sp[n_gs]->strings;
1267
1268 for (n_s = 0; n_s < n_strings; n_s++) {
1269 s = stash;
1270 stash += sizeof(struct usb_string);
1271 if (org_s->s)
1272 s->s = org_s->s;
1273 else
1274 s->s = "";
1275 org_s++;
1276 }
1277 s = stash;
1278 s->s = NULL;
1279 stash += sizeof(struct usb_string);
1280
1281 }
1282 gs_array[n_gs] = NULL;
1283 return uc;
1284}
1285
1286/**
1287 * usb_gstrings_attach() - attach gadget strings to a cdev and assign ids
1288 * @cdev: the device whose string descriptor IDs are being allocated
1289 * and attached.
1290 * @sp: an array of usb_gadget_strings to attach.
1291 * @n_strings: number of entries in each usb_strings array (sp[]->strings)
1292 *
1293 * This function will create a deep copy of usb_gadget_strings and usb_string
1294 * and attach it to the cdev. The actual string (usb_string.s) will not be
1295 * copied but only a referenced will be made. The struct usb_gadget_strings
Masanari Iida06ed0de2015-03-10 22:37:46 +09001296 * array may contain multiple languages and should be NULL terminated.
Sebastian Andrzej Siewior9bb28592012-12-23 21:10:22 +01001297 * The ->language pointer of each struct usb_gadget_strings has to contain the
1298 * same amount of entries.
1299 * For instance: sp[0] is en-US, sp[1] is es-ES. It is expected that the first
Masanari Iida06ed0de2015-03-10 22:37:46 +09001300 * usb_string entry of es-ES contains the translation of the first usb_string
Sebastian Andrzej Siewior9bb28592012-12-23 21:10:22 +01001301 * entry of en-US. Therefore both entries become the same id assign.
1302 */
1303struct usb_string *usb_gstrings_attach(struct usb_composite_dev *cdev,
1304 struct usb_gadget_strings **sp, unsigned n_strings)
1305{
1306 struct usb_gadget_string_container *uc;
1307 struct usb_gadget_strings **n_gs;
1308 unsigned n_gstrings = 0;
1309 unsigned i;
1310 int ret;
1311
1312 for (i = 0; sp[i]; i++)
1313 n_gstrings++;
1314
1315 if (!n_gstrings)
1316 return ERR_PTR(-EINVAL);
1317
1318 uc = copy_gadget_strings(sp, n_gstrings, n_strings);
1319 if (IS_ERR(uc))
Felipe Balbidad4bab2014-03-10 13:30:56 -05001320 return ERR_CAST(uc);
Sebastian Andrzej Siewior9bb28592012-12-23 21:10:22 +01001321
1322 n_gs = get_containers_gs(uc);
1323 ret = usb_string_ids_tab(cdev, n_gs[0]->strings);
1324 if (ret)
1325 goto err;
1326
1327 for (i = 1; i < n_gstrings; i++) {
1328 struct usb_string *m_s;
1329 struct usb_string *s;
1330 unsigned n;
1331
1332 m_s = n_gs[0]->strings;
1333 s = n_gs[i]->strings;
1334 for (n = 0; n < n_strings; n++) {
1335 s->id = m_s->id;
1336 s++;
1337 m_s++;
1338 }
1339 }
1340 list_add_tail(&uc->list, &cdev->gstrings);
1341 return n_gs[0]->strings;
1342err:
1343 kfree(uc);
1344 return ERR_PTR(ret);
1345}
1346EXPORT_SYMBOL_GPL(usb_gstrings_attach);
1347
Michal Nazarewiczf2adc4f2010-06-16 12:07:59 +02001348/**
1349 * usb_string_ids_n() - allocate unused string IDs in batch
Randy Dunlapd187abb2010-08-11 12:07:13 -07001350 * @c: the device whose string descriptor IDs are being allocated
Michal Nazarewiczf2adc4f2010-06-16 12:07:59 +02001351 * @n: number of string IDs to allocate
1352 * Context: single threaded during gadget setup
1353 *
1354 * Returns the first requested ID. This ID and next @n-1 IDs are now
Randy Dunlapd187abb2010-08-11 12:07:13 -07001355 * valid IDs. At least provided that @n is non-zero because if it
Michal Nazarewiczf2adc4f2010-06-16 12:07:59 +02001356 * is, returns last requested ID which is now very useful information.
1357 *
1358 * @usb_string_ids_n() is called from bind() callbacks to allocate
1359 * string IDs. Drivers for functions, configurations, or gadgets will
1360 * then store that ID in the appropriate descriptors and string table.
1361 *
1362 * All string identifier should be allocated using this,
1363 * @usb_string_id() or @usb_string_ids_n() routine, to ensure that for
1364 * example different functions don't wrongly assign different meanings
1365 * to the same identifier.
1366 */
1367int usb_string_ids_n(struct usb_composite_dev *c, unsigned n)
1368{
1369 unsigned next = c->next_string_id;
1370 if (unlikely(n > 254 || (unsigned)next + n > 254))
1371 return -ENODEV;
1372 c->next_string_id += n;
1373 return next + 1;
1374}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +02001375EXPORT_SYMBOL_GPL(usb_string_ids_n);
Michal Nazarewiczf2adc4f2010-06-16 12:07:59 +02001376
David Brownell40982be2008-06-19 17:52:58 -07001377/*-------------------------------------------------------------------------*/
1378
1379static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
1380{
Felipe Balbia7c12ea2014-09-18 10:01:55 -05001381 struct usb_composite_dev *cdev;
1382
David Brownell40982be2008-06-19 17:52:58 -07001383 if (req->status || req->actual != req->length)
1384 DBG((struct usb_composite_dev *) ep->driver_data,
1385 "setup complete --> %d, %d/%d\n",
1386 req->status, req->actual, req->length);
Felipe Balbia7c12ea2014-09-18 10:01:55 -05001387
1388 /*
1389 * REVIST The same ep0 requests are shared with function drivers
1390 * so they don't have to maintain the same ->complete() stubs.
1391 *
1392 * Because of that, we need to check for the validity of ->context
1393 * here, even though we know we've set it to something useful.
1394 */
1395 if (!req->context)
1396 return;
1397
1398 cdev = req->context;
1399
1400 if (cdev->req == req)
1401 cdev->setup_pending = false;
1402 else if (cdev->os_desc_req == req)
1403 cdev->os_desc_pending = false;
1404 else
1405 WARN(1, "unknown request %p\n", req);
1406}
1407
1408static int composite_ep0_queue(struct usb_composite_dev *cdev,
1409 struct usb_request *req, gfp_t gfp_flags)
1410{
1411 int ret;
1412
1413 ret = usb_ep_queue(cdev->gadget->ep0, req, gfp_flags);
1414 if (ret == 0) {
1415 if (cdev->req == req)
1416 cdev->setup_pending = true;
1417 else if (cdev->os_desc_req == req)
1418 cdev->os_desc_pending = true;
1419 else
1420 WARN(1, "unknown request %p\n", req);
1421 }
1422
1423 return ret;
David Brownell40982be2008-06-19 17:52:58 -07001424}
1425
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001426static int count_ext_compat(struct usb_configuration *c)
1427{
1428 int i, res;
1429
1430 res = 0;
1431 for (i = 0; i < c->next_interface_id; ++i) {
1432 struct usb_function *f;
1433 int j;
1434
1435 f = c->interface[i];
1436 for (j = 0; j < f->os_desc_n; ++j) {
1437 struct usb_os_desc *d;
1438
1439 if (i != f->os_desc_table[j].if_id)
1440 continue;
1441 d = f->os_desc_table[j].os_desc;
1442 if (d && d->ext_compat_id)
1443 ++res;
1444 }
1445 }
1446 BUG_ON(res > 255);
1447 return res;
1448}
1449
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001450static int fill_ext_compat(struct usb_configuration *c, u8 *buf)
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001451{
1452 int i, count;
1453
1454 count = 16;
Chris Dickens636ba132017-12-31 18:59:43 -08001455 buf += 16;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001456 for (i = 0; i < c->next_interface_id; ++i) {
1457 struct usb_function *f;
1458 int j;
1459
1460 f = c->interface[i];
1461 for (j = 0; j < f->os_desc_n; ++j) {
1462 struct usb_os_desc *d;
1463
1464 if (i != f->os_desc_table[j].if_id)
1465 continue;
1466 d = f->os_desc_table[j].os_desc;
1467 if (d && d->ext_compat_id) {
1468 *buf++ = i;
1469 *buf++ = 0x01;
1470 memcpy(buf, d->ext_compat_id, 16);
1471 buf += 22;
1472 } else {
1473 ++buf;
1474 *buf = 0x01;
1475 buf += 23;
1476 }
1477 count += 24;
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001478 if (count + 24 >= USB_COMP_EP0_OS_DESC_BUFSIZ)
1479 return count;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001480 }
1481 }
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001482
1483 return count;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001484}
1485
1486static int count_ext_prop(struct usb_configuration *c, int interface)
1487{
1488 struct usb_function *f;
Julia Lawall849b1332014-05-19 06:31:07 +02001489 int j;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001490
1491 f = c->interface[interface];
1492 for (j = 0; j < f->os_desc_n; ++j) {
1493 struct usb_os_desc *d;
1494
1495 if (interface != f->os_desc_table[j].if_id)
1496 continue;
1497 d = f->os_desc_table[j].os_desc;
1498 if (d && d->ext_compat_id)
1499 return d->ext_prop_count;
1500 }
Julia Lawall849b1332014-05-19 06:31:07 +02001501 return 0;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001502}
1503
1504static int len_ext_prop(struct usb_configuration *c, int interface)
1505{
1506 struct usb_function *f;
1507 struct usb_os_desc *d;
1508 int j, res;
1509
1510 res = 10; /* header length */
1511 f = c->interface[interface];
1512 for (j = 0; j < f->os_desc_n; ++j) {
1513 if (interface != f->os_desc_table[j].if_id)
1514 continue;
1515 d = f->os_desc_table[j].os_desc;
1516 if (d)
1517 return min(res + d->ext_prop_len, 4096);
1518 }
1519 return res;
1520}
1521
1522static int fill_ext_prop(struct usb_configuration *c, int interface, u8 *buf)
1523{
1524 struct usb_function *f;
1525 struct usb_os_desc *d;
1526 struct usb_os_desc_ext_prop *ext_prop;
1527 int j, count, n, ret;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001528
1529 f = c->interface[interface];
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001530 count = 10; /* header length */
Chris Dickens636ba132017-12-31 18:59:43 -08001531 buf += 10;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001532 for (j = 0; j < f->os_desc_n; ++j) {
1533 if (interface != f->os_desc_table[j].if_id)
1534 continue;
1535 d = f->os_desc_table[j].os_desc;
1536 if (d)
1537 list_for_each_entry(ext_prop, &d->ext_prop, entry) {
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001538 n = ext_prop->data_len +
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001539 ext_prop->name_len + 14;
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001540 if (count + n >= USB_COMP_EP0_OS_DESC_BUFSIZ)
1541 return count;
1542 usb_ext_prop_put_size(buf, n);
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001543 usb_ext_prop_put_type(buf, ext_prop->type);
1544 ret = usb_ext_prop_put_name(buf, ext_prop->name,
1545 ext_prop->name_len);
1546 if (ret < 0)
1547 return ret;
1548 switch (ext_prop->type) {
1549 case USB_EXT_PROP_UNICODE:
1550 case USB_EXT_PROP_UNICODE_ENV:
1551 case USB_EXT_PROP_UNICODE_LINK:
1552 usb_ext_prop_put_unicode(buf, ret,
1553 ext_prop->data,
1554 ext_prop->data_len);
1555 break;
1556 case USB_EXT_PROP_BINARY:
1557 usb_ext_prop_put_binary(buf, ret,
1558 ext_prop->data,
1559 ext_prop->data_len);
1560 break;
1561 case USB_EXT_PROP_LE32:
1562 /* not implemented */
1563 case USB_EXT_PROP_BE32:
1564 /* not implemented */
1565 default:
1566 return -EINVAL;
1567 }
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001568 buf += n;
1569 count += n;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001570 }
1571 }
1572
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001573 return count;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001574}
1575
David Brownell40982be2008-06-19 17:52:58 -07001576/*
1577 * The setup() callback implements all the ep0 functionality that's
1578 * not handled lower down, in hardware or the hardware driver(like
1579 * device and endpoint feature flags, and their status). It's all
1580 * housekeeping for the gadget function we're implementing. Most of
1581 * the work is in config and function specific setup.
1582 */
Sebastian Andrzej Siewior2d5a8892012-12-23 21:10:21 +01001583int
David Brownell40982be2008-06-19 17:52:58 -07001584composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1585{
1586 struct usb_composite_dev *cdev = get_gadget_data(gadget);
1587 struct usb_request *req = cdev->req;
1588 int value = -EOPNOTSUPP;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001589 int status = 0;
David Brownell40982be2008-06-19 17:52:58 -07001590 u16 w_index = le16_to_cpu(ctrl->wIndex);
Bryan Wu08889512009-01-08 00:21:19 +08001591 u8 intf = w_index & 0xFF;
David Brownell40982be2008-06-19 17:52:58 -07001592 u16 w_value = le16_to_cpu(ctrl->wValue);
1593 u16 w_length = le16_to_cpu(ctrl->wLength);
1594 struct usb_function *f = NULL;
Laurent Pinchart52426582009-10-21 00:03:38 +02001595 u8 endp;
David Brownell40982be2008-06-19 17:52:58 -07001596
1597 /* partial re-init of the response message; the function or the
1598 * gadget might need to intercept e.g. a control-OUT completion
1599 * when we delegate to it.
1600 */
1601 req->zero = 0;
Felipe Balbi57943712014-09-18 09:54:54 -05001602 req->context = cdev;
David Brownell40982be2008-06-19 17:52:58 -07001603 req->complete = composite_setup_complete;
Maulik Mankad2edb11c2011-02-22 19:08:42 +05301604 req->length = 0;
David Brownell40982be2008-06-19 17:52:58 -07001605 gadget->ep0->driver_data = cdev;
1606
Andrzej Pietrasiewicz232c0102015-03-03 10:52:04 +01001607 /*
1608 * Don't let non-standard requests match any of the cases below
1609 * by accident.
1610 */
1611 if ((ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD)
1612 goto unknown;
1613
David Brownell40982be2008-06-19 17:52:58 -07001614 switch (ctrl->bRequest) {
1615
1616 /* we handle all standard USB descriptors */
1617 case USB_REQ_GET_DESCRIPTOR:
1618 if (ctrl->bRequestType != USB_DIR_IN)
1619 goto unknown;
1620 switch (w_value >> 8) {
1621
1622 case USB_DT_DEVICE:
1623 cdev->desc.bNumConfigurations =
1624 count_configs(cdev, USB_DT_DEVICE);
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001625 cdev->desc.bMaxPacketSize0 =
1626 cdev->gadget->ep0->maxpacket;
1627 if (gadget_is_superspeed(gadget)) {
Sebastian Andrzej Siewiora8f21152011-07-19 20:21:52 +02001628 if (gadget->speed >= USB_SPEED_SUPER) {
Chunfeng Yun1ef6c422018-05-09 19:29:16 +08001629 cdev->desc.bcdUSB = cpu_to_le16(0x0320);
Sebastian Andrzej Siewiora8f21152011-07-19 20:21:52 +02001630 cdev->desc.bMaxPacketSize0 = 9;
1631 } else {
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001632 cdev->desc.bcdUSB = cpu_to_le16(0x0210);
Sebastian Andrzej Siewiora8f21152011-07-19 20:21:52 +02001633 }
Igor Kotrasinski5527e732015-08-20 10:00:01 +02001634 } else {
John Youna9548c52017-04-28 12:55:20 +04001635 if (gadget->lpm_capable)
1636 cdev->desc.bcdUSB = cpu_to_le16(0x0201);
1637 else
1638 cdev->desc.bcdUSB = cpu_to_le16(0x0200);
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001639 }
1640
David Brownell40982be2008-06-19 17:52:58 -07001641 value = min(w_length, (u16) sizeof cdev->desc);
1642 memcpy(req->buf, &cdev->desc, value);
1643 break;
1644 case USB_DT_DEVICE_QUALIFIER:
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001645 if (!gadget_is_dualspeed(gadget) ||
1646 gadget->speed >= USB_SPEED_SUPER)
David Brownell40982be2008-06-19 17:52:58 -07001647 break;
1648 device_qual(cdev);
1649 value = min_t(int, w_length,
1650 sizeof(struct usb_qualifier_descriptor));
1651 break;
1652 case USB_DT_OTHER_SPEED_CONFIG:
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001653 if (!gadget_is_dualspeed(gadget) ||
1654 gadget->speed >= USB_SPEED_SUPER)
David Brownell40982be2008-06-19 17:52:58 -07001655 break;
1656 /* FALLTHROUGH */
1657 case USB_DT_CONFIG:
1658 value = config_desc(cdev, w_value);
1659 if (value >= 0)
1660 value = min(w_length, (u16) value);
1661 break;
1662 case USB_DT_STRING:
1663 value = get_string(cdev, req->buf,
1664 w_index, w_value & 0xff);
1665 if (value >= 0)
1666 value = min(w_length, (u16) value);
1667 break;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001668 case USB_DT_BOS:
John Youna9548c52017-04-28 12:55:20 +04001669 if (gadget_is_superspeed(gadget) ||
1670 gadget->lpm_capable) {
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001671 value = bos_desc(cdev);
1672 value = min(w_length, (u16) value);
1673 }
1674 break;
Macpaul Lin53e62422015-07-09 15:18:42 +08001675 case USB_DT_OTG:
1676 if (gadget_is_otg(gadget)) {
1677 struct usb_configuration *config;
1678 int otg_desc_len = 0;
1679
1680 if (cdev->config)
1681 config = cdev->config;
1682 else
1683 config = list_first_entry(
1684 &cdev->configs,
1685 struct usb_configuration, list);
1686 if (!config)
1687 goto done;
1688
1689 if (gadget->otg_caps &&
1690 (gadget->otg_caps->otg_rev >= 0x0200))
1691 otg_desc_len += sizeof(
1692 struct usb_otg20_descriptor);
1693 else
1694 otg_desc_len += sizeof(
1695 struct usb_otg_descriptor);
1696
1697 value = min_t(int, w_length, otg_desc_len);
1698 memcpy(req->buf, config->descriptors[0], value);
1699 }
1700 break;
David Brownell40982be2008-06-19 17:52:58 -07001701 }
1702 break;
1703
1704 /* any number of configs can work */
1705 case USB_REQ_SET_CONFIGURATION:
1706 if (ctrl->bRequestType != 0)
1707 goto unknown;
1708 if (gadget_is_otg(gadget)) {
1709 if (gadget->a_hnp_support)
1710 DBG(cdev, "HNP available\n");
1711 else if (gadget->a_alt_hnp_support)
1712 DBG(cdev, "HNP on another port\n");
1713 else
1714 VDBG(cdev, "HNP inactive\n");
1715 }
1716 spin_lock(&cdev->lock);
1717 value = set_config(cdev, ctrl, w_value);
1718 spin_unlock(&cdev->lock);
1719 break;
1720 case USB_REQ_GET_CONFIGURATION:
1721 if (ctrl->bRequestType != USB_DIR_IN)
1722 goto unknown;
1723 if (cdev->config)
1724 *(u8 *)req->buf = cdev->config->bConfigurationValue;
1725 else
1726 *(u8 *)req->buf = 0;
1727 value = min(w_length, (u16) 1);
1728 break;
1729
Krzysztof Opasiak7e4da3f2016-12-20 19:52:16 +01001730 /* function drivers must handle get/set altsetting */
David Brownell40982be2008-06-19 17:52:58 -07001731 case USB_REQ_SET_INTERFACE:
1732 if (ctrl->bRequestType != USB_RECIP_INTERFACE)
1733 goto unknown;
Jassi Brarff085de2011-02-06 17:39:17 +09001734 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
David Brownell40982be2008-06-19 17:52:58 -07001735 break;
Bryan Wu08889512009-01-08 00:21:19 +08001736 f = cdev->config->interface[intf];
David Brownell40982be2008-06-19 17:52:58 -07001737 if (!f)
1738 break;
Krzysztof Opasiak7e4da3f2016-12-20 19:52:16 +01001739
1740 /*
1741 * If there's no get_alt() method, we know only altsetting zero
1742 * works. There is no need to check if set_alt() is not NULL
1743 * as we check this in usb_add_function().
1744 */
1745 if (w_value && !f->get_alt)
David Brownell40982be2008-06-19 17:52:58 -07001746 break;
Chunfeng Yun980900d2018-05-25 17:24:57 +08001747
1748 spin_lock(&cdev->lock);
David Brownell40982be2008-06-19 17:52:58 -07001749 value = f->set_alt(f, w_index, w_value);
Roger Quadros1b9ba002011-05-09 13:08:06 +03001750 if (value == USB_GADGET_DELAYED_STATUS) {
1751 DBG(cdev,
1752 "%s: interface %d (%s) requested delayed status\n",
1753 __func__, intf, f->name);
1754 cdev->delayed_status++;
1755 DBG(cdev, "delayed_status count %d\n",
1756 cdev->delayed_status);
1757 }
Chunfeng Yun980900d2018-05-25 17:24:57 +08001758 spin_unlock(&cdev->lock);
David Brownell40982be2008-06-19 17:52:58 -07001759 break;
1760 case USB_REQ_GET_INTERFACE:
1761 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
1762 goto unknown;
Jassi Brarff085de2011-02-06 17:39:17 +09001763 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
David Brownell40982be2008-06-19 17:52:58 -07001764 break;
Bryan Wu08889512009-01-08 00:21:19 +08001765 f = cdev->config->interface[intf];
David Brownell40982be2008-06-19 17:52:58 -07001766 if (!f)
1767 break;
1768 /* lots of interfaces only need altsetting zero... */
1769 value = f->get_alt ? f->get_alt(f, w_index) : 0;
1770 if (value < 0)
1771 break;
1772 *((u8 *)req->buf) = value;
1773 value = min(w_length, (u16) 1);
1774 break;
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001775 case USB_REQ_GET_STATUS:
Li Junc5348b62016-02-19 10:04:44 +08001776 if (gadget_is_otg(gadget) && gadget->hnp_polling_support &&
1777 (w_index == OTG_STS_SELECTOR)) {
1778 if (ctrl->bRequestType != (USB_DIR_IN |
1779 USB_RECIP_DEVICE))
1780 goto unknown;
1781 *((u8 *)req->buf) = gadget->host_request_flag;
1782 value = 1;
1783 break;
1784 }
1785
1786 /*
1787 * USB 3.0 additions:
1788 * Function driver should handle get_status request. If such cb
1789 * wasn't supplied we respond with default value = 0
1790 * Note: function driver should supply such cb only for the
1791 * first interface of the function
1792 */
Tatyana Brokhmanbdb64d72011-06-29 16:41:50 +03001793 if (!gadget_is_superspeed(gadget))
1794 goto unknown;
1795 if (ctrl->bRequestType != (USB_DIR_IN | USB_RECIP_INTERFACE))
1796 goto unknown;
1797 value = 2; /* This is the length of the get_status reply */
1798 put_unaligned_le16(0, req->buf);
1799 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1800 break;
1801 f = cdev->config->interface[intf];
1802 if (!f)
1803 break;
1804 status = f->get_status ? f->get_status(f) : 0;
1805 if (status < 0)
1806 break;
1807 put_unaligned_le16(status & 0x0000ffff, req->buf);
1808 break;
1809 /*
1810 * Function drivers should handle SetFeature/ClearFeature
1811 * (FUNCTION_SUSPEND) request. function_suspend cb should be supplied
1812 * only for the first interface of the function
1813 */
1814 case USB_REQ_CLEAR_FEATURE:
1815 case USB_REQ_SET_FEATURE:
1816 if (!gadget_is_superspeed(gadget))
1817 goto unknown;
1818 if (ctrl->bRequestType != (USB_DIR_OUT | USB_RECIP_INTERFACE))
1819 goto unknown;
1820 switch (w_value) {
1821 case USB_INTRF_FUNC_SUSPEND:
1822 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1823 break;
1824 f = cdev->config->interface[intf];
1825 if (!f)
1826 break;
1827 value = 0;
1828 if (f->func_suspend)
1829 value = f->func_suspend(f, w_index >> 8);
1830 if (value < 0) {
1831 ERROR(cdev,
1832 "func_suspend() returned error %d\n",
1833 value);
1834 value = 0;
1835 }
1836 break;
1837 }
1838 break;
David Brownell40982be2008-06-19 17:52:58 -07001839 default:
1840unknown:
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001841 /*
1842 * OS descriptors handling
1843 */
1844 if (cdev->use_os_string && cdev->os_desc_config &&
Mario Schuknechtdf6738d2015-01-26 20:30:27 +01001845 (ctrl->bRequestType & USB_TYPE_VENDOR) &&
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001846 ctrl->bRequest == cdev->b_vendor_code) {
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001847 struct usb_configuration *os_desc_cfg;
1848 u8 *buf;
1849 int interface;
1850 int count = 0;
1851
1852 req = cdev->os_desc_req;
Felipe Balbi57943712014-09-18 09:54:54 -05001853 req->context = cdev;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001854 req->complete = composite_setup_complete;
1855 buf = req->buf;
1856 os_desc_cfg = cdev->os_desc_config;
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001857 w_length = min_t(u16, w_length, USB_COMP_EP0_OS_DESC_BUFSIZ);
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001858 memset(buf, 0, w_length);
1859 buf[5] = 0x01;
1860 switch (ctrl->bRequestType & USB_RECIP_MASK) {
1861 case USB_RECIP_DEVICE:
1862 if (w_index != 0x4 || (w_value >> 8))
1863 break;
1864 buf[6] = w_index;
Chris Dickens636ba132017-12-31 18:59:43 -08001865 /* Number of ext compat interfaces */
1866 count = count_ext_compat(os_desc_cfg);
1867 buf[8] = count;
1868 count *= 24; /* 24 B/ext compat desc */
1869 count += 16; /* header */
1870 put_unaligned_le32(count, buf);
1871 value = w_length;
1872 if (w_length > 0x10) {
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08001873 value = fill_ext_compat(os_desc_cfg, buf);
1874 value = min_t(u16, w_length, value);
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001875 }
1876 break;
1877 case USB_RECIP_INTERFACE:
1878 if (w_index != 0x5 || (w_value >> 8))
1879 break;
1880 interface = w_value & 0xFF;
1881 buf[6] = w_index;
Chris Dickens636ba132017-12-31 18:59:43 -08001882 count = count_ext_prop(os_desc_cfg,
1883 interface);
1884 put_unaligned_le16(count, buf + 8);
1885 count = len_ext_prop(os_desc_cfg,
1886 interface);
1887 put_unaligned_le32(count, buf);
1888 value = w_length;
1889 if (w_length > 0x0A) {
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001890 value = fill_ext_prop(os_desc_cfg,
1891 interface, buf);
Chris Dickens636ba132017-12-31 18:59:43 -08001892 if (value >= 0)
1893 value = min_t(u16, w_length, value);
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001894 }
1895 break;
1896 }
William Wu7e14f47a2016-05-13 18:30:42 +08001897
Chris Dickens636ba132017-12-31 18:59:43 -08001898 goto check_value;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02001899 }
1900
David Brownell40982be2008-06-19 17:52:58 -07001901 VDBG(cdev,
1902 "non-core control req%02x.%02x v%04x i%04x l%d\n",
1903 ctrl->bRequestType, ctrl->bRequest,
1904 w_value, w_index, w_length);
1905
Laurent Pinchart52426582009-10-21 00:03:38 +02001906 /* functions always handle their interfaces and endpoints...
1907 * punt other recipients (other, WUSB, ...) to the current
David Brownell40982be2008-06-19 17:52:58 -07001908 * configuration code.
David Brownell40982be2008-06-19 17:52:58 -07001909 */
Kishon Vijay Abraham Ib4c21f02015-06-11 22:12:11 +05301910 if (cdev->config) {
1911 list_for_each_entry(f, &cdev->config->functions, list)
Felix Hädicke1a00b4572016-06-22 01:12:08 +02001912 if (f->req_match &&
1913 f->req_match(f, ctrl, false))
Kishon Vijay Abraham Ib4c21f02015-06-11 22:12:11 +05301914 goto try_fun_setup;
Felix Hädicke1a00b4572016-06-22 01:12:08 +02001915 } else {
1916 struct usb_configuration *c;
1917 list_for_each_entry(c, &cdev->configs, list)
1918 list_for_each_entry(f, &c->functions, list)
1919 if (f->req_match &&
1920 f->req_match(f, ctrl, true))
1921 goto try_fun_setup;
Kishon Vijay Abraham Ib4c21f02015-06-11 22:12:11 +05301922 }
Felix Hädicke1a00b4572016-06-22 01:12:08 +02001923 f = NULL;
Kishon Vijay Abraham Ib4c21f02015-06-11 22:12:11 +05301924
Laurent Pinchart52426582009-10-21 00:03:38 +02001925 switch (ctrl->bRequestType & USB_RECIP_MASK) {
1926 case USB_RECIP_INTERFACE:
Jassi Brarff085de2011-02-06 17:39:17 +09001927 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
Maulik Mankad3c47eb02011-01-13 18:19:56 +05301928 break;
1929 f = cdev->config->interface[intf];
Laurent Pinchart52426582009-10-21 00:03:38 +02001930 break;
1931
1932 case USB_RECIP_ENDPOINT:
Peter Chenc526c622016-07-01 15:33:28 +08001933 if (!cdev->config)
1934 break;
Laurent Pinchart52426582009-10-21 00:03:38 +02001935 endp = ((w_index & 0x80) >> 3) | (w_index & 0x0f);
1936 list_for_each_entry(f, &cdev->config->functions, list) {
1937 if (test_bit(endp, f->endpoints))
1938 break;
1939 }
1940 if (&f->list == &cdev->config->functions)
David Brownell40982be2008-06-19 17:52:58 -07001941 f = NULL;
Laurent Pinchart52426582009-10-21 00:03:38 +02001942 break;
David Brownell40982be2008-06-19 17:52:58 -07001943 }
Andrzej Pietrasiewiczf563d232015-03-03 10:52:23 +01001944try_fun_setup:
Laurent Pinchart52426582009-10-21 00:03:38 +02001945 if (f && f->setup)
1946 value = f->setup(f, ctrl);
1947 else {
David Brownell40982be2008-06-19 17:52:58 -07001948 struct usb_configuration *c;
1949
1950 c = cdev->config;
Andrzej Pietrasiewicza01091e2013-11-07 08:41:25 +01001951 if (!c)
1952 goto done;
1953
1954 /* try current config's setup */
1955 if (c->setup) {
David Brownell40982be2008-06-19 17:52:58 -07001956 value = c->setup(c, ctrl);
Andrzej Pietrasiewicza01091e2013-11-07 08:41:25 +01001957 goto done;
1958 }
1959
1960 /* try the only function in the current config */
1961 if (!list_is_singular(&c->functions))
1962 goto done;
1963 f = list_first_entry(&c->functions, struct usb_function,
1964 list);
1965 if (f->setup)
1966 value = f->setup(f, ctrl);
David Brownell40982be2008-06-19 17:52:58 -07001967 }
1968
1969 goto done;
1970 }
1971
Chris Dickens636ba132017-12-31 18:59:43 -08001972check_value:
David Brownell40982be2008-06-19 17:52:58 -07001973 /* respond with data transfer before status phase? */
Roger Quadros1b9ba002011-05-09 13:08:06 +03001974 if (value >= 0 && value != USB_GADGET_DELAYED_STATUS) {
David Brownell40982be2008-06-19 17:52:58 -07001975 req->length = value;
Felipe Balbi57943712014-09-18 09:54:54 -05001976 req->context = cdev;
David Brownell40982be2008-06-19 17:52:58 -07001977 req->zero = value < w_length;
Felipe Balbia7c12ea2014-09-18 10:01:55 -05001978 value = composite_ep0_queue(cdev, req, GFP_ATOMIC);
David Brownell40982be2008-06-19 17:52:58 -07001979 if (value < 0) {
1980 DBG(cdev, "ep_queue --> %d\n", value);
1981 req->status = 0;
1982 composite_setup_complete(gadget->ep0, req);
1983 }
Roger Quadros1b9ba002011-05-09 13:08:06 +03001984 } else if (value == USB_GADGET_DELAYED_STATUS && w_length != 0) {
1985 WARN(cdev,
1986 "%s: Delayed status not supported for w_length != 0",
1987 __func__);
David Brownell40982be2008-06-19 17:52:58 -07001988 }
1989
1990done:
1991 /* device either stalls (value < 0) or reports success */
1992 return value;
1993}
1994
Sebastian Andrzej Siewior2d5a8892012-12-23 21:10:21 +01001995void composite_disconnect(struct usb_gadget *gadget)
David Brownell40982be2008-06-19 17:52:58 -07001996{
1997 struct usb_composite_dev *cdev = get_gadget_data(gadget);
1998 unsigned long flags;
1999
2000 /* REVISIT: should we have config and device level
2001 * disconnect callbacks?
2002 */
2003 spin_lock_irqsave(&cdev->lock, flags);
Benjamin Herrenschmidt602fda12019-07-26 14:59:03 +10002004 cdev->suspended = 0;
David Brownell40982be2008-06-19 17:52:58 -07002005 if (cdev->config)
2006 reset_config(cdev);
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002007 if (cdev->driver->disconnect)
2008 cdev->driver->disconnect(cdev);
David Brownell40982be2008-06-19 17:52:58 -07002009 spin_unlock_irqrestore(&cdev->lock, flags);
2010}
2011
2012/*-------------------------------------------------------------------------*/
2013
Greg Kroah-Hartmance26bd22013-08-23 16:34:43 -07002014static ssize_t suspended_show(struct device *dev, struct device_attribute *attr,
2015 char *buf)
Fabien Chouteauf48cf802010-04-23 14:21:26 +02002016{
2017 struct usb_gadget *gadget = dev_to_usb_gadget(dev);
2018 struct usb_composite_dev *cdev = get_gadget_data(gadget);
2019
2020 return sprintf(buf, "%d\n", cdev->suspended);
2021}
Greg Kroah-Hartmance26bd22013-08-23 16:34:43 -07002022static DEVICE_ATTR_RO(suspended);
Fabien Chouteauf48cf802010-04-23 14:21:26 +02002023
Sebastian Andrzej Siewior779d5162012-12-23 21:09:55 +01002024static void __composite_unbind(struct usb_gadget *gadget, bool unbind_driver)
David Brownell40982be2008-06-19 17:52:58 -07002025{
2026 struct usb_composite_dev *cdev = get_gadget_data(gadget);
Andrew Gabbasovaec17e12017-09-30 08:55:55 -07002027 struct usb_gadget_strings *gstr = cdev->driver->strings[0];
2028 struct usb_string *dev_str = gstr->strings;
David Brownell40982be2008-06-19 17:52:58 -07002029
2030 /* composite_disconnect() must already have been called
2031 * by the underlying peripheral controller driver!
2032 * so there's no i/o concurrency that could affect the
2033 * state protected by cdev->lock.
2034 */
2035 WARN_ON(cdev->config);
2036
2037 while (!list_empty(&cdev->configs)) {
2038 struct usb_configuration *c;
David Brownell40982be2008-06-19 17:52:58 -07002039 c = list_first_entry(&cdev->configs,
2040 struct usb_configuration, list);
Benoit Goby51cce6f2012-05-10 10:07:57 +02002041 remove_config(cdev, c);
David Brownell40982be2008-06-19 17:52:58 -07002042 }
Sebastian Andrzej Siewior779d5162012-12-23 21:09:55 +01002043 if (cdev->driver->unbind && unbind_driver)
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002044 cdev->driver->unbind(cdev);
David Brownell40982be2008-06-19 17:52:58 -07002045
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002046 composite_dev_cleanup(cdev);
2047
Andrew Gabbasovaec17e12017-09-30 08:55:55 -07002048 if (dev_str[USB_GADGET_MANUFACTURER_IDX].s == cdev->def_manufacturer)
2049 dev_str[USB_GADGET_MANUFACTURER_IDX].s = "";
2050
Sebastian Andrzej Siewiorcc2683c2012-09-10 15:01:58 +02002051 kfree(cdev->def_manufacturer);
David Brownell40982be2008-06-19 17:52:58 -07002052 kfree(cdev);
2053 set_gadget_data(gadget, NULL);
David Brownell40982be2008-06-19 17:52:58 -07002054}
2055
Sebastian Andrzej Siewior779d5162012-12-23 21:09:55 +01002056static void composite_unbind(struct usb_gadget *gadget)
2057{
2058 __composite_unbind(gadget, true);
2059}
2060
Sebastian Andrzej Siewior7d16e8d2012-09-10 15:01:53 +02002061static void update_unchanged_dev_desc(struct usb_device_descriptor *new,
2062 const struct usb_device_descriptor *old)
2063{
2064 __le16 idVendor;
2065 __le16 idProduct;
2066 __le16 bcdDevice;
Sebastian Andrzej Siewior1cf0d262012-09-10 15:01:54 +02002067 u8 iSerialNumber;
Sebastian Andrzej Siewior03de9bf2012-09-10 15:01:55 +02002068 u8 iManufacturer;
Sebastian Andrzej Siewior2d35ee42012-09-10 15:01:56 +02002069 u8 iProduct;
Sebastian Andrzej Siewior7d16e8d2012-09-10 15:01:53 +02002070
2071 /*
2072 * these variables may have been set in
2073 * usb_composite_overwrite_options()
2074 */
2075 idVendor = new->idVendor;
2076 idProduct = new->idProduct;
2077 bcdDevice = new->bcdDevice;
Sebastian Andrzej Siewior1cf0d262012-09-10 15:01:54 +02002078 iSerialNumber = new->iSerialNumber;
Sebastian Andrzej Siewior03de9bf2012-09-10 15:01:55 +02002079 iManufacturer = new->iManufacturer;
Sebastian Andrzej Siewior2d35ee42012-09-10 15:01:56 +02002080 iProduct = new->iProduct;
Sebastian Andrzej Siewior7d16e8d2012-09-10 15:01:53 +02002081
2082 *new = *old;
2083 if (idVendor)
2084 new->idVendor = idVendor;
2085 if (idProduct)
2086 new->idProduct = idProduct;
2087 if (bcdDevice)
2088 new->bcdDevice = bcdDevice;
Sebastian Andrzej Siewiored9cbda2012-09-10 09:16:07 +02002089 else
2090 new->bcdDevice = cpu_to_le16(get_default_bcdDevice());
Sebastian Andrzej Siewior1cf0d262012-09-10 15:01:54 +02002091 if (iSerialNumber)
2092 new->iSerialNumber = iSerialNumber;
Sebastian Andrzej Siewior03de9bf2012-09-10 15:01:55 +02002093 if (iManufacturer)
2094 new->iManufacturer = iManufacturer;
Sebastian Andrzej Siewior2d35ee42012-09-10 15:01:56 +02002095 if (iProduct)
2096 new->iProduct = iProduct;
Sebastian Andrzej Siewior7d16e8d2012-09-10 15:01:53 +02002097}
2098
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002099int composite_dev_prepare(struct usb_composite_driver *composite,
2100 struct usb_composite_dev *cdev)
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002101{
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002102 struct usb_gadget *gadget = cdev->gadget;
2103 int ret = -ENOMEM;
2104
2105 /* preallocate control response and buffer */
2106 cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
2107 if (!cdev->req)
2108 return -ENOMEM;
2109
2110 cdev->req->buf = kmalloc(USB_COMP_EP0_BUFSIZ, GFP_KERNEL);
2111 if (!cdev->req->buf)
2112 goto fail;
2113
2114 ret = device_create_file(&gadget->dev, &dev_attr_suspended);
2115 if (ret)
2116 goto fail_dev;
2117
2118 cdev->req->complete = composite_setup_complete;
Felipe Balbi57943712014-09-18 09:54:54 -05002119 cdev->req->context = cdev;
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002120 gadget->ep0->driver_data = cdev;
2121
2122 cdev->driver = composite;
2123
2124 /*
2125 * As per USB compliance update, a device that is actively drawing
2126 * more than 100mA from USB must report itself as bus-powered in
2127 * the GetStatus(DEVICE) call.
2128 */
2129 if (CONFIG_USB_GADGET_VBUS_DRAW <= USB_SELF_POWER_VBUS_MAX_DRAW)
2130 usb_gadget_set_selfpowered(gadget);
2131
2132 /* interface and string IDs start at zero via kzalloc.
2133 * we force endpoints to start unassigned; few controller
2134 * drivers will zero ep->driver_data.
2135 */
2136 usb_ep_autoconfig_reset(gadget);
2137 return 0;
2138fail_dev:
2139 kfree(cdev->req->buf);
2140fail:
2141 usb_ep_free_request(gadget->ep0, cdev->req);
2142 cdev->req = NULL;
2143 return ret;
2144}
2145
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002146int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
2147 struct usb_ep *ep0)
2148{
2149 int ret = 0;
2150
2151 cdev->os_desc_req = usb_ep_alloc_request(ep0, GFP_KERNEL);
2152 if (!cdev->os_desc_req) {
Christophe JAILLET3887db52016-07-16 08:34:33 +02002153 ret = -ENOMEM;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002154 goto end;
2155 }
2156
Chris Dickens5d6ae4f2017-12-31 18:59:42 -08002157 cdev->os_desc_req->buf = kmalloc(USB_COMP_EP0_OS_DESC_BUFSIZ,
2158 GFP_KERNEL);
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002159 if (!cdev->os_desc_req->buf) {
Christophe JAILLET3887db52016-07-16 08:34:33 +02002160 ret = -ENOMEM;
Christophe JAILLET990758c2017-01-04 06:30:16 +01002161 usb_ep_free_request(ep0, cdev->os_desc_req);
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002162 goto end;
2163 }
Felipe Balbi57943712014-09-18 09:54:54 -05002164 cdev->os_desc_req->context = cdev;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002165 cdev->os_desc_req->complete = composite_setup_complete;
2166end:
2167 return ret;
2168}
2169
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002170void composite_dev_cleanup(struct usb_composite_dev *cdev)
2171{
Sebastian Andrzej Siewior27a466332012-12-23 21:10:23 +01002172 struct usb_gadget_string_container *uc, *tmp;
Benjamin Herrenschmidtaaeab022018-03-23 13:44:06 +11002173 struct usb_ep *ep, *tmp_ep;
Sebastian Andrzej Siewior27a466332012-12-23 21:10:23 +01002174
2175 list_for_each_entry_safe(uc, tmp, &cdev->gstrings, list) {
2176 list_del(&uc->list);
2177 kfree(uc);
2178 }
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002179 if (cdev->os_desc_req) {
Felipe Balbia7c12ea2014-09-18 10:01:55 -05002180 if (cdev->os_desc_pending)
2181 usb_ep_dequeue(cdev->gadget->ep0, cdev->os_desc_req);
2182
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002183 kfree(cdev->os_desc_req->buf);
Chandana Kishori Chiluveru1c20c892019-10-01 13:16:48 +05302184 cdev->os_desc_req->buf = NULL;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002185 usb_ep_free_request(cdev->gadget->ep0, cdev->os_desc_req);
Chandana Kishori Chiluveru1c20c892019-10-01 13:16:48 +05302186 cdev->os_desc_req = NULL;
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002187 }
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002188 if (cdev->req) {
Felipe Balbia7c12ea2014-09-18 10:01:55 -05002189 if (cdev->setup_pending)
2190 usb_ep_dequeue(cdev->gadget->ep0, cdev->req);
2191
Li Junbe0a8882014-08-28 21:44:11 +08002192 kfree(cdev->req->buf);
Chandana Kishori Chiluveru1c20c892019-10-01 13:16:48 +05302193 cdev->req->buf = NULL;
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002194 usb_ep_free_request(cdev->gadget->ep0, cdev->req);
Chandana Kishori Chiluveru1c20c892019-10-01 13:16:48 +05302195 cdev->req = NULL;
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002196 }
Sebastian Andrzej Siewior88af8bb2012-12-23 21:10:24 +01002197 cdev->next_string_id = 0;
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002198 device_remove_file(&cdev->gadget->dev, &dev_attr_suspended);
Benjamin Herrenschmidtaaeab022018-03-23 13:44:06 +11002199
2200 /*
2201 * Some UDC backends have a dynamic EP allocation scheme.
2202 *
2203 * In that case, the dispose() callback is used to notify the
2204 * backend that the EPs are no longer in use.
2205 *
2206 * Note: The UDC backend can remove the EP from the ep_list as
2207 * a result, so we need to use the _safe list iterator.
2208 */
2209 list_for_each_entry_safe(ep, tmp_ep,
2210 &cdev->gadget->ep_list, ep_list) {
2211 if (ep->ops->dispose)
2212 ep->ops->dispose(ep);
2213 }
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002214}
2215
2216static int composite_bind(struct usb_gadget *gadget,
2217 struct usb_gadget_driver *gdriver)
David Brownell40982be2008-06-19 17:52:58 -07002218{
2219 struct usb_composite_dev *cdev;
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002220 struct usb_composite_driver *composite = to_cdriver(gdriver);
David Brownell40982be2008-06-19 17:52:58 -07002221 int status = -ENOMEM;
2222
2223 cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
2224 if (!cdev)
2225 return status;
2226
2227 spin_lock_init(&cdev->lock);
2228 cdev->gadget = gadget;
2229 set_gadget_data(gadget, cdev);
2230 INIT_LIST_HEAD(&cdev->configs);
Sebastian Andrzej Siewior9bb28592012-12-23 21:10:22 +01002231 INIT_LIST_HEAD(&cdev->gstrings);
David Brownell40982be2008-06-19 17:52:58 -07002232
Sebastian Andrzej Siewiora5923342012-12-23 21:10:20 +01002233 status = composite_dev_prepare(composite, cdev);
2234 if (status)
David Brownell40982be2008-06-19 17:52:58 -07002235 goto fail;
David Brownell40982be2008-06-19 17:52:58 -07002236
2237 /* composite gadget needs to assign strings for whole device (like
2238 * serial number), register function drivers, potentially update
2239 * power state and consumption, etc
2240 */
Sebastian Andrzej Siewiorfac3a432012-09-06 20:11:01 +02002241 status = composite->bind(cdev);
David Brownell40982be2008-06-19 17:52:58 -07002242 if (status < 0)
2243 goto fail;
2244
Andrzej Pietrasiewicz37a3a532014-05-08 14:06:23 +02002245 if (cdev->use_os_string) {
2246 status = composite_os_desc_req_prepare(cdev, gadget->ep0);
2247 if (status)
2248 goto fail;
2249 }
2250
Sebastian Andrzej Siewior7d16e8d2012-09-10 15:01:53 +02002251 update_unchanged_dev_desc(&cdev->desc, composite->dev);
Greg Kroah-Hartmandbb442b2010-12-16 15:52:30 -08002252
Michal Nazarewiczad1a8102010-08-12 17:43:46 +02002253 /* has userspace failed to provide a serial number? */
2254 if (composite->needs_serial && !cdev->desc.iSerialNumber)
2255 WARNING(cdev, "userspace failed to provide iSerialNumber\n");
2256
David Brownell40982be2008-06-19 17:52:58 -07002257 INFO(cdev, "%s ready\n", composite->name);
2258 return 0;
2259
2260fail:
Sebastian Andrzej Siewior779d5162012-12-23 21:09:55 +01002261 __composite_unbind(gadget, false);
David Brownell40982be2008-06-19 17:52:58 -07002262 return status;
2263}
2264
2265/*-------------------------------------------------------------------------*/
2266
Andrzej Pietrasiewicz3a571872014-10-08 12:03:36 +02002267void composite_suspend(struct usb_gadget *gadget)
David Brownell40982be2008-06-19 17:52:58 -07002268{
2269 struct usb_composite_dev *cdev = get_gadget_data(gadget);
2270 struct usb_function *f;
2271
David Brownell89429392009-03-19 14:14:17 -07002272 /* REVISIT: should we have config level
David Brownell40982be2008-06-19 17:52:58 -07002273 * suspend/resume callbacks?
2274 */
2275 DBG(cdev, "suspend\n");
2276 if (cdev->config) {
2277 list_for_each_entry(f, &cdev->config->functions, list) {
2278 if (f->suspend)
2279 f->suspend(f);
2280 }
2281 }
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002282 if (cdev->driver->suspend)
2283 cdev->driver->suspend(cdev);
Fabien Chouteauf48cf802010-04-23 14:21:26 +02002284
2285 cdev->suspended = 1;
Hao Wub23f2f92010-11-29 15:17:03 +08002286
Thinh Nguyen5e5caf42020-02-03 18:05:32 -08002287 usb_gadget_set_selfpowered(gadget);
Hao Wub23f2f92010-11-29 15:17:03 +08002288 usb_gadget_vbus_draw(gadget, 2);
David Brownell40982be2008-06-19 17:52:58 -07002289}
2290
Andrzej Pietrasiewicz3a571872014-10-08 12:03:36 +02002291void composite_resume(struct usb_gadget *gadget)
David Brownell40982be2008-06-19 17:52:58 -07002292{
2293 struct usb_composite_dev *cdev = get_gadget_data(gadget);
2294 struct usb_function *f;
Jack Phama2035412020-01-30 19:10:36 -08002295 unsigned maxpower;
David Brownell40982be2008-06-19 17:52:58 -07002296
David Brownell89429392009-03-19 14:14:17 -07002297 /* REVISIT: should we have config level
David Brownell40982be2008-06-19 17:52:58 -07002298 * suspend/resume callbacks?
2299 */
2300 DBG(cdev, "resume\n");
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002301 if (cdev->driver->resume)
2302 cdev->driver->resume(cdev);
David Brownell40982be2008-06-19 17:52:58 -07002303 if (cdev->config) {
2304 list_for_each_entry(f, &cdev->config->functions, list) {
2305 if (f->resume)
2306 f->resume(f);
2307 }
Hao Wub23f2f92010-11-29 15:17:03 +08002308
Jack Phama2035412020-01-30 19:10:36 -08002309 maxpower = cdev->config->MaxPower ?
2310 cdev->config->MaxPower : CONFIG_USB_GADGET_VBUS_DRAW;
2311 if (gadget->speed < USB_SPEED_SUPER)
2312 maxpower = min(maxpower, 500U);
2313 else
2314 maxpower = min(maxpower, 900U);
Hao Wub23f2f92010-11-29 15:17:03 +08002315
Thinh Nguyen5e5caf42020-02-03 18:05:32 -08002316 if (maxpower > USB_SELF_POWER_VBUS_MAX_DRAW)
2317 usb_gadget_clear_selfpowered(gadget);
2318
Jack Phama2035412020-01-30 19:10:36 -08002319 usb_gadget_vbus_draw(gadget, maxpower);
David Brownell40982be2008-06-19 17:52:58 -07002320 }
Fabien Chouteauf48cf802010-04-23 14:21:26 +02002321
2322 cdev->suspended = 0;
David Brownell40982be2008-06-19 17:52:58 -07002323}
2324
2325/*-------------------------------------------------------------------------*/
2326
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002327static const struct usb_gadget_driver composite_driver_template = {
Sebastian Andrzej Siewior93952952012-09-06 20:11:05 +02002328 .bind = composite_bind,
Michal Nazarewicz915c8be2009-11-09 14:15:25 +01002329 .unbind = composite_unbind,
David Brownell40982be2008-06-19 17:52:58 -07002330
2331 .setup = composite_setup,
Peter Chend8a816f2014-09-09 08:56:49 +08002332 .reset = composite_disconnect,
David Brownell40982be2008-06-19 17:52:58 -07002333 .disconnect = composite_disconnect,
2334
2335 .suspend = composite_suspend,
2336 .resume = composite_resume,
2337
2338 .driver = {
2339 .owner = THIS_MODULE,
2340 },
2341};
2342
2343/**
Michal Nazarewicz07a18bd2010-08-12 17:43:54 +02002344 * usb_composite_probe() - register a composite driver
David Brownell40982be2008-06-19 17:52:58 -07002345 * @driver: the driver to register
Nishanth Menon43febb22013-03-04 16:52:38 -06002346 *
David Brownell40982be2008-06-19 17:52:58 -07002347 * Context: single threaded during gadget setup
2348 *
2349 * This function is used to register drivers using the composite driver
2350 * framework. The return value is zero, or a negative errno value.
2351 * Those values normally come from the driver's @bind method, which does
2352 * all the work of setting up the driver to match the hardware.
2353 *
2354 * On successful return, the gadget is ready to respond to requests from
2355 * the host, unless one of its components invokes usb_gadget_disconnect()
2356 * while it was binding. That would usually be done in order to wait for
2357 * some userspace participation.
2358 */
Sebastian Andrzej Siewior03e42bd2012-09-06 20:11:04 +02002359int usb_composite_probe(struct usb_composite_driver *driver)
David Brownell40982be2008-06-19 17:52:58 -07002360{
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002361 struct usb_gadget_driver *gadget_driver;
2362
2363 if (!driver || !driver->dev || !driver->bind)
David Brownell40982be2008-06-19 17:52:58 -07002364 return -EINVAL;
2365
2366 if (!driver->name)
2367 driver->name = "composite";
David Brownell40982be2008-06-19 17:52:58 -07002368
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002369 driver->gadget_driver = composite_driver_template;
2370 gadget_driver = &driver->gadget_driver;
2371
2372 gadget_driver->function = (char *) driver->name;
2373 gadget_driver->driver.name = driver->name;
2374 gadget_driver->max_speed = driver->max_speed;
2375
2376 return usb_gadget_probe_driver(gadget_driver);
David Brownell40982be2008-06-19 17:52:58 -07002377}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +02002378EXPORT_SYMBOL_GPL(usb_composite_probe);
David Brownell40982be2008-06-19 17:52:58 -07002379
2380/**
2381 * usb_composite_unregister() - unregister a composite driver
2382 * @driver: the driver to unregister
2383 *
2384 * This function is used to unregister drivers using the composite
2385 * driver framework.
2386 */
Michal Nazarewicz28824b12010-05-05 12:53:13 +02002387void usb_composite_unregister(struct usb_composite_driver *driver)
David Brownell40982be2008-06-19 17:52:58 -07002388{
Sebastian Andrzej Siewiorffe0b332012-09-07 09:53:17 +02002389 usb_gadget_unregister_driver(&driver->gadget_driver);
David Brownell40982be2008-06-19 17:52:58 -07002390}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +02002391EXPORT_SYMBOL_GPL(usb_composite_unregister);
Roger Quadros1b9ba002011-05-09 13:08:06 +03002392
2393/**
2394 * usb_composite_setup_continue() - Continue with the control transfer
2395 * @cdev: the composite device who's control transfer was kept waiting
2396 *
2397 * This function must be called by the USB function driver to continue
2398 * with the control transfer's data/status stage in case it had requested to
2399 * delay the data/status stages. A USB function's setup handler (e.g. set_alt())
2400 * can request the composite framework to delay the setup request's data/status
2401 * stages by returning USB_GADGET_DELAYED_STATUS.
2402 */
2403void usb_composite_setup_continue(struct usb_composite_dev *cdev)
2404{
2405 int value;
2406 struct usb_request *req = cdev->req;
2407 unsigned long flags;
2408
2409 DBG(cdev, "%s\n", __func__);
2410 spin_lock_irqsave(&cdev->lock, flags);
2411
2412 if (cdev->delayed_status == 0) {
2413 WARN(cdev, "%s: Unexpected call\n", __func__);
2414
2415 } else if (--cdev->delayed_status == 0) {
2416 DBG(cdev, "%s: Completing delayed status\n", __func__);
2417 req->length = 0;
Felipe Balbi57943712014-09-18 09:54:54 -05002418 req->context = cdev;
Felipe Balbia7c12ea2014-09-18 10:01:55 -05002419 value = composite_ep0_queue(cdev, req, GFP_ATOMIC);
Roger Quadros1b9ba002011-05-09 13:08:06 +03002420 if (value < 0) {
2421 DBG(cdev, "ep_queue --> %d\n", value);
2422 req->status = 0;
2423 composite_setup_complete(cdev->gadget->ep0, req);
2424 }
2425 }
2426
2427 spin_unlock_irqrestore(&cdev->lock, flags);
2428}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +02002429EXPORT_SYMBOL_GPL(usb_composite_setup_continue);
Roger Quadros1b9ba002011-05-09 13:08:06 +03002430
Sebastian Andrzej Siewiorcc2683c2012-09-10 15:01:58 +02002431static char *composite_default_mfr(struct usb_gadget *gadget)
2432{
Juergen Gross5002c932016-10-10 12:48:36 +02002433 return kasprintf(GFP_KERNEL, "%s %s with %s", init_utsname()->sysname,
2434 init_utsname()->release, gadget->name);
Sebastian Andrzej Siewiorcc2683c2012-09-10 15:01:58 +02002435}
2436
Sebastian Andrzej Siewior7d16e8d2012-09-10 15:01:53 +02002437void usb_composite_overwrite_options(struct usb_composite_dev *cdev,
2438 struct usb_composite_overwrite *covr)
2439{
2440 struct usb_device_descriptor *desc = &cdev->desc;
Sebastian Andrzej Siewior1cf0d262012-09-10 15:01:54 +02002441 struct usb_gadget_strings *gstr = cdev->driver->strings[0];
2442 struct usb_string *dev_str = gstr->strings;
Sebastian Andrzej Siewior7d16e8d2012-09-10 15:01:53 +02002443
2444 if (covr->idVendor)
2445 desc->idVendor = cpu_to_le16(covr->idVendor);
2446
2447 if (covr->idProduct)
2448 desc->idProduct = cpu_to_le16(covr->idProduct);
2449
2450 if (covr->bcdDevice)
2451 desc->bcdDevice = cpu_to_le16(covr->bcdDevice);
Sebastian Andrzej Siewior1cf0d262012-09-10 15:01:54 +02002452
2453 if (covr->serial_number) {
2454 desc->iSerialNumber = dev_str[USB_GADGET_SERIAL_IDX].id;
2455 dev_str[USB_GADGET_SERIAL_IDX].s = covr->serial_number;
2456 }
Sebastian Andrzej Siewior03de9bf2012-09-10 15:01:55 +02002457 if (covr->manufacturer) {
2458 desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
2459 dev_str[USB_GADGET_MANUFACTURER_IDX].s = covr->manufacturer;
Sebastian Andrzej Siewiorcc2683c2012-09-10 15:01:58 +02002460
2461 } else if (!strlen(dev_str[USB_GADGET_MANUFACTURER_IDX].s)) {
2462 desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
2463 cdev->def_manufacturer = composite_default_mfr(cdev->gadget);
2464 dev_str[USB_GADGET_MANUFACTURER_IDX].s = cdev->def_manufacturer;
Sebastian Andrzej Siewior03de9bf2012-09-10 15:01:55 +02002465 }
Sebastian Andrzej Siewior2d35ee42012-09-10 15:01:56 +02002466
2467 if (covr->product) {
2468 desc->iProduct = dev_str[USB_GADGET_PRODUCT_IDX].id;
2469 dev_str[USB_GADGET_PRODUCT_IDX].s = covr->product;
2470 }
Sebastian Andrzej Siewior7d16e8d2012-09-10 15:01:53 +02002471}
Sebastian Andrzej Siewior721e2e92012-09-06 20:11:27 +02002472EXPORT_SYMBOL_GPL(usb_composite_overwrite_options);
Sebastian Andrzej Siewiord80c3042012-09-06 20:11:28 +02002473
2474MODULE_LICENSE("GPL");
2475MODULE_AUTHOR("David Brownell");