1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/debugfs.h>
20#include <linux/device.h>
21#include <linux/delay.h>
22#include <linux/dma-mapping.h>
23#include <linux/init.h>
24#include <linux/module.h>
25#include <linux/kthread.h>
26#include <linux/wait.h>
27#include <linux/async.h>
28#include <linux/pm_runtime.h>
29#include <linux/pinctrl/devinfo.h>
30
31#include "base.h"
32#include "power/power.h"
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53static DEFINE_MUTEX(deferred_probe_mutex);
54static LIST_HEAD(deferred_probe_pending_list);
55static LIST_HEAD(deferred_probe_active_list);
56static atomic_t deferred_trigger_count = ATOMIC_INIT(0);
57static struct dentry *deferred_devices;
58static bool initcalls_done;
59
60
61#define ASYNC_DRV_NAMES_MAX_LEN 256
62static char async_probe_drv_names[ASYNC_DRV_NAMES_MAX_LEN];
63
64
65
66
67
68
69static bool defer_all_probes;
70
71
72
73
74static void deferred_probe_work_func(struct work_struct *work)
75{
76 struct device *dev;
77 struct device_private *private;
78
79
80
81
82
83
84
85
86
87
88
89
90 mutex_lock(&deferred_probe_mutex);
91 while (!list_empty(&deferred_probe_active_list)) {
92 private = list_first_entry(&deferred_probe_active_list,
93 typeof(*dev->p), deferred_probe);
94 dev = private->device;
95 list_del_init(&private->deferred_probe);
96
97 get_device(dev);
98
99
100
101
102
103 mutex_unlock(&deferred_probe_mutex);
104
105
106
107
108
109
110
111 device_pm_move_to_tail(dev);
112
113 dev_dbg(dev, "Retrying from deferred list\n");
114 bus_probe_device(dev);
115 mutex_lock(&deferred_probe_mutex);
116
117 put_device(dev);
118 }
119 mutex_unlock(&deferred_probe_mutex);
120}
121static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func);
122
123void driver_deferred_probe_add(struct device *dev)
124{
125 mutex_lock(&deferred_probe_mutex);
126 if (list_empty(&dev->p->deferred_probe)) {
127 dev_dbg(dev, "Added to deferred list\n");
128 list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list);
129 }
130 mutex_unlock(&deferred_probe_mutex);
131}
132
133void driver_deferred_probe_del(struct device *dev)
134{
135 mutex_lock(&deferred_probe_mutex);
136 if (!list_empty(&dev->p->deferred_probe)) {
137 dev_dbg(dev, "Removed from deferred list\n");
138 list_del_init(&dev->p->deferred_probe);
139 }
140 mutex_unlock(&deferred_probe_mutex);
141}
142
143static bool driver_deferred_probe_enable = false;
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162static void driver_deferred_probe_trigger(void)
163{
164 if (!driver_deferred_probe_enable)
165 return;
166
167
168
169
170
171
172 mutex_lock(&deferred_probe_mutex);
173 atomic_inc(&deferred_trigger_count);
174 list_splice_tail_init(&deferred_probe_pending_list,
175 &deferred_probe_active_list);
176 mutex_unlock(&deferred_probe_mutex);
177
178
179
180
181
182 schedule_work(&deferred_probe_work);
183}
184
185
186
187
188
189
190void device_block_probing(void)
191{
192 defer_all_probes = true;
193
194 wait_for_device_probe();
195}
196
197
198
199
200
201
202
203void device_unblock_probing(void)
204{
205 defer_all_probes = false;
206 driver_deferred_probe_trigger();
207}
208
209
210
211
212static int deferred_devs_show(struct seq_file *s, void *data)
213{
214 struct device_private *curr;
215
216 mutex_lock(&deferred_probe_mutex);
217
218 list_for_each_entry(curr, &deferred_probe_pending_list, deferred_probe)
219 seq_printf(s, "%s\n", dev_name(curr->device));
220
221 mutex_unlock(&deferred_probe_mutex);
222
223 return 0;
224}
225DEFINE_SHOW_ATTRIBUTE(deferred_devs);
226
227static int deferred_probe_timeout = -1;
228static int __init deferred_probe_timeout_setup(char *str)
229{
230 int timeout;
231
232 if (!kstrtoint(str, 10, &timeout))
233 deferred_probe_timeout = timeout;
234 return 1;
235}
236__setup("deferred_probe_timeout=", deferred_probe_timeout_setup);
237
238static int __driver_deferred_probe_check_state(struct device *dev)
239{
240 if (!initcalls_done)
241 return -EPROBE_DEFER;
242
243 if (!deferred_probe_timeout) {
244 dev_WARN(dev, "deferred probe timeout, ignoring dependency");
245 return -ETIMEDOUT;
246 }
247
248 return 0;
249}
250
251
252
253
254
255
256
257
258
259
260
261
262int driver_deferred_probe_check_state(struct device *dev)
263{
264 int ret;
265
266 ret = __driver_deferred_probe_check_state(dev);
267 if (ret < 0)
268 return ret;
269
270 dev_warn(dev, "ignoring dependency for device, assuming no driver");
271
272 return -ENODEV;
273}
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290int driver_deferred_probe_check_state_continue(struct device *dev)
291{
292 int ret;
293
294 ret = __driver_deferred_probe_check_state(dev);
295 if (ret < 0)
296 return ret;
297
298 return -EPROBE_DEFER;
299}
300
301static void deferred_probe_timeout_work_func(struct work_struct *work)
302{
303 struct device_private *private, *p;
304
305 deferred_probe_timeout = 0;
306 driver_deferred_probe_trigger();
307 flush_work(&deferred_probe_work);
308
309 list_for_each_entry_safe(private, p, &deferred_probe_pending_list, deferred_probe)
310 dev_info(private->device, "deferred probe pending");
311}
312static DECLARE_DELAYED_WORK(deferred_probe_timeout_work, deferred_probe_timeout_work_func);
313
314
315
316
317
318
319
320
321static int deferred_probe_initcall(void)
322{
323 deferred_devices = debugfs_create_file("devices_deferred", 0444, NULL,
324 NULL, &deferred_devs_fops);
325
326 driver_deferred_probe_enable = true;
327 driver_deferred_probe_trigger();
328
329 flush_work(&deferred_probe_work);
330 initcalls_done = true;
331
332
333
334
335
336 driver_deferred_probe_trigger();
337 flush_work(&deferred_probe_work);
338
339 if (deferred_probe_timeout > 0) {
340 schedule_delayed_work(&deferred_probe_timeout_work,
341 deferred_probe_timeout * HZ);
342 }
343 return 0;
344}
345late_initcall(deferred_probe_initcall);
346
347static void __exit deferred_probe_exit(void)
348{
349 debugfs_remove_recursive(deferred_devices);
350}
351__exitcall(deferred_probe_exit);
352
353
354
355
356
357
358
359
360
361
362bool device_is_bound(struct device *dev)
363{
364 return dev->p && klist_node_attached(&dev->p->knode_driver);
365}
366
367static void driver_bound(struct device *dev)
368{
369 if (device_is_bound(dev)) {
370 printk(KERN_WARNING "%s: device %s already bound\n",
371 __func__, kobject_name(&dev->kobj));
372 return;
373 }
374
375 pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->driver->name,
376 __func__, dev_name(dev));
377
378 klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
379 device_links_driver_bound(dev);
380
381 device_pm_check_callbacks(dev);
382
383
384
385
386
387 driver_deferred_probe_del(dev);
388 driver_deferred_probe_trigger();
389
390 if (dev->bus)
391 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
392 BUS_NOTIFY_BOUND_DRIVER, dev);
393
394 kobject_uevent(&dev->kobj, KOBJ_BIND);
395}
396
397static ssize_t coredump_store(struct device *dev, struct device_attribute *attr,
398 const char *buf, size_t count)
399{
400 device_lock(dev);
401 dev->driver->coredump(dev);
402 device_unlock(dev);
403
404 return count;
405}
406static DEVICE_ATTR_WO(coredump);
407
408static int driver_sysfs_add(struct device *dev)
409{
410 int ret;
411
412 if (dev->bus)
413 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
414 BUS_NOTIFY_BIND_DRIVER, dev);
415
416 ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
417 kobject_name(&dev->kobj));
418 if (ret)
419 goto fail;
420
421 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,
422 "driver");
423 if (ret)
424 goto rm_dev;
425
426 if (!IS_ENABLED(CONFIG_DEV_COREDUMP) || !dev->driver->coredump ||
427 !device_create_file(dev, &dev_attr_coredump))
428 return 0;
429
430 sysfs_remove_link(&dev->kobj, "driver");
431
432rm_dev:
433 sysfs_remove_link(&dev->driver->p->kobj,
434 kobject_name(&dev->kobj));
435
436fail:
437 return ret;
438}
439
440static void driver_sysfs_remove(struct device *dev)
441{
442 struct device_driver *drv = dev->driver;
443
444 if (drv) {
445 if (drv->coredump)
446 device_remove_file(dev, &dev_attr_coredump);
447 sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));
448 sysfs_remove_link(&dev->kobj, "driver");
449 }
450}
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466int device_bind_driver(struct device *dev)
467{
468 int ret;
469
470 ret = driver_sysfs_add(dev);
471 if (!ret)
472 driver_bound(dev);
473 else if (dev->bus)
474 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
475 BUS_NOTIFY_DRIVER_NOT_BOUND, dev);
476 return ret;
477}
478EXPORT_SYMBOL_GPL(device_bind_driver);
479
480static atomic_t probe_count = ATOMIC_INIT(0);
481static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
482
483static void driver_deferred_probe_add_trigger(struct device *dev,
484 int local_trigger_count)
485{
486 driver_deferred_probe_add(dev);
487
488 if (local_trigger_count != atomic_read(&deferred_trigger_count))
489 driver_deferred_probe_trigger();
490}
491
492static int really_probe(struct device *dev, struct device_driver *drv)
493{
494 int ret = -EPROBE_DEFER;
495 int local_trigger_count = atomic_read(&deferred_trigger_count);
496 bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) &&
497 !drv->suppress_bind_attrs;
498
499 if (defer_all_probes) {
500
501
502
503
504
505 dev_dbg(dev, "Driver %s force probe deferral\n", drv->name);
506 driver_deferred_probe_add(dev);
507 return ret;
508 }
509
510 ret = device_links_check_suppliers(dev);
511 if (ret == -EPROBE_DEFER)
512 driver_deferred_probe_add_trigger(dev, local_trigger_count);
513 if (ret)
514 return ret;
515
516 atomic_inc(&probe_count);
517 pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
518 drv->bus->name, __func__, drv->name, dev_name(dev));
519 WARN_ON(!list_empty(&dev->devres_head));
520
521re_probe:
522 dev->driver = drv;
523
524
525 ret = pinctrl_bind_pins(dev);
526 if (ret)
527 goto pinctrl_bind_failed;
528
529 if (dev->bus->dma_configure) {
530 ret = dev->bus->dma_configure(dev);
531 if (ret)
532 goto probe_failed;
533 }
534
535 if (driver_sysfs_add(dev)) {
536 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
537 __func__, dev_name(dev));
538 goto probe_failed;
539 }
540
541 if (dev->pm_domain && dev->pm_domain->activate) {
542 ret = dev->pm_domain->activate(dev);
543 if (ret)
544 goto probe_failed;
545 }
546
547 if (dev->bus->probe) {
548 ret = dev->bus->probe(dev);
549 if (ret)
550 goto probe_failed;
551 } else if (drv->probe) {
552 ret = drv->probe(dev);
553 if (ret)
554 goto probe_failed;
555 }
556
557 if (test_remove) {
558 test_remove = false;
559
560 if (dev->bus->remove)
561 dev->bus->remove(dev);
562 else if (drv->remove)
563 drv->remove(dev);
564
565 devres_release_all(dev);
566 driver_sysfs_remove(dev);
567 dev->driver = NULL;
568 dev_set_drvdata(dev, NULL);
569 if (dev->pm_domain && dev->pm_domain->dismiss)
570 dev->pm_domain->dismiss(dev);
571 pm_runtime_reinit(dev);
572
573 goto re_probe;
574 }
575
576 pinctrl_init_done(dev);
577
578 if (dev->pm_domain && dev->pm_domain->sync)
579 dev->pm_domain->sync(dev);
580
581 driver_bound(dev);
582 ret = 1;
583 pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
584 drv->bus->name, __func__, dev_name(dev), drv->name);
585 goto done;
586
587probe_failed:
588 if (dev->bus)
589 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
590 BUS_NOTIFY_DRIVER_NOT_BOUND, dev);
591pinctrl_bind_failed:
592 device_links_no_driver(dev);
593 devres_release_all(dev);
594 arch_teardown_dma_ops(dev);
595 driver_sysfs_remove(dev);
596 dev->driver = NULL;
597 dev_set_drvdata(dev, NULL);
598 if (dev->pm_domain && dev->pm_domain->dismiss)
599 dev->pm_domain->dismiss(dev);
600 pm_runtime_reinit(dev);
601 dev_pm_set_driver_flags(dev, 0);
602
603 switch (ret) {
604 case -EPROBE_DEFER:
605
606 dev_dbg(dev, "Driver %s requests probe deferral\n", drv->name);
607 driver_deferred_probe_add_trigger(dev, local_trigger_count);
608 break;
609 case -ENODEV:
610 case -ENXIO:
611 pr_debug("%s: probe of %s rejects match %d\n",
612 drv->name, dev_name(dev), ret);
613 break;
614 default:
615
616 printk(KERN_WARNING
617 "%s: probe of %s failed with error %d\n",
618 drv->name, dev_name(dev), ret);
619 }
620
621
622
623
624 ret = 0;
625done:
626 atomic_dec(&probe_count);
627 wake_up(&probe_waitqueue);
628 return ret;
629}
630
631
632
633
634static int really_probe_debug(struct device *dev, struct device_driver *drv)
635{
636 ktime_t calltime, delta, rettime;
637 int ret;
638
639 calltime = ktime_get();
640 ret = really_probe(dev, drv);
641 rettime = ktime_get();
642 delta = ktime_sub(rettime, calltime);
643 printk(KERN_DEBUG "probe of %s returned %d after %lld usecs\n",
644 dev_name(dev), ret, (s64) ktime_to_us(delta));
645 return ret;
646}
647
648
649
650
651
652
653
654int driver_probe_done(void)
655{
656 pr_debug("%s: probe_count = %d\n", __func__,
657 atomic_read(&probe_count));
658 if (atomic_read(&probe_count))
659 return -EBUSY;
660 return 0;
661}
662
663
664
665
666
667void wait_for_device_probe(void)
668{
669
670 flush_work(&deferred_probe_work);
671
672
673 wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
674 async_synchronize_full();
675}
676EXPORT_SYMBOL_GPL(wait_for_device_probe);
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691int driver_probe_device(struct device_driver *drv, struct device *dev)
692{
693 int ret = 0;
694
695 if (!device_is_registered(dev))
696 return -ENODEV;
697
698 pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
699 drv->bus->name, __func__, dev_name(dev), drv->name);
700
701 pm_runtime_get_suppliers(dev);
702 if (dev->parent)
703 pm_runtime_get_sync(dev->parent);
704
705 pm_runtime_barrier(dev);
706 if (initcall_debug)
707 ret = really_probe_debug(dev, drv);
708 else
709 ret = really_probe(dev, drv);
710 pm_request_idle(dev);
711
712 if (dev->parent)
713 pm_runtime_put(dev->parent);
714
715 pm_runtime_put_suppliers(dev);
716 return ret;
717}
718
719static inline bool cmdline_requested_async_probing(const char *drv_name)
720{
721 return parse_option_str(async_probe_drv_names, drv_name);
722}
723
724
725static int __init save_async_options(char *buf)
726{
727 if (strlen(buf) >= ASYNC_DRV_NAMES_MAX_LEN)
728 printk(KERN_WARNING
729 "Too long list of driver names for 'driver_async_probe'!\n");
730
731 strlcpy(async_probe_drv_names, buf, ASYNC_DRV_NAMES_MAX_LEN);
732 return 0;
733}
734__setup("driver_async_probe=", save_async_options);
735
736bool driver_allows_async_probing(struct device_driver *drv)
737{
738 switch (drv->probe_type) {
739 case PROBE_PREFER_ASYNCHRONOUS:
740 return true;
741
742 case PROBE_FORCE_SYNCHRONOUS:
743 return false;
744
745 default:
746 if (cmdline_requested_async_probing(drv->name))
747 return true;
748
749 if (module_requested_async_probing(drv->owner))
750 return true;
751
752 return false;
753 }
754}
755
756struct device_attach_data {
757 struct device *dev;
758
759
760
761
762
763
764
765
766 bool check_async;
767
768
769
770
771
772
773
774
775
776
777
778
779
780 bool want_async;
781
782
783
784
785
786 bool have_async;
787};
788
789static int __device_attach_driver(struct device_driver *drv, void *_data)
790{
791 struct device_attach_data *data = _data;
792 struct device *dev = data->dev;
793 bool async_allowed;
794 int ret;
795
796 ret = driver_match_device(drv, dev);
797 if (ret == 0) {
798
799 return 0;
800 } else if (ret == -EPROBE_DEFER) {
801 dev_dbg(dev, "Device match requests probe deferral\n");
802 driver_deferred_probe_add(dev);
803 } else if (ret < 0) {
804 dev_dbg(dev, "Bus failed to match device: %d", ret);
805 return ret;
806 }
807
808 async_allowed = driver_allows_async_probing(drv);
809
810 if (async_allowed)
811 data->have_async = true;
812
813 if (data->check_async && async_allowed != data->want_async)
814 return 0;
815
816 return driver_probe_device(drv, dev);
817}
818
819static void __device_attach_async_helper(void *_dev, async_cookie_t cookie)
820{
821 struct device *dev = _dev;
822 struct device_attach_data data = {
823 .dev = dev,
824 .check_async = true,
825 .want_async = true,
826 };
827
828 device_lock(dev);
829
830
831
832
833
834
835
836 if (dev->p->dead || dev->driver)
837 goto out_unlock;
838
839 if (dev->parent)
840 pm_runtime_get_sync(dev->parent);
841
842 bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver);
843 dev_dbg(dev, "async probe completed\n");
844
845 pm_request_idle(dev);
846
847 if (dev->parent)
848 pm_runtime_put(dev->parent);
849out_unlock:
850 device_unlock(dev);
851
852 put_device(dev);
853}
854
855static int __device_attach(struct device *dev, bool allow_async)
856{
857 int ret = 0;
858
859 device_lock(dev);
860 if (dev->driver) {
861 if (device_is_bound(dev)) {
862 ret = 1;
863 goto out_unlock;
864 }
865 ret = device_bind_driver(dev);
866 if (ret == 0)
867 ret = 1;
868 else {
869 dev->driver = NULL;
870 ret = 0;
871 }
872 } else {
873 struct device_attach_data data = {
874 .dev = dev,
875 .check_async = allow_async,
876 .want_async = false,
877 };
878
879 if (dev->parent)
880 pm_runtime_get_sync(dev->parent);
881
882 ret = bus_for_each_drv(dev->bus, NULL, &data,
883 __device_attach_driver);
884 if (!ret && allow_async && data.have_async) {
885
886
887
888
889
890
891
892 dev_dbg(dev, "scheduling asynchronous probe\n");
893 get_device(dev);
894 async_schedule_dev(__device_attach_async_helper, dev);
895 } else {
896 pm_request_idle(dev);
897 }
898
899 if (dev->parent)
900 pm_runtime_put(dev->parent);
901 }
902out_unlock:
903 device_unlock(dev);
904 return ret;
905}
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921int device_attach(struct device *dev)
922{
923 return __device_attach(dev, false);
924}
925EXPORT_SYMBOL_GPL(device_attach);
926
927void device_initial_probe(struct device *dev)
928{
929 __device_attach(dev, true);
930}
931
932
933
934
935
936
937
938
939
940
941static void __device_driver_lock(struct device *dev, struct device *parent)
942{
943 if (parent && dev->bus->need_parent_lock)
944 device_lock(parent);
945 device_lock(dev);
946}
947
948
949
950
951
952
953
954
955
956
957static void __device_driver_unlock(struct device *dev, struct device *parent)
958{
959 device_unlock(dev);
960 if (parent && dev->bus->need_parent_lock)
961 device_unlock(parent);
962}
963
964
965
966
967
968
969
970
971
972int device_driver_attach(struct device_driver *drv, struct device *dev)
973{
974 int ret = 0;
975
976 __device_driver_lock(dev, dev->parent);
977
978
979
980
981
982 if (!dev->p->dead && !dev->driver)
983 ret = driver_probe_device(drv, dev);
984
985 __device_driver_unlock(dev, dev->parent);
986
987 return ret;
988}
989
990static void __driver_attach_async_helper(void *_dev, async_cookie_t cookie)
991{
992 struct device *dev = _dev;
993 struct device_driver *drv;
994 int ret = 0;
995
996 __device_driver_lock(dev, dev->parent);
997
998 drv = dev->p->async_driver;
999
1000
1001
1002
1003
1004 if (!dev->p->dead && !dev->driver)
1005 ret = driver_probe_device(drv, dev);
1006
1007 __device_driver_unlock(dev, dev->parent);
1008
1009 dev_dbg(dev, "driver %s async attach completed: %d\n", drv->name, ret);
1010
1011 put_device(dev);
1012}
1013
1014static int __driver_attach(struct device *dev, void *data)
1015{
1016 struct device_driver *drv = data;
1017 int ret;
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029 ret = driver_match_device(drv, dev);
1030 if (ret == 0) {
1031
1032 return 0;
1033 } else if (ret == -EPROBE_DEFER) {
1034 dev_dbg(dev, "Device match requests probe deferral\n");
1035 driver_deferred_probe_add(dev);
1036 } else if (ret < 0) {
1037 dev_dbg(dev, "Bus failed to match device: %d", ret);
1038 return ret;
1039 }
1040
1041 if (driver_allows_async_probing(drv)) {
1042
1043
1044
1045
1046
1047
1048
1049 dev_dbg(dev, "probing driver %s asynchronously\n", drv->name);
1050 device_lock(dev);
1051 if (!dev->driver) {
1052 get_device(dev);
1053 dev->p->async_driver = drv;
1054 async_schedule_dev(__driver_attach_async_helper, dev);
1055 }
1056 device_unlock(dev);
1057 return 0;
1058 }
1059
1060 device_driver_attach(drv, dev);
1061
1062 return 0;
1063}
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074int driver_attach(struct device_driver *drv)
1075{
1076 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
1077}
1078EXPORT_SYMBOL_GPL(driver_attach);
1079
1080
1081
1082
1083
1084static void __device_release_driver(struct device *dev, struct device *parent)
1085{
1086 struct device_driver *drv;
1087
1088 drv = dev->driver;
1089 if (drv) {
1090 while (device_links_busy(dev)) {
1091 __device_driver_unlock(dev, parent);
1092
1093 device_links_unbind_consumers(dev);
1094
1095 __device_driver_lock(dev, parent);
1096
1097
1098
1099
1100
1101 if (dev->driver != drv)
1102 return;
1103 }
1104
1105 pm_runtime_get_sync(dev);
1106 pm_runtime_clean_up_links(dev);
1107
1108 driver_sysfs_remove(dev);
1109
1110 if (dev->bus)
1111 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1112 BUS_NOTIFY_UNBIND_DRIVER,
1113 dev);
1114
1115 pm_runtime_put_sync(dev);
1116
1117 if (dev->bus && dev->bus->remove)
1118 dev->bus->remove(dev);
1119 else if (drv->remove)
1120 drv->remove(dev);
1121
1122 device_links_driver_cleanup(dev);
1123
1124 devres_release_all(dev);
1125 arch_teardown_dma_ops(dev);
1126 dev->driver = NULL;
1127 dev_set_drvdata(dev, NULL);
1128 if (dev->pm_domain && dev->pm_domain->dismiss)
1129 dev->pm_domain->dismiss(dev);
1130 pm_runtime_reinit(dev);
1131 dev_pm_set_driver_flags(dev, 0);
1132
1133 klist_remove(&dev->p->knode_driver);
1134 device_pm_check_callbacks(dev);
1135 if (dev->bus)
1136 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1137 BUS_NOTIFY_UNBOUND_DRIVER,
1138 dev);
1139
1140 kobject_uevent(&dev->kobj, KOBJ_UNBIND);
1141 }
1142}
1143
1144void device_release_driver_internal(struct device *dev,
1145 struct device_driver *drv,
1146 struct device *parent)
1147{
1148 __device_driver_lock(dev, parent);
1149
1150 if (!drv || drv == dev->driver)
1151 __device_release_driver(dev, parent);
1152
1153 __device_driver_unlock(dev, parent);
1154}
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167void device_release_driver(struct device *dev)
1168{
1169
1170
1171
1172
1173
1174 device_release_driver_internal(dev, NULL, NULL);
1175}
1176EXPORT_SYMBOL_GPL(device_release_driver);
1177
1178
1179
1180
1181
1182
1183
1184
1185void device_driver_detach(struct device *dev)
1186{
1187 device_release_driver_internal(dev, NULL, dev->parent);
1188}
1189
1190
1191
1192
1193
1194void driver_detach(struct device_driver *drv)
1195{
1196 struct device_private *dev_prv;
1197 struct device *dev;
1198
1199 if (driver_allows_async_probing(drv))
1200 async_synchronize_full();
1201
1202 for (;;) {
1203 spin_lock(&drv->p->klist_devices.k_lock);
1204 if (list_empty(&drv->p->klist_devices.k_list)) {
1205 spin_unlock(&drv->p->klist_devices.k_lock);
1206 break;
1207 }
1208 dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
1209 struct device_private,
1210 knode_driver.n_node);
1211 dev = dev_prv->device;
1212 get_device(dev);
1213 spin_unlock(&drv->p->klist_devices.k_lock);
1214 device_release_driver_internal(dev, drv, dev->parent);
1215 put_device(dev);
1216 }
1217}
1218