linux将所有的驱动抽象为struct device_driver结构。这样设计可以方便驱动程序更好编写,在编写驱动的时候只需要将此结构嵌入到具体的驱动中即可。
比如常见的结构: struct platform_driver结构
struct platform_driver {
int (*probe)(struct platform_device *);
int (*remove)(struct platform_device *);
void (*shutdown)(struct platform_device *);
int (*suspend)(struct platform_device *, pm_message_t state);
int (*resume)(struct platform_device *);
struct device_driver driver;
const struct platform_device_id *id_table;
bool prevent_deferred_probe;
};
可以看到device_driver结构嵌入到platform_driver
struct device_driver {
const char *name;
struct bus_type *bus;
struct module *owner;
const char *mod_name; /* used for built-in modules */
bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
const struct of_device_id *of_match_table;
const struct acpi_device_id *acpi_match_table;
int (*probe) (struct device *dev);
int (*remove) (struct device *dev);
void (*shutdown) (struct device *dev);
int (*suspend) (struct device *dev, pm_message_t state);
int (*resume) (struct device *dev);
const struct attribute_group **groups;
const struct dev_pm_ops *pm;
struct driver_private *p;
};
name: 设备驱动的名称
bus: 设备驱动所属的总线
owner: 设备驱动的owner,通常为THIS_MODULE
suppress_bind_attrs: 通过sysfs操作设备驱动的bind/unbind,用来使能/关闭设备与驱动的自动匹配
of_device_id: device_tree中使用,用于匹配设备。
probe,remove: 当设备匹配/移除的时候,会调用设备驱动的probe/remove函数。
shutdown,suspend, resume: 代表设备驱动在调用管理的时候的回调函数。
groups: 设备驱动的属性。
p: 设备驱动的私有数据结构,通常可以将驱动的信息放入此结构中。
内核使用driver_attribute结构代表设备驱动的属性
struct driver_attribute {
struct attribute attr;
ssize_t (*show)(struct device_driver *driver, char *buf);
ssize_t (*store)(struct device_driver *driver, const char *buf,
size_t count);
};
设备驱动的属性,同样通过注册,最后调用到驱动的show和store函数。
和设备一样,内核也为设备驱动定义了一些驱动的宏属性,方便定义驱动属性。
#define DRIVER_ATTR(_name, _mode, _show, _store) \
struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store)
#define DRIVER_ATTR_RW(_name) \
struct driver_attribute driver_attr_##_name = __ATTR_RW(_name)
#define DRIVER_ATTR_RO(_name) \
struct driver_attribute driver_attr_##_name = __ATTR_RO(_name)
#define DRIVER_ATTR_WO(_name) \
struct driver_attribute driver_attr_##_name = __ATTR_WO(_name)
int driver_register(struct device_driver *drv)
{
int ret;
struct device_driver *other;
BUG_ON(!drv->bus->p); //确定bus->p是否存在,不存在则会产生panic
if ((drv->bus->probe && drv->probe) || //警告信息,有新驱动的时候出出现此log。
(drv->bus->remove && drv->remove) ||
(drv->bus->shutdown && drv->shutdown))
printk(KERN_WARNING "Driver '%s' needs updating - please use "
"bus_type methods\n", drv->name);
other = driver_find(drv->name, drv->bus); //已经注册过的话,就打印已经注册的信息。
if (other) {
printk(KERN_ERR "Error: Driver '%s' is already registered, "
"aborting...\n", drv->name);
return -EBUSY;
}
ret = bus_add_driver(drv); //添加驱动到具体的bus
if (ret)
return ret;
ret = driver_add_groups(drv, drv->groups); //添加驱动的属性
if (ret) {
bus_remove_driver(drv);
return ret;
}
kobject_uevent(&drv->p->kobj, KOBJ_ADD); //使用uevent机制,通知上层添加新的驱动
return ret;
}
A: 通过驱动的名称在所属的总线上查找,判断总线上是否已经有此驱动,防止重复注册。
struct device_driver *driver_find(const char *name, struct bus_type *bus)
{
struct kobject *k = kset_find_obj(bus->p->drivers_kset, name);
struct driver_private *priv;
if (k) {
/* Drop reference added by kset_find_obj() */
kobject_put(k);
priv = to_driver(k);
return priv->driver;
}
return NULL;
}
通过kset_find_obj函数,在drivers_set中查找是否已经注册,已经注册返回具体的驱动,如果没有注册返回NULL。
B: 将具体的驱动添加到所属的总线,这是注册驱动的核心函数。
int bus_add_driver(struct device_driver *drv)
{
struct bus_type *bus;
struct driver_private *priv;
int error = 0;
bus = bus_get(drv->bus);
if (!bus)
return -EINVAL;
pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
priv = kzalloc(sizeof(*priv), GFP_KERNEL); //申请driver_private内存
if (!priv) {
error = -ENOMEM;
goto out_put_bus;
}
klist_init(&priv->klist_devices, NULL, NULL);
priv->driver = drv; //将驱动存放到driver_private的driver中
drv->p = priv; //存放priv到device_driver的p中
priv->kobj.kset = bus->p->drivers_kset; //设置kset
error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
"%s", drv->name); //初始化和添加一个kobject
if (error)
goto out_unregister;
klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers); //添加驱动到klist_driver链表中
if (drv->bus->p->drivers_autoprobe) { //驱动所属的bus是否支持自动probe
error = driver_attach(drv); //如果支持,则调用attach函数,这个函数在device中已经分析过
if (error)
goto out_unregister;
}
module_add_driver(drv->owner, drv);
error = driver_create_file(drv, &driver_attr_uevent); //创建驱动的Uevent属性
if (error) {
printk(KERN_ERR "%s: uevent attr (%s) failed\n",
__func__, drv->name);
}
error = driver_add_groups(drv, bus->drv_groups); //创建bus下的驱动属性
if (error) {
/* How the hell do we get out of this pickle? Give up */
printk(KERN_ERR "%s: driver_create_groups(%s) failed\n",
__func__, drv->name);
}
if (!drv->suppress_bind_attrs) { //添加绑定/不绑定的属性
error = add_bind_files(drv);
if (error) {
/* Ditto */
printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
__func__, drv->name);
}
}
return 0;
}
void driver_unregister(struct device_driver *drv)
{
if (!drv || !drv->p) {
WARN(1, "Unexpected driver unregister!\n");
return;
}
driver_remove_groups(drv, drv->groups); //移除驱动的属性
bus_remove_driver(drv); //从所属的bus下移除该驱动
}
void bus_remove_driver(struct device_driver *drv)
{
if (!drv->bus)
return;
if (!drv->suppress_bind_attrs) //移除bind/unbind的属性
remove_bind_files(drv);
driver_remove_groups(drv, drv->bus->drv_groups); //移除设备属性
driver_remove_file(drv, &driver_attr_uevent); //移除uevent属性
klist_remove(&drv->p->knode_bus); //移除驱动节点,从klist_driver链表中
pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name);
driver_detach(drv); //解除设备与驱动联系
module_remove_driver(drv);
kobject_put(&drv->p->kobj); //驱动引用计数减1
bus_put(drv->bus); //总线引用计数减1
}
重点看下设备与对应的驱动是如何解除联系的。
void driver_detach(struct device_driver *drv)
{
struct device_private *dev_prv;
struct device *dev;
for (;;) {
spin_lock(&drv->p->klist_devices.k_lock); //加锁,防止别的驱动也在做相似的操作
if (list_empty(&drv->p->klist_devices.k_list)) { //如果设备链表为空,直接返回
spin_unlock(&drv->p->klist_devices.k_lock);
break;
}
dev_prv = list_entry(drv->p->klist_devices.k_list.prev, //对设备链表中的每个设备,调用__device_release_drive函数
struct device_private,
knode_driver.n_node);
dev = dev_prv->device;
get_device(dev);
spin_unlock(&drv->p->klist_devices.k_lock);
if (dev->parent) /* Needed for USB */
device_lock(dev->parent);
device_lock(dev);
if (dev->driver == drv)
__device_release_driver(dev);
device_unlock(dev);
if (dev->parent)
device_unlock(dev->parent);
put_device(dev);
}
}
接下来分析__device_release_driver函数
static void __device_release_driver(struct device *dev)
{
struct device_driver *drv;
drv = dev->driver;
if (drv) {
pm_runtime_get_sync(dev);
driver_sysfs_remove(dev); //从sysfs中移除该驱动的信息
if (dev->bus) //调用bus下的通知机制,发送unbind_driver消息
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
BUS_NOTIFY_UNBIND_DRIVER,
dev);
pm_runtime_put_sync(dev);
if (dev->bus && dev->bus->remove)
dev->bus->remove(dev); //调用bus下的remove函数
else if (drv->remove) //调用该驱动的remove函数
drv->remove(dev);
devres_release_all(dev); //释放该设备所占用的资源
dev->driver = NULL;
dev_set_drvdata(dev, NULL);
klist_remove(&dev->p->knode_driver);
if (dev->bus)
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
BUS_NOTIFY_UNBOUND_DRIVER,
dev);
}
}