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 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program; if not, write to the Free Software
  18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21/* #define VERBOSE_DEBUG */
  22
  23#include <linux/kallsyms.h>
  24#include <linux/kernel.h>
  25#include <linux/slab.h>
 
  26#include <linux/device.h>
  27#include <linux/utsname.h>
  28
  29#include <linux/usb/composite.h>
 
  30#include <asm/unaligned.h>
  31
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  32/*
  33 * The code in this file is utility code, used to build a gadget driver
  34 * from one or more "function" drivers, one or more "configuration"
  35 * objects, and a "usb_composite_driver" by gluing them together along
  36 * with the relevant device-wide data.
  37 */
  38
  39/* big enough to hold our biggest descriptor */
  40#define USB_BUFSIZ	1024
  41
  42static struct usb_composite_driver *composite;
  43static int (*composite_gadget_bind)(struct usb_composite_dev *cdev);
  44
  45/* Some systems will need runtime overrides for the  product identifiers
  46 * published in the device descriptor, either numbers or strings or both.
  47 * String parameters are in UTF-8 (superset of ASCII's 7 bit characters).
 
 
 
  48 */
 
 
 
 
 
  49
  50static ushort idVendor;
  51module_param(idVendor, ushort, 0);
  52MODULE_PARM_DESC(idVendor, "USB Vendor ID");
  53
  54static ushort idProduct;
  55module_param(idProduct, ushort, 0);
  56MODULE_PARM_DESC(idProduct, "USB Product ID");
  57
  58static ushort bcdDevice;
  59module_param(bcdDevice, ushort, 0);
  60MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
  61
  62static char *iManufacturer;
  63module_param(iManufacturer, charp, 0);
  64MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
  65
  66static char *iProduct;
  67module_param(iProduct, charp, 0);
  68MODULE_PARM_DESC(iProduct, "USB Product string");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  69
  70static char *iSerialNumber;
  71module_param(iSerialNumber, charp, 0);
  72MODULE_PARM_DESC(iSerialNumber, "SerialNumber string");
 
  73
  74static char composite_manufacturer[50];
 
  75
  76/*-------------------------------------------------------------------------*/
  77/**
  78 * next_ep_desc() - advance to the next EP descriptor
  79 * @t: currect pointer within descriptor array
  80 *
  81 * Return: next EP descriptor or NULL
  82 *
  83 * Iterate over @t until either EP descriptor found or
  84 * NULL (that indicates end of list) encountered
  85 */
  86static struct usb_descriptor_header**
  87next_ep_desc(struct usb_descriptor_header **t)
  88{
  89	for (; *t; t++) {
  90		if ((*t)->bDescriptorType == USB_DT_ENDPOINT)
  91			return t;
  92	}
  93	return NULL;
  94}
  95
  96/*
  97 * for_each_ep_desc()- iterate over endpoint descriptors in the
  98 *		descriptors list
  99 * @start:	pointer within descriptor array.
 100 * @ep_desc:	endpoint descriptor to use as the loop cursor
 101 */
 102#define for_each_ep_desc(start, ep_desc) \
 103	for (ep_desc = next_ep_desc(start); \
 104	      ep_desc; ep_desc = next_ep_desc(ep_desc+1))
 105
 106/**
 107 * config_ep_by_speed() - configures the given endpoint
 108 * according to gadget speed.
 109 * @g: pointer to the gadget
 110 * @f: usb function
 111 * @_ep: the endpoint to configure
 112 *
 113 * Return: error code, 0 on success
 114 *
 115 * This function chooses the right descriptors for a given
 116 * endpoint according to gadget speed and saves it in the
 117 * endpoint desc field. If the endpoint already has a descriptor
 118 * assigned to it - overwrites it with currently corresponding
 119 * descriptor. The endpoint maxpacket field is updated according
 120 * to the chosen descriptor.
 121 * Note: the supplied function should hold all the descriptors
 122 * for supported speeds
 123 */
 124int config_ep_by_speed(struct usb_gadget *g,
 125			struct usb_function *f,
 126			struct usb_ep *_ep)
 127{
 128	struct usb_endpoint_descriptor *chosen_desc = NULL;
 129	struct usb_descriptor_header **speed_desc = NULL;
 130
 131	struct usb_ss_ep_comp_descriptor *comp_desc = NULL;
 132	int want_comp_desc = 0;
 133
 134	struct usb_descriptor_header **d_spd; /* cursor for speed desc */
 135
 136	if (!g || !f || !_ep)
 137		return -EIO;
 138
 139	/* select desired speed */
 140	switch (g->speed) {
 
 
 
 
 
 
 
 141	case USB_SPEED_SUPER:
 142		if (gadget_is_superspeed(g)) {
 143			speed_desc = f->ss_descriptors;
 144			want_comp_desc = 1;
 145			break;
 146		}
 147		/* else: Fall trough */
 148	case USB_SPEED_HIGH:
 149		if (gadget_is_dualspeed(g)) {
 150			speed_desc = f->hs_descriptors;
 151			break;
 152		}
 153		/* else: fall through */
 154	default:
 155		speed_desc = f->descriptors;
 156	}
 157	/* find descriptors */
 158	for_each_ep_desc(speed_desc, d_spd) {
 159		chosen_desc = (struct usb_endpoint_descriptor *)*d_spd;
 160		if (chosen_desc->bEndpointAddress == _ep->address)
 161			goto ep_found;
 162	}
 163	return -EIO;
 164
 165ep_found:
 166	/* commit results */
 167	_ep->maxpacket = le16_to_cpu(chosen_desc->wMaxPacketSize);
 168	_ep->desc = chosen_desc;
 169	_ep->comp_desc = NULL;
 170	_ep->maxburst = 0;
 171	_ep->mult = 0;
 
 
 
 
 
 172	if (!want_comp_desc)
 173		return 0;
 174
 175	/*
 176	 * Companion descriptor should follow EP descriptor
 177	 * USB 3.0 spec, #9.6.7
 178	 */
 179	comp_desc = (struct usb_ss_ep_comp_descriptor *)*(++d_spd);
 180	if (!comp_desc ||
 181	    (comp_desc->bDescriptorType != USB_DT_SS_ENDPOINT_COMP))
 182		return -EIO;
 183	_ep->comp_desc = comp_desc;
 184	if (g->speed == USB_SPEED_SUPER) {
 185		switch (usb_endpoint_type(_ep->desc)) {
 186		case USB_ENDPOINT_XFER_BULK:
 187		case USB_ENDPOINT_XFER_INT:
 188			_ep->maxburst = comp_desc->bMaxBurst;
 189			break;
 190		case USB_ENDPOINT_XFER_ISOC:
 191			/* mult: bits 1:0 of bmAttributes */
 192			_ep->mult = comp_desc->bmAttributes & 0x3;
 
 
 
 
 193			break;
 194		default:
 195			/* Do nothing for control endpoints */
 
 
 
 
 
 
 196			break;
 197		}
 198	}
 199	return 0;
 200}
 
 201
 202/**
 203 * usb_add_function() - add a function to a configuration
 204 * @config: the configuration
 205 * @function: the function being added
 206 * Context: single threaded during gadget setup
 207 *
 208 * After initialization, each configuration must have one or more
 209 * functions added to it.  Adding a function involves calling its @bind()
 210 * method to allocate resources such as interface and string identifiers
 211 * and endpoints.
 212 *
 213 * This function returns the value of the function's bind(), which is
 214 * zero for success else a negative errno value.
 215 */
 216int usb_add_function(struct usb_configuration *config,
 217		struct usb_function *function)
 218{
 219	int	value = -EINVAL;
 220
 221	DBG(config->cdev, "adding '%s'/%p to config '%s'/%p\n",
 222			function->name, function,
 223			config->label, config);
 224
 225	if (!function->set_alt || !function->disable)
 226		goto done;
 227
 228	function->config = config;
 229	list_add_tail(&function->list, &config->functions);
 230
 
 
 
 
 
 
 231	/* REVISIT *require* function->bind? */
 232	if (function->bind) {
 233		value = function->bind(config, function);
 234		if (value < 0) {
 235			list_del(&function->list);
 236			function->config = NULL;
 237		}
 238	} else
 239		value = 0;
 240
 241	/* We allow configurations that don't work at both speeds.
 242	 * If we run into a lowspeed Linux system, treat it the same
 243	 * as full speed ... it's the function drivers that will need
 244	 * to avoid bulk and ISO transfers.
 245	 */
 246	if (!config->fullspeed && function->descriptors)
 247		config->fullspeed = true;
 248	if (!config->highspeed && function->hs_descriptors)
 249		config->highspeed = true;
 250	if (!config->superspeed && function->ss_descriptors)
 251		config->superspeed = true;
 
 
 252
 253done:
 254	if (value)
 255		DBG(config->cdev, "adding '%s'/%p --> %d\n",
 256				function->name, function, value);
 257	return value;
 258}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 259
 260/**
 261 * usb_function_deactivate - prevent function and gadget enumeration
 262 * @function: the function that isn't yet ready to respond
 263 *
 264 * Blocks response of the gadget driver to host enumeration by
 265 * preventing the data line pullup from being activated.  This is
 266 * normally called during @bind() processing to change from the
 267 * initial "ready to respond" state, or when a required resource
 268 * becomes available.
 269 *
 270 * For example, drivers that serve as a passthrough to a userspace
 271 * daemon can block enumeration unless that daemon (such as an OBEX,
 272 * MTP, or print server) is ready to handle host requests.
 273 *
 274 * Not all systems support software control of their USB peripheral
 275 * data pullups.
 276 *
 277 * Returns zero on success, else negative errno.
 278 */
 279int usb_function_deactivate(struct usb_function *function)
 280{
 281	struct usb_composite_dev	*cdev = function->config->cdev;
 282	unsigned long			flags;
 283	int				status = 0;
 284
 285	spin_lock_irqsave(&cdev->lock, flags);
 286
 287	if (cdev->deactivations == 0)
 288		status = usb_gadget_disconnect(cdev->gadget);
 289	if (status == 0)
 290		cdev->deactivations++;
 291
 292	spin_unlock_irqrestore(&cdev->lock, flags);
 293	return status;
 294}
 
 295
 296/**
 297 * usb_function_activate - allow function and gadget enumeration
 298 * @function: function on which usb_function_activate() was called
 299 *
 300 * Reverses effect of usb_function_deactivate().  If no more functions
 301 * are delaying their activation, the gadget driver will respond to
 302 * host enumeration procedures.
 303 *
 304 * Returns zero on success, else negative errno.
 305 */
 306int usb_function_activate(struct usb_function *function)
 307{
 308	struct usb_composite_dev	*cdev = function->config->cdev;
 
 309	int				status = 0;
 310
 311	spin_lock(&cdev->lock);
 312
 313	if (WARN_ON(cdev->deactivations == 0))
 314		status = -EINVAL;
 315	else {
 316		cdev->deactivations--;
 317		if (cdev->deactivations == 0)
 318			status = usb_gadget_connect(cdev->gadget);
 319	}
 320
 321	spin_unlock(&cdev->lock);
 322	return status;
 323}
 
 324
 325/**
 326 * usb_interface_id() - allocate an unused interface ID
 327 * @config: configuration associated with the interface
 328 * @function: function handling the interface
 329 * Context: single threaded during gadget setup
 330 *
 331 * usb_interface_id() is called from usb_function.bind() callbacks to
 332 * allocate new interface IDs.  The function driver will then store that
 333 * ID in interface, association, CDC union, and other descriptors.  It
 334 * will also handle any control requests targeted at that interface,
 335 * particularly changing its altsetting via set_alt().  There may
 336 * also be class-specific or vendor-specific requests to handle.
 337 *
 338 * All interface identifier should be allocated using this routine, to
 339 * ensure that for example different functions don't wrongly assign
 340 * different meanings to the same identifier.  Note that since interface
 341 * identifiers are configuration-specific, functions used in more than
 342 * one configuration (or more than once in a given configuration) need
 343 * multiple versions of the relevant descriptors.
 344 *
 345 * Returns the interface ID which was allocated; or -ENODEV if no
 346 * more interface IDs can be allocated.
 347 */
 348int usb_interface_id(struct usb_configuration *config,
 349		struct usb_function *function)
 350{
 351	unsigned id = config->next_interface_id;
 352
 353	if (id < MAX_CONFIG_INTERFACES) {
 354		config->interface[id] = function;
 355		config->next_interface_id = id + 1;
 356		return id;
 357	}
 358	return -ENODEV;
 359}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 360
 361static int config_buf(struct usb_configuration *config,
 362		enum usb_device_speed speed, void *buf, u8 type)
 363{
 364	struct usb_config_descriptor	*c = buf;
 365	void				*next = buf + USB_DT_CONFIG_SIZE;
 366	int				len = USB_BUFSIZ - USB_DT_CONFIG_SIZE;
 367	struct usb_function		*f;
 368	int				status;
 369
 
 370	/* write the config descriptor */
 371	c = buf;
 372	c->bLength = USB_DT_CONFIG_SIZE;
 373	c->bDescriptorType = type;
 374	/* wTotalLength is written later */
 375	c->bNumInterfaces = config->next_interface_id;
 376	c->bConfigurationValue = config->bConfigurationValue;
 377	c->iConfiguration = config->iConfiguration;
 378	c->bmAttributes = USB_CONFIG_ATT_ONE | config->bmAttributes;
 379	c->bMaxPower = config->bMaxPower ? : (CONFIG_USB_GADGET_VBUS_DRAW / 2);
 380
 381	/* There may be e.g. OTG descriptors */
 382	if (config->descriptors) {
 383		status = usb_descriptor_fillbuf(next, len,
 384				config->descriptors);
 385		if (status < 0)
 386			return status;
 387		len -= status;
 388		next += status;
 389	}
 390
 391	/* add each function's descriptors */
 392	list_for_each_entry(f, &config->functions, list) {
 393		struct usb_descriptor_header **descriptors;
 394
 395		switch (speed) {
 396		case USB_SPEED_SUPER:
 397			descriptors = f->ss_descriptors;
 398			break;
 399		case USB_SPEED_HIGH:
 400			descriptors = f->hs_descriptors;
 401			break;
 402		default:
 403			descriptors = f->descriptors;
 404		}
 405
 406		if (!descriptors)
 407			continue;
 408		status = usb_descriptor_fillbuf(next, len,
 409			(const struct usb_descriptor_header **) descriptors);
 410		if (status < 0)
 411			return status;
 412		len -= status;
 413		next += status;
 414	}
 415
 416	len = next - buf;
 417	c->wTotalLength = cpu_to_le16(len);
 418	return len;
 419}
 420
 421static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
 422{
 423	struct usb_gadget		*gadget = cdev->gadget;
 424	struct usb_configuration	*c;
 
 425	u8				type = w_value >> 8;
 426	enum usb_device_speed		speed = USB_SPEED_UNKNOWN;
 427
 428	if (gadget->speed == USB_SPEED_SUPER)
 429		speed = gadget->speed;
 430	else if (gadget_is_dualspeed(gadget)) {
 431		int	hs = 0;
 432		if (gadget->speed == USB_SPEED_HIGH)
 433			hs = 1;
 434		if (type == USB_DT_OTHER_SPEED_CONFIG)
 435			hs = !hs;
 436		if (hs)
 437			speed = USB_SPEED_HIGH;
 438
 439	}
 440
 441	/* This is a lookup by config *INDEX* */
 442	w_value &= 0xff;
 443	list_for_each_entry(c, &cdev->configs, list) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 444		/* ignore configs that won't work at this speed */
 445		switch (speed) {
 
 
 
 
 446		case USB_SPEED_SUPER:
 447			if (!c->superspeed)
 448				continue;
 449			break;
 450		case USB_SPEED_HIGH:
 451			if (!c->highspeed)
 452				continue;
 453			break;
 454		default:
 455			if (!c->fullspeed)
 456				continue;
 457		}
 458
 459		if (w_value == 0)
 460			return config_buf(c, speed, cdev->req->buf, type);
 461		w_value--;
 462	}
 463	return -EINVAL;
 464}
 465
 466static int count_configs(struct usb_composite_dev *cdev, unsigned type)
 467{
 468	struct usb_gadget		*gadget = cdev->gadget;
 469	struct usb_configuration	*c;
 470	unsigned			count = 0;
 471	int				hs = 0;
 472	int				ss = 0;
 
 473
 474	if (gadget_is_dualspeed(gadget)) {
 475		if (gadget->speed == USB_SPEED_HIGH)
 476			hs = 1;
 477		if (gadget->speed == USB_SPEED_SUPER)
 478			ss = 1;
 
 
 479		if (type == USB_DT_DEVICE_QUALIFIER)
 480			hs = !hs;
 481	}
 482	list_for_each_entry(c, &cdev->configs, list) {
 483		/* ignore configs that won't work at this speed */
 484		if (ss) {
 
 
 
 485			if (!c->superspeed)
 486				continue;
 487		} else if (hs) {
 488			if (!c->highspeed)
 489				continue;
 490		} else {
 491			if (!c->fullspeed)
 492				continue;
 493		}
 494		count++;
 495	}
 496	return count;
 497}
 498
 499/**
 500 * bos_desc() - prepares the BOS descriptor.
 501 * @cdev: pointer to usb_composite device to generate the bos
 502 *	descriptor for
 503 *
 504 * This function generates the BOS (Binary Device Object)
 505 * descriptor and its device capabilities descriptors. The BOS
 506 * descriptor should be supported by a SuperSpeed device.
 507 */
 508static int bos_desc(struct usb_composite_dev *cdev)
 509{
 510	struct usb_ext_cap_descriptor	*usb_ext;
 511	struct usb_ss_cap_descriptor	*ss_cap;
 512	struct usb_dcd_config_params	dcd_config_params;
 513	struct usb_bos_descriptor	*bos = cdev->req->buf;
 514
 515	bos->bLength = USB_DT_BOS_SIZE;
 516	bos->bDescriptorType = USB_DT_BOS;
 517
 518	bos->wTotalLength = cpu_to_le16(USB_DT_BOS_SIZE);
 519	bos->bNumDeviceCaps = 0;
 520
 521	/*
 522	 * A SuperSpeed device shall include the USB2.0 extension descriptor
 523	 * and shall support LPM when operating in USB2.0 HS mode.
 524	 */
 525	usb_ext = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
 526	bos->bNumDeviceCaps++;
 527	le16_add_cpu(&bos->wTotalLength, USB_DT_USB_EXT_CAP_SIZE);
 528	usb_ext->bLength = USB_DT_USB_EXT_CAP_SIZE;
 529	usb_ext->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
 530	usb_ext->bDevCapabilityType = USB_CAP_TYPE_EXT;
 531	usb_ext->bmAttributes = cpu_to_le32(USB_LPM_SUPPORT);
 532
 533	/*
 534	 * The Superspeed USB Capability descriptor shall be implemented by all
 535	 * SuperSpeed devices.
 536	 */
 537	ss_cap = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
 538	bos->bNumDeviceCaps++;
 539	le16_add_cpu(&bos->wTotalLength, USB_DT_USB_SS_CAP_SIZE);
 540	ss_cap->bLength = USB_DT_USB_SS_CAP_SIZE;
 541	ss_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
 542	ss_cap->bDevCapabilityType = USB_SS_CAP_TYPE;
 543	ss_cap->bmAttributes = 0; /* LTM is not supported yet */
 544	ss_cap->wSpeedSupported = cpu_to_le16(USB_LOW_SPEED_OPERATION |
 545				USB_FULL_SPEED_OPERATION |
 546				USB_HIGH_SPEED_OPERATION |
 547				USB_5GBPS_OPERATION);
 548	ss_cap->bFunctionalitySupport = USB_LOW_SPEED_OPERATION;
 549
 550	/* Get Controller configuration */
 551	if (cdev->gadget->ops->get_config_params)
 552		cdev->gadget->ops->get_config_params(&dcd_config_params);
 553	else {
 554		dcd_config_params.bU1devExitLat = USB_DEFULT_U1_DEV_EXIT_LAT;
 555		dcd_config_params.bU2DevExitLat =
 556			cpu_to_le16(USB_DEFULT_U2_DEV_EXIT_LAT);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 557	}
 558	ss_cap->bU1devExitLat = dcd_config_params.bU1devExitLat;
 559	ss_cap->bU2DevExitLat = dcd_config_params.bU2DevExitLat;
 560
 561	return le16_to_cpu(bos->wTotalLength);
 562}
 563
 564static void device_qual(struct usb_composite_dev *cdev)
 565{
 566	struct usb_qualifier_descriptor	*qual = cdev->req->buf;
 567
 568	qual->bLength = sizeof(*qual);
 569	qual->bDescriptorType = USB_DT_DEVICE_QUALIFIER;
 570	/* POLICY: same bcdUSB and device type info at both speeds */
 571	qual->bcdUSB = cdev->desc.bcdUSB;
 572	qual->bDeviceClass = cdev->desc.bDeviceClass;
 573	qual->bDeviceSubClass = cdev->desc.bDeviceSubClass;
 574	qual->bDeviceProtocol = cdev->desc.bDeviceProtocol;
 575	/* ASSUME same EP0 fifo size at both speeds */
 576	qual->bMaxPacketSize0 = cdev->gadget->ep0->maxpacket;
 577	qual->bNumConfigurations = count_configs(cdev, USB_DT_DEVICE_QUALIFIER);
 578	qual->bRESERVED = 0;
 579}
 580
 581/*-------------------------------------------------------------------------*/
 582
 583static void reset_config(struct usb_composite_dev *cdev)
 584{
 585	struct usb_function		*f;
 586
 587	DBG(cdev, "reset config\n");
 588
 589	list_for_each_entry(f, &cdev->config->functions, list) {
 590		if (f->disable)
 591			f->disable(f);
 592
 593		bitmap_zero(f->endpoints, 32);
 594	}
 595	cdev->config = NULL;
 
 596}
 597
 598static int set_config(struct usb_composite_dev *cdev,
 599		const struct usb_ctrlrequest *ctrl, unsigned number)
 600{
 601	struct usb_gadget	*gadget = cdev->gadget;
 602	struct usb_configuration *c = NULL;
 603	int			result = -EINVAL;
 604	unsigned		power = gadget_is_otg(gadget) ? 8 : 100;
 605	int			tmp;
 606
 607	if (number) {
 608		list_for_each_entry(c, &cdev->configs, list) {
 609			if (c->bConfigurationValue == number) {
 610				/*
 611				 * We disable the FDs of the previous
 612				 * configuration only if the new configuration
 613				 * is a valid one
 614				 */
 615				if (cdev->config)
 616					reset_config(cdev);
 617				result = 0;
 618				break;
 619			}
 620		}
 621		if (result < 0)
 622			goto done;
 623	} else { /* Zero configuration value - need to reset the config */
 624		if (cdev->config)
 625			reset_config(cdev);
 626		result = 0;
 627	}
 628
 629	INFO(cdev, "%s speed config #%d: %s\n",
 630		({ char *speed;
 631		switch (gadget->speed) {
 632		case USB_SPEED_LOW:
 633			speed = "low";
 634			break;
 635		case USB_SPEED_FULL:
 636			speed = "full";
 637			break;
 638		case USB_SPEED_HIGH:
 639			speed = "high";
 640			break;
 641		case USB_SPEED_SUPER:
 642			speed = "super";
 643			break;
 644		default:
 645			speed = "?";
 646			break;
 647		} ; speed; }), number, c ? c->label : "unconfigured");
 648
 649	if (!c)
 650		goto done;
 651
 
 652	cdev->config = c;
 653
 654	/* Initialize all interfaces by setting them to altsetting zero. */
 655	for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
 656		struct usb_function	*f = c->interface[tmp];
 657		struct usb_descriptor_header **descriptors;
 658
 659		if (!f)
 660			break;
 661
 662		/*
 663		 * Record which endpoints are used by the function. This is used
 664		 * to dispatch control requests targeted at that endpoint to the
 665		 * function's setup callback instead of the current
 666		 * configuration's setup callback.
 667		 */
 668		switch (gadget->speed) {
 669		case USB_SPEED_SUPER:
 670			descriptors = f->ss_descriptors;
 671			break;
 672		case USB_SPEED_HIGH:
 673			descriptors = f->hs_descriptors;
 674			break;
 675		default:
 676			descriptors = f->descriptors;
 677		}
 678
 679		for (; *descriptors; ++descriptors) {
 680			struct usb_endpoint_descriptor *ep;
 681			int addr;
 682
 683			if ((*descriptors)->bDescriptorType != USB_DT_ENDPOINT)
 684				continue;
 685
 686			ep = (struct usb_endpoint_descriptor *)*descriptors;
 687			addr = ((ep->bEndpointAddress & 0x80) >> 3)
 688			     |  (ep->bEndpointAddress & 0x0f);
 689			set_bit(addr, f->endpoints);
 690		}
 691
 692		result = f->set_alt(f, tmp, 0);
 693		if (result < 0) {
 694			DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
 695					tmp, f->name, f, result);
 696
 697			reset_config(cdev);
 698			goto done;
 699		}
 700
 701		if (result == USB_GADGET_DELAYED_STATUS) {
 702			DBG(cdev,
 703			 "%s: interface %d (%s) requested delayed status\n",
 704					__func__, tmp, f->name);
 705			cdev->delayed_status++;
 706			DBG(cdev, "delayed_status count %d\n",
 707					cdev->delayed_status);
 708		}
 709	}
 710
 711	/* when we return, be sure our power usage is valid */
 712	power = c->bMaxPower ? (2 * c->bMaxPower) : CONFIG_USB_GADGET_VBUS_DRAW;
 713done:
 714	usb_gadget_vbus_draw(gadget, power);
 715	if (result >= 0 && cdev->delayed_status)
 716		result = USB_GADGET_DELAYED_STATUS;
 717	return result;
 718}
 719
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 720/**
 721 * usb_add_config() - add a configuration to a device.
 722 * @cdev: wraps the USB gadget
 723 * @config: the configuration, with bConfigurationValue assigned
 724 * @bind: the configuration's bind function
 725 * Context: single threaded during gadget setup
 726 *
 727 * One of the main tasks of a composite @bind() routine is to
 728 * add each of the configurations it supports, using this routine.
 729 *
 730 * This function returns the value of the configuration's @bind(), which
 731 * is zero for success else a negative errno value.  Binding configurations
 732 * assigns global resources including string IDs, and per-configuration
 733 * resources such as interface IDs and endpoints.
 734 */
 735int usb_add_config(struct usb_composite_dev *cdev,
 736		struct usb_configuration *config,
 737		int (*bind)(struct usb_configuration *))
 738{
 739	int				status = -EINVAL;
 740	struct usb_configuration	*c;
 
 
 741
 742	DBG(cdev, "adding config #%u '%s'/%p\n",
 743			config->bConfigurationValue,
 744			config->label, config);
 745
 746	if (!config->bConfigurationValue || !bind)
 
 747		goto done;
 748
 749	/* Prevent duplicate configuration identifiers */
 750	list_for_each_entry(c, &cdev->configs, list) {
 751		if (c->bConfigurationValue == config->bConfigurationValue) {
 752			status = -EBUSY;
 753			goto done;
 754		}
 755	}
 756
 757	config->cdev = cdev;
 758	list_add_tail(&config->list, &cdev->configs);
 759
 760	INIT_LIST_HEAD(&config->functions);
 761	config->next_interface_id = 0;
 762
 763	status = bind(config);
 764	if (status < 0) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 765		list_del(&config->list);
 766		config->cdev = NULL;
 767	} else {
 768		unsigned	i;
 769
 770		DBG(cdev, "cfg %d/%p speeds:%s%s%s\n",
 771			config->bConfigurationValue, config,
 
 772			config->superspeed ? " super" : "",
 773			config->highspeed ? " high" : "",
 774			config->fullspeed
 775				? (gadget_is_dualspeed(cdev->gadget)
 776					? " full"
 777					: " full/low")
 778				: "");
 779
 780		for (i = 0; i < MAX_CONFIG_INTERFACES; i++) {
 781			struct usb_function	*f = config->interface[i];
 782
 783			if (!f)
 784				continue;
 785			DBG(cdev, "  interface %d = %s/%p\n",
 786				i, f->name, f);
 787		}
 788	}
 789
 790	/* set_alt(), or next bind(), sets up
 791	 * ep->driver_data as needed.
 792	 */
 793	usb_ep_autoconfig_reset(cdev->gadget);
 794
 795done:
 796	if (status)
 797		DBG(cdev, "added config '%s'/%u --> %d\n", config->label,
 798				config->bConfigurationValue, status);
 799	return status;
 800}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 801
 802/*-------------------------------------------------------------------------*/
 803
 804/* We support strings in multiple languages ... string descriptor zero
 805 * says which languages are supported.  The typical case will be that
 806 * only one language (probably English) is used, with I18N handled on
 807 * the host side.
 808 */
 809
 810static void collect_langs(struct usb_gadget_strings **sp, __le16 *buf)
 811{
 812	const struct usb_gadget_strings	*s;
 813	u16				language;
 814	__le16				*tmp;
 815
 816	while (*sp) {
 817		s = *sp;
 818		language = cpu_to_le16(s->language);
 819		for (tmp = buf; *tmp && tmp < &buf[126]; tmp++) {
 820			if (*tmp == language)
 821				goto repeat;
 822		}
 823		*tmp++ = language;
 824repeat:
 825		sp++;
 826	}
 827}
 828
 829static int lookup_string(
 830	struct usb_gadget_strings	**sp,
 831	void				*buf,
 832	u16				language,
 833	int				id
 834)
 835{
 836	struct usb_gadget_strings	*s;
 837	int				value;
 838
 839	while (*sp) {
 840		s = *sp++;
 841		if (s->language != language)
 842			continue;
 843		value = usb_gadget_get_string(s, id, buf);
 844		if (value > 0)
 845			return value;
 846	}
 847	return -EINVAL;
 848}
 849
 850static int get_string(struct usb_composite_dev *cdev,
 851		void *buf, u16 language, int id)
 852{
 
 
 853	struct usb_configuration	*c;
 854	struct usb_function		*f;
 855	int				len;
 856	const char			*str;
 857
 858	/* Yes, not only is USB's I18N support probably more than most
 859	 * folk will ever care about ... also, it's all supported here.
 860	 * (Except for UTF8 support for Unicode's "Astral Planes".)
 861	 */
 862
 863	/* 0 == report all available language codes */
 864	if (id == 0) {
 865		struct usb_string_descriptor	*s = buf;
 866		struct usb_gadget_strings	**sp;
 867
 868		memset(s, 0, 256);
 869		s->bDescriptorType = USB_DT_STRING;
 870
 871		sp = composite->strings;
 872		if (sp)
 873			collect_langs(sp, s->wData);
 874
 875		list_for_each_entry(c, &cdev->configs, list) {
 876			sp = c->strings;
 877			if (sp)
 878				collect_langs(sp, s->wData);
 879
 880			list_for_each_entry(f, &c->functions, list) {
 881				sp = f->strings;
 882				if (sp)
 883					collect_langs(sp, s->wData);
 884			}
 885		}
 
 
 
 
 
 
 886
 887		for (len = 0; len <= 126 && s->wData[len]; len++)
 888			continue;
 889		if (!len)
 890			return -EINVAL;
 891
 892		s->bLength = 2 * (len + 1);
 893		return s->bLength;
 894	}
 895
 896	/* Otherwise, look up and return a specified string.  First
 897	 * check if the string has not been overridden.
 898	 */
 899	if (cdev->manufacturer_override == id)
 900		str = iManufacturer ?: composite->iManufacturer ?:
 901			composite_manufacturer;
 902	else if (cdev->product_override == id)
 903		str = iProduct ?: composite->iProduct;
 904	else if (cdev->serial_override == id)
 905		str = iSerialNumber;
 906	else
 907		str = NULL;
 908	if (str) {
 909		struct usb_gadget_strings strings = {
 910			.language = language,
 911			.strings  = &(struct usb_string) { 0xff, str }
 912		};
 913		return usb_gadget_get_string(&strings, 0xff, buf);
 
 
 914	}
 915
 916	/* String IDs are device-scoped, so we look up each string
 917	 * table we're told about.  These lookups are infrequent;
 918	 * simpler-is-better here.
 919	 */
 920	if (composite->strings) {
 921		len = lookup_string(composite->strings, buf, language, id);
 922		if (len > 0)
 923			return len;
 924	}
 925	list_for_each_entry(c, &cdev->configs, list) {
 926		if (c->strings) {
 927			len = lookup_string(c->strings, buf, language, id);
 928			if (len > 0)
 929				return len;
 930		}
 931		list_for_each_entry(f, &c->functions, list) {
 932			if (!f->strings)
 933				continue;
 934			len = lookup_string(f->strings, buf, language, id);
 935			if (len > 0)
 936				return len;
 937		}
 938	}
 939	return -EINVAL;
 940}
 941
 942/**
 943 * usb_string_id() - allocate an unused string ID
 944 * @cdev: the device whose string descriptor IDs are being allocated
 945 * Context: single threaded during gadget setup
 946 *
 947 * @usb_string_id() is called from bind() callbacks to allocate
 948 * string IDs.  Drivers for functions, configurations, or gadgets will
 949 * then store that ID in the appropriate descriptors and string table.
 950 *
 951 * All string identifier should be allocated using this,
 952 * @usb_string_ids_tab() or @usb_string_ids_n() routine, to ensure
 953 * that for example different functions don't wrongly assign different
 954 * meanings to the same identifier.
 955 */
 956int usb_string_id(struct usb_composite_dev *cdev)
 957{
 958	if (cdev->next_string_id < 254) {
 959		/* string id 0 is reserved by USB spec for list of
 960		 * supported languages */
 961		/* 255 reserved as well? -- mina86 */
 962		cdev->next_string_id++;
 963		return cdev->next_string_id;
 964	}
 965	return -ENODEV;
 966}
 
 967
 968/**
 969 * usb_string_ids() - allocate unused string IDs in batch
 970 * @cdev: the device whose string descriptor IDs are being allocated
 971 * @str: an array of usb_string objects to assign numbers to
 972 * Context: single threaded during gadget setup
 973 *
 974 * @usb_string_ids() is called from bind() callbacks to allocate
 975 * string IDs.  Drivers for functions, configurations, or gadgets will
 976 * then copy IDs from the string table to the appropriate descriptors
 977 * and string table for other languages.
 978 *
 979 * All string identifier should be allocated using this,
 980 * @usb_string_id() or @usb_string_ids_n() routine, to ensure that for
 981 * example different functions don't wrongly assign different meanings
 982 * to the same identifier.
 983 */
 984int usb_string_ids_tab(struct usb_composite_dev *cdev, struct usb_string *str)
 985{
 986	int next = cdev->next_string_id;
 987
 988	for (; str->s; ++str) {
 989		if (unlikely(next >= 254))
 990			return -ENODEV;
 991		str->id = ++next;
 992	}
 993
 994	cdev->next_string_id = next;
 995
 996	return 0;
 997}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 998
 999/**
1000 * usb_string_ids_n() - allocate unused string IDs in batch
1001 * @c: the device whose string descriptor IDs are being allocated
1002 * @n: number of string IDs to allocate
1003 * Context: single threaded during gadget setup
1004 *
1005 * Returns the first requested ID.  This ID and next @n-1 IDs are now
1006 * valid IDs.  At least provided that @n is non-zero because if it
1007 * is, returns last requested ID which is now very useful information.
1008 *
1009 * @usb_string_ids_n() is called from bind() callbacks to allocate
1010 * string IDs.  Drivers for functions, configurations, or gadgets will
1011 * then store that ID in the appropriate descriptors and string table.
1012 *
1013 * All string identifier should be allocated using this,
1014 * @usb_string_id() or @usb_string_ids_n() routine, to ensure that for
1015 * example different functions don't wrongly assign different meanings
1016 * to the same identifier.
1017 */
1018int usb_string_ids_n(struct usb_composite_dev *c, unsigned n)
1019{
1020	unsigned next = c->next_string_id;
1021	if (unlikely(n > 254 || (unsigned)next + n > 254))
1022		return -ENODEV;
1023	c->next_string_id += n;
1024	return next + 1;
1025}
1026
1027
1028/*-------------------------------------------------------------------------*/
1029
1030static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
1031{
 
 
1032	if (req->status || req->actual != req->length)
1033		DBG((struct usb_composite_dev *) ep->driver_data,
1034				"setup complete --> %d, %d/%d\n",
1035				req->status, req->actual, req->length);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1036}
1037
1038/*
1039 * The setup() callback implements all the ep0 functionality that's
1040 * not handled lower down, in hardware or the hardware driver(like
1041 * device and endpoint feature flags, and their status).  It's all
1042 * housekeeping for the gadget function we're implementing.  Most of
1043 * the work is in config and function specific setup.
1044 */
1045static int
1046composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1047{
1048	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
1049	struct usb_request		*req = cdev->req;
1050	int				value = -EOPNOTSUPP;
1051	int				status = 0;
1052	u16				w_index = le16_to_cpu(ctrl->wIndex);
1053	u8				intf = w_index & 0xFF;
1054	u16				w_value = le16_to_cpu(ctrl->wValue);
1055	u16				w_length = le16_to_cpu(ctrl->wLength);
1056	struct usb_function		*f = NULL;
1057	u8				endp;
1058
1059	/* partial re-init of the response message; the function or the
1060	 * gadget might need to intercept e.g. a control-OUT completion
1061	 * when we delegate to it.
1062	 */
1063	req->zero = 0;
 
1064	req->complete = composite_setup_complete;
1065	req->length = 0;
1066	gadget->ep0->driver_data = cdev;
1067
 
 
 
 
 
 
 
1068	switch (ctrl->bRequest) {
1069
1070	/* we handle all standard USB descriptors */
1071	case USB_REQ_GET_DESCRIPTOR:
1072		if (ctrl->bRequestType != USB_DIR_IN)
1073			goto unknown;
1074		switch (w_value >> 8) {
1075
1076		case USB_DT_DEVICE:
1077			cdev->desc.bNumConfigurations =
1078				count_configs(cdev, USB_DT_DEVICE);
1079			cdev->desc.bMaxPacketSize0 =
1080				cdev->gadget->ep0->maxpacket;
1081			if (gadget_is_superspeed(gadget)) {
1082				if (gadget->speed >= USB_SPEED_SUPER) {
1083					cdev->desc.bcdUSB = cpu_to_le16(0x0300);
1084					cdev->desc.bMaxPacketSize0 = 9;
1085				} else {
1086					cdev->desc.bcdUSB = cpu_to_le16(0x0210);
1087				}
 
 
 
 
 
1088			}
1089
1090			value = min(w_length, (u16) sizeof cdev->desc);
1091			memcpy(req->buf, &cdev->desc, value);
1092			break;
1093		case USB_DT_DEVICE_QUALIFIER:
1094			if (!gadget_is_dualspeed(gadget) ||
1095			    gadget->speed >= USB_SPEED_SUPER)
1096				break;
1097			device_qual(cdev);
1098			value = min_t(int, w_length,
1099				sizeof(struct usb_qualifier_descriptor));
1100			break;
1101		case USB_DT_OTHER_SPEED_CONFIG:
1102			if (!gadget_is_dualspeed(gadget) ||
1103			    gadget->speed >= USB_SPEED_SUPER)
1104				break;
1105			/* FALLTHROUGH */
1106		case USB_DT_CONFIG:
1107			value = config_desc(cdev, w_value);
1108			if (value >= 0)
1109				value = min(w_length, (u16) value);
1110			break;
1111		case USB_DT_STRING:
1112			value = get_string(cdev, req->buf,
1113					w_index, w_value & 0xff);
1114			if (value >= 0)
1115				value = min(w_length, (u16) value);
1116			break;
1117		case USB_DT_BOS:
1118			if (gadget_is_superspeed(gadget)) {
 
1119				value = bos_desc(cdev);
1120				value = min(w_length, (u16) value);
1121			}
1122			break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1123		}
1124		break;
1125
1126	/* any number of configs can work */
1127	case USB_REQ_SET_CONFIGURATION:
1128		if (ctrl->bRequestType != 0)
1129			goto unknown;
1130		if (gadget_is_otg(gadget)) {
1131			if (gadget->a_hnp_support)
1132				DBG(cdev, "HNP available\n");
1133			else if (gadget->a_alt_hnp_support)
1134				DBG(cdev, "HNP on another port\n");
1135			else
1136				VDBG(cdev, "HNP inactive\n");
1137		}
1138		spin_lock(&cdev->lock);
1139		value = set_config(cdev, ctrl, w_value);
1140		spin_unlock(&cdev->lock);
1141		break;
1142	case USB_REQ_GET_CONFIGURATION:
1143		if (ctrl->bRequestType != USB_DIR_IN)
1144			goto unknown;
1145		if (cdev->config)
1146			*(u8 *)req->buf = cdev->config->bConfigurationValue;
1147		else
1148			*(u8 *)req->buf = 0;
1149		value = min(w_length, (u16) 1);
1150		break;
1151
1152	/* function drivers must handle get/set altsetting; if there's
1153	 * no get() method, we know only altsetting zero works.
1154	 */
1155	case USB_REQ_SET_INTERFACE:
1156		if (ctrl->bRequestType != USB_RECIP_INTERFACE)
1157			goto unknown;
1158		if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1159			break;
1160		f = cdev->config->interface[intf];
1161		if (!f)
1162			break;
1163		if (w_value && !f->set_alt)
 
 
 
 
 
 
1164			break;
1165		value = f->set_alt(f, w_index, w_value);
1166		if (value == USB_GADGET_DELAYED_STATUS) {
1167			DBG(cdev,
1168			 "%s: interface %d (%s) requested delayed status\n",
1169					__func__, intf, f->name);
1170			cdev->delayed_status++;
1171			DBG(cdev, "delayed_status count %d\n",
1172					cdev->delayed_status);
1173		}
1174		break;
1175	case USB_REQ_GET_INTERFACE:
1176		if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
1177			goto unknown;
1178		if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1179			break;
1180		f = cdev->config->interface[intf];
1181		if (!f)
1182			break;
1183		/* lots of interfaces only need altsetting zero... */
1184		value = f->get_alt ? f->get_alt(f, w_index) : 0;
1185		if (value < 0)
1186			break;
1187		*((u8 *)req->buf) = value;
1188		value = min(w_length, (u16) 1);
1189		break;
1190
1191	/*
1192	 * USB 3.0 additions:
1193	 * Function driver should handle get_status request. If such cb
1194	 * wasn't supplied we respond with default value = 0
1195	 * Note: function driver should supply such cb only for the first
1196	 * interface of the function
1197	 */
1198	case USB_REQ_GET_STATUS:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1199		if (!gadget_is_superspeed(gadget))
1200			goto unknown;
1201		if (ctrl->bRequestType != (USB_DIR_IN | USB_RECIP_INTERFACE))
1202			goto unknown;
1203		value = 2;	/* This is the length of the get_status reply */
1204		put_unaligned_le16(0, req->buf);
1205		if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1206			break;
1207		f = cdev->config->interface[intf];
1208		if (!f)
1209			break;
1210		status = f->get_status ? f->get_status(f) : 0;
1211		if (status < 0)
1212			break;
1213		put_unaligned_le16(status & 0x0000ffff, req->buf);
1214		break;
1215	/*
1216	 * Function drivers should handle SetFeature/ClearFeature
1217	 * (FUNCTION_SUSPEND) request. function_suspend cb should be supplied
1218	 * only for the first interface of the function
1219	 */
1220	case USB_REQ_CLEAR_FEATURE:
1221	case USB_REQ_SET_FEATURE:
1222		if (!gadget_is_superspeed(gadget))
1223			goto unknown;
1224		if (ctrl->bRequestType != (USB_DIR_OUT | USB_RECIP_INTERFACE))
1225			goto unknown;
1226		switch (w_value) {
1227		case USB_INTRF_FUNC_SUSPEND:
1228			if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1229				break;
1230			f = cdev->config->interface[intf];
1231			if (!f)
1232				break;
1233			value = 0;
1234			if (f->func_suspend)
1235				value = f->func_suspend(f, w_index >> 8);
1236			if (value < 0) {
1237				ERROR(cdev,
1238				      "func_suspend() returned error %d\n",
1239				      value);
1240				value = 0;
1241			}
1242			break;
1243		}
1244		break;
1245	default:
1246unknown:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1247		VDBG(cdev,
1248			"non-core control req%02x.%02x v%04x i%04x l%d\n",
1249			ctrl->bRequestType, ctrl->bRequest,
1250			w_value, w_index, w_length);
1251
1252		/* functions always handle their interfaces and endpoints...
1253		 * punt other recipients (other, WUSB, ...) to the current
1254		 * configuration code.
1255		 *
1256		 * REVISIT it could make sense to let the composite device
1257		 * take such requests too, if that's ever needed:  to work
1258		 * in config 0, etc.
1259		 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1260		switch (ctrl->bRequestType & USB_RECIP_MASK) {
1261		case USB_RECIP_INTERFACE:
1262			if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1263				break;
1264			f = cdev->config->interface[intf];
1265			break;
1266
1267		case USB_RECIP_ENDPOINT:
 
 
1268			endp = ((w_index & 0x80) >> 3) | (w_index & 0x0f);
1269			list_for_each_entry(f, &cdev->config->functions, list) {
1270				if (test_bit(endp, f->endpoints))
1271					break;
1272			}
1273			if (&f->list == &cdev->config->functions)
1274				f = NULL;
1275			break;
1276		}
1277
1278		if (f && f->setup)
1279			value = f->setup(f, ctrl);
1280		else {
1281			struct usb_configuration	*c;
1282
1283			c = cdev->config;
1284			if (c && c->setup)
 
 
 
 
1285				value = c->setup(c, ctrl);
 
 
 
 
 
 
 
 
 
 
1286		}
1287
1288		goto done;
1289	}
1290
 
1291	/* respond with data transfer before status phase? */
1292	if (value >= 0 && value != USB_GADGET_DELAYED_STATUS) {
1293		req->length = value;
 
1294		req->zero = value < w_length;
1295		value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1296		if (value < 0) {
1297			DBG(cdev, "ep_queue --> %d\n", value);
1298			req->status = 0;
1299			composite_setup_complete(gadget->ep0, req);
1300		}
1301	} else if (value == USB_GADGET_DELAYED_STATUS && w_length != 0) {
1302		WARN(cdev,
1303			"%s: Delayed status not supported for w_length != 0",
1304			__func__);
1305	}
1306
1307done:
1308	/* device either stalls (value < 0) or reports success */
1309	return value;
1310}
1311
1312static void composite_disconnect(struct usb_gadget *gadget)
1313{
1314	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
1315	unsigned long			flags;
1316
1317	/* REVISIT:  should we have config and device level
1318	 * disconnect callbacks?
1319	 */
1320	spin_lock_irqsave(&cdev->lock, flags);
1321	if (cdev->config)
1322		reset_config(cdev);
1323	if (composite->disconnect)
1324		composite->disconnect(cdev);
1325	spin_unlock_irqrestore(&cdev->lock, flags);
1326}
1327
1328/*-------------------------------------------------------------------------*/
1329
1330static ssize_t composite_show_suspended(struct device *dev,
1331					struct device_attribute *attr,
1332					char *buf)
1333{
1334	struct usb_gadget *gadget = dev_to_usb_gadget(dev);
1335	struct usb_composite_dev *cdev = get_gadget_data(gadget);
1336
1337	return sprintf(buf, "%d\n", cdev->suspended);
1338}
 
1339
1340static DEVICE_ATTR(suspended, 0444, composite_show_suspended, NULL);
1341
1342static void
1343composite_unbind(struct usb_gadget *gadget)
1344{
1345	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
 
 
1346
1347	/* composite_disconnect() must already have been called
1348	 * by the underlying peripheral controller driver!
1349	 * so there's no i/o concurrency that could affect the
1350	 * state protected by cdev->lock.
1351	 */
1352	WARN_ON(cdev->config);
1353
1354	while (!list_empty(&cdev->configs)) {
1355		struct usb_configuration	*c;
1356
1357		c = list_first_entry(&cdev->configs,
1358				struct usb_configuration, list);
1359		while (!list_empty(&c->functions)) {
1360			struct usb_function		*f;
1361
1362			f = list_first_entry(&c->functions,
1363					struct usb_function, list);
1364			list_del(&f->list);
1365			if (f->unbind) {
1366				DBG(cdev, "unbind function '%s'/%p\n",
1367						f->name, f);
1368				f->unbind(c, f);
1369				/* may free memory for "f" */
1370			}
1371		}
1372		list_del(&c->list);
1373		if (c->unbind) {
1374			DBG(cdev, "unbind config '%s'/%p\n", c->label, c);
1375			c->unbind(c);
1376			/* may free memory for "c" */
1377		}
1378	}
1379	if (composite->unbind)
1380		composite->unbind(cdev);
1381
1382	if (cdev->req) {
1383		kfree(cdev->req->buf);
1384		usb_ep_free_request(gadget->ep0, cdev->req);
1385	}
1386	device_remove_file(&gadget->dev, &dev_attr_suspended);
 
1387	kfree(cdev);
1388	set_gadget_data(gadget, NULL);
1389	composite = NULL;
1390}
1391
1392static u8 override_id(struct usb_composite_dev *cdev, u8 *desc)
1393{
1394	if (!*desc) {
1395		int ret = usb_string_id(cdev);
1396		if (unlikely(ret < 0))
1397			WARNING(cdev, "failed to override string ID\n");
1398		else
1399			*desc = ret;
1400	}
1401
1402	return *desc;
1403}
1404
1405static int composite_bind(struct usb_gadget *gadget)
 
1406{
1407	struct usb_composite_dev	*cdev;
1408	int				status = -ENOMEM;
 
 
 
 
1409
1410	cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
1411	if (!cdev)
1412		return status;
 
 
 
 
 
 
 
1413
1414	spin_lock_init(&cdev->lock);
1415	cdev->gadget = gadget;
1416	set_gadget_data(gadget, cdev);
1417	INIT_LIST_HEAD(&cdev->configs);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1418
1419	/* preallocate control response and buffer */
1420	cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
1421	if (!cdev->req)
1422		goto fail;
1423	cdev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
 
1424	if (!cdev->req->buf)
1425		goto fail;
 
 
 
 
 
1426	cdev->req->complete = composite_setup_complete;
 
1427	gadget->ep0->driver_data = cdev;
1428
1429	cdev->bufsiz = USB_BUFSIZ;
1430	cdev->driver = composite;
1431
1432	/*
1433	 * As per USB compliance update, a device that is actively drawing
1434	 * more than 100mA from USB must report itself as bus-powered in
1435	 * the GetStatus(DEVICE) call.
1436	 */
1437	if (CONFIG_USB_GADGET_VBUS_DRAW <= USB_SELF_POWER_VBUS_MAX_DRAW)
1438		usb_gadget_set_selfpowered(gadget);
1439
1440	/* interface and string IDs start at zero via kzalloc.
1441	 * we force endpoints to start unassigned; few controller
1442	 * drivers will zero ep->driver_data.
1443	 */
1444	usb_ep_autoconfig_reset(cdev->gadget);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1445
1446	/* composite gadget needs to assign strings for whole device (like
1447	 * serial number), register function drivers, potentially update
1448	 * power state and consumption, etc
1449	 */
1450	status = composite_gadget_bind(cdev);
1451	if (status < 0)
1452		goto fail;
1453
1454	cdev->desc = *composite->dev;
1455
1456	/* standardized runtime overrides for device ID data */
1457	if (idVendor)
1458		cdev->desc.idVendor = cpu_to_le16(idVendor);
1459	if (idProduct)
1460		cdev->desc.idProduct = cpu_to_le16(idProduct);
1461	if (bcdDevice)
1462		cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);
1463
1464	/* string overrides */
1465	if (iManufacturer || !cdev->desc.iManufacturer) {
1466		if (!iManufacturer && !composite->iManufacturer &&
1467		    !*composite_manufacturer)
1468			snprintf(composite_manufacturer,
1469				 sizeof composite_manufacturer,
1470				 "%s %s with %s",
1471				 init_utsname()->sysname,
1472				 init_utsname()->release,
1473				 gadget->name);
1474
1475		cdev->manufacturer_override =
1476			override_id(cdev, &cdev->desc.iManufacturer);
1477	}
1478
1479	if (iProduct || (!cdev->desc.iProduct && composite->iProduct))
1480		cdev->product_override =
1481			override_id(cdev, &cdev->desc.iProduct);
1482
1483	if (iSerialNumber)
1484		cdev->serial_override =
1485			override_id(cdev, &cdev->desc.iSerialNumber);
1486
1487	/* has userspace failed to provide a serial number? */
1488	if (composite->needs_serial && !cdev->desc.iSerialNumber)
1489		WARNING(cdev, "userspace failed to provide iSerialNumber\n");
1490
1491	/* finish up */
1492	status = device_create_file(&gadget->dev, &dev_attr_suspended);
1493	if (status)
1494		goto fail;
1495
1496	INFO(cdev, "%s ready\n", composite->name);
1497	return 0;
1498
1499fail:
1500	composite_unbind(gadget);
1501	return status;
1502}
1503
1504/*-------------------------------------------------------------------------*/
1505
1506static void
1507composite_suspend(struct usb_gadget *gadget)
1508{
1509	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
1510	struct usb_function		*f;
1511
1512	/* REVISIT:  should we have config level
1513	 * suspend/resume callbacks?
1514	 */
1515	DBG(cdev, "suspend\n");
1516	if (cdev->config) {
1517		list_for_each_entry(f, &cdev->config->functions, list) {
1518			if (f->suspend)
1519				f->suspend(f);
1520		}
1521	}
1522	if (composite->suspend)
1523		composite->suspend(cdev);
1524
1525	cdev->suspended = 1;
1526
1527	usb_gadget_vbus_draw(gadget, 2);
1528}
1529
1530static void
1531composite_resume(struct usb_gadget *gadget)
1532{
1533	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
1534	struct usb_function		*f;
1535	u8				maxpower;
1536
1537	/* REVISIT:  should we have config level
1538	 * suspend/resume callbacks?
1539	 */
1540	DBG(cdev, "resume\n");
1541	if (composite->resume)
1542		composite->resume(cdev);
1543	if (cdev->config) {
1544		list_for_each_entry(f, &cdev->config->functions, list) {
1545			if (f->resume)
1546				f->resume(f);
1547		}
1548
1549		maxpower = cdev->config->bMaxPower;
1550
1551		usb_gadget_vbus_draw(gadget, maxpower ?
1552			(2 * maxpower) : CONFIG_USB_GADGET_VBUS_DRAW);
1553	}
1554
1555	cdev->suspended = 0;
1556}
1557
1558/*-------------------------------------------------------------------------*/
1559
1560static struct usb_gadget_driver composite_driver = {
1561#ifdef CONFIG_USB_GADGET_SUPERSPEED
1562	.speed		= USB_SPEED_SUPER,
1563#else
1564	.speed		= USB_SPEED_HIGH,
1565#endif
1566
1567	.unbind		= composite_unbind,
1568
1569	.setup		= composite_setup,
 
1570	.disconnect	= composite_disconnect,
1571
1572	.suspend	= composite_suspend,
1573	.resume		= composite_resume,
1574
1575	.driver	= {
1576		.owner		= THIS_MODULE,
1577	},
1578};
1579
1580/**
1581 * usb_composite_probe() - register a composite driver
1582 * @driver: the driver to register
1583 * @bind: the callback used to allocate resources that are shared across the
1584 *	whole device, such as string IDs, and add its configurations using
1585 *	@usb_add_config().  This may fail by returning a negative errno
1586 *	value; it should return zero on successful initialization.
1587 * Context: single threaded during gadget setup
1588 *
1589 * This function is used to register drivers using the composite driver
1590 * framework.  The return value is zero, or a negative errno value.
1591 * Those values normally come from the driver's @bind method, which does
1592 * all the work of setting up the driver to match the hardware.
1593 *
1594 * On successful return, the gadget is ready to respond to requests from
1595 * the host, unless one of its components invokes usb_gadget_disconnect()
1596 * while it was binding.  That would usually be done in order to wait for
1597 * some userspace participation.
1598 */
1599int usb_composite_probe(struct usb_composite_driver *driver,
1600			       int (*bind)(struct usb_composite_dev *cdev))
1601{
1602	if (!driver || !driver->dev || !bind || composite)
 
 
1603		return -EINVAL;
1604
1605	if (!driver->name)
1606		driver->name = "composite";
1607	if (!driver->iProduct)
1608		driver->iProduct = driver->name;
1609	composite_driver.function =  (char *) driver->name;
1610	composite_driver.driver.name = driver->name;
1611	composite_driver.speed = min((u8)composite_driver.speed,
1612				     (u8)driver->max_speed);
1613	composite = driver;
1614	composite_gadget_bind = bind;
1615
1616	return usb_gadget_probe_driver(&composite_driver, composite_bind);
 
 
 
 
 
 
 
1617}
 
