Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
composite.c
Go to the documentation of this file.
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 /*
25  * The code in this file is utility code, used to build a gadget driver
26  * from one or more "function" drivers, one or more "configuration"
27  * objects, and a "usb_composite_driver" by gluing them together along
28  * with the relevant device-wide data.
29  */
30 
31 /* big enough to hold our biggest descriptor */
32 #define USB_BUFSIZ 1024
33 
34 static struct usb_composite_driver *composite;
35 
36 /* Some systems will need runtime overrides for the product identifiers
37  * published in the device descriptor, either numbers or strings or both.
38  * String parameters are in UTF-8 (superset of ASCII's 7 bit characters).
39  */
40 
41 static ushort idVendor;
42 module_param(idVendor, ushort, 0644);
43 MODULE_PARM_DESC(idVendor, "USB Vendor ID");
44 
45 static ushort idProduct;
46 module_param(idProduct, ushort, 0644);
47 MODULE_PARM_DESC(idProduct, "USB Product ID");
48 
49 static ushort bcdDevice;
50 module_param(bcdDevice, ushort, 0644);
51 MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
52 
53 static char *iManufacturer;
54 module_param(iManufacturer, charp, 0644);
55 MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
56 
57 static char *iProduct;
58 module_param(iProduct, charp, 0644);
59 MODULE_PARM_DESC(iProduct, "USB Product string");
60 
61 static char *iSerialNumber;
62 module_param(iSerialNumber, charp, 0644);
63 MODULE_PARM_DESC(iSerialNumber, "SerialNumber string");
64 
65 static char composite_manufacturer[50];
66 
67 /*-------------------------------------------------------------------------*/
77 static struct usb_descriptor_header**
78 next_ep_desc(struct usb_descriptor_header **t)
79 {
80  for (; *t; t++) {
81  if ((*t)->bDescriptorType == USB_DT_ENDPOINT)
82  return t;
83  }
84  return NULL;
85 }
86 
87 /*
88  * for_each_ep_desc()- iterate over endpoint descriptors in the
89  * descriptors list
90  * @start: pointer within descriptor array.
91  * @ep_desc: endpoint descriptor to use as the loop cursor
92  */
93 #define for_each_ep_desc(start, ep_desc) \
94  for (ep_desc = next_ep_desc(start); \
95  ep_desc; ep_desc = next_ep_desc(ep_desc+1))
96 
116  struct usb_function *f,
117  struct usb_ep *_ep)
118 {
119  struct usb_composite_dev *cdev = get_gadget_data(g);
120  struct usb_endpoint_descriptor *chosen_desc = NULL;
121  struct usb_descriptor_header **speed_desc = NULL;
122 
123  struct usb_ss_ep_comp_descriptor *comp_desc = NULL;
124  int want_comp_desc = 0;
125 
126  struct usb_descriptor_header **d_spd; /* cursor for speed desc */
127 
128  if (!g || !f || !_ep)
129  return -EIO;
130 
131  /* select desired speed */
132  switch (g->speed) {
133  case USB_SPEED_SUPER:
134  if (gadget_is_superspeed(g)) {
135  speed_desc = f->ss_descriptors;
136  want_comp_desc = 1;
137  break;
138  }
139  /* else: Fall trough */
140  case USB_SPEED_HIGH:
141  if (gadget_is_dualspeed(g)) {
142  speed_desc = f->hs_descriptors;
143  break;
144  }
145  /* else: fall through */
146  default:
147  speed_desc = f->descriptors;
148  }
149  /* find descriptors */
150  for_each_ep_desc(speed_desc, d_spd) {
151  chosen_desc = (struct usb_endpoint_descriptor *)*d_spd;
152  if (chosen_desc->bEndpointAddress == _ep->address)
153  goto ep_found;
154  }
155  return -EIO;
156 
157 ep_found:
158  /* commit results */
159  _ep->maxpacket = usb_endpoint_maxp(chosen_desc);
160  _ep->desc = chosen_desc;
161  _ep->comp_desc = NULL;
162  _ep->maxburst = 0;
163  _ep->mult = 0;
164  if (!want_comp_desc)
165  return 0;
166 
167  /*
168  * Companion descriptor should follow EP descriptor
169  * USB 3.0 spec, #9.6.7
170  */
171  comp_desc = (struct usb_ss_ep_comp_descriptor *)*(++d_spd);
172  if (!comp_desc ||
174  return -EIO;
175  _ep->comp_desc = comp_desc;
176  if (g->speed == USB_SPEED_SUPER) {
177  switch (usb_endpoint_type(_ep->desc)) {
179  /* mult: bits 1:0 of bmAttributes */
180  _ep->mult = comp_desc->bmAttributes & 0x3;
183  _ep->maxburst = comp_desc->bMaxBurst + 1;
184  break;
185  default:
186  if (comp_desc->bMaxBurst != 0)
187  ERROR(cdev, "ep0 bMaxBurst must be 0\n");
188  _ep->maxburst = 1;
189  break;
190  }
191  }
192  return 0;
193 }
194 
210  struct usb_function *function)
211 {
212  int value = -EINVAL;
213 
214  DBG(config->cdev, "adding '%s'/%p to config '%s'/%p\n",
215  function->name, function,
216  config->label, config);
217 
218  if (!function->set_alt || !function->disable)
219  goto done;
220 
221  function->config = config;
222  list_add_tail(&function->list, &config->functions);
223 
224  /* REVISIT *require* function->bind? */
225  if (function->bind) {
226  value = function->bind(config, function);
227  if (value < 0) {
228  list_del(&function->list);
229  function->config = NULL;
230  }
231  } else
232  value = 0;
233 
234  /* We allow configurations that don't work at both speeds.
235  * If we run into a lowspeed Linux system, treat it the same
236  * as full speed ... it's the function drivers that will need
237  * to avoid bulk and ISO transfers.
238  */
239  if (!config->fullspeed && function->descriptors)
240  config->fullspeed = true;
241  if (!config->highspeed && function->hs_descriptors)
242  config->highspeed = true;
243  if (!config->superspeed && function->ss_descriptors)
244  config->superspeed = true;
245 
246 done:
247  if (value)
248  DBG(config->cdev, "adding '%s'/%p --> %d\n",
249  function->name, function, value);
250  return value;
251 }
252 
273 {
274  struct usb_composite_dev *cdev = function->config->cdev;
275  unsigned long flags;
276  int status = 0;
277 
278  spin_lock_irqsave(&cdev->lock, flags);
279 
280  if (cdev->deactivations == 0)
281  status = usb_gadget_disconnect(cdev->gadget);
282  if (status == 0)
283  cdev->deactivations++;
284 
285  spin_unlock_irqrestore(&cdev->lock, flags);
286  return status;
287 }
288 
299 int usb_function_activate(struct usb_function *function)
300 {
301  struct usb_composite_dev *cdev = function->config->cdev;
302  unsigned long flags;
303  int status = 0;
304 
305  spin_lock_irqsave(&cdev->lock, flags);
306 
307  if (WARN_ON(cdev->deactivations == 0))
308  status = -EINVAL;
309  else {
310  cdev->deactivations--;
311  if (cdev->deactivations == 0)
312  status = usb_gadget_connect(cdev->gadget);
313  }
314 
315  spin_unlock_irqrestore(&cdev->lock, flags);
316  return status;
317 }
318 
343  struct usb_function *function)
344 {
345  unsigned id = config->next_interface_id;
346 
347  if (id < MAX_CONFIG_INTERFACES) {
348  config->interface[id] = function;
349  config->next_interface_id = id + 1;
350  return id;
351  }
352  return -ENODEV;
353 }
354 
355 static int config_buf(struct usb_configuration *config,
356  enum usb_device_speed speed, void *buf, u8 type)
357 {
358  struct usb_config_descriptor *c = buf;
359  void *next = buf + USB_DT_CONFIG_SIZE;
361  struct usb_function *f;
362  int status;
363 
364  /* write the config descriptor */
365  c = buf;
367  c->bDescriptorType = type;
368  /* wTotalLength is written later */
369  c->bNumInterfaces = config->next_interface_id;
371  c->iConfiguration = config->iConfiguration;
373  c->bMaxPower = config->bMaxPower ? : (CONFIG_USB_GADGET_VBUS_DRAW / 2);
374 
375  /* There may be e.g. OTG descriptors */
376  if (config->descriptors) {
377  status = usb_descriptor_fillbuf(next, len,
378  config->descriptors);
379  if (status < 0)
380  return status;
381  len -= status;
382  next += status;
383  }
384 
385  /* add each function's descriptors */
386  list_for_each_entry(f, &config->functions, list) {
388 
389  switch (speed) {
390  case USB_SPEED_SUPER:
391  descriptors = f->ss_descriptors;
392  break;
393  case USB_SPEED_HIGH:
394  descriptors = f->hs_descriptors;
395  break;
396  default:
397  descriptors = f->descriptors;
398  }
399 
400  if (!descriptors)
401  continue;
402  status = usb_descriptor_fillbuf(next, len,
403  (const struct usb_descriptor_header **) descriptors);
404  if (status < 0)
405  return status;
406  len -= status;
407  next += status;
408  }
409 
410  len = next - buf;
411  c->wTotalLength = cpu_to_le16(len);
412  return len;
413 }
414 
415 static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
416 {
417  struct usb_gadget *gadget = cdev->gadget;
418  struct usb_configuration *c;
419  u8 type = w_value >> 8;
420  enum usb_device_speed speed = USB_SPEED_UNKNOWN;
421 
422  if (gadget->speed == USB_SPEED_SUPER)
423  speed = gadget->speed;
424  else if (gadget_is_dualspeed(gadget)) {
425  int hs = 0;
426  if (gadget->speed == USB_SPEED_HIGH)
427  hs = 1;
428  if (type == USB_DT_OTHER_SPEED_CONFIG)
429  hs = !hs;
430  if (hs)
431  speed = USB_SPEED_HIGH;
432 
433  }
434 
435  /* This is a lookup by config *INDEX* */
436  w_value &= 0xff;
437  list_for_each_entry(c, &cdev->configs, list) {
438  /* ignore configs that won't work at this speed */
439  switch (speed) {
440  case USB_SPEED_SUPER:
441  if (!c->superspeed)
442  continue;
443  break;
444  case USB_SPEED_HIGH:
445  if (!c->highspeed)
446  continue;
447  break;
448  default:
449  if (!c->fullspeed)
450  continue;
451  }
452 
453  if (w_value == 0)
454  return config_buf(c, speed, cdev->req->buf, type);
455  w_value--;
456  }
457  return -EINVAL;
458 }
459 
460 static int count_configs(struct usb_composite_dev *cdev, unsigned type)
461 {
462  struct usb_gadget *gadget = cdev->gadget;
463  struct usb_configuration *c;
464  unsigned count = 0;
465  int hs = 0;
466  int ss = 0;
467 
468  if (gadget_is_dualspeed(gadget)) {
469  if (gadget->speed == USB_SPEED_HIGH)
470  hs = 1;
471  if (gadget->speed == USB_SPEED_SUPER)
472  ss = 1;
473  if (type == USB_DT_DEVICE_QUALIFIER)
474  hs = !hs;
475  }
476  list_for_each_entry(c, &cdev->configs, list) {
477  /* ignore configs that won't work at this speed */
478  if (ss) {
479  if (!c->superspeed)
480  continue;
481  } else if (hs) {
482  if (!c->highspeed)
483  continue;
484  } else {
485  if (!c->fullspeed)
486  continue;
487  }
488  count++;
489  }
490  return count;
491 }
492 
502 static int bos_desc(struct usb_composite_dev *cdev)
503 {
504  struct usb_ext_cap_descriptor *usb_ext;
506  struct usb_dcd_config_params dcd_config_params;
507  struct usb_bos_descriptor *bos = cdev->req->buf;
508 
509  bos->bLength = USB_DT_BOS_SIZE;
511 
513  bos->bNumDeviceCaps = 0;
514 
515  /*
516  * A SuperSpeed device shall include the USB2.0 extension descriptor
517  * and shall support LPM when operating in USB2.0 HS mode.
518  */
519  usb_ext = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
520  bos->bNumDeviceCaps++;
521  le16_add_cpu(&bos->wTotalLength, USB_DT_USB_EXT_CAP_SIZE);
522  usb_ext->bLength = USB_DT_USB_EXT_CAP_SIZE;
526 
527  /*
528  * The Superspeed USB Capability descriptor shall be implemented by all
529  * SuperSpeed devices.
530  */
531  ss_cap = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
532  bos->bNumDeviceCaps++;
533  le16_add_cpu(&bos->wTotalLength, USB_DT_USB_SS_CAP_SIZE);
537  ss_cap->bmAttributes = 0; /* LTM is not supported yet */
543 
544  /* Get Controller configuration */
545  if (cdev->gadget->ops->get_config_params)
546  cdev->gadget->ops->get_config_params(&dcd_config_params);
547  else {
548  dcd_config_params.bU1devExitLat = USB_DEFAULT_U1_DEV_EXIT_LAT;
549  dcd_config_params.bU2DevExitLat =
551  }
552  ss_cap->bU1devExitLat = dcd_config_params.bU1devExitLat;
553  ss_cap->bU2DevExitLat = dcd_config_params.bU2DevExitLat;
554 
555  return le16_to_cpu(bos->wTotalLength);
556 }
557 
558 static void device_qual(struct usb_composite_dev *cdev)
559 {
560  struct usb_qualifier_descriptor *qual = cdev->req->buf;
561 
562  qual->bLength = sizeof(*qual);
564  /* POLICY: same bcdUSB and device type info at both speeds */
565  qual->bcdUSB = cdev->desc.bcdUSB;
566  qual->bDeviceClass = cdev->desc.bDeviceClass;
567  qual->bDeviceSubClass = cdev->desc.bDeviceSubClass;
568  qual->bDeviceProtocol = cdev->desc.bDeviceProtocol;
569  /* ASSUME same EP0 fifo size at both speeds */
570  qual->bMaxPacketSize0 = cdev->gadget->ep0->maxpacket;
571  qual->bNumConfigurations = count_configs(cdev, USB_DT_DEVICE_QUALIFIER);
572  qual->bRESERVED = 0;
573 }
574 
575 /*-------------------------------------------------------------------------*/
576 
577 static void reset_config(struct usb_composite_dev *cdev)
578 {
579  struct usb_function *f;
580 
581  DBG(cdev, "reset config\n");
582 
583  list_for_each_entry(f, &cdev->config->functions, list) {
584  if (f->disable)
585  f->disable(f);
586 
587  bitmap_zero(f->endpoints, 32);
588  }
589  cdev->config = NULL;
590 }
591 
592 static int set_config(struct usb_composite_dev *cdev,
593  const struct usb_ctrlrequest *ctrl, unsigned number)
594 {
595  struct usb_gadget *gadget = cdev->gadget;
596  struct usb_configuration *c = NULL;
597  int result = -EINVAL;
598  unsigned power = gadget_is_otg(gadget) ? 8 : 100;
599  int tmp;
600 
601  if (number) {
602  list_for_each_entry(c, &cdev->configs, list) {
603  if (c->bConfigurationValue == number) {
604  /*
605  * We disable the FDs of the previous
606  * configuration only if the new configuration
607  * is a valid one
608  */
609  if (cdev->config)
610  reset_config(cdev);
611  result = 0;
612  break;
613  }
614  }
615  if (result < 0)
616  goto done;
617  } else { /* Zero configuration value - need to reset the config */
618  if (cdev->config)
619  reset_config(cdev);
620  result = 0;
621  }
622 
623  INFO(cdev, "%s config #%d: %s\n",
624  usb_speed_string(gadget->speed),
625  number, c ? c->label : "unconfigured");
626 
627  if (!c)
628  goto done;
629 
630  cdev->config = c;
631 
632  /* Initialize all interfaces by setting them to altsetting zero. */
633  for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
634  struct usb_function *f = c->interface[tmp];
636 
637  if (!f)
638  break;
639 
640  /*
641  * Record which endpoints are used by the function. This is used
642  * to dispatch control requests targeted at that endpoint to the
643  * function's setup callback instead of the current
644  * configuration's setup callback.
645  */
646  switch (gadget->speed) {
647  case USB_SPEED_SUPER:
648  descriptors = f->ss_descriptors;
649  break;
650  case USB_SPEED_HIGH:
651  descriptors = f->hs_descriptors;
652  break;
653  default:
654  descriptors = f->descriptors;
655  }
656 
657  for (; *descriptors; ++descriptors) {
658  struct usb_endpoint_descriptor *ep;
659  int addr;
660 
661  if ((*descriptors)->bDescriptorType != USB_DT_ENDPOINT)
662  continue;
663 
664  ep = (struct usb_endpoint_descriptor *)*descriptors;
665  addr = ((ep->bEndpointAddress & 0x80) >> 3)
666  | (ep->bEndpointAddress & 0x0f);
667  set_bit(addr, f->endpoints);
668  }
669 
670  result = f->set_alt(f, tmp, 0);
671  if (result < 0) {
672  DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
673  tmp, f->name, f, result);
674 
675  reset_config(cdev);
676  goto done;
677  }
678 
679  if (result == USB_GADGET_DELAYED_STATUS) {
680  DBG(cdev,
681  "%s: interface %d (%s) requested delayed status\n",
682  __func__, tmp, f->name);
683  cdev->delayed_status++;
684  DBG(cdev, "delayed_status count %d\n",
685  cdev->delayed_status);
686  }
687  }
688 
689  /* when we return, be sure our power usage is valid */
690  power = c->bMaxPower ? (2 * c->bMaxPower) : CONFIG_USB_GADGET_VBUS_DRAW;
691 done:
692  usb_gadget_vbus_draw(gadget, power);
693  if (result >= 0 && cdev->delayed_status)
694  result = USB_GADGET_DELAYED_STATUS;
695  return result;
696 }
697 
714  struct usb_configuration *config,
715  int (*bind)(struct usb_configuration *))
716 {
717  int status = -EINVAL;
718  struct usb_configuration *c;
719 
720  DBG(cdev, "adding config #%u '%s'/%p\n",
721  config->bConfigurationValue,
722  config->label, config);
723 
724  if (!config->bConfigurationValue || !bind)
725  goto done;
726 
727  /* Prevent duplicate configuration identifiers */
728  list_for_each_entry(c, &cdev->configs, list) {
729  if (c->bConfigurationValue == config->bConfigurationValue) {
730  status = -EBUSY;
731  goto done;
732  }
733  }
734 
735  config->cdev = cdev;
736  list_add_tail(&config->list, &cdev->configs);
737 
738  INIT_LIST_HEAD(&config->functions);
739  config->next_interface_id = 0;
740  memset(config->interface, 0, sizeof(config->interface));
741 
742  status = bind(config);
743  if (status < 0) {
744  while (!list_empty(&config->functions)) {
745  struct usb_function *f;
746 
747  f = list_first_entry(&config->functions,
748  struct usb_function, list);
749  list_del(&f->list);
750  if (f->unbind) {
751  DBG(cdev, "unbind function '%s'/%p\n",
752  f->name, f);
753  f->unbind(config, f);
754  /* may free memory for "f" */
755  }
756  }
757  list_del(&config->list);
758  config->cdev = NULL;
759  } else {
760  unsigned i;
761 
762  DBG(cdev, "cfg %d/%p speeds:%s%s%s\n",
763  config->bConfigurationValue, config,
764  config->superspeed ? " super" : "",
765  config->highspeed ? " high" : "",
766  config->fullspeed
767  ? (gadget_is_dualspeed(cdev->gadget)
768  ? " full"
769  : " full/low")
770  : "");
771 
772  for (i = 0; i < MAX_CONFIG_INTERFACES; i++) {
773  struct usb_function *f = config->interface[i];
774 
775  if (!f)
776  continue;
777  DBG(cdev, " interface %d = %s/%p\n",
778  i, f->name, f);
779  }
780  }
781 
782  /* set_alt(), or next bind(), sets up
783  * ep->driver_data as needed.
784  */
786 
787 done:
788  if (status)
789  DBG(cdev, "added config '%s'/%u --> %d\n", config->label,
790  config->bConfigurationValue, status);
791  return status;
792 }
793 
794 static void remove_config(struct usb_composite_dev *cdev,
795  struct usb_configuration *config)
796 {
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", f->name, f);
805  f->unbind(config, f);
806  /* may free memory for "f" */
807  }
808  }
809  list_del(&config->list);
810  if (config->unbind) {
811  DBG(cdev, "unbind config '%s'/%p\n", config->label, config);
812  config->unbind(config);
813  /* may free memory for "c" */
814  }
815 }
816 
827  struct usb_configuration *config)
828 {
829  unsigned long flags;
830 
831  spin_lock_irqsave(&cdev->lock, flags);
832 
833  if (cdev->config == config)
834  reset_config(cdev);
835 
836  spin_unlock_irqrestore(&cdev->lock, flags);
837 
838  remove_config(cdev, config);
839 }
840 
841 /*-------------------------------------------------------------------------*/
842 
843 /* We support strings in multiple languages ... string descriptor zero
844  * says which languages are supported. The typical case will be that
845  * only one language (probably English) is used, with I18N handled on
846  * the host side.
847  */
848 
849 static void collect_langs(struct usb_gadget_strings **sp, __le16 *buf)
850 {
851  const struct usb_gadget_strings *s;
853  __le16 *tmp;
854 
855  while (*sp) {
856  s = *sp;
857  language = cpu_to_le16(s->language);
858  for (tmp = buf; *tmp && tmp < &buf[126]; tmp++) {
859  if (*tmp == language)
860  goto repeat;
861  }
862  *tmp++ = language;
863 repeat:
864  sp++;
865  }
866 }
867 
868 static int lookup_string(
869  struct usb_gadget_strings **sp,
870  void *buf,
871  u16 language,
872  int id
873 )
874 {
875  struct usb_gadget_strings *s;
876  int value;
877 
878  while (*sp) {
879  s = *sp++;
880  if (s->language != language)
881  continue;
882  value = usb_gadget_get_string(s, id, buf);
883  if (value > 0)
884  return value;
885  }
886  return -EINVAL;
887 }
888 
889 static int get_string(struct usb_composite_dev *cdev,
890  void *buf, u16 language, int id)
891 {
892  struct usb_configuration *c;
893  struct usb_function *f;
894  int len;
895  const char *str;
896 
897  /* Yes, not only is USB's I18N support probably more than most
898  * folk will ever care about ... also, it's all supported here.
899  * (Except for UTF8 support for Unicode's "Astral Planes".)
900  */
901 
902  /* 0 == report all available language codes */
903  if (id == 0) {
904  struct usb_string_descriptor *s = buf;
905  struct usb_gadget_strings **sp;
906 
907  memset(s, 0, 256);
909 
910  sp = composite->strings;
911  if (sp)
912  collect_langs(sp, s->wData);
913 
914  list_for_each_entry(c, &cdev->configs, list) {
915  sp = c->strings;
916  if (sp)
917  collect_langs(sp, s->wData);
918 
920  sp = f->strings;
921  if (sp)
922  collect_langs(sp, s->wData);
923  }
924  }
925 
926  for (len = 0; len <= 126 && s->wData[len]; len++)
927  continue;
928  if (!len)
929  return -EINVAL;
930 
931  s->bLength = 2 * (len + 1);
932  return s->bLength;
933  }
934 
935  /* Otherwise, look up and return a specified string. First
936  * check if the string has not been overridden.
937  */
938  if (cdev->manufacturer_override == id)
939  str = iManufacturer ?: composite->iManufacturer ?:
940  composite_manufacturer;
941  else if (cdev->product_override == id)
942  str = iProduct ?: composite->iProduct;
943  else if (cdev->serial_override == id)
944  str = iSerialNumber ?: composite->iSerialNumber;
945  else
946  str = NULL;
947  if (str) {
948  struct usb_gadget_strings strings = {
949  .language = language,
950  .strings = &(struct usb_string) { 0xff, str }
951  };
952  return usb_gadget_get_string(&strings, 0xff, buf);
953  }
954 
955  /* String IDs are device-scoped, so we look up each string
956  * table we're told about. These lookups are infrequent;
957  * simpler-is-better here.
958  */
959  if (composite->strings) {
960  len = lookup_string(composite->strings, buf, language, id);
961  if (len > 0)
962  return len;
963  }
964  list_for_each_entry(c, &cdev->configs, list) {
965  if (c->strings) {
966  len = lookup_string(c->strings, buf, language, id);
967  if (len > 0)
968  return len;
969  }
971  if (!f->strings)
972  continue;
973  len = lookup_string(f->strings, buf, language, id);
974  if (len > 0)
975  return len;
976  }
977  }
978  return -EINVAL;
979 }
980 
996 {
997  if (cdev->next_string_id < 254) {
998  /* string id 0 is reserved by USB spec for list of
999  * supported languages */
1000  /* 255 reserved as well? -- mina86 */
1001  cdev->next_string_id++;
1002  return cdev->next_string_id;
1003  }
1004  return -ENODEV;
1005 }
1006 
1023 int usb_string_ids_tab(struct usb_composite_dev *cdev, struct usb_string *str)
1024 {
1025  int next = cdev->next_string_id;
1026 
1027  for (; str->s; ++str) {
1028  if (unlikely(next >= 254))
1029  return -ENODEV;
1030  str->id = ++next;
1031  }
1032 
1033  cdev->next_string_id = next;
1034 
1035  return 0;
1036 }
1037 
1057 int usb_string_ids_n(struct usb_composite_dev *c, unsigned n)
1058 {
1059  unsigned next = c->next_string_id;
1060  if (unlikely(n > 254 || (unsigned)next + n > 254))
1061  return -ENODEV;
1062  c->next_string_id += n;
1063  return next + 1;
1064 }
1065 
1066 
1067 /*-------------------------------------------------------------------------*/
1068 
1069 static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
1070 {
1071  if (req->status || req->actual != req->length)
1072  DBG((struct usb_composite_dev *) ep->driver_data,
1073  "setup complete --> %d, %d/%d\n",
1074  req->status, req->actual, req->length);
1075 }
1076 
1077 /*
1078  * The setup() callback implements all the ep0 functionality that's
1079  * not handled lower down, in hardware or the hardware driver(like
1080  * device and endpoint feature flags, and their status). It's all
1081  * housekeeping for the gadget function we're implementing. Most of
1082  * the work is in config and function specific setup.
1083  */
1084 static int
1085 composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1086 {
1087  struct usb_composite_dev *cdev = get_gadget_data(gadget);
1088  struct usb_request *req = cdev->req;
1089  int value = -EOPNOTSUPP;
1090  int status = 0;
1091  u16 w_index = le16_to_cpu(ctrl->wIndex);
1092  u8 intf = w_index & 0xFF;
1093  u16 w_value = le16_to_cpu(ctrl->wValue);
1094  u16 w_length = le16_to_cpu(ctrl->wLength);
1095  struct usb_function *f = NULL;
1096  u8 endp;
1097 
1098  /* partial re-init of the response message; the function or the
1099  * gadget might need to intercept e.g. a control-OUT completion
1100  * when we delegate to it.
1101  */
1102  req->zero = 0;
1103  req->complete = composite_setup_complete;
1104  req->length = 0;
1105  gadget->ep0->driver_data = cdev;
1106 
1107  switch (ctrl->bRequest) {
1108 
1109  /* we handle all standard USB descriptors */
1111  if (ctrl->bRequestType != USB_DIR_IN)
1112  goto unknown;
1113  switch (w_value >> 8) {
1114 
1115  case USB_DT_DEVICE:
1116  cdev->desc.bNumConfigurations =
1117  count_configs(cdev, USB_DT_DEVICE);
1118  cdev->desc.bMaxPacketSize0 =
1119  cdev->gadget->ep0->maxpacket;
1120  if (gadget_is_superspeed(gadget)) {
1121  if (gadget->speed >= USB_SPEED_SUPER) {
1122  cdev->desc.bcdUSB = cpu_to_le16(0x0300);
1123  cdev->desc.bMaxPacketSize0 = 9;
1124  } else {
1125  cdev->desc.bcdUSB = cpu_to_le16(0x0210);
1126  }
1127  }
1128 
1129  value = min(w_length, (u16) sizeof cdev->desc);
1130  memcpy(req->buf, &cdev->desc, value);
1131  break;
1133  if (!gadget_is_dualspeed(gadget) ||
1134  gadget->speed >= USB_SPEED_SUPER)
1135  break;
1136  device_qual(cdev);
1137  value = min_t(int, w_length,
1138  sizeof(struct usb_qualifier_descriptor));
1139  break;
1141  if (!gadget_is_dualspeed(gadget) ||
1142  gadget->speed >= USB_SPEED_SUPER)
1143  break;
1144  /* FALLTHROUGH */
1145  case USB_DT_CONFIG:
1146  value = config_desc(cdev, w_value);
1147  if (value >= 0)
1148  value = min(w_length, (u16) value);
1149  break;
1150  case USB_DT_STRING:
1151  value = get_string(cdev, req->buf,
1152  w_index, w_value & 0xff);
1153  if (value >= 0)
1154  value = min(w_length, (u16) value);
1155  break;
1156  case USB_DT_BOS:
1157  if (gadget_is_superspeed(gadget)) {
1158  value = bos_desc(cdev);
1159  value = min(w_length, (u16) value);
1160  }
1161  break;
1162  }
1163  break;
1164 
1165  /* any number of configs can work */
1167  if (ctrl->bRequestType != 0)
1168  goto unknown;
1169  if (gadget_is_otg(gadget)) {
1170  if (gadget->a_hnp_support)
1171  DBG(cdev, "HNP available\n");
1172  else if (gadget->a_alt_hnp_support)
1173  DBG(cdev, "HNP on another port\n");
1174  else
1175  VDBG(cdev, "HNP inactive\n");
1176  }
1177  spin_lock(&cdev->lock);
1178  value = set_config(cdev, ctrl, w_value);
1179  spin_unlock(&cdev->lock);
1180  break;
1182  if (ctrl->bRequestType != USB_DIR_IN)
1183  goto unknown;
1184  if (cdev->config)
1185  *(u8 *)req->buf = cdev->config->bConfigurationValue;
1186  else
1187  *(u8 *)req->buf = 0;
1188  value = min(w_length, (u16) 1);
1189  break;
1190 
1191  /* function drivers must handle get/set altsetting; if there's
1192  * no get() method, we know only altsetting zero works.
1193  */
1194  case USB_REQ_SET_INTERFACE:
1195  if (ctrl->bRequestType != USB_RECIP_INTERFACE)
1196  goto unknown;
1197  if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1198  break;
1199  f = cdev->config->interface[intf];
1200  if (!f)
1201  break;
1202  if (w_value && !f->set_alt)
1203  break;
1204  value = f->set_alt(f, w_index, w_value);
1205  if (value == USB_GADGET_DELAYED_STATUS) {
1206  DBG(cdev,
1207  "%s: interface %d (%s) requested delayed status\n",
1208  __func__, intf, f->name);
1209  cdev->delayed_status++;
1210  DBG(cdev, "delayed_status count %d\n",
1211  cdev->delayed_status);
1212  }
1213  break;
1214  case USB_REQ_GET_INTERFACE:
1216  goto unknown;
1217  if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1218  break;
1219  f = cdev->config->interface[intf];
1220  if (!f)
1221  break;
1222  /* lots of interfaces only need altsetting zero... */
1223  value = f->get_alt ? f->get_alt(f, w_index) : 0;
1224  if (value < 0)
1225  break;
1226  *((u8 *)req->buf) = value;
1227  value = min(w_length, (u16) 1);
1228  break;
1229 
1230  /*
1231  * USB 3.0 additions:
1232  * Function driver should handle get_status request. If such cb
1233  * wasn't supplied we respond with default value = 0
1234  * Note: function driver should supply such cb only for the first
1235  * interface of the function
1236  */
1237  case USB_REQ_GET_STATUS:
1238  if (!gadget_is_superspeed(gadget))
1239  goto unknown;
1240  if (ctrl->bRequestType != (USB_DIR_IN | USB_RECIP_INTERFACE))
1241  goto unknown;
1242  value = 2; /* This is the length of the get_status reply */
1243  put_unaligned_le16(0, req->buf);
1244  if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1245  break;
1246  f = cdev->config->interface[intf];
1247  if (!f)
1248  break;
1249  status = f->get_status ? f->get_status(f) : 0;
1250  if (status < 0)
1251  break;
1252  put_unaligned_le16(status & 0x0000ffff, req->buf);
1253  break;
1254  /*
1255  * Function drivers should handle SetFeature/ClearFeature
1256  * (FUNCTION_SUSPEND) request. function_suspend cb should be supplied
1257  * only for the first interface of the function
1258  */
1259  case USB_REQ_CLEAR_FEATURE:
1260  case USB_REQ_SET_FEATURE:
1261  if (!gadget_is_superspeed(gadget))
1262  goto unknown;
1263  if (ctrl->bRequestType != (USB_DIR_OUT | USB_RECIP_INTERFACE))
1264  goto unknown;
1265  switch (w_value) {
1267  if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1268  break;
1269  f = cdev->config->interface[intf];
1270  if (!f)
1271  break;
1272  value = 0;
1273  if (f->func_suspend)
1274  value = f->func_suspend(f, w_index >> 8);
1275  if (value < 0) {
1276  ERROR(cdev,
1277  "func_suspend() returned error %d\n",
1278  value);
1279  value = 0;
1280  }
1281  break;
1282  }
1283  break;
1284  default:
1285 unknown:
1286  VDBG(cdev,
1287  "non-core control req%02x.%02x v%04x i%04x l%d\n",
1288  ctrl->bRequestType, ctrl->bRequest,
1289  w_value, w_index, w_length);
1290 
1291  /* functions always handle their interfaces and endpoints...
1292  * punt other recipients (other, WUSB, ...) to the current
1293  * configuration code.
1294  *
1295  * REVISIT it could make sense to let the composite device
1296  * take such requests too, if that's ever needed: to work
1297  * in config 0, etc.
1298  */
1299  switch (ctrl->bRequestType & USB_RECIP_MASK) {
1300  case USB_RECIP_INTERFACE:
1301  if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1302  break;
1303  f = cdev->config->interface[intf];
1304  break;
1305 
1306  case USB_RECIP_ENDPOINT:
1307  endp = ((w_index & 0x80) >> 3) | (w_index & 0x0f);
1308  list_for_each_entry(f, &cdev->config->functions, list) {
1309  if (test_bit(endp, f->endpoints))
1310  break;
1311  }
1312  if (&f->list == &cdev->config->functions)
1313  f = NULL;
1314  break;
1315  }
1316 
1317  if (f && f->setup)
1318  value = f->setup(f, ctrl);
1319  else {
1320  struct usb_configuration *c;
1321 
1322  c = cdev->config;
1323  if (c && c->setup)
1324  value = c->setup(c, ctrl);
1325  }
1326 
1327  goto done;
1328  }
1329 
1330  /* respond with data transfer before status phase? */
1331  if (value >= 0 && value != USB_GADGET_DELAYED_STATUS) {
1332  req->length = value;
1333  req->zero = value < w_length;
1334  value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1335  if (value < 0) {
1336  DBG(cdev, "ep_queue --> %d\n", value);
1337  req->status = 0;
1338  composite_setup_complete(gadget->ep0, req);
1339  }
1340  } else if (value == USB_GADGET_DELAYED_STATUS && w_length != 0) {
1341  WARN(cdev,
1342  "%s: Delayed status not supported for w_length != 0",
1343  __func__);
1344  }
1345 
1346 done:
1347  /* device either stalls (value < 0) or reports success */
1348  return value;
1349 }
1350 
1351 static void composite_disconnect(struct usb_gadget *gadget)
1352 {
1353  struct usb_composite_dev *cdev = get_gadget_data(gadget);
1354  unsigned long flags;
1355 
1356  /* REVISIT: should we have config and device level
1357  * disconnect callbacks?
1358  */
1359  spin_lock_irqsave(&cdev->lock, flags);
1360  if (cdev->config)
1361  reset_config(cdev);
1362  if (composite->disconnect)
1363  composite->disconnect(cdev);
1364  spin_unlock_irqrestore(&cdev->lock, flags);
1365 }
1366 
1367 /*-------------------------------------------------------------------------*/
1368 
1369 static ssize_t composite_show_suspended(struct device *dev,
1370  struct device_attribute *attr,
1371  char *buf)
1372 {
1373  struct usb_gadget *gadget = dev_to_usb_gadget(dev);
1374  struct usb_composite_dev *cdev = get_gadget_data(gadget);
1375 
1376  return sprintf(buf, "%d\n", cdev->suspended);
1377 }
1378 
1379 static DEVICE_ATTR(suspended, 0444, composite_show_suspended, NULL);
1380 
1381 static void
1382 composite_unbind(struct usb_gadget *gadget)
1383 {
1384  struct usb_composite_dev *cdev = get_gadget_data(gadget);
1385 
1386  /* composite_disconnect() must already have been called
1387  * by the underlying peripheral controller driver!
1388  * so there's no i/o concurrency that could affect the
1389  * state protected by cdev->lock.
1390  */
1391  WARN_ON(cdev->config);
1392 
1393  while (!list_empty(&cdev->configs)) {
1394  struct usb_configuration *c;
1395  c = list_first_entry(&cdev->configs,
1396  struct usb_configuration, list);
1397  remove_config(cdev, c);
1398  }
1399  if (composite->unbind)
1400  composite->unbind(cdev);
1401 
1402  if (cdev->req) {
1403  kfree(cdev->req->buf);
1404  usb_ep_free_request(gadget->ep0, cdev->req);
1405  }
1406  device_remove_file(&gadget->dev, &dev_attr_suspended);
1407  kfree(cdev);
1408  set_gadget_data(gadget, NULL);
1409  composite = NULL;
1410 }
1411 
1412 static u8 override_id(struct usb_composite_dev *cdev, u8 *desc)
1413 {
1414  if (!*desc) {
1415  int ret = usb_string_id(cdev);
1416  if (unlikely(ret < 0))
1417  WARNING(cdev, "failed to override string ID\n");
1418  else
1419  *desc = ret;
1420  }
1421 
1422  return *desc;
1423 }
1424 
1425 static int composite_bind(struct usb_gadget *gadget,
1426  struct usb_gadget_driver *driver)
1427 {
1428  struct usb_composite_dev *cdev;
1429  int status = -ENOMEM;
1430 
1431  cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
1432  if (!cdev)
1433  return status;
1434 
1435  spin_lock_init(&cdev->lock);
1436  cdev->gadget = gadget;
1437  set_gadget_data(gadget, cdev);
1438  INIT_LIST_HEAD(&cdev->configs);
1439 
1440  /* preallocate control response and buffer */
1441  cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
1442  if (!cdev->req)
1443  goto fail;
1444  cdev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
1445  if (!cdev->req->buf)
1446  goto fail;
1447  cdev->req->complete = composite_setup_complete;
1448  gadget->ep0->driver_data = cdev;
1449 
1450  cdev->bufsiz = USB_BUFSIZ;
1451  cdev->driver = composite;
1452 
1453  /*
1454  * As per USB compliance update, a device that is actively drawing
1455  * more than 100mA from USB must report itself as bus-powered in
1456  * the GetStatus(DEVICE) call.
1457  */
1458  if (CONFIG_USB_GADGET_VBUS_DRAW <= USB_SELF_POWER_VBUS_MAX_DRAW)
1459  usb_gadget_set_selfpowered(gadget);
1460 
1461  /* interface and string IDs start at zero via kzalloc.
1462  * we force endpoints to start unassigned; few controller
1463  * drivers will zero ep->driver_data.
1464  */
1466 
1467  /* composite gadget needs to assign strings for whole device (like
1468  * serial number), register function drivers, potentially update
1469  * power state and consumption, etc
1470  */
1471  status = composite->bind(cdev);
1472  if (status < 0)
1473  goto fail;
1474 
1475  cdev->desc = *composite->dev;
1476 
1477  /* standardized runtime overrides for device ID data */
1478  if (idVendor)
1479  cdev->desc.idVendor = cpu_to_le16(idVendor);
1480  else
1481  idVendor = le16_to_cpu(cdev->desc.idVendor);
1482  if (idProduct)
1483  cdev->desc.idProduct = cpu_to_le16(idProduct);
1484  else
1485  idProduct = le16_to_cpu(cdev->desc.idProduct);
1486  if (bcdDevice)
1487  cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);
1488  else
1489  bcdDevice = le16_to_cpu(cdev->desc.bcdDevice);
1490 
1491  /* string overrides */
1492  if (iManufacturer || !cdev->desc.iManufacturer) {
1493  if (!iManufacturer && !composite->iManufacturer &&
1494  !*composite_manufacturer)
1495  snprintf(composite_manufacturer,
1496  sizeof composite_manufacturer,
1497  "%s %s with %s",
1498  init_utsname()->sysname,
1499  init_utsname()->release,
1500  gadget->name);
1501 
1502  cdev->manufacturer_override =
1503  override_id(cdev, &cdev->desc.iManufacturer);
1504  }
1505 
1506  if (iProduct || (!cdev->desc.iProduct && composite->iProduct))
1507  cdev->product_override =
1508  override_id(cdev, &cdev->desc.iProduct);
1509 
1510  if (iSerialNumber ||
1511  (!cdev->desc.iSerialNumber && composite->iSerialNumber))
1512  cdev->serial_override =
1513  override_id(cdev, &cdev->desc.iSerialNumber);
1514 
1515  /* has userspace failed to provide a serial number? */
1516  if (composite->needs_serial && !cdev->desc.iSerialNumber)
1517  WARNING(cdev, "userspace failed to provide iSerialNumber\n");
1518 
1519  /* finish up */
1520  status = device_create_file(&gadget->dev, &dev_attr_suspended);
1521  if (status)
1522  goto fail;
1523 
1524  INFO(cdev, "%s ready\n", composite->name);
1525  return 0;
1526 
1527 fail:
1528  composite_unbind(gadget);
1529  return status;
1530 }
1531 
1532 /*-------------------------------------------------------------------------*/
1533 
1534 static void
1535 composite_suspend(struct usb_gadget *gadget)
1536 {
1537  struct usb_composite_dev *cdev = get_gadget_data(gadget);
1538  struct usb_function *f;
1539 
1540  /* REVISIT: should we have config level
1541  * suspend/resume callbacks?
1542  */
1543  DBG(cdev, "suspend\n");
1544  if (cdev->config) {
1545  list_for_each_entry(f, &cdev->config->functions, list) {
1546  if (f->suspend)
1547  f->suspend(f);
1548  }
1549  }
1550  if (composite->suspend)
1551  composite->suspend(cdev);
1552 
1553  cdev->suspended = 1;
1554 
1555  usb_gadget_vbus_draw(gadget, 2);
1556 }
1557 
1558 static void
1559 composite_resume(struct usb_gadget *gadget)
1560 {
1561  struct usb_composite_dev *cdev = get_gadget_data(gadget);
1562  struct usb_function *f;
1563  u8 maxpower;
1564 
1565  /* REVISIT: should we have config level
1566  * suspend/resume callbacks?
1567  */
1568  DBG(cdev, "resume\n");
1569  if (composite->resume)
1570  composite->resume(cdev);
1571  if (cdev->config) {
1572  list_for_each_entry(f, &cdev->config->functions, list) {
1573  if (f->resume)
1574  f->resume(f);
1575  }
1576 
1577  maxpower = cdev->config->bMaxPower;
1578 
1579  usb_gadget_vbus_draw(gadget, maxpower ?
1580  (2 * maxpower) : CONFIG_USB_GADGET_VBUS_DRAW);
1581  }
1582 
1583  cdev->suspended = 0;
1584 }
1585 
1586 /*-------------------------------------------------------------------------*/
1587 
1588 static struct usb_gadget_driver composite_driver = {
1589  .bind = composite_bind,
1590  .unbind = composite_unbind,
1591 
1592  .setup = composite_setup,
1593  .disconnect = composite_disconnect,
1594 
1595  .suspend = composite_suspend,
1596  .resume = composite_resume,
1597 
1598  .driver = {
1599  .owner = THIS_MODULE,
1600  },
1601 };
1602 
1623 {
1624  if (!driver || !driver->dev || composite || !driver->bind)
1625  return -EINVAL;
1626 
1627  if (!driver->name)
1628  driver->name = "composite";
1629  if (!driver->iProduct)
1630  driver->iProduct = driver->name;
1631  composite_driver.function = (char *) driver->name;
1632  composite_driver.driver.name = driver->name;
1633  composite_driver.max_speed = driver->max_speed;
1634  composite = driver;
1635 
1636  return usb_gadget_probe_driver(&composite_driver);
1637 }
1638 
1647 {
1648  if (composite != driver)
1649  return;
1650  usb_gadget_unregister_driver(&composite_driver);
1651 }
1652 
1664 {
1665  int value;
1666  struct usb_request *req = cdev->req;
1667  unsigned long flags;
1668 
1669  DBG(cdev, "%s\n", __func__);
1670  spin_lock_irqsave(&cdev->lock, flags);
1671 
1672  if (cdev->delayed_status == 0) {
1673  WARN(cdev, "%s: Unexpected call\n", __func__);
1674 
1675  } else if (--cdev->delayed_status == 0) {
1676  DBG(cdev, "%s: Completing delayed status\n", __func__);
1677  req->length = 0;
1678  value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1679  if (value < 0) {
1680  DBG(cdev, "ep_queue --> %d\n", value);
1681  req->status = 0;
1682  composite_setup_complete(cdev->gadget->ep0, req);
1683  }
1684  }
1685 
1686  spin_unlock_irqrestore(&cdev->lock, flags);
1687 }
1688