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