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