2 * driver.c - centralized device driver management
4 * Copyright (c) 2002-3 Patrick Mochel
5 * Copyright (c) 2002-3 Open Source Development Labs
7 * This file is released under the GPLv2
11 #include <linux/config.h>
12 #include <linux/device.h>
13 #include <linux/module.h>
14 #include <linux/errno.h>
15 #include <linux/string.h>
18 #define to_dev(node) container_of(node, struct device, driver_list)
19 #define to_drv(obj) container_of(obj, struct device_driver, kobj)
22 static struct device
* next_device(struct klist_iter
* i
)
24 struct klist_node
* n
= klist_next(i
);
25 return n
? container_of(n
, struct device
, knode_driver
) : NULL
;
29 * driver_for_each_device - Iterator for devices bound to a driver.
30 * @drv: Driver we're iterating.
31 * @data: Data to pass to the callback.
32 * @fn: Function to call for each device.
34 * Iterate over the @drv's list of devices calling @fn for each one.
37 int driver_for_each_device(struct device_driver
* drv
, struct device
* start
,
38 void * data
, int (*fn
)(struct device
*, void *))
47 klist_iter_init_node(&drv
->klist_devices
, &i
,
48 start
? &start
->knode_driver
: NULL
);
49 while ((dev
= next_device(&i
)) && !error
)
50 error
= fn(dev
, data
);
55 EXPORT_SYMBOL_GPL(driver_for_each_device
);
59 * driver_create_file - create sysfs file for driver.
61 * @attr: driver attribute descriptor.
64 int driver_create_file(struct device_driver
* drv
, struct driver_attribute
* attr
)
67 if (get_driver(drv
)) {
68 error
= sysfs_create_file(&drv
->kobj
, &attr
->attr
);
77 * driver_remove_file - remove sysfs file for driver.
79 * @attr: driver attribute descriptor.
82 void driver_remove_file(struct device_driver
* drv
, struct driver_attribute
* attr
)
84 if (get_driver(drv
)) {
85 sysfs_remove_file(&drv
->kobj
, &attr
->attr
);
92 * get_driver - increment driver reference count.
95 struct device_driver
* get_driver(struct device_driver
* drv
)
97 return drv
? to_drv(kobject_get(&drv
->kobj
)) : NULL
;
102 * put_driver - decrement driver's refcount.
105 void put_driver(struct device_driver
* drv
)
107 kobject_put(&drv
->kobj
);
112 * driver_register - register driver with bus
113 * @drv: driver to register
115 * We pass off most of the work to the bus_add_driver() call,
116 * since most of the things we have to do deal with the bus
119 * The one interesting aspect is that we setup @drv->unloaded
120 * as a completion that gets complete when the driver reference
123 int driver_register(struct device_driver
* drv
)
125 klist_init(&drv
->klist_devices
);
126 init_completion(&drv
->unloaded
);
127 return bus_add_driver(drv
);
132 * driver_unregister - remove driver from system.
135 * Again, we pass off most of the work to the bus-level call.
137 * Though, once that is done, we wait until @drv->unloaded is completed.
138 * This will block until the driver refcount reaches 0, and it is
139 * released. Only modular drivers will call this function, and we
140 * have to guarantee that it won't complete, letting the driver
141 * unload until all references are gone.
144 void driver_unregister(struct device_driver
* drv
)
146 bus_remove_driver(drv
);
147 wait_for_completion(&drv
->unloaded
);
151 * driver_find - locate driver on a bus by its name.
152 * @name: name of the driver.
153 * @bus: bus to scan for the driver.
155 * Call kset_find_obj() to iterate over list of drivers on
156 * a bus to find driver by name. Return driver if found.
158 * Note that kset_find_obj increments driver's reference count.
160 struct device_driver
*driver_find(const char *name
, struct bus_type
*bus
)
162 struct kobject
*k
= kset_find_obj(&bus
->drivers
, name
);
168 EXPORT_SYMBOL_GPL(driver_register
);
169 EXPORT_SYMBOL_GPL(driver_unregister
);
170 EXPORT_SYMBOL_GPL(get_driver
);
171 EXPORT_SYMBOL_GPL(put_driver
);
172 EXPORT_SYMBOL_GPL(driver_find
);
174 EXPORT_SYMBOL_GPL(driver_create_file
);
175 EXPORT_SYMBOL_GPL(driver_remove_file
);