xref: /openbmc/linux/drivers/usb/gadget/composite.c (revision 6774def6)
1 /*
2  * composite.c - infrastructure for Composite USB Gadgets
3  *
4  * Copyright (C) 2006-2008 David Brownell
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  */
11 
12 /* #define VERBOSE_DEBUG */
13 
14 #include <linux/kallsyms.h>
15 #include <linux/kernel.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/device.h>
19 #include <linux/utsname.h>
20 
21 #include <linux/usb/composite.h>
22 #include <asm/unaligned.h>
23 
24 #include "u_os_desc.h"
25 
26 /**
27  * struct usb_os_string - represents OS String to be reported by a gadget
28  * @bLength: total length of the entire descritor, always 0x12
29  * @bDescriptorType: USB_DT_STRING
30  * @qwSignature: the OS String proper
31  * @bMS_VendorCode: code used by the host for subsequent requests
32  * @bPad: not used, must be zero
33  */
34 struct usb_os_string {
35 	__u8	bLength;
36 	__u8	bDescriptorType;
37 	__u8	qwSignature[OS_STRING_QW_SIGN_LEN];
38 	__u8	bMS_VendorCode;
39 	__u8	bPad;
40 } __packed;
41 
42 /*
43  * The code in this file is utility code, used to build a gadget driver
44  * from one or more "function" drivers, one or more "configuration"
45  * objects, and a "usb_composite_driver" by gluing them together along
46  * with the relevant device-wide data.
47  */
48 
49 static struct usb_gadget_strings **get_containers_gs(
50 		struct usb_gadget_string_container *uc)
51 {
52 	return (struct usb_gadget_strings **)uc->stash;
53 }
54 
55 /**
56  * next_ep_desc() - advance to the next EP descriptor
57  * @t: currect pointer within descriptor array
58  *
59  * Return: next EP descriptor or NULL
60  *
61  * Iterate over @t until either EP descriptor found or
62  * NULL (that indicates end of list) encountered
63  */
64 static struct usb_descriptor_header**
65 next_ep_desc(struct usb_descriptor_header **t)
66 {
67 	for (; *t; t++) {
68 		if ((*t)->bDescriptorType == USB_DT_ENDPOINT)
69 			return t;
70 	}
71 	return NULL;
72 }
73 
74 /*
75  * for_each_ep_desc()- iterate over endpoint descriptors in the
76  *		descriptors list
77  * @start:	pointer within descriptor array.
78  * @ep_desc:	endpoint descriptor to use as the loop cursor
79  */
80 #define for_each_ep_desc(start, ep_desc) \
81 	for (ep_desc = next_ep_desc(start); \
82 	      ep_desc; ep_desc = next_ep_desc(ep_desc+1))
83 
84 /**
85  * config_ep_by_speed() - configures the given endpoint
86  * according to gadget speed.
87  * @g: pointer to the gadget
88  * @f: usb function
89  * @_ep: the endpoint to configure
90  *
91  * Return: error code, 0 on success
92  *
93  * This function chooses the right descriptors for a given
94  * endpoint according to gadget speed and saves it in the
95  * endpoint desc field. If the endpoint already has a descriptor
96  * assigned to it - overwrites it with currently corresponding
97  * descriptor. The endpoint maxpacket field is updated according
98  * to the chosen descriptor.
99  * Note: the supplied function should hold all the descriptors
100  * for supported speeds
101  */
102 int config_ep_by_speed(struct usb_gadget *g,
103 			struct usb_function *f,
104 			struct usb_ep *_ep)
105 {
106 	struct usb_composite_dev	*cdev = get_gadget_data(g);
107 	struct usb_endpoint_descriptor *chosen_desc = NULL;
108 	struct usb_descriptor_header **speed_desc = NULL;
109 
110 	struct usb_ss_ep_comp_descriptor *comp_desc = NULL;
111 	int want_comp_desc = 0;
112 
113 	struct usb_descriptor_header **d_spd; /* cursor for speed desc */
114 
115 	if (!g || !f || !_ep)
116 		return -EIO;
117 
118 	/* select desired speed */
119 	switch (g->speed) {
120 	case USB_SPEED_SUPER:
121 		if (gadget_is_superspeed(g)) {
122 			speed_desc = f->ss_descriptors;
123 			want_comp_desc = 1;
124 			break;
125 		}
126 		/* else: Fall trough */
127 	case USB_SPEED_HIGH:
128 		if (gadget_is_dualspeed(g)) {
129 			speed_desc = f->hs_descriptors;
130 			break;
131 		}
132 		/* else: fall through */
133 	default:
134 		speed_desc = f->fs_descriptors;
135 	}
136 	/* find descriptors */
137 	for_each_ep_desc(speed_desc, d_spd) {
138 		chosen_desc = (struct usb_endpoint_descriptor *)*d_spd;
139 		if (chosen_desc->bEndpointAddress == _ep->address)
140 			goto ep_found;
141 	}
142 	return -EIO;
143 
144 ep_found:
145 	/* commit results */
146 	_ep->maxpacket = usb_endpoint_maxp(chosen_desc);
147 	_ep->desc = chosen_desc;
148 	_ep->comp_desc = NULL;
149 	_ep->maxburst = 0;
150 	_ep->mult = 0;
151 	if (!want_comp_desc)
152 		return 0;
153 
154 	/*
155 	 * Companion descriptor should follow EP descriptor
156 	 * USB 3.0 spec, #9.6.7
157 	 */
158 	comp_desc = (struct usb_ss_ep_comp_descriptor *)*(++d_spd);
159 	if (!comp_desc ||
160 	    (comp_desc->bDescriptorType != USB_DT_SS_ENDPOINT_COMP))
161 		return -EIO;
162 	_ep->comp_desc = comp_desc;
163 	if (g->speed == USB_SPEED_SUPER) {
164 		switch (usb_endpoint_type(_ep->desc)) {
165 		case USB_ENDPOINT_XFER_ISOC:
166 			/* mult: bits 1:0 of bmAttributes */
167 			_ep->mult = comp_desc->bmAttributes & 0x3;
168 		case USB_ENDPOINT_XFER_BULK:
169 		case USB_ENDPOINT_XFER_INT:
170 			_ep->maxburst = comp_desc->bMaxBurst + 1;
171 			break;
172 		default:
173 			if (comp_desc->bMaxBurst != 0)
174 				ERROR(cdev, "ep0 bMaxBurst must be 0\n");
175 			_ep->maxburst = 1;
176 			break;
177 		}
178 	}
179 	return 0;
180 }
181 EXPORT_SYMBOL_GPL(config_ep_by_speed);
182 
183 /**
184  * usb_add_function() - add a function to a configuration
185  * @config: the configuration
186  * @function: the function being added
187  * Context: single threaded during gadget setup
188  *
189  * After initialization, each configuration must have one or more
190  * functions added to it.  Adding a function involves calling its @bind()
191  * method to allocate resources such as interface and string identifiers
192  * and endpoints.
193  *
194  * This function returns the value of the function's bind(), which is
195  * zero for success else a negative errno value.
196  */
197 int usb_add_function(struct usb_configuration *config,
198 		struct usb_function *function)
199 {
200 	int	value = -EINVAL;
201 
202 	DBG(config->cdev, "adding '%s'/%p to config '%s'/%p\n",
203 			function->name, function,
204 			config->label, config);
205 
206 	if (!function->set_alt || !function->disable)
207 		goto done;
208 
209 	function->config = config;
210 	list_add_tail(&function->list, &config->functions);
211 
212 	/* REVISIT *require* function->bind? */
213 	if (function->bind) {
214 		value = function->bind(config, function);
215 		if (value < 0) {
216 			list_del(&function->list);
217 			function->config = NULL;
218 		}
219 	} else
220 		value = 0;
221 
222 	/* We allow configurations that don't work at both speeds.
223 	 * If we run into a lowspeed Linux system, treat it the same
224 	 * as full speed ... it's the function drivers that will need
225 	 * to avoid bulk and ISO transfers.
226 	 */
227 	if (!config->fullspeed && function->fs_descriptors)
228 		config->fullspeed = true;
229 	if (!config->highspeed && function->hs_descriptors)
230 		config->highspeed = true;
231 	if (!config->superspeed && function->ss_descriptors)
232 		config->superspeed = true;
233 
234 done:
235 	if (value)
236 		DBG(config->cdev, "adding '%s'/%p --> %d\n",
237 				function->name, function, value);
238 	return value;
239 }
240 EXPORT_SYMBOL_GPL(usb_add_function);
241 
242 void usb_remove_function(struct usb_configuration *c, struct usb_function *f)
243 {
244 	if (f->disable)
245 		f->disable(f);
246 
247 	bitmap_zero(f->endpoints, 32);
248 	list_del(&f->list);
249 	if (f->unbind)
250 		f->unbind(c, f);
251 }
252 EXPORT_SYMBOL_GPL(usb_remove_function);
253 
254 /**
255  * usb_function_deactivate - prevent function and gadget enumeration
256  * @function: the function that isn't yet ready to respond
257  *
258  * Blocks response of the gadget driver to host enumeration by
259  * preventing the data line pullup from being activated.  This is
260  * normally called during @bind() processing to change from the
261  * initial "ready to respond" state, or when a required resource
262  * becomes available.
263  *
264  * For example, drivers that serve as a passthrough to a userspace
265  * daemon can block enumeration unless that daemon (such as an OBEX,
266  * MTP, or print server) is ready to handle host requests.
267  *
268  * Not all systems support software control of their USB peripheral
269  * data pullups.
270  *
271  * Returns zero on success, else negative errno.
272  */
273 int usb_function_deactivate(struct usb_function *function)
274 {
275 	struct usb_composite_dev	*cdev = function->config->cdev;
276 	unsigned long			flags;
277 	int				status = 0;
278 
279 	spin_lock_irqsave(&cdev->lock, flags);
280 
281 	if (cdev->deactivations == 0)
282 		status = usb_gadget_disconnect(cdev->gadget);
283 	if (status == 0)
284 		cdev->deactivations++;
285 
286 	spin_unlock_irqrestore(&cdev->lock, flags);
287 	return status;
288 }
289 EXPORT_SYMBOL_GPL(usb_function_deactivate);
290 
291 /**
292  * usb_function_activate - allow function and gadget enumeration
293  * @function: function on which usb_function_activate() was called
294  *
295  * Reverses effect of usb_function_deactivate().  If no more functions
296  * are delaying their activation, the gadget driver will respond to
297  * host enumeration procedures.
298  *
299  * Returns zero on success, else negative errno.
300  */
301 int usb_function_activate(struct usb_function *function)
302 {
303 	struct usb_composite_dev	*cdev = function->config->cdev;
304 	unsigned long			flags;
305 	int				status = 0;
306 
307 	spin_lock_irqsave(&cdev->lock, flags);
308 
309 	if (WARN_ON(cdev->deactivations == 0))
310 		status = -EINVAL;
311 	else {
312 		cdev->deactivations--;
313 		if (cdev->deactivations == 0)
314 			status = usb_gadget_connect(cdev->gadget);
315 	}
316 
317 	spin_unlock_irqrestore(&cdev->lock, flags);
318 	return status;
319 }
320 EXPORT_SYMBOL_GPL(usb_function_activate);
321 
322 /**
323  * usb_interface_id() - allocate an unused interface ID
324  * @config: configuration associated with the interface
325  * @function: function handling the interface
326  * Context: single threaded during gadget setup
327  *
328  * usb_interface_id() is called from usb_function.bind() callbacks to
329  * allocate new interface IDs.  The function driver will then store that
330  * ID in interface, association, CDC union, and other descriptors.  It
331  * will also handle any control requests targeted at that interface,
332  * particularly changing its altsetting via set_alt().  There may
333  * also be class-specific or vendor-specific requests to handle.
334  *
335  * All interface identifier should be allocated using this routine, to
336  * ensure that for example different functions don't wrongly assign
337  * different meanings to the same identifier.  Note that since interface
338  * identifiers are configuration-specific, functions used in more than
339  * one configuration (or more than once in a given configuration) need
340  * multiple versions of the relevant descriptors.
341  *
342  * Returns the interface ID which was allocated; or -ENODEV if no
343  * more interface IDs can be allocated.
344  */
345 int usb_interface_id(struct usb_configuration *config,
346 		struct usb_function *function)
347 {
348 	unsigned id = config->next_interface_id;
349 
350 	if (id < MAX_CONFIG_INTERFACES) {
351 		config->interface[id] = function;
352 		config->next_interface_id = id + 1;
353 		return id;
354 	}
355 	return -ENODEV;
356 }
357 EXPORT_SYMBOL_GPL(usb_interface_id);
358 
359 static u8 encode_bMaxPower(enum usb_device_speed speed,
360 		struct usb_configuration *c)
361 {
362 	unsigned val;
363 
364 	if (c->MaxPower)
365 		val = c->MaxPower;
366 	else
367 		val = CONFIG_USB_GADGET_VBUS_DRAW;
368 	if (!val)
369 		return 0;
370 	switch (speed) {
371 	case USB_SPEED_SUPER:
372 		return DIV_ROUND_UP(val, 8);
373 	default:
374 		return DIV_ROUND_UP(val, 2);
375 	}
376 }
377 
378 static int config_buf(struct usb_configuration *config,
379 		enum usb_device_speed speed, void *buf, u8 type)
380 {
381 	struct usb_config_descriptor	*c = buf;
382 	void				*next = buf + USB_DT_CONFIG_SIZE;
383 	int				len;
384 	struct usb_function		*f;
385 	int				status;
386 
387 	len = USB_COMP_EP0_BUFSIZ - USB_DT_CONFIG_SIZE;
388 	/* write the config descriptor */
389 	c = buf;
390 	c->bLength = USB_DT_CONFIG_SIZE;
391 	c->bDescriptorType = type;
392 	/* wTotalLength is written later */
393 	c->bNumInterfaces = config->next_interface_id;
394 	c->bConfigurationValue = config->bConfigurationValue;
395 	c->iConfiguration = config->iConfiguration;
396 	c->bmAttributes = USB_CONFIG_ATT_ONE | config->bmAttributes;
397 	c->bMaxPower = encode_bMaxPower(speed, config);
398 
399 	/* There may be e.g. OTG descriptors */
400 	if (config->descriptors) {
401 		status = usb_descriptor_fillbuf(next, len,
402 				config->descriptors);
403 		if (status < 0)
404 			return status;
405 		len -= status;
406 		next += status;
407 	}
408 
409 	/* add each function's descriptors */
410 	list_for_each_entry(f, &config->functions, list) {
411 		struct usb_descriptor_header **descriptors;
412 
413 		switch (speed) {
414 		case USB_SPEED_SUPER:
415 			descriptors = f->ss_descriptors;
416 			break;
417 		case USB_SPEED_HIGH:
418 			descriptors = f->hs_descriptors;
419 			break;
420 		default:
421 			descriptors = f->fs_descriptors;
422 		}
423 
424 		if (!descriptors)
425 			continue;
426 		status = usb_descriptor_fillbuf(next, len,
427 			(const struct usb_descriptor_header **) descriptors);
428 		if (status < 0)
429 			return status;
430 		len -= status;
431 		next += status;
432 	}
433 
434 	len = next - buf;
435 	c->wTotalLength = cpu_to_le16(len);
436 	return len;
437 }
438 
439 static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
440 {
441 	struct usb_gadget		*gadget = cdev->gadget;
442 	struct usb_configuration	*c;
443 	struct list_head		*pos;
444 	u8				type = w_value >> 8;
445 	enum usb_device_speed		speed = USB_SPEED_UNKNOWN;
446 
447 	if (gadget->speed == USB_SPEED_SUPER)
448 		speed = gadget->speed;
449 	else if (gadget_is_dualspeed(gadget)) {
450 		int	hs = 0;
451 		if (gadget->speed == USB_SPEED_HIGH)
452 			hs = 1;
453 		if (type == USB_DT_OTHER_SPEED_CONFIG)
454 			hs = !hs;
455 		if (hs)
456 			speed = USB_SPEED_HIGH;
457 
458 	}
459 
460 	/* This is a lookup by config *INDEX* */
461 	w_value &= 0xff;
462 
463 	pos = &cdev->configs;
464 	c = cdev->os_desc_config;
465 	if (c)
466 		goto check_config;
467 
468 	while ((pos = pos->next) !=  &cdev->configs) {
469 		c = list_entry(pos, typeof(*c), list);
470 
471 		/* skip OS Descriptors config which is handled separately */
472 		if (c == cdev->os_desc_config)
473 			continue;
474 
475 check_config:
476 		/* ignore configs that won't work at this speed */
477 		switch (speed) {
478 		case USB_SPEED_SUPER:
479 			if (!c->superspeed)
480 				continue;
481 			break;
482 		case USB_SPEED_HIGH:
483 			if (!c->highspeed)
484 				continue;
485 			break;
486 		default:
487 			if (!c->fullspeed)
488 				continue;
489 		}
490 
491 		if (w_value == 0)
492 			return config_buf(c, speed, cdev->req->buf, type);
493 		w_value--;
494 	}
495 	return -EINVAL;
496 }
497 
498 static int count_configs(struct usb_composite_dev *cdev, unsigned type)
499 {
500 	struct usb_gadget		*gadget = cdev->gadget;
501 	struct usb_configuration	*c;
502 	unsigned			count = 0;
503 	int				hs = 0;
504 	int				ss = 0;
505 
506 	if (gadget_is_dualspeed(gadget)) {
507 		if (gadget->speed == USB_SPEED_HIGH)
508 			hs = 1;
509 		if (gadget->speed == USB_SPEED_SUPER)
510 			ss = 1;
511 		if (type == USB_DT_DEVICE_QUALIFIER)
512 			hs = !hs;
513 	}
514 	list_for_each_entry(c, &cdev->configs, list) {
515 		/* ignore configs that won't work at this speed */
516 		if (ss) {
517 			if (!c->superspeed)
518 				continue;
519 		} else if (hs) {
520 			if (!c->highspeed)
521 				continue;
522 		} else {
523 			if (!c->fullspeed)
524 				continue;
525 		}
526 		count++;
527 	}
528 	return count;
529 }
530 
531 /**
532  * bos_desc() - prepares the BOS descriptor.
533  * @cdev: pointer to usb_composite device to generate the bos
534  *	descriptor for
535  *
536  * This function generates the BOS (Binary Device Object)
537  * descriptor and its device capabilities descriptors. The BOS
538  * descriptor should be supported by a SuperSpeed device.
539  */
540 static int bos_desc(struct usb_composite_dev *cdev)
541 {
542 	struct usb_ext_cap_descriptor	*usb_ext;
543 	struct usb_ss_cap_descriptor	*ss_cap;
544 	struct usb_dcd_config_params	dcd_config_params;
545 	struct usb_bos_descriptor	*bos = cdev->req->buf;
546 
547 	bos->bLength = USB_DT_BOS_SIZE;
548 	bos->bDescriptorType = USB_DT_BOS;
549 
550 	bos->wTotalLength = cpu_to_le16(USB_DT_BOS_SIZE);
551 	bos->bNumDeviceCaps = 0;
552 
553 	/*
554 	 * A SuperSpeed device shall include the USB2.0 extension descriptor
555 	 * and shall support LPM when operating in USB2.0 HS mode.
556 	 */
557 	usb_ext = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
558 	bos->bNumDeviceCaps++;
559 	le16_add_cpu(&bos->wTotalLength, USB_DT_USB_EXT_CAP_SIZE);
560 	usb_ext->bLength = USB_DT_USB_EXT_CAP_SIZE;
561 	usb_ext->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
562 	usb_ext->bDevCapabilityType = USB_CAP_TYPE_EXT;
563 	usb_ext->bmAttributes = cpu_to_le32(USB_LPM_SUPPORT | USB_BESL_SUPPORT);
564 
565 	/*
566 	 * The Superspeed USB Capability descriptor shall be implemented by all
567 	 * SuperSpeed devices.
568 	 */
569 	ss_cap = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
570 	bos->bNumDeviceCaps++;
571 	le16_add_cpu(&bos->wTotalLength, USB_DT_USB_SS_CAP_SIZE);
572 	ss_cap->bLength = USB_DT_USB_SS_CAP_SIZE;
573 	ss_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
574 	ss_cap->bDevCapabilityType = USB_SS_CAP_TYPE;
575 	ss_cap->bmAttributes = 0; /* LTM is not supported yet */
576 	ss_cap->wSpeedSupported = cpu_to_le16(USB_LOW_SPEED_OPERATION |
577 				USB_FULL_SPEED_OPERATION |
578 				USB_HIGH_SPEED_OPERATION |
579 				USB_5GBPS_OPERATION);
580 	ss_cap->bFunctionalitySupport = USB_LOW_SPEED_OPERATION;
581 
582 	/* Get Controller configuration */
583 	if (cdev->gadget->ops->get_config_params)
584 		cdev->gadget->ops->get_config_params(&dcd_config_params);
585 	else {
586 		dcd_config_params.bU1devExitLat = USB_DEFAULT_U1_DEV_EXIT_LAT;
587 		dcd_config_params.bU2DevExitLat =
588 			cpu_to_le16(USB_DEFAULT_U2_DEV_EXIT_LAT);
589 	}
590 	ss_cap->bU1devExitLat = dcd_config_params.bU1devExitLat;
591 	ss_cap->bU2DevExitLat = dcd_config_params.bU2DevExitLat;
592 
593 	return le16_to_cpu(bos->wTotalLength);
594 }
595 
596 static void device_qual(struct usb_composite_dev *cdev)
597 {
598 	struct usb_qualifier_descriptor	*qual = cdev->req->buf;
599 
600 	qual->bLength = sizeof(*qual);
601 	qual->bDescriptorType = USB_DT_DEVICE_QUALIFIER;
602 	/* POLICY: same bcdUSB and device type info at both speeds */
603 	qual->bcdUSB = cdev->desc.bcdUSB;
604 	qual->bDeviceClass = cdev->desc.bDeviceClass;
605 	qual->bDeviceSubClass = cdev->desc.bDeviceSubClass;
606 	qual->bDeviceProtocol = cdev->desc.bDeviceProtocol;
607 	/* ASSUME same EP0 fifo size at both speeds */
608 	qual->bMaxPacketSize0 = cdev->gadget->ep0->maxpacket;
609 	qual->bNumConfigurations = count_configs(cdev, USB_DT_DEVICE_QUALIFIER);
610 	qual->bRESERVED = 0;
611 }
612 
613 /*-------------------------------------------------------------------------*/
614 
615 static void reset_config(struct usb_composite_dev *cdev)
616 {
617 	struct usb_function		*f;
618 
619 	DBG(cdev, "reset config\n");
620 
621 	list_for_each_entry(f, &cdev->config->functions, list) {
622 		if (f->disable)
623 			f->disable(f);
624 
625 		bitmap_zero(f->endpoints, 32);
626 	}
627 	cdev->config = NULL;
628 	cdev->delayed_status = 0;
629 }
630 
631 static int set_config(struct usb_composite_dev *cdev,
632 		const struct usb_ctrlrequest *ctrl, unsigned number)
633 {
634 	struct usb_gadget	*gadget = cdev->gadget;
635 	struct usb_configuration *c = NULL;
636 	int			result = -EINVAL;
637 	unsigned		power = gadget_is_otg(gadget) ? 8 : 100;
638 	int			tmp;
639 
640 	if (number) {
641 		list_for_each_entry(c, &cdev->configs, list) {
642 			if (c->bConfigurationValue == number) {
643 				/*
644 				 * We disable the FDs of the previous
645 				 * configuration only if the new configuration
646 				 * is a valid one
647 				 */
648 				if (cdev->config)
649 					reset_config(cdev);
650 				result = 0;
651 				break;
652 			}
653 		}
654 		if (result < 0)
655 			goto done;
656 	} else { /* Zero configuration value - need to reset the config */
657 		if (cdev->config)
658 			reset_config(cdev);
659 		result = 0;
660 	}
661 
662 	INFO(cdev, "%s config #%d: %s\n",
663 	     usb_speed_string(gadget->speed),
664 	     number, c ? c->label : "unconfigured");
665 
666 	if (!c)
667 		goto done;
668 
669 	usb_gadget_set_state(gadget, USB_STATE_CONFIGURED);
670 	cdev->config = c;
671 
672 	/* Initialize all interfaces by setting them to altsetting zero. */
673 	for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
674 		struct usb_function	*f = c->interface[tmp];
675 		struct usb_descriptor_header **descriptors;
676 
677 		if (!f)
678 			break;
679 
680 		/*
681 		 * Record which endpoints are used by the function. This is used
682 		 * to dispatch control requests targeted at that endpoint to the
683 		 * function's setup callback instead of the current
684 		 * configuration's setup callback.
685 		 */
686 		switch (gadget->speed) {
687 		case USB_SPEED_SUPER:
688 			descriptors = f->ss_descriptors;
689 			break;
690 		case USB_SPEED_HIGH:
691 			descriptors = f->hs_descriptors;
692 			break;
693 		default:
694 			descriptors = f->fs_descriptors;
695 		}
696 
697 		for (; *descriptors; ++descriptors) {
698 			struct usb_endpoint_descriptor *ep;
699 			int addr;
700 
701 			if ((*descriptors)->bDescriptorType != USB_DT_ENDPOINT)
702 				continue;
703 
704 			ep = (struct usb_endpoint_descriptor *)*descriptors;
705 			addr = ((ep->bEndpointAddress & 0x80) >> 3)
706 			     |  (ep->bEndpointAddress & 0x0f);
707 			set_bit(addr, f->endpoints);
708 		}
709 
710 		result = f->set_alt(f, tmp, 0);
711 		if (result < 0) {
712 			DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
713 					tmp, f->name, f, result);
714 
715 			reset_config(cdev);
716 			goto done;
717 		}
718 
719 		if (result == USB_GADGET_DELAYED_STATUS) {
720 			DBG(cdev,
721 			 "%s: interface %d (%s) requested delayed status\n",
722 					__func__, tmp, f->name);
723 			cdev->delayed_status++;
724 			DBG(cdev, "delayed_status count %d\n",
725 					cdev->delayed_status);
726 		}
727 	}
728 
729 	/* when we return, be sure our power usage is valid */
730 	power = c->MaxPower ? c->MaxPower : CONFIG_USB_GADGET_VBUS_DRAW;
731 done:
732 	usb_gadget_vbus_draw(gadget, power);
733 	if (result >= 0 && cdev->delayed_status)
734 		result = USB_GADGET_DELAYED_STATUS;
735 	return result;
736 }
737 
738 int usb_add_config_only(struct usb_composite_dev *cdev,
739 		struct usb_configuration *config)
740 {
741 	struct usb_configuration *c;
742 
743 	if (!config->bConfigurationValue)
744 		return -EINVAL;
745 
746 	/* Prevent duplicate configuration identifiers */
747 	list_for_each_entry(c, &cdev->configs, list) {
748 		if (c->bConfigurationValue == config->bConfigurationValue)
749 			return -EBUSY;
750 	}
751 
752 	config->cdev = cdev;
753 	list_add_tail(&config->list, &cdev->configs);
754 
755 	INIT_LIST_HEAD(&config->functions);
756 	config->next_interface_id = 0;
757 	memset(config->interface, 0, sizeof(config->interface));
758 
759 	return 0;
760 }
761 EXPORT_SYMBOL_GPL(usb_add_config_only);
762 
763 /**
764  * usb_add_config() - add a configuration to a device.
765  * @cdev: wraps the USB gadget
766  * @config: the configuration, with bConfigurationValue assigned
767  * @bind: the configuration's bind function
768  * Context: single threaded during gadget setup
769  *
770  * One of the main tasks of a composite @bind() routine is to
771  * add each of the configurations it supports, using this routine.
772  *
773  * This function returns the value of the configuration's @bind(), which
774  * is zero for success else a negative errno value.  Binding configurations
775  * assigns global resources including string IDs, and per-configuration
776  * resources such as interface IDs and endpoints.
777  */
778 int usb_add_config(struct usb_composite_dev *cdev,
779 		struct usb_configuration *config,
780 		int (*bind)(struct usb_configuration *))
781 {
782 	int				status = -EINVAL;
783 
784 	if (!bind)
785 		goto done;
786 
787 	DBG(cdev, "adding config #%u '%s'/%p\n",
788 			config->bConfigurationValue,
789 			config->label, config);
790 
791 	status = usb_add_config_only(cdev, config);
792 	if (status)
793 		goto done;
794 
795 	status = bind(config);
796 	if (status < 0) {
797 		while (!list_empty(&config->functions)) {
798 			struct usb_function		*f;
799 
800 			f = list_first_entry(&config->functions,
801 					struct usb_function, list);
802 			list_del(&f->list);
803 			if (f->unbind) {
804 				DBG(cdev, "unbind function '%s'/%p\n",
805 					f->name, f);
806 				f->unbind(config, f);
807 				/* may free memory for "f" */
808 			}
809 		}
810 		list_del(&config->list);
811 		config->cdev = NULL;
812 	} else {
813 		unsigned	i;
814 
815 		DBG(cdev, "cfg %d/%p speeds:%s%s%s\n",
816 			config->bConfigurationValue, config,
817 			config->superspeed ? " super" : "",
818 			config->highspeed ? " high" : "",
819 			config->fullspeed
820 				? (gadget_is_dualspeed(cdev->gadget)
821 					? " full"
822 					: " full/low")
823 				: "");
824 
825 		for (i = 0; i < MAX_CONFIG_INTERFACES; i++) {
826 			struct usb_function	*f = config->interface[i];
827 
828 			if (!f)
829 				continue;
830 			DBG(cdev, "  interface %d = %s/%p\n",
831 				i, f->name, f);
832 		}
833 	}
834 
835 	/* set_alt(), or next bind(), sets up
836 	 * ep->driver_data as needed.
837 	 */
838 	usb_ep_autoconfig_reset(cdev->gadget);
839 
840 done:
841 	if (status)
842 		DBG(cdev, "added config '%s'/%u --> %d\n", config->label,
843 				config->bConfigurationValue, status);
844 	return status;
845 }
846 EXPORT_SYMBOL_GPL(usb_add_config);
847 
848 static void remove_config(struct usb_composite_dev *cdev,
849 			      struct usb_configuration *config)
850 {
851 	while (!list_empty(&config->functions)) {
852 		struct usb_function		*f;
853 
854 		f = list_first_entry(&config->functions,
855 				struct usb_function, list);
856 		list_del(&f->list);
857 		if (f->unbind) {
858 			DBG(cdev, "unbind function '%s'/%p\n", f->name, f);
859 			f->unbind(config, f);
860 			/* may free memory for "f" */
861 		}
862 	}
863 	list_del(&config->list);
864 	if (config->unbind) {
865 		DBG(cdev, "unbind config '%s'/%p\n", config->label, config);
866 		config->unbind(config);
867 			/* may free memory for "c" */
868 	}
869 }
870 
871 /**
872  * usb_remove_config() - remove a configuration from a device.
873  * @cdev: wraps the USB gadget
874  * @config: the configuration
875  *
876  * Drivers must call usb_gadget_disconnect before calling this function
877  * to disconnect the device from the host and make sure the host will not
878  * try to enumerate the device while we are changing the config list.
879  */
880 void usb_remove_config(struct usb_composite_dev *cdev,
881 		      struct usb_configuration *config)
882 {
883 	unsigned long flags;
884 
885 	spin_lock_irqsave(&cdev->lock, flags);
886 
887 	if (cdev->config == config)
888 		reset_config(cdev);
889 
890 	spin_unlock_irqrestore(&cdev->lock, flags);
891 
892 	remove_config(cdev, config);
893 }
894 
895 /*-------------------------------------------------------------------------*/
896 
897 /* We support strings in multiple languages ... string descriptor zero
898  * says which languages are supported.  The typical case will be that
899  * only one language (probably English) is used, with I18N handled on
900  * the host side.
901  */
902 
903 static void collect_langs(struct usb_gadget_strings **sp, __le16 *buf)
904 {
905 	const struct usb_gadget_strings	*s;
906 	__le16				language;
907 	__le16				*tmp;
908 
909 	while (*sp) {
910 		s = *sp;
911 		language = cpu_to_le16(s->language);
912 		for (tmp = buf; *tmp && tmp < &buf[126]; tmp++) {
913 			if (*tmp == language)
914 				goto repeat;
915 		}
916 		*tmp++ = language;
917 repeat:
918 		sp++;
919 	}
920 }
921 
922 static int lookup_string(
923 	struct usb_gadget_strings	**sp,
924 	void				*buf,
925 	u16				language,
926 	int				id
927 )
928 {
929 	struct usb_gadget_strings	*s;
930 	int				value;
931 
932 	while (*sp) {
933 		s = *sp++;
934 		if (s->language != language)
935 			continue;
936 		value = usb_gadget_get_string(s, id, buf);
937 		if (value > 0)
938 			return value;
939 	}
940 	return -EINVAL;
941 }
942 
943 static int get_string(struct usb_composite_dev *cdev,
944 		void *buf, u16 language, int id)
945 {
946 	struct usb_composite_driver	*composite = cdev->driver;
947 	struct usb_gadget_string_container *uc;
948 	struct usb_configuration	*c;
949 	struct usb_function		*f;
950 	int				len;
951 
952 	/* Yes, not only is USB's I18N support probably more than most
953 	 * folk will ever care about ... also, it's all supported here.
954 	 * (Except for UTF8 support for Unicode's "Astral Planes".)
955 	 */
956 
957 	/* 0 == report all available language codes */
958 	if (id == 0) {
959 		struct usb_string_descriptor	*s = buf;
960 		struct usb_gadget_strings	**sp;
961 
962 		memset(s, 0, 256);
963 		s->bDescriptorType = USB_DT_STRING;
964 
965 		sp = composite->strings;
966 		if (sp)
967 			collect_langs(sp, s->wData);
968 
969 		list_for_each_entry(c, &cdev->configs, list) {
970 			sp = c->strings;
971 			if (sp)
972 				collect_langs(sp, s->wData);
973 
974 			list_for_each_entry(f, &c->functions, list) {
975 				sp = f->strings;
976 				if (sp)
977 					collect_langs(sp, s->wData);
978 			}
979 		}
980 		list_for_each_entry(uc, &cdev->gstrings, list) {
981 			struct usb_gadget_strings **sp;
982 
983 			sp = get_containers_gs(uc);
984 			collect_langs(sp, s->wData);
985 		}
986 
987 		for (len = 0; len <= 126 && s->wData[len]; len++)
988 			continue;
989 		if (!len)
990 			return -EINVAL;
991 
992 		s->bLength = 2 * (len + 1);
993 		return s->bLength;
994 	}
995 
996 	if (cdev->use_os_string && language == 0 && id == OS_STRING_IDX) {
997 		struct usb_os_string *b = buf;
998 		b->bLength = sizeof(*b);
999 		b->bDescriptorType = USB_DT_STRING;
1000 		compiletime_assert(
1001 			sizeof(b->qwSignature) == sizeof(cdev->qw_sign),
1002 			"qwSignature size must be equal to qw_sign");
1003 		memcpy(&b->qwSignature, cdev->qw_sign, sizeof(b->qwSignature));
1004 		b->bMS_VendorCode = cdev->b_vendor_code;
1005 		b->bPad = 0;
1006 		return sizeof(*b);
1007 	}
1008 
1009 	list_for_each_entry(uc, &cdev->gstrings, list) {
1010 		struct usb_gadget_strings **sp;
1011 
1012 		sp = get_containers_gs(uc);
1013 		len = lookup_string(sp, buf, language, id);
1014 		if (len > 0)
1015 			return len;
1016 	}
1017 
1018 	/* String IDs are device-scoped, so we look up each string
1019 	 * table we're told about.  These lookups are infrequent;
1020 	 * simpler-is-better here.
1021 	 */
1022 	if (composite->strings) {
1023 		len = lookup_string(composite->strings, buf, language, id);
1024 		if (len > 0)
1025 			return len;
1026 	}
1027 	list_for_each_entry(c, &cdev->configs, list) {
1028 		if (c->strings) {
1029 			len = lookup_string(c->strings, buf, language, id);
1030 			if (len > 0)
1031 				return len;
1032 		}
1033 		list_for_each_entry(f, &c->functions, list) {
1034 			if (!f->strings)
1035 				continue;
1036 			len = lookup_string(f->strings, buf, language, id);
1037 			if (len > 0)
1038 				return len;
1039 		}
1040 	}
1041 	return -EINVAL;
1042 }
1043 
1044 /**
1045  * usb_string_id() - allocate an unused string ID
1046  * @cdev: the device whose string descriptor IDs are being allocated
1047  * Context: single threaded during gadget setup
1048  *
1049  * @usb_string_id() is called from bind() callbacks to allocate
1050  * string IDs.  Drivers for functions, configurations, or gadgets will
1051  * then store that ID in the appropriate descriptors and string table.
1052  *
1053  * All string identifier should be allocated using this,
1054  * @usb_string_ids_tab() or @usb_string_ids_n() routine, to ensure
1055  * that for example different functions don't wrongly assign different
1056  * meanings to the same identifier.
1057  */
1058 int usb_string_id(struct usb_composite_dev *cdev)
1059 {
1060 	if (cdev->next_string_id < 254) {
1061 		/* string id 0 is reserved by USB spec for list of
1062 		 * supported languages */
1063 		/* 255 reserved as well? -- mina86 */
1064 		cdev->next_string_id++;
1065 		return cdev->next_string_id;
1066 	}
1067 	return -ENODEV;
1068 }
1069 EXPORT_SYMBOL_GPL(usb_string_id);
1070 
1071 /**
1072  * usb_string_ids() - allocate unused string IDs in batch
1073  * @cdev: the device whose string descriptor IDs are being allocated
1074  * @str: an array of usb_string objects to assign numbers to
1075  * Context: single threaded during gadget setup
1076  *
1077  * @usb_string_ids() is called from bind() callbacks to allocate
1078  * string IDs.  Drivers for functions, configurations, or gadgets will
1079  * then copy IDs from the string table to the appropriate descriptors
1080  * and string table for other languages.
1081  *
1082  * All string identifier should be allocated using this,
1083  * @usb_string_id() or @usb_string_ids_n() routine, to ensure that for
1084  * example different functions don't wrongly assign different meanings
1085  * to the same identifier.
1086  */
1087 int usb_string_ids_tab(struct usb_composite_dev *cdev, struct usb_string *str)
1088 {
1089 	int next = cdev->next_string_id;
1090 
1091 	for (; str->s; ++str) {
1092 		if (unlikely(next >= 254))
1093 			return -ENODEV;
1094 		str->id = ++next;
1095 	}
1096 
1097 	cdev->next_string_id = next;
1098 
1099 	return 0;
1100 }
1101 EXPORT_SYMBOL_GPL(usb_string_ids_tab);
1102 
1103 static struct usb_gadget_string_container *copy_gadget_strings(
1104 		struct usb_gadget_strings **sp, unsigned n_gstrings,
1105 		unsigned n_strings)
1106 {
1107 	struct usb_gadget_string_container *uc;
1108 	struct usb_gadget_strings **gs_array;
1109 	struct usb_gadget_strings *gs;
1110 	struct usb_string *s;
1111 	unsigned mem;
1112 	unsigned n_gs;
1113 	unsigned n_s;
1114 	void *stash;
1115 
1116 	mem = sizeof(*uc);
1117 	mem += sizeof(void *) * (n_gstrings + 1);
1118 	mem += sizeof(struct usb_gadget_strings) * n_gstrings;
1119 	mem += sizeof(struct usb_string) * (n_strings + 1) * (n_gstrings);
1120 	uc = kmalloc(mem, GFP_KERNEL);
1121 	if (!uc)
1122 		return ERR_PTR(-ENOMEM);
1123 	gs_array = get_containers_gs(uc);
1124 	stash = uc->stash;
1125 	stash += sizeof(void *) * (n_gstrings + 1);
1126 	for (n_gs = 0; n_gs < n_gstrings; n_gs++) {
1127 		struct usb_string *org_s;
1128 
1129 		gs_array[n_gs] = stash;
1130 		gs = gs_array[n_gs];
1131 		stash += sizeof(struct usb_gadget_strings);
1132 		gs->language = sp[n_gs]->language;
1133 		gs->strings = stash;
1134 		org_s = sp[n_gs]->strings;
1135 
1136 		for (n_s = 0; n_s < n_strings; n_s++) {
1137 			s = stash;
1138 			stash += sizeof(struct usb_string);
1139 			if (org_s->s)
1140 				s->s = org_s->s;
1141 			else
1142 				s->s = "";
1143 			org_s++;
1144 		}
1145 		s = stash;
1146 		s->s = NULL;
1147 		stash += sizeof(struct usb_string);
1148 
1149 	}
1150 	gs_array[n_gs] = NULL;
1151 	return uc;
1152 }
1153 
1154 /**
1155  * usb_gstrings_attach() - attach gadget strings to a cdev and assign ids
1156  * @cdev: the device whose string descriptor IDs are being allocated
1157  * and attached.
1158  * @sp: an array of usb_gadget_strings to attach.
1159  * @n_strings: number of entries in each usb_strings array (sp[]->strings)
1160  *
1161  * This function will create a deep copy of usb_gadget_strings and usb_string
1162  * and attach it to the cdev. The actual string (usb_string.s) will not be
1163  * copied but only a referenced will be made. The struct usb_gadget_strings
1164  * array may contain multiple languges and should be NULL terminated.
1165  * The ->language pointer of each struct usb_gadget_strings has to contain the
1166  * same amount of entries.
1167  * For instance: sp[0] is en-US, sp[1] is es-ES. It is expected that the first
1168  * usb_string entry of es-ES containts the translation of the first usb_string
1169  * entry of en-US. Therefore both entries become the same id assign.
1170  */
1171 struct usb_string *usb_gstrings_attach(struct usb_composite_dev *cdev,
1172 		struct usb_gadget_strings **sp, unsigned n_strings)
1173 {
1174 	struct usb_gadget_string_container *uc;
1175 	struct usb_gadget_strings **n_gs;
1176 	unsigned n_gstrings = 0;
1177 	unsigned i;
1178 	int ret;
1179 
1180 	for (i = 0; sp[i]; i++)
1181 		n_gstrings++;
1182 
1183 	if (!n_gstrings)
1184 		return ERR_PTR(-EINVAL);
1185 
1186 	uc = copy_gadget_strings(sp, n_gstrings, n_strings);
1187 	if (IS_ERR(uc))
1188 		return ERR_CAST(uc);
1189 
1190 	n_gs = get_containers_gs(uc);
1191 	ret = usb_string_ids_tab(cdev, n_gs[0]->strings);
1192 	if (ret)
1193 		goto err;
1194 
1195 	for (i = 1; i < n_gstrings; i++) {
1196 		struct usb_string *m_s;
1197 		struct usb_string *s;
1198 		unsigned n;
1199 
1200 		m_s = n_gs[0]->strings;
1201 		s = n_gs[i]->strings;
1202 		for (n = 0; n < n_strings; n++) {
1203 			s->id = m_s->id;
1204 			s++;
1205 			m_s++;
1206 		}
1207 	}
1208 	list_add_tail(&uc->list, &cdev->gstrings);
1209 	return n_gs[0]->strings;
1210 err:
1211 	kfree(uc);
1212 	return ERR_PTR(ret);
1213 }
1214 EXPORT_SYMBOL_GPL(usb_gstrings_attach);
1215 
1216 /**
1217  * usb_string_ids_n() - allocate unused string IDs in batch
1218  * @c: the device whose string descriptor IDs are being allocated
1219  * @n: number of string IDs to allocate
1220  * Context: single threaded during gadget setup
1221  *
1222  * Returns the first requested ID.  This ID and next @n-1 IDs are now
1223  * valid IDs.  At least provided that @n is non-zero because if it
1224  * is, returns last requested ID which is now very useful information.
1225  *
1226  * @usb_string_ids_n() is called from bind() callbacks to allocate
1227  * string IDs.  Drivers for functions, configurations, or gadgets will
1228  * then store that ID in the appropriate descriptors and string table.
1229  *
1230  * All string identifier should be allocated using this,
1231  * @usb_string_id() or @usb_string_ids_n() routine, to ensure that for
1232  * example different functions don't wrongly assign different meanings
1233  * to the same identifier.
1234  */
1235 int usb_string_ids_n(struct usb_composite_dev *c, unsigned n)
1236 {
1237 	unsigned next = c->next_string_id;
1238 	if (unlikely(n > 254 || (unsigned)next + n > 254))
1239 		return -ENODEV;
1240 	c->next_string_id += n;
1241 	return next + 1;
1242 }
1243 EXPORT_SYMBOL_GPL(usb_string_ids_n);
1244 
1245 /*-------------------------------------------------------------------------*/
1246 
1247 static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
1248 {
1249 	if (req->status || req->actual != req->length)
1250 		DBG((struct usb_composite_dev *) ep->driver_data,
1251 				"setup complete --> %d, %d/%d\n",
1252 				req->status, req->actual, req->length);
1253 }
1254 
1255 static int count_ext_compat(struct usb_configuration *c)
1256 {
1257 	int i, res;
1258 
1259 	res = 0;
1260 	for (i = 0; i < c->next_interface_id; ++i) {
1261 		struct usb_function *f;
1262 		int j;
1263 
1264 		f = c->interface[i];
1265 		for (j = 0; j < f->os_desc_n; ++j) {
1266 			struct usb_os_desc *d;
1267 
1268 			if (i != f->os_desc_table[j].if_id)
1269 				continue;
1270 			d = f->os_desc_table[j].os_desc;
1271 			if (d && d->ext_compat_id)
1272 				++res;
1273 		}
1274 	}
1275 	BUG_ON(res > 255);
1276 	return res;
1277 }
1278 
1279 static void fill_ext_compat(struct usb_configuration *c, u8 *buf)
1280 {
1281 	int i, count;
1282 
1283 	count = 16;
1284 	for (i = 0; i < c->next_interface_id; ++i) {
1285 		struct usb_function *f;
1286 		int j;
1287 
1288 		f = c->interface[i];
1289 		for (j = 0; j < f->os_desc_n; ++j) {
1290 			struct usb_os_desc *d;
1291 
1292 			if (i != f->os_desc_table[j].if_id)
1293 				continue;
1294 			d = f->os_desc_table[j].os_desc;
1295 			if (d && d->ext_compat_id) {
1296 				*buf++ = i;
1297 				*buf++ = 0x01;
1298 				memcpy(buf, d->ext_compat_id, 16);
1299 				buf += 22;
1300 			} else {
1301 				++buf;
1302 				*buf = 0x01;
1303 				buf += 23;
1304 			}
1305 			count += 24;
1306 			if (count >= 4096)
1307 				return;
1308 		}
1309 	}
1310 }
1311 
1312 static int count_ext_prop(struct usb_configuration *c, int interface)
1313 {
1314 	struct usb_function *f;
1315 	int j;
1316 
1317 	f = c->interface[interface];
1318 	for (j = 0; j < f->os_desc_n; ++j) {
1319 		struct usb_os_desc *d;
1320 
1321 		if (interface != f->os_desc_table[j].if_id)
1322 			continue;
1323 		d = f->os_desc_table[j].os_desc;
1324 		if (d && d->ext_compat_id)
1325 			return d->ext_prop_count;
1326 	}
1327 	return 0;
1328 }
1329 
1330 static int len_ext_prop(struct usb_configuration *c, int interface)
1331 {
1332 	struct usb_function *f;
1333 	struct usb_os_desc *d;
1334 	int j, res;
1335 
1336 	res = 10; /* header length */
1337 	f = c->interface[interface];
1338 	for (j = 0; j < f->os_desc_n; ++j) {
1339 		if (interface != f->os_desc_table[j].if_id)
1340 			continue;
1341 		d = f->os_desc_table[j].os_desc;
1342 		if (d)
1343 			return min(res + d->ext_prop_len, 4096);
1344 	}
1345 	return res;
1346 }
1347 
1348 static int fill_ext_prop(struct usb_configuration *c, int interface, u8 *buf)
1349 {
1350 	struct usb_function *f;
1351 	struct usb_os_desc *d;
1352 	struct usb_os_desc_ext_prop *ext_prop;
1353 	int j, count, n, ret;
1354 	u8 *start = buf;
1355 
1356 	f = c->interface[interface];
1357 	for (j = 0; j < f->os_desc_n; ++j) {
1358 		if (interface != f->os_desc_table[j].if_id)
1359 			continue;
1360 		d = f->os_desc_table[j].os_desc;
1361 		if (d)
1362 			list_for_each_entry(ext_prop, &d->ext_prop, entry) {
1363 				/* 4kB minus header length */
1364 				n = buf - start;
1365 				if (n >= 4086)
1366 					return 0;
1367 
1368 				count = ext_prop->data_len +
1369 					ext_prop->name_len + 14;
1370 				if (count > 4086 - n)
1371 					return -EINVAL;
1372 				usb_ext_prop_put_size(buf, count);
1373 				usb_ext_prop_put_type(buf, ext_prop->type);
1374 				ret = usb_ext_prop_put_name(buf, ext_prop->name,
1375 							    ext_prop->name_len);
1376 				if (ret < 0)
1377 					return ret;
1378 				switch (ext_prop->type) {
1379 				case USB_EXT_PROP_UNICODE:
1380 				case USB_EXT_PROP_UNICODE_ENV:
1381 				case USB_EXT_PROP_UNICODE_LINK:
1382 					usb_ext_prop_put_unicode(buf, ret,
1383 							 ext_prop->data,
1384 							 ext_prop->data_len);
1385 					break;
1386 				case USB_EXT_PROP_BINARY:
1387 					usb_ext_prop_put_binary(buf, ret,
1388 							ext_prop->data,
1389 							ext_prop->data_len);
1390 					break;
1391 				case USB_EXT_PROP_LE32:
1392 					/* not implemented */
1393 				case USB_EXT_PROP_BE32:
1394 					/* not implemented */
1395 				default:
1396 					return -EINVAL;
1397 				}
1398 				buf += count;
1399 			}
1400 	}
1401 
1402 	return 0;
1403 }
1404 
1405 /*
1406  * The setup() callback implements all the ep0 functionality that's
1407  * not handled lower down, in hardware or the hardware driver(like
1408  * device and endpoint feature flags, and their status).  It's all
1409  * housekeeping for the gadget function we're implementing.  Most of
1410  * the work is in config and function specific setup.
1411  */
1412 int
1413 composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1414 {
1415 	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
1416 	struct usb_request		*req = cdev->req;
1417 	int				value = -EOPNOTSUPP;
1418 	int				status = 0;
1419 	u16				w_index = le16_to_cpu(ctrl->wIndex);
1420 	u8				intf = w_index & 0xFF;
1421 	u16				w_value = le16_to_cpu(ctrl->wValue);
1422 	u16				w_length = le16_to_cpu(ctrl->wLength);
1423 	struct usb_function		*f = NULL;
1424 	u8				endp;
1425 
1426 	/* partial re-init of the response message; the function or the
1427 	 * gadget might need to intercept e.g. a control-OUT completion
1428 	 * when we delegate to it.
1429 	 */
1430 	req->zero = 0;
1431 	req->complete = composite_setup_complete;
1432 	req->length = 0;
1433 	gadget->ep0->driver_data = cdev;
1434 
1435 	switch (ctrl->bRequest) {
1436 
1437 	/* we handle all standard USB descriptors */
1438 	case USB_REQ_GET_DESCRIPTOR:
1439 		if (ctrl->bRequestType != USB_DIR_IN)
1440 			goto unknown;
1441 		switch (w_value >> 8) {
1442 
1443 		case USB_DT_DEVICE:
1444 			cdev->desc.bNumConfigurations =
1445 				count_configs(cdev, USB_DT_DEVICE);
1446 			cdev->desc.bMaxPacketSize0 =
1447 				cdev->gadget->ep0->maxpacket;
1448 			if (gadget_is_superspeed(gadget)) {
1449 				if (gadget->speed >= USB_SPEED_SUPER) {
1450 					cdev->desc.bcdUSB = cpu_to_le16(0x0300);
1451 					cdev->desc.bMaxPacketSize0 = 9;
1452 				} else {
1453 					cdev->desc.bcdUSB = cpu_to_le16(0x0210);
1454 				}
1455 			}
1456 
1457 			value = min(w_length, (u16) sizeof cdev->desc);
1458 			memcpy(req->buf, &cdev->desc, value);
1459 			break;
1460 		case USB_DT_DEVICE_QUALIFIER:
1461 			if (!gadget_is_dualspeed(gadget) ||
1462 			    gadget->speed >= USB_SPEED_SUPER)
1463 				break;
1464 			device_qual(cdev);
1465 			value = min_t(int, w_length,
1466 				sizeof(struct usb_qualifier_descriptor));
1467 			break;
1468 		case USB_DT_OTHER_SPEED_CONFIG:
1469 			if (!gadget_is_dualspeed(gadget) ||
1470 			    gadget->speed >= USB_SPEED_SUPER)
1471 				break;
1472 			/* FALLTHROUGH */
1473 		case USB_DT_CONFIG:
1474 			value = config_desc(cdev, w_value);
1475 			if (value >= 0)
1476 				value = min(w_length, (u16) value);
1477 			break;
1478 		case USB_DT_STRING:
1479 			value = get_string(cdev, req->buf,
1480 					w_index, w_value & 0xff);
1481 			if (value >= 0)
1482 				value = min(w_length, (u16) value);
1483 			break;
1484 		case USB_DT_BOS:
1485 			if (gadget_is_superspeed(gadget)) {
1486 				value = bos_desc(cdev);
1487 				value = min(w_length, (u16) value);
1488 			}
1489 			break;
1490 		}
1491 		break;
1492 
1493 	/* any number of configs can work */
1494 	case USB_REQ_SET_CONFIGURATION:
1495 		if (ctrl->bRequestType != 0)
1496 			goto unknown;
1497 		if (gadget_is_otg(gadget)) {
1498 			if (gadget->a_hnp_support)
1499 				DBG(cdev, "HNP available\n");
1500 			else if (gadget->a_alt_hnp_support)
1501 				DBG(cdev, "HNP on another port\n");
1502 			else
1503 				VDBG(cdev, "HNP inactive\n");
1504 		}
1505 		spin_lock(&cdev->lock);
1506 		value = set_config(cdev, ctrl, w_value);
1507 		spin_unlock(&cdev->lock);
1508 		break;
1509 	case USB_REQ_GET_CONFIGURATION:
1510 		if (ctrl->bRequestType != USB_DIR_IN)
1511 			goto unknown;
1512 		if (cdev->config)
1513 			*(u8 *)req->buf = cdev->config->bConfigurationValue;
1514 		else
1515 			*(u8 *)req->buf = 0;
1516 		value = min(w_length, (u16) 1);
1517 		break;
1518 
1519 	/* function drivers must handle get/set altsetting; if there's
1520 	 * no get() method, we know only altsetting zero works.
1521 	 */
1522 	case USB_REQ_SET_INTERFACE:
1523 		if (ctrl->bRequestType != USB_RECIP_INTERFACE)
1524 			goto unknown;
1525 		if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1526 			break;
1527 		f = cdev->config->interface[intf];
1528 		if (!f)
1529 			break;
1530 		if (w_value && !f->set_alt)
1531 			break;
1532 		value = f->set_alt(f, w_index, w_value);
1533 		if (value == USB_GADGET_DELAYED_STATUS) {
1534 			DBG(cdev,
1535 			 "%s: interface %d (%s) requested delayed status\n",
1536 					__func__, intf, f->name);
1537 			cdev->delayed_status++;
1538 			DBG(cdev, "delayed_status count %d\n",
1539 					cdev->delayed_status);
1540 		}
1541 		break;
1542 	case USB_REQ_GET_INTERFACE:
1543 		if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
1544 			goto unknown;
1545 		if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1546 			break;
1547 		f = cdev->config->interface[intf];
1548 		if (!f)
1549 			break;
1550 		/* lots of interfaces only need altsetting zero... */
1551 		value = f->get_alt ? f->get_alt(f, w_index) : 0;
1552 		if (value < 0)
1553 			break;
1554 		*((u8 *)req->buf) = value;
1555 		value = min(w_length, (u16) 1);
1556 		break;
1557 
1558 	/*
1559 	 * USB 3.0 additions:
1560 	 * Function driver should handle get_status request. If such cb
1561 	 * wasn't supplied we respond with default value = 0
1562 	 * Note: function driver should supply such cb only for the first
1563 	 * interface of the function
1564 	 */
1565 	case USB_REQ_GET_STATUS:
1566 		if (!gadget_is_superspeed(gadget))
1567 			goto unknown;
1568 		if (ctrl->bRequestType != (USB_DIR_IN | USB_RECIP_INTERFACE))
1569 			goto unknown;
1570 		value = 2;	/* This is the length of the get_status reply */
1571 		put_unaligned_le16(0, req->buf);
1572 		if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1573 			break;
1574 		f = cdev->config->interface[intf];
1575 		if (!f)
1576 			break;
1577 		status = f->get_status ? f->get_status(f) : 0;
1578 		if (status < 0)
1579 			break;
1580 		put_unaligned_le16(status & 0x0000ffff, req->buf);
1581 		break;
1582 	/*
1583 	 * Function drivers should handle SetFeature/ClearFeature
1584 	 * (FUNCTION_SUSPEND) request. function_suspend cb should be supplied
1585 	 * only for the first interface of the function
1586 	 */
1587 	case USB_REQ_CLEAR_FEATURE:
1588 	case USB_REQ_SET_FEATURE:
1589 		if (!gadget_is_superspeed(gadget))
1590 			goto unknown;
1591 		if (ctrl->bRequestType != (USB_DIR_OUT | USB_RECIP_INTERFACE))
1592 			goto unknown;
1593 		switch (w_value) {
1594 		case USB_INTRF_FUNC_SUSPEND:
1595 			if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1596 				break;
1597 			f = cdev->config->interface[intf];
1598 			if (!f)
1599 				break;
1600 			value = 0;
1601 			if (f->func_suspend)
1602 				value = f->func_suspend(f, w_index >> 8);
1603 			if (value < 0) {
1604 				ERROR(cdev,
1605 				      "func_suspend() returned error %d\n",
1606 				      value);
1607 				value = 0;
1608 			}
1609 			break;
1610 		}
1611 		break;
1612 	default:
1613 unknown:
1614 		/*
1615 		 * OS descriptors handling
1616 		 */
1617 		if (cdev->use_os_string && cdev->os_desc_config &&
1618 		    (ctrl->bRequest & USB_TYPE_VENDOR) &&
1619 		    ctrl->bRequest == cdev->b_vendor_code) {
1620 			struct usb_request		*req;
1621 			struct usb_configuration	*os_desc_cfg;
1622 			u8				*buf;
1623 			int				interface;
1624 			int				count = 0;
1625 
1626 			req = cdev->os_desc_req;
1627 			req->complete = composite_setup_complete;
1628 			buf = req->buf;
1629 			os_desc_cfg = cdev->os_desc_config;
1630 			memset(buf, 0, w_length);
1631 			buf[5] = 0x01;
1632 			switch (ctrl->bRequestType & USB_RECIP_MASK) {
1633 			case USB_RECIP_DEVICE:
1634 				if (w_index != 0x4 || (w_value >> 8))
1635 					break;
1636 				buf[6] = w_index;
1637 				if (w_length == 0x10) {
1638 					/* Number of ext compat interfaces */
1639 					count = count_ext_compat(os_desc_cfg);
1640 					buf[8] = count;
1641 					count *= 24; /* 24 B/ext compat desc */
1642 					count += 16; /* header */
1643 					put_unaligned_le32(count, buf);
1644 					value = w_length;
1645 				} else {
1646 					/* "extended compatibility ID"s */
1647 					count = count_ext_compat(os_desc_cfg);
1648 					buf[8] = count;
1649 					count *= 24; /* 24 B/ext compat desc */
1650 					count += 16; /* header */
1651 					put_unaligned_le32(count, buf);
1652 					buf += 16;
1653 					fill_ext_compat(os_desc_cfg, buf);
1654 					value = w_length;
1655 				}
1656 				break;
1657 			case USB_RECIP_INTERFACE:
1658 				if (w_index != 0x5 || (w_value >> 8))
1659 					break;
1660 				interface = w_value & 0xFF;
1661 				buf[6] = w_index;
1662 				if (w_length == 0x0A) {
1663 					count = count_ext_prop(os_desc_cfg,
1664 						interface);
1665 					put_unaligned_le16(count, buf + 8);
1666 					count = len_ext_prop(os_desc_cfg,
1667 						interface);
1668 					put_unaligned_le32(count, buf);
1669 
1670 					value = w_length;
1671 				} else {
1672 					count = count_ext_prop(os_desc_cfg,
1673 						interface);
1674 					put_unaligned_le16(count, buf + 8);
1675 					count = len_ext_prop(os_desc_cfg,
1676 						interface);
1677 					put_unaligned_le32(count, buf);
1678 					buf += 10;
1679 					value = fill_ext_prop(os_desc_cfg,
1680 							      interface, buf);
1681 					if (value < 0)
1682 						return value;
1683 
1684 					value = w_length;
1685 				}
1686 				break;
1687 			}
1688 			req->length = value;
1689 			req->zero = value < w_length;
1690 			value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1691 			if (value < 0) {
1692 				DBG(cdev, "ep_queue --> %d\n", value);
1693 				req->status = 0;
1694 				composite_setup_complete(gadget->ep0, req);
1695 			}
1696 			return value;
1697 		}
1698 
1699 		VDBG(cdev,
1700 			"non-core control req%02x.%02x v%04x i%04x l%d\n",
1701 			ctrl->bRequestType, ctrl->bRequest,
1702 			w_value, w_index, w_length);
1703 
1704 		/* functions always handle their interfaces and endpoints...
1705 		 * punt other recipients (other, WUSB, ...) to the current
1706 		 * configuration code.
1707 		 *
1708 		 * REVISIT it could make sense to let the composite device
1709 		 * take such requests too, if that's ever needed:  to work
1710 		 * in config 0, etc.
1711 		 */
1712 		switch (ctrl->bRequestType & USB_RECIP_MASK) {
1713 		case USB_RECIP_INTERFACE:
1714 			if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1715 				break;
1716 			f = cdev->config->interface[intf];
1717 			break;
1718 
1719 		case USB_RECIP_ENDPOINT:
1720 			endp = ((w_index & 0x80) >> 3) | (w_index & 0x0f);
1721 			list_for_each_entry(f, &cdev->config->functions, list) {
1722 				if (test_bit(endp, f->endpoints))
1723 					break;
1724 			}
1725 			if (&f->list == &cdev->config->functions)
1726 				f = NULL;
1727 			break;
1728 		}
1729 
1730 		if (f && f->setup)
1731 			value = f->setup(f, ctrl);
1732 		else {
1733 			struct usb_configuration	*c;
1734 
1735 			c = cdev->config;
1736 			if (!c)
1737 				goto done;
1738 
1739 			/* try current config's setup */
1740 			if (c->setup) {
1741 				value = c->setup(c, ctrl);
1742 				goto done;
1743 			}
1744 
1745 			/* try the only function in the current config */
1746 			if (!list_is_singular(&c->functions))
1747 				goto done;
1748 			f = list_first_entry(&c->functions, struct usb_function,
1749 					     list);
1750 			if (f->setup)
1751 				value = f->setup(f, ctrl);
1752 		}
1753 
1754 		goto done;
1755 	}
1756 
1757 	/* respond with data transfer before status phase? */
1758 	if (value >= 0 && value != USB_GADGET_DELAYED_STATUS) {
1759 		req->length = value;
1760 		req->zero = value < w_length;
1761 		value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1762 		if (value < 0) {
1763 			DBG(cdev, "ep_queue --> %d\n", value);
1764 			req->status = 0;
1765 			composite_setup_complete(gadget->ep0, req);
1766 		}
1767 	} else if (value == USB_GADGET_DELAYED_STATUS && w_length != 0) {
1768 		WARN(cdev,
1769 			"%s: Delayed status not supported for w_length != 0",
1770 			__func__);
1771 	}
1772 
1773 done:
1774 	/* device either stalls (value < 0) or reports success */
1775 	return value;
1776 }
1777 
1778 void composite_disconnect(struct usb_gadget *gadget)
1779 {
1780 	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
1781 	unsigned long			flags;
1782 
1783 	/* REVISIT:  should we have config and device level
1784 	 * disconnect callbacks?
1785 	 */
1786 	spin_lock_irqsave(&cdev->lock, flags);
1787 	if (cdev->config)
1788 		reset_config(cdev);
1789 	if (cdev->driver->disconnect)
1790 		cdev->driver->disconnect(cdev);
1791 	spin_unlock_irqrestore(&cdev->lock, flags);
1792 }
1793 
1794 /*-------------------------------------------------------------------------*/
1795 
1796 static ssize_t suspended_show(struct device *dev, struct device_attribute *attr,
1797 			      char *buf)
1798 {
1799 	struct usb_gadget *gadget = dev_to_usb_gadget(dev);
1800 	struct usb_composite_dev *cdev = get_gadget_data(gadget);
1801 
1802 	return sprintf(buf, "%d\n", cdev->suspended);
1803 }
1804 static DEVICE_ATTR_RO(suspended);
1805 
1806 static void __composite_unbind(struct usb_gadget *gadget, bool unbind_driver)
1807 {
1808 	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
1809 
1810 	/* composite_disconnect() must already have been called
1811 	 * by the underlying peripheral controller driver!
1812 	 * so there's no i/o concurrency that could affect the
1813 	 * state protected by cdev->lock.
1814 	 */
1815 	WARN_ON(cdev->config);
1816 
1817 	while (!list_empty(&cdev->configs)) {
1818 		struct usb_configuration	*c;
1819 		c = list_first_entry(&cdev->configs,
1820 				struct usb_configuration, list);
1821 		remove_config(cdev, c);
1822 	}
1823 	if (cdev->driver->unbind && unbind_driver)
1824 		cdev->driver->unbind(cdev);
1825 
1826 	composite_dev_cleanup(cdev);
1827 
1828 	kfree(cdev->def_manufacturer);
1829 	kfree(cdev);
1830 	set_gadget_data(gadget, NULL);
1831 }
1832 
1833 static void composite_unbind(struct usb_gadget *gadget)
1834 {
1835 	__composite_unbind(gadget, true);
1836 }
1837 
1838 static void update_unchanged_dev_desc(struct usb_device_descriptor *new,
1839 		const struct usb_device_descriptor *old)
1840 {
1841 	__le16 idVendor;
1842 	__le16 idProduct;
1843 	__le16 bcdDevice;
1844 	u8 iSerialNumber;
1845 	u8 iManufacturer;
1846 	u8 iProduct;
1847 
1848 	/*
1849 	 * these variables may have been set in
1850 	 * usb_composite_overwrite_options()
1851 	 */
1852 	idVendor = new->idVendor;
1853 	idProduct = new->idProduct;
1854 	bcdDevice = new->bcdDevice;
1855 	iSerialNumber = new->iSerialNumber;
1856 	iManufacturer = new->iManufacturer;
1857 	iProduct = new->iProduct;
1858 
1859 	*new = *old;
1860 	if (idVendor)
1861 		new->idVendor = idVendor;
1862 	if (idProduct)
1863 		new->idProduct = idProduct;
1864 	if (bcdDevice)
1865 		new->bcdDevice = bcdDevice;
1866 	else
1867 		new->bcdDevice = cpu_to_le16(get_default_bcdDevice());
1868 	if (iSerialNumber)
1869 		new->iSerialNumber = iSerialNumber;
1870 	if (iManufacturer)
1871 		new->iManufacturer = iManufacturer;
1872 	if (iProduct)
1873 		new->iProduct = iProduct;
1874 }
1875 
1876 int composite_dev_prepare(struct usb_composite_driver *composite,
1877 		struct usb_composite_dev *cdev)
1878 {
1879 	struct usb_gadget *gadget = cdev->gadget;
1880 	int ret = -ENOMEM;
1881 
1882 	/* preallocate control response and buffer */
1883 	cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
1884 	if (!cdev->req)
1885 		return -ENOMEM;
1886 
1887 	cdev->req->buf = kmalloc(USB_COMP_EP0_BUFSIZ, GFP_KERNEL);
1888 	if (!cdev->req->buf)
1889 		goto fail;
1890 
1891 	ret = device_create_file(&gadget->dev, &dev_attr_suspended);
1892 	if (ret)
1893 		goto fail_dev;
1894 
1895 	cdev->req->complete = composite_setup_complete;
1896 	gadget->ep0->driver_data = cdev;
1897 
1898 	cdev->driver = composite;
1899 
1900 	/*
1901 	 * As per USB compliance update, a device that is actively drawing
1902 	 * more than 100mA from USB must report itself as bus-powered in
1903 	 * the GetStatus(DEVICE) call.
1904 	 */
1905 	if (CONFIG_USB_GADGET_VBUS_DRAW <= USB_SELF_POWER_VBUS_MAX_DRAW)
1906 		usb_gadget_set_selfpowered(gadget);
1907 
1908 	/* interface and string IDs start at zero via kzalloc.
1909 	 * we force endpoints to start unassigned; few controller
1910 	 * drivers will zero ep->driver_data.
1911 	 */
1912 	usb_ep_autoconfig_reset(gadget);
1913 	return 0;
1914 fail_dev:
1915 	kfree(cdev->req->buf);
1916 fail:
1917 	usb_ep_free_request(gadget->ep0, cdev->req);
1918 	cdev->req = NULL;
1919 	return ret;
1920 }
1921 
1922 int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
1923 				  struct usb_ep *ep0)
1924 {
1925 	int ret = 0;
1926 
1927 	cdev->os_desc_req = usb_ep_alloc_request(ep0, GFP_KERNEL);
1928 	if (!cdev->os_desc_req) {
1929 		ret = PTR_ERR(cdev->os_desc_req);
1930 		goto end;
1931 	}
1932 
1933 	/* OS feature descriptor length <= 4kB */
1934 	cdev->os_desc_req->buf = kmalloc(4096, GFP_KERNEL);
1935 	if (!cdev->os_desc_req->buf) {
1936 		ret = PTR_ERR(cdev->os_desc_req->buf);
1937 		kfree(cdev->os_desc_req);
1938 		goto end;
1939 	}
1940 	cdev->os_desc_req->complete = composite_setup_complete;
1941 end:
1942 	return ret;
1943 }
1944 
1945 void composite_dev_cleanup(struct usb_composite_dev *cdev)
1946 {
1947 	struct usb_gadget_string_container *uc, *tmp;
1948 
1949 	list_for_each_entry_safe(uc, tmp, &cdev->gstrings, list) {
1950 		list_del(&uc->list);
1951 		kfree(uc);
1952 	}
1953 	if (cdev->os_desc_req) {
1954 		kfree(cdev->os_desc_req->buf);
1955 		usb_ep_free_request(cdev->gadget->ep0, cdev->os_desc_req);
1956 	}
1957 	if (cdev->req) {
1958 		kfree(cdev->req->buf);
1959 		usb_ep_free_request(cdev->gadget->ep0, cdev->req);
1960 	}
1961 	cdev->next_string_id = 0;
1962 	device_remove_file(&cdev->gadget->dev, &dev_attr_suspended);
1963 }
1964 
1965 static int composite_bind(struct usb_gadget *gadget,
1966 		struct usb_gadget_driver *gdriver)
1967 {
1968 	struct usb_composite_dev	*cdev;
1969 	struct usb_composite_driver	*composite = to_cdriver(gdriver);
1970 	int				status = -ENOMEM;
1971 
1972 	cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
1973 	if (!cdev)
1974 		return status;
1975 
1976 	spin_lock_init(&cdev->lock);
1977 	cdev->gadget = gadget;
1978 	set_gadget_data(gadget, cdev);
1979 	INIT_LIST_HEAD(&cdev->configs);
1980 	INIT_LIST_HEAD(&cdev->gstrings);
1981 
1982 	status = composite_dev_prepare(composite, cdev);
1983 	if (status)
1984 		goto fail;
1985 
1986 	/* composite gadget needs to assign strings for whole device (like
1987 	 * serial number), register function drivers, potentially update
1988 	 * power state and consumption, etc
1989 	 */
1990 	status = composite->bind(cdev);
1991 	if (status < 0)
1992 		goto fail;
1993 
1994 	if (cdev->use_os_string) {
1995 		status = composite_os_desc_req_prepare(cdev, gadget->ep0);
1996 		if (status)
1997 			goto fail;
1998 	}
1999 
2000 	update_unchanged_dev_desc(&cdev->desc, composite->dev);
2001 
2002 	/* has userspace failed to provide a serial number? */
2003 	if (composite->needs_serial && !cdev->desc.iSerialNumber)
2004 		WARNING(cdev, "userspace failed to provide iSerialNumber\n");
2005 
2006 	INFO(cdev, "%s ready\n", composite->name);
2007 	return 0;
2008 
2009 fail:
2010 	__composite_unbind(gadget, false);
2011 	return status;
2012 }
2013 
2014 /*-------------------------------------------------------------------------*/
2015 
2016 static void
2017 composite_suspend(struct usb_gadget *gadget)
2018 {
2019 	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
2020 	struct usb_function		*f;
2021 
2022 	/* REVISIT:  should we have config level
2023 	 * suspend/resume callbacks?
2024 	 */
2025 	DBG(cdev, "suspend\n");
2026 	if (cdev->config) {
2027 		list_for_each_entry(f, &cdev->config->functions, list) {
2028 			if (f->suspend)
2029 				f->suspend(f);
2030 		}
2031 	}
2032 	if (cdev->driver->suspend)
2033 		cdev->driver->suspend(cdev);
2034 
2035 	cdev->suspended = 1;
2036 
2037 	usb_gadget_vbus_draw(gadget, 2);
2038 }
2039 
2040 static void
2041 composite_resume(struct usb_gadget *gadget)
2042 {
2043 	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
2044 	struct usb_function		*f;
2045 	u16				maxpower;
2046 
2047 	/* REVISIT:  should we have config level
2048 	 * suspend/resume callbacks?
2049 	 */
2050 	DBG(cdev, "resume\n");
2051 	if (cdev->driver->resume)
2052 		cdev->driver->resume(cdev);
2053 	if (cdev->config) {
2054 		list_for_each_entry(f, &cdev->config->functions, list) {
2055 			if (f->resume)
2056 				f->resume(f);
2057 		}
2058 
2059 		maxpower = cdev->config->MaxPower;
2060 
2061 		usb_gadget_vbus_draw(gadget, maxpower ?
2062 			maxpower : CONFIG_USB_GADGET_VBUS_DRAW);
2063 	}
2064 
2065 	cdev->suspended = 0;
2066 }
2067 
2068 /*-------------------------------------------------------------------------*/
2069 
2070 static const struct usb_gadget_driver composite_driver_template = {
2071 	.bind		= composite_bind,
2072 	.unbind		= composite_unbind,
2073 
2074 	.setup		= composite_setup,
2075 	.reset		= composite_disconnect,
2076 	.disconnect	= composite_disconnect,
2077 
2078 	.suspend	= composite_suspend,
2079 	.resume		= composite_resume,
2080 
2081 	.driver	= {
2082 		.owner		= THIS_MODULE,
2083 	},
2084 };
2085 
2086 /**
2087  * usb_composite_probe() - register a composite driver
2088  * @driver: the driver to register
2089  *
2090  * Context: single threaded during gadget setup
2091  *
2092  * This function is used to register drivers using the composite driver
2093  * framework.  The return value is zero, or a negative errno value.
2094  * Those values normally come from the driver's @bind method, which does
2095  * all the work of setting up the driver to match the hardware.
2096  *
2097  * On successful return, the gadget is ready to respond to requests from
2098  * the host, unless one of its components invokes usb_gadget_disconnect()
2099  * while it was binding.  That would usually be done in order to wait for
2100  * some userspace participation.
2101  */
2102 int usb_composite_probe(struct usb_composite_driver *driver)
2103 {
2104 	struct usb_gadget_driver *gadget_driver;
2105 
2106 	if (!driver || !driver->dev || !driver->bind)
2107 		return -EINVAL;
2108 
2109 	if (!driver->name)
2110 		driver->name = "composite";
2111 
2112 	driver->gadget_driver = composite_driver_template;
2113 	gadget_driver = &driver->gadget_driver;
2114 
2115 	gadget_driver->function =  (char *) driver->name;
2116 	gadget_driver->driver.name = driver->name;
2117 	gadget_driver->max_speed = driver->max_speed;
2118 
2119 	return usb_gadget_probe_driver(gadget_driver);
2120 }
2121 EXPORT_SYMBOL_GPL(usb_composite_probe);
2122 
2123 /**
2124  * usb_composite_unregister() - unregister a composite driver
2125  * @driver: the driver to unregister
2126  *
2127  * This function is used to unregister drivers using the composite
2128  * driver framework.
2129  */
2130 void usb_composite_unregister(struct usb_composite_driver *driver)
2131 {
2132 	usb_gadget_unregister_driver(&driver->gadget_driver);
2133 }
2134 EXPORT_SYMBOL_GPL(usb_composite_unregister);
2135 
2136 /**
2137  * usb_composite_setup_continue() - Continue with the control transfer
2138  * @cdev: the composite device who's control transfer was kept waiting
2139  *
2140  * This function must be called by the USB function driver to continue
2141  * with the control transfer's data/status stage in case it had requested to
2142  * delay the data/status stages. A USB function's setup handler (e.g. set_alt())
2143  * can request the composite framework to delay the setup request's data/status
2144  * stages by returning USB_GADGET_DELAYED_STATUS.
2145  */
2146 void usb_composite_setup_continue(struct usb_composite_dev *cdev)
2147 {
2148 	int			value;
2149 	struct usb_request	*req = cdev->req;
2150 	unsigned long		flags;
2151 
2152 	DBG(cdev, "%s\n", __func__);
2153 	spin_lock_irqsave(&cdev->lock, flags);
2154 
2155 	if (cdev->delayed_status == 0) {
2156 		WARN(cdev, "%s: Unexpected call\n", __func__);
2157 
2158 	} else if (--cdev->delayed_status == 0) {
2159 		DBG(cdev, "%s: Completing delayed status\n", __func__);
2160 		req->length = 0;
2161 		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
2162 		if (value < 0) {
2163 			DBG(cdev, "ep_queue --> %d\n", value);
2164 			req->status = 0;
2165 			composite_setup_complete(cdev->gadget->ep0, req);
2166 		}
2167 	}
2168 
2169 	spin_unlock_irqrestore(&cdev->lock, flags);
2170 }
2171 EXPORT_SYMBOL_GPL(usb_composite_setup_continue);
2172 
2173 static char *composite_default_mfr(struct usb_gadget *gadget)
2174 {
2175 	char *mfr;
2176 	int len;
2177 
2178 	len = snprintf(NULL, 0, "%s %s with %s", init_utsname()->sysname,
2179 			init_utsname()->release, gadget->name);
2180 	len++;
2181 	mfr = kmalloc(len, GFP_KERNEL);
2182 	if (!mfr)
2183 		return NULL;
2184 	snprintf(mfr, len, "%s %s with %s", init_utsname()->sysname,
2185 			init_utsname()->release, gadget->name);
2186 	return mfr;
2187 }
2188 
2189 void usb_composite_overwrite_options(struct usb_composite_dev *cdev,
2190 		struct usb_composite_overwrite *covr)
2191 {
2192 	struct usb_device_descriptor	*desc = &cdev->desc;
2193 	struct usb_gadget_strings	*gstr = cdev->driver->strings[0];
2194 	struct usb_string		*dev_str = gstr->strings;
2195 
2196 	if (covr->idVendor)
2197 		desc->idVendor = cpu_to_le16(covr->idVendor);
2198 
2199 	if (covr->idProduct)
2200 		desc->idProduct = cpu_to_le16(covr->idProduct);
2201 
2202 	if (covr->bcdDevice)
2203 		desc->bcdDevice = cpu_to_le16(covr->bcdDevice);
2204 
2205 	if (covr->serial_number) {
2206 		desc->iSerialNumber = dev_str[USB_GADGET_SERIAL_IDX].id;
2207 		dev_str[USB_GADGET_SERIAL_IDX].s = covr->serial_number;
2208 	}
2209 	if (covr->manufacturer) {
2210 		desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
2211 		dev_str[USB_GADGET_MANUFACTURER_IDX].s = covr->manufacturer;
2212 
2213 	} else if (!strlen(dev_str[USB_GADGET_MANUFACTURER_IDX].s)) {
2214 		desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
2215 		cdev->def_manufacturer = composite_default_mfr(cdev->gadget);
2216 		dev_str[USB_GADGET_MANUFACTURER_IDX].s = cdev->def_manufacturer;
2217 	}
2218 
2219 	if (covr->product) {
2220 		desc->iProduct = dev_str[USB_GADGET_PRODUCT_IDX].id;
2221 		dev_str[USB_GADGET_PRODUCT_IDX].s = covr->product;
2222 	}
2223 }
2224 EXPORT_SYMBOL_GPL(usb_composite_overwrite_options);
2225 
2226 MODULE_LICENSE("GPL");
2227 MODULE_AUTHOR("David Brownell");
2228