Linux设备模型

Linux的sysfs文件系统一般mount在/sys目录。本文主要介绍sysfs文件系统中设备驱动模型的建立过程，内核版本2.6.29。

设备驱动信息主要用来表示设备以及驱动的层次关系，以及处理热插拔等。/sys中与之相关的数据有：

class              代表一类设备，比如mtd、net、tty等等

bus         总线，比如PCI、USB、I2C等

device     代表一个设备

driver      代表一个驱动

 

以下是一些sysfs中的全局变量：

//  /sys/class

struct kset * class_kset = kset_create_and_add("class", NULL, NULL);                 

//     /sys/bus

struct kset * bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);    

//     /sys/devices

struct kset * devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);   

 

的基本结构

struct class {

         const char            *name;

         struct module               *owner;

         struct class_attribute             *class_attrs;

         struct device_attribute           *dev_attrs;

         struct kobject                         *dev_kobj;

         int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);

         void (*class_release)(struct class *class);

         void (*dev_release)(struct device *dev);

         int (*suspend)(struct device *dev, pm_message_t state);

         int (*resume)(struct device *dev);

         struct pm_ops *pm;

         struct class_private *p;

};

struct class_private {

         struct kset class_subsys;

         struct list_head class_devices;

         struct list_head class_interfaces;

         struct kset class_dirs;

         struct mutex class_mutex;

         struct class *class;

};

class在sysfs中的层次由struct class_private决定。struct class只是class_private的封装。

struct class_private::class_subsys.kobj.kset = class_kset;  // 父目录为/sys/class

struct class_private::class_subsys.kobj->name代表这个class在/sys/class中显示的名字

struct class::dev_attrs为设备属性，往class中添加设备的时候，这些属性会自动添加到设备目录下。

新建class有两种方法：静态创建和动态创建。

l         静态创建

static struct class i2c_adapter_class = {

       .owner                  = THIS_MODULE,

       .name                    = "i2c-adapter",

       .dev_attrs              = i2c_adapter_attrs,

       .class_attrs   = ...

};

int retval = class_register(&i2c_adapter_class)；

 

l         动态创建

i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");

class_create分配申请一块空间给class，然后对name、owner和class_release函数赋值，并最终调用class_register。

class_register

根据struct class的值，设置struct class_private

调用add_class_attrs在class中添加属性。

l         class attrs

class的属性最终是在/sys/class//目录下以文件的形式存在。用户程序可以直接对这些属性进行读写。如果要静态创建属性，可以在定义class时对.class_attrs域赋值，使其指向要添加的attr数组。如果要动态创建。可以通过函数class_create_file添加。

int class_create_file(struct class *cls, const struct class_attribute *attr);

 

如果是动态创建的属性，需要在模块卸载时调用class_remove_file释放。

如果是静态创建的属性，在调用class_unregister时会自动释放。

的基本结构

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 pm_ext_ops *pm;

         struct bus_type_private *p;

};

struct bus_type_private {

         struct kset subsys;

         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;

};

与class类似，bus在sysfs中的显示由struct bus_type_private决定，struct bus_type只是一个封装。

struct bus_type_private::subsys.kobj代表/sys/bus/目录。

struct bus_type_private::subsys.kobj.kset = bus_kset; // 默认父目录为/sys/bus/

struct bus_type_private::subsys.kobj.ktype = &bus_ktype;  // bus的属性操作

struct bus_type_private::subsys.kobj.name = 在/sys/bus/目录下显示的名字>;

在/sys/bus/目录，每创建成功一个，都会自动创建两个子目录drivers和devices，分别代表连到此的设备和驱动。在drivers和devices子目录下，每新建一个driver，会把struct bus_type中的drv_attrs属性赋给那个driver；每创建一个device，会把struct bus_type中dev_attrs赋给那个device。

新建bus

struct bus_type i2c_bus_type = {

       .name             = "i2c",

       .dev_attrs              = i2c_dev_attrs,

       .match           = i2c_device_match,

       .uevent           = i2c_device_uevent,

       .probe            = i2c_device_probe,

       .remove          = i2c_device_remove,

       .shutdown      = i2c_device_shutdown,

       .suspend         = i2c_device_suspend,

       .resume          = i2c_device_resume,

       .bus_attr         = …

};

int ret = bus_register(&i2c_bus_type);

 

int bus_register(struct bus_type *bus);

分配内存给struct bus_type_private;

根据struct bus_type的域设置bus_type_private;

根据.bus_attr设置bus的属性，这些属性在bus_unregister时会被自动释放。（bus属性也可通过bus_create_file动态添加，但所有动态添加的属性都要在卸载时通过bus_remove_file释放。）

 

．Device 的基本结构

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 */

         const char            *init_name; /* initial name of the device */

         struct device_type       *type;

         unsigned              uevent_suppress:1;

         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;

         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;

         spinlock_t           devres_lock;

         struct list_head   devres_head;

         struct list_head   node;

         struct class          *class;

         dev_t                            devt; /* dev_t, creates the sysfs "dev" */

         struct attribute_group  **groups;   /* optional groups */

         void  (*release)(struct device *dev);

};

