前言:android系统中马达采用的是timed_output这个驱动模型,主要是android为linux kernel添加的,实现代码timed_output.c所在的目录drivers/staging/android,是android为linux kernel添加的,
版权
*Copyright (C) 2009 Google, Inc.
* Author: Mike Lockwood
确定是android为linux kernel添加的,目前仅仅用于vibrator。
二、 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类,/sys/class/timed_output
if(IS_ERR(timed_output_class))
returnPTR_ERR(timed_output_class);
atomic_set(&device_count,0);
}
return0;
}
这个函数里用到了原子操作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这个目录了.
2. 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();//确保在sys/class/下创建类timed_output
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结构体,是由
//staticDEVICE_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 toregister 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);
}
3. Enable的读写函数
staticssize_tenable_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);
}
staticssize_tenable_store(
struct device *dev, structdevice_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
2 #include
3 #include
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
2 #include
3 #include
4 #include
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 memclass failed!\n");
26 return -1;
27 }
28 printk("create memclass 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_registerfailed!\n");
40 kfree(mem_class);
41 return -1;
42 }
43 printk("class_registersuccess\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 blockclass 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("deviceclass '%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("%scalled 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很重要的一个概念,它的使用方法一定要掌握。
http://blog.csdn.net/angle_birds/article/details/16801609