Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/base/dd.c

  1 /*
  2  * drivers/base/dd.c - The core device/driver interactions.
  3  *
  4  * This file contains the (sometimes tricky) code that controls the
  5  * interactions between devices and drivers, which primarily includes
  6  * driver binding and unbinding.
  7  *
  8  * All of this code used to exist in drivers/base/bus.c, but was
  9  * relocated to here in the name of compartmentalization (since it wasn't
 10  * strictly code just for the 'struct bus_type'.
 11  *
 12  * Copyright (c) 2002-5 Patrick Mochel
 13  * Copyright (c) 2002-3 Open Source Development Labs
 14  * Copyright (c) 2007-2009 Greg Kroah-Hartman <gregkh@suse.de>
 15  * Copyright (c) 2007-2009 Novell Inc.
 16  *
 17  * This file is released under the GPLv2
 18  */
 19 
 20 #include <linux/device.h>
 21 #include <linux/delay.h>
 22 #include <linux/module.h>
 23 #include <linux/kthread.h>
 24 #include <linux/wait.h>
 25 #include <linux/async.h>
 26 #include <linux/pm_runtime.h>
 27 #include <linux/pinctrl/devinfo.h>
 28 
 29 #include "base.h"
 30 #include "power/power.h"
 31 
 32 /*
 33  * Deferred Probe infrastructure.
 34  *
 35  * Sometimes driver probe order matters, but the kernel doesn't always have
 36  * dependency information which means some drivers will get probed before a
 37  * resource it depends on is available.  For example, an SDHCI driver may
 38  * first need a GPIO line from an i2c GPIO controller before it can be
 39  * initialized.  If a required resource is not available yet, a driver can
 40  * request probing to be deferred by returning -EPROBE_DEFER from its probe hook
 41  *
 42  * Deferred probe maintains two lists of devices, a pending list and an active
 43  * list.  A driver returning -EPROBE_DEFER causes the device to be added to the
 44  * pending list.  A successful driver probe will trigger moving all devices
 45  * from the pending to the active list so that the workqueue will eventually
 46  * retry them.
 47  *
 48  * The deferred_probe_mutex must be held any time the deferred_probe_*_list
 49  * of the (struct device*)->p->deferred_probe pointers are manipulated
 50  */
 51 static DEFINE_MUTEX(deferred_probe_mutex);
 52 static LIST_HEAD(deferred_probe_pending_list);
 53 static LIST_HEAD(deferred_probe_active_list);
 54 static atomic_t deferred_trigger_count = ATOMIC_INIT(0);
 55 
 56 /*
 57  * In some cases, like suspend to RAM or hibernation, It might be reasonable
 58  * to prohibit probing of devices as it could be unsafe.
 59  * Once defer_all_probes is true all drivers probes will be forcibly deferred.
 60  */
 61 static bool defer_all_probes;
 62 
 63 /*
 64  * deferred_probe_work_func() - Retry probing devices in the active list.
 65  */
 66 static void deferred_probe_work_func(struct work_struct *work)
 67 {
 68         struct device *dev;
 69         struct device_private *private;
 70         /*
 71          * This block processes every device in the deferred 'active' list.
 72          * Each device is removed from the active list and passed to
 73          * bus_probe_device() to re-attempt the probe.  The loop continues
 74          * until every device in the active list is removed and retried.
 75          *
 76          * Note: Once the device is removed from the list and the mutex is
 77          * released, it is possible for the device get freed by another thread
 78          * and cause a illegal pointer dereference.  This code uses
 79          * get/put_device() to ensure the device structure cannot disappear
 80          * from under our feet.
 81          */
 82         mutex_lock(&deferred_probe_mutex);
 83         while (!list_empty(&deferred_probe_active_list)) {
 84                 private = list_first_entry(&deferred_probe_active_list,
 85                                         typeof(*dev->p), deferred_probe);
 86                 dev = private->device;
 87                 list_del_init(&private->deferred_probe);
 88 
 89                 get_device(dev);
 90 
 91                 /*
 92                  * Drop the mutex while probing each device; the probe path may
 93                  * manipulate the deferred list
 94                  */
 95                 mutex_unlock(&deferred_probe_mutex);
 96 
 97                 /*
 98                  * Force the device to the end of the dpm_list since
 99                  * the PM code assumes that the order we add things to
100                  * the list is a good order for suspend but deferred
101                  * probe makes that very unsafe.
102                  */
103                 device_pm_lock();
104                 device_pm_move_last(dev);
105                 device_pm_unlock();
106 
107                 dev_dbg(dev, "Retrying from deferred list\n");
108                 bus_probe_device(dev);
109 
110                 mutex_lock(&deferred_probe_mutex);
111 
112                 put_device(dev);
113         }
114         mutex_unlock(&deferred_probe_mutex);
115 }
116 static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func);
117 
118 static void driver_deferred_probe_add(struct device *dev)
119 {
120         mutex_lock(&deferred_probe_mutex);
121         if (list_empty(&dev->p->deferred_probe)) {
122                 dev_dbg(dev, "Added to deferred list\n");
123                 list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list);
124         }
125         mutex_unlock(&deferred_probe_mutex);
126 }
127 
128 void driver_deferred_probe_del(struct device *dev)
129 {
130         mutex_lock(&deferred_probe_mutex);
131         if (!list_empty(&dev->p->deferred_probe)) {
132                 dev_dbg(dev, "Removed from deferred list\n");
133                 list_del_init(&dev->p->deferred_probe);
134         }
135         mutex_unlock(&deferred_probe_mutex);
136 }
137 
138 static bool driver_deferred_probe_enable = false;
139 /**
140  * driver_deferred_probe_trigger() - Kick off re-probing deferred devices
141  *
142  * This functions moves all devices from the pending list to the active
143  * list and schedules the deferred probe workqueue to process them.  It
144  * should be called anytime a driver is successfully bound to a device.
145  *
146  * Note, there is a race condition in multi-threaded probe. In the case where
147  * more than one device is probing at the same time, it is possible for one
148  * probe to complete successfully while another is about to defer. If the second
149  * depends on the first, then it will get put on the pending list after the
150  * trigger event has already occurred and will be stuck there.
151  *
152  * The atomic 'deferred_trigger_count' is used to determine if a successful
153  * trigger has occurred in the midst of probing a driver. If the trigger count
154  * changes in the midst of a probe, then deferred processing should be triggered
155  * again.
156  */
157 static void driver_deferred_probe_trigger(void)
158 {
159         if (!driver_deferred_probe_enable)
160                 return;
161 
162         /*
163          * A successful probe means that all the devices in the pending list
164          * should be triggered to be reprobed.  Move all the deferred devices
165          * into the active list so they can be retried by the workqueue
166          */
167         mutex_lock(&deferred_probe_mutex);
168         atomic_inc(&deferred_trigger_count);
169         list_splice_tail_init(&deferred_probe_pending_list,
170                               &deferred_probe_active_list);
171         mutex_unlock(&deferred_probe_mutex);
172 
173         /*
174          * Kick the re-probe thread.  It may already be scheduled, but it is
175          * safe to kick it again.
176          */
177         schedule_work(&deferred_probe_work);
178 }
179 
180 /**
181  * device_block_probing() - Block/defere device's probes
182  *
183  *      It will disable probing of devices and defer their probes instead.
184  */
185 void device_block_probing(void)
186 {
187         defer_all_probes = true;
188         /* sync with probes to avoid races. */
189         wait_for_device_probe();
190 }
191 
192 /**
193  * device_unblock_probing() - Unblock/enable device's probes
194  *
195  *      It will restore normal behavior and trigger re-probing of deferred
196  * devices.
197  */
198 void device_unblock_probing(void)
199 {
200         defer_all_probes = false;
201         driver_deferred_probe_trigger();
202 }
203 
204 /**
205  * deferred_probe_initcall() - Enable probing of deferred devices
206  *
207  * We don't want to get in the way when the bulk of drivers are getting probed.
208  * Instead, this initcall makes sure that deferred probing is delayed until
209  * late_initcall time.
210  */
211 static int deferred_probe_initcall(void)
212 {
213         driver_deferred_probe_enable = true;
214         driver_deferred_probe_trigger();
215         /* Sort as many dependencies as possible before exiting initcalls */
216         flush_work(&deferred_probe_work);
217         return 0;
218 }
219 late_initcall(deferred_probe_initcall);
220 
221 /**
222  * device_is_bound() - Check if device is bound to a driver
223  * @dev: device to check
224  *
225  * Returns true if passed device has already finished probing successfully
226  * against a driver.
227  *
228  * This function must be called with the device lock held.
229  */
230 bool device_is_bound(struct device *dev)
231 {
232         return dev->p && klist_node_attached(&dev->p->knode_driver);
233 }
234 
235 static void driver_bound(struct device *dev)
236 {
237         if (device_is_bound(dev)) {
238                 printk(KERN_WARNING "%s: device %s already bound\n",
239                         __func__, kobject_name(&dev->kobj));
240                 return;
241         }
242 
243         pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->driver->name,
244                  __func__, dev_name(dev));
245 
246         klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
247         device_links_driver_bound(dev);
248 
249         device_pm_check_callbacks(dev);
250 
251         /*
252          * Make sure the device is no longer in one of the deferred lists and
253          * kick off retrying all pending devices
254          */
255         driver_deferred_probe_del(dev);
256         driver_deferred_probe_trigger();
257 
258         if (dev->bus)
259                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
260                                              BUS_NOTIFY_BOUND_DRIVER, dev);
261 }
262 
263 static int driver_sysfs_add(struct device *dev)
264 {
265         int ret;
266 
267         if (dev->bus)
268                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
269                                              BUS_NOTIFY_BIND_DRIVER, dev);
270 
271         ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
272                           kobject_name(&dev->kobj));
273         if (ret == 0) {
274                 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,
275                                         "driver");
276                 if (ret)
277                         sysfs_remove_link(&dev->driver->p->kobj,
278                                         kobject_name(&dev->kobj));
279         }
280         return ret;
281 }
282 
283 static void driver_sysfs_remove(struct device *dev)
284 {
285         struct device_driver *drv = dev->driver;
286 
287         if (drv) {
288                 sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));
289                 sysfs_remove_link(&dev->kobj, "driver");
290         }
291 }
292 
293 /**
294  * device_bind_driver - bind a driver to one device.
295  * @dev: device.
296  *
297  * Allow manual attachment of a driver to a device.
298  * Caller must have already set @dev->driver.
299  *
300  * Note that this does not modify the bus reference count
301  * nor take the bus's rwsem. Please verify those are accounted
302  * for before calling this. (It is ok to call with no other effort
303  * from a driver's probe() method.)
304  *
305  * This function must be called with the device lock held.
306  */
307 int device_bind_driver(struct device *dev)
308 {
309         int ret;
310 
311         ret = driver_sysfs_add(dev);
312         if (!ret)
313                 driver_bound(dev);
314         else if (dev->bus)
315                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
316                                              BUS_NOTIFY_DRIVER_NOT_BOUND, dev);
317         return ret;
318 }
319 EXPORT_SYMBOL_GPL(device_bind_driver);
320 
321 static atomic_t probe_count = ATOMIC_INIT(0);
322 static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
323 
324 static int really_probe(struct device *dev, struct device_driver *drv)
325 {
326         int ret = -EPROBE_DEFER;
327         int local_trigger_count = atomic_read(&deferred_trigger_count);
328         bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) &&
329                            !drv->suppress_bind_attrs;
330 
331         if (defer_all_probes) {
332                 /*
333                  * Value of defer_all_probes can be set only by
334                  * device_defer_all_probes_enable() which, in turn, will call
335                  * wait_for_device_probe() right after that to avoid any races.
336                  */
337                 dev_dbg(dev, "Driver %s force probe deferral\n", drv->name);
338                 driver_deferred_probe_add(dev);
339                 return ret;
340         }
341 
342         ret = device_links_check_suppliers(dev);
343         if (ret)
344                 return ret;
345 
346         atomic_inc(&probe_count);
347         pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
348                  drv->bus->name, __func__, drv->name, dev_name(dev));
349         WARN_ON(!list_empty(&dev->devres_head));
350 
351 re_probe:
352         dev->driver = drv;
353 
354         /* If using pinctrl, bind pins now before probing */
355         ret = pinctrl_bind_pins(dev);
356         if (ret)
357                 goto pinctrl_bind_failed;
358 
359         if (driver_sysfs_add(dev)) {
360                 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
361                         __func__, dev_name(dev));
362                 goto probe_failed;
363         }
364 
365         if (dev->pm_domain && dev->pm_domain->activate) {
366                 ret = dev->pm_domain->activate(dev);
367                 if (ret)
368                         goto probe_failed;
369         }
370 
371         /*
372          * Ensure devices are listed in devices_kset in correct order
373          * It's important to move Dev to the end of devices_kset before
374          * calling .probe, because it could be recursive and parent Dev
375          * should always go first
376          */
377         devices_kset_move_last(dev);
378 
379         if (dev->bus->probe) {
380                 ret = dev->bus->probe(dev);
381                 if (ret)
382                         goto probe_failed;
383         } else if (drv->probe) {
384                 ret = drv->probe(dev);
385                 if (ret)
386                         goto probe_failed;
387         }
388 
389         if (test_remove) {
390                 test_remove = false;
391 
392                 if (dev->bus->remove)
393                         dev->bus->remove(dev);
394                 else if (drv->remove)
395                         drv->remove(dev);
396 
397                 devres_release_all(dev);
398                 driver_sysfs_remove(dev);
399                 dev->driver = NULL;
400                 dev_set_drvdata(dev, NULL);
401                 if (dev->pm_domain && dev->pm_domain->dismiss)
402                         dev->pm_domain->dismiss(dev);
403                 pm_runtime_reinit(dev);
404 
405                 goto re_probe;
406         }
407 
408         pinctrl_init_done(dev);
409 
410         if (dev->pm_domain && dev->pm_domain->sync)
411                 dev->pm_domain->sync(dev);
412 
413         driver_bound(dev);
414         ret = 1;
415         pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
416                  drv->bus->name, __func__, dev_name(dev), drv->name);
417         goto done;
418 
419 probe_failed:
420         if (dev->bus)
421                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
422                                              BUS_NOTIFY_DRIVER_NOT_BOUND, dev);
423 pinctrl_bind_failed:
424         device_links_no_driver(dev);
425         devres_release_all(dev);
426         driver_sysfs_remove(dev);
427         dev->driver = NULL;
428         dev_set_drvdata(dev, NULL);
429         if (dev->pm_domain && dev->pm_domain->dismiss)
430                 dev->pm_domain->dismiss(dev);
431         pm_runtime_reinit(dev);
432 
433         switch (ret) {
434         case -EPROBE_DEFER:
435                 /* Driver requested deferred probing */
436                 dev_dbg(dev, "Driver %s requests probe deferral\n", drv->name);
437                 driver_deferred_probe_add(dev);
438                 /* Did a trigger occur while probing? Need to re-trigger if yes */
439                 if (local_trigger_count != atomic_read(&deferred_trigger_count))
440                         driver_deferred_probe_trigger();
441                 break;
442         case -ENODEV:
443         case -ENXIO:
444                 pr_debug("%s: probe of %s rejects match %d\n",
445                          drv->name, dev_name(dev), ret);
446                 break;
447         default:
448                 /* driver matched but the probe failed */
449                 printk(KERN_WARNING
450                        "%s: probe of %s failed with error %d\n",
451                        drv->name, dev_name(dev), ret);
452         }
453         /*
454          * Ignore errors returned by ->probe so that the next driver can try
455          * its luck.
456          */
457         ret = 0;
458 done:
459         atomic_dec(&probe_count);
460         wake_up(&probe_waitqueue);
461         return ret;
462 }
463 
464 /**
465  * driver_probe_done
466  * Determine if the probe sequence is finished or not.
467  *
468  * Should somehow figure out how to use a semaphore, not an atomic variable...
469  */
470 int driver_probe_done(void)
471 {
472         pr_debug("%s: probe_count = %d\n", __func__,
473                  atomic_read(&probe_count));
474         if (atomic_read(&probe_count))
475                 return -EBUSY;
476         return 0;
477 }
478 
479 /**
480  * wait_for_device_probe
481  * Wait for device probing to be completed.
482  */
483 void wait_for_device_probe(void)
484 {
485         /* wait for the deferred probe workqueue to finish */
486         flush_work(&deferred_probe_work);
487 
488         /* wait for the known devices to complete their probing */
489         wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
490         async_synchronize_full();
491 }
492 EXPORT_SYMBOL_GPL(wait_for_device_probe);
493 
494 /**
495  * driver_probe_device - attempt to bind device & driver together
496  * @drv: driver to bind a device to
497  * @dev: device to try to bind to the driver
498  *
499  * This function returns -ENODEV if the device is not registered,
500  * 1 if the device is bound successfully and 0 otherwise.
501  *
502  * This function must be called with @dev lock held.  When called for a
503  * USB interface, @dev->parent lock must be held as well.
504  *
505  * If the device has a parent, runtime-resume the parent before driver probing.
506  */
507 int driver_probe_device(struct device_driver *drv, struct device *dev)
508 {
509         int ret = 0;
510 
511         if (!device_is_registered(dev))
512                 return -ENODEV;
513 
514         pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
515                  drv->bus->name, __func__, dev_name(dev), drv->name);
516 
517         pm_runtime_get_suppliers(dev);
518         if (dev->parent)
519                 pm_runtime_get_sync(dev->parent);
520 
521         pm_runtime_barrier(dev);
522         ret = really_probe(dev, drv);
523         pm_request_idle(dev);
524 
525         if (dev->parent)
526                 pm_runtime_put(dev->parent);
527 
528         pm_runtime_put_suppliers(dev);
529         return ret;
530 }
531 
532 bool driver_allows_async_probing(struct device_driver *drv)
533 {
534         switch (drv->probe_type) {
535         case PROBE_PREFER_ASYNCHRONOUS:
536                 return true;
537 
538         case PROBE_FORCE_SYNCHRONOUS:
539                 return false;
540 
541         default:
542                 if (module_requested_async_probing(drv->owner))
543                         return true;
544 
545                 return false;
546         }
547 }
548 
549 struct device_attach_data {
550         struct device *dev;
551 
552         /*
553          * Indicates whether we are are considering asynchronous probing or
554          * not. Only initial binding after device or driver registration
555          * (including deferral processing) may be done asynchronously, the
556          * rest is always synchronous, as we expect it is being done by
557          * request from userspace.
558          */
559         bool check_async;
560 
561         /*
562          * Indicates if we are binding synchronous or asynchronous drivers.
563          * When asynchronous probing is enabled we'll execute 2 passes
564          * over drivers: first pass doing synchronous probing and second
565          * doing asynchronous probing (if synchronous did not succeed -
566          * most likely because there was no driver requiring synchronous
567          * probing - and we found asynchronous driver during first pass).
568          * The 2 passes are done because we can't shoot asynchronous
569          * probe for given device and driver from bus_for_each_drv() since
570          * driver pointer is not guaranteed to stay valid once
571          * bus_for_each_drv() iterates to the next driver on the bus.
572          */
573         bool want_async;
574 
575         /*
576          * We'll set have_async to 'true' if, while scanning for matching
577          * driver, we'll encounter one that requests asynchronous probing.
578          */
579         bool have_async;
580 };
581 
582 static int __device_attach_driver(struct device_driver *drv, void *_data)
583 {
584         struct device_attach_data *data = _data;
585         struct device *dev = data->dev;
586         bool async_allowed;
587         int ret;
588 
589         /*
590          * Check if device has already been claimed. This may
591          * happen with driver loading, device discovery/registration,
592          * and deferred probe processing happens all at once with
593          * multiple threads.
594          */
595         if (dev->driver)
596                 return -EBUSY;
597 
598         ret = driver_match_device(drv, dev);
599         if (ret == 0) {
600                 /* no match */
601                 return 0;
602         } else if (ret == -EPROBE_DEFER) {
603                 dev_dbg(dev, "Device match requests probe deferral\n");
604                 driver_deferred_probe_add(dev);
605         } else if (ret < 0) {
606                 dev_dbg(dev, "Bus failed to match device: %d", ret);
607                 return ret;
608         } /* ret > 0 means positive match */
609 
610         async_allowed = driver_allows_async_probing(drv);
611 
612         if (async_allowed)
613                 data->have_async = true;
614 
615         if (data->check_async && async_allowed != data->want_async)
616                 return 0;
617 
618         return driver_probe_device(drv, dev);
619 }
620 
621 static void __device_attach_async_helper(void *_dev, async_cookie_t cookie)
622 {
623         struct device *dev = _dev;
624         struct device_attach_data data = {
625                 .dev            = dev,
626                 .check_async    = true,
627                 .want_async     = true,
628         };
629 
630         device_lock(dev);
631 
632         if (dev->parent)
633                 pm_runtime_get_sync(dev->parent);
634 
635         bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver);
636         dev_dbg(dev, "async probe completed\n");
637 
638         pm_request_idle(dev);
639 
640         if (dev->parent)
641                 pm_runtime_put(dev->parent);
642 
643         device_unlock(dev);
644 
645         put_device(dev);
646 }
647 
648 static int __device_attach(struct device *dev, bool allow_async)
649 {
650         int ret = 0;
651 
652         device_lock(dev);
653         if (dev->driver) {
654                 if (device_is_bound(dev)) {
655                         ret = 1;
656                         goto out_unlock;
657                 }
658                 ret = device_bind_driver(dev);
659                 if (ret == 0)
660                         ret = 1;
661                 else {
662                         dev->driver = NULL;
663                         ret = 0;
664                 }
665         } else {
666                 struct device_attach_data data = {
667                         .dev = dev,
668                         .check_async = allow_async,
669                         .want_async = false,
670                 };
671 
672                 if (dev->parent)
673                         pm_runtime_get_sync(dev->parent);
674 
675                 ret = bus_for_each_drv(dev->bus, NULL, &data,
676                                         __device_attach_driver);
677                 if (!ret && allow_async && data.have_async) {
678                         /*
679                          * If we could not find appropriate driver
680                          * synchronously and we are allowed to do
681                          * async probes and there are drivers that
682                          * want to probe asynchronously, we'll
683                          * try them.
684                          */
685                         dev_dbg(dev, "scheduling asynchronous probe\n");
686                         get_device(dev);
687                         async_schedule(__device_attach_async_helper, dev);
688                 } else {
689                         pm_request_idle(dev);
690                 }
691 
692                 if (dev->parent)
693                         pm_runtime_put(dev->parent);
694         }
695 out_unlock:
696         device_unlock(dev);
697         return ret;
698 }
699 
700 /**
701  * device_attach - try to attach device to a driver.
702  * @dev: device.
703  *
704  * Walk the list of drivers that the bus has and call
705  * driver_probe_device() for each pair. If a compatible
706  * pair is found, break out and return.
707  *
708  * Returns 1 if the device was bound to a driver;
709  * 0 if no matching driver was found;
710  * -ENODEV if the device is not registered.
711  *
712  * When called for a USB interface, @dev->parent lock must be held.
713  */
714 int device_attach(struct device *dev)
715 {
716         return __device_attach(dev, false);
717 }
718 EXPORT_SYMBOL_GPL(device_attach);
719 
720 void device_initial_probe(struct device *dev)
721 {
722         __device_attach(dev, true);
723 }
724 
725 static int __driver_attach(struct device *dev, void *data)
726 {
727         struct device_driver *drv = data;
728         int ret;
729 
730         /*
731          * Lock device and try to bind to it. We drop the error
732          * here and always return 0, because we need to keep trying
733          * to bind to devices and some drivers will return an error
734          * simply if it didn't support the device.
735          *
736          * driver_probe_device() will spit a warning if there
737          * is an error.
738          */
739 
740         ret = driver_match_device(drv, dev);
741         if (ret == 0) {
742                 /* no match */
743                 return 0;
744         } else if (ret == -EPROBE_DEFER) {
745                 dev_dbg(dev, "Device match requests probe deferral\n");
746                 driver_deferred_probe_add(dev);
747         } else if (ret < 0) {
748                 dev_dbg(dev, "Bus failed to match device: %d", ret);
749                 return ret;
750         } /* ret > 0 means positive match */
751 
752         if (dev->parent)        /* Needed for USB */
753                 device_lock(dev->parent);
754         device_lock(dev);
755         if (!dev->driver)
756                 driver_probe_device(drv, dev);
757         device_unlock(dev);
758         if (dev->parent)
759                 device_unlock(dev->parent);
760 
761         return 0;
762 }
763 
764 /**
765  * driver_attach - try to bind driver to devices.
766  * @drv: driver.
767  *
768  * Walk the list of devices that the bus has on it and try to
769  * match the driver with each one.  If driver_probe_device()
770  * returns 0 and the @dev->driver is set, we've found a
771  * compatible pair.
772  */
773 int driver_attach(struct device_driver *drv)
774 {
775         return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
776 }
777 EXPORT_SYMBOL_GPL(driver_attach);
778 
779 /*
780  * __device_release_driver() must be called with @dev lock held.
781  * When called for a USB interface, @dev->parent lock must be held as well.
782  */
783 static void __device_release_driver(struct device *dev, struct device *parent)
784 {
785         struct device_driver *drv;
786 
787         drv = dev->driver;
788         if (drv) {
789                 if (driver_allows_async_probing(drv))
790                         async_synchronize_full();
791 
792                 while (device_links_busy(dev)) {
793                         device_unlock(dev);
794                         if (parent)
795                                 device_unlock(parent);
796 
797                         device_links_unbind_consumers(dev);
798                         if (parent)
799                                 device_lock(parent);
800 
801                         device_lock(dev);
802                         /*
803                          * A concurrent invocation of the same function might
804                          * have released the driver successfully while this one
805                          * was waiting, so check for that.
806                          */
807                         if (dev->driver != drv)
808                                 return;
809                 }
810 
811                 pm_runtime_get_sync(dev);
812                 pm_runtime_clean_up_links(dev);
813 
814                 driver_sysfs_remove(dev);
815 
816                 if (dev->bus)
817                         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
818                                                      BUS_NOTIFY_UNBIND_DRIVER,
819                                                      dev);
820 
821                 pm_runtime_put_sync(dev);
822 
823                 if (dev->bus && dev->bus->remove)
824                         dev->bus->remove(dev);
825                 else if (drv->remove)
826                         drv->remove(dev);
827 
828                 device_links_driver_cleanup(dev);
829                 devres_release_all(dev);
830                 dev->driver = NULL;
831                 dev_set_drvdata(dev, NULL);
832                 if (dev->pm_domain && dev->pm_domain->dismiss)
833                         dev->pm_domain->dismiss(dev);
834                 pm_runtime_reinit(dev);
835 
836                 klist_remove(&dev->p->knode_driver);
837                 device_pm_check_callbacks(dev);
838                 if (dev->bus)
839                         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
840                                                      BUS_NOTIFY_UNBOUND_DRIVER,
841                                                      dev);
842         }
843 }
844 
845 void device_release_driver_internal(struct device *dev,
846                                     struct device_driver *drv,
847                                     struct device *parent)
848 {
849         if (parent)
850                 device_lock(parent);
851 
852         device_lock(dev);
853         if (!drv || drv == dev->driver)
854                 __device_release_driver(dev, parent);
855 
856         device_unlock(dev);
857         if (parent)
858                 device_unlock(parent);
859 }
860 
861 /**
862  * device_release_driver - manually detach device from driver.
863  * @dev: device.
864  *
865  * Manually detach device from driver.
866  * When called for a USB interface, @dev->parent lock must be held.
867  *
868  * If this function is to be called with @dev->parent lock held, ensure that
869  * the device's consumers are unbound in advance or that their locks can be
870  * acquired under the @dev->parent lock.
871  */
872 void device_release_driver(struct device *dev)
873 {
874         /*
875          * If anyone calls device_release_driver() recursively from
876          * within their ->remove callback for the same device, they
877          * will deadlock right here.
878          */
879         device_release_driver_internal(dev, NULL, NULL);
880 }
881 EXPORT_SYMBOL_GPL(device_release_driver);
882 
883 /**
884  * driver_detach - detach driver from all devices it controls.
885  * @drv: driver.
886  */
887 void driver_detach(struct device_driver *drv)
888 {
889         struct device_private *dev_prv;
890         struct device *dev;
891 
892         for (;;) {
893                 spin_lock(&drv->p->klist_devices.k_lock);
894                 if (list_empty(&drv->p->klist_devices.k_list)) {
895                         spin_unlock(&drv->p->klist_devices.k_lock);
896                         break;
897                 }
898                 dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
899                                      struct device_private,
900                                      knode_driver.n_node);
901                 dev = dev_prv->device;
902                 get_device(dev);
903                 spin_unlock(&drv->p->klist_devices.k_lock);
904                 device_release_driver_internal(dev, drv, dev->parent);
905                 put_device(dev);
906         }
907 }
908 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us