3.2 device_register

int device_register(struct device *dev) ;

此函数将device登记到sysfs中。在调用之前，需对struct device进行初始化。

struct device dev ;

dev. parent =  ;  // 父设备

dev.release =  ; // 登记释放dev时调用的回调函数

dev.class =  ;     // struct class

dev.bus =  ;         // 所属总线

然后调用device_register(&dev) ;

int device_register(struct device *dev)

{

       device_initialize(dev);

       return device_add(dev);

}

device_initialize

做一些初始化工作，dev->kobj.kset = devices_kset ; // 代表/sys/device目录

device_add

//设置dev->kobj.parent，即确定这个dev的父目录，详情见下节

setup_parent(dev, dev->parent);

// 将dev挂到dev->kobj.parent代表的目录，如果没有parent，父目录默认被设置成dev->kobj.kset代表的目录

       kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev->bus_id);

       device_create_file(dev, &uevent_attr);  // 给设备添加uevent属性

if (MAJOR(dev->devt))

device_create_file(dev, &devt_attr);     // 给设备添加dev属性（打印主从设备号）

device_create_sys_dev_entry(dev);      // 在设备的class下创建设备链接，比如/sys/char和/sys/block，链接名字为major:minor；如果设备没有class，默认为/sys/char目录

device_add_class_symlinks(dev);        

// 在设备目录下建立subsystem链接，指向其所属的class

sysfs_create_link(&dev->kobj, &dev->class->p->class_subsys.kobj, "subsystem");

                     // 在设备所属class目录下建立指向设备的链接，以设备名命名

sysfs_create_link(&dev->class->p->class_subsys.kobj, &dev->kobj, dev->bus_id);

// 如果父设备存在，在设备目录下建立指向父设备的链接，以device命名

                     sysfs_create_link(&dev->kobj, &dev->parent->kobj, "device");

              device_add_attrs(dev);

                     // 如果有class，把class中dev_attrs属性都加上

                     device_add_attributes(dev, class->dev_attrs);

                     // 如果有type，把type中dev_attrs属性都加上

                     device_add_groups(dev, type->groups);

                     // 把device中groups指向的属性都加上

                     device_add_groups(dev, dev->groups);

              bus_add_device(dev);    // 在设备有bus时有效

                     // 如果有bus，将bus中dev_attrs都加上

                     device_add_attrs(bus_get(dev->bus), dev);

                     // 在bus中建立指向设备的链接，以设备名命名

sysfs_create_link(&bus->p->devices_kset->kobj, &dev->kobj, dev->bus_id);

// 在设备中建立指向总线的链接，以”subsystem”命名

sysfs_create_link(&dev->kobj, &dev->bus->p->subsys.kobj, "subsystem");

              dpm_sysfs_add(dev);    // 建立power属性

device_pm_add(dev);

(&dev->kobj, KOBJ_ADD);

bus_attach_device(dev);

/* 如果总线支持自动检测设备（drivers_autoprobe == 1; 默认都支持），调用device_attach(dev); device_attach中，如果发现dev已经有driver与之关联，作一些sysfs的操作；如果没有，对总线中每一个驱动调用__device_attach。

__device_attachàdriver_probe_device

driver_probe_device先调用bus的match函数，如果返回的是match，再调用really_probe。（bus的match函数在这里调用）

really_probe先看bus有没有probe函数，如果有，调用bus的probe。如果没有，调用driver的probe函数（这里就是我们驱动程序的probe函数被调用的地方）。*/

if (bus->p->drivers_autoprobe)

       ret = device_attach(dev);

klist_add_tail(&dev->knode_parent, &parent->klist_children);

list_add_tail(&dev->node, &dev->class->p->class_devices);

list_for_each_entry(class_intf, &dev->class->p->class_interfaces, node)

       if (class_intf->add_dev)

              class_intf->add_dev(dev, class_intf);

 

3.3 device的四种类型

在sysfs的设备模型中，有四种设备类型：

物理设备              有parent设备，没有class

直接虚拟设备       有parent设备和class，parent没有class

间接虚拟设备       有parent设备和class，parent有class

纯虚拟设备           没有parent，有class（网络环回设备等）

 

以挂在PCI总线上的I2C适配器为例，首先需要创建一个设备，使其bus域指向PCI bus，这是一个物理设备；然后，以这个物理设备为父设备，创建一个class为I2C_adapter_class的子设备，这个设备是直接虚拟设备，描述I2C adapter的功能。I2C子系统对每一个I2C adapter，又进一步创建了一个字符设备，I2C dev，这个字符设备的class被设置为I2C_device_class，这里I2C dev就是一个间接虚拟设备。

