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