Linux设备模型（bus，device，driver）

Linux设备模型是由总线（bus_type），设备（device），驱动（device_driver）这三个数据结构来描述的。在设备模型中，所有的设备都通过总线来连接。即使有些设备没有连接到一根物理上的总线，Linux为其设置了一个内部的，虚拟的platform总线，来维持总线，驱动，设备的关系。总线是处理器与一个或者多个设备之间的通道。比如一个USB控制器通常是一个PCI设备，设备模型展示了总线和他们所控制的设备之间的连接。
一般来说可以这么理解,整个的设备模型是一个OO的体系结构,总线,设备,驱动都是其中鲜活存在的对象，kobject是他们的基类，所实现的只是一些公共的接口，kset是同种类型的kobject对象的集合，也可以说是对象的容器。只是因为C语言里不可能会有C++语言里类的class继承等概念，只有通过kobject嵌入到对象结构中来实现。这样，内核使用kobject将各个对象连接起来组成一个分层的体系结构。kobject结构中包含了parent成员，指向了另一个kobject结构，也就是这个分层结构的上一层结点。而kset是通过链表来实现的。

kobject是Linux在2.6中新引进的统一的设备管理模型，目的是对Linux的2.6系统所有的设备进行统一的管理。kobject是组成设备模型的基本结构。kobject是驱动程序模型中的一个核心数据结构，与sysfs文件系统自然的绑定在一起：——每个kobject对应sysfs文件系统中的一个目录。kobject往往被嵌入到设备驱动程序模型中的组件中，如总线，设备和驱动程序的描述符。kobject的作用是，为所属“容器”提供
.引用计数器
.维持容器的层次列表或组
.为容器的属性提供一种用户态查看的视图
kset是同类型kobject结构的一个集合体，通过kset数据结构可将kobjects组成一棵层次树。

struct bus_type {
    const char      *name;       //总线类型的名称
    struct bus_attribute    *bus_attrs;  //总线属性
    struct device_attribute *dev_attrs;  //设备属性
    struct driver_attribute *drv_attrs;  //驱动属性
    int (*match)(struct device *dev, struct device_driver *drv);
    int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
    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 (*suspend_late)(struct device *dev, pm_message_t state);
    int (*resume_early)(struct device *dev);
    int (*resume)(struct device *dev);
    struct dev_pm_ops *pm;
    struct bus_type_private *p;
};
struct bus_type_private {
    struct kset subsys;                  //该总线的subsystem
    struct kset *drivers_kset;           //所有与该总线相关的驱动集合
    struct kset *devices_kset;           //所有挂接在该总线上的设备集合
    struct klist klist_devices;
    struct klist klist_drivers;
    struct blocking_notifier_head bus_notifier;
    unsigned int drivers_autoprobe:1;
    struct bus_type *bus;
};
struct bus_attribute {
    struct attribute    attr;
    ssize_t (*show)(struct bus_type *bus, char *buf);
    ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
};

subsys描述该总线的子系统，subsys是一个kset结构，他连接到一个全局变量kset bus_subsys中。这样，每一根总线系统都会通过bus_subsys结构连接起来。kset *devices_kset是指向该总线所有设备的集合的指针，kset *drivers_kset是指向该总线所有驱动的集合的指针。该总线上的设备和驱动分别用一个链表连接在一起，分别是klist_devices，klist_drivers。每次都用kset *drivers_kset，kset *devices_kset遍历所有设备/驱动很麻烦，用klist比较直接方便。

