1
2
3
4
5#include <linux/pci.h>
6#include <linux/usb.h>
7#include <linux/module.h>
8#include <linux/slab.h>
9#include <linux/mm.h>
10#include <linux/timer.h>
11#include <linux/ctype.h>
12#include <linux/nls.h>
13#include <linux/device.h>
14#include <linux/scatterlist.h>
15#include <linux/usb/quirks.h>
16#include <linux/usb/hcd.h>
17#include <asm/byteorder.h>
18
19#include "usb.h"
20
21static void cancel_async_set_config(struct usb_device *udev);
22
23struct api_context {
24 struct completion done;
25 int status;
26};
27
28static void usb_api_blocking_completion(struct urb *urb)
29{
30 struct api_context *ctx = urb->context;
31
32 ctx->status = urb->status;
33 complete(&ctx->done);
34}
35
36
37
38
39
40
41
42
43static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length)
44{
45 struct api_context ctx;
46 unsigned long expire;
47 int retval;
48
49 init_completion(&ctx.done);
50 urb->context = &ctx;
51 urb->actual_length = 0;
52 retval = usb_submit_urb(urb, GFP_NOIO);
53 if (unlikely(retval))
54 goto out;
55
56 expire = timeout ? msecs_to_jiffies(timeout) : MAX_SCHEDULE_TIMEOUT;
57 if (!wait_for_completion_timeout(&ctx.done, expire)) {
58 usb_kill_urb(urb);
59 retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status);
60
61 dev_dbg(&urb->dev->dev,
62 "%s timed out on ep%d%s len=%u/%u\n",
63 current->comm,
64 usb_endpoint_num(&urb->ep->desc),
65 usb_urb_dir_in(urb) ? "in" : "out",
66 urb->actual_length,
67 urb->transfer_buffer_length);
68 } else
69 retval = ctx.status;
70out:
71 if (actual_length)
72 *actual_length = urb->actual_length;
73
74 usb_free_urb(urb);
75 return retval;
76}
77
78
79
80static int usb_internal_control_msg(struct usb_device *usb_dev,
81 unsigned int pipe,
82 struct usb_ctrlrequest *cmd,
83 void *data, int len, int timeout)
84{
85 struct urb *urb;
86 int retv;
87 int length;
88
89 urb = usb_alloc_urb(0, GFP_NOIO);
90 if (!urb)
91 return -ENOMEM;
92
93 usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data,
94 len, usb_api_blocking_completion, NULL);
95
96 retv = usb_start_wait_urb(urb, timeout, &length);
97 if (retv < 0)
98 return retv;
99 else
100 return length;
101}
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
132 __u8 requesttype, __u16 value, __u16 index, void *data,
133 __u16 size, int timeout)
134{
135 struct usb_ctrlrequest *dr;
136 int ret;
137
138 dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
139 if (!dr)
140 return -ENOMEM;
141
142 dr->bRequestType = requesttype;
143 dr->bRequest = request;
144 dr->wValue = cpu_to_le16(value);
145 dr->wIndex = cpu_to_le16(index);
146 dr->wLength = cpu_to_le16(size);
147
148 ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout);
149
150 kfree(dr);
151
152 return ret;
153}
154EXPORT_SYMBOL_GPL(usb_control_msg);
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183int usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe,
184 void *data, int len, int *actual_length, int timeout)
185{
186 return usb_bulk_msg(usb_dev, pipe, data, len, actual_length, timeout);
187}
188EXPORT_SYMBOL_GPL(usb_interrupt_msg);
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
224 void *data, int len, int *actual_length, int timeout)
225{
226 struct urb *urb;
227 struct usb_host_endpoint *ep;
228
229 ep = usb_pipe_endpoint(usb_dev, pipe);
230 if (!ep || len < 0)
231 return -EINVAL;
232
233 urb = usb_alloc_urb(0, GFP_KERNEL);
234 if (!urb)
235 return -ENOMEM;
236
237 if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
238 USB_ENDPOINT_XFER_INT) {
239 pipe = (pipe & ~(3 << 30)) | (PIPE_INTERRUPT << 30);
240 usb_fill_int_urb(urb, usb_dev, pipe, data, len,
241 usb_api_blocking_completion, NULL,
242 ep->desc.bInterval);
243 } else
244 usb_fill_bulk_urb(urb, usb_dev, pipe, data, len,
245 usb_api_blocking_completion, NULL);
246
247 return usb_start_wait_urb(urb, timeout, actual_length);
248}
249EXPORT_SYMBOL_GPL(usb_bulk_msg);
250
251
252
253static void sg_clean(struct usb_sg_request *io)
254{
255 if (io->urbs) {
256 while (io->entries--)
257 usb_free_urb(io->urbs[io->entries]);
258 kfree(io->urbs);
259 io->urbs = NULL;
260 }
261 io->dev = NULL;
262}
263
264static void sg_complete(struct urb *urb)
265{
266 struct usb_sg_request *io = urb->context;
267 int status = urb->status;
268
269 spin_lock(&io->lock);
270
271
272
273
274
275
276
277
278
279
280
281 if (io->status
282 && (io->status != -ECONNRESET
283 || status != -ECONNRESET)
284 && urb->actual_length) {
285 dev_err(io->dev->bus->controller,
286 "dev %s ep%d%s scatterlist error %d/%d\n",
287 io->dev->devpath,
288 usb_endpoint_num(&urb->ep->desc),
289 usb_urb_dir_in(urb) ? "in" : "out",
290 status, io->status);
291
292 }
293
294 if (io->status == 0 && status && status != -ECONNRESET) {
295 int i, found, retval;
296
297 io->status = status;
298
299
300
301
302
303 spin_unlock(&io->lock);
304 for (i = 0, found = 0; i < io->entries; i++) {
305 if (!io->urbs[i] || !io->urbs[i]->dev)
306 continue;
307 if (found) {
308 retval = usb_unlink_urb(io->urbs[i]);
309 if (retval != -EINPROGRESS &&
310 retval != -ENODEV &&
311 retval != -EBUSY &&
312 retval != -EIDRM)
313 dev_err(&io->dev->dev,
314 "%s, unlink --> %d\n",
315 __func__, retval);
316 } else if (urb == io->urbs[i])
317 found = 1;
318 }
319 spin_lock(&io->lock);
320 }
321
322
323 io->bytes += urb->actual_length;
324 io->count--;
325 if (!io->count)
326 complete(&io->complete);
327
328 spin_unlock(&io->lock);
329}
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
360 unsigned pipe, unsigned period, struct scatterlist *sg,
361 int nents, size_t length, gfp_t mem_flags)
362{
363 int i;
364 int urb_flags;
365 int use_sg;
366
367 if (!io || !dev || !sg
368 || usb_pipecontrol(pipe)
369 || usb_pipeisoc(pipe)
370 || nents <= 0)
371 return -EINVAL;
372
373 spin_lock_init(&io->lock);
374 io->dev = dev;
375 io->pipe = pipe;
376
377 if (dev->bus->sg_tablesize > 0) {
378 use_sg = true;
379 io->entries = 1;
380 } else {
381 use_sg = false;
382 io->entries = nents;
383 }
384
385
386 io->urbs = kmalloc(io->entries * sizeof(*io->urbs), mem_flags);
387 if (!io->urbs)
388 goto nomem;
389
390 urb_flags = URB_NO_INTERRUPT;
391 if (usb_pipein(pipe))
392 urb_flags |= URB_SHORT_NOT_OK;
393
394 for_each_sg(sg, sg, io->entries, i) {
395 struct urb *urb;
396 unsigned len;
397
398 urb = usb_alloc_urb(0, mem_flags);
399 if (!urb) {
400 io->entries = i;
401 goto nomem;
402 }
403 io->urbs[i] = urb;
404
405 urb->dev = NULL;
406 urb->pipe = pipe;
407 urb->interval = period;
408 urb->transfer_flags = urb_flags;
409 urb->complete = sg_complete;
410 urb->context = io;
411 urb->sg = sg;
412
413 if (use_sg) {
414
415 urb->transfer_buffer = NULL;
416 urb->num_sgs = nents;
417
418
419 len = length;
420 if (len == 0) {
421 struct scatterlist *sg2;
422 int j;
423
424 for_each_sg(sg, sg2, nents, j)
425 len += sg2->length;
426 }
427 } else {
428
429
430
431
432
433 if (!PageHighMem(sg_page(sg)))
434 urb->transfer_buffer = sg_virt(sg);
435 else
436 urb->transfer_buffer = NULL;
437
438 len = sg->length;
439 if (length) {
440 len = min_t(size_t, len, length);
441 length -= len;
442 if (length == 0)
443 io->entries = i + 1;
444 }
445 }
446 urb->transfer_buffer_length = len;
447 }
448 io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT;
449
450
451 io->count = io->entries;
452 io->status = 0;
453 io->bytes = 0;
454 init_completion(&io->complete);
455 return 0;
456
457nomem:
458 sg_clean(io);
459 return -ENOMEM;
460}
461EXPORT_SYMBOL_GPL(usb_sg_init);
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506void usb_sg_wait(struct usb_sg_request *io)
507{
508 int i;
509 int entries = io->entries;
510
511
512 spin_lock_irq(&io->lock);
513 i = 0;
514 while (i < entries && !io->status) {
515 int retval;
516
517 io->urbs[i]->dev = io->dev;
518 retval = usb_submit_urb(io->urbs[i], GFP_ATOMIC);
519
520
521
522
523 spin_unlock_irq(&io->lock);
524 switch (retval) {
525
526 case -ENXIO:
527 case -EAGAIN:
528 case -ENOMEM:
529 retval = 0;
530 yield();
531 break;
532
533
534
535
536
537
538
539 case 0:
540 ++i;
541 cpu_relax();
542 break;
543
544
545 default:
546 io->urbs[i]->status = retval;
547 dev_dbg(&io->dev->dev, "%s, submit --> %d\n",
548 __func__, retval);
549 usb_sg_cancel(io);
550 }
551 spin_lock_irq(&io->lock);
552 if (retval && (io->status == 0 || io->status == -ECONNRESET))
553 io->status = retval;
554 }
555 io->count -= entries - i;
556 if (io->count == 0)
557 complete(&io->complete);
558 spin_unlock_irq(&io->lock);
559
560
561
562
563
564 wait_for_completion(&io->complete);
565
566 sg_clean(io);
567}
568EXPORT_SYMBOL_GPL(usb_sg_wait);
569
570
571
572
573
574
575
576
577
578void usb_sg_cancel(struct usb_sg_request *io)
579{
580 unsigned long flags;
581
582 spin_lock_irqsave(&io->lock, flags);
583
584
585 if (!io->status) {
586 int i;
587
588 io->status = -ECONNRESET;
589 spin_unlock(&io->lock);
590 for (i = 0; i < io->entries; i++) {
591 int retval;
592
593 if (!io->urbs[i]->dev)
594 continue;
595 retval = usb_unlink_urb(io->urbs[i]);
596 if (retval != -EINPROGRESS
597 && retval != -ENODEV
598 && retval != -EBUSY
599 && retval != -EIDRM)
600 dev_warn(&io->dev->dev, "%s, unlink --> %d\n",
601 __func__, retval);
602 }
603 spin_lock(&io->lock);
604 }
605 spin_unlock_irqrestore(&io->lock, flags);
606}
607EXPORT_SYMBOL_GPL(usb_sg_cancel);
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633int usb_get_descriptor(struct usb_device *dev, unsigned char type,
634 unsigned char index, void *buf, int size)
635{
636 int i;
637 int result;
638
639 memset(buf, 0, size);
640
641 for (i = 0; i < 3; ++i) {
642
643 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
644 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
645 (type << 8) + index, 0, buf, size,
646 USB_CTRL_GET_TIMEOUT);
647 if (result <= 0 && result != -ETIMEDOUT)
648 continue;
649 if (result > 1 && ((u8 *)buf)[1] != type) {
650 result = -ENODATA;
651 continue;
652 }
653 break;
654 }
655 return result;
656}
657EXPORT_SYMBOL_GPL(usb_get_descriptor);
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681static int usb_get_string(struct usb_device *dev, unsigned short langid,
682 unsigned char index, void *buf, int size)
683{
684 int i;
685 int result;
686
687 for (i = 0; i < 3; ++i) {
688
689 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
690 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
691 (USB_DT_STRING << 8) + index, langid, buf, size,
692 USB_CTRL_GET_TIMEOUT);
693 if (result == 0 || result == -EPIPE)
694 continue;
695 if (result > 1 && ((u8 *) buf)[1] != USB_DT_STRING) {
696 result = -ENODATA;
697 continue;
698 }
699 break;
700 }
701 return result;
702}
703
704static void usb_try_string_workarounds(unsigned char *buf, int *length)
705{
706 int newlength, oldlength = *length;
707
708 for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
709 if (!isprint(buf[newlength]) || buf[newlength + 1])
710 break;
711
712 if (newlength > 2) {
713 buf[0] = newlength;
714 *length = newlength;
715 }
716}
717
718static int usb_string_sub(struct usb_device *dev, unsigned int langid,
719 unsigned int index, unsigned char *buf)
720{
721 int rc;
722
723
724
725 if (dev->quirks & USB_QUIRK_STRING_FETCH_255)
726 rc = -EIO;
727 else
728 rc = usb_get_string(dev, langid, index, buf, 255);
729
730
731
732 if (rc < 2) {
733 rc = usb_get_string(dev, langid, index, buf, 2);
734 if (rc == 2)
735 rc = usb_get_string(dev, langid, index, buf, buf[0]);
736 }
737
738 if (rc >= 2) {
739 if (!buf[0] && !buf[1])
740 usb_try_string_workarounds(buf, &rc);
741
742
743 if (buf[0] < rc)
744 rc = buf[0];
745
746 rc = rc - (rc & 1);
747 }
748
749 if (rc < 2)
750 rc = (rc < 0 ? rc : -EINVAL);
751
752 return rc;
753}
754
755static int usb_get_langid(struct usb_device *dev, unsigned char *tbuf)
756{
757 int err;
758
759 if (dev->have_langid)
760 return 0;
761
762 if (dev->string_langid < 0)
763 return -EPIPE;
764
765 err = usb_string_sub(dev, 0, 0, tbuf);
766
767
768
769 if (err == -ENODATA || (err > 0 && err < 4)) {
770 dev->string_langid = 0x0409;
771 dev->have_langid = 1;
772 dev_err(&dev->dev,
773 "language id specifier not provided by device, defaulting to English\n");
774 return 0;
775 }
776
777
778
779
780 if (err < 0) {
781 dev_err(&dev->dev, "string descriptor 0 read error: %d\n",
782 err);
783 dev->string_langid = -1;
784 return -EPIPE;
785 }
786
787
788 dev->string_langid = tbuf[2] | (tbuf[3] << 8);
789 dev->have_langid = 1;
790 dev_dbg(&dev->dev, "default language 0x%04x\n",
791 dev->string_langid);
792 return 0;
793}
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
813{
814 unsigned char *tbuf;
815 int err;
816
817 if (dev->state == USB_STATE_SUSPENDED)
818 return -EHOSTUNREACH;
819 if (size <= 0 || !buf || !index)
820 return -EINVAL;
821 buf[0] = 0;
822 tbuf = kmalloc(256, GFP_NOIO);
823 if (!tbuf)
824 return -ENOMEM;
825
826 err = usb_get_langid(dev, tbuf);
827 if (err < 0)
828 goto errout;
829
830 err = usb_string_sub(dev, dev->string_langid, index, tbuf);
831 if (err < 0)
832 goto errout;
833
834 size--;
835 err = utf16s_to_utf8s((wchar_t *) &tbuf[2], (err - 2) / 2,
836 UTF16_LITTLE_ENDIAN, buf, size);
837 buf[err] = 0;
838
839 if (tbuf[1] != USB_DT_STRING)
840 dev_dbg(&dev->dev,
841 "wrong descriptor type %02x for string %d (\"%s\")\n",
842 tbuf[1], index, buf);
843
844 errout:
845 kfree(tbuf);
846 return err;
847}
848EXPORT_SYMBOL_GPL(usb_string);
849
850
851#define MAX_USB_STRING_SIZE (127 * 3 + 1)
852
853
854
855
856
857
858
859
860
861char *usb_cache_string(struct usb_device *udev, int index)
862{
863 char *buf;
864 char *smallbuf = NULL;
865 int len;
866
867 if (index <= 0)
868 return NULL;
869
870 buf = kmalloc(MAX_USB_STRING_SIZE, GFP_NOIO);
871 if (buf) {
872 len = usb_string(udev, index, buf, MAX_USB_STRING_SIZE);
873 if (len > 0) {
874 smallbuf = kmalloc(++len, GFP_NOIO);
875 if (!smallbuf)
876 return buf;
877 memcpy(smallbuf, buf, len);
878 }
879 kfree(buf);
880 }
881 return smallbuf;
882}
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902int usb_get_device_descriptor(struct usb_device *dev, unsigned int size)
903{
904 struct usb_device_descriptor *desc;
905 int ret;
906
907 if (size > sizeof(*desc))
908 return -EINVAL;
909 desc = kmalloc(sizeof(*desc), GFP_NOIO);
910 if (!desc)
911 return -ENOMEM;
912
913 ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, size);
914 if (ret >= 0)
915 memcpy(&dev->descriptor, desc, size);
916 kfree(desc);
917 return ret;
918}
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942int usb_get_status(struct usb_device *dev, int type, int target, void *data)
943{
944 int ret;
945 __le16 *status = kmalloc(sizeof(*status), GFP_KERNEL);
946
947 if (!status)
948 return -ENOMEM;
949
950 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
951 USB_REQ_GET_STATUS, USB_DIR_IN | type, 0, target, status,
952 sizeof(*status), USB_CTRL_GET_TIMEOUT);
953
954 if (ret == 2) {
955 *(u16 *) data = le16_to_cpu(*status);
956 ret = 0;
957 } else if (ret >= 0) {
958 ret = -EIO;
959 }
960 kfree(status);
961 return ret;
962}
963EXPORT_SYMBOL_GPL(usb_get_status);
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988int usb_clear_halt(struct usb_device *dev, int pipe)
989{
990 int result;
991 int endp = usb_pipeendpoint(pipe);
992
993 if (usb_pipein(pipe))
994 endp |= USB_DIR_IN;
995
996
997
998
999
1000 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1001 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT,
1002 USB_ENDPOINT_HALT, endp, NULL, 0,
1003 USB_CTRL_SET_TIMEOUT);
1004
1005
1006 if (result < 0)
1007 return result;
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017 usb_reset_endpoint(dev, endp);
1018
1019 return 0;
1020}
1021EXPORT_SYMBOL_GPL(usb_clear_halt);
1022
1023static int create_intf_ep_devs(struct usb_interface *intf)
1024{
1025 struct usb_device *udev = interface_to_usbdev(intf);
1026 struct usb_host_interface *alt = intf->cur_altsetting;
1027 int i;
1028
1029 if (intf->ep_devs_created || intf->unregistering)
1030 return 0;
1031
1032 for (i = 0; i < alt->desc.bNumEndpoints; ++i)
1033 (void) usb_create_ep_devs(&intf->dev, &alt->endpoint[i], udev);
1034 intf->ep_devs_created = 1;
1035 return 0;
1036}
1037
1038static void remove_intf_ep_devs(struct usb_interface *intf)
1039{
1040 struct usb_host_interface *alt = intf->cur_altsetting;
1041 int i;
1042
1043 if (!intf->ep_devs_created)
1044 return;
1045
1046 for (i = 0; i < alt->desc.bNumEndpoints; ++i)
1047 usb_remove_ep_devs(&alt->endpoint[i]);
1048 intf->ep_devs_created = 0;
1049}
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr,
1064 bool reset_hardware)
1065{
1066 unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK;
1067 struct usb_host_endpoint *ep;
1068
1069 if (!dev)
1070 return;
1071
1072 if (usb_endpoint_out(epaddr)) {
1073 ep = dev->ep_out[epnum];
1074 if (reset_hardware)
1075 dev->ep_out[epnum] = NULL;
1076 } else {
1077 ep = dev->ep_in[epnum];
1078 if (reset_hardware)
1079 dev->ep_in[epnum] = NULL;
1080 }
1081 if (ep) {
1082 ep->enabled = 0;
1083 usb_hcd_flush_endpoint(dev, ep);
1084 if (reset_hardware)
1085 usb_hcd_disable_endpoint(dev, ep);
1086 }
1087}
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098void usb_reset_endpoint(struct usb_device *dev, unsigned int epaddr)
1099{
1100 unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK;
1101 struct usb_host_endpoint *ep;
1102
1103 if (usb_endpoint_out(epaddr))
1104 ep = dev->ep_out[epnum];
1105 else
1106 ep = dev->ep_in[epnum];
1107 if (ep)
1108 usb_hcd_reset_endpoint(dev, ep);
1109}
1110EXPORT_SYMBOL_GPL(usb_reset_endpoint);
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf,
1123 bool reset_hardware)
1124{
1125 struct usb_host_interface *alt = intf->cur_altsetting;
1126 int i;
1127
1128 for (i = 0; i < alt->desc.bNumEndpoints; ++i) {
1129 usb_disable_endpoint(dev,
1130 alt->endpoint[i].desc.bEndpointAddress,
1131 reset_hardware);
1132 }
1133}
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145void usb_disable_device(struct usb_device *dev, int skip_ep0)
1146{
1147 int i;
1148 struct usb_hcd *hcd = bus_to_hcd(dev->bus);
1149
1150
1151
1152
1153 if (dev->actconfig) {
1154
1155
1156
1157
1158
1159 for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++)
1160 dev->actconfig->interface[i]->unregistering = 1;
1161
1162 for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
1163 struct usb_interface *interface;
1164
1165
1166 interface = dev->actconfig->interface[i];
1167 if (!device_is_registered(&interface->dev))
1168 continue;
1169 dev_dbg(&dev->dev, "unregistering interface %s\n",
1170 dev_name(&interface->dev));
1171 remove_intf_ep_devs(interface);
1172 device_del(&interface->dev);
1173 }
1174
1175
1176
1177
1178 for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
1179 put_device(&dev->actconfig->interface[i]->dev);
1180 dev->actconfig->interface[i] = NULL;
1181 }
1182
1183 if (dev->usb2_hw_lpm_enabled == 1)
1184 usb_set_usb2_hardware_lpm(dev, 0);
1185 usb_unlocked_disable_lpm(dev);
1186 usb_disable_ltm(dev);
1187
1188 dev->actconfig = NULL;
1189 if (dev->state == USB_STATE_CONFIGURED)
1190 usb_set_device_state(dev, USB_STATE_ADDRESS);
1191 }
1192
1193 dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
1194 skip_ep0 ? "non-ep0" : "all");
1195 if (hcd->driver->check_bandwidth) {
1196
1197 for (i = skip_ep0; i < 16; ++i) {
1198 usb_disable_endpoint(dev, i, false);
1199 usb_disable_endpoint(dev, i + USB_DIR_IN, false);
1200 }
1201
1202 mutex_lock(hcd->bandwidth_mutex);
1203 usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
1204 mutex_unlock(hcd->bandwidth_mutex);
1205
1206 }
1207 for (i = skip_ep0; i < 16; ++i) {
1208 usb_disable_endpoint(dev, i, true);
1209 usb_disable_endpoint(dev, i + USB_DIR_IN, true);
1210 }
1211}
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222void usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep,
1223 bool reset_ep)
1224{
1225 int epnum = usb_endpoint_num(&ep->desc);
1226 int is_out = usb_endpoint_dir_out(&ep->desc);
1227 int is_control = usb_endpoint_xfer_control(&ep->desc);
1228
1229 if (reset_ep)
1230 usb_hcd_reset_endpoint(dev, ep);
1231 if (is_out || is_control)
1232 dev->ep_out[epnum] = ep;
1233 if (!is_out || is_control)
1234 dev->ep_in[epnum] = ep;
1235 ep->enabled = 1;
1236}
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246void usb_enable_interface(struct usb_device *dev,
1247 struct usb_interface *intf, bool reset_eps)
1248{
1249 struct usb_host_interface *alt = intf->cur_altsetting;
1250 int i;
1251
1252 for (i = 0; i < alt->desc.bNumEndpoints; ++i)
1253 usb_enable_endpoint(dev, &alt->endpoint[i], reset_eps);
1254}
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289int usb_set_interface(struct usb_device *dev, int interface, int alternate)
1290{
1291 struct usb_interface *iface;
1292 struct usb_host_interface *alt;
1293 struct usb_hcd *hcd = bus_to_hcd(dev->bus);
1294 int i, ret, manual = 0;
1295 unsigned int epaddr;
1296 unsigned int pipe;
1297
1298 if (dev->state == USB_STATE_SUSPENDED)
1299 return -EHOSTUNREACH;
1300
1301 iface = usb_ifnum_to_if(dev, interface);
1302 if (!iface) {
1303 dev_dbg(&dev->dev, "selecting invalid interface %d\n",
1304 interface);
1305 return -EINVAL;
1306 }
1307 if (iface->unregistering)
1308 return -ENODEV;
1309
1310 alt = usb_altnum_to_altsetting(iface, alternate);
1311 if (!alt) {
1312 dev_warn(&dev->dev, "selecting invalid altsetting %d\n",
1313 alternate);
1314 return -EINVAL;
1315 }
1316
1317
1318
1319
1320 mutex_lock(hcd->bandwidth_mutex);
1321
1322
1323
1324 if (usb_disable_lpm(dev)) {
1325 dev_err(&iface->dev, "%s Failed to disable LPM\n.", __func__);
1326 mutex_unlock(hcd->bandwidth_mutex);
1327 return -ENOMEM;
1328 }
1329
1330 for (i = 0; i < iface->cur_altsetting->desc.bNumEndpoints; i++)
1331 iface->cur_altsetting->endpoint[i].streams = 0;
1332
1333 ret = usb_hcd_alloc_bandwidth(dev, NULL, iface->cur_altsetting, alt);
1334 if (ret < 0) {
1335 dev_info(&dev->dev, "Not enough bandwidth for altsetting %d\n",
1336 alternate);
1337 usb_enable_lpm(dev);
1338 mutex_unlock(hcd->bandwidth_mutex);
1339 return ret;
1340 }
1341
1342 if (dev->quirks & USB_QUIRK_NO_SET_INTF)
1343 ret = -EPIPE;
1344 else
1345 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1346 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
1347 alternate, interface, NULL, 0, 5000);
1348
1349
1350
1351
1352 if (ret == -EPIPE && iface->num_altsetting == 1) {
1353 dev_dbg(&dev->dev,
1354 "manual set_interface for iface %d, alt %d\n",
1355 interface, alternate);
1356 manual = 1;
1357 } else if (ret < 0) {
1358
1359 usb_hcd_alloc_bandwidth(dev, NULL, alt, iface->cur_altsetting);
1360 usb_enable_lpm(dev);
1361 mutex_unlock(hcd->bandwidth_mutex);
1362 return ret;
1363 }
1364 mutex_unlock(hcd->bandwidth_mutex);
1365
1366
1367
1368
1369
1370
1371
1372
1373 if (iface->cur_altsetting != alt) {
1374 remove_intf_ep_devs(iface);
1375 usb_remove_sysfs_intf_files(iface);
1376 }
1377 usb_disable_interface(dev, iface, true);
1378
1379 iface->cur_altsetting = alt;
1380
1381
1382 usb_unlocked_enable_lpm(dev);
1383
1384
1385
1386
1387
1388
1389 if (manual) {
1390 for (i = 0; i < alt->desc.bNumEndpoints; i++) {
1391 epaddr = alt->endpoint[i].desc.bEndpointAddress;
1392 pipe = __create_pipe(dev,
1393 USB_ENDPOINT_NUMBER_MASK & epaddr) |
1394 (usb_endpoint_out(epaddr) ?
1395 USB_DIR_OUT : USB_DIR_IN);
1396
1397 usb_clear_halt(dev, pipe);
1398 }
1399 }
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412 usb_enable_interface(dev, iface, true);
1413 if (device_is_registered(&iface->dev)) {
1414 usb_create_sysfs_intf_files(iface);
1415 create_intf_ep_devs(iface);
1416 }
1417 return 0;
1418}
1419EXPORT_SYMBOL_GPL(usb_set_interface);
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443int usb_reset_configuration(struct usb_device *dev)
1444{
1445 int i, retval;
1446 struct usb_host_config *config;
1447 struct usb_hcd *hcd = bus_to_hcd(dev->bus);
1448
1449 if (dev->state == USB_STATE_SUSPENDED)
1450 return -EHOSTUNREACH;
1451
1452
1453
1454
1455
1456
1457 for (i = 1; i < 16; ++i) {
1458 usb_disable_endpoint(dev, i, true);
1459 usb_disable_endpoint(dev, i + USB_DIR_IN, true);
1460 }
1461
1462 config = dev->actconfig;
1463 retval = 0;
1464 mutex_lock(hcd->bandwidth_mutex);
1465
1466
1467
1468 if (usb_disable_lpm(dev)) {
1469 dev_err(&dev->dev, "%s Failed to disable LPM\n.", __func__);
1470 mutex_unlock(hcd->bandwidth_mutex);
1471 return -ENOMEM;
1472 }
1473
1474 for (i = 0; i < config->desc.bNumInterfaces; i++) {
1475 struct usb_interface *intf = config->interface[i];
1476 struct usb_host_interface *alt;
1477
1478 alt = usb_altnum_to_altsetting(intf, 0);
1479 if (!alt)
1480 alt = &intf->altsetting[0];
1481 if (alt != intf->cur_altsetting)
1482 retval = usb_hcd_alloc_bandwidth(dev, NULL,
1483 intf->cur_altsetting, alt);
1484 if (retval < 0)
1485 break;
1486 }
1487
1488 if (retval < 0) {
1489reset_old_alts:
1490 for (i--; i >= 0; i--) {
1491 struct usb_interface *intf = config->interface[i];
1492 struct usb_host_interface *alt;
1493
1494 alt = usb_altnum_to_altsetting(intf, 0);
1495 if (!alt)
1496 alt = &intf->altsetting[0];
1497 if (alt != intf->cur_altsetting)
1498 usb_hcd_alloc_bandwidth(dev, NULL,
1499 alt, intf->cur_altsetting);
1500 }
1501 usb_enable_lpm(dev);
1502 mutex_unlock(hcd->bandwidth_mutex);
1503 return retval;
1504 }
1505 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1506 USB_REQ_SET_CONFIGURATION, 0,
1507 config->desc.bConfigurationValue, 0,
1508 NULL, 0, USB_CTRL_SET_TIMEOUT);
1509 if (retval < 0)
1510 goto reset_old_alts;
1511 mutex_unlock(hcd->bandwidth_mutex);
1512
1513
1514 for (i = 0; i < config->desc.bNumInterfaces; i++) {
1515 struct usb_interface *intf = config->interface[i];
1516 struct usb_host_interface *alt;
1517
1518 alt = usb_altnum_to_altsetting(intf, 0);
1519
1520
1521
1522
1523
1524
1525 if (!alt)
1526 alt = &intf->altsetting[0];
1527
1528 if (alt != intf->cur_altsetting) {
1529 remove_intf_ep_devs(intf);
1530 usb_remove_sysfs_intf_files(intf);
1531 }
1532 intf->cur_altsetting = alt;
1533 usb_enable_interface(dev, intf, true);
1534 if (device_is_registered(&intf->dev)) {
1535 usb_create_sysfs_intf_files(intf);
1536 create_intf_ep_devs(intf);
1537 }
1538 }
1539
1540 usb_unlocked_enable_lpm(dev);
1541 return 0;
1542}
1543EXPORT_SYMBOL_GPL(usb_reset_configuration);
1544
1545static void usb_release_interface(struct device *dev)
1546{
1547 struct usb_interface *intf = to_usb_interface(dev);
1548 struct usb_interface_cache *intfc =
1549 altsetting_to_usb_interface_cache(intf->altsetting);
1550
1551 kref_put(&intfc->ref, usb_release_interface_cache);
1552 usb_put_dev(interface_to_usbdev(intf));
1553 kfree(intf);
1554}
1555
1556
1557
1558
1559
1560
1561void usb_deauthorize_interface(struct usb_interface *intf)
1562{
1563 struct device *dev = &intf->dev;
1564
1565 device_lock(dev->parent);
1566
1567 if (intf->authorized) {
1568 device_lock(dev);
1569 intf->authorized = 0;
1570 device_unlock(dev);
1571
1572 usb_forced_unbind_intf(intf);
1573 }
1574
1575 device_unlock(dev->parent);
1576}
1577
1578
1579
1580
1581
1582
1583void usb_authorize_interface(struct usb_interface *intf)
1584{
1585 struct device *dev = &intf->dev;
1586
1587 if (!intf->authorized) {
1588 device_lock(dev);
1589 intf->authorized = 1;
1590 device_unlock(dev);
1591 }
1592}
1593
1594static int usb_if_uevent(struct device *dev, struct kobj_uevent_env *env)
1595{
1596 struct usb_device *usb_dev;
1597 struct usb_interface *intf;
1598 struct usb_host_interface *alt;
1599
1600 intf = to_usb_interface(dev);
1601 usb_dev = interface_to_usbdev(intf);
1602 alt = intf->cur_altsetting;
1603
1604 if (add_uevent_var(env, "INTERFACE=%d/%d/%d",
1605 alt->desc.bInterfaceClass,
1606 alt->desc.bInterfaceSubClass,
1607 alt->desc.bInterfaceProtocol))
1608 return -ENOMEM;
1609
1610 if (add_uevent_var(env,
1611 "MODALIAS=usb:"
1612 "v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02Xin%02X",
1613 le16_to_cpu(usb_dev->descriptor.idVendor),
1614 le16_to_cpu(usb_dev->descriptor.idProduct),
1615 le16_to_cpu(usb_dev->descriptor.bcdDevice),
1616 usb_dev->descriptor.bDeviceClass,
1617 usb_dev->descriptor.bDeviceSubClass,
1618 usb_dev->descriptor.bDeviceProtocol,
1619 alt->desc.bInterfaceClass,
1620 alt->desc.bInterfaceSubClass,
1621 alt->desc.bInterfaceProtocol,
1622 alt->desc.bInterfaceNumber))
1623 return -ENOMEM;
1624
1625 return 0;
1626}
1627
1628struct device_type usb_if_device_type = {
1629 .name = "usb_interface",
1630 .release = usb_release_interface,
1631 .uevent = usb_if_uevent,
1632};
1633
1634static struct usb_interface_assoc_descriptor *find_iad(struct usb_device *dev,
1635 struct usb_host_config *config,
1636 u8 inum)
1637{
1638 struct usb_interface_assoc_descriptor *retval = NULL;
1639 struct usb_interface_assoc_descriptor *intf_assoc;
1640 int first_intf;
1641 int last_intf;
1642 int i;
1643
1644 for (i = 0; (i < USB_MAXIADS && config->intf_assoc[i]); i++) {
1645 intf_assoc = config->intf_assoc[i];
1646 if (intf_assoc->bInterfaceCount == 0)
1647 continue;
1648
1649 first_intf = intf_assoc->bFirstInterface;
1650 last_intf = first_intf + (intf_assoc->bInterfaceCount - 1);
1651 if (inum >= first_intf && inum <= last_intf) {
1652 if (!retval)
1653 retval = intf_assoc;
1654 else
1655 dev_err(&dev->dev, "Interface #%d referenced"
1656 " by multiple IADs\n", inum);
1657 }
1658 }
1659
1660 return retval;
1661}
1662
1663
1664
1665
1666
1667
1668static void __usb_queue_reset_device(struct work_struct *ws)
1669{
1670 int rc;
1671 struct usb_interface *iface =
1672 container_of(ws, struct usb_interface, reset_ws);
1673 struct usb_device *udev = interface_to_usbdev(iface);
1674
1675 rc = usb_lock_device_for_reset(udev, iface);
1676 if (rc >= 0) {
1677 usb_reset_device(udev);
1678 usb_unlock_device(udev);
1679 }
1680 usb_put_intf(iface);
1681}
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729int usb_set_configuration(struct usb_device *dev, int configuration)
1730{
1731 int i, ret;
1732 struct usb_host_config *cp = NULL;
1733 struct usb_interface **new_interfaces = NULL;
1734 struct usb_hcd *hcd = bus_to_hcd(dev->bus);
1735 int n, nintf;
1736
1737 if (dev->authorized == 0 || configuration == -1)
1738 configuration = 0;
1739 else {
1740 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
1741 if (dev->config[i].desc.bConfigurationValue ==
1742 configuration) {
1743 cp = &dev->config[i];
1744 break;
1745 }
1746 }
1747 }
1748 if ((!cp && configuration != 0))
1749 return -EINVAL;
1750
1751
1752
1753
1754
1755
1756 if (cp && configuration == 0)
1757 dev_warn(&dev->dev, "config 0 descriptor??\n");
1758
1759
1760
1761 n = nintf = 0;
1762 if (cp) {
1763 nintf = cp->desc.bNumInterfaces;
1764 new_interfaces = kmalloc(nintf * sizeof(*new_interfaces),
1765 GFP_NOIO);
1766 if (!new_interfaces) {
1767 dev_err(&dev->dev, "Out of memory\n");
1768 return -ENOMEM;
1769 }
1770
1771 for (; n < nintf; ++n) {
1772 new_interfaces[n] = kzalloc(
1773 sizeof(struct usb_interface),
1774 GFP_NOIO);
1775 if (!new_interfaces[n]) {
1776 dev_err(&dev->dev, "Out of memory\n");
1777 ret = -ENOMEM;
1778free_interfaces:
1779 while (--n >= 0)
1780 kfree(new_interfaces[n]);
1781 kfree(new_interfaces);
1782 return ret;
1783 }
1784 }
1785
1786 i = dev->bus_mA - usb_get_max_power(dev, cp);
1787 if (i < 0)
1788 dev_warn(&dev->dev, "new config #%d exceeds power "
1789 "limit by %dmA\n",
1790 configuration, -i);
1791 }
1792
1793
1794 ret = usb_autoresume_device(dev);
1795 if (ret)
1796 goto free_interfaces;
1797
1798
1799
1800
1801 if (dev->state != USB_STATE_ADDRESS)
1802 usb_disable_device(dev, 1);
1803
1804
1805 cancel_async_set_config(dev);
1806
1807
1808
1809
1810
1811
1812
1813 mutex_lock(hcd->bandwidth_mutex);
1814
1815
1816
1817
1818 if (dev->actconfig && usb_disable_lpm(dev)) {
1819 dev_err(&dev->dev, "%s Failed to disable LPM\n.", __func__);
1820 mutex_unlock(hcd->bandwidth_mutex);
1821 ret = -ENOMEM;
1822 goto free_interfaces;
1823 }
1824 ret = usb_hcd_alloc_bandwidth(dev, cp, NULL, NULL);
1825 if (ret < 0) {
1826 if (dev->actconfig)
1827 usb_enable_lpm(dev);
1828 mutex_unlock(hcd->bandwidth_mutex);
1829 usb_autosuspend_device(dev);
1830 goto free_interfaces;
1831 }
1832
1833
1834
1835
1836
1837 for (i = 0; i < nintf; ++i) {
1838 struct usb_interface_cache *intfc;
1839 struct usb_interface *intf;
1840 struct usb_host_interface *alt;
1841
1842 cp->interface[i] = intf = new_interfaces[i];
1843 intfc = cp->intf_cache[i];
1844 intf->altsetting = intfc->altsetting;
1845 intf->num_altsetting = intfc->num_altsetting;
1846 intf->authorized = !!HCD_INTF_AUTHORIZED(hcd);
1847 kref_get(&intfc->ref);
1848
1849 alt = usb_altnum_to_altsetting(intf, 0);
1850
1851
1852
1853
1854
1855
1856 if (!alt)
1857 alt = &intf->altsetting[0];
1858
1859 intf->intf_assoc =
1860 find_iad(dev, cp, alt->desc.bInterfaceNumber);
1861 intf->cur_altsetting = alt;
1862 usb_enable_interface(dev, intf, true);
1863 intf->dev.parent = &dev->dev;
1864 intf->dev.driver = NULL;
1865 intf->dev.bus = &usb_bus_type;
1866 intf->dev.type = &usb_if_device_type;
1867 intf->dev.groups = usb_interface_groups;
1868 intf->dev.dma_mask = dev->dev.dma_mask;
1869 INIT_WORK(&intf->reset_ws, __usb_queue_reset_device);
1870 intf->minor = -1;
1871 device_initialize(&intf->dev);
1872 pm_runtime_no_callbacks(&intf->dev);
1873 dev_set_name(&intf->dev, "%d-%s:%d.%d",
1874 dev->bus->busnum, dev->devpath,
1875 configuration, alt->desc.bInterfaceNumber);
1876 usb_get_dev(dev);
1877 }
1878 kfree(new_interfaces);
1879
1880 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1881 USB_REQ_SET_CONFIGURATION, 0, configuration, 0,
1882 NULL, 0, USB_CTRL_SET_TIMEOUT);
1883 if (ret < 0 && cp) {
1884
1885
1886
1887
1888 usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
1889 for (i = 0; i < nintf; ++i) {
1890 usb_disable_interface(dev, cp->interface[i], true);
1891 put_device(&cp->interface[i]->dev);
1892 cp->interface[i] = NULL;
1893 }
1894 cp = NULL;
1895 }
1896
1897 dev->actconfig = cp;
1898 mutex_unlock(hcd->bandwidth_mutex);
1899
1900 if (!cp) {
1901 usb_set_device_state(dev, USB_STATE_ADDRESS);
1902
1903
1904 usb_autosuspend_device(dev);
1905 return ret;
1906 }
1907 usb_set_device_state(dev, USB_STATE_CONFIGURED);
1908
1909 if (cp->string == NULL &&
1910 !(dev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
1911 cp->string = usb_cache_string(dev, cp->desc.iConfiguration);
1912
1913
1914 usb_unlocked_enable_lpm(dev);
1915
1916 usb_enable_ltm(dev);
1917
1918
1919
1920
1921
1922
1923
1924 for (i = 0; i < nintf; ++i) {
1925 struct usb_interface *intf = cp->interface[i];
1926
1927 dev_dbg(&dev->dev,
1928 "adding %s (config #%d, interface %d)\n",
1929 dev_name(&intf->dev), configuration,
1930 intf->cur_altsetting->desc.bInterfaceNumber);
1931 device_enable_async_suspend(&intf->dev);
1932 ret = device_add(&intf->dev);
1933 if (ret != 0) {
1934 dev_err(&dev->dev, "device_add(%s) --> %d\n",
1935 dev_name(&intf->dev), ret);
1936 continue;
1937 }
1938 create_intf_ep_devs(intf);
1939 }
1940
1941 usb_autosuspend_device(dev);
1942 return 0;
1943}
1944EXPORT_SYMBOL_GPL(usb_set_configuration);
1945
1946static LIST_HEAD(set_config_list);
1947static DEFINE_SPINLOCK(set_config_lock);
1948
1949struct set_config_request {
1950 struct usb_device *udev;
1951 int config;
1952 struct work_struct work;
1953 struct list_head node;
1954};
1955
1956
1957static void driver_set_config_work(struct work_struct *work)
1958{
1959 struct set_config_request *req =
1960 container_of(work, struct set_config_request, work);
1961 struct usb_device *udev = req->udev;
1962
1963 usb_lock_device(udev);
1964 spin_lock(&set_config_lock);
1965 list_del(&req->node);
1966 spin_unlock(&set_config_lock);
1967
1968 if (req->config >= -1)
1969 usb_set_configuration(udev, req->config);
1970 usb_unlock_device(udev);
1971 usb_put_dev(udev);
1972 kfree(req);
1973}
1974
1975
1976
1977
1978static void cancel_async_set_config(struct usb_device *udev)
1979{
1980 struct set_config_request *req;
1981
1982 spin_lock(&set_config_lock);
1983 list_for_each_entry(req, &set_config_list, node) {
1984 if (req->udev == udev)
1985 req->config = -999;
1986 }
1987 spin_unlock(&set_config_lock);
1988}
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010int usb_driver_set_configuration(struct usb_device *udev, int config)
2011{
2012 struct set_config_request *req;
2013
2014 req = kmalloc(sizeof(*req), GFP_KERNEL);
2015 if (!req)
2016 return -ENOMEM;
2017 req->udev = udev;
2018 req->config = config;
2019 INIT_WORK(&req->work, driver_set_config_work);
2020
2021 spin_lock(&set_config_lock);
2022 list_add(&req->node, &set_config_list);
2023 spin_unlock(&set_config_lock);
2024
2025 usb_get_dev(udev);
2026 schedule_work(&req->work);
2027 return 0;
2028}
2029EXPORT_SYMBOL_GPL(usb_driver_set_configuration);
2030