Linux设备驱动的class(类)的理解(以timed_output为基础)

 

一、  前言

前天写了关于安卓震动系统的驱动开发全过程，其中用到了timed_output这个驱动模型，那天只是简单的用了一下，今天拿出来彻底的研究一下，分享一下我的理解。

在使用这个驱动模型的时候，我一直都很奇怪，它的名字看上去和时间有很大的关系，在我的心里我也以为它会提供一些与时间操作相关的函数，帮助开发人员简单的完成与时间相关的操作，但是翻遍了它的实现代码都没有发现它与时间的半毛钱关系。真坑爹！

面对这么坑爹的一个驱动模型，我很想知道，它是linux kernel原来就带的呢，还是android为linux kernel添加的，首先我看到它的实现代码timed_output.c所在的目录drivers/staging/android，比较明显这个是android为linux kernel添加的，再打开文件看它的版权

*Copyright (C) 2009 Google, Inc.

* Author: Mike Lockwood <lockwood@android.com

更加确定这个就是android为linux kernel添加的，这个驱动模型写的这么酱油，我想也有他的道理，它的首要作用就是为android HAL层和内核驱动 提供通用的接口模型，它已经完全具备了这个功能。再加上这个驱动模型我只发现了 振动（vibrator）系统会用得到，震动系统本来就很简单，可能google觉得没必要为了使用这么少，还这么简单的系统做太多太复杂的工作。

好了上面全是废话，下面正式开始。

二、   timed_output代码分析

1. 注册函数和删除

timed_output属于一个内核模块，分析一个内核模块一般都从

module_init(timed_output_init);

module_exit(timed_output_exit);

两个宏分析开始，这两个宏左右是注册内核模块的开始和结束函数。具体实现方法是，通过这两个宏向一个数据段中添加和删除这两个函数指针来完成的，这里不做说明了网上有很多说的很好。

 

static int __init timed_output_init(void)

{

         return create_timed_output_class();

}

函数调用create_timed_output_class

具体看

static int create_timed_output_class(void)

{

         if (!timed_output_class) {

timed_output_class = class_create(THIS_MODULE, "timed_output");//建立//timed_output_class类

                  if (IS_ERR(timed_output_class))

                          return PTR_ERR(timed_output_class);

                  atomic_set(&device_count, 0);

         }

         return 0;

}

这个函数里用到了原子操作atomic_set(&device_count, 0);对于原子操作,我google到一个说明讲的很好:

所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或事件打断，也就说，它的最小的执行单位，不可能有比它更小的执行单位，因此这里的原子实际是使用了物理学里的物质微粒的概念。
　　原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中，它们都使用汇编语言实现，因为C语言并不能实现这样的操作。
　　原子操作主要用于实现资源计数，很多引用计数(refcnt)就是通过原子操作实现的。

删除函数

static void __exit timed_output_exit(void)

{

class_destroy(timed_output_class);

}

调用 class_destroy()删除这个类 .这两个函数非常简单, 当内核执行这两个函数以后就可以在/sys/class/目录下看到timed_output这个目录了.

1. Timed_output设备的注册和删除

int timed_output_dev_register(struct timed_output_dev *tdev);

void timed_output_dev_unregister(struct timed_output_dev *tdev)

这两个函数是添加和删除设备时候 用户代码自己调用的下面一条条分析语句分析

int timed_output_dev_register(struct timed_output_dev *tdev)

