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