1
2
3
4
5
6
7
8
9
10
11
12
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
26
27
28
29
30
31static struct usb_gadget_strings **get_containers_gs(
32 struct usb_gadget_string_container *uc)
33{
34 return (struct usb_gadget_strings **)uc->stash;
35}
36
37
38
39
40
41
42
43
44
45
46static struct usb_descriptor_header**
47next_ep_desc(struct usb_descriptor_header **t)
48{
49 for (; *t; t++) {
50 if ((*t)->bDescriptorType == USB_DT_ENDPOINT)
51 return t;
52 }
53 return NULL;
54}
55
56
57
58
59
60
61
62#define for_each_ep_desc(start, ep_desc) \
63 for (ep_desc = next_ep_desc(start); \
64 ep_desc; ep_desc = next_ep_desc(ep_desc+1))
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84int config_ep_by_speed(struct usb_gadget *g,
85 struct usb_function *f,
86 struct usb_ep *_ep)
87{
88 struct usb_composite_dev *cdev = get_gadget_data(g);
89 struct usb_endpoint_descriptor *chosen_desc = NULL;
90 struct usb_descriptor_header **speed_desc = NULL;
91
92 struct usb_ss_ep_comp_descriptor *comp_desc = NULL;
93 int want_comp_desc = 0;
94
95 struct usb_descriptor_header **d_spd;
96
97 if (!g || !f || !_ep)
98 return -EIO;
99
100
101 switch (g->speed) {
102 case USB_SPEED_SUPER:
103 if (gadget_is_superspeed(g)) {
104 speed_desc = f->ss_descriptors;
105 want_comp_desc = 1;
106 break;
107 }
108
109 case USB_SPEED_HIGH:
110 if (gadget_is_dualspeed(g)) {
111 speed_desc = f->hs_descriptors;
112 break;
113 }
114
115 default:
116 speed_desc = f->fs_descriptors;
117 }
118
119 for_each_ep_desc(speed_desc, d_spd) {
120 chosen_desc = (struct usb_endpoint_descriptor *)*d_spd;
121 if (chosen_desc->bEndpointAddress == _ep->address)
122 goto ep_found;
123 }
124 return -EIO;
125
126ep_found:
127
128 _ep->maxpacket = usb_endpoint_maxp(chosen_desc);
129 _ep->desc = chosen_desc;
130 _ep->comp_desc = NULL;
131 _ep->maxburst = 0;
132 _ep->mult = 0;
133 if (!want_comp_desc)
134 return 0;
135
136
137
138
139
140 comp_desc = (struct usb_ss_ep_comp_descriptor *)*(++d_spd);
141 if (!comp_desc ||
142 (comp_desc->bDescriptorType != USB_DT_SS_ENDPOINT_COMP))
143 return -EIO;
144 _ep->comp_desc = comp_desc;
145 if (g->speed == USB_SPEED_SUPER) {
146 switch (usb_endpoint_type(_ep->desc)) {
147 case USB_ENDPOINT_XFER_ISOC:
148
149 _ep->mult = comp_desc->bmAttributes & 0x3;
150 case USB_ENDPOINT_XFER_BULK:
151 case USB_ENDPOINT_XFER_INT:
152 _ep->maxburst = comp_desc->bMaxBurst + 1;
153 break;
154 default:
155 if (comp_desc->bMaxBurst != 0)
156 ERROR(cdev, "ep0 bMaxBurst must be 0\n");
157 _ep->maxburst = 1;
158 break;
159 }
160 }
161 return 0;
162}
163EXPORT_SYMBOL_GPL(config_ep_by_speed);
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179int usb_add_function(struct usb_configuration *config,
180 struct usb_function *function)
181{
182 int value = -EINVAL;
183
184 DBG(config->cdev, "adding '%s'/%p to config '%s'/%p\n",
185 function->name, function,
186 config->label, config);
187
188 if (!function->set_alt || !function->disable)
189 goto done;
190
191 function->config = config;
192 list_add_tail(&function->list, &config->functions);
193
194
195 if (function->bind) {
196 value = function->bind(config, function);
197 if (value < 0) {
198 list_del(&function->list);
199 function->config = NULL;
200 }
201 } else
202 value = 0;
203
204
205
206
207
208
209 if (!config->fullspeed && function->fs_descriptors)
210 config->fullspeed = true;
211 if (!config->highspeed && function->hs_descriptors)
212 config->highspeed = true;
213 if (!config->superspeed && function->ss_descriptors)
214 config->superspeed = true;
215
216done:
217 if (value)
218 DBG(config->cdev, "adding '%s'/%p --> %d\n",
219 function->name, function, value);
220 return value;
221}
222EXPORT_SYMBOL_GPL(usb_add_function);
223
224void usb_remove_function(struct usb_configuration *c, struct usb_function *f)
225{
226 if (f->disable)
227 f->disable(f);
228
229 bitmap_zero(f->endpoints, 32);
230 list_del(&f->list);
231 if (f->unbind)
232 f->unbind(c, f);
233}
234EXPORT_SYMBOL_GPL(usb_remove_function);
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255int usb_function_deactivate(struct usb_function *function)
256{
257 struct usb_composite_dev *cdev = function->config->cdev;
258 unsigned long flags;
259 int status = 0;
260
261 spin_lock_irqsave(&cdev->lock, flags);
262
263 if (cdev->deactivations == 0)
264 status = usb_gadget_disconnect(cdev->gadget);
265 if (status == 0)
266 cdev->deactivations++;
267
268 spin_unlock_irqrestore(&cdev->lock, flags);
269 return status;
270}
271EXPORT_SYMBOL_GPL(usb_function_deactivate);
272
273
274
275
276
277
278
279
280
281
282
283int usb_function_activate(struct usb_function *function)
284{
285 struct usb_composite_dev *cdev = function->config->cdev;
286 unsigned long flags;
287 int status = 0;
288
289 spin_lock_irqsave(&cdev->lock, flags);
290
291 if (WARN_ON(cdev->deactivations == 0))
292 status = -EINVAL;
293 else {
294 cdev->deactivations--;
295 if (cdev->deactivations == 0)
296 status = usb_gadget_connect(cdev->gadget);
297 }
298
299 spin_unlock_irqrestore(&cdev->lock, flags);
300 return status;
301}
302EXPORT_SYMBOL_GPL(usb_function_activate);
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327int usb_interface_id(struct usb_configuration *config,
328 struct usb_function *function)
329{
330 unsigned id = config->next_interface_id;
331
332 if (id < MAX_CONFIG_INTERFACES) {
333 config->interface[id] = function;
334 config->next_interface_id = id + 1;
335 return id;
336 }
337 return -ENODEV;
338}
339EXPORT_SYMBOL_GPL(usb_interface_id);
340
341static u8 encode_bMaxPower(enum usb_device_speed speed,
342 struct usb_configuration *c)
343{
344 unsigned val;
345
346 if (c->MaxPower)
347 val = c->MaxPower;
348 else
349 val = CONFIG_USB_GADGET_VBUS_DRAW;
350 if (!val)
351 return 0;
352 switch (speed) {
353 case USB_SPEED_SUPER:
354 return DIV_ROUND_UP(val, 8);
355 default:
356 return DIV_ROUND_UP(val, 2);
357 }
358}
359
360static int config_buf(struct usb_configuration *config,
361 enum usb_device_speed speed, void *buf, u8 type)
362{
363 struct usb_config_descriptor *c = buf;
364 void *next = buf + USB_DT_CONFIG_SIZE;
365 int len;
366 struct usb_function *f;
367 int status;
368
369 len = USB_COMP_EP0_BUFSIZ - USB_DT_CONFIG_SIZE;
370
371 c = buf;
372 c->bLength = USB_DT_CONFIG_SIZE;
373 c->bDescriptorType = type;
374
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 = encode_bMaxPower(speed, config);
380
381
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
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->fs_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
442 w_value &= 0xff;
443 list_for_each_entry(c, &cdev->configs, list) {
444
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
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
501
502
503
504
505
506
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
523
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
535
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;
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
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_DEFAULT_U1_DEV_EXIT_LAT;
555 dcd_config_params.bU2DevExitLat =
556 cpu_to_le16(USB_DEFAULT_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
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
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 cdev->delayed_status = 0;
597}
598
599static int set_config(struct usb_composite_dev *cdev,
600 const struct usb_ctrlrequest *ctrl, unsigned number)
601{
602 struct usb_gadget *gadget = cdev->gadget;
603 struct usb_configuration *c = NULL;
604 int result = -EINVAL;
605 unsigned power = gadget_is_otg(gadget) ? 8 : 100;
606 int tmp;
607
608 if (number) {
609 list_for_each_entry(c, &cdev->configs, list) {
610 if (c->bConfigurationValue == number) {
611
612
613
614
615
616 if (cdev->config)
617 reset_config(cdev);
618 result = 0;
619 break;
620 }
621 }
622 if (result < 0)
623 goto done;
624 } else {
625 if (cdev->config)
626 reset_config(cdev);
627 result = 0;
628 }
629
630 INFO(cdev, "%s config #%d: %s\n",
631 usb_speed_string(gadget->speed),
632 number, c ? c->label : "unconfigured");
633
634 if (!c)
635 goto done;
636
637 cdev->config = c;
638
639
640 for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
641 struct usb_function *f = c->interface[tmp];
642 struct usb_descriptor_header **descriptors;
643
644 if (!f)
645 break;
646
647
648
649
650
651
652
653 switch (gadget->speed) {
654 case USB_SPEED_SUPER:
655 descriptors = f->ss_descriptors;
656 break;
657 case USB_SPEED_HIGH:
658 descriptors = f->hs_descriptors;
659 break;
660 default:
661 descriptors = f->fs_descriptors;
662 }
663
664 for (; *descriptors; ++descriptors) {
665 struct usb_endpoint_descriptor *ep;
666 int addr;
667
668 if ((*descriptors)->bDescriptorType != USB_DT_ENDPOINT)
669 continue;
670
671 ep = (struct usb_endpoint_descriptor *)*descriptors;
672 addr = ((ep->bEndpointAddress & 0x80) >> 3)
673 | (ep->bEndpointAddress & 0x0f);
674 set_bit(addr, f->endpoints);
675 }
676
677 result = f->set_alt(f, tmp, 0);
678 if (result < 0) {
679 DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
680 tmp, f->name, f, result);
681
682 reset_config(cdev);
683 goto done;
684 }
685
686 if (result == USB_GADGET_DELAYED_STATUS) {
687 DBG(cdev,
688 "%s: interface %d (%s) requested delayed status\n",
689 __func__, tmp, f->name);
690 cdev->delayed_status++;
691 DBG(cdev, "delayed_status count %d\n",
692 cdev->delayed_status);
693 }
694 }
695
696
697 power = c->MaxPower ? c->MaxPower : CONFIG_USB_GADGET_VBUS_DRAW;
698done:
699 usb_gadget_vbus_draw(gadget, power);
700 if (result >= 0 && cdev->delayed_status)
701 result = USB_GADGET_DELAYED_STATUS;
702 return result;
703}
704
705int usb_add_config_only(struct usb_composite_dev *cdev,
706 struct usb_configuration *config)
707{
708 struct usb_configuration *c;
709
710 if (!config->bConfigurationValue)
711 return -EINVAL;
712
713
714 list_for_each_entry(c, &cdev->configs, list) {
715 if (c->bConfigurationValue == config->bConfigurationValue)
716 return -EBUSY;
717 }
718
719 config->cdev = cdev;
720 list_add_tail(&config->list, &cdev->configs);
721
722 INIT_LIST_HEAD(&config->functions);
723 config->next_interface_id = 0;
724 memset(config->interface, 0, sizeof(config->interface));
725
726 return 0;
727}
728EXPORT_SYMBOL_GPL(usb_add_config_only);
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745int usb_add_config(struct usb_composite_dev *cdev,
746 struct usb_configuration *config,
747 int (*bind)(struct usb_configuration *))
748{
749 int status = -EINVAL;
750
751 if (!bind)
752 goto done;
753
754 DBG(cdev, "adding config #%u '%s'/%p\n",
755 config->bConfigurationValue,
756 config->label, config);
757
758 status = usb_add_config_only(cdev, config);
759 if (status)
760 goto done;
761
762 status = bind(config);
763 if (status < 0) {
764 while (!list_empty(&config->functions)) {
765 struct usb_function *f;
766
767 f = list_first_entry(&config->functions,
768 struct usb_function, list);
769 list_del(&f->list);
770 if (f->unbind) {
771 DBG(cdev, "unbind function '%s'/%p\n",
772 f->name, f);
773 f->unbind(config, f);
774
775 }
776 }
777 list_del(&config->list);
778 config->cdev = NULL;
779 } else {
780 unsigned i;
781
782 DBG(cdev, "cfg %d/%p speeds:%s%s%s\n",
783 config->bConfigurationValue, config,
784 config->superspeed ? " super" : "",
785 config->highspeed ? " high" : "",
786 config->fullspeed
787 ? (gadget_is_dualspeed(cdev->gadget)
788 ? " full"
789 : " full/low")
790 : "");
791
792 for (i = 0; i < MAX_CONFIG_INTERFACES; i++) {
793 struct usb_function *f = config->interface[i];
794
795 if (!f)
796 continue;
797 DBG(cdev, " interface %d = %s/%p\n",
798 i, f->name, f);
799 }
800 }
801
802
803
804
805 usb_ep_autoconfig_reset(cdev->gadget);
806
807done:
808 if (status)
809 DBG(cdev, "added config '%s'/%u --> %d\n", config->label,
810 config->bConfigurationValue, status);
811 return status;
812}
813EXPORT_SYMBOL_GPL(usb_add_config);
814
815static void remove_config(struct usb_composite_dev *cdev,
816 struct usb_configuration *config)
817{
818 while (!list_empty(&config->functions)) {
819 struct usb_function *f;
820
821 f = list_first_entry(&config->functions,
822 struct usb_function, list);
823 list_del(&f->list);
824 if (f->unbind) {
825 DBG(cdev, "unbind function '%s'/%p\n", f->name, f);
826 f->unbind(config, f);
827
828 }
829 }
830 list_del(&config->list);
831 if (config->unbind) {
832 DBG(cdev, "unbind config '%s'/%p\n", config->label, config);
833 config->unbind(config);
834
835 }
836}
837
838
839
840
841
842
843
844
845
846
847void usb_remove_config(struct usb_composite_dev *cdev,
848 struct usb_configuration *config)
849{
850 unsigned long flags;
851
852 spin_lock_irqsave(&cdev->lock, flags);
853
854 if (cdev->config == config)
855 reset_config(cdev);
856
857 spin_unlock_irqrestore(&cdev->lock, flags);
858
859 remove_config(cdev, config);
860}
861
862
863
864
865
866
867
868
869
870static void collect_langs(struct usb_gadget_strings **sp, __le16 *buf)
871{
872 const struct usb_gadget_strings *s;
873 __le16 language;
874 __le16 *tmp;
875
876 while (*sp) {
877 s = *sp;
878 language = cpu_to_le16(s->language);
879 for (tmp = buf; *tmp && tmp < &buf[126]; tmp++) {
880 if (*tmp == language)
881 goto repeat;
882 }
883 *tmp++ = language;
884repeat:
885 sp++;
886 }
887}
888
889static int lookup_string(
890 struct usb_gadget_strings **sp,
891 void *buf,
892 u16 language,
893 int id
894)
895{
896 struct usb_gadget_strings *s;
897 int value;
898
899 while (*sp) {
900 s = *sp++;
901 if (s->language != language)
902 continue;
903 value = usb_gadget_get_string(s, id, buf);
904 if (value > 0)
905 return value;
906 }
907 return -EINVAL;
908}
909
910static int get_string(struct usb_composite_dev *cdev,
911 void *buf, u16 language, int id)
912{
913 struct usb_composite_driver *composite = cdev->driver;
914 struct usb_gadget_string_container *uc;
915 struct usb_configuration *c;
916 struct usb_function *f;
917 int len;
918
919
920
921
922
923
924
925 if (id == 0) {
926 struct usb_string_descriptor *s = buf;
927 struct usb_gadget_strings **sp;
928
929 memset(s, 0, 256);
930 s->bDescriptorType = USB_DT_STRING;
931
932 sp = composite->strings;
933 if (sp)
934 collect_langs(sp, s->wData);
935
936 list_for_each_entry(c, &cdev->configs, list) {
937 sp = c->strings;
938 if (sp)
939 collect_langs(sp, s->wData);
940
941 list_for_each_entry(f, &c->functions, list) {
942 sp = f->strings;
943 if (sp)
944 collect_langs(sp, s->wData);
945 }
946 }
947 list_for_each_entry(uc, &cdev->gstrings, list) {
948 struct usb_gadget_strings **sp;
949
950 sp = get_containers_gs(uc);
951 collect_langs(sp, s->wData);
952 }
953
954 for (len = 0; len <= 126 && s->wData[len]; len++)
955 continue;
956 if (!len)
957 return -EINVAL;
958
959 s->bLength = 2 * (len + 1);
960 return s->bLength;
961 }
962
963 list_for_each_entry(uc, &cdev->gstrings, list) {
964 struct usb_gadget_strings **sp;
965
966 sp = get_containers_gs(uc);
967 len = lookup_string(sp, buf, language, id);
968 if (len > 0)
969 return len;
970 }
971
972
973
974
975
976 if (composite->strings) {
977 len = lookup_string(composite->strings, buf, language, id);
978 if (len > 0)
979 return len;
980 }
981 list_for_each_entry(c, &cdev->configs, list) {
982 if (c->strings) {
983 len = lookup_string(c->strings, buf, language, id);
984 if (len > 0)
985 return len;
986 }
987 list_for_each_entry(f, &c->functions, list) {
988 if (!f->strings)
989 continue;
990 len = lookup_string(f->strings, buf, language, id);
991 if (len > 0)
992 return len;
993 }
994 }
995 return -EINVAL;
996}
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012int usb_string_id(struct usb_composite_dev *cdev)
1013{
1014 if (cdev->next_string_id < 254) {
1015
1016
1017
1018 cdev->next_string_id++;
1019 return cdev->next_string_id;
1020 }
1021 return -ENODEV;
1022}
1023EXPORT_SYMBOL_GPL(usb_string_id);
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041int usb_string_ids_tab(struct usb_composite_dev *cdev, struct usb_string *str)
1042{
1043 int next = cdev->next_string_id;
1044
1045 for (; str->s; ++str) {
1046 if (unlikely(next >= 254))
1047 return -ENODEV;
1048 str->id = ++next;
1049 }
1050
1051 cdev->next_string_id = next;
1052
1053 return 0;
1054}
1055EXPORT_SYMBOL_GPL(usb_string_ids_tab);
1056
1057static struct usb_gadget_string_container *copy_gadget_strings(
1058 struct usb_gadget_strings **sp, unsigned n_gstrings,
1059 unsigned n_strings)
1060{
1061 struct usb_gadget_string_container *uc;
1062 struct usb_gadget_strings **gs_array;
1063 struct usb_gadget_strings *gs;
1064 struct usb_string *s;
1065 unsigned mem;
1066 unsigned n_gs;
1067 unsigned n_s;
1068 void *stash;
1069
1070 mem = sizeof(*uc);
1071 mem += sizeof(void *) * (n_gstrings + 1);
1072 mem += sizeof(struct usb_gadget_strings) * n_gstrings;
1073 mem += sizeof(struct usb_string) * (n_strings + 1) * (n_gstrings);
1074 uc = kmalloc(mem, GFP_KERNEL);
1075 if (!uc)
1076 return ERR_PTR(-ENOMEM);
1077 gs_array = get_containers_gs(uc);
1078 stash = uc->stash;
1079 stash += sizeof(void *) * (n_gstrings + 1);
1080 for (n_gs = 0; n_gs < n_gstrings; n_gs++) {
1081 struct usb_string *org_s;
1082
1083 gs_array[n_gs] = stash;
1084 gs = gs_array[n_gs];
1085 stash += sizeof(struct usb_gadget_strings);
1086 gs->language = sp[n_gs]->language;
1087 gs->strings = stash;
1088 org_s = sp[n_gs]->strings;
1089
1090 for (n_s = 0; n_s < n_strings; n_s++) {
1091 s = stash;
1092 stash += sizeof(struct usb_string);
1093 if (org_s->s)
1094 s->s = org_s->s;
1095 else
1096 s->s = "";
1097 org_s++;
1098 }
1099 s = stash;
1100 s->s = NULL;
1101 stash += sizeof(struct usb_string);
1102
1103 }
1104 gs_array[n_gs] = NULL;
1105 return uc;
1106}
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125struct usb_string *usb_gstrings_attach(struct usb_composite_dev *cdev,
1126 struct usb_gadget_strings **sp, unsigned n_strings)
1127{
1128 struct usb_gadget_string_container *uc;
1129 struct usb_gadget_strings **n_gs;
1130 unsigned n_gstrings = 0;
1131 unsigned i;
1132 int ret;
1133
1134 for (i = 0; sp[i]; i++)
1135 n_gstrings++;
1136
1137 if (!n_gstrings)
1138 return ERR_PTR(-EINVAL);
1139
1140 uc = copy_gadget_strings(sp, n_gstrings, n_strings);
1141 if (IS_ERR(uc))
1142 return ERR_CAST(uc);
1143
1144 n_gs = get_containers_gs(uc);
1145 ret = usb_string_ids_tab(cdev, n_gs[0]->strings);
1146 if (ret)
1147 goto err;
1148
1149 for (i = 1; i < n_gstrings; i++) {
1150 struct usb_string *m_s;
1151 struct usb_string *s;
1152 unsigned n;
1153
1154 m_s = n_gs[0]->strings;
1155 s = n_gs[i]->strings;
1156 for (n = 0; n < n_strings; n++) {
1157 s->id = m_s->id;
1158 s++;
1159 m_s++;
1160 }
1161 }
1162 list_add_tail(&uc->list, &cdev->gstrings);
1163 return n_gs[0]->strings;
1164err:
1165 kfree(uc);
1166 return ERR_PTR(ret);
1167}
1168EXPORT_SYMBOL_GPL(usb_gstrings_attach);
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189int usb_string_ids_n(struct usb_composite_dev *c, unsigned n)
1190{
1191 unsigned next = c->next_string_id;
1192 if (unlikely(n > 254 || (unsigned)next + n > 254))
1193 return -ENODEV;
1194 c->next_string_id += n;
1195 return next + 1;
1196}
1197EXPORT_SYMBOL_GPL(usb_string_ids_n);
1198
1199
1200
1201static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
1202{
1203 if (req->status || req->actual != req->length)
1204 DBG((struct usb_composite_dev *) ep->driver_data,
1205 "setup complete --> %d, %d/%d\n",
1206 req->status, req->actual, req->length);
1207}
1208
1209
1210
1211
1212
1213
1214
1215
1216int
1217composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1218{
1219 struct usb_composite_dev *cdev = get_gadget_data(gadget);
1220 struct usb_request *req = cdev->req;
1221 int value = -EOPNOTSUPP;
1222 int status = 0;
1223 u16 w_index = le16_to_cpu(ctrl->wIndex);
1224 u8 intf = w_index & 0xFF;
1225 u16 w_value = le16_to_cpu(ctrl->wValue);
1226 u16 w_length = le16_to_cpu(ctrl->wLength);
1227 struct usb_function *f = NULL;
1228 u8 endp;
1229
1230
1231
1232
1233
1234 req->zero = 0;
1235 req->complete = composite_setup_complete;
1236 req->length = 0;
1237 gadget->ep0->driver_data = cdev;
1238
1239 switch (ctrl->bRequest) {
1240
1241
1242 case USB_REQ_GET_DESCRIPTOR:
1243 if (ctrl->bRequestType != USB_DIR_IN)
1244 goto unknown;
1245 switch (w_value >> 8) {
1246
1247 case USB_DT_DEVICE:
1248 cdev->desc.bNumConfigurations =
1249 count_configs(cdev, USB_DT_DEVICE);
1250 cdev->desc.bMaxPacketSize0 =
1251 cdev->gadget->ep0->maxpacket;
1252 if (gadget_is_superspeed(gadget)) {
1253 if (gadget->speed >= USB_SPEED_SUPER) {
1254 cdev->desc.bcdUSB = cpu_to_le16(0x0300);
1255 cdev->desc.bMaxPacketSize0 = 9;
1256 } else {
1257 cdev->desc.bcdUSB = cpu_to_le16(0x0210);
1258 }
1259 }
1260
1261 value = min(w_length, (u16) sizeof cdev->desc);
1262 memcpy(req->buf, &cdev->desc, value);
1263 break;
1264 case USB_DT_DEVICE_QUALIFIER:
1265 if (!gadget_is_dualspeed(gadget) ||
1266 gadget->speed >= USB_SPEED_SUPER)
1267 break;
1268 device_qual(cdev);
1269 value = min_t(int, w_length,
1270 sizeof(struct usb_qualifier_descriptor));
1271 break;
1272 case USB_DT_OTHER_SPEED_CONFIG:
1273 if (!gadget_is_dualspeed(gadget) ||
1274 gadget->speed >= USB_SPEED_SUPER)
1275 break;
1276
1277 case USB_DT_CONFIG:
1278 value = config_desc(cdev, w_value);
1279 if (value >= 0)
1280 value = min(w_length, (u16) value);
1281 break;
1282 case USB_DT_STRING:
1283 value = get_string(cdev, req->buf,
1284 w_index, w_value & 0xff);
1285 if (value >= 0)
1286 value = min(w_length, (u16) value);
1287 break;
1288 case USB_DT_BOS:
1289 if (gadget_is_superspeed(gadget)) {
1290 value = bos_desc(cdev);
1291 value = min(w_length, (u16) value);
1292 }
1293 break;
1294 }
1295 break;
1296
1297
1298 case USB_REQ_SET_CONFIGURATION:
1299 if (ctrl->bRequestType != 0)
1300 goto unknown;
1301 if (gadget_is_otg(gadget)) {
1302 if (gadget->a_hnp_support)
1303 DBG(cdev, "HNP available\n");
1304 else if (gadget->a_alt_hnp_support)
1305 DBG(cdev, "HNP on another port\n");
1306 else
1307 VDBG(cdev, "HNP inactive\n");
1308 }
1309 spin_lock(&cdev->lock);
1310 value = set_config(cdev, ctrl, w_value);
1311 spin_unlock(&cdev->lock);
1312 break;
1313 case USB_REQ_GET_CONFIGURATION:
1314 if (ctrl->bRequestType != USB_DIR_IN)
1315 goto unknown;
1316 if (cdev->config)
1317 *(u8 *)req->buf = cdev->config->bConfigurationValue;
1318 else
1319 *(u8 *)req->buf = 0;
1320 value = min(w_length, (u16) 1);
1321 break;
1322
1323
1324
1325
1326 case USB_REQ_SET_INTERFACE:
1327 if (ctrl->bRequestType != USB_RECIP_INTERFACE)
1328 goto unknown;
1329 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1330 break;
1331 f = cdev->config->interface[intf];
1332 if (!f)
1333 break;
1334 if (w_value && !f->set_alt)
1335 break;
1336 value = f->set_alt(f, w_index, w_value);
1337 if (value == USB_GADGET_DELAYED_STATUS) {
1338 DBG(cdev,
1339 "%s: interface %d (%s) requested delayed status\n",
1340 __func__, intf, f->name);
1341 cdev->delayed_status++;
1342 DBG(cdev, "delayed_status count %d\n",
1343 cdev->delayed_status);
1344 }
1345 break;
1346 case USB_REQ_GET_INTERFACE:
1347 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
1348 goto unknown;
1349 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1350 break;
1351 f = cdev->config->interface[intf];
1352 if (!f)
1353 break;
1354
1355 value = f->get_alt ? f->get_alt(f, w_index) : 0;
1356 if (value < 0)
1357 break;
1358 *((u8 *)req->buf) = value;
1359 value = min(w_length, (u16) 1);
1360 break;
1361
1362
1363
1364
1365
1366
1367
1368
1369 case USB_REQ_GET_STATUS:
1370 if (!gadget_is_superspeed(gadget))
1371 goto unknown;
1372 if (ctrl->bRequestType != (USB_DIR_IN | USB_RECIP_INTERFACE))
1373 goto unknown;
1374 value = 2;
1375 put_unaligned_le16(0, req->buf);
1376 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1377 break;
1378 f = cdev->config->interface[intf];
1379 if (!f)
1380 break;
1381 status = f->get_status ? f->get_status(f) : 0;
1382 if (status < 0)
1383 break;
1384 put_unaligned_le16(status & 0x0000ffff, req->buf);
1385 break;
1386
1387
1388
1389
1390
1391 case USB_REQ_CLEAR_FEATURE:
1392 case USB_REQ_SET_FEATURE:
1393 if (!gadget_is_superspeed(gadget))
1394 goto unknown;
1395 if (ctrl->bRequestType != (USB_DIR_OUT | USB_RECIP_INTERFACE))
1396 goto unknown;
1397 switch (w_value) {
1398 case USB_INTRF_FUNC_SUSPEND:
1399 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1400 break;
1401 f = cdev->config->interface[intf];
1402 if (!f)
1403 break;
1404 value = 0;
1405 if (f->func_suspend)
1406 value = f->func_suspend(f, w_index >> 8);
1407 if (value < 0) {
1408 ERROR(cdev,
1409 "func_suspend() returned error %d\n",
1410 value);
1411 value = 0;
1412 }
1413 break;
1414 }
1415 break;
1416 default:
1417unknown:
1418 VDBG(cdev,
1419 "non-core control req%02x.%02x v%04x i%04x l%d\n",
1420 ctrl->bRequestType, ctrl->bRequest,
1421 w_value, w_index, w_length);
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431 switch (ctrl->bRequestType & USB_RECIP_MASK) {
1432 case USB_RECIP_INTERFACE:
1433 if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
1434 break;
1435 f = cdev->config->interface[intf];
1436 break;
1437
1438 case USB_RECIP_ENDPOINT:
1439 endp = ((w_index & 0x80) >> 3) | (w_index & 0x0f);
1440 list_for_each_entry(f, &cdev->config->functions, list) {
1441 if (test_bit(endp, f->endpoints))
1442 break;
1443 }
1444 if (&f->list == &cdev->config->functions)
1445 f = NULL;
1446 break;
1447 }
1448
1449 if (f && f->setup)
1450 value = f->setup(f, ctrl);
1451 else {
1452 struct usb_configuration *c;
1453
1454 c = cdev->config;
1455 if (!c)
1456 goto done;
1457
1458
1459 if (c->setup) {
1460 value = c->setup(c, ctrl);
1461 goto done;
1462 }
1463
1464
1465 if (!list_is_singular(&c->functions))
1466 goto done;
1467 f = list_first_entry(&c->functions, struct usb_function,
1468 list);
1469 if (f->setup)
1470 value = f->setup(f, ctrl);
1471 }
1472
1473 goto done;
1474 }
1475
1476
1477 if (value >= 0 && value != USB_GADGET_DELAYED_STATUS) {
1478 req->length = value;
1479 req->zero = value < w_length;
1480 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1481 if (value < 0) {
1482 DBG(cdev, "ep_queue --> %d\n", value);
1483 req->status = 0;
1484 composite_setup_complete(gadget->ep0, req);
1485 }
1486 } else if (value == USB_GADGET_DELAYED_STATUS && w_length != 0) {
1487 WARN(cdev,
1488 "%s: Delayed status not supported for w_length != 0",
1489 __func__);
1490 }
1491
1492done:
1493
1494 return value;
1495}
1496
1497void composite_disconnect(struct usb_gadget *gadget)
1498{
1499 struct usb_composite_dev *cdev = get_gadget_data(gadget);
1500 unsigned long flags;
1501
1502
1503
1504
1505 spin_lock_irqsave(&cdev->lock, flags);
1506 if (cdev->config)
1507 reset_config(cdev);
1508 if (cdev->driver->disconnect)
1509 cdev->driver->disconnect(cdev);
1510 spin_unlock_irqrestore(&cdev->lock, flags);
1511}
1512
1513
1514
1515static ssize_t suspended_show(struct device *dev, struct device_attribute *attr,
1516 char *buf)
1517{
1518 struct usb_gadget *gadget = dev_to_usb_gadget(dev);
1519 struct usb_composite_dev *cdev = get_gadget_data(gadget);
1520
1521 return sprintf(buf, "%d\n", cdev->suspended);
1522}
1523static DEVICE_ATTR_RO(suspended);
1524
1525static void __composite_unbind(struct usb_gadget *gadget, bool unbind_driver)
1526{
1527 struct usb_composite_dev *cdev = get_gadget_data(gadget);
1528
1529
1530
1531
1532
1533
1534 WARN_ON(cdev->config);
1535
1536 while (!list_empty(&cdev->configs)) {
1537 struct usb_configuration *c;
1538 c = list_first_entry(&cdev->configs,
1539 struct usb_configuration, list);
1540 remove_config(cdev, c);
1541 }
1542 if (cdev->driver->unbind && unbind_driver)
1543 cdev->driver->unbind(cdev);
1544
1545 composite_dev_cleanup(cdev);
1546
1547 kfree(cdev->def_manufacturer);
1548 kfree(cdev);
1549 set_gadget_data(gadget, NULL);
1550}
1551
1552static void composite_unbind(struct usb_gadget *gadget)
1553{
1554 __composite_unbind(gadget, true);
1555}
1556
1557static void update_unchanged_dev_desc(struct usb_device_descriptor *new,
1558 const struct usb_device_descriptor *old)
1559{
1560 __le16 idVendor;
1561 __le16 idProduct;
1562 __le16 bcdDevice;
1563 u8 iSerialNumber;
1564 u8 iManufacturer;
1565 u8 iProduct;
1566
1567
1568
1569
1570
1571 idVendor = new->idVendor;
1572 idProduct = new->idProduct;
1573 bcdDevice = new->bcdDevice;
1574 iSerialNumber = new->iSerialNumber;
1575 iManufacturer = new->iManufacturer;
1576 iProduct = new->iProduct;
1577
1578 *new = *old;
1579 if (idVendor)
1580 new->idVendor = idVendor;
1581 if (idProduct)
1582 new->idProduct = idProduct;
1583 if (bcdDevice)
1584 new->bcdDevice = bcdDevice;
1585 else
1586 new->bcdDevice = cpu_to_le16(get_default_bcdDevice());
1587 if (iSerialNumber)
1588 new->iSerialNumber = iSerialNumber;
1589 if (iManufacturer)
1590 new->iManufacturer = iManufacturer;
1591 if (iProduct)
1592 new->iProduct = iProduct;
1593}
1594
1595int composite_dev_prepare(struct usb_composite_driver *composite,
1596 struct usb_composite_dev *cdev)
1597{
1598 struct usb_gadget *gadget = cdev->gadget;
1599 int ret = -ENOMEM;
1600
1601
1602 cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
1603 if (!cdev->req)
1604 return -ENOMEM;
1605
1606 cdev->req->buf = kmalloc(USB_COMP_EP0_BUFSIZ, GFP_KERNEL);
1607 if (!cdev->req->buf)
1608 goto fail;
1609
1610 ret = device_create_file(&gadget->dev, &dev_attr_suspended);
1611 if (ret)
1612 goto fail_dev;
1613
1614 cdev->req->complete = composite_setup_complete;
1615 gadget->ep0->driver_data = cdev;
1616
1617 cdev->driver = composite;
1618
1619
1620
1621
1622
1623
1624 if (CONFIG_USB_GADGET_VBUS_DRAW <= USB_SELF_POWER_VBUS_MAX_DRAW)
1625 usb_gadget_set_selfpowered(gadget);
1626
1627
1628
1629
1630
1631 usb_ep_autoconfig_reset(gadget);
1632 return 0;
1633fail_dev:
1634 kfree(cdev->req->buf);
1635fail:
1636 usb_ep_free_request(gadget->ep0, cdev->req);
1637 cdev->req = NULL;
1638 return ret;
1639}
1640
1641void composite_dev_cleanup(struct usb_composite_dev *cdev)
1642{
1643 struct usb_gadget_string_container *uc, *tmp;
1644
1645 list_for_each_entry_safe(uc, tmp, &cdev->gstrings, list) {
1646 list_del(&uc->list);
1647 kfree(uc);
1648 }
1649 if (cdev->req) {
1650 kfree(cdev->req->buf);
1651 usb_ep_free_request(cdev->gadget->ep0, cdev->req);
1652 }
1653 cdev->next_string_id = 0;
1654 device_remove_file(&cdev->gadget->dev, &dev_attr_suspended);
1655}
1656
1657static int composite_bind(struct usb_gadget *gadget,
1658 struct usb_gadget_driver *gdriver)
1659{
1660 struct usb_composite_dev *cdev;
1661 struct usb_composite_driver *composite = to_cdriver(gdriver);
1662 int status = -ENOMEM;
1663
1664 cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
1665 if (!cdev)
1666 return status;
1667
1668 spin_lock_init(&cdev->lock);
1669 cdev->gadget = gadget;
1670 set_gadget_data(gadget, cdev);
1671 INIT_LIST_HEAD(&cdev->configs);
1672 INIT_LIST_HEAD(&cdev->gstrings);
1673
1674 status = composite_dev_prepare(composite, cdev);
1675 if (status)
1676 goto fail;
1677
1678
1679
1680
1681
1682 status = composite->bind(cdev);
1683 if (status < 0)
1684 goto fail;
1685
1686 update_unchanged_dev_desc(&cdev->desc, composite->dev);
1687
1688
1689 if (composite->needs_serial && !cdev->desc.iSerialNumber)
1690 WARNING(cdev, "userspace failed to provide iSerialNumber\n");
1691
1692 INFO(cdev, "%s ready\n", composite->name);
1693 return 0;
1694
1695fail:
1696 __composite_unbind(gadget, false);
1697 return status;
1698}
1699
1700
1701
1702static void
1703composite_suspend(struct usb_gadget *gadget)
1704{
1705 struct usb_composite_dev *cdev = get_gadget_data(gadget);
1706 struct usb_function *f;
1707
1708
1709
1710
1711 DBG(cdev, "suspend\n");
1712 if (cdev->config) {
1713 list_for_each_entry(f, &cdev->config->functions, list) {
1714 if (f->suspend)
1715 f->suspend(f);
1716 }
1717 }
1718 if (cdev->driver->suspend)
1719 cdev->driver->suspend(cdev);
1720
1721 cdev->suspended = 1;
1722
1723 usb_gadget_vbus_draw(gadget, 2);
1724}
1725
1726static void
1727composite_resume(struct usb_gadget *gadget)
1728{
1729 struct usb_composite_dev *cdev = get_gadget_data(gadget);
1730 struct usb_function *f;
1731 u16 maxpower;
1732
1733
1734
1735
1736 DBG(cdev, "resume\n");
1737 if (cdev->driver->resume)
1738 cdev->driver->resume(cdev);
1739 if (cdev->config) {
1740 list_for_each_entry(f, &cdev->config->functions, list) {
1741 if (f->resume)
1742 f->resume(f);
1743 }
1744
1745 maxpower = cdev->config->MaxPower;
1746
1747 usb_gadget_vbus_draw(gadget, maxpower ?
1748 maxpower : CONFIG_USB_GADGET_VBUS_DRAW);
1749 }
1750
1751 cdev->suspended = 0;
1752}
1753
1754
1755
1756static const struct usb_gadget_driver composite_driver_template = {
1757 .bind = composite_bind,
1758 .unbind = composite_unbind,
1759
1760 .setup = composite_setup,
1761 .disconnect = composite_disconnect,
1762
1763 .suspend = composite_suspend,
1764 .resume = composite_resume,
1765
1766 .driver = {
1767 .owner = THIS_MODULE,
1768 },
1769};
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787int usb_composite_probe(struct usb_composite_driver *driver)
1788{
1789 struct usb_gadget_driver *gadget_driver;
1790
1791 if (!driver || !driver->dev || !driver->bind)
1792 return -EINVAL;
1793
1794 if (!driver->name)
1795 driver->name = "composite";
1796
1797 driver->gadget_driver = composite_driver_template;
1798 gadget_driver = &driver->gadget_driver;
1799
1800 gadget_driver->function = (char *) driver->name;
1801 gadget_driver->driver.name = driver->name;
1802 gadget_driver->max_speed = driver->max_speed;
1803
1804 return usb_gadget_probe_driver(gadget_driver);
1805}
1806EXPORT_SYMBOL_GPL(usb_composite_probe);
1807
1808
1809
1810
1811
1812
1813
1814
1815void usb_composite_unregister(struct usb_composite_driver *driver)
1816{
1817 usb_gadget_unregister_driver(&driver->gadget_driver);
1818}
1819EXPORT_SYMBOL_GPL(usb_composite_unregister);
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831void usb_composite_setup_continue(struct usb_composite_dev *cdev)
1832{
1833 int value;
1834 struct usb_request *req = cdev->req;
1835 unsigned long flags;
1836
1837 DBG(cdev, "%s\n", __func__);
1838 spin_lock_irqsave(&cdev->lock, flags);
1839
1840 if (cdev->delayed_status == 0) {
1841 WARN(cdev, "%s: Unexpected call\n", __func__);
1842
1843 } else if (--cdev->delayed_status == 0) {
1844 DBG(cdev, "%s: Completing delayed status\n", __func__);
1845 req->length = 0;
1846 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1847 if (value < 0) {
1848 DBG(cdev, "ep_queue --> %d\n", value);
1849 req->status = 0;
1850 composite_setup_complete(cdev->gadget->ep0, req);
1851 }
1852 }
1853
1854 spin_unlock_irqrestore(&cdev->lock, flags);
1855}
1856EXPORT_SYMBOL_GPL(usb_composite_setup_continue);
1857
1858static char *composite_default_mfr(struct usb_gadget *gadget)
1859{
1860 char *mfr;
1861 int len;
1862
1863 len = snprintf(NULL, 0, "%s %s with %s", init_utsname()->sysname,
1864 init_utsname()->release, gadget->name);
1865 len++;
1866 mfr = kmalloc(len, GFP_KERNEL);
1867 if (!mfr)
1868 return NULL;
1869 snprintf(mfr, len, "%s %s with %s", init_utsname()->sysname,
1870 init_utsname()->release, gadget->name);
1871 return mfr;
1872}
1873
1874void usb_composite_overwrite_options(struct usb_composite_dev *cdev,
1875 struct usb_composite_overwrite *covr)
1876{
1877 struct usb_device_descriptor *desc = &cdev->desc;
1878 struct usb_gadget_strings *gstr = cdev->driver->strings[0];
1879 struct usb_string *dev_str = gstr->strings;
1880
1881 if (covr->idVendor)
1882 desc->idVendor = cpu_to_le16(covr->idVendor);
1883
1884 if (covr->idProduct)
1885 desc->idProduct = cpu_to_le16(covr->idProduct);
1886
1887 if (covr->bcdDevice)
1888 desc->bcdDevice = cpu_to_le16(covr->bcdDevice);
1889
1890 if (covr->serial_number) {
1891 desc->iSerialNumber = dev_str[USB_GADGET_SERIAL_IDX].id;
1892 dev_str[USB_GADGET_SERIAL_IDX].s = covr->serial_number;
1893 }
1894 if (covr->manufacturer) {
1895 desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
1896 dev_str[USB_GADGET_MANUFACTURER_IDX].s = covr->manufacturer;
1897
1898 } else if (!strlen(dev_str[USB_GADGET_MANUFACTURER_IDX].s)) {
1899 desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
1900 cdev->def_manufacturer = composite_default_mfr(cdev->gadget);
1901 dev_str[USB_GADGET_MANUFACTURER_IDX].s = cdev->def_manufacturer;
1902 }
1903
1904 if (covr->product) {
1905 desc->iProduct = dev_str[USB_GADGET_PRODUCT_IDX].id;
1906 dev_str[USB_GADGET_PRODUCT_IDX].s = covr->product;
1907 }
1908}
1909EXPORT_SYMBOL_GPL(usb_composite_overwrite_options);
1910
1911MODULE_LICENSE("GPL");
1912MODULE_AUTHOR("David Brownell");
1913