{

int ret;

//timed_output结构体中 name enable get_time三个成员不能为空

if (!tdev || !tdev->name || !tdev->enable || !tdev->get_time)

          return -EINVAL;

//如果timed_output 类没有注册的话,就从这里注册,也就是说要使用timed_output驱动//框架不用module_init(timed_output_init);也是可以的

ret = create_timed_output_class();

if (ret < 0)

          return ret;

//原子计数加1

tdev->index = atomic_inc_return(&device_count);

//创建设备

tdev->dev = device_create(timed_output_class, NULL,

          MKDEV(0, tdev->index), NULL, tdev->name);

if (IS_ERR(tdev->dev))

          return PTR_ERR(tdev->dev);

//创建enable设备文件

//这里有个参数dev_attr_enable结构体,是由

//static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, enable_show, enable_store);

//这个宏创建的

ret = device_create_file(tdev->dev, &dev_attr_enable);

if (ret < 0)

          goto err_create_file;

//给结构体变量付一个值

dev_set_drvdata(tdev->dev, tdev);

tdev->state = 0;

return 0;

 

err_create_file:

device_destroy(timed_output_class, MKDEV(0, tdev->index));

printk(KERN_ERR "timed_output: Failed to register driver %s\n",

                   tdev->name);

 

return ret;

}

void timed_output_dev_unregister(struct timed_output_dev *tdev)

//这个函数很简单不做说明

{

device_remove_file(tdev->dev, &dev_attr_enable);

device_destroy(timed_output_class, MKDEV(0, tdev->index));

dev_set_drvdata(tdev->dev, NULL);

}

1. Enable的读写函数

 

static ssize_t enable_show(struct device *dev, struct device_attribute *attr,

          char *buf)

{

struct timed_output_dev *tdev = dev_get_drvdata(dev);

int remaining = tdev->get_time(tdev);

 

return sprintf(buf, "%d\n", remaining);

}

 

static ssize_t enable_store(

          struct device *dev, struct device_attribute *attr,

          const char *buf, size_t size)

{

struct timed_output_dev *tdev = dev_get_drvdata(dev);

int value;

 

if (sscanf(buf, "%d", &value) != 1)

          return -EINVAL;

 

tdev->enable(tdev, value);

 

return size;

}

 

static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, enable_show, enable_store);

这几个函数都很简单不做说明

三、  Class理解

看完上面的代码，觉得还是非常好理解的，唯一不懂的就是上面class创建删除，device创建删除的具体实现。class是设备驱动中很重要的一块，下面是从LDD3中关于class的说明：

一个类是一个设备的高级视图, 它抽象出低级的实现细节. 驱动可以见到一个SCSI 磁盘或者一个 ATA 磁盘, 在类的级别, 它们都是磁盘. 类允许用户空间基于它们做什么来使用设备, 而不是它们如何被连接或者它们如何工作.

几乎所有的类都在 sysfs 中在 /sys/class 下出现. 因此, 例如, 所有的网络接口可在 /sys/class/net 下发现, 不管接口类型.输入设备可在 /sys/class/input 下, 以及串行设备在 /sys/class/tty. 一个例外是块设备, 由于历史的原因在 /sys/block.类成员关系常常由高级的代码处理, 不必要驱动的明确的支持.

我的理解是类就是 设备的分类，通过特定的实现方法，系统把设备分成一定的类，类里面每个设备生成自己的设备文件，提供给上层调用。

关于class的创建和删除本来想自己写的，但是在网上看到skywang12345大神一个特别好的文章先把地址贴过来

http://www.cnblogs.com/skywang12345/archive/2013/05/15/driver_class.html

下面是具体内容复制粘贴的。 （本人属于转载！！！！！！！！！）

linux中class_create和class_register说明

 

本文介绍linux中class_create和class_register的相关使用方法

1 class结构体介绍

    内核中定义了struct class结构体，顾名思义，一个struct class结构体类型变量对应一个类，内核同时提供了class_create(…)函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建好了这个类，再调用device_create(…)函数来在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应device_create(…)函数，去/sysfs下寻找对应的类从而创建设备节点。

 

2 class相关API说明

如下表：

 

 

3 class_create()使用示例

示例一，通过class_create()、class_destroy()去注册和注销/sys/class/my_char_dev