struct device {
    struct klist        klist_children;
    struct klist_node   knode_parent;   /* node in sibling list */
    struct klist_node   knode_driver;
    struct klist_node   knode_bus;
    struct device       *parent;
    struct kobject kobj;
    char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
    unsigned        uevent_suppress:1;
    const char      *init_name; /* initial name of the device */
    struct device_type  *type;
    struct semaphore    sem;    /* semaphore to synchronize calls to
                     * its driver.
                     */
    struct bus_type *bus;       /* type of bus device is on */
    struct device_driver *driver;   /* which driver has allocated this
                       device */
    void        *driver_data;   /* data private to the driver */
    void        *platform_data; /* Platform specific data, device
                       core doesn't touch it */
    struct dev_pm_info  power;
#ifdef CONFIG_NUMA
    int     numa_node;  /* NUMA node this device is close to */
#endif
    u64     *dma_mask;  /* dma mask (if dma'able device) */
    u64     coherent_dma_mask;/* Like dma_mask, but for
                         alloc_coherent mappings as
                         not all hardware supports
                         64 bit addresses for consistent
                         allocations such descriptors. */
    struct device_dma_parameters *dma_parms;
    struct list_head    dma_pools;  /* dma pools (if dma'ble) */
    struct dma_coherent_mem *dma_mem; /* internal for coherent mem
                         override */
    /* arch specific additions */
    struct dev_archdata archdata;
    dev_t           devt;   /* dev_t, creates the sysfs "dev" */
    spinlock_t      devres_lock;
    struct list_head    devres_head;
    struct klist_node   knode_class;
    struct class        *class;
    struct attribute_group  **groups;   /* optional groups */
    void    (*release)(struct device *dev);
};
struct device_private {
    struct klist klist_children;
    struct klist_node knode_parent;
    struct klist_node knode_driver;
    struct klist_node knode_bus;
    struct device *device;
};
struct device_attribute {
    struct attribute    attr;
    ssize_t (*show)(struct device *dev, struct device_attribute *attr,
            char *buf);
    ssize_t (*store)(struct device *dev, struct device_attribute *attr,
             const char *buf, size_t count);
};

需要注意的是，总线也是设备，也必须按设备注册。这里的parent是指该设备所属的父设备，struct kobject kobj;表示该设备并把它连接到结构体系中的kobject。请注意，作为一个通用准则，device->kobj->parent与&device->parent->kobj是相同的。bus_id是在总线上唯一标识该设备的字符串。struct bus_type *bus;标识了该设备连接在何种类型的总线上。struct device_driver *driver;管理该设备的驱动。void (*release)(struct device *dev);当指向设备的最后一个引用被删除时,内核调用该方法。它将从内嵌的kobject的release方法中调用。device_private中的knode_parent,knode_driver,knode_bus分别是挂入parent,驱动，总线链表中的指针。

struct device_driver {
    const char      *name;               //设备驱动程序的名称
    struct bus_type     *bus;                //该驱动所管理的设备挂接的总线类型
    struct module       *owner;
    const char      *mod_name;  /* used for built-in modules */
    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);
    struct attribute_group **groups;
    struct dev_pm_ops *pm;
    struct driver_private *p;
};
struct driver_private {
    struct kobject kobj;
    struct klist klist_devices;               //该驱动所管理的设备链表头
    struct klist_node knode_bus;              //挂入总线链表中的指针
    struct module_kobject *mkobj;
    struct device_driver *driver;
};
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);
};

name指向驱动的名字，上边的device中也有一个名为bus_id的字符数组。查看一下，struct bus_type中有一个match，函数，这个是干什么用的呢。设备有了驱动才可以工作，只有驱动没有设备也是不行，驱动和设备需要关联上，这就需要这个match函数。驱动和设备是通过name来管理的，所以在match函数中要比较device的bus_id和driver中的name是否相等。如果相等，就说明驱动和设备互相找到了，这时device_driver中的probe函数被调用。我下边的例子中是这样实现的：

static ssize_t show_driver_author(struct device_driver *driver, char *buf){
    return snprintf(buf, PAGE_SIZE, "%s/n", author);
}

下面是一个测试程序：

BUS：

#include
#include
#include
#include
#include

static char *author = "LiWanPeng";

static ssize_t show_bus_author(struct bus_type *bus, char *buf){
    return snprintf(buf, PAGE_SIZE, "%s/n", author);
}

void my_bus_release(struct device *dev){
    printk(KERN_DEBUG "my bus release/n");
}

static int virtual_bus_match(struct device *dev, struct device_driver *drv){
    return !strncmp(dev->bus_id, drv->name, strlen(drv->name));
}

struct bus_type virtual_bus = {
    .name = "my_bus",
    .match = virtual_bus_match,
};

struct device my_bus = {
    .init_name = "my_bus0",
    .release = my_bus_release,
};

EXPORT_SYMBOL(my_bus);
EXPORT_SYMBOL(virtual_bus);

static BUS_ATTR(author, S_IRUGO, show_bus_author, NULL);

