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