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