1618
1619/**
1620 * usb_composite_unregister() - unregister a composite driver
1621 * @driver: the driver to unregister
1622 *
1623 * This function is used to unregister drivers using the composite
1624 * driver framework.
1625 */
1626void usb_composite_unregister(struct usb_composite_driver *driver)
1627{
1628	if (composite != driver)
1629		return;
1630	usb_gadget_unregister_driver(&composite_driver);
1631}
 
1632
1633/**
1634 * usb_composite_setup_continue() - Continue with the control transfer
1635 * @cdev: the composite device who's control transfer was kept waiting
1636 *
1637 * This function must be called by the USB function driver to continue
1638 * with the control transfer's data/status stage in case it had requested to
1639 * delay the data/status stages. A USB function's setup handler (e.g. set_alt())
1640 * can request the composite framework to delay the setup request's data/status
1641 * stages by returning USB_GADGET_DELAYED_STATUS.
1642 */
1643void usb_composite_setup_continue(struct usb_composite_dev *cdev)
1644{
1645	int			value;
1646	struct usb_request	*req = cdev->req;
1647	unsigned long		flags;
1648
1649	DBG(cdev, "%s\n", __func__);
1650	spin_lock_irqsave(&cdev->lock, flags);
1651
1652	if (cdev->delayed_status == 0) {
1653		WARN(cdev, "%s: Unexpected call\n", __func__);
1654
1655	} else if (--cdev->delayed_status == 0) {
1656		DBG(cdev, "%s: Completing delayed status\n", __func__);
1657		req->length = 0;
1658		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
 
1659		if (value < 0) {
1660			DBG(cdev, "ep_queue --> %d\n", value);
1661			req->status = 0;
1662			composite_setup_complete(cdev->gadget->ep0, req);
1663		}
1664	}
1665
1666	spin_unlock_irqrestore(&cdev->lock, flags);
1667}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1668