1/* 2 * driver.c - centralized device driver management 3 * 4 * Copyright (c) 2002-3 Patrick Mochel 5 * Copyright (c) 2002-3 Open Source Development Labs 6 * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de> 7 * Copyright (c) 2007 Novell Inc. 8 * 9 * This file is released under the GPLv2 10 * 11 */ 12 13#include <linux/device.h> 14#include <linux/module.h> 15#include <linux/errno.h> 16#include <linux/slab.h> 17#include <linux/string.h> 18#include "base.h" 19 20static struct device *next_device(struct klist_iter *i) 21{ 22 struct klist_node *n = klist_next(i); 23 struct device *dev = NULL; 24 struct device_private *dev_prv; 25 26 if (n) { 27 dev_prv = to_device_private_driver(n); 28 dev = dev_prv->device; 29 } 30 return dev; 31} 32 33/** 34 * driver_for_each_device - Iterator for devices bound to a driver. 35 * @drv: Driver we're iterating. 36 * @start: Device to begin with 37 * @data: Data to pass to the callback. 38 * @fn: Function to call for each device. 39 * 40 * Iterate over the @drv's list of devices calling @fn for each one. 41 */ 42int driver_for_each_device(struct device_driver *drv, struct device *start, 43 void *data, int (*fn)(struct device *, void *)) 44{ 45 struct klist_iter i; 46 struct device *dev; 47 int error = 0; 48 49 if (!drv) 50 return -EINVAL; 51 52 klist_iter_init_node(&drv->p->klist_devices, &i, 53 start ? &start->p->knode_driver : NULL); 54 while ((dev = next_device(&i)) && !error) 55 error = fn(dev, data); 56 klist_iter_exit(&i); 57 return error; 58} 59EXPORT_SYMBOL_GPL(driver_for_each_device); 60 61/** 62 * driver_find_device - device iterator for locating a particular device. 63 * @drv: The device's driver 64 * @start: Device to begin with 65 * @data: Data to pass to match function 66 * @match: Callback function to check device 67 * 68 * This is similar to the driver_for_each_device() function above, but 69 * it returns a reference to a device that is 'found' for later use, as 70 * determined by the @match callback. 71 * 72 * The callback should return 0 if the device doesn't match and non-zero 73 * if it does. If the callback returns non-zero, this function will 74 * return to the caller and not iterate over any more devices. 75 */ 76struct device *driver_find_device(struct device_driver *drv, 77 struct device *start, void *data, 78 int (*match)(struct device *dev, void *data)) 79{ 80 struct klist_iter i; 81 struct device *dev; 82 83 if (!drv) 84 return NULL; 85 86 klist_iter_init_node(&drv->p->klist_devices, &i, 87 (start ? &start->p->knode_driver : NULL)); 88 while ((dev = next_device(&i))) 89 if (match(dev, data) && get_device(dev)) 90 break; 91 klist_iter_exit(&i); 92 return dev; 93} 94EXPORT_SYMBOL_GPL(driver_find_device); 95 96/** 97 * driver_create_file - create sysfs file for driver. 98 * @drv: driver. 99 * @attr: driver attribute descriptor. 100 */ 101int driver_create_file(struct device_driver *drv, 102 const struct driver_attribute *attr) 103{ 104 int error; 105 if (drv) 106 error = sysfs_create_file(&drv->p->kobj, &attr->attr); 107 else 108 error = -EINVAL; 109 return error; 110} 111EXPORT_SYMBOL_GPL(driver_create_file); 112 113/** 114 * driver_remove_file - remove sysfs file for driver. 115 * @drv: driver. 116 * @attr: driver attribute descriptor. 117 */ 118void driver_remove_file(struct device_driver *drv, 119 const struct driver_attribute *attr) 120{ 121 if (drv) 122 sysfs_remove_file(&drv->p->kobj, &attr->attr); 123} 124EXPORT_SYMBOL_GPL(driver_remove_file); 125 126/** 127 * driver_add_kobj - add a kobject below the specified driver 128 * @drv: requesting device driver 129 * @kobj: kobject to add below this driver 130 * @fmt: format string that names the kobject 131 * 132 * You really don't want to do this, this is only here due to one looney 133 * iseries driver, go poke those developers if you are annoyed about 134 * this... 135 */ 136int driver_add_kobj(struct device_driver *drv, struct kobject *kobj, 137 const char *fmt, ...) 138{ 139 va_list args; 140 char *name; 141 int ret; 142 143 va_start(args, fmt); 144 name = kvasprintf(GFP_KERNEL, fmt, args); 145 va_end(args); 146 147 if (!name) 148 return -ENOMEM; 149 150 ret = kobject_add(kobj, &drv->p->kobj, "%s", name); 151 kfree(name); 152 return ret; 153} 154EXPORT_SYMBOL_GPL(driver_add_kobj); 155 156/** 157 * get_driver - increment driver reference count. 158 * @drv: driver. 159 */ 160struct device_driver *get_driver(struct device_driver *drv) 161{ 162 if (drv) { 163 struct driver_private *priv; 164 struct kobject *kobj; 165 166 kobj = kobject_get(&drv->p->kobj); 167 priv = to_driver(kobj); 168 return priv->driver; 169 } 170 return NULL; 171} 172EXPORT_SYMBOL_GPL(get_driver); 173 174/** 175 * put_driver - decrement driver's refcount. 176 * @drv: driver. 177 */ 178void put_driver(struct device_driver *drv) 179{ 180 kobject_put(&drv->p->kobj); 181} 182EXPORT_SYMBOL_GPL(put_driver); 183 184static int driver_add_groups(struct device_driver *drv, 185 const struct attribute_group **groups) 186{ 187 int error = 0; 188 int i; 189 190 if (groups) { 191 for (i = 0; groups[i]; i++) { 192 error = sysfs_create_group(&drv->p->kobj, groups[i]); 193 if (error) { 194 while (--i >= 0) 195 sysfs_remove_group(&drv->p->kobj, 196 groups[i]); 197 break; 198 } 199 } 200 } 201 return error; 202} 203 204static void driver_remove_groups(struct device_driver *drv, 205 const struct attribute_group **groups) 206{ 207 int i; 208 209 if (groups) 210 for (i = 0; groups[i]; i++) 211 sysfs_remove_group(&drv->p->kobj, groups[i]); 212} 213 214/** 215 * driver_register - register driver with bus 216 * @drv: driver to register 217 * 218 * We pass off most of the work to the bus_add_driver() call, 219 * since most of the things we have to do deal with the bus 220 * structures. 221 */ 222int driver_register(struct device_driver *drv) 223{ 224 int ret; 225 struct device_driver *other; 226 227 BUG_ON(!drv->bus->p); 228 229 if ((drv->bus->probe && drv->probe) || 230 (drv->bus->remove && drv->remove) || 231 (drv->bus->shutdown && drv->shutdown)) 232 printk(KERN_WARNING "Driver '%s' needs updating - please use " 233 "bus_type methods\n", drv->name); 234 235 other = driver_find(drv->name, drv->bus); 236 if (other) { 237 put_driver(other); 238 printk(KERN_ERR "Error: Driver '%s' is already registered, " 239 "aborting...\n", drv->name); 240 return -EBUSY; 241 } 242 243 ret = bus_add_driver(drv); 244 if (ret) 245 return ret; 246 ret = driver_add_groups(drv, drv->groups); 247 if (ret) 248 bus_remove_driver(drv); 249 return ret; 250} 251EXPORT_SYMBOL_GPL(driver_register); 252 253/** 254 * driver_unregister - remove driver from system. 255 * @drv: driver. 256 * 257 * Again, we pass off most of the work to the bus-level call. 258 */ 259void driver_unregister(struct device_driver *drv) 260{ 261 if (!drv || !drv->p) { 262 WARN(1, "Unexpected driver unregister!\n"); 263 return; 264 } 265 driver_remove_groups(drv, drv->groups); 266 bus_remove_driver(drv); 267} 268EXPORT_SYMBOL_GPL(driver_unregister); 269 270/** 271 * driver_find - locate driver on a bus by its name. 272 * @name: name of the driver. 273 * @bus: bus to scan for the driver. 274 * 275 * Call kset_find_obj() to iterate over list of drivers on 276 * a bus to find driver by name. Return driver if found. 277 * 278 * Note that kset_find_obj increments driver's reference count. 279 */ 280struct device_driver *driver_find(const char *name, struct bus_type *bus) 281{ 282 struct kobject *k = kset_find_obj(bus->p->drivers_kset, name); 283 struct driver_private *priv; 284 285 if (k) { 286 priv = to_driver(k); 287 return priv->driver; 288 } 289 return NULL; 290} 291EXPORT_SYMBOL_GPL(driver_find); 292