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