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
535int usb_driver_claim_interface(struct usb_driver *driver,
536 struct usb_interface *iface, void *data)
537{
538 struct device *dev;
539 int retval = 0;
540
541 if (!iface)
542 return -ENODEV;
543
544 dev = &iface->dev;
545 if (dev->driver)
546 return -EBUSY;
547
548
549 if (!iface->authorized)
550 return -ENODEV;
551
552 dev->driver = &driver->drvwrap.driver;
553 usb_set_intfdata(iface, data);
554 iface->needs_binding = 0;
555
556 iface->condition = USB_INTERFACE_BOUND;
557
558
559
560
561
562
563
564 pm_suspend_ignore_children(dev, false);
565 if (driver->supports_autosuspend)
566 pm_runtime_enable(dev);
567 else
568 pm_runtime_set_active(dev);
569
570
571
572
573 if (device_is_registered(dev))
574 retval = device_bind_driver(dev);
575
576 if (retval) {
577 dev->driver = NULL;
578 usb_set_intfdata(iface, NULL);
579 iface->needs_remote_wakeup = 0;
580 iface->condition = USB_INTERFACE_UNBOUND;
581
582
583
584
585
586 if (driver->supports_autosuspend)
587 pm_runtime_disable(dev);
588 pm_runtime_set_suspended(dev);
589 }
590
591 return retval;
592}
593EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609void usb_driver_release_interface(struct usb_driver *driver,
610 struct usb_interface *iface)
611{
612 struct device *dev = &iface->dev;
613
614
615 if (!dev->driver || dev->driver != &driver->drvwrap.driver)
616 return;
617
618
619 if (iface->condition != USB_INTERFACE_BOUND)
620 return;
621 iface->condition = USB_INTERFACE_UNBINDING;
622
623
624
625
626 if (device_is_registered(dev)) {
627 device_release_driver(dev);
628 } else {
629 device_lock(dev);
630 usb_unbind_interface(dev);
631 dev->driver = NULL;
632 device_unlock(dev);
633 }
634}
635EXPORT_SYMBOL_GPL(usb_driver_release_interface);
636
637
638int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
639{
640 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
641 id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
642 return 0;
643
644 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
645 id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
646 return 0;
647
648
649
650 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
651 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
652 return 0;
653
654 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
655 (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
656 return 0;
657
658 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
659 (id->bDeviceClass != dev->descriptor.bDeviceClass))
660 return 0;
661
662 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
663 (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
664 return 0;
665
666 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
667 (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
668 return 0;
669
670 return 1;
671}
672
673
674int usb_match_one_id_intf(struct usb_device *dev,
675 struct usb_host_interface *intf,
676 const struct usb_device_id *id)
677{
678
679
680
681 if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
682 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
683 (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
684 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
685 USB_DEVICE_ID_MATCH_INT_PROTOCOL |
686 USB_DEVICE_ID_MATCH_INT_NUMBER)))
687 return 0;
688
689 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
690 (id->bInterfaceClass != intf->desc.bInterfaceClass))
691 return 0;
692
693 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
694 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
695 return 0;
696
697 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
698 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
699 return 0;
700
701 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER) &&
702 (id->bInterfaceNumber != intf->desc.bInterfaceNumber))
703 return 0;
704
705 return 1;
706}
707
708
709int usb_match_one_id(struct usb_interface *interface,
710 const struct usb_device_id *id)
711{
712 struct usb_host_interface *intf;
713 struct usb_device *dev;
714
715
716 if (id == NULL)
717 return 0;
718
719 intf = interface->cur_altsetting;
720 dev = interface_to_usbdev(interface);
721
722 if (!usb_match_device(dev, id))
723 return 0;
724
725 return usb_match_one_id_intf(dev, intf, id);
726}
727EXPORT_SYMBOL_GPL(usb_match_one_id);
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
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
802const struct usb_device_id *usb_match_id(struct usb_interface *interface,
803 const struct usb_device_id *id)
804{
805
806 if (id == NULL)
807 return NULL;
808
809
810
811
812
813
814 for (; id->idVendor || id->idProduct || id->bDeviceClass ||
815 id->bInterfaceClass || id->driver_info; id++) {
816 if (usb_match_one_id(interface, id))
817 return id;
818 }
819
820 return NULL;
821}
822EXPORT_SYMBOL_GPL(usb_match_id);
823
824const struct usb_device_id *usb_device_match_id(struct usb_device *udev,
825 const struct usb_device_id *id)
826{
827 if (!id)
828 return NULL;
829
830 for (; id->idVendor || id->idProduct ; id++) {
831 if (usb_match_device(udev, id))
832 return id;
833 }
834
835 return NULL;
836}
837
838bool usb_driver_applicable(struct usb_device *udev,
839 struct usb_device_driver *udrv)
840{
841 if (udrv->id_table && udrv->match)
842 return usb_device_match_id(udev, udrv->id_table) != NULL &&
843 udrv->match(udev);
844
845 if (udrv->id_table)
846 return usb_device_match_id(udev, udrv->id_table) != NULL;
847
848 if (udrv->match)
849 return udrv->match(udev);
850
851 return false;
852}
853
854static int usb_device_match(struct device *dev, struct device_driver *drv)
855{
856
857 if (is_usb_device(dev)) {
858 struct usb_device *udev;
859 struct usb_device_driver *udrv;
860
861
862 if (!is_usb_device_driver(drv))
863 return 0;
864
865 udev = to_usb_device(dev);
866 udrv = to_usb_device_driver(drv);
867
868
869
870
871
872 if (!udrv->id_table && !udrv->match)
873 return 1;
874
875 return usb_driver_applicable(udev, udrv);
876
877 } else if (is_usb_interface(dev)) {
878 struct usb_interface *intf;
879 struct usb_driver *usb_drv;
880 const struct usb_device_id *id;
881
882
883 if (is_usb_device_driver(drv))
884 return 0;
885
886 intf = to_usb_interface(dev);
887 usb_drv = to_usb_driver(drv);
888
889 id = usb_match_id(intf, usb_drv->id_table);
890 if (id)
891 return 1;
892
893 id = usb_match_dynamic_id(intf, usb_drv);
894 if (id)
895 return 1;
896 }
897
898 return 0;
899}
900
901static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
902{
903 struct usb_device *usb_dev;
904
905 if (is_usb_device(dev)) {
906 usb_dev = to_usb_device(dev);
907 } else if (is_usb_interface(dev)) {
908 struct usb_interface *intf = to_usb_interface(dev);
909
910 usb_dev = interface_to_usbdev(intf);
911 } else {
912 return 0;
913 }
914
915 if (usb_dev->devnum < 0) {
916
917 pr_debug("usb %s: already deleted?\n", dev_name(dev));
918 return -ENODEV;
919 }
920 if (!usb_dev->bus) {
921 pr_debug("usb %s: bus removed?\n", dev_name(dev));
922 return -ENODEV;
923 }
924
925
926 if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
927 le16_to_cpu(usb_dev->descriptor.idVendor),
928 le16_to_cpu(usb_dev->descriptor.idProduct),
929 le16_to_cpu(usb_dev->descriptor.bcdDevice)))
930 return -ENOMEM;
931
932
933 if (add_uevent_var(env, "TYPE=%d/%d/%d",
934 usb_dev->descriptor.bDeviceClass,
935 usb_dev->descriptor.bDeviceSubClass,
936 usb_dev->descriptor.bDeviceProtocol))
937 return -ENOMEM;
938
939 return 0;
940}
941
942static int __usb_bus_reprobe_drivers(struct device *dev, void *data)
943{
944 struct usb_device_driver *new_udriver = data;
945 struct usb_device *udev;
946 int ret;
947
948
949 if (dev->driver != &usb_generic_driver.drvwrap.driver)
950 return 0;
951
952 udev = to_usb_device(dev);
953 if (!usb_driver_applicable(udev, new_udriver))
954 return 0;
955
956 ret = device_reprobe(dev);
957 if (ret && ret != -EPROBE_DEFER)
958 dev_err(dev, "Failed to reprobe device (error %d)\n", ret);
959
960 return 0;
961}
962
963
964
965
966
967
968
969
970
971
972
973
974int usb_register_device_driver(struct usb_device_driver *new_udriver,
975 struct module *owner)
976{
977 int retval = 0;
978
979 if (usb_disabled())
980 return -ENODEV;
981
982 new_udriver->drvwrap.for_devices = 1;
983 new_udriver->drvwrap.driver.name = new_udriver->name;
984 new_udriver->drvwrap.driver.bus = &usb_bus_type;
985 new_udriver->drvwrap.driver.probe = usb_probe_device;
986 new_udriver->drvwrap.driver.remove = usb_unbind_device;
987 new_udriver->drvwrap.driver.owner = owner;
988 new_udriver->drvwrap.driver.dev_groups = new_udriver->dev_groups;
989
990 retval = driver_register(&new_udriver->drvwrap.driver);
991
992 if (!retval) {
993 pr_info("%s: registered new device driver %s\n",
994 usbcore_name, new_udriver->name);
995
996
997
998
999 bus_for_each_dev(&usb_bus_type, NULL, new_udriver,
1000 __usb_bus_reprobe_drivers);
1001 } else {
1002 pr_err("%s: error %d registering device driver %s\n",
1003 usbcore_name, retval, new_udriver->name);
1004 }
1005
1006 return retval;
1007}
1008EXPORT_SYMBOL_GPL(usb_register_device_driver);
1009
1010
1011
1012
1013
1014
1015
1016
1017void usb_deregister_device_driver(struct usb_device_driver *udriver)
1018{
1019 pr_info("%s: deregistering device driver %s\n",
1020 usbcore_name, udriver->name);
1021
1022 driver_unregister(&udriver->drvwrap.driver);
1023}
1024EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
1043 const char *mod_name)
1044{
1045 int retval = 0;
1046
1047 if (usb_disabled())
1048 return -ENODEV;
1049
1050 new_driver->drvwrap.for_devices = 0;
1051 new_driver->drvwrap.driver.name = new_driver->name;
1052 new_driver->drvwrap.driver.bus = &usb_bus_type;
1053 new_driver->drvwrap.driver.probe = usb_probe_interface;
1054 new_driver->drvwrap.driver.remove = usb_unbind_interface;
1055 new_driver->drvwrap.driver.owner = owner;
1056 new_driver->drvwrap.driver.mod_name = mod_name;
1057 new_driver->drvwrap.driver.dev_groups = new_driver->dev_groups;
1058 spin_lock_init(&new_driver->dynids.lock);
1059 INIT_LIST_HEAD(&new_driver->dynids.list);
1060
1061 retval = driver_register(&new_driver->drvwrap.driver);
1062 if (retval)
1063 goto out;
1064
1065 retval = usb_create_newid_files(new_driver);
1066 if (retval)
1067 goto out_newid;
1068
1069 pr_info("%s: registered new interface driver %s\n",
1070 usbcore_name, new_driver->name);
1071
1072out:
1073 return retval;
1074
1075out_newid:
1076 driver_unregister(&new_driver->drvwrap.driver);
1077
1078 pr_err("%s: error %d registering interface driver %s\n",
1079 usbcore_name, retval, new_driver->name);
1080 goto out;
1081}
1082EXPORT_SYMBOL_GPL(usb_register_driver);
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095void usb_deregister(struct usb_driver *driver)
1096{
1097 pr_info("%s: deregistering interface driver %s\n",
1098 usbcore_name, driver->name);
1099
1100 usb_remove_newid_files(driver);
1101 driver_unregister(&driver->drvwrap.driver);
1102 usb_free_dynids(driver);
1103}
1104EXPORT_SYMBOL_GPL(usb_deregister);
1105
1106
1107
1108
1109
1110
1111
1112void usb_forced_unbind_intf(struct usb_interface *intf)
1113{
1114 struct usb_driver *driver = to_usb_driver(intf->dev.driver);
1115
1116 dev_dbg(&intf->dev, "forced unbind\n");
1117 usb_driver_release_interface(driver, intf);
1118
1119
1120 intf->needs_binding = 1;
1121}
1122
1123
1124
1125
1126
1127
1128
1129static void unbind_marked_interfaces(struct usb_device *udev)
1130{
1131 struct usb_host_config *config;
1132 int i;
1133 struct usb_interface *intf;
1134
1135 config = udev->actconfig;
1136 if (config) {
1137 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
1138 intf = config->interface[i];
1139 if (intf->dev.driver && intf->needs_binding)
1140 usb_forced_unbind_intf(intf);
1141 }
1142 }
1143}
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153static void usb_rebind_intf(struct usb_interface *intf)
1154{
1155 int rc;
1156
1157
1158 if (intf->dev.driver)
1159 usb_forced_unbind_intf(intf);
1160
1161
1162 if (!intf->dev.power.is_prepared) {
1163 intf->needs_binding = 0;
1164 rc = device_attach(&intf->dev);
1165 if (rc < 0 && rc != -EPROBE_DEFER)
1166 dev_warn(&intf->dev, "rebind failed: %d\n", rc);
1167 }
1168}
1169
1170
1171
1172
1173
1174
1175
1176static void rebind_marked_interfaces(struct usb_device *udev)
1177{
1178 struct usb_host_config *config;
1179 int i;
1180 struct usb_interface *intf;
1181
1182 config = udev->actconfig;
1183 if (config) {
1184 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
1185 intf = config->interface[i];
1186 if (intf->needs_binding)
1187 usb_rebind_intf(intf);
1188 }
1189 }
1190}
1191
1192
1193
1194
1195
1196
1197
1198
1199void usb_unbind_and_rebind_marked_interfaces(struct usb_device *udev)
1200{
1201 unbind_marked_interfaces(udev);
1202 rebind_marked_interfaces(udev);
1203}
1204
1205#ifdef CONFIG_PM
1206
1207
1208
1209
1210
1211
1212
1213static void unbind_no_pm_drivers_interfaces(struct usb_device *udev)
1214{
1215 struct usb_host_config *config;
1216 int i;
1217 struct usb_interface *intf;
1218 struct usb_driver *drv;
1219
1220 config = udev->actconfig;
1221 if (config) {
1222 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
1223 intf = config->interface[i];
1224
1225 if (intf->dev.driver) {
1226 drv = to_usb_driver(intf->dev.driver);
1227 if (!drv->suspend || !drv->resume)
1228 usb_forced_unbind_intf(intf);
1229 }
1230 }
1231 }
1232}
1233
1234static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
1235{
1236 struct usb_device_driver *udriver;
1237 int status = 0;
1238
1239 if (udev->state == USB_STATE_NOTATTACHED ||
1240 udev->state == USB_STATE_SUSPENDED)
1241 goto done;
1242
1243
1244 if (udev->dev.driver)
1245 udriver = to_usb_device_driver(udev->dev.driver);
1246 else {
1247 udev->do_remote_wakeup = 0;
1248 udriver = &usb_generic_driver;
1249 }
1250 if (udriver->suspend)
1251 status = udriver->suspend(udev, msg);
1252 if (status == 0 && udriver->generic_subclass)
1253 status = usb_generic_driver_suspend(udev, msg);
1254
1255 done:
1256 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1257 return status;
1258}
1259
1260static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
1261{
1262 struct usb_device_driver *udriver;
1263 int status = 0;
1264
1265 if (udev->state == USB_STATE_NOTATTACHED)
1266 goto done;
1267
1268
1269 if (udev->dev.driver == NULL) {
1270 status = -ENOTCONN;
1271 goto done;
1272 }
1273
1274
1275
1276
1277 if (!PMSG_IS_AUTO(msg) && udev->parent && udev->bus->hs_companion)
1278 device_pm_wait_for_dev(&udev->dev,
1279 &udev->bus->hs_companion->root_hub->dev);
1280
1281 if (udev->quirks & USB_QUIRK_RESET_RESUME)
1282 udev->reset_resume = 1;
1283
1284 udriver = to_usb_device_driver(udev->dev.driver);
1285 if (udriver->generic_subclass)
1286 status = usb_generic_driver_resume(udev, msg);
1287 if (status == 0 && udriver->resume)
1288 status = udriver->resume(udev, msg);
1289
1290 done:
1291 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1292 return status;
1293}
1294
1295static int usb_suspend_interface(struct usb_device *udev,
1296 struct usb_interface *intf, pm_message_t msg)
1297{
1298 struct usb_driver *driver;
1299 int status = 0;
1300
1301 if (udev->state == USB_STATE_NOTATTACHED ||
1302 intf->condition == USB_INTERFACE_UNBOUND)
1303 goto done;
1304 driver = to_usb_driver(intf->dev.driver);
1305
1306
1307 status = driver->suspend(intf, msg);
1308 if (status && !PMSG_IS_AUTO(msg))
1309 dev_err(&intf->dev, "suspend error %d\n", status);
1310
1311 done:
1312 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1313 return status;
1314}
1315
1316static int usb_resume_interface(struct usb_device *udev,
1317 struct usb_interface *intf, pm_message_t msg, int reset_resume)
1318{
1319 struct usb_driver *driver;
1320 int status = 0;
1321
1322 if (udev->state == USB_STATE_NOTATTACHED)
1323 goto done;
1324
1325
1326 if (intf->condition == USB_INTERFACE_UNBINDING)
1327 goto done;
1328
1329
1330 if (intf->condition == USB_INTERFACE_UNBOUND) {
1331
1332
1333 if (intf->needs_altsetting0 && !intf->dev.power.is_prepared) {
1334 usb_set_interface(udev, intf->altsetting[0].
1335 desc.bInterfaceNumber, 0);
1336 intf->needs_altsetting0 = 0;
1337 }
1338 goto done;
1339 }
1340
1341
1342 if (intf->needs_binding)
1343 goto done;
1344 driver = to_usb_driver(intf->dev.driver);
1345
1346 if (reset_resume) {
1347 if (driver->reset_resume) {
1348 status = driver->reset_resume(intf);
1349 if (status)
1350 dev_err(&intf->dev, "%s error %d\n",
1351 "reset_resume", status);
1352 } else {
1353 intf->needs_binding = 1;
1354 dev_dbg(&intf->dev, "no reset_resume for driver %s?\n",
1355 driver->name);
1356 }
1357 } else {
1358 status = driver->resume(intf);
1359 if (status)
1360 dev_err(&intf->dev, "resume error %d\n", status);
1361 }
1362
1363done:
1364 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1365
1366
1367 return status;
1368}
1369
1370
1371
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
1397static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1398{
1399 int status = 0;
1400 int i = 0, n = 0;
1401 struct usb_interface *intf;
1402
1403 if (udev->state == USB_STATE_NOTATTACHED ||
1404 udev->state == USB_STATE_SUSPENDED)
1405 goto done;
1406
1407
1408 if (udev->actconfig) {
1409 n = udev->actconfig->desc.bNumInterfaces;
1410 for (i = n - 1; i >= 0; --i) {
1411 intf = udev->actconfig->interface[i];
1412 status = usb_suspend_interface(udev, intf, msg);
1413
1414
1415 if (!PMSG_IS_AUTO(msg))
1416 status = 0;
1417 if (status != 0)
1418 break;
1419 }
1420 }
1421 if (status == 0) {
1422 status = usb_suspend_device(udev, msg);
1423
1424
1425
1426
1427
1428
1429
1430 if (udev->parent && !PMSG_IS_AUTO(msg))
1431 status = 0;
1432
1433
1434
1435
1436
1437 if (status && status != -EBUSY) {
1438 int err;
1439 u16 devstat;
1440
1441 err = usb_get_std_status(udev, USB_RECIP_DEVICE, 0,
1442 &devstat);
1443 if (err) {
1444 dev_err(&udev->dev,
1445 "Failed to suspend device, error %d\n",
1446 status);
1447 goto done;
1448 }
1449 }
1450 }
1451
1452
1453 if (status != 0) {
1454 if (udev->actconfig) {
1455 msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
1456 while (++i < n) {
1457 intf = udev->actconfig->interface[i];
1458 usb_resume_interface(udev, intf, msg, 0);
1459 }
1460 }
1461
1462
1463
1464
1465 } else {
1466 udev->can_submit = 0;
1467 for (i = 0; i < 16; ++i) {
1468 usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1469 usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1470 }
1471 }
1472
1473 done:
1474 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1475 return status;
1476}
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
1499{
1500 int status = 0;
1501 int i;
1502 struct usb_interface *intf;
1503
1504 if (udev->state == USB_STATE_NOTATTACHED) {
1505 status = -ENODEV;
1506 goto done;
1507 }
1508 udev->can_submit = 1;
1509
1510
1511 if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume)
1512 status = usb_resume_device(udev, msg);
1513
1514
1515 if (status == 0 && udev->actconfig) {
1516 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1517 intf = udev->actconfig->interface[i];
1518 usb_resume_interface(udev, intf, msg,
1519 udev->reset_resume);
1520 }
1521 }
1522 usb_mark_last_busy(udev);
1523
1524 done:
1525 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1526 if (!status)
1527 udev->reset_resume = 0;
1528 return status;
1529}
1530
1531static void choose_wakeup(struct usb_device *udev, pm_message_t msg)
1532{
1533 int w;
1534
1535
1536
1537
1538
1539 if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) {
1540 if (udev->state != USB_STATE_SUSPENDED)
1541 udev->do_remote_wakeup = 0;
1542 return;
1543 }
1544
1545
1546
1547
1548 w = device_may_wakeup(&udev->dev);
1549
1550
1551
1552
1553 if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup)
1554 pm_runtime_resume(&udev->dev);
1555 udev->do_remote_wakeup = w;
1556}
1557
1558
1559int usb_suspend(struct device *dev, pm_message_t msg)
1560{
1561 struct usb_device *udev = to_usb_device(dev);
1562 int r;
1563
1564 unbind_no_pm_drivers_interfaces(udev);
1565
1566
1567
1568
1569
1570 choose_wakeup(udev, msg);
1571 r = usb_suspend_both(udev, msg);
1572 if (r)
1573 return r;
1574
1575 if (udev->quirks & USB_QUIRK_DISCONNECT_SUSPEND)
1576 usb_port_disable(udev);
1577
1578 return 0;
1579}
1580
1581
1582int usb_resume_complete(struct device *dev)
1583{
1584 struct usb_device *udev = to_usb_device(dev);
1585
1586
1587
1588
1589 if (udev->state != USB_STATE_NOTATTACHED)
1590 rebind_marked_interfaces(udev);
1591 return 0;
1592}
1593
1594
1595int usb_resume(struct device *dev, pm_message_t msg)
1596{
1597 struct usb_device *udev = to_usb_device(dev);
1598 int status;
1599
1600
1601
1602
1603
1604
1605
1606
1607 status = usb_resume_both(udev, msg);
1608 if (status == 0) {
1609 pm_runtime_disable(dev);
1610 pm_runtime_set_active(dev);
1611 pm_runtime_enable(dev);
1612 unbind_marked_interfaces(udev);
1613 }
1614
1615
1616
1617
1618 if (status == -ENODEV || status == -ESHUTDOWN)
1619 status = 0;
1620 return status;
1621}
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633void usb_enable_autosuspend(struct usb_device *udev)
1634{
1635 pm_runtime_allow(&udev->dev);
1636}
1637EXPORT_SYMBOL_GPL(usb_enable_autosuspend);
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648void usb_disable_autosuspend(struct usb_device *udev)
1649{
1650 pm_runtime_forbid(&udev->dev);
1651}
1652EXPORT_SYMBOL_GPL(usb_disable_autosuspend);
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670void usb_autosuspend_device(struct usb_device *udev)
1671{
1672 int status;
1673
1674 usb_mark_last_busy(udev);
1675 status = pm_runtime_put_sync_autosuspend(&udev->dev);
1676 dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1677 __func__, atomic_read(&udev->dev.power.usage_count),
1678 status);
1679}
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701int usb_autoresume_device(struct usb_device *udev)
1702{
1703 int status;
1704
1705 status = pm_runtime_get_sync(&udev->dev);
1706 if (status < 0)
1707 pm_runtime_put_sync(&udev->dev);
1708 dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1709 __func__, atomic_read(&udev->dev.power.usage_count),
1710 status);
1711 if (status > 0)
1712 status = 0;
1713 return status;
1714}
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731void usb_autopm_put_interface(struct usb_interface *intf)
1732{
1733 struct usb_device *udev = interface_to_usbdev(intf);
1734 int status;
1735
1736 usb_mark_last_busy(udev);
1737 status = pm_runtime_put_sync(&intf->dev);
1738 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1739 __func__, atomic_read(&intf->dev.power.usage_count),
1740 status);
1741}
1742EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759void usb_autopm_put_interface_async(struct usb_interface *intf)
1760{
1761 struct usb_device *udev = interface_to_usbdev(intf);
1762 int status;
1763
1764 usb_mark_last_busy(udev);
1765 status = pm_runtime_put(&intf->dev);
1766 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1767 __func__, atomic_read(&intf->dev.power.usage_count),
1768 status);
1769}
1770EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
1782{
1783 struct usb_device *udev = interface_to_usbdev(intf);
1784
1785 usb_mark_last_busy(udev);
1786 pm_runtime_put_noidle(&intf->dev);
1787}
1788EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend);
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809int usb_autopm_get_interface(struct usb_interface *intf)
1810{
1811 int status;
1812
1813 status = pm_runtime_get_sync(&intf->dev);
1814 if (status < 0)
1815 pm_runtime_put_sync(&intf->dev);
1816 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1817 __func__, atomic_read(&intf->dev.power.usage_count),
1818 status);
1819 if (status > 0)
1820 status = 0;
1821 return status;
1822}
1823EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842int usb_autopm_get_interface_async(struct usb_interface *intf)
1843{
1844 int status;
1845
1846 status = pm_runtime_get(&intf->dev);
1847 if (status < 0 && status != -EINPROGRESS)
1848 pm_runtime_put_noidle(&intf->dev);
1849 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1850 __func__, atomic_read(&intf->dev.power.usage_count),
1851 status);
1852 if (status > 0 || status == -EINPROGRESS)
1853 status = 0;
1854 return status;
1855}
1856EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
1868{
1869 struct usb_device *udev = interface_to_usbdev(intf);
1870
1871 usb_mark_last_busy(udev);
1872 pm_runtime_get_noresume(&intf->dev);
1873}
1874EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume);
1875
1876
1877static int autosuspend_check(struct usb_device *udev)
1878{
1879 int w, i;
1880 struct usb_interface *intf;
1881
1882 if (udev->state == USB_STATE_NOTATTACHED)
1883 return -ENODEV;
1884
1885
1886
1887
1888 w = 0;
1889 if (udev->actconfig) {
1890 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1891 intf = udev->actconfig->interface[i];
1892
1893
1894
1895
1896
1897
1898 if (intf->dev.power.disable_depth)
1899 continue;
1900 if (atomic_read(&intf->dev.power.usage_count) > 0)
1901 return -EBUSY;
1902 w |= intf->needs_remote_wakeup;
1903
1904
1905
1906
1907
1908 if (udev->quirks & USB_QUIRK_RESET_RESUME) {
1909 struct usb_driver *driver;
1910
1911 driver = to_usb_driver(intf->dev.driver);
1912 if (!driver->reset_resume ||
1913 intf->needs_remote_wakeup)
1914 return -EOPNOTSUPP;
1915 }
1916 }
1917 }
1918 if (w && !device_can_wakeup(&udev->dev)) {
1919 dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
1920 return -EOPNOTSUPP;
1921 }
1922
1923
1924
1925
1926
1927
1928 if (w && udev->parent == udev->bus->root_hub &&
1929 bus_to_hcd(udev->bus)->cant_recv_wakeups) {
1930 dev_dbg(&udev->dev, "HCD doesn't handle wakeup requests\n");
1931 return -EOPNOTSUPP;
1932 }
1933
1934 udev->do_remote_wakeup = w;
1935 return 0;
1936}
1937
1938int usb_runtime_suspend(struct device *dev)
1939{
1940 struct usb_device *udev = to_usb_device(dev);
1941 int status;
1942
1943
1944
1945
1946
1947 if (autosuspend_check(udev) != 0)
1948 return -EAGAIN;
1949
1950 status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
1951
1952
1953 if (status == -EAGAIN || status == -EBUSY)
1954 usb_mark_last_busy(udev);
1955
1956
1957
1958
1959
1960
1961
1962 if (status != 0 && udev->parent)
1963 return -EBUSY;
1964 return status;
1965}
1966
1967int usb_runtime_resume(struct device *dev)
1968{
1969 struct usb_device *udev = to_usb_device(dev);
1970 int status;
1971
1972
1973
1974
1975 status = usb_resume_both(udev, PMSG_AUTO_RESUME);
1976 return status;
1977}
1978
1979int usb_runtime_idle(struct device *dev)
1980{
1981 struct usb_device *udev = to_usb_device(dev);
1982
1983
1984
1985
1986 if (autosuspend_check(udev) == 0)
1987 pm_runtime_autosuspend(dev);
1988
1989 return -EBUSY;
1990}
1991
1992static int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
1993{
1994 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
1995 int ret = -EPERM;
1996
1997 if (hcd->driver->set_usb2_hw_lpm) {
1998 ret = hcd->driver->set_usb2_hw_lpm(hcd, udev, enable);
1999 if (!ret)
2000 udev->usb2_hw_lpm_enabled = enable;
2001 }
2002
2003 return ret;
2004}
2005
2006int usb_enable_usb2_hardware_lpm(struct usb_device *udev)
2007{
2008 if (!udev->usb2_hw_lpm_capable ||
2009 !udev->usb2_hw_lpm_allowed ||
2010 udev->usb2_hw_lpm_enabled)
2011 return 0;
2012
2013 return usb_set_usb2_hardware_lpm(udev, 1);
2014}
2015
2016int usb_disable_usb2_hardware_lpm(struct usb_device *udev)
2017{
2018 if (!udev->usb2_hw_lpm_enabled)
2019 return 0;
2020
2021 return usb_set_usb2_hardware_lpm(udev, 0);
2022}
2023
2024#endif
2025
2026struct bus_type usb_bus_type = {
2027 .name = "usb",
2028 .match = usb_device_match,
2029 .uevent = usb_uevent,
2030 .need_parent_lock = true,
2031};
2032