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