linux设备驱动模型如下所示（摘自《linux设备驱动开发详解》）：
在Linux内核中，分别使用bus_type、device和device_driver来描述总线、设备和设备驱动之间的关系。首先根据SOC内部的总线关系分别分类出USB总线、PCI总线、I2C总线、SPI总线等常见总线，另外考虑到SOC系统中一些独立的外设控制器以及挂接在SOC内存空间的外设不依附前面这些总线，linux发明了一种虚拟总线，即platform总线，相应的设备称为platform_device，而驱动称为platform_driver。linux设备模型中，总线将设备和驱动绑定。在系统每注册一个设备的时候，会寻找与之匹配的驱动；相反的，在系统每注册一个驱动的时候，会寻找与之区域的设备，而匹配由总线完成。接下来，以platform总线、platform_device和platform_driver三者的关系为例进行说明linux设备模型是如何通过总线管理设备与设备驱动的。
先来看下platform_device的注册，以s3c2440平台为例，在mach-smdk2440.c对平台设备进行了注册，如下：
首先根据SOC中有哪些设备定义平台设备数组：
static struct platform_device *smdk2440_devices[] __initdata = {
&s3c_device_usb,
&s3c_device_lcd,
&s3c_device_wdt,
&s3c_device_i2c0,
&s3c_device_iis,
};
平台设备的结构体定义如下：
struct platform_device {
const char * name;
int id;
struct device dev;
u32 num_resources;
struct resource * resource;
};
接着通过platform_add_devices()注册到platform总线上，分别通过platform_device_register()单个注册每一个平台设备，其源码如下：
int platform_device_register(struct platform_device *pdev)
{
device_initialize(&pdev->dev);
return platform_device_add(pdev);
}
详细看下platform_device_add的源码：
首先将dev.parent = &platform_bus;
pdev->dev.bus = &platform_bus_type;
然后根据设备的num_resources往设备的parent上insert_resource()，最后调用device_add()将设备注册到device hierarchy。device_add的源码如下：
int device_add(struct device *dev)
{
struct device *parent = NULL;
struct class_interface *class_intf;
int error = -EINVAL;
dev = get_device(dev);
if (!dev)
goto done;
/* Temporarily support init_name if it is set.
* It will override bus_id for now */
if (dev->init_name)
dev_set_name(dev, "%s", dev->init_name);
if (!strlen(dev->bus_id))
goto done;
pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
parent = get_device(dev->parent);
setup_parent(dev, parent);
/* use parent numa_node */
if (parent)
set_dev_node(dev, dev_to_node(parent));
/* first, register with generic layer. */
error = kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev_name(dev));
if (error)
goto Error;
/* notify platform of device entry */
if (platform_notify)
platform_notify(dev);
error = device_create_file(dev, &uevent_attr);
if (error)
goto attrError;
if (MAJOR(dev->devt)) {
error = device_create_file(dev, &devt_attr);
if (error)
goto ueventattrError;
error = device_create_sys_dev_entry(dev);
if (error)
goto devtattrError;
}
error = device_add_class_symlinks(dev);
if (error)
goto SymlinkError;
error = device_add_attrs(dev);
if (error)
goto AttrsError;
error = bus_add_device(dev);
if (error)
goto BusError;
error = dpm_sysfs_add(dev);
if (error)
goto DPMError;
device_pm_add(dev);
/* Notify clients of device addition. This call must come
* after dpm_sysf_add() and before kobject_uevent().
*/
if (dev->bus)
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
BUS_NOTIFY_ADD_DEVICE, dev);
kobject_uevent(&dev->kobj, KOBJ_ADD);
bus_attach_device(dev);
if (parent)
klist_add_tail(&dev->knode_parent, &parent->klist_children);
if (dev->class) {
mutex_lock(&dev->class->p->class_mutex);
/* tie the class to the device */
klist_add_tail(&dev->knode_class,
&dev->class->p->class_devices);
/* notify any interfaces that the device is here */
list_for_each_entry(class_intf,
&dev->class->p->class_interfaces, node)
if (class_intf->add_dev)
class_intf->add_dev(dev, class_intf);
mutex_unlock(&dev->class->p->class_mutex);
}
done:
......
}
该函数先判断dev是否为空，再调用setup_parent()为dev寻找父节点，再调用kobject_add（）往父节点添加kobject节点，
然后分别调用device_create_file为设备节点创建sysfs的设备节点,再创建一些软连接符号，接着执行bus_attach_device(dev)为设备
寻找对应的设备驱动，详细看下该函数的内容：
void bus_attach_device(struct device *dev)
{
struct bus_type *bus = dev->bus;
int ret = 0;
if (bus) {
if (bus->p->drivers_autoprobe)
ret = device_attach(dev);
WARN_ON(ret < 0);
if (ret >= 0)
klist_add_tail(&dev->knode_bus, &bus->p->klist_devices);
}
}
首先会判断drivers_autoprobe是否为真，然后调用device_attach()，成功后再调用 klist_add_tail(&dev->knode_bus, &bus->p->klist_devices);将设备
添加到klist_devices链表中，下面详细看下device_attach函数的内容：
int device_attach(struct device *dev)
{
int ret = 0;
down(&dev->sem);
if (dev->driver) {
ret = device_bind_driver(dev);
if (ret == 0)
ret = 1;
else {
dev->driver = NULL;
ret = 0;
}
} else {
ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
}
up(&dev->sem);
return ret;
}
如果dev已经有驱动关联了，就调用device_bind_driver，否则就调用bus_for_each_drv()从设备
所依附的总线上遍历已注册的驱动。该函数中会回调__device_attach()来为设备寻找匹配的驱动，其源码如下：
static int __device_attach(struct device_driver *drv, void *data)
{
struct device *dev = data;
return driver_probe_device(drv, dev);
}
int driver_probe_device(struct device_driver *drv, struct device *dev)
{
int ret = 0;
if (!device_is_registered(dev))
return -ENODEV;
if (drv->bus->match && !drv->bus->match(dev, drv))
goto done;
pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
drv->bus->name, __func__, dev_name(dev), drv->name);
ret = really_probe(dev, drv);
done:
return ret;
}
可以看到，最后匹配dev与drv的函数是在drv所依附的bus->match()中匹配的，由于这里注册的是platform总线，看下
platform总线的定义，如下：
struct bus_type platform_bus_type = {
.name = "platform",
.dev_attrs = platform_dev_attrs,
.match = platform_match,
.uevent = platform_uevent,
.pm = PLATFORM_PM_OPS_PTR,
};
其match方法如下：
static int platform_match(struct device *dev, struct device_driver *drv)
{
struct platform_device *pdev;
pdev = container_of(dev, struct platform_device, dev);
return (strcmp(pdev->name, drv->name) == 0);
}
match()方法只是判断dev->name与drv->name是否相同。现在回过来看driver_probe_device()匹配成功的内容，
若dev与drv匹配成功，则会调用really_probe(dev, drv)，其源码如下：
static int really_probe(struct device *dev, struct device_driver *drv)
{
int ret = 0;
atomic_inc(&probe_count);
dev->driver = drv;
if (driver_sysfs_add(dev)) {
printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
__func__, dev_name(dev));
goto probe_failed;
}
if (dev->bus->probe) {
ret = dev->bus->probe(dev);
if (ret)
goto probe_failed;
} else if (drv->probe) {
ret = drv->probe(dev);
if (ret)
goto probe_failed;
}
driver_bound(dev);
ret = 1;
pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
drv->bus->name, __func__, dev_name(dev), drv->name);
goto done;
probe_failed:
......
return ret;
}
首先将dev->driver指向drv，然后判断dev->bus->probe与drv->probe方法是否存在，在platform总线上没有probe方法，
因此会执行drv->probe()方法，即platform_driver的probe方法。
分析好了platform_device的注册过程，接下来看下platform_driver的注册过程，以s3c2440平台的s3c_device_wdt平台设备的平台驱动为例，平台驱动通过platform_driver_register注册平台驱动，先看下s3c_device_wdt的平台驱动定义，如下：
static struct platform_driver s3c2410wdt_driver = {
.probe = s3c2410wdt_probe,
.remove = s3c2410wdt_remove,
.shutdown = s3c2410wdt_shutdown,
.suspend = s3c2410wdt_suspend,
.resume = s3c2410wdt_resume,
.driver = {
.owner = THIS_MODULE,
.name = "s3c2410-wdt",
},
};
可以看到.driver.name字段与s3c_device_wdt的平台设备的.name字段相同，当platform总线的match方法匹配出平台设备与平台驱动后就调用平台驱动
的probe方法了，本例就是s3c2410wdt_driver的.probe方法。下面来详细看下平台驱动的注册，即platform_driver_register函数的内容：
int platform_driver_register(struct platform_driver *drv)
{
drv->driver.bus = &platform_bus_type;
if (drv->probe)
drv->driver.probe = platform_drv_probe;
if (drv->remove)
drv->driver.remove = platform_drv_remove;
if (drv->shutdown)
drv->driver.shutdown = platform_drv_shutdown;
if (drv->suspend)
drv->driver.suspend = platform_drv_suspend;
if (drv->resume)
drv->driver.resume = platform_drv_resume;
return driver_register(&drv->driver);
}
首先将drv->driver.bus设为platform_bus_type，然后判断drv的probe、remove、shutdown、suspend和resume字段是否为空，若为空，则使用平台总线对应的
默认平台驱动接口，然后调用driver_register注册平台驱动，其源码如下：
int driver_register(struct device_driver *drv)
{
int ret;
struct device_driver *other;
if ((drv->bus->probe && drv->probe) ||
(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) {
put_driver(other);
printk(KERN_ERR "Error: Driver '%s' is already registered, "
"aborting...\n", drv->name);
return -EEXIST;
}
ret = bus_add_driver(drv);
if (ret)
return ret;
ret = driver_add_groups(drv, drv->groups);
if (ret)
bus_remove_driver(drv);
return ret;
}
首先根据drv->bus和drv->name从drv依附的bus中寻找是否已经注册了drv->name的平台驱动，若没注册，则调用bus_add_driver()注册驱动，其源码如下：
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);
if (!priv) {
error = -ENOMEM;
goto out_put_bus;
}
klist_init(&priv->klist_devices, NULL, NULL);
priv->driver = drv;
drv->p = priv;
priv->kobj.kset = bus->p->drivers_kset;
error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
"%s", drv->name);
if (error)
goto out_unregister;
if (drv->bus->p->drivers_autoprobe) {
error = driver_attach(drv);
if (error)
goto out_unregister;
}
klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
module_add_driver(drv->owner, drv);
error = driver_create_file(drv, &driver_attr_uevent);
if (error) {
printk(KERN_ERR "%s: uevent attr (%s) failed\n",
__func__, drv->name);
}
error = driver_add_attrs(bus, drv);
if (error) {
/* How the hell do we get out of this pickle? Give up */
printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
__func__, drv->name);
}
error = add_bind_files(drv);
if (error) {
/* Ditto */
printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
__func__, drv->name);
}
kobject_uevent(&priv->kobj, KOBJ_ADD);
return error;
out_unregister:
......
}
该函数首先根据drv->bus获得drv依附的bus，再创建一个priv结构体来存放drv在内核中需要表示的相关数据结构，接着判断
drv->bus->p->drivers_autoprobe是否为真，若为真，则调用driver_attach将驱动与某个平台设备进行关联。然后通过klist_add_tail将
priv所指向的drv添加到klist_drivers链表中，最后会调用driver_create_file等为drv创建sysfs对应的设备驱动节点。
下面来详细看下driver_attach中是如何将驱动与某个平台设备进行关联的，其源码如下：
int driver_attach(struct device_driver *drv)
{
return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
}
在bus_for_each_dev中会回调__driver_attach()函数，其源码如下：
static int __driver_attach(struct device *dev, void *data)
{
struct device_driver *drv = data;
if (drv->bus->match && !drv->bus->match(dev, drv))
return 0;
if (dev->parent) /* Needed for USB */
down(&dev->parent->sem);
down(&dev->sem);
if (!dev->driver)
driver_probe_device(drv, dev);
up(&dev->sem);
if (dev->parent)
up(&dev->parent->sem);
return 0;
}
该函数首先判断drv所依附的bus->match()函数是否存在，若存在，则调用其match()函数来匹配设备与设备驱动。由于platform总线的
match()方法只是判断platform_device与platform_driver的名字是否相同，若相同，则判断dev->driver是否已关联。若没有关联，
则调用driver_probe_device(drv, dev)，该函数在上面platform_device注册过程中已分析过，其最终调用really_probe(dev, drv)，
继而执行drv的probe方法。
int __init platform_bus_init(void)
{
int error;
error = device_register(&platform_bus);
if (error)
return error;
error = bus_register(&platform_bus_type);
if (error)
device_unregister(&platform_bus);
return error;
}
struct device platform_bus = {
.init_name = "platform",
};
struct bus_type platform_bus_type = {
.name = "platform",
.dev_attrs = platform_dev_attrs,
.match = platform_match,
.uevent = platform_uevent,
.pm = PLATFORM_PM_OPS_PTR,
};
在platform_bus的初始化函数中，首先会通过device_register()注册platform_bus，再通过bus_register()注册platform_bus_type。分别来看下两个注册
函数的内容。device_register()的源码如下：
int device_register(struct device *dev)
{
device_initialize(dev);
return device_add(dev);
}
该函数的内容与平台设备的注册过程没什么区别，只不过此时注册的是platform_bus，没有指明parent节点，因此将platform_bus作为一个节点。接着再来看下
bus_register()的内容，如下：
int bus_register(struct bus_type *bus)
{
int retval;
struct bus_type_private *priv;
priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->bus = bus;
bus->p = priv;
BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
if (retval)
goto out;
priv->subsys.kobj.kset = bus_kset;
priv->subsys.kobj.ktype = &bus_ktype;
priv->drivers_autoprobe = 1;
retval = kset_register(&priv->subsys);
if (retval)
goto out;
retval = bus_create_file(bus, &bus_attr_uevent);
if (retval)
goto bus_uevent_fail;
priv->devices_kset = kset_create_and_add("devices", NULL,
&priv->subsys.kobj);
if (!priv->devices_kset) {
retval = -ENOMEM;
goto bus_devices_fail;
}
priv->drivers_kset = kset_create_and_add("drivers", NULL,
&priv->subsys.kobj);
if (!priv->drivers_kset) {
retval = -ENOMEM;
goto bus_drivers_fail;
}
klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
klist_init(&priv->klist_drivers, NULL, NULL);
retval = add_probe_files(bus);
if (retval)
goto bus_probe_files_fail;
retval = bus_add_attrs(bus);
if (retval)
goto bus_attrs_fail;
pr_debug("bus: '%s': registered\n", bus->name);
return 0;
bus_attrs_fail:
......
}
该函数中会申请priv结构体来存储bus在内核中需要表示的数据结构，可以看到:
priv->subsys.kobj.kset = bus_kset;
priv->subsys.kobj.ktype = &bus_ktype;
priv->drivers_autoprobe = 1;
这里将drivers_autoprobe设为1，且kset为bus_kset，ktype为bus_ktype。然后调用kset_register()注册platform_bus的kset，接着调用
bus_create_file()为bus创建sysfs的总线节点，然后调用priv->devices_kset = kset_create_and_add("devices", NULL,&priv->subsys.kobj);
和priv->drivers_kset = kset_create_and_add("drivers", NULL,&priv->subsys.kobj)为总线分别创建device和driver的kset容器。然后分别
初始化priv->klist_devices和priv->klist_drivers链表，后面设备和设备驱动的注册会分别添加到klist_devices和klist_drivers两个链表中。在驱动注册过程中
的bus_for_each_dev()函数中会遍历klist_devices来寻找该驱动对应的device；在设备注册过程中的bus_for_each_drv()函数会遍历klist_drivers来寻找该设备
对应的driver。