1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/device.h>
26#include <linux/slab.h>
27#include <linux/export.h>
28#include <linux/usb.h>
29#include <linux/usb/quirks.h>
30#include <linux/usb/hcd.h>
31
32#include "usb.h"
33
34
35
36
37
38
39ssize_t usb_store_new_id(struct usb_dynids *dynids,
40 struct device_driver *driver,
41 const char *buf, size_t count)
42{
43 struct usb_dynid *dynid;
44 u32 idVendor = 0;
45 u32 idProduct = 0;
46 unsigned int bInterfaceClass = 0;
47 int fields = 0;
48 int retval = 0;
49
50 fields = sscanf(buf, "%x %x %x", &idVendor, &idProduct,
51 &bInterfaceClass);
52 if (fields < 2)
53 return -EINVAL;
54
55 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
56 if (!dynid)
57 return -ENOMEM;
58
59 INIT_LIST_HEAD(&dynid->node);
60 dynid->id.idVendor = idVendor;
61 dynid->id.idProduct = idProduct;
62 dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE;
63 if (fields == 3) {
64 dynid->id.bInterfaceClass = (u8)bInterfaceClass;
65 dynid->id.match_flags |= USB_DEVICE_ID_MATCH_INT_CLASS;
66 }
67
68 spin_lock(&dynids->lock);
69 list_add_tail(&dynid->node, &dynids->list);
70 spin_unlock(&dynids->lock);
71
72 retval = driver_attach(driver);
73
74 if (retval)
75 return retval;
76 return count;
77}
78EXPORT_SYMBOL_GPL(usb_store_new_id);
79
80ssize_t usb_show_dynids(struct usb_dynids *dynids, char *buf)
81{
82 struct usb_dynid *dynid;
83 size_t count = 0;
84
85 list_for_each_entry(dynid, &dynids->list, node)
86 if (dynid->id.bInterfaceClass != 0)
87 count += scnprintf(&buf[count], PAGE_SIZE - count, "%04x %04x %02x\n",
88 dynid->id.idVendor, dynid->id.idProduct,
89 dynid->id.bInterfaceClass);
90 else
91 count += scnprintf(&buf[count], PAGE_SIZE - count, "%04x %04x\n",
92 dynid->id.idVendor, dynid->id.idProduct);
93 return count;
94}
95EXPORT_SYMBOL_GPL(usb_show_dynids);
96
97static ssize_t show_dynids(struct device_driver *driver, char *buf)
98{
99 struct usb_driver *usb_drv = to_usb_driver(driver);
100
101 return usb_show_dynids(&usb_drv->dynids, buf);
102}
103
104static ssize_t store_new_id(struct device_driver *driver,
105 const char *buf, size_t count)
106{
107 struct usb_driver *usb_drv = to_usb_driver(driver);
108
109 return usb_store_new_id(&usb_drv->dynids, driver, buf, count);
110}
111static DRIVER_ATTR(new_id, S_IRUGO | S_IWUSR, show_dynids, store_new_id);
112
113
114
115
116
117
118
119
120
121static ssize_t
122store_remove_id(struct device_driver *driver, const char *buf, size_t count)
123{
124 struct usb_dynid *dynid, *n;
125 struct usb_driver *usb_driver = to_usb_driver(driver);
126 u32 idVendor;
127 u32 idProduct;
128 int fields;
129
130 fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
131 if (fields < 2)
132 return -EINVAL;
133
134 spin_lock(&usb_driver->dynids.lock);
135 list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) {
136 struct usb_device_id *id = &dynid->id;
137 if ((id->idVendor == idVendor) &&
138 (id->idProduct == idProduct)) {
139 list_del(&dynid->node);
140 kfree(dynid);
141 break;
142 }
143 }
144 spin_unlock(&usb_driver->dynids.lock);
145 return count;
146}
147static DRIVER_ATTR(remove_id, S_IRUGO | S_IWUSR, show_dynids, store_remove_id);
148
149static int usb_create_newid_files(struct usb_driver *usb_drv)
150{
151 int error = 0;
152
153 if (usb_drv->no_dynamic_id)
154 goto exit;
155
156 if (usb_drv->probe != NULL) {
157 error = driver_create_file(&usb_drv->drvwrap.driver,
158 &driver_attr_new_id);
159 if (error == 0) {
160 error = driver_create_file(&usb_drv->drvwrap.driver,
161 &driver_attr_remove_id);
162 if (error)
163 driver_remove_file(&usb_drv->drvwrap.driver,
164 &driver_attr_new_id);
165 }
166 }
167exit:
168 return error;
169}
170
171static void usb_remove_newid_files(struct usb_driver *usb_drv)
172{
173 if (usb_drv->no_dynamic_id)
174 return;
175
176 if (usb_drv->probe != NULL) {
177 driver_remove_file(&usb_drv->drvwrap.driver,
178 &driver_attr_remove_id);
179 driver_remove_file(&usb_drv->drvwrap.driver,
180 &driver_attr_new_id);
181 }
182}
183
184static void usb_free_dynids(struct usb_driver *usb_drv)
185{
186 struct usb_dynid *dynid, *n;
187
188 spin_lock(&usb_drv->dynids.lock);
189 list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) {
190 list_del(&dynid->node);
191 kfree(dynid);
192 }
193 spin_unlock(&usb_drv->dynids.lock);
194}
195
196static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf,
197 struct usb_driver *drv)
198{
199 struct usb_dynid *dynid;
200
201 spin_lock(&drv->dynids.lock);
202 list_for_each_entry(dynid, &drv->dynids.list, node) {
203 if (usb_match_one_id(intf, &dynid->id)) {
204 spin_unlock(&drv->dynids.lock);
205 return &dynid->id;
206 }
207 }
208 spin_unlock(&drv->dynids.lock);
209 return NULL;
210}
211
212
213
214static int usb_probe_device(struct device *dev)
215{
216 struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
217 struct usb_device *udev = to_usb_device(dev);
218 int error = 0;
219
220 dev_dbg(dev, "%s\n", __func__);
221
222
223
224
225
226
227 if (!udriver->supports_autosuspend)
228 error = usb_autoresume_device(udev);
229
230 if (!error)
231 error = udriver->probe(udev);
232 return error;
233}
234
235
236static int usb_unbind_device(struct device *dev)
237{
238 struct usb_device *udev = to_usb_device(dev);
239 struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
240
241 udriver->disconnect(udev);
242 if (!udriver->supports_autosuspend)
243 usb_autosuspend_device(udev);
244 return 0;
245}
246
247
248
249
250
251
252
253
254
255
256static void usb_cancel_queued_reset(struct usb_interface *iface)
257{
258 if (iface->reset_running == 0)
259 cancel_work_sync(&iface->reset_ws);
260}
261
262
263static int usb_probe_interface(struct device *dev)
264{
265 struct usb_driver *driver = to_usb_driver(dev->driver);
266 struct usb_interface *intf = to_usb_interface(dev);
267 struct usb_device *udev = interface_to_usbdev(intf);
268 const struct usb_device_id *id;
269 int error = -ENODEV;
270 int lpm_disable_error;
271
272 dev_dbg(dev, "%s\n", __func__);
273
274 intf->needs_binding = 0;
275
276 if (usb_device_is_owned(udev))
277 return error;
278
279 if (udev->authorized == 0) {
280 dev_err(&intf->dev, "Device is not authorized for usage\n");
281 return error;
282 }
283
284 id = usb_match_id(intf, driver->id_table);
285 if (!id)
286 id = usb_match_dynamic_id(intf, driver);
287 if (!id)
288 return error;
289
290 dev_dbg(dev, "%s - got id\n", __func__);
291
292 error = usb_autoresume_device(udev);
293 if (error)
294 return error;
295
296 intf->condition = USB_INTERFACE_BINDING;
297
298
299
300
301
302 pm_runtime_set_active(dev);
303 pm_suspend_ignore_children(dev, false);
304 if (driver->supports_autosuspend)
305 pm_runtime_enable(dev);
306
307
308
309
310
311
312
313
314
315
316
317
318 lpm_disable_error = usb_unlocked_disable_lpm(udev);
319 if (lpm_disable_error && driver->disable_hub_initiated_lpm) {
320 dev_err(&intf->dev, "%s Failed to disable LPM for driver %s\n.",
321 __func__, driver->name);
322 error = lpm_disable_error;
323 goto err;
324 }
325
326
327 if (intf->needs_altsetting0) {
328 error = usb_set_interface(udev, intf->altsetting[0].
329 desc.bInterfaceNumber, 0);
330 if (error < 0)
331 goto err;
332 intf->needs_altsetting0 = 0;
333 }
334
335 error = driver->probe(intf, id);
336 if (error)
337 goto err;
338
339 intf->condition = USB_INTERFACE_BOUND;
340
341
342 if (!lpm_disable_error)
343 usb_unlocked_enable_lpm(udev);
344
345 usb_autosuspend_device(udev);
346 return error;
347
348 err:
349 usb_set_intfdata(intf, NULL);
350 intf->needs_remote_wakeup = 0;
351 intf->condition = USB_INTERFACE_UNBOUND;
352 usb_cancel_queued_reset(intf);
353
354
355 if (!lpm_disable_error)
356 usb_unlocked_enable_lpm(udev);
357
358
359 if (driver->supports_autosuspend)
360 pm_runtime_disable(dev);
361 pm_runtime_set_suspended(dev);
362
363 usb_autosuspend_device(udev);
364 return error;
365}
366
367
368static int usb_unbind_interface(struct device *dev)
369{
370 struct usb_driver *driver = to_usb_driver(dev->driver);
371 struct usb_interface *intf = to_usb_interface(dev);
372 struct usb_device *udev;
373 int error, r, lpm_disable_error;
374
375 intf->condition = USB_INTERFACE_UNBINDING;
376
377
378 udev = interface_to_usbdev(intf);
379 error = usb_autoresume_device(udev);
380
381
382
383
384
385
386 lpm_disable_error = usb_unlocked_disable_lpm(udev);
387
388
389
390
391 if (!driver->soft_unbind)
392 usb_disable_interface(udev, intf, false);
393
394 driver->disconnect(intf);
395 usb_cancel_queued_reset(intf);
396
397
398
399
400
401
402
403 if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
404
405
406
407 usb_enable_interface(udev, intf, false);
408 } else if (!error && !intf->dev.power.is_prepared) {
409 r = usb_set_interface(udev, intf->altsetting[0].
410 desc.bInterfaceNumber, 0);
411 if (r < 0)
412 intf->needs_altsetting0 = 1;
413 } else {
414 intf->needs_altsetting0 = 1;
415 }
416 usb_set_intfdata(intf, NULL);
417
418 intf->condition = USB_INTERFACE_UNBOUND;
419 intf->needs_remote_wakeup = 0;
420
421
422 if (!lpm_disable_error)
423 usb_unlocked_enable_lpm(udev);
424
425
426 if (driver->supports_autosuspend)
427 pm_runtime_disable(dev);
428 pm_runtime_set_suspended(dev);
429
430
431 for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r)
432 usb_autopm_put_interface_no_suspend(intf);
433 atomic_set(&intf->pm_usage_cnt, 0);
434
435 if (!error)
436 usb_autosuspend_device(udev);
437
438 return 0;
439}
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461int usb_driver_claim_interface(struct usb_driver *driver,
462 struct usb_interface *iface, void *priv)
463{
464 struct device *dev = &iface->dev;
465 struct usb_device *udev;
466 int retval = 0;
467 int lpm_disable_error;
468
469 if (dev->driver)
470 return -EBUSY;
471
472 udev = interface_to_usbdev(iface);
473
474 dev->driver = &driver->drvwrap.driver;
475 usb_set_intfdata(iface, priv);
476 iface->needs_binding = 0;
477
478 iface->condition = USB_INTERFACE_BOUND;
479
480
481 lpm_disable_error = usb_unlocked_disable_lpm(udev);
482 if (lpm_disable_error && driver->disable_hub_initiated_lpm) {
483 dev_err(&iface->dev, "%s Failed to disable LPM for driver %s\n.",
484 __func__, driver->name);
485 return -ENOMEM;
486 }
487
488
489
490
491
492
493
494 pm_suspend_ignore_children(dev, false);
495 if (driver->supports_autosuspend)
496 pm_runtime_enable(dev);
497 else
498 pm_runtime_set_active(dev);
499
500
501
502
503 if (device_is_registered(dev))
504 retval = device_bind_driver(dev);
505
506
507 if (!lpm_disable_error)
508 usb_unlocked_enable_lpm(udev);
509
510 return retval;
511}
512EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528void usb_driver_release_interface(struct usb_driver *driver,
529 struct usb_interface *iface)
530{
531 struct device *dev = &iface->dev;
532
533
534 if (!dev->driver || dev->driver != &driver->drvwrap.driver)
535 return;
536
537
538 if (iface->condition != USB_INTERFACE_BOUND)
539 return;
540 iface->condition = USB_INTERFACE_UNBINDING;
541
542
543
544
545 if (device_is_registered(dev)) {
546 device_release_driver(dev);
547 } else {
548 device_lock(dev);
549 usb_unbind_interface(dev);
550 dev->driver = NULL;
551 device_unlock(dev);
552 }
553}
554EXPORT_SYMBOL_GPL(usb_driver_release_interface);
555
556
557int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
558{
559 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
560 id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
561 return 0;
562
563 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
564 id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
565 return 0;
566
567
568
569 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
570 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
571 return 0;
572
573 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
574 (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
575 return 0;
576
577 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
578 (id->bDeviceClass != dev->descriptor.bDeviceClass))
579 return 0;
580
581 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
582 (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
583 return 0;
584
585 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
586 (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
587 return 0;
588
589 return 1;
590}
591
592
593int usb_match_one_id_intf(struct usb_device *dev,
594 struct usb_host_interface *intf,
595 const struct usb_device_id *id)
596{
597
598
599
600 if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
601 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
602 (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
603 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
604 USB_DEVICE_ID_MATCH_INT_PROTOCOL |
605 USB_DEVICE_ID_MATCH_INT_NUMBER)))
606 return 0;
607
608 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
609 (id->bInterfaceClass != intf->desc.bInterfaceClass))
610 return 0;
611
612 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
613 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
614 return 0;
615
616 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
617 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
618 return 0;
619
620 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER) &&
621 (id->bInterfaceNumber != intf->desc.bInterfaceNumber))
622 return 0;
623
624 return 1;
625}
626
627
628int usb_match_one_id(struct usb_interface *interface,
629 const struct usb_device_id *id)
630{
631 struct usb_host_interface *intf;
632 struct usb_device *dev;
633
634
635 if (id == NULL)
636 return 0;
637
638 intf = interface->cur_altsetting;
639 dev = interface_to_usbdev(interface);
640
641 if (!usb_match_device(dev, id))
642 return 0;
643
644 return usb_match_one_id_intf(dev, intf, id);
645}
646EXPORT_SYMBOL_GPL(usb_match_one_id);
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719const struct usb_device_id *usb_match_id(struct usb_interface *interface,
720 const struct usb_device_id *id)
721{
722
723 if (id == NULL)
724 return NULL;
725
726
727
728
729
730
731 for (; id->idVendor || id->idProduct || id->bDeviceClass ||
732 id->bInterfaceClass || id->driver_info; id++) {
733 if (usb_match_one_id(interface, id))
734 return id;
735 }
736
737 return NULL;
738}
739EXPORT_SYMBOL_GPL(usb_match_id);
740
741static int usb_device_match(struct device *dev, struct device_driver *drv)
742{
743
744 if (is_usb_device(dev)) {
745
746
747 if (!is_usb_device_driver(drv))
748 return 0;
749
750
751 return 1;
752
753 } else if (is_usb_interface(dev)) {
754 struct usb_interface *intf;
755 struct usb_driver *usb_drv;
756 const struct usb_device_id *id;
757
758
759 if (is_usb_device_driver(drv))
760 return 0;
761
762 intf = to_usb_interface(dev);
763 usb_drv = to_usb_driver(drv);
764
765 id = usb_match_id(intf, usb_drv->id_table);
766 if (id)
767 return 1;
768
769 id = usb_match_dynamic_id(intf, usb_drv);
770 if (id)
771 return 1;
772 }
773
774 return 0;
775}
776
777static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
778{
779 struct usb_device *usb_dev;
780
781 if (is_usb_device(dev)) {
782 usb_dev = to_usb_device(dev);
783 } else if (is_usb_interface(dev)) {
784 struct usb_interface *intf = to_usb_interface(dev);
785
786 usb_dev = interface_to_usbdev(intf);
787 } else {
788 return 0;
789 }
790
791 if (usb_dev->devnum < 0) {
792
793 pr_debug("usb %s: already deleted?\n", dev_name(dev));
794 return -ENODEV;
795 }
796 if (!usb_dev->bus) {
797 pr_debug("usb %s: bus removed?\n", dev_name(dev));
798 return -ENODEV;
799 }
800
801
802 if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
803 le16_to_cpu(usb_dev->descriptor.idVendor),
804 le16_to_cpu(usb_dev->descriptor.idProduct),
805 le16_to_cpu(usb_dev->descriptor.bcdDevice)))
806 return -ENOMEM;
807
808
809 if (add_uevent_var(env, "TYPE=%d/%d/%d",
810 usb_dev->descriptor.bDeviceClass,
811 usb_dev->descriptor.bDeviceSubClass,
812 usb_dev->descriptor.bDeviceProtocol))
813 return -ENOMEM;
814
815 return 0;
816}
817
818
819
820
821
822
823
824
825
826
827
828int usb_register_device_driver(struct usb_device_driver *new_udriver,
829 struct module *owner)
830{
831 int retval = 0;
832
833 if (usb_disabled())
834 return -ENODEV;
835
836 new_udriver->drvwrap.for_devices = 1;
837 new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
838 new_udriver->drvwrap.driver.bus = &usb_bus_type;
839 new_udriver->drvwrap.driver.probe = usb_probe_device;
840 new_udriver->drvwrap.driver.remove = usb_unbind_device;
841 new_udriver->drvwrap.driver.owner = owner;
842
843 retval = driver_register(&new_udriver->drvwrap.driver);
844
845 if (!retval)
846 pr_info("%s: registered new device driver %s\n",
847 usbcore_name, new_udriver->name);
848 else
849 printk(KERN_ERR "%s: error %d registering device "
850 " driver %s\n",
851 usbcore_name, retval, new_udriver->name);
852
853 return retval;
854}
855EXPORT_SYMBOL_GPL(usb_register_device_driver);
856
857
858
859
860
861
862
863
864void usb_deregister_device_driver(struct usb_device_driver *udriver)
865{
866 pr_info("%s: deregistering device driver %s\n",
867 usbcore_name, udriver->name);
868
869 driver_unregister(&udriver->drvwrap.driver);
870}
871EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
889 const char *mod_name)
890{
891 int retval = 0;
892
893 if (usb_disabled())
894 return -ENODEV;
895
896 new_driver->drvwrap.for_devices = 0;
897 new_driver->drvwrap.driver.name = (char *) new_driver->name;
898 new_driver->drvwrap.driver.bus = &usb_bus_type;
899 new_driver->drvwrap.driver.probe = usb_probe_interface;
900 new_driver->drvwrap.driver.remove = usb_unbind_interface;
901 new_driver->drvwrap.driver.owner = owner;
902 new_driver->drvwrap.driver.mod_name = mod_name;
903 spin_lock_init(&new_driver->dynids.lock);
904 INIT_LIST_HEAD(&new_driver->dynids.list);
905
906 retval = driver_register(&new_driver->drvwrap.driver);
907 if (retval)
908 goto out;
909
910 retval = usb_create_newid_files(new_driver);
911 if (retval)
912 goto out_newid;
913
914 pr_info("%s: registered new interface driver %s\n",
915 usbcore_name, new_driver->name);
916
917out:
918 return retval;
919
920out_newid:
921 driver_unregister(&new_driver->drvwrap.driver);
922
923 printk(KERN_ERR "%s: error %d registering interface "
924 " driver %s\n",
925 usbcore_name, retval, new_driver->name);
926 goto out;
927}
928EXPORT_SYMBOL_GPL(usb_register_driver);
929
930
931
932
933
934
935
936
937
938
939
940
941void usb_deregister(struct usb_driver *driver)
942{
943 pr_info("%s: deregistering interface driver %s\n",
944 usbcore_name, driver->name);
945
946 usb_remove_newid_files(driver);
947 driver_unregister(&driver->drvwrap.driver);
948 usb_free_dynids(driver);
949}
950EXPORT_SYMBOL_GPL(usb_deregister);
951
952
953
954
955
956
957
958
959void usb_forced_unbind_intf(struct usb_interface *intf)
960{
961 struct usb_driver *driver = to_usb_driver(intf->dev.driver);
962
963 dev_dbg(&intf->dev, "forced unbind\n");
964 usb_driver_release_interface(driver, intf);
965
966
967 intf->needs_binding = 1;
968}
969
970
971
972
973
974
975
976
977
978
979void usb_rebind_intf(struct usb_interface *intf)
980{
981 int rc;
982
983
984 if (intf->dev.driver)
985 usb_forced_unbind_intf(intf);
986
987
988 if (!intf->dev.power.is_prepared) {
989 intf->needs_binding = 0;
990 rc = device_attach(&intf->dev);
991 if (rc < 0)
992 dev_warn(&intf->dev, "rebind failed: %d\n", rc);
993 }
994}
995
996#ifdef CONFIG_PM
997
998
999
1000
1001
1002
1003
1004static void unbind_no_pm_drivers_interfaces(struct usb_device *udev)
1005{
1006 struct usb_host_config *config;
1007 int i;
1008 struct usb_interface *intf;
1009 struct usb_driver *drv;
1010
1011 config = udev->actconfig;
1012 if (config) {
1013 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
1014 intf = config->interface[i];
1015
1016 if (intf->dev.driver) {
1017 drv = to_usb_driver(intf->dev.driver);
1018 if (!drv->suspend || !drv->resume)
1019 usb_forced_unbind_intf(intf);
1020 }
1021 }
1022 }
1023}
1024
1025
1026
1027
1028
1029
1030static void unbind_no_reset_resume_drivers_interfaces(struct usb_device *udev)
1031{
1032 struct usb_host_config *config;
1033 int i;
1034 struct usb_interface *intf;
1035
1036 config = udev->actconfig;
1037 if (config) {
1038 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
1039 intf = config->interface[i];
1040 if (intf->dev.driver && intf->needs_binding)
1041 usb_forced_unbind_intf(intf);
1042 }
1043 }
1044}
1045
1046static void do_rebind_interfaces(struct usb_device *udev)
1047{
1048 struct usb_host_config *config;
1049 int i;
1050 struct usb_interface *intf;
1051
1052 config = udev->actconfig;
1053 if (config) {
1054 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
1055 intf = config->interface[i];
1056 if (intf->needs_binding)
1057 usb_rebind_intf(intf);
1058 }
1059 }
1060}
1061
1062static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
1063{
1064 struct usb_device_driver *udriver;
1065 int status = 0;
1066
1067 if (udev->state == USB_STATE_NOTATTACHED ||
1068 udev->state == USB_STATE_SUSPENDED)
1069 goto done;
1070
1071
1072 if (udev->dev.driver)
1073 udriver = to_usb_device_driver(udev->dev.driver);
1074 else {
1075 udev->do_remote_wakeup = 0;
1076 udriver = &usb_generic_driver;
1077 }
1078 status = udriver->suspend(udev, msg);
1079
1080 done:
1081 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1082 return status;
1083}
1084
1085static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
1086{
1087 struct usb_device_driver *udriver;
1088 int status = 0;
1089
1090 if (udev->state == USB_STATE_NOTATTACHED)
1091 goto done;
1092
1093
1094 if (udev->dev.driver == NULL) {
1095 status = -ENOTCONN;
1096 goto done;
1097 }
1098
1099
1100
1101
1102 if (!PMSG_IS_AUTO(msg) && udev->parent && udev->bus->hs_companion)
1103 device_pm_wait_for_dev(&udev->dev,
1104 &udev->bus->hs_companion->root_hub->dev);
1105
1106 if (udev->quirks & USB_QUIRK_RESET_RESUME)
1107 udev->reset_resume = 1;
1108
1109 udriver = to_usb_device_driver(udev->dev.driver);
1110 status = udriver->resume(udev, msg);
1111
1112 done:
1113 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1114 return status;
1115}
1116
1117static int usb_suspend_interface(struct usb_device *udev,
1118 struct usb_interface *intf, pm_message_t msg)
1119{
1120 struct usb_driver *driver;
1121 int status = 0;
1122
1123 if (udev->state == USB_STATE_NOTATTACHED ||
1124 intf->condition == USB_INTERFACE_UNBOUND)
1125 goto done;
1126 driver = to_usb_driver(intf->dev.driver);
1127
1128
1129 status = driver->suspend(intf, msg);
1130 if (status && !PMSG_IS_AUTO(msg))
1131 dev_err(&intf->dev, "suspend error %d\n", status);
1132
1133 done:
1134 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1135 return status;
1136}
1137
1138static int usb_resume_interface(struct usb_device *udev,
1139 struct usb_interface *intf, pm_message_t msg, int reset_resume)
1140{
1141 struct usb_driver *driver;
1142 int status = 0;
1143
1144 if (udev->state == USB_STATE_NOTATTACHED)
1145 goto done;
1146
1147
1148 if (intf->condition == USB_INTERFACE_UNBINDING)
1149 goto done;
1150
1151
1152 if (intf->condition == USB_INTERFACE_UNBOUND) {
1153
1154
1155 if (intf->needs_altsetting0 && !intf->dev.power.is_prepared) {
1156 usb_set_interface(udev, intf->altsetting[0].
1157 desc.bInterfaceNumber, 0);
1158 intf->needs_altsetting0 = 0;
1159 }
1160 goto done;
1161 }
1162
1163
1164 if (intf->needs_binding)
1165 goto done;
1166 driver = to_usb_driver(intf->dev.driver);
1167
1168 if (reset_resume) {
1169 if (driver->reset_resume) {
1170 status = driver->reset_resume(intf);
1171 if (status)
1172 dev_err(&intf->dev, "%s error %d\n",
1173 "reset_resume", status);
1174 } else {
1175 intf->needs_binding = 1;
1176 dev_warn(&intf->dev, "no %s for driver %s?\n",
1177 "reset_resume", driver->name);
1178 }
1179 } else {
1180 status = driver->resume(intf);
1181 if (status)
1182 dev_err(&intf->dev, "resume error %d\n", status);
1183 }
1184
1185done:
1186 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1187
1188
1189 return status;
1190}
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1218{
1219 int status = 0;
1220 int i = 0, n = 0;
1221 struct usb_interface *intf;
1222
1223 if (udev->state == USB_STATE_NOTATTACHED ||
1224 udev->state == USB_STATE_SUSPENDED)
1225 goto done;
1226
1227
1228 if (udev->actconfig) {
1229 n = udev->actconfig->desc.bNumInterfaces;
1230 for (i = n - 1; i >= 0; --i) {
1231 intf = udev->actconfig->interface[i];
1232 status = usb_suspend_interface(udev, intf, msg);
1233
1234
1235 if (!PMSG_IS_AUTO(msg))
1236 status = 0;
1237 if (status != 0)
1238 break;
1239 }
1240 }
1241 if (status == 0) {
1242 status = usb_suspend_device(udev, msg);
1243
1244
1245
1246
1247
1248
1249
1250 if (udev->parent && !PMSG_IS_AUTO(msg))
1251 status = 0;
1252 }
1253
1254
1255 if (status != 0) {
1256 if (udev->actconfig) {
1257 msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
1258 while (++i < n) {
1259 intf = udev->actconfig->interface[i];
1260 usb_resume_interface(udev, intf, msg, 0);
1261 }
1262 }
1263
1264
1265
1266
1267 } else {
1268 udev->can_submit = 0;
1269 for (i = 0; i < 16; ++i) {
1270 usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1271 usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1272 }
1273 }
1274
1275 done:
1276 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1277 return status;
1278}
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
1299{
1300 int status = 0;
1301 int i;
1302 struct usb_interface *intf;
1303
1304 if (udev->state == USB_STATE_NOTATTACHED) {
1305 status = -ENODEV;
1306 goto done;
1307 }
1308 udev->can_submit = 1;
1309
1310
1311 if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume)
1312 status = usb_resume_device(udev, msg);
1313
1314
1315 if (status == 0 && udev->actconfig) {
1316 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1317 intf = udev->actconfig->interface[i];
1318 usb_resume_interface(udev, intf, msg,
1319 udev->reset_resume);
1320 }
1321 }
1322 usb_mark_last_busy(udev);
1323
1324 done:
1325 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1326 if (!status)
1327 udev->reset_resume = 0;
1328 return status;
1329}
1330
1331static void choose_wakeup(struct usb_device *udev, pm_message_t msg)
1332{
1333 int w;
1334
1335
1336
1337
1338
1339 if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) {
1340 if (udev->state != USB_STATE_SUSPENDED)
1341 udev->do_remote_wakeup = 0;
1342 return;
1343 }
1344
1345
1346
1347
1348 w = device_may_wakeup(&udev->dev);
1349
1350
1351
1352
1353 if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup)
1354 pm_runtime_resume(&udev->dev);
1355 udev->do_remote_wakeup = w;
1356}
1357
1358
1359int usb_suspend(struct device *dev, pm_message_t msg)
1360{
1361 struct usb_device *udev = to_usb_device(dev);
1362
1363 unbind_no_pm_drivers_interfaces(udev);
1364
1365
1366
1367
1368
1369 choose_wakeup(udev, msg);
1370 return usb_suspend_both(udev, msg);
1371}
1372
1373
1374int usb_resume_complete(struct device *dev)
1375{
1376 struct usb_device *udev = to_usb_device(dev);
1377
1378
1379
1380
1381 if (udev->state != USB_STATE_NOTATTACHED)
1382 do_rebind_interfaces(udev);
1383 return 0;
1384}
1385
1386
1387int usb_resume(struct device *dev, pm_message_t msg)
1388{
1389 struct usb_device *udev = to_usb_device(dev);
1390 int status;
1391
1392
1393
1394
1395
1396
1397
1398
1399 status = usb_resume_both(udev, msg);
1400 if (status == 0) {
1401 pm_runtime_disable(dev);
1402 pm_runtime_set_active(dev);
1403 pm_runtime_enable(dev);
1404 unbind_no_reset_resume_drivers_interfaces(udev);
1405 }
1406
1407
1408
1409
1410 if (status == -ENODEV || status == -ESHUTDOWN)
1411 status = 0;
1412 return status;
1413}
1414
1415#endif
1416
1417#ifdef CONFIG_PM_RUNTIME
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429void usb_enable_autosuspend(struct usb_device *udev)
1430{
1431 pm_runtime_allow(&udev->dev);
1432}
1433EXPORT_SYMBOL_GPL(usb_enable_autosuspend);
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444void usb_disable_autosuspend(struct usb_device *udev)
1445{
1446 pm_runtime_forbid(&udev->dev);
1447}
1448EXPORT_SYMBOL_GPL(usb_disable_autosuspend);
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466void usb_autosuspend_device(struct usb_device *udev)
1467{
1468 int status;
1469
1470 usb_mark_last_busy(udev);
1471 status = pm_runtime_put_sync_autosuspend(&udev->dev);
1472 dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1473 __func__, atomic_read(&udev->dev.power.usage_count),
1474 status);
1475}
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495int usb_autoresume_device(struct usb_device *udev)
1496{
1497 int status;
1498
1499 status = pm_runtime_get_sync(&udev->dev);
1500 if (status < 0)
1501 pm_runtime_put_sync(&udev->dev);
1502 dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1503 __func__, atomic_read(&udev->dev.power.usage_count),
1504 status);
1505 if (status > 0)
1506 status = 0;
1507 return status;
1508}
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525void usb_autopm_put_interface(struct usb_interface *intf)
1526{
1527 struct usb_device *udev = interface_to_usbdev(intf);
1528 int status;
1529
1530 usb_mark_last_busy(udev);
1531 atomic_dec(&intf->pm_usage_cnt);
1532 status = pm_runtime_put_sync(&intf->dev);
1533 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1534 __func__, atomic_read(&intf->dev.power.usage_count),
1535 status);
1536}
1537EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554void usb_autopm_put_interface_async(struct usb_interface *intf)
1555{
1556 struct usb_device *udev = interface_to_usbdev(intf);
1557 int status;
1558
1559 usb_mark_last_busy(udev);
1560 atomic_dec(&intf->pm_usage_cnt);
1561 status = pm_runtime_put(&intf->dev);
1562 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1563 __func__, atomic_read(&intf->dev.power.usage_count),
1564 status);
1565}
1566EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
1578{
1579 struct usb_device *udev = interface_to_usbdev(intf);
1580
1581 usb_mark_last_busy(udev);
1582 atomic_dec(&intf->pm_usage_cnt);
1583 pm_runtime_put_noidle(&intf->dev);
1584}
1585EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend);
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604int usb_autopm_get_interface(struct usb_interface *intf)
1605{
1606 int status;
1607
1608 status = pm_runtime_get_sync(&intf->dev);
1609 if (status < 0)
1610 pm_runtime_put_sync(&intf->dev);
1611 else
1612 atomic_inc(&intf->pm_usage_cnt);
1613 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1614 __func__, atomic_read(&intf->dev.power.usage_count),
1615 status);
1616 if (status > 0)
1617 status = 0;
1618 return status;
1619}
1620EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637int usb_autopm_get_interface_async(struct usb_interface *intf)
1638{
1639 int status;
1640
1641 status = pm_runtime_get(&intf->dev);
1642 if (status < 0 && status != -EINPROGRESS)
1643 pm_runtime_put_noidle(&intf->dev);
1644 else
1645 atomic_inc(&intf->pm_usage_cnt);
1646 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1647 __func__, atomic_read(&intf->dev.power.usage_count),
1648 status);
1649 if (status > 0 || status == -EINPROGRESS)
1650 status = 0;
1651 return status;
1652}
1653EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
1665{
1666 struct usb_device *udev = interface_to_usbdev(intf);
1667
1668 usb_mark_last_busy(udev);
1669 atomic_inc(&intf->pm_usage_cnt);
1670 pm_runtime_get_noresume(&intf->dev);
1671}
1672EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume);
1673
1674
1675static int autosuspend_check(struct usb_device *udev)
1676{
1677 int w, i;
1678 struct usb_interface *intf;
1679
1680
1681
1682
1683 w = 0;
1684 if (udev->actconfig) {
1685 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1686 intf = udev->actconfig->interface[i];
1687
1688
1689
1690
1691
1692
1693 if (intf->dev.power.disable_depth)
1694 continue;
1695 if (atomic_read(&intf->dev.power.usage_count) > 0)
1696 return -EBUSY;
1697 w |= intf->needs_remote_wakeup;
1698
1699
1700
1701
1702
1703 if (udev->quirks & USB_QUIRK_RESET_RESUME) {
1704 struct usb_driver *driver;
1705
1706 driver = to_usb_driver(intf->dev.driver);
1707 if (!driver->reset_resume ||
1708 intf->needs_remote_wakeup)
1709 return -EOPNOTSUPP;
1710 }
1711 }
1712 }
1713 if (w && !device_can_wakeup(&udev->dev)) {
1714 dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
1715 return -EOPNOTSUPP;
1716 }
1717 udev->do_remote_wakeup = w;
1718 return 0;
1719}
1720
1721int usb_runtime_suspend(struct device *dev)
1722{
1723 struct usb_device *udev = to_usb_device(dev);
1724 int status;
1725
1726
1727
1728
1729
1730 if (autosuspend_check(udev) != 0)
1731 return -EAGAIN;
1732
1733 status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
1734
1735
1736 if (status == -EAGAIN || status == -EBUSY)
1737 usb_mark_last_busy(udev);
1738
1739
1740
1741
1742 if (status != 0)
1743 return -EBUSY;
1744 return status;
1745}
1746
1747int usb_runtime_resume(struct device *dev)
1748{
1749 struct usb_device *udev = to_usb_device(dev);
1750 int status;
1751
1752
1753
1754
1755 status = usb_resume_both(udev, PMSG_AUTO_RESUME);
1756 return status;
1757}
1758
1759int usb_runtime_idle(struct device *dev)
1760{
1761 struct usb_device *udev = to_usb_device(dev);
1762
1763
1764
1765
1766 if (autosuspend_check(udev) == 0)
1767 pm_runtime_autosuspend(dev);
1768
1769 return -EBUSY;
1770}
1771
1772int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
1773{
1774 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
1775 int ret = -EPERM;
1776
1777 if (hcd->driver->set_usb2_hw_lpm) {
1778 ret = hcd->driver->set_usb2_hw_lpm(hcd, udev, enable);
1779 if (!ret)
1780 udev->usb2_hw_lpm_enabled = enable;
1781 }
1782
1783 return ret;
1784}
1785
1786#endif
1787
1788struct bus_type usb_bus_type = {
1789 .name = "usb",
1790 .match = usb_device_match,
1791 .uevent = usb_uevent,
1792};
1793