Version:  2.0.40 2.2.26 2.4.37 3.12 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

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 
248         device_pm_check_callbacks(dev);
249 
250         /*
251          * Make sure the device is no longer in one of the deferred lists and
252          * kick off retrying all pending devices
253          */
254         driver_deferred_probe_del(dev);
255         driver_deferred_probe_trigger();
256 
257         if (dev->bus)
258                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
259                                              BUS_NOTIFY_BOUND_DRIVER, dev);
260 }
261 
262 static int driver_sysfs_add(struct device *dev)
263 {
264         int ret;
265 
266         if (dev->bus)
267                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
268                                              BUS_NOTIFY_BIND_DRIVER, dev);
269 
270         ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
271                           kobject_name(&dev->kobj));
272         if (ret == 0) {
273                 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,
274                                         "driver");
275                 if (ret)
276                         sysfs_remove_link(&dev->driver->p->kobj,
277                                         kobject_name(&dev->kobj));
278         }
279         return ret;
280 }
281 
282 static void driver_sysfs_remove(struct device *dev)
283 {
284         struct device_driver *drv = dev->driver;
285 
286         if (drv) {
287                 sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));
288                 sysfs_remove_link(&dev->kobj, "driver");
289         }
290 }
291 
292 /**
293  * device_bind_driver - bind a driver to one device.
294  * @dev: device.
295  *
296  * Allow manual attachment of a driver to a device.
297  * Caller must have already set @dev->driver.
298  *
299  * Note that this does not modify the bus reference count
300  * nor take the bus's rwsem. Please verify those are accounted
301  * for before calling this. (It is ok to call with no other effort
302  * from a driver's probe() method.)
303  *
304  * This function must be called with the device lock held.
305  */
306 int device_bind_driver(struct device *dev)
307 {
308         int ret;
309 
310         ret = driver_sysfs_add(dev);
311         if (!ret)
312                 driver_bound(dev);
313         else if (dev->bus)
314                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
315                                              BUS_NOTIFY_DRIVER_NOT_BOUND, dev);
316         return ret;
317 }
318 EXPORT_SYMBOL_GPL(device_bind_driver);
319 
320 static atomic_t probe_count = ATOMIC_INIT(0);
321 static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
322 
323 static int really_probe(struct device *dev, struct device_driver *drv)
324 {
325         int ret = -EPROBE_DEFER;
326         int local_trigger_count = atomic_read(&deferred_trigger_count);
327         bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) &&
328                            !drv->suppress_bind_attrs;
329 
330         if (defer_all_probes) {
331                 /*
332                  * Value of defer_all_probes can be set only by
333                  * device_defer_all_probes_enable() which, in turn, will call
334                  * wait_for_device_probe() right after that to avoid any races.
335                  */
336                 dev_dbg(dev, "Driver %s force probe deferral\n", drv->name);
337                 driver_deferred_probe_add(dev);
338                 return ret;
339         }
340 
341         atomic_inc(&probe_count);
342         pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
343                  drv->bus->name, __func__, drv->name, dev_name(dev));
344         WARN_ON(!list_empty(&dev->devres_head));
345 
346 re_probe:
347         dev->driver = drv;
348 
349         /* If using pinctrl, bind pins now before probing */
350         ret = pinctrl_bind_pins(dev);
351         if (ret)
352                 goto pinctrl_bind_failed;
353 
354         if (driver_sysfs_add(dev)) {
355                 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
356                         __func__, dev_name(dev));
357                 goto probe_failed;
358         }
359 
360         if (dev->pm_domain && dev->pm_domain->activate) {
361                 ret = dev->pm_domain->activate(dev);
362                 if (ret)
363                         goto probe_failed;
364         }
365 
366         /*
367          * Ensure devices are listed in devices_kset in correct order
368          * It's important to move Dev to the end of devices_kset before
369          * calling .probe, because it could be recursive and parent Dev
370          * should always go first
371          */
372         devices_kset_move_last(dev);
373 
374         if (dev->bus->probe) {
375                 ret = dev->bus->probe(dev);
376                 if (ret)
377                         goto probe_failed;
378         } else if (drv->probe) {
379                 ret = drv->probe(dev);
380                 if (ret)
381                         goto probe_failed;
382         }
383 
384         if (test_remove) {
385                 test_remove = false;
386 
387                 if (dev->bus->remove)
388                         dev->bus->remove(dev);
389                 else if (drv->remove)
390                         drv->remove(dev);
391 
392                 devres_release_all(dev);
393                 driver_sysfs_remove(dev);
394                 dev->driver = NULL;
395                 dev_set_drvdata(dev, NULL);
396                 if (dev->pm_domain && dev->pm_domain->dismiss)
397                         dev->pm_domain->dismiss(dev);
398                 pm_runtime_reinit(dev);
399 
400                 goto re_probe;
401         }
402 
403         pinctrl_init_done(dev);
404 
405         if (dev->pm_domain && dev->pm_domain->sync)
406                 dev->pm_domain->sync(dev);
407 
408         driver_bound(dev);
409         ret = 1;
410         pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
411                  drv->bus->name, __func__, dev_name(dev), drv->name);
412         goto done;
413 
414 probe_failed:
415         if (dev->bus)
416                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
417                                              BUS_NOTIFY_DRIVER_NOT_BOUND, dev);
418 pinctrl_bind_failed:
419         devres_release_all(dev);
420         driver_sysfs_remove(dev);
421         dev->driver = NULL;
422         dev_set_drvdata(dev, NULL);
423         if (dev->pm_domain && dev->pm_domain->dismiss)
424                 dev->pm_domain->dismiss(dev);
425         pm_runtime_reinit(dev);
426 
427         switch (ret) {
428         case -EPROBE_DEFER:
429                 /* Driver requested deferred probing */
430                 dev_dbg(dev, "Driver %s requests probe deferral\n", drv->name);
431                 driver_deferred_probe_add(dev);
432                 /* Did a trigger occur while probing? Need to re-trigger if yes */
433                 if (local_trigger_count != atomic_read(&deferred_trigger_count))
434                         driver_deferred_probe_trigger();
435                 break;
436         case -ENODEV:
437         case -ENXIO:
438                 pr_debug("%s: probe of %s rejects match %d\n",
439                          drv->name, dev_name(dev), ret);
440                 break;
441         default:
442                 /* driver matched but the probe failed */
443                 printk(KERN_WARNING
444                        "%s: probe of %s failed with error %d\n",
445                        drv->name, dev_name(dev), ret);
446         }
447         /*
448          * Ignore errors returned by ->probe so that the next driver can try
449          * its luck.
450          */
451         ret = 0;
452 done:
453         atomic_dec(&probe_count);
454         wake_up(&probe_waitqueue);
455         return ret;
456 }
457 
458 /**
459  * driver_probe_done
460  * Determine if the probe sequence is finished or not.
461  *
462  * Should somehow figure out how to use a semaphore, not an atomic variable...
463  */
464 int driver_probe_done(void)
465 {
466         pr_debug("%s: probe_count = %d\n", __func__,
467                  atomic_read(&probe_count));
468         if (atomic_read(&probe_count))
469                 return -EBUSY;
470         return 0;
471 }
472 
473 /**
474  * wait_for_device_probe
475  * Wait for device probing to be completed.
476  */
477 void wait_for_device_probe(void)
478 {
479         /* wait for the deferred probe workqueue to finish */
480         flush_work(&deferred_probe_work);
481 
482         /* wait for the known devices to complete their probing */
483         wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
484         async_synchronize_full();
485 }
486 EXPORT_SYMBOL_GPL(wait_for_device_probe);
487 
488 /**
489  * driver_probe_device - attempt to bind device & driver together
490  * @drv: driver to bind a device to
491  * @dev: device to try to bind to the driver
492  *
493  * This function returns -ENODEV if the device is not registered,
494  * 1 if the device is bound successfully and 0 otherwise.
495  *
496  * This function must be called with @dev lock held.  When called for a
497  * USB interface, @dev->parent lock must be held as well.
498  *
499  * If the device has a parent, runtime-resume the parent before driver probing.
500  */
501 int driver_probe_device(struct device_driver *drv, struct device *dev)
502 {
503         int ret = 0;
504 
505         if (!device_is_registered(dev))
506                 return -ENODEV;
507 
508         pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
509                  drv->bus->name, __func__, dev_name(dev), drv->name);
510 
511         if (dev->parent)
512                 pm_runtime_get_sync(dev->parent);
513 
514         pm_runtime_barrier(dev);
515         ret = really_probe(dev, drv);
516         pm_request_idle(dev);
517 
518         if (dev->parent)
519                 pm_runtime_put(dev->parent);
520 
521         return ret;
522 }
523 
524 bool driver_allows_async_probing(struct device_driver *drv)
525 {
526         switch (drv->probe_type) {
527         case PROBE_PREFER_ASYNCHRONOUS:
528                 return true;
529 
530         case PROBE_FORCE_SYNCHRONOUS:
531                 return false;
532 
533         default:
534                 if (module_requested_async_probing(drv->owner))
535                         return true;
536 
537                 return false;
538         }
539 }
540 
541 struct device_attach_data {
542         struct device *dev;
543 
544         /*
545          * Indicates whether we are are considering asynchronous probing or
546          * not. Only initial binding after device or driver registration
547          * (including deferral processing) may be done asynchronously, the
548          * rest is always synchronous, as we expect it is being done by
549          * request from userspace.
550          */
551         bool check_async;
552 
553         /*
554          * Indicates if we are binding synchronous or asynchronous drivers.
555          * When asynchronous probing is enabled we'll execute 2 passes
556          * over drivers: first pass doing synchronous probing and second
557          * doing asynchronous probing (if synchronous did not succeed -
558          * most likely because there was no driver requiring synchronous
559          * probing - and we found asynchronous driver during first pass).
560          * The 2 passes are done because we can't shoot asynchronous
561          * probe for given device and driver from bus_for_each_drv() since
562          * driver pointer is not guaranteed to stay valid once
563          * bus_for_each_drv() iterates to the next driver on the bus.
564          */
565         bool want_async;
566 
567         /*
568          * We'll set have_async to 'true' if, while scanning for matching
569          * driver, we'll encounter one that requests asynchronous probing.
570          */
571         bool have_async;
572 };
573 
574 static int __device_attach_driver(struct device_driver *drv, void *_data)
575 {
576         struct device_attach_data *data = _data;
577         struct device *dev = data->dev;
578         bool async_allowed;
579         int ret;
580 
581         /*
582          * Check if device has already been claimed. This may
583          * happen with driver loading, device discovery/registration,
584          * and deferred probe processing happens all at once with
585          * multiple threads.
586          */
587         if (dev->driver)
588                 return -EBUSY;
589 
590         ret = driver_match_device(drv, dev);
591         if (ret == 0) {
592                 /* no match */
593                 return 0;
594         } else if (ret == -EPROBE_DEFER) {
595                 dev_dbg(dev, "Device match requests probe deferral\n");
596                 driver_deferred_probe_add(dev);
597         } else if (ret < 0) {
598                 dev_dbg(dev, "Bus failed to match device: %d", ret);
599                 return ret;
600         } /* ret > 0 means positive match */
601 
602         async_allowed = driver_allows_async_probing(drv);
603 
604         if (async_allowed)
605                 data->have_async = true;
606 
607         if (data->check_async && async_allowed != data->want_async)
608                 return 0;
609 
610         return driver_probe_device(drv, dev);
611 }
612 
613 static void __device_attach_async_helper(void *_dev, async_cookie_t cookie)
614 {
615         struct device *dev = _dev;
616         struct device_attach_data data = {
617                 .dev            = dev,
618                 .check_async    = true,
619                 .want_async     = true,
620         };
621 
622         device_lock(dev);
623 
624         if (dev->parent)
625                 pm_runtime_get_sync(dev->parent);
626 
627         bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver);
628         dev_dbg(dev, "async probe completed\n");
629 
630         pm_request_idle(dev);
631 
632         if (dev->parent)
633                 pm_runtime_put(dev->parent);
634 
635         device_unlock(dev);
636 
637         put_device(dev);
638 }
639 
640 static int __device_attach(struct device *dev, bool allow_async)
641 {
642         int ret = 0;
643 
644         device_lock(dev);
645         if (dev->driver) {
646                 if (device_is_bound(dev)) {
647                         ret = 1;
648                         goto out_unlock;
649                 }
650                 ret = device_bind_driver(dev);
651                 if (ret == 0)
652                         ret = 1;
653                 else {
654                         dev->driver = NULL;
655                         ret = 0;
656                 }
657         } else {
658                 struct device_attach_data data = {
659                         .dev = dev,
660                         .check_async = allow_async,
661                         .want_async = false,
662                 };
663 
664                 if (dev->parent)
665                         pm_runtime_get_sync(dev->parent);
666 
667                 ret = bus_for_each_drv(dev->bus, NULL, &data,
668                                         __device_attach_driver);
669                 if (!ret && allow_async && data.have_async) {
670                         /*
671                          * If we could not find appropriate driver
672                          * synchronously and we are allowed to do
673                          * async probes and there are drivers that
674                          * want to probe asynchronously, we'll
675                          * try them.
676                          */
677                         dev_dbg(dev, "scheduling asynchronous probe\n");
678                         get_device(dev);
679                         async_schedule(__device_attach_async_helper, dev);
680                 } else {
681                         pm_request_idle(dev);
682                 }
683 
684                 if (dev->parent)
685                         pm_runtime_put(dev->parent);
686         }
687 out_unlock:
688         device_unlock(dev);
689         return ret;
690 }
691 
692 /**
693  * device_attach - try to attach device to a driver.
694  * @dev: device.
695  *
696  * Walk the list of drivers that the bus has and call
697  * driver_probe_device() for each pair. If a compatible
698  * pair is found, break out and return.
699  *
700  * Returns 1 if the device was bound to a driver;
701  * 0 if no matching driver was found;
702  * -ENODEV if the device is not registered.
703  *
704  * When called for a USB interface, @dev->parent lock must be held.
705  */
706 int device_attach(struct device *dev)
707 {
708         return __device_attach(dev, false);
709 }
710 EXPORT_SYMBOL_GPL(device_attach);
711 
712 void device_initial_probe(struct device *dev)
713 {
714         __device_attach(dev, true);
715 }
716 
717 static int __driver_attach(struct device *dev, void *data)
718 {
719         struct device_driver *drv = data;
720         int ret;
721 
722         /*
723          * Lock device and try to bind to it. We drop the error
724          * here and always return 0, because we need to keep trying
725          * to bind to devices and some drivers will return an error
726          * simply if it didn't support the device.
727          *
728          * driver_probe_device() will spit a warning if there
729          * is an error.
730          */
731 
732         ret = driver_match_device(drv, dev);
733         if (ret == 0) {
734                 /* no match */
735                 return 0;
736         } else if (ret == -EPROBE_DEFER) {
737                 dev_dbg(dev, "Device match requests probe deferral\n");
738                 driver_deferred_probe_add(dev);
739         } else if (ret < 0) {
740                 dev_dbg(dev, "Bus failed to match device: %d", ret);
741                 return ret;
742         } /* ret > 0 means positive match */
743 
744         if (dev->parent)        /* Needed for USB */
745                 device_lock(dev->parent);
746         device_lock(dev);
747         if (!dev->driver)
748                 driver_probe_device(drv, dev);
749         device_unlock(dev);
750         if (dev->parent)
751                 device_unlock(dev->parent);
752 
753         return 0;
754 }
755 
756 /**
757  * driver_attach - try to bind driver to devices.
758  * @drv: driver.
759  *
760  * Walk the list of devices that the bus has on it and try to
761  * match the driver with each one.  If driver_probe_device()
762  * returns 0 and the @dev->driver is set, we've found a
763  * compatible pair.
764  */
765 int driver_attach(struct device_driver *drv)
766 {
767         return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
768 }
769 EXPORT_SYMBOL_GPL(driver_attach);
770 
771 /*
772  * __device_release_driver() must be called with @dev lock held.
773  * When called for a USB interface, @dev->parent lock must be held as well.
774  */
775 static void __device_release_driver(struct device *dev)
776 {
777         struct device_driver *drv;
778 
779         drv = dev->driver;
780         if (drv) {
781                 if (driver_allows_async_probing(drv))
782                         async_synchronize_full();
783 
784                 pm_runtime_get_sync(dev);
785 
786                 driver_sysfs_remove(dev);
787 
788                 if (dev->bus)
789                         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
790                                                      BUS_NOTIFY_UNBIND_DRIVER,
791                                                      dev);
792 
793                 pm_runtime_put_sync(dev);
794 
795                 if (dev->bus && dev->bus->remove)
796                         dev->bus->remove(dev);
797                 else if (drv->remove)
798                         drv->remove(dev);
799                 devres_release_all(dev);
800                 dev->driver = NULL;
801                 dev_set_drvdata(dev, NULL);
802                 if (dev->pm_domain && dev->pm_domain->dismiss)
803                         dev->pm_domain->dismiss(dev);
804                 pm_runtime_reinit(dev);
805 
806                 klist_remove(&dev->p->knode_driver);
807                 device_pm_check_callbacks(dev);
808                 if (dev->bus)
809                         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
810                                                      BUS_NOTIFY_UNBOUND_DRIVER,
811                                                      dev);
812         }
813 }
814 
815 /**
816  * device_release_driver - manually detach device from driver.
817  * @dev: device.
818  *
819  * Manually detach device from driver.
820  * When called for a USB interface, @dev->parent lock must be held.
821  */
822 void device_release_driver(struct device *dev)
823 {
824         /*
825          * If anyone calls device_release_driver() recursively from
826          * within their ->remove callback for the same device, they
827          * will deadlock right here.
828          */
829         device_lock(dev);
830         __device_release_driver(dev);
831         device_unlock(dev);
832 }
833 EXPORT_SYMBOL_GPL(device_release_driver);
834 
835 /**
836  * driver_detach - detach driver from all devices it controls.
837  * @drv: driver.
838  */
839 void driver_detach(struct device_driver *drv)
840 {
841         struct device_private *dev_prv;
842         struct device *dev;
843 
844         for (;;) {
845                 spin_lock(&drv->p->klist_devices.k_lock);
846                 if (list_empty(&drv->p->klist_devices.k_list)) {
847                         spin_unlock(&drv->p->klist_devices.k_lock);
848                         break;
849                 }
850                 dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
851                                      struct device_private,
852                                      knode_driver.n_node);
853                 dev = dev_prv->device;
854                 get_device(dev);
855                 spin_unlock(&drv->p->klist_devices.k_lock);
856 
857                 if (dev->parent)        /* Needed for USB */
858                         device_lock(dev->parent);
859                 device_lock(dev);
860                 if (dev->driver == drv)
861                         __device_release_driver(dev);
862                 device_unlock(dev);
863                 if (dev->parent)
864                         device_unlock(dev->parent);
865                 put_device(dev);
866         }
867 }
868 

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