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