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