除非是纯虚设备，否则任何一个虚拟设备向父设备追溯，一定能找到一个物理设备。

 

struct device中有两个域，bus和class，这两个域不能同时有值。如果bus域非空，说明这个struct device是挂在某个总线上，那么它必须是一个物理设备，class域必须是NULL；如果class域非空，说明这是一个属于某个类的虚拟设备，那么它的bus域就必须是NULL。所以，在上节提到的两个函数，device_add_class_symlinks(dev) 与bus_add_device(dev)中，虽然都创建了subsystem链接，但它们只有一个会起作用，否则系统会崩溃。

 

setup_parent函数

void setup_parent(struct device *dev, struct device *parent) ;

这个函数用来决定dev被加到sysfs的哪个目录下。代码逻辑为：

       kobj = get_device_parent(dev, parent);

       if (kobj)

              dev->kobj.parent = kobj;

 

static struct kobject *get_device_parent(struct device *dev, struct device *parent) ;

这个函数会按照设备类型决定设备的父目录 :

l         如果是物理设备且有父设备 （dev->class == NULL && dev->parent）

       父目录就是父设备代表的目录

l         如果是直接虚拟设备 （dev->class && dev->parent && dev->parent->class != NULL）

在父设备代表的目录下新建一个子目录，名字为dev->class->name。然后把这个新建的目录作为设备的父目录 :/sys/devices//。

l         如果是间接虚拟设备 （dev->class && dev->parent && dev->parent->class == NULL）

       父目录就是父设备代表的目录

l         如果是纯虚拟设备 （dev->class && dev->parent == NULL）

       父目录为/sys/devices/virtual/

l         如果是物理设备且没有父设备 （dev->class == NULL && dev->parent == NULL）

    本函数不设置父目录，返回NULL。但由于此函数返回后会继续调用kobject_add，所以父目录会设置成dev->kobj->kset代表的目录，也就是一开始device_initialize函数里设置的/sys/devices目录。可以看出这是物理root设备，比如platform （/sys/devices/platform）。

 

 

4.1 struct device_driver基本结构

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 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;

};

driver_register将driver注册到sysfs系统中，在注册之前需要对driver进行初始化

struct device_driver driver = {

       .name = ;

       .bus = ;

       .probe = ;                // 探测设备

       .remove = ;           // 移除设备

       .suspend = ;         // 挂起设备 进入低功耗状态）

       .resume = ;           // 运行设备（从低功耗状态恢复）

};

 

int driver_register(struct device_driver *drv)              // 将driver登记到sysfs系统中

       bus_add_driver(drv);

       driver_add_groups(drv, drv->groups);

 

int bus_add_driver(struct device_driver *drv)

       // 分配并初始化struct driver_private

       。。。

       priv->kobj.kset = bus->p->drivers_kset;      // 父目录指向bus的drivers子目录

       // 为driver新建一个kobj，父目录在上一行的kset中指定了

       kobject_init_and_add(&priv->kobj, &driver_ktype, NULL, “s%”, drv->name);

       /* 如果drv的bus支持autoprobe（bus->p->drivers_autoprobe==1;默认都是1），调用driver_attach，driver_attach对bus中每一个device，调用__driver_attach。__driver_attach调用driver_probe_device， driver_probe_device的过程在上一章中的device_register函数中有描述。*/

       if (drv->bus->p->drivers_autoprobe)

              driver_attach(drv);

// 把driver加入到bus的drivers列表

       klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);             

module_add_driver (drv->owner, drv);

driver_create_file(drv, &driver_attr_uevent);              // 加入uevent属性

driver_add_attrs(bus, drv);    // 将bus中drv_attrs属性列表加入driver目录

add_bind_files(drv);              // 加入bind、unbind属性（与热插拔有关）

kobject_uevent(&priv->kobj, KOBJ_ADD);

 

int driver_add_groups(struct device_driver *drv, struct attribute_group **groups)

对group中每一个group，调用sysfs_create_group在driver下创建一个子目录，并将group里的属性作为文件加入到子目录中。

      

前面提到的class、bus、drivers和devices在sysfs系统中都是以目录表示；它们的属性则由文件表示。所有的目录、文件都是通过sysfs模块提供的函数创建和维护。这些sysfs的函数主要包括：

 

// 在kobj代表的目录下新建一个文件

int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)；

sysfs_add_file

       sysfs_add_file_mode

 

// 在kobj代表的目录下创建链接，指向target，链接名为name

int sysfs_create_link(struct kobject *kobj, struct kobject *target, const char *name);

 

// 如果grp->name存在，在kobj代表的子目录下创建以grp->name命名的子目录

// 在kobj代表的目录或新建的子目录下添加属性文件

int sysfs_create_group(struct kobject *kobj, const struct attribute_group *grp)；

 

// 在sysfs中创建子目录

struct kset *kset_create_and_add(const char *name, struct kset_uevent_ops *uevent_ops,

struct kobject *parent_kobj)；