static int __init bus_init(void){
    int ret;
    ret = bus_register(&virtual_bus);
    if(ret)
        return ret;
    if(bus_create_file(&virtual_bus, &bus_attr_author))
        printk(KERN_NOTICE "Unable to create author attribute/n");
    ret = device_register(&my_bus);
    if(ret)
        printk(KERN_NOTICE "Fail to register device/n");
    printk("bus regiter success/n");
    return ret;
}

static void __exit bus_exit(void){
    bus_unregister(&virtual_bus);
    device_unregister(&my_bus);
}

module_init(bus_init);
module_exit(bus_exit);
MODULE_LICENSE("GPL");

DEVICE：

#include
#include
#include
#include

char *author = "LiWanPeng";
extern struct bus_type virtual_bus;
extern struct device my_bus;

static ssize_t show_device_author(struct device *dev, struct device_attribute *attr, char *buf){
    return snprintf(buf, PAGE_SIZE, "%s/n", author);
}

void virtual_device_release(struct device *dev){
    printk("virtual_device is released/n");
}

struct device virtual_device ={
    .bus_id = "my_dev",
    .bus = &virtual_bus,
    .parent = &my_bus,
    .release = virtual_device_release,
};

static DEVICE_ATTR(author, S_IRUGO, show_device_author, NULL);

static int __init device_init(void){
    int ret;
    ret = device_register(&virtual_device);
    if(ret)
        return ret;
    if(device_create_file(&virtual_device, &dev_attr_author))
        printk(KERN_NOTICE "Unable to create author attribute/n");
    printk("device register success/n");
    return ret;
}

static void __exit device_exit(void){
    device_unregister(&virtual_device);
}

module_init(device_init);
module_exit(device_exit);
MODULE_AUTHOR("liwanpeng");
MODULE_LICENSE("GPL");

DRIVER：

#include
#include
#include
#include
#include

extern struct bus_type virtual_bus;
char *author = "LiWanPeng";

static ssize_t show_driver_author(struct device_driver *driver, char *buf){
    return snprintf(buf, PAGE_SIZE, "%s/n", author);
}

int my_driver_remove(struct device *dev){
    printk("driver is removed/n");
    return 0;
}

int my_driver_probe(struct device *dev){
    printk("driver can handle the device/n");
    return 0;
}

struct device_driver virtual_driver = {
    .name = "my_dev",
    .bus = &virtual_bus,
    .probe = my_driver_probe,
    .remove = my_driver_remove,
};

static DRIVER_ATTR(author, S_IRUGO, show_driver_author, NULL);

static int __init my_driver_init(void){
    int ret;
    ret = driver_register(&virtual_driver);
    if(ret)
        return ret;
    if(driver_create_file(&virtual_driver, &driver_attr_author))
        printk(KERN_NOTICE "Unable to create author attribute/n");
    printk("driver register success/n");
    return ret;
}

static void __exit my_driver_exit(void){
    driver_unregister(&virtual_driver);
}

module_init(my_driver_init);
module_exit(my_driver_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("liwanpeng");

Makefile:

ifneq ($(KERNELRELEASE),)
    obj-m:= driver.o bus.o device.o
else
    KERNELDIR ?= /lib/modules/$(shell uname -r)/build
    PWD := $(shell pwd)
modules:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clear:
    rm -rf *.o
endif

测试：

root@hacker:/home/hacker/program# dmesg
[  500.120888] bus regiter success
[  503.635832] device register success
[  515.237701] driver can handle the device
[  515.237772] driver register success


root@hacker:/home/hacker/program# dmesg
[  627.552494] bus regiter success
[  631.652273] driver register success
[  641.867854] driver can handle the device
[  641.867861] device register success

root@hacker:/sys/bus/my_bus/drivers/my_dev# ls -l
total 0
-r--r--r-- 1 root root 4096 2011-05-06 22:46 author
--w------- 1 root root 4096 2011-05-06 22:46 bind
lrwxrwxrwx 1 root root    0 2011-05-06 22:46 my_dev -> ../../../../devices/my_bus0/my_dev
--w------- 1 root root 4096 2011-05-06 22:46 uevent
--w------- 1 root root 4096 2011-05-06 22:46 unbind
root@hacker:/sys/bus/my_bus/drivers/my_dev# cat author
LiWanPeng