代码如下：

 

 

 1 #include <linux/module.h>

 2 #include <linux/init.h>

 3 #include <linux/device.h>

 4

 5 struct class *mem_class;

 6

 7 static int __init class_create_destroy_init(void)

 8 {

 9     // class_create动态创建设备的逻辑类，并完成部分字段的初始化，然后将其添加到内核中。创建的逻辑类位于/sys/class/。

10     // 参数：

11     //        owner, 拥有者。一般赋值为THIS_MODULE。

12     //        name, 创建的逻辑类的名称。

13     mem_class = class_create(THIS_MODULE, "my_char_dev");

14     if (mem_class==NULL)

15     {

16         printk("<0> create class failed!\n");

17         return -1;

18     }

19

20     return 0;

21 }

22

23 static void __exit class_create_destroy_exit(void)

24 {

25     if (mem_class != NULL)

26     {

27         class_destroy(mem_class);

28         mem_class = NULL;

29     }

30

31 }

32

33 module_init(class_create_destroy_init);

34 module_exit(class_create_destroy_exit);

35

36 MODULE_LICENSE("GPL");

 

 

4 class_register()使用示例

示例二，通过class_register()、class_unregister()去注册和注销/sys/class/my_char_dev

代码如下：

 

 

 1 #include <linux/module.h>

 2 #include <linux/init.h>

 3 #include <linux/device.h>

 4 #include <linux/slab.h>

 5

 6 #define CLASS_NAME "my_char_dev"

 7 struct class *mem_class;

 8

 9 static void class_create_release (struct class *cls)

10 {

11     printk("%s\n", __func__ );

12     kfree(cls);

13 }

14

15 static int __init class_create_destroy_init(void)

16 {

17     printk("%s\n", __func__);

18

19     int ret;

20

21     // 申请class结构体内存

22     mem_class = kzalloc(sizeof(*mem_class), GFP_KERNEL);

23     if (mem_class == NULL)

24     {

25         printk("create mem class failed!\n");

26         return -1;

27     }

28     printk("create mem class success\n");

29

30     mem_class->name = CLASS_NAME;

31     mem_class->owner = THIS_MODULE;

32     // 注销时class时的回调函数，在此回调函数中释放之前所分配的class结构体内存

33     mem_class->class_release = class_create_release;

34

35     // 将class注册到内核中，同时会在/sys/class/下创建class对应的节点

36     int retval = class_register(mem_class);

37     if (ret)

38     {

39         printk("class_register failed!\n");

40         kfree(mem_class);

41         return -1;   

42     }

43     printk("class_register success\n");

44

45

46     return 0;

47 }

48

49 static void __exit class_create_destroy_exit(void)

50 {

51     printk("%s\n", __func__);

52

53     if (mem_class != NULL)

54     {

55         class_unregister(mem_class);

56         mem_class = NULL;

57     }

58 }

59

60 module_init(class_create_destroy_init);

61 module_exit(class_create_destroy_exit);

62

63 MODULE_LICENSE("GPL");

 

 

附录一，class_create()和class_register()对比

实际上，示例一和示例二是等价的。具体的可以通过查看class_create()和class_register()、class_destroy()和class_unregister()的源码去验证。

class_register()的代码如下：

 

1 // 将class注册到/sys/class/中

2 #define class_register(class)           \

3 ({                      \

4     static struct lock_class_key __key; \

5     __class_register(class, &__key);    \

6 })

 

class_register()是通过调用__class_register()来注册到sysfs中的。

__class_register()的代码如下：

 

 

 1 int __class_register(struct class *cls, struct lock_class_key *key)

 2 {

 3     struct class_private *cp;

 4     int error;

 5 

 6     pr_debug("device class '%s': registering\n", cls->name);

 7 

 8     cp = kzalloc(sizeof(*cp), GFP_KERNEL);

 9     if (!cp)

10         return -ENOMEM;

11     klist_init(&cp->class_devices, klist_class_dev_get, klist_class_dev_put);

12     INIT_LIST_HEAD(&cp->class_interfaces);

13     kset_init(&cp->class_dirs);

14     __mutex_init(&cp->class_mutex, "struct class mutex", key);

15     error = kobject_set_name(&cp->class_subsys.kobj, "%s", cls->name);

16     if (error) {

17         kfree(cp);

18         return error;

19     }

20 

21     /* set the default /sys/dev directory for devices of this class */

22     if (!cls->dev_kobj)

23         cls->dev_kobj = sysfs_dev_char_kobj;

24 

25 #if defined(CONFIG_SYSFS_DEPRECATED) && defined(CONFIG_BLOCK)

26     /* let the block class directory show up in the root of sysfs */

27     if (cls != &block_class)

28         cp->class_subsys.kobj.kset = class_kset;

29 #else

30     cp->class_subsys.kobj.kset = class_kset;

31 #endif

32     cp->class_subsys.kobj.ktype = &class_ktype;

33     cp->class = cls;

34     cls->p = cp;

35

36     // 将class注册到内核中

37     error = kset_register(&cp->class_subsys);

38     if (error) {

39         kfree(cp);

40         return error;

41     }

42     error = add_class_attrs(class_get(cls));

43     class_put(cls);

44     return error;

45 }

 

