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 * 15 * This file is released under the GPLv2 16 */ 17 18 #include <linux/device.h> 19 #include <linux/module.h> 20 21 #include "base.h" 22 #include "power/power.h" 23 24 #define to_drv(node) container_of(node, struct device_driver, kobj.entry) 25 26 27 /** 28 * device_bind_driver - bind a driver to one device. 29 * @dev: device. 30 * 31 * Allow manual attachment of a driver to a device. 32 * Caller must have already set @dev->driver. 33 * 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.) 38 * 39 * This function must be called with @dev->sem held. 40 */ 41 void device_bind_driver(struct device * dev) 42 { 43 if (klist_node_attached(&dev->knode_driver)) 44 return; 45 46 pr_debug("bound device '%s' to driver '%s'\n", 47 dev->bus_id, dev->driver->name); 48 klist_add_tail(&dev->knode_driver, &dev->driver->klist_devices); 49 sysfs_create_link(&dev->driver->kobj, &dev->kobj, 50 kobject_name(&dev->kobj)); 51 sysfs_create_link(&dev->kobj, &dev->driver->kobj, "driver"); 52 } 53 54 /** 55 * driver_probe_device - attempt to bind device & driver. 56 * @drv: driver. 57 * @dev: device. 58 * 59 * First, we call the bus's match function, if one present, which 60 * should compare the device IDs the driver supports with the 61 * device IDs of the device. Note we don't do this ourselves 62 * because we don't know the format of the ID structures, nor what 63 * is to be considered a match and what is not. 64 * 65 * This function returns 1 if a match is found, an error if one 66 * occurs (that is not -ENODEV or -ENXIO), and 0 otherwise. 67 * 68 * This function must be called with @dev->sem held. When called 69 * for a USB interface, @dev->parent->sem must be held as well. 70 */ 71 int driver_probe_device(struct device_driver * drv, struct device * dev) 72 { 73 int ret = 0; 74 75 if (drv->bus->match && !drv->bus->match(dev, drv)) 76 goto Done; 77 78 pr_debug("%s: Matched Device %s with Driver %s\n", 79 drv->bus->name, dev->bus_id, drv->name); 80 dev->driver = drv; 81 if (dev->bus->probe) { 82 ret = dev->bus->probe(dev); 83 if (ret) { 84 dev->driver = NULL; 85 goto ProbeFailed; 86 } 87 } else if (drv->probe) { 88 ret = drv->probe(dev); 89 if (ret) { 90 dev->driver = NULL; 91 goto ProbeFailed; 92 } 93 } 94 device_bind_driver(dev); 95 ret = 1; 96 pr_debug("%s: Bound Device %s to Driver %s\n", 97 drv->bus->name, dev->bus_id, drv->name); 98 goto Done; 99 100 ProbeFailed: 101 if (ret == -ENODEV || ret == -ENXIO) { 102 /* Driver matched, but didn't support device 103 * or device not found. 104 * Not an error; keep going. 105 */ 106 ret = 0; 107 } else { 108 /* driver matched but the probe failed */ 109 printk(KERN_WARNING 110 "%s: probe of %s failed with error %d\n", 111 drv->name, dev->bus_id, ret); 112 } 113 Done: 114 return ret; 115 } 116 117 static int __device_attach(struct device_driver * drv, void * data) 118 { 119 struct device * dev = data; 120 return driver_probe_device(drv, dev); 121 } 122 123 /** 124 * device_attach - try to attach device to a driver. 125 * @dev: device. 126 * 127 * Walk the list of drivers that the bus has and call 128 * driver_probe_device() for each pair. If a compatible 129 * pair is found, break out and return. 130 * 131 * Returns 1 if the device was bound to a driver; 132 * 0 if no matching device was found; error code otherwise. 133 * 134 * When called for a USB interface, @dev->parent->sem must be held. 135 */ 136 int device_attach(struct device * dev) 137 { 138 int ret = 0; 139 140 down(&dev->sem); 141 if (dev->driver) { 142 device_bind_driver(dev); 143 ret = 1; 144 } else 145 ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach); 146 up(&dev->sem); 147 return ret; 148 } 149 150 static int __driver_attach(struct device * dev, void * data) 151 { 152 struct device_driver * drv = data; 153 154 /* 155 * Lock device and try to bind to it. We drop the error 156 * here and always return 0, because we need to keep trying 157 * to bind to devices and some drivers will return an error 158 * simply if it didn't support the device. 159 * 160 * driver_probe_device() will spit a warning if there 161 * is an error. 162 */ 163 164 if (dev->parent) /* Needed for USB */ 165 down(&dev->parent->sem); 166 down(&dev->sem); 167 if (!dev->driver) 168 driver_probe_device(drv, dev); 169 up(&dev->sem); 170 if (dev->parent) 171 up(&dev->parent->sem); 172 173 return 0; 174 } 175 176 /** 177 * driver_attach - try to bind driver to devices. 178 * @drv: driver. 179 * 180 * Walk the list of devices that the bus has on it and try to 181 * match the driver with each one. If driver_probe_device() 182 * returns 0 and the @dev->driver is set, we've found a 183 * compatible pair. 184 */ 185 void driver_attach(struct device_driver * drv) 186 { 187 bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); 188 } 189 190 /** 191 * device_release_driver - manually detach device from driver. 192 * @dev: device. 193 * 194 * Manually detach device from driver. 195 * 196 * __device_release_driver() must be called with @dev->sem held. 197 * When called for a USB interface, @dev->parent->sem must be held 198 * as well. 199 */ 200 201 static void __device_release_driver(struct device * dev) 202 { 203 struct device_driver * drv; 204 205 drv = dev->driver; 206 if (drv) { 207 get_driver(drv); 208 sysfs_remove_link(&drv->kobj, kobject_name(&dev->kobj)); 209 sysfs_remove_link(&dev->kobj, "driver"); 210 klist_remove(&dev->knode_driver); 211 212 if (dev->bus && dev->bus->remove) 213 dev->bus->remove(dev); 214 else if (drv->remove) 215 drv->remove(dev); 216 dev->driver = NULL; 217 put_driver(drv); 218 } 219 } 220 221 void device_release_driver(struct device * dev) 222 { 223 /* 224 * If anyone calls device_release_driver() recursively from 225 * within their ->remove callback for the same device, they 226 * will deadlock right here. 227 */ 228 down(&dev->sem); 229 __device_release_driver(dev); 230 up(&dev->sem); 231 } 232 233 234 /** 235 * driver_detach - detach driver from all devices it controls. 236 * @drv: driver. 237 */ 238 void driver_detach(struct device_driver * drv) 239 { 240 struct device * dev; 241 242 for (;;) { 243 spin_lock(&drv->klist_devices.k_lock); 244 if (list_empty(&drv->klist_devices.k_list)) { 245 spin_unlock(&drv->klist_devices.k_lock); 246 break; 247 } 248 dev = list_entry(drv->klist_devices.k_list.prev, 249 struct device, knode_driver.n_node); 250 get_device(dev); 251 spin_unlock(&drv->klist_devices.k_lock); 252 253 if (dev->parent) /* Needed for USB */ 254 down(&dev->parent->sem); 255 down(&dev->sem); 256 if (dev->driver == drv) 257 __device_release_driver(dev); 258 up(&dev->sem); 259 if (dev->parent) 260 up(&dev->parent->sem); 261 put_device(dev); 262 } 263 } 264 265 266 EXPORT_SYMBOL_GPL(device_bind_driver); 267 EXPORT_SYMBOL_GPL(device_release_driver); 268 EXPORT_SYMBOL_GPL(device_attach); 269 EXPORT_SYMBOL_GPL(driver_attach); 270 271