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代码分析
- 注册函数和删除
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这个目录了.
- 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);
}
- 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很重要的一个概念,它的使用方法一定要掌握。
linux内核下载地址: https://www.kernel.org/pub/linux/kernel