class_unregister()的代码如下：

 

 

1 void class_unregister(struct class *cls)

2 {

3     pr_debug("device class '%s': unregistering\n", cls->name);

4     remove_class_attrs(cls);

5     // 将class从内核中注销

6     kset_unregister(&cls->p->class_subsys);

7 }

 

 

 

下面，我们查看class_create()、class_destroy()的相关代码。

class_create()的代码如下：

 

1 #define class_create(owner, name)       \

2 ({                      \

3     static struct lock_class_key __key; \

4     __class_create(owner, name, &__key);    \

5 })

 

class_create()是通过调用__class_create()注册到内核中的。

__class_create()的代码如下：

 

 

 1 struct class *__class_create(struct module *owner, const char *name,

 2                  struct lock_class_key *key)

 3 {

 4     struct class *cls;

 5     int retval;

 6 

 7     // 分配class结构体

 8     cls = kzalloc(sizeof(*cls), GFP_KERNEL);

 9     if (!cls) {

10         retval = -ENOMEM;

11         goto error;

12     }

13 

14     cls->name = name;

15     cls->owner = owner;

16     // class对应的释放函数，在class从内核中注销时会执行该函数

17     cls->class_release = class_create_release;

18     

19     // 通过调用__class_register()将class注册到内核中

20     retval = __class_register(cls, key);

21     if (retval)

22         goto error;

23     

24     return cls;

25     

26 error:

27     kfree(cls);

28     return ERR_PTR(retval);

29 }

 

 

class_create_release的代码如下：

 

1 static void class_create_release(struct class *cls)

2 {

3     pr_debug("%s called for %s\n", __func__, cls->name);

4     // 释放class结构体

5     kfree(cls);

6 }

 

实际上，__class_create()是通过调用__class_register()注册到sysfs中的！所以，本质上，class_create()和class_register()的作用是类似的。

class_destroy()的代码如下：

 

 

1 void class_destroy(struct class *cls)

2 {

3     if ((cls == NULL) || (IS_ERR(cls)))

4         return;

5     // 调用class_unregister()将class从内核中注销

6     class_unregister(cls);

7 }

 

 

实际上，class_destroy()是通过调用class_unregister()实现的。

 

 关于struct device *device_create(struct class *class, struct device *parent,

                          dev_t devt, void *drvdata, const char *fmt, ...)

这个函数用于在一个类中创建一个虚拟设备，如果parent不为空，那么新创建的设备回事这个parent的字设备.创建的这个设备可以用来创建在sysfs中创建设备文件.

int device_create_file(struct device *dev,

                 const struct device_attribute *attr)

为dev在sysfs中创建一个设备文件

 

这里两个函数使用方法比较简单,不做过多说明了,完全参照timed_output 使用方法就可以了.

四、  总结

这个文章主要是原理的分析，不具备太多的实际操作，学习一下理论磨刀不误砍柴工。

Timed_output驱动框架虽然很简单，担他涉及到了linux驱动中的class的全部的使用方法，对于新手来讲是个很好的参考例子，以后涉及到需要建立class时候可以参考一下。

Class是linux很重要的一个概念，它的使用方法一定要掌握。