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