| Start/ | End/ | |||
| True | False | - | Line | Source |
| 1 | /* | |||
| 2 | * bus.c - bus driver management | |||
| 3 | * | |||
| 4 | * Copyright (c) 2002-3 Patrick Mochel | |||
| 5 | * Copyright (c) 2002-3 Open Source Development Labs | |||
| 6 | * | |||
| 7 | * This file is released under the GPLv2 | |||
| 8 | * | |||
| 9 | */ | |||
| 10 | ||||
| 11 | #include <linux/config.h> | |||
| 12 | #include <linux/device.h> | |||
| 13 | #include <linux/module.h> | |||
| 14 | #include <linux/errno.h> | |||
| 15 | #include <linux/init.h> | |||
| 16 | #include <linux/string.h> | |||
| 17 | #include "base.h" | |||
| 18 | #include "power/power.h" | |||
| 19 | ||||
| 20 | #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr) | |||
| 21 | #define to_bus(obj) container_of(obj, struct bus_type, subsys.kset.kobj) | |||
| 22 | ||||
| 23 | /* | |||
| 24 | * sysfs bindings for drivers | |||
| 25 | */ | |||
| 26 | ||||
| 27 | #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr) | |||
| 28 | #define to_driver(obj) container_of(obj, struct device_driver, kobj) | |||
| 29 | ||||
| 30 | ||||
| 31 | static ssize_t | |||
| 0 | 0 | - | 32 | drv_attr_show(struct kobject * kobj, struct attribute * attr, char * buf) |
| 33 | { | |||
| 34 | struct driver_attribute * drv_attr = to_drv_attr(attr); | |||
| 35 | struct device_driver * drv = to_driver(kobj); | |||
| 36 | ssize_t ret = -EIO; | |||
| 37 | ||||
| 0 | 0 | - | 38 | if (drv_attr->show) |
| 39 | ret = drv_attr->show(drv, buf); | |||
| 0 | - | 40 | return ret; | |
| 41 | } | |||
| 42 | ||||
| 43 | static ssize_t | |||
| 0 | 0 | - | 44 | drv_attr_store(struct kobject * kobj, struct attribute * attr, |
| 45 | const char * buf, size_t count) | |||
| 46 | { | |||
| 47 | struct driver_attribute * drv_attr = to_drv_attr(attr); | |||
| 48 | struct device_driver * drv = to_driver(kobj); | |||
| 49 | ssize_t ret = -EIO; | |||
| 50 | ||||
| 0 | 0 | - | 51 | if (drv_attr->store) |
| 52 | ret = drv_attr->store(drv, buf, count); | |||
| 0 | - | 53 | return ret; | |
| 54 | } | |||
| 55 | ||||
| 56 | static struct sysfs_ops driver_sysfs_ops = { | |||
| 57 | .show = drv_attr_show, | |||
| 58 | .store = drv_attr_store, | |||
| 59 | }; | |||
| 60 | ||||
| 61 | ||||
| 0 | 0 | - | 62 | static void driver_release(struct kobject * kobj) |
| 63 | { | |||
| 64 | struct device_driver * drv = to_driver(kobj); | |||
| 65 | complete(&drv->unloaded); | |||
| 66 | } | |||
| 67 | ||||
| 68 | static struct kobj_type ktype_driver = { | |||
| 69 | .sysfs_ops = &driver_sysfs_ops, | |||
| 70 | .release = driver_release, | |||
| 71 | }; | |||
| 72 | ||||
| 73 | ||||
| 74 | /* | |||
| 75 | * sysfs bindings for buses | |||
| 76 | */ | |||
| 77 | ||||
| 78 | ||||
| 79 | static ssize_t | |||
| 0 | 0 | - | 80 | bus_attr_show(struct kobject * kobj, struct attribute * attr, char * buf) |
| 81 | { | |||
| 82 | struct bus_attribute * bus_attr = to_bus_attr(attr); | |||
| 83 | struct bus_type * bus = to_bus(kobj); | |||
| 84 | ssize_t ret = 0; | |||
| 85 | ||||
| 0 | 0 | - | 86 | if (bus_attr->show) |
| 87 | ret = bus_attr->show(bus, buf); | |||
| 0 | - | 88 | return ret; | |
| 89 | } | |||
| 90 | ||||
| 91 | static ssize_t | |||
| 0 | 0 | - | 92 | bus_attr_store(struct kobject * kobj, struct attribute * attr, |
| 93 | const char * buf, size_t count) | |||
| 94 | { | |||
| 95 | struct bus_attribute * bus_attr = to_bus_attr(attr); | |||
| 96 | struct bus_type * bus = to_bus(kobj); | |||
| 97 | ssize_t ret = 0; | |||
| 98 | ||||
| 0 | 0 | - | 99 | if (bus_attr->store) |
| 100 | ret = bus_attr->store(bus, buf, count); | |||
| 0 | - | 101 | return ret; | |
| 102 | } | |||
| 103 | ||||
| 104 | static struct sysfs_ops bus_sysfs_ops = { | |||
| 105 | .show = bus_attr_show, | |||
| 106 | .store = bus_attr_store, | |||
| 107 | }; | |||
| 108 | ||||
| 18 | 0 | 109 | int bus_create_file(struct bus_type * bus, struct bus_attribute * attr) | |
| 110 | { | |||
| 111 | int error; | |||
| 18 | 0 | - | 112 | if (get_bus(bus)) { |
| 113 | error = sysfs_create_file(&bus->subsys.kset.kobj, &attr->attr); | |||
| 114 | put_bus(bus); | |||
| 115 | } else | |||
| 116 | error = -EINVAL; | |||
| 18 | 117 | return error; | ||
| 118 | } | |||
| 119 | ||||
| 0 | 0 | - | 120 | void bus_remove_file(struct bus_type * bus, struct bus_attribute * attr) |
| 121 | { | |||
| 0 | 0 | - | 122 | if (get_bus(bus)) { |
| 123 | sysfs_remove_file(&bus->subsys.kset.kobj, &attr->attr); | |||
| 124 | put_bus(bus); | |||
| 125 | } | |||
| 126 | } | |||
| 127 | ||||
| 128 | static struct kobj_type ktype_bus = { | |||
| 129 | .sysfs_ops = &bus_sysfs_ops, | |||
| 130 | ||||
| 131 | }; | |||
| 132 | ||||
| 133 | decl_subsys(bus, &ktype_bus, NULL); | |||
| 134 | ||||
| 135 | ||||
| 136 | #ifdef CONFIG_HOTPLUG | |||
| 137 | ||||
| 138 | /* Manually detach a device from its associated driver. */ | |||
| 0 | 0 | - | 139 | static int driver_helper(struct device *dev, void *data) |
| 140 | { | |||
| 141 | const char *name = data; | |||
| 142 | ||||
| 0 | 0 | - | 143 | if (strcmp(name, dev->bus_id) == 0) |
| 0 | - | 144 | return 1; | |
| 0 | - | 145 | return 0; | |
| 146 | } | |||
| 147 | ||||
| 0 | 0 | - | 148 | static ssize_t driver_unbind(struct device_driver *drv, |
| 149 | const char *buf, size_t count) | |||
| 150 | { | |||
| 151 | struct bus_type *bus = get_bus(drv->bus); | |||
| 152 | struct device *dev; | |||
| 153 | int err = -ENODEV; | |||
| 154 | ||||
| 155 | dev = bus_find_device(bus, NULL, (void *)buf, driver_helper); | |||
| 0 | 0 | - | 156 | if (dev && dev->driver == drv) { |
| 0 | - | 156 | T && T | |
| 0 | - | 156 | T && F | |
| 0 | - | 156 | F && _ | |
| 0 | 0 | - | 157 | if (dev->parent) /* Needed for USB */ |
| 158 | down(&dev->parent->sem); | |||
| 159 | device_release_driver(dev); | |||
| 0 | 0 | - | 160 | if (dev->parent) |
| 161 | up(&dev->parent->sem); | |||
| 162 | err = count; | |||
| 163 | } | |||
| 164 | put_device(dev); | |||
| 165 | put_bus(bus); | |||
| 0 | - | 166 | return err; | |
| 167 | } | |||
| 168 | static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind); | |||
| 169 | ||||
| 170 | /* | |||
| 171 | * Manually attach a device to a driver. | |||
| 172 | * Note: the driver must want to bind to the device, | |||
| 173 | * it is not possible to override the driver's id table. | |||
| 174 | */ | |||
| 0 | 0 | - | 175 | static ssize_t driver_bind(struct device_driver *drv, |
| 176 | const char *buf, size_t count) | |||
| 177 | { | |||
| 178 | struct bus_type *bus = get_bus(drv->bus); | |||
| 179 | struct device *dev; | |||
| 180 | int err = -ENODEV; | |||
| 181 | ||||
| 182 | dev = bus_find_device(bus, NULL, (void *)buf, driver_helper); | |||
| 0 | 0 | - | 183 | if (dev && dev->driver == NULL) { |
| 0 | - | 183 | T && T | |
| 0 | - | 183 | T && F | |
| 0 | - | 183 | F && _ | |
| 0 | 0 | - | 184 | if (dev->parent) /* Needed for USB */ |
| 185 | down(&dev->parent->sem); | |||
| 186 | down(&dev->sem); | |||
| 187 | err = driver_probe_device(drv, dev); | |||
| 188 | up(&dev->sem); | |||
| 0 | 0 | - | 189 | if (dev->parent) |
| 190 | up(&dev->parent->sem); | |||
| 191 | } | |||
| 192 | put_device(dev); | |||
| 193 | put_bus(bus); | |||
| 0 | - | 194 | return err; | |
| 195 | } | |||
| 196 | static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind); | |||
| 197 | ||||
| 198 | #endif | |||
| 199 | ||||
| 2262 | 0 | 200 | static struct device * next_device(struct klist_iter * i) | |
| 201 | { | |||
| 202 | struct klist_node * n = klist_next(i); | |||
| 203 | return n ? container_of(n, struct device, knode_bus) : NULL; | |||
| 2009 | 253 | 203 | ternary-?: n | |
| 2262 | 203 | return n ? ( { const typeof ( ( ( struct devic.. | ||
| 204 | } | |||
| 205 | ||||
| 206 | /** | |||
| 207 | * bus_for_each_dev - device iterator. | |||
| 208 | * @bus: bus type. | |||
| 209 | * @start: device to start iterating from. | |||
| 210 | * @data: data for the callback. | |||
| 211 | * @fn: function to be called for each device. | |||
| 212 | * | |||
| 213 | * Iterate over @bus's list of devices, and call @fn for each, | |||
| 214 | * passing it @data. If @start is not NULL, we use that device to | |||
| 215 | * begin iterating from. | |||
| 216 | * | |||
| 217 | * We check the return of @fn each time. If it returns anything | |||
| 218 | * other than 0, we break out and return that value. | |||
| 219 | * | |||
| 220 | * NOTE: The device that returns a non-zero value is not retained | |||
| 221 | * in any way, nor is its refcount incremented. If the caller needs | |||
| 222 | * to retain this data, it should do, and increment the reference | |||
| 223 | * count in the supplied callback. | |||
| 224 | */ | |||
| 225 | ||||
| 253 | 0 | 226 | int bus_for_each_dev(struct bus_type * bus, struct device * start, | |
| 227 | void * data, int (*fn)(struct device *, void *)) | |||
| 228 | { | |||
| 229 | struct klist_iter i; | |||
| 230 | struct device * dev; | |||
| 231 | int error = 0; | |||
| 232 | ||||
| 0 | 253 | - | 233 | if (!bus) |
| 0 | - | 234 | return -EINVAL; | |
| 235 | ||||
| 236 | klist_iter_init_node(&bus->klist_devices, &i, | |||
| 237 | (start ? &start->knode_bus : NULL)); | |||
| 0 | 253 | - | 237 | ternary-?: start |
| 2009 | 253 | 238 | while ((dev = next_device(&i)) && !error) | |
| 2009 | 238 | (T) && T | ||
| 0 | - | 238 | (T) && F | |
| 253 | 238 | (F) && _ | ||
| 239 | error = fn(dev, data); | |||
| 240 | klist_iter_exit(&i); | |||
| 253 | 241 | return error; | ||
| 242 | } | |||
| 243 | ||||
| 244 | /** | |||
| 245 | * bus_find_device - device iterator for locating a particular device. | |||
| 246 | * @bus: bus type | |||
| 247 | * @start: Device to begin with | |||
| 248 | * @data: Data to pass to match function | |||
| 249 | * @match: Callback function to check device | |||
| 250 | * | |||
| 251 | * This is similar to the bus_for_each_dev() function above, but it | |||
| 252 | * returns a reference to a device that is 'found' for later use, as | |||
| 253 | * determined by the @match callback. | |||
| 254 | * | |||
| 255 | * The callback should return 0 if the device doesn't match and non-zero | |||
| 256 | * if it does. If the callback returns non-zero, this function will | |||
| 257 | * return to the caller and not iterate over any more devices. | |||
| 258 | */ | |||
| 0 | 0 | - | 259 | struct device * bus_find_device(struct bus_type *bus, |
| 260 | struct device *start, void *data, | |||
| 261 | int (*match)(struct device *, void *)) | |||
| 262 | { | |||
| 263 | struct klist_iter i; | |||
| 264 | struct device *dev; | |||
| 265 | ||||
| 0 | 0 | - | 266 | if (!bus) |
| 0 | - | 267 | return NULL; | |
| 268 | ||||
| 269 | klist_iter_init_node(&bus->klist_devices, &i, | |||
| 270 | (start ? &start->knode_bus : NULL)); | |||
| 0 | 0 | - | 270 | ternary-?: start |
| 0 | 0 | - | 271 | while ((dev = next_device(&i))) |
| 0 | 0 | - | 272 | if (match(dev, data) && get_device(dev)) |
| 0 | - | 272 | T && T | |
| 0 | - | 272 | T && F | |
| 0 | - | 272 | F && _ | |
| 0 | - | 273 | break; | |
| 274 | klist_iter_exit(&i); | |||
| 0 | - | 275 | return dev; | |
| 276 | } | |||
| 277 | ||||
| 278 | ||||
| 366 | 0 | 279 | static struct device_driver * next_driver(struct klist_iter * i) | |
| 280 | { | |||
| 281 | struct klist_node * n = klist_next(i); | |||
| 282 | return n ? container_of(n, struct device_driver, knode_bus) : NULL; | |||
| 153 | 213 | 282 | ternary-?: n | |
| 366 | 282 | return n ? ( { const typeof ( ( ( struct devic.. | ||
| 283 | } | |||
| 284 | ||||
| 285 | /** | |||
| 286 | * bus_for_each_drv - driver iterator | |||
| 287 | * @bus: bus we're dealing with. | |||
| 288 | * @start: driver to start iterating on. | |||
| 289 | * @data: data to pass to the callback. | |||
| 290 | * @fn: function to call for each driver. | |||
| 291 | * | |||
| 292 | * This is nearly identical to the device iterator above. | |||
| 293 | * We iterate over each driver that belongs to @bus, and call | |||
| 294 | * @fn for each. If @fn returns anything but 0, we break out | |||
| 295 | * and return it. If @start is not NULL, we use it as the head | |||
| 296 | * of the list. | |||
| 297 | * | |||
| 298 | * NOTE: we don't return the driver that returns a non-zero | |||
| 299 | * value, nor do we leave the reference count incremented for that | |||
| 300 | * driver. If the caller needs to know that info, it must set it | |||
| 301 | * in the callback. It must also be sure to increment the refcount | |||
| 302 | * so it doesn't disappear before returning to the caller. | |||
| 303 | */ | |||
| 304 | ||||
| 241 | 0 | 305 | int bus_for_each_drv(struct bus_type * bus, struct device_driver * start, | |
| 306 | void * data, int (*fn)(struct device_driver *, void *)) | |||
| 307 | { | |||
| 308 | struct klist_iter i; | |||
| 309 | struct device_driver * drv; | |||
| 310 | int error = 0; | |||
| 311 | ||||
| 0 | 241 | - | 312 | if (!bus) |
| 0 | - | 313 | return -EINVAL; | |
| 314 | ||||
| 315 | klist_iter_init_node(&bus->klist_drivers, &i, | |||
| 316 | start ? &start->knode_bus : NULL); | |||
| 0 | 241 | - | 316 | ternary-?: start |
| 125 | 241 | 317 | while ((drv = next_driver(&i)) && !error) | |
| 125 | 317 | (T) && T | ||
| 28 | 317 | (T) && F | ||
| 213 | 317 | (F) && _ | ||
| 318 | error = fn(drv, data); | |||
| 319 | klist_iter_exit(&i); | |||
| 241 | 320 | return error; | ||
| 321 | } | |||
| 322 | ||||
| 260 | 0 | 323 | static int device_add_attrs(struct bus_type * bus, struct device * dev) | |
| 324 | { | |||
| 325 | int error = 0; | |||
| 326 | int i; | |||
| 327 | ||||
| 138 | 122 | 328 | if (bus->dev_attrs) { | |
| 1110 | 138 | 329 | for (i = 0; attr_name(bus->dev_attrs[i]); i++) { | |
| 330 | error = device_create_file(dev,&bus->dev_attrs[i]); | |||
| 0 | 1110 | - | 331 | if (error) |
| 0 | - | 332 | goto Err; | |
| 333 | } | |||
| 334 | } | |||
| 335 | Done: | |||
| 260 | 336 | return error; | ||
| 337 | Err: | |||
| 0 | 0 | - | 338 | while (--i >= 0) |
| 339 | device_remove_file(dev,&bus->dev_attrs[i]); | |||
| 0 | - | 340 | goto Done; | |
| 341 | } | |||
| 342 | ||||
| 343 | ||||
| 2 | 2 | 344 | static void device_remove_attrs(struct bus_type * bus, struct device * dev) | |
| 345 | { | |||
| 346 | int i; | |||
| 347 | ||||
| 0 | 2 | - | 348 | if (bus->dev_attrs) { |
| 0 | 0 | - | 349 | for (i = 0; attr_name(bus->dev_attrs[i]); i++) |
| 350 | device_remove_file(dev,&bus->dev_attrs[i]); | |||
| 351 | } | |||
| 352 | } | |||
| 353 | ||||
| 354 | ||||
| 355 | /** | |||
| 356 | * bus_add_device - add device to bus | |||
| 357 | * @dev: device being added | |||
| 358 | * | |||
| 359 | * - Add the device to its bus's list of devices. | |||
| 360 | * - Try to attach to driver. | |||
| 361 | * - Create link to device's physical location. | |||
| 362 | */ | |||
| 374 | 0 | 363 | int bus_add_device(struct device * dev) | |
| 364 | { | |||
| 365 | struct bus_type * bus = get_bus(dev->bus); | |||
| 366 | int error = 0; | |||
| 367 | ||||
| 260 | 114 | 368 | if (bus) { | |
| 369 | pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id); | |||
| 0 | 260 | - | 369 | do-while (0) |
| 370 | device_attach(dev); | |||
| 371 | klist_add_tail(&dev->knode_bus, &bus->klist_devices); | |||
| 372 | error = device_add_attrs(bus, dev); | |||
| 260 | 0 | - | 373 | if (!error) { |
| 374 | sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id); | |||
| 375 | sysfs_create_link(&dev->kobj, &dev->bus->subsys.kset.kobj, "bus"); | |||
| 376 | } | |||
| 377 | } | |||
| 374 | 378 | return error; | ||
| 379 | } | |||
| 380 | ||||
| 381 | /** | |||
| 382 | * bus_remove_device - remove device from bus | |||
| 383 | * @dev: device to be removed | |||
| 384 | * | |||
| 385 | * - Remove symlink from bus's directory. | |||
| 386 | * - Delete device from bus's list. | |||
| 387 | * - Detach from its driver. | |||
| 388 | * - Drop reference taken in bus_add_device(). | |||
| 389 | */ | |||
| 44 | 44 | 390 | void bus_remove_device(struct device * dev) | |
| 391 | { | |||
| 2 | 42 | 392 | if (dev->bus) { | |
| 393 | sysfs_remove_link(&dev->kobj, "bus"); | |||
| 394 | sysfs_remove_link(&dev->bus->devices.kobj, dev->bus_id); | |||
| 395 | device_remove_attrs(dev->bus, dev); | |||
| 396 | klist_remove(&dev->knode_bus); | |||
| 397 | pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id); | |||
| 0 | 2 | - | 397 | do-while (0) |
| 398 | device_release_driver(dev); | |||
| 399 | put_bus(dev->bus); | |||
| 400 | } | |||
| 401 | } | |||
| 402 | ||||
| 247 | 0 | 403 | static int driver_add_attrs(struct bus_type * bus, struct device_driver * drv) | |
| 404 | { | |||
| 405 | int error = 0; | |||
| 406 | int i; | |||
| 407 | ||||
| 12 | 235 | 408 | if (bus->drv_attrs) { | |
| 24 | 12 | 409 | for (i = 0; attr_name(bus->drv_attrs[i]); i++) { | |
| 410 | error = driver_create_file(drv, &bus->drv_attrs[i]); | |||
| 0 | 24 | - | 411 | if (error) |
| 0 | - | 412 | goto Err; | |
| 413 | } | |||
| 414 | } | |||
| 415 | Done: | |||
| 247 | 416 | return error; | ||
| 417 | Err: | |||
| 0 | 0 | - | 418 | while (--i >= 0) |
| 419 | driver_remove_file(drv, &bus->drv_attrs[i]); | |||
| 0 | - | 420 | goto Done; | |
| 421 | } | |||
| 422 | ||||
| 423 | ||||
| 0 | 0 | - | 424 | static void driver_remove_attrs(struct bus_type * bus, struct device_driver * drv) |
| 425 | { | |||
| 426 | int i; | |||
| 427 | ||||
| 0 | 0 | - | 428 | if (bus->drv_attrs) { |
| 0 | 0 | - | 429 | for (i = 0; attr_name(bus->drv_attrs[i]); i++) |
| 430 | driver_remove_file(drv, &bus->drv_attrs[i]); | |||
| 431 | } | |||
| 432 | } | |||
| 433 | ||||
| 434 | #ifdef CONFIG_HOTPLUG | |||
| 435 | /* | |||
| 436 | * Thanks to drivers making their tables __devinit, we can't allow manual | |||
| 437 | * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled. | |||
| 438 | */ | |||
| 247 | 247 | 439 | static void add_bind_files(struct device_driver *drv) | |
| 440 | { | |||
| 441 | driver_create_file(drv, &driver_attr_unbind); | |||
| 442 | driver_create_file(drv, &driver_attr_bind); | |||
| 443 | } | |||
| 444 | ||||
| 0 | 0 | - | 445 | static void remove_bind_files(struct device_driver *drv) |
| 446 | { | |||
| 447 | driver_remove_file(drv, &driver_attr_bind); | |||
| 448 | driver_remove_file(drv, &driver_attr_unbind); | |||
| 449 | } | |||
| 450 | #else | |||
| 451 | static inline void add_bind_files(struct device_driver *drv) {} | |||
| 452 | static inline void remove_bind_files(struct device_driver *drv) {} | |||
| 453 | #endif | |||
| 454 | ||||
| 455 | /** | |||
| 456 | * bus_add_driver - Add a driver to the bus. | |||
| 457 | * @drv: driver. | |||
| 458 | * | |||
| 459 | */ | |||
| 247 | 0 | 460 | int bus_add_driver(struct device_driver * drv) | |
| 461 | { | |||
| 462 | struct bus_type * bus = get_bus(drv->bus); | |||
| 463 | int error = 0; | |||
| 464 | ||||
| 247 | 0 | - | 465 | if (bus) { |
| 466 | pr_debug("bus %s: add driver %s\n", bus->name, drv->name); | |||
| 0 | 247 | - | 466 | do-while (0) |
| 467 | error = kobject_set_name(&drv->kobj, "%s", drv->name); | |||
| 0 | 247 | - | 468 | if (error) { |
| 469 | put_bus(bus); | |||
| 0 | - | 470 | return error; | |
| 471 | } | |||
| 472 | drv->kobj.kset = &bus->drivers; | |||
| 0 | 247 | - | 473 | if ((error = kobject_register(&drv->kobj))) { |
| 474 | put_bus(bus); | |||
| 0 | - | 475 | return error; | |
| 476 | } | |||
| 477 | ||||
| 478 | driver_attach(drv); | |||
| 479 | klist_add_tail(&drv->knode_bus, &bus->klist_drivers); | |||
| 480 | module_add_driver(drv->owner, drv); | |||
| 481 | ||||
| 482 | driver_add_attrs(bus, drv); | |||
| 483 | add_bind_files(drv); | |||
| 484 | } | |||
| 247 | 485 | return error; | ||
| 486 | } | |||
| 487 | ||||
| 488 | ||||
| 489 | /** | |||
| 490 | * bus_remove_driver - delete driver from bus's knowledge. | |||
| 491 | * @drv: driver. | |||
| 492 | * | |||
| 493 | * Detach the driver from the devices it controls, and remove | |||
| 494 | * it from its bus's list of drivers. Finally, we drop the reference | |||
| 495 | * to the bus we took in bus_add_driver(). | |||
| 496 | */ | |||
| 497 | ||||
| 0 | 0 | - | 498 | void bus_remove_driver(struct device_driver * drv) |
| 499 | { | |||
| 0 | 0 | - | 500 | if (drv->bus) { |
| 501 | remove_bind_files(drv); | |||
| 502 | driver_remove_attrs(drv->bus, drv); | |||
| 503 | klist_remove(&drv->knode_bus); | |||
| 504 | pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name); | |||
| 0 | 0 | - | 504 | do-while (0) |
| 505 | driver_detach(drv); | |||
| 506 | module_remove_driver(drv); | |||
| 507 | kobject_unregister(&drv->kobj); | |||
| 508 | put_bus(drv->bus); | |||
| 509 | } | |||
| 510 | } | |||
| 511 | ||||
| 512 | ||||
| 513 | /* Helper for bus_rescan_devices's iter */ | |||
| 18 | 0 | 514 | static int bus_rescan_devices_helper(struct device *dev, void *data) | |
| 515 | { | |||
| 18 | 0 | - | 516 | if (!dev->driver) { |
| 18 | 0 | - | 517 | if (dev->parent) /* Needed for USB */ |
| 518 | down(&dev->parent->sem); | |||
| 519 | device_attach(dev); | |||
| 18 | 0 | - | 520 | if (dev->parent) |
| 521 | up(&dev->parent->sem); | |||
| 522 | } | |||
| 18 | 523 | return 0; | ||
| 524 | } | |||
| 525 | ||||
| 526 | /** | |||
| 527 | * bus_rescan_devices - rescan devices on the bus for possible drivers | |||
| 528 | * @bus: the bus to scan. | |||
| 529 | * | |||
| 530 | ||||