2 * drivers/base/dd.c - The core device/driver interactions.
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.
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'.
12 * Copyright (c) 2002-5 Patrick Mochel
13 * Copyright (c) 2002-3 Open Source Development Labs
15 * This file is released under the GPLv2
18 #include <linux/device.h>
19 #include <linux/module.h>
22 #include "power/power.h"
24 #define to_drv(node) container_of(node, struct device_driver, kobj.entry)
28 * device_bind_driver - bind a driver to one device.
31 * Allow manual attachment of a driver to a device.
32 * Caller must have already set @dev->driver.
34 * Note that this does not modify the bus reference count
35 * nor take the bus's rwsem. Please verify those are accounted
36 * for before calling this. (It is ok to call with no other effort
37 * from a driver's probe() method.)
39 void device_bind_driver(struct device
* dev
)
41 pr_debug("bound device '%s' to driver '%s'\n",
42 dev
->bus_id
, dev
->driver
->name
);
43 klist_add_tail(&dev
->driver
->klist_devices
, &dev
->knode_driver
);
44 sysfs_create_link(&dev
->driver
->kobj
, &dev
->kobj
,
45 kobject_name(&dev
->kobj
));
46 sysfs_create_link(&dev
->kobj
, &dev
->driver
->kobj
, "driver");
50 * driver_probe_device - attempt to bind device & driver.
54 * First, we call the bus's match function, if one present, which
55 * should compare the device IDs the driver supports with the
56 * device IDs of the device. Note we don't do this ourselves
57 * because we don't know the format of the ID structures, nor what
58 * is to be considered a match and what is not.
60 * If we find a match, we call @drv->probe(@dev) if it exists, and
61 * call device_bind_driver() above.
63 int driver_probe_device(struct device_driver
* drv
, struct device
* dev
)
67 if (drv
->bus
->match
&& !drv
->bus
->match(dev
, drv
))
73 error
= drv
->probe(dev
);
81 device_bind_driver(dev
);
85 static int __device_attach(struct device_driver
* drv
, void * data
)
87 struct device
* dev
= data
;
90 error
= driver_probe_device(drv
, dev
);
92 if (error
== -ENODEV
&& error
== -ENXIO
) {
93 /* Driver matched, but didn't support device
94 * or device not found.
95 * Not an error; keep going.
99 /* driver matched but the probe failed */
101 "%s: probe of %s failed with error %d\n",
102 drv
->name
, dev
->bus_id
, error
);
108 * device_attach - try to attach device to a driver.
111 * Walk the list of drivers that the bus has and call
112 * driver_probe_device() for each pair. If a compatible
113 * pair is found, break out and return.
115 int device_attach(struct device
* dev
)
118 device_bind_driver(dev
);
122 return bus_for_each_drv(dev
->bus
, NULL
, dev
, __device_attach
);
125 static int __driver_attach(struct device
* dev
, void * data
)
127 struct device_driver
* drv
= data
;
131 error
= driver_probe_device(drv
, dev
);
133 if (error
!= -ENODEV
) {
134 /* driver matched but the probe failed */
136 "%s: probe of %s failed with error %d\n",
137 drv
->name
, dev
->bus_id
, error
);
146 * driver_attach - try to bind driver to devices.
149 * Walk the list of devices that the bus has on it and try to
150 * match the driver with each one. If driver_probe_device()
151 * returns 0 and the @dev->driver is set, we've found a
154 * Note that we ignore the -ENODEV error from driver_probe_device(),
155 * since it's perfectly valid for a driver not to bind to any devices.
157 void driver_attach(struct device_driver
* drv
)
159 bus_for_each_dev(drv
->bus
, NULL
, drv
, __driver_attach
);
163 * device_release_driver - manually detach device from driver.
166 * Manually detach device from driver.
167 * Note that this is called without incrementing the bus
168 * reference count nor taking the bus's rwsem. Be sure that
169 * those are accounted for before calling this function.
171 void device_release_driver(struct device
* dev
)
173 struct device_driver
* drv
= dev
->driver
;
178 sysfs_remove_link(&drv
->kobj
, kobject_name(&dev
->kobj
));
179 sysfs_remove_link(&dev
->kobj
, "driver");
180 klist_del(&dev
->knode_driver
);
189 static int __remove_driver(struct device
* dev
, void * unused
)
191 device_release_driver(dev
);
196 * driver_detach - detach driver from all devices it controls.
199 void driver_detach(struct device_driver
* drv
)
201 driver_for_each_device(drv
, NULL
, NULL
, __remove_driver
);
205 EXPORT_SYMBOL_GPL(driver_probe_device
);
206 EXPORT_SYMBOL_GPL(device_bind_driver
);
207 EXPORT_SYMBOL_GPL(device_release_driver
);
208 EXPORT_SYMBOL_GPL(device_attach
);
209 EXPORT_SYMBOL_GPL(driver_attach
);
This page took 0.087004 seconds and 6 git commands to generate.