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 = to_usb_device(dev);
158 int error = -ENODEV;
159
160 dev_dbg(dev, "%s\n", __func__);
161
162
163
164
165
166
167 udev->pm_usage_cnt = !(udriver->supports_autosuspend);
168
169 error = udriver->probe(udev);
170 return error;
171}
172
173
174static int usb_unbind_device(struct device *dev)
175{
176 struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
177
178 udriver->disconnect(to_usb_device(dev));
179 return 0;
180}
181
182
183
184
185
186
187
188
189
190
191static void usb_cancel_queued_reset(struct usb_interface *iface)
192{
193 if (iface->reset_running == 0)
194 cancel_work_sync(&iface->reset_ws);
195}
196
197
198static int usb_probe_interface(struct device *dev)
199{
200 struct usb_driver *driver = to_usb_driver(dev->driver);
201 struct usb_interface *intf = to_usb_interface(dev);
202 struct usb_device *udev = interface_to_usbdev(intf);
203 const struct usb_device_id *id;
204 int error = -ENODEV;
205
206 dev_dbg(dev, "%s\n", __func__);
207
208 intf->needs_binding = 0;
209
210 if (usb_device_is_owned(udev))
211 return -ENODEV;
212
213 if (udev->authorized == 0) {
214 dev_err(&intf->dev, "Device is not authorized for usage\n");
215 return -ENODEV;
216 }
217
218 id = usb_match_id(intf, driver->id_table);
219 if (!id)
220 id = usb_match_dynamic_id(intf, driver);
221 if (id) {
222 dev_dbg(dev, "%s - got id\n", __func__);
223
224 error = usb_autoresume_device(udev);
225 if (error)
226 return error;
227
228
229
230
231
232 mark_active(intf);
233 intf->condition = USB_INTERFACE_BINDING;
234
235
236
237
238 atomic_set(&intf->pm_usage_cnt, !driver->supports_autosuspend);
239
240
241 if (intf->needs_altsetting0) {
242 error = usb_set_interface(udev, intf->altsetting[0].
243 desc.bInterfaceNumber, 0);
244 if (error < 0)
245 goto err;
246
247 intf->needs_altsetting0 = 0;
248 }
249
250 error = driver->probe(intf, id);
251 if (error)
252 goto err;
253
254 intf->condition = USB_INTERFACE_BOUND;
255 usb_autosuspend_device(udev);
256 }
257
258 return error;
259
260err:
261 mark_quiesced(intf);
262 intf->needs_remote_wakeup = 0;
263 intf->condition = USB_INTERFACE_UNBOUND;
264 usb_cancel_queued_reset(intf);
265 usb_autosuspend_device(udev);
266 return error;
267}
268
269
270static int usb_unbind_interface(struct device *dev)
271{
272 struct usb_driver *driver = to_usb_driver(dev->driver);
273 struct usb_interface *intf = to_usb_interface(dev);
274 struct usb_device *udev;
275 int error, r;
276
277 intf->condition = USB_INTERFACE_UNBINDING;
278
279
280 udev = interface_to_usbdev(intf);
281 error = usb_autoresume_device(udev);
282
283
284
285
286 if (!driver->soft_unbind)
287 usb_disable_interface(udev, intf, false);
288
289 driver->disconnect(intf);
290 usb_cancel_queued_reset(intf);
291
292
293
294
295
296
297
298 if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
299
300
301
302 usb_enable_interface(udev, intf, false);
303 } else if (!error && intf->dev.power.status == DPM_ON) {
304 r = usb_set_interface(udev, intf->altsetting[0].
305 desc.bInterfaceNumber, 0);
306 if (r < 0)
307 intf->needs_altsetting0 = 1;
308 } else {
309 intf->needs_altsetting0 = 1;
310 }
311 usb_set_intfdata(intf, NULL);
312
313 intf->condition = USB_INTERFACE_UNBOUND;
314 mark_quiesced(intf);
315 intf->needs_remote_wakeup = 0;
316
317 if (!error)
318 usb_autosuspend_device(udev);
319
320 return 0;
321}
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343int usb_driver_claim_interface(struct usb_driver *driver,
344 struct usb_interface *iface, void *priv)
345{
346 struct device *dev = &iface->dev;
347 struct usb_device *udev = interface_to_usbdev(iface);
348 int retval = 0;
349
350 if (dev->driver)
351 return -EBUSY;
352
353 dev->driver = &driver->drvwrap.driver;
354 usb_set_intfdata(iface, priv);
355 iface->needs_binding = 0;
356
357 usb_pm_lock(udev);
358 iface->condition = USB_INTERFACE_BOUND;
359 mark_active(iface);
360 atomic_set(&iface->pm_usage_cnt, !driver->supports_autosuspend);
361 usb_pm_unlock(udev);
362
363
364
365
366 if (device_is_registered(dev))
367 retval = device_bind_driver(dev);
368
369 return retval;
370}
371EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387void usb_driver_release_interface(struct usb_driver *driver,
388 struct usb_interface *iface)
389{
390 struct device *dev = &iface->dev;
391
392
393 if (!dev->driver || dev->driver != &driver->drvwrap.driver)
394 return;
395
396
397 if (iface->condition != USB_INTERFACE_BOUND)
398 return;
399 iface->condition = USB_INTERFACE_UNBINDING;
400
401
402
403
404 if (device_is_registered(dev)) {
405 device_release_driver(dev);
406 } else {
407 down(&dev->sem);
408 usb_unbind_interface(dev);
409 dev->driver = NULL;
410 up(&dev->sem);
411 }
412}
413EXPORT_SYMBOL_GPL(usb_driver_release_interface);
414
415
416int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
417{
418 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
419 id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
420 return 0;
421
422 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
423 id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
424 return 0;
425
426
427
428 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
429 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
430 return 0;
431
432 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
433 (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
434 return 0;
435
436 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
437 (id->bDeviceClass != dev->descriptor.bDeviceClass))
438 return 0;
439
440 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
441 (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
442 return 0;
443
444 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
445 (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
446 return 0;
447
448 return 1;
449}
450
451
452int usb_match_one_id(struct usb_interface *interface,
453 const struct usb_device_id *id)
454{
455 struct usb_host_interface *intf;
456 struct usb_device *dev;
457
458
459 if (id == NULL)
460 return 0;
461
462 intf = interface->cur_altsetting;
463 dev = interface_to_usbdev(interface);
464
465 if (!usb_match_device(dev, id))
466 return 0;
467
468
469
470
471 if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
472 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
473 (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
474 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
475 USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
476 return 0;
477
478 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
479 (id->bInterfaceClass != intf->desc.bInterfaceClass))
480 return 0;
481
482 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
483 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
484 return 0;
485
486 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
487 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
488 return 0;
489
490 return 1;
491}
492EXPORT_SYMBOL_GPL(usb_match_one_id);
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
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565const struct usb_device_id *usb_match_id(struct usb_interface *interface,
566 const struct usb_device_id *id)
567{
568
569 if (id == NULL)
570 return NULL;
571
572
573
574
575
576
577 for (; id->idVendor || id->idProduct || id->bDeviceClass ||
578 id->bInterfaceClass || id->driver_info; id++) {
579 if (usb_match_one_id(interface, id))
580 return id;
581 }
582
583 return NULL;
584}
585EXPORT_SYMBOL_GPL(usb_match_id);
586
587static int usb_device_match(struct device *dev, struct device_driver *drv)
588{
589
590 if (is_usb_device(dev)) {
591
592
593 if (!is_usb_device_driver(drv))
594 return 0;
595
596
597 return 1;
598
599 } else if (is_usb_interface(dev)) {
600 struct usb_interface *intf;
601 struct usb_driver *usb_drv;
602 const struct usb_device_id *id;
603
604
605 if (is_usb_device_driver(drv))
606 return 0;
607
608 intf = to_usb_interface(dev);
609 usb_drv = to_usb_driver(drv);
610
611 id = usb_match_id(intf, usb_drv->id_table);
612 if (id)
613 return 1;
614
615 id = usb_match_dynamic_id(intf, usb_drv);
616 if (id)
617 return 1;
618 }
619
620 return 0;
621}
622
623#ifdef CONFIG_HOTPLUG
624static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
625{
626 struct usb_device *usb_dev;
627
628
629 pr_debug("usb %s: uevent\n", dev_name(dev));
630
631 if (is_usb_device(dev)) {
632 usb_dev = to_usb_device(dev);
633 } else if (is_usb_interface(dev)) {
634 struct usb_interface *intf = to_usb_interface(dev);
635
636 usb_dev = interface_to_usbdev(intf);
637 } else {
638 return 0;
639 }
640
641 if (usb_dev->devnum < 0) {
642 pr_debug("usb %s: already deleted?\n", dev_name(dev));
643 return -ENODEV;
644 }
645 if (!usb_dev->bus) {
646 pr_debug("usb %s: bus removed?\n", dev_name(dev));
647 return -ENODEV;
648 }
649
650#ifdef CONFIG_USB_DEVICEFS
651
652
653
654
655 if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
656 usb_dev->bus->busnum, usb_dev->devnum))
657 return -ENOMEM;
658#endif
659
660
661 if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
662 le16_to_cpu(usb_dev->descriptor.idVendor),
663 le16_to_cpu(usb_dev->descriptor.idProduct),
664 le16_to_cpu(usb_dev->descriptor.bcdDevice)))
665 return -ENOMEM;
666
667
668 if (add_uevent_var(env, "TYPE=%d/%d/%d",
669 usb_dev->descriptor.bDeviceClass,
670 usb_dev->descriptor.bDeviceSubClass,
671 usb_dev->descriptor.bDeviceProtocol))
672 return -ENOMEM;
673
674 return 0;
675}
676
677#else
678
679static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
680{
681 return -ENODEV;
682}
683#endif
684
685
686
687
688
689
690
691
692
693
694
695int usb_register_device_driver(struct usb_device_driver *new_udriver,
696 struct module *owner)
697{
698 int retval = 0;
699
700 if (usb_disabled())
701 return -ENODEV;
702
703 new_udriver->drvwrap.for_devices = 1;
704 new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
705 new_udriver->drvwrap.driver.bus = &usb_bus_type;
706 new_udriver->drvwrap.driver.probe = usb_probe_device;
707 new_udriver->drvwrap.driver.remove = usb_unbind_device;
708 new_udriver->drvwrap.driver.owner = owner;
709
710 retval = driver_register(&new_udriver->drvwrap.driver);
711
712 if (!retval) {
713 pr_info("%s: registered new device driver %s\n",
714 usbcore_name, new_udriver->name);
715 usbfs_update_special();
716 } else {
717 printk(KERN_ERR "%s: error %d registering device "
718 " driver %s\n",
719 usbcore_name, retval, new_udriver->name);
720 }
721
722 return retval;
723}
724EXPORT_SYMBOL_GPL(usb_register_device_driver);
725
726
727
728
729
730
731
732
733void usb_deregister_device_driver(struct usb_device_driver *udriver)
734{
735 pr_info("%s: deregistering device driver %s\n",
736 usbcore_name, udriver->name);
737
738 driver_unregister(&udriver->drvwrap.driver);
739 usbfs_update_special();
740}
741EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
759 const char *mod_name)
760{
761 int retval = 0;
762
763 if (usb_disabled())
764 return -ENODEV;
765
766 new_driver->drvwrap.for_devices = 0;
767 new_driver->drvwrap.driver.name = (char *) new_driver->name;
768 new_driver->drvwrap.driver.bus = &usb_bus_type;
769 new_driver->drvwrap.driver.probe = usb_probe_interface;
770 new_driver->drvwrap.driver.remove = usb_unbind_interface;
771 new_driver->drvwrap.driver.owner = owner;
772 new_driver->drvwrap.driver.mod_name = mod_name;
773 spin_lock_init(&new_driver->dynids.lock);
774 INIT_LIST_HEAD(&new_driver->dynids.list);
775
776 retval = driver_register(&new_driver->drvwrap.driver);
777
778 if (!retval) {
779 pr_info("%s: registered new interface driver %s\n",
780 usbcore_name, new_driver->name);
781 usbfs_update_special();
782 usb_create_newid_file(new_driver);
783 } else {
784 printk(KERN_ERR "%s: error %d registering interface "
785 " driver %s\n",
786 usbcore_name, retval, new_driver->name);
787 }
788
789 return retval;
790}
791EXPORT_SYMBOL_GPL(usb_register_driver);
792
793
794
795
796
797
798
799
800
801
802
803
804void usb_deregister(struct usb_driver *driver)
805{
806 pr_info("%s: deregistering interface driver %s\n",
807 usbcore_name, driver->name);
808
809 usb_remove_newid_file(driver);
810 usb_free_dynids(driver);
811 driver_unregister(&driver->drvwrap.driver);
812
813 usbfs_update_special();
814}
815EXPORT_SYMBOL_GPL(usb_deregister);
816
817
818
819
820
821
822
823
824void usb_forced_unbind_intf(struct usb_interface *intf)
825{
826 struct usb_driver *driver = to_usb_driver(intf->dev.driver);
827
828 dev_dbg(&intf->dev, "forced unbind\n");
829 usb_driver_release_interface(driver, intf);
830
831
832 intf->needs_binding = 1;
833}
834
835
836
837
838
839
840
841
842
843
844void usb_rebind_intf(struct usb_interface *intf)
845{
846 int rc;
847
848
849 if (intf->dev.driver) {
850 struct usb_driver *driver =
851 to_usb_driver(intf->dev.driver);
852
853 dev_dbg(&intf->dev, "forced unbind\n");
854 usb_driver_release_interface(driver, intf);
855 }
856
857
858 if (intf->dev.power.status == DPM_ON) {
859 intf->needs_binding = 0;
860 rc = device_attach(&intf->dev);
861 if (rc < 0)
862 dev_warn(&intf->dev, "rebind failed: %d\n", rc);
863 }
864}
865
866#ifdef CONFIG_PM
867
868#define DO_UNBIND 0
869#define DO_REBIND 1
870
871
872
873
874
875
876static void do_unbind_rebind(struct usb_device *udev, int action)
877{
878 struct usb_host_config *config;
879 int i;
880 struct usb_interface *intf;
881 struct usb_driver *drv;
882
883 config = udev->actconfig;
884 if (config) {
885 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
886 intf = config->interface[i];
887 switch (action) {
888 case DO_UNBIND:
889 if (intf->dev.driver) {
890 drv = to_usb_driver(intf->dev.driver);
891 if (!drv->suspend || !drv->resume)
892 usb_forced_unbind_intf(intf);
893 }
894 break;
895 case DO_REBIND:
896 if (intf->needs_binding)
897 usb_rebind_intf(intf);
898 break;
899 }
900 }
901 }
902}
903
904
905static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
906{
907 struct usb_device_driver *udriver;
908 int status = 0;
909
910 if (udev->state == USB_STATE_NOTATTACHED ||
911 udev->state == USB_STATE_SUSPENDED)
912 goto done;
913
914
915 if (udev->dev.driver)
916 udriver = to_usb_device_driver(udev->dev.driver);
917 else {
918 udev->do_remote_wakeup = 0;
919 udriver = &usb_generic_driver;
920 }
921 status = udriver->suspend(udev, msg);
922
923 done:
924 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
925 return status;
926}
927
928
929static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
930{
931 struct usb_device_driver *udriver;
932 int status = 0;
933
934 if (udev->state == USB_STATE_NOTATTACHED)
935 goto done;
936
937
938 if (udev->dev.driver == NULL) {
939 status = -ENOTCONN;
940 goto done;
941 }
942
943 if (udev->quirks & USB_QUIRK_RESET_RESUME)
944 udev->reset_resume = 1;
945
946 udriver = to_usb_device_driver(udev->dev.driver);
947 status = udriver->resume(udev, msg);
948
949 done:
950 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
951 if (status == 0)
952 udev->autoresume_disabled = 0;
953 return status;
954}
955
956
957static int usb_suspend_interface(struct usb_device *udev,
958 struct usb_interface *intf, pm_message_t msg)
959{
960 struct usb_driver *driver;
961 int status = 0;
962
963
964 if (udev->state == USB_STATE_NOTATTACHED || !is_active(intf))
965 goto done;
966
967
968 if (intf->condition == USB_INTERFACE_UNBOUND)
969 goto done;
970 driver = to_usb_driver(intf->dev.driver);
971
972 if (driver->suspend) {
973 status = driver->suspend(intf, msg);
974 if (status == 0)
975 mark_quiesced(intf);
976 else if (!(msg.event & PM_EVENT_AUTO))
977 dev_err(&intf->dev, "%s error %d\n",
978 "suspend", status);
979 } else {
980
981 intf->needs_binding = 1;
982 dev_warn(&intf->dev, "no %s for driver %s?\n",
983 "suspend", driver->name);
984 mark_quiesced(intf);
985 }
986
987 done:
988 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
989 return status;
990}
991
992
993static int usb_resume_interface(struct usb_device *udev,
994 struct usb_interface *intf, pm_message_t msg, int reset_resume)
995{
996 struct usb_driver *driver;
997 int status = 0;
998
999 if (udev->state == USB_STATE_NOTATTACHED || is_active(intf))
1000 goto done;
1001
1002
1003 if (intf->condition == USB_INTERFACE_UNBINDING)
1004 goto done;
1005
1006
1007 if (intf->condition == USB_INTERFACE_UNBOUND) {
1008
1009
1010 if (intf->needs_altsetting0 &&
1011 intf->dev.power.status == DPM_ON) {
1012 usb_set_interface(udev, intf->altsetting[0].
1013 desc.bInterfaceNumber, 0);
1014 intf->needs_altsetting0 = 0;
1015 }
1016 goto done;
1017 }
1018
1019
1020 if (intf->needs_binding)
1021 goto done;
1022 driver = to_usb_driver(intf->dev.driver);
1023
1024 if (reset_resume) {
1025 if (driver->reset_resume) {
1026 status = driver->reset_resume(intf);
1027 if (status)
1028 dev_err(&intf->dev, "%s error %d\n",
1029 "reset_resume", status);
1030 } else {
1031 intf->needs_binding = 1;
1032 dev_warn(&intf->dev, "no %s for driver %s?\n",
1033 "reset_resume", driver->name);
1034 }
1035 } else {
1036 if (driver->resume) {
1037 status = driver->resume(intf);
1038 if (status)
1039 dev_err(&intf->dev, "%s error %d\n",
1040 "resume", status);
1041 } else {
1042 intf->needs_binding = 1;
1043 dev_warn(&intf->dev, "no %s for driver %s?\n",
1044 "resume", driver->name);
1045 }
1046 }
1047
1048done:
1049 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1050 if (status == 0 && intf->condition == USB_INTERFACE_BOUND)
1051 mark_active(intf);
1052
1053
1054 return status;
1055}
1056
1057#ifdef CONFIG_USB_SUSPEND
1058
1059
1060static int autosuspend_check(struct usb_device *udev, int reschedule)
1061{
1062 int i;
1063 struct usb_interface *intf;
1064 unsigned long suspend_time, j;
1065
1066
1067
1068
1069
1070 if (udev->pm_usage_cnt > 0)
1071 return -EBUSY;
1072 if (udev->autosuspend_delay < 0 || udev->autosuspend_disabled)
1073 return -EPERM;
1074
1075 suspend_time = udev->last_busy + udev->autosuspend_delay;
1076 if (udev->actconfig) {
1077 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1078 intf = udev->actconfig->interface[i];
1079 if (!is_active(intf))
1080 continue;
1081 if (atomic_read(&intf->pm_usage_cnt) > 0)
1082 return -EBUSY;
1083 if (intf->needs_remote_wakeup &&
1084 !udev->do_remote_wakeup) {
1085 dev_dbg(&udev->dev, "remote wakeup needed "
1086 "for autosuspend\n");
1087 return -EOPNOTSUPP;
1088 }
1089
1090
1091
1092
1093
1094 if (udev->quirks & USB_QUIRK_RESET_RESUME) {
1095 struct usb_driver *driver;
1096
1097 driver = to_usb_driver(intf->dev.driver);
1098 if (!driver->reset_resume ||
1099 intf->needs_remote_wakeup)
1100 return -EOPNOTSUPP;
1101 }
1102 }
1103 }
1104
1105
1106
1107
1108
1109
1110 j = jiffies;
1111 if (time_before(j, suspend_time))
1112 reschedule = 1;
1113 else
1114 suspend_time = j + HZ;
1115 if (reschedule) {
1116 if (!timer_pending(&udev->autosuspend.timer)) {
1117 queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
1118 round_jiffies_up_relative(suspend_time - j));
1119 }
1120 return -EAGAIN;
1121 }
1122 return 0;
1123}
1124
1125#else
1126
1127static inline int autosuspend_check(struct usb_device *udev, int reschedule)
1128{
1129 return 0;
1130}
1131
1132#endif
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1170{
1171 int status = 0;
1172 int i = 0;
1173 struct usb_interface *intf;
1174 struct usb_device *parent = udev->parent;
1175
1176 if (udev->state == USB_STATE_NOTATTACHED ||
1177 udev->state == USB_STATE_SUSPENDED)
1178 goto done;
1179
1180 udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
1181
1182 if (msg.event & PM_EVENT_AUTO) {
1183 status = autosuspend_check(udev, 0);
1184 if (status < 0)
1185 goto done;
1186 }
1187
1188
1189 if (udev->actconfig) {
1190 for (; i < udev->actconfig->desc.bNumInterfaces; i++) {
1191 intf = udev->actconfig->interface[i];
1192 status = usb_suspend_interface(udev, intf, msg);
1193 if (status != 0)
1194 break;
1195 }
1196 }
1197 if (status == 0)
1198 status = usb_suspend_device(udev, msg);
1199
1200
1201 if (status != 0) {
1202 pm_message_t msg2;
1203
1204 msg2.event = msg.event ^ (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
1205 while (--i >= 0) {
1206 intf = udev->actconfig->interface[i];
1207 usb_resume_interface(udev, intf, msg2, 0);
1208 }
1209
1210
1211 if (msg.event & PM_EVENT_AUTO)
1212 autosuspend_check(udev, status == -EBUSY);
1213
1214
1215
1216
1217 } else {
1218 cancel_delayed_work(&udev->autosuspend);
1219 udev->can_submit = 0;
1220 for (i = 0; i < 16; ++i) {
1221 usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1222 usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1223 }
1224
1225
1226
1227
1228
1229 if (parent && udev->state == USB_STATE_SUSPENDED)
1230 usb_autosuspend_device(parent);
1231 }
1232
1233 done:
1234 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1235 return status;
1236}
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
1268{
1269 int status = 0;
1270 int i;
1271 struct usb_interface *intf;
1272 struct usb_device *parent = udev->parent;
1273
1274 cancel_delayed_work(&udev->autosuspend);
1275 if (udev->state == USB_STATE_NOTATTACHED) {
1276 status = -ENODEV;
1277 goto done;
1278 }
1279 udev->can_submit = 1;
1280
1281
1282 if (udev->state == USB_STATE_SUSPENDED) {
1283 if ((msg.event & PM_EVENT_AUTO) &&
1284 udev->autoresume_disabled) {
1285 status = -EPERM;
1286 goto done;
1287 }
1288 if (parent) {
1289 status = usb_autoresume_device(parent);
1290 if (status == 0) {
1291 status = usb_resume_device(udev, msg);
1292 if (status || udev->state ==
1293 USB_STATE_NOTATTACHED) {
1294 usb_autosuspend_device(parent);
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304 if (udev->state ==
1305 USB_STATE_NOTATTACHED)
1306 udev->discon_suspended = 1;
1307 }
1308 }
1309 } else {
1310
1311
1312
1313
1314 status = usb_resume_device(udev, msg);
1315 }
1316 } else if (udev->reset_resume)
1317 status = usb_resume_device(udev, msg);
1318
1319 if (status == 0 && udev->actconfig) {
1320 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1321 intf = udev->actconfig->interface[i];
1322 usb_resume_interface(udev, intf, msg,
1323 udev->reset_resume);
1324 }
1325 }
1326
1327 done:
1328 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1329 if (!status)
1330 udev->reset_resume = 0;
1331 return status;
1332}
1333
1334#ifdef CONFIG_USB_SUSPEND
1335
1336
1337
1338
1339static int usb_autopm_do_device(struct usb_device *udev, int inc_usage_cnt)
1340{
1341 int status = 0;
1342
1343 usb_pm_lock(udev);
1344 udev->auto_pm = 1;
1345 udev->pm_usage_cnt += inc_usage_cnt;
1346 WARN_ON(udev->pm_usage_cnt < 0);
1347 if (inc_usage_cnt)
1348 udev->last_busy = jiffies;
1349 if (inc_usage_cnt >= 0 && udev->pm_usage_cnt > 0) {
1350 if (udev->state == USB_STATE_SUSPENDED)
1351 status = usb_resume_both(udev, PMSG_AUTO_RESUME);
1352 if (status != 0)
1353 udev->pm_usage_cnt -= inc_usage_cnt;
1354 else if (inc_usage_cnt)
1355 udev->last_busy = jiffies;
1356 } else if (inc_usage_cnt <= 0 && udev->pm_usage_cnt <= 0) {
1357 status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
1358 }
1359 usb_pm_unlock(udev);
1360 return status;
1361}
1362
1363
1364void usb_autosuspend_work(struct work_struct *work)
1365{
1366 struct usb_device *udev =
1367 container_of(work, struct usb_device, autosuspend.work);
1368
1369 usb_autopm_do_device(udev, 0);
1370}
1371
1372
1373void usb_autoresume_work(struct work_struct *work)
1374{
1375 struct usb_device *udev =
1376 container_of(work, struct usb_device, autoresume);
1377
1378
1379
1380
1381 if (usb_autopm_do_device(udev, 1) == 0)
1382 usb_autopm_do_device(udev, -1);
1383}
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405void usb_autosuspend_device(struct usb_device *udev)
1406{
1407 int status;
1408
1409 status = usb_autopm_do_device(udev, -1);
1410 dev_vdbg(&udev->dev, "%s: cnt %d\n",
1411 __func__, udev->pm_usage_cnt);
1412}
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427void usb_try_autosuspend_device(struct usb_device *udev)
1428{
1429 usb_autopm_do_device(udev, 0);
1430 dev_vdbg(&udev->dev, "%s: cnt %d\n",
1431 __func__, udev->pm_usage_cnt);
1432}
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453int usb_autoresume_device(struct usb_device *udev)
1454{
1455 int status;
1456
1457 status = usb_autopm_do_device(udev, 1);
1458 dev_vdbg(&udev->dev, "%s: status %d cnt %d\n",
1459 __func__, status, udev->pm_usage_cnt);
1460 return status;
1461}
1462
1463
1464
1465
1466static int usb_autopm_do_interface(struct usb_interface *intf,
1467 int inc_usage_cnt)
1468{
1469 struct usb_device *udev = interface_to_usbdev(intf);
1470 int status = 0;
1471
1472 usb_pm_lock(udev);
1473 if (intf->condition == USB_INTERFACE_UNBOUND)
1474 status = -ENODEV;
1475 else {
1476 udev->auto_pm = 1;
1477 atomic_add(inc_usage_cnt, &intf->pm_usage_cnt);
1478 udev->last_busy = jiffies;
1479 if (inc_usage_cnt >= 0 &&
1480 atomic_read(&intf->pm_usage_cnt) > 0) {
1481 if (udev->state == USB_STATE_SUSPENDED)
1482 status = usb_resume_both(udev,
1483 PMSG_AUTO_RESUME);
1484 if (status != 0)
1485 atomic_sub(inc_usage_cnt, &intf->pm_usage_cnt);
1486 else
1487 udev->last_busy = jiffies;
1488 } else if (inc_usage_cnt <= 0 &&
1489 atomic_read(&intf->pm_usage_cnt) <= 0) {
1490 status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
1491 }
1492 }
1493 usb_pm_unlock(udev);
1494 return status;
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
1528void usb_autopm_put_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, atomic_read(&intf->pm_usage_cnt));
1535}
1536EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553void usb_autopm_put_interface_async(struct usb_interface *intf)
1554{
1555 struct usb_device *udev = interface_to_usbdev(intf);
1556 int status = 0;
1557
1558 if (intf->condition == USB_INTERFACE_UNBOUND) {
1559 status = -ENODEV;
1560 } else {
1561 udev->last_busy = jiffies;
1562 atomic_dec(&intf->pm_usage_cnt);
1563 if (udev->autosuspend_disabled || udev->autosuspend_delay < 0)
1564 status = -EPERM;
1565 else if (atomic_read(&intf->pm_usage_cnt) <= 0 &&
1566 !timer_pending(&udev->autosuspend.timer)) {
1567 queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
1568 round_jiffies_up_relative(
1569 udev->autosuspend_delay));
1570 }
1571 }
1572 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1573 __func__, status, atomic_read(&intf->pm_usage_cnt));
1574}
1575EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611int usb_autopm_get_interface(struct usb_interface *intf)
1612{
1613 int status;
1614
1615 status = usb_autopm_do_interface(intf, 1);
1616 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1617 __func__, status, atomic_read(&intf->pm_usage_cnt));
1618 return status;
1619}
1620EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636int usb_autopm_get_interface_async(struct usb_interface *intf)
1637{
1638 struct usb_device *udev = interface_to_usbdev(intf);
1639 int status = 0;
1640
1641 if (intf->condition == USB_INTERFACE_UNBOUND)
1642 status = -ENODEV;
1643 else if (udev->autoresume_disabled)
1644 status = -EPERM;
1645 else {
1646 atomic_inc(&intf->pm_usage_cnt);
1647 if (atomic_read(&intf->pm_usage_cnt) > 0 &&
1648 udev->state == USB_STATE_SUSPENDED)
1649 queue_work(ksuspend_usb_wq, &udev->autoresume);
1650 }
1651 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1652 __func__, status, atomic_read(&intf->pm_usage_cnt));
1653 return status;
1654}
1655EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668int usb_autopm_set_interface(struct usb_interface *intf)
1669{
1670 int status;
1671
1672 status = usb_autopm_do_interface(intf, 0);
1673 dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
1674 __func__, status, atomic_read(&intf->pm_usage_cnt));
1675 return status;
1676}
1677EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
1678
1679#else
1680
1681void usb_autosuspend_work(struct work_struct *work)
1682{}
1683
1684void usb_autoresume_work(struct work_struct *work)
1685{}
1686
1687#endif
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
1705{
1706 int status;
1707
1708 do_unbind_rebind(udev, DO_UNBIND);
1709 usb_pm_lock(udev);
1710 udev->auto_pm = 0;
1711 status = usb_suspend_both(udev, msg);
1712 usb_pm_unlock(udev);
1713 return status;
1714}
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728int usb_external_resume_device(struct usb_device *udev, pm_message_t msg)
1729{
1730 int status;
1731
1732 usb_pm_lock(udev);
1733 udev->auto_pm = 0;
1734 status = usb_resume_both(udev, msg);
1735 udev->last_busy = jiffies;
1736 usb_pm_unlock(udev);
1737 if (status == 0)
1738 do_unbind_rebind(udev, DO_REBIND);
1739
1740
1741
1742 if (status == 0)
1743 usb_try_autosuspend_device(udev);
1744 return status;
1745}
1746
1747int usb_suspend(struct device *dev, pm_message_t msg)
1748{
1749 struct usb_device *udev;
1750
1751 udev = to_usb_device(dev);
1752
1753
1754
1755
1756
1757
1758
1759 if (udev->state == USB_STATE_SUSPENDED) {
1760 if (udev->parent || udev->speed != USB_SPEED_HIGH)
1761 udev->skip_sys_resume = 1;
1762 return 0;
1763 }
1764
1765 udev->skip_sys_resume = 0;
1766 return usb_external_suspend_device(udev, msg);
1767}
1768
1769int usb_resume(struct device *dev, pm_message_t msg)
1770{
1771 struct usb_device *udev;
1772 int status;
1773
1774 udev = to_usb_device(dev);
1775
1776
1777
1778
1779
1780 if (udev->skip_sys_resume)
1781 return 0;
1782 status = usb_external_resume_device(udev, msg);
1783
1784
1785
1786
1787 if (status == -ENODEV)
1788 return 0;
1789 return status;
1790}
1791
1792#endif
1793
1794struct bus_type usb_bus_type = {
1795 .name = "usb",
1796 .match = usb_device_match,
1797 .uevent = usb_uevent,
1798};
1799