linux字符设备驱动

一、字符设备、字符设备驱动与用户空间访问该设备的程序三者之间的关系。

如图,在Linux内核中使用cdev结构体来描述字符设备,通过其成员dev_t来定义设备号(分为主、次设备号)以确定字符设备的唯一性。通过其成员file_operations来定义字符设备驱动提供给VFS的接口函数,如常见的open()、read()、write()等。

在Linux字符设备驱动中,模块加载函数通过register_chrdev_region( ) 或alloc_chrdev_region( )来静态或者动态获取设备号,通过cdev_init( )建立cdev与file_operations之间的连接,通过cdev_add( )向系统添加一个cdev以完成注册。模块卸载函数通过cdev_del( )来注销cdev,通过unregister_chrdev_region( )来释放设备号。

用户空间访问该设备的程序通过Linux系统调用,如open( )、read( )、write( ),来“调用”file_operations来定义字符设备驱动提供给VFS的接口函数。

二、字符设备驱动模型

(PS:神马情况!本地上传的图片,质量下降这么多)

 1. 驱动初始化

1.1. 分配cdev

在2.6的内核中使用cdev结构体来描述字符设备,在驱动中分配cdev,主要是分配一个cdev结构体与申请设备号,以按键驱动为例:

 1 /*……*/
 2 /* 分配cdev*/
 3 struct cdev btn_cdev;
 4 /*……*/
 5 /* 1.1 申请设备号*/
 6     if(major){
 7         //静态
 8         dev_id = MKDEV(major, 0);
 9         register_chrdev_region(dev_id, 1, "button");
10     } else {
11         //动态
12         alloc_chardev_region(&dev_id, 0, 1, "button");
13         major = MAJOR(dev_id);
14     }
15 /*……*/

从上面的代码可以看出,申请设备号有动静之分,其实设备号还有主次之分。

在Linux中以主设备号用来标识与设备文件相连的驱动程序。次编号被驱动程序用来辨别操作的是哪个设备。cdev 结构体的 dev_t 成员定义了设备号,为 32 位,其中高 12 位为主设备号,低20 位为次设备号。

设备号的获得与生成:

获得:主设备号:MAJOR(dev_t dev);

次设备号:MINOR(dev_t dev);

生成:MKDEV(int major,int minor);

设备号申请的动静之分:

静态:

1 int register_chrdev_region(dev_t from, unsigned count, const char *name);
2 /*功能:申请使用从from开始的count 个设备号(主设备号不变,次设备号增加)*/ 

静态申请相对较简单,但是一旦驱动被广泛使用,这个随机选定的主设备号可能会导致设备号冲突,而使驱动程序无法注册。

动态:

1 int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name);
2 /*功能:请求内核动态分配count个设备号,且次设备号从baseminor开始。*/ 

动态申请简单,易于驱动推广,但是无法在安装驱动前创建设备文件(因为安装前还没有分配到主设备号)。

1.2. 初始化cdev

1 void cdev_init(struct cdev *, struct file_operations *);
2 /* cdev_init()函数用于初始化 cdev 的成员,并建立 cdev 和 file_operations 之间的连接。*/

1.3. 注册cdev

1 int cdev_add(struct cdev *, dev_t, unsigned);
2 /*cdev_add()函数向系统添加一个 cdev,完成字符设备的注册。*/

1.4. 硬件初始化

硬件初始化主要是硬件资源的申请与配置,以mini2440的按键驱动为例:

1 s3c2410_gpio_cfg(S3C2410_GPG(0),S3C2410_GPIO_INPUT);
2 /*
3 void s3c2410_gpio_cfgpin(unsigned int pin, unsigned int function)
4 pin 是哪个引脚, function 是引脚模式
5 函数功能:是设置引脚模式
6 void s3c2410_gpio_setpin(unsigned int pin, unsigned int to);
7 unsigned int s3c2410_gpio_getpin(unsigned int pin);
8 */

  2.实现设备操作

用户空间的程序以访问文件的形式访问字符设备,通常进行open、read、write、close等系统调用。而这些系统调用的最终落实则是file_operations结构体中成员函数,它们是字符设备驱动与内核的接口。以mini2440的按键驱动为例:

1 /*设备操作集合*/
2 static struct file_operations btn_fops = {
3     .owner = THIS_MODULE,
4     .open = button_open,
5     .release = button_close,
6     .read = button_read
7 };

上面代码中的button_open、button_close、button_read是要在驱动中自己实现的。file_operations结构体成员函数有很多个,下面就选几个常见的来展示:

2.1. open()函数

原型:

1 int(*open)(struct inode *, struct file*);
2 /*打开*/

案例:

 1 static int button_open(struct inode *inode, struct file *file){
 2     unsigned long flags;
 3     //获取分配好的私有数据结构的首地址
 4     struct button_priv *pbtnp = container_of(inode->i_cdev,
 5                                              struct button_priv,
 6                                              btn_cdev);
 7     /*
 8 struct button_priv{
 9         char *name;
10         strcut cdev btn_cdev;
11 }
12 container_of 是个宏定义。功能是通过结构体种某个变量的首地址,
13 就可得到这个结构体的首地址
14 */
15     //保存首地址到file->private_data
16     file->private_data = pbtnp;
17     if(down_interruptible(&pbtnp->sema)){
18         printk("Proccess is INT!\n");
19         return -EINTR;
20     }
21     printk("open button successfully !\n");
22     return 0;
23 }

 2.2. read( )函数

原型:

  

1 ssize_t(*read)(struct file *, char __user*, size_t, loff_t*);
2 /*用来从设备中读取数据,成功时函数返回读取的字节数,出错时返回一个负值*/ 

案例:

 1 static ssize_t button_read(struct file *file, char __user *buf,
 2                 size_t count, loff_t *ppos){
 3     //获取首地址
 4     struct button_priv *pbtnp = file->private_data;
 5     //判断按键是否有操作,如果有,则读取键值并上报给用户;反之,则休眠
 6     wait_event_interruptible(pbtnp->btn_wq, is_press != 0);
 7     is_press = 0;
 8     //上报键值
 9     copy_to_user(buf, &key_value, sizeof(key_value));
10     return count;
11 }
12 /*参数:file是文件结构体指针,buf是用户空间内存的地址,该地址在内核空间不能直接读写,
13   count 是要读的字节数,ppos是读的位置相对于文件开头的偏移*/

2.3. write( )函数

原型:

1 ssize_t(*write)(struct file *, const char__user *, size_t, loff_t*);
2 /*向设备发送数据,成功时该函数返回写入的字节数。如果此函数未被实现,
3   当用户进行write()系统调用时,将得到-EINVAL返回值*/

案例:

 1 static ssize_t mem_write(struct file *filp, const char __user *buf,
 2                          size_t size, loff_t *ppos){
 3     unsigned long p =  *ppos;
 4     unsigned int count = size;
 5     int ret = 0;
 6     int *register_addr = filp->private_data; /*获取设备的寄存器地址*/
 7     /*分析和获取有效的写长度*/
 8     if (p >= 5*sizeof(int))
 9         return 0;
10     if (count > 5*sizeof(int) - p)
11         count = 5*sizeof(int) - p;
12     /*从用户空间写入数据*/
13     if (copy_from_user(register_addr + p, buf, count))
14         ret = -EFAULT;
15     else {
16         *ppos += count;
17         ret = count;
18     }
19     return ret;
20 }
21 /*参数:filp是文件结构体指针,buf是用户空间内存的地址,该地址在内核空间不能直接读写,
22   count 是要读的字节数,ppos是读的位置相对于文件开头的偏移*/

2.4. close( )函数

原型:

1 int(*release)(struct inode *, struct file*);
2 /*关闭*/

案例:

1 static int button_close(struct inode *inode, struct file *file){
2     /* 1.获取首地址*/
3     struct button_priv *pbtnp = file->private_data;
4     up(&pbtnp->sema);
5     return 0;
6 }

2.5. 补充说明

1. 在Linux字符设备驱动程序设计中,有3种非常重要的数据结构:struct file、struct inode、struct file_operations。

struct file 代表一个打开的文件。系统中每个打开的文件在内核空间都有一个关联的struct file。它由内核在打开文件时创建, 在文件关闭后释放。其成员loff_t f_pos 表示文件读写位置。

struct inode 用来记录文件的物理上的信息。因此,它和代表打开文件的file结构是不同的。一个文件可以对应多个file结构,但只有一个inode结构。其成员dev_t i_rdev表示设备号。

struct file_operations 一个函数指针的集合,定义能在设备上进行的操作。结构中的成员指向驱动中的函数,这些函数实现一个特别的操作, 对于不支持的操作保留为NULL。

2. 在read( )和write( )中的buff 参数是用户空间指针。因此,它不能被内核代码直接引用,因为用户空间指针在内核空间时可能根本是无效的——没有那个地址的映射。因此,内核提供了专门的函数用于访问用户空间的指针:

1 unsigned long copy_from_user(void *to, const void __user *from, unsigned long count);
2 unsigned long copy_to_user(void __user *to, const void *from, unsigned long count);

    3. 驱动注销

3.1. 删除cdev

在字符设备驱动模块卸载函数中通过cdev_del()函数向系统删除一个cdev,完成字符设备的注销。

1 /*原型:*/
2 void cdev_del(struct cdev *);
3 /*例:*/
4 cdev_del(&btn_cdev); 

3.2. 释放设备号

在调用cdev_del()函数从系统注销字符设备之后,unregister_chrdev_region()应该被调用以释放原先申请的设备号。

1 /*原型:*/
2 void unregister_chrdev_region(dev_t from, unsigned count);
3 /*例:*/
4 unregister_chrdev_region(MKDEV(major, 0), 1);

三、Linux字符设备驱动模板与案例

1. 字符设备驱动模块加载与卸载函数模板

在实际开发中,通常习惯为设备定义一个设备相关的结构体,其包含该设备所涉及到的cdev、私有数据及信号量等信息。

 1 /*字符设备驱动模块加载与卸载函数模板*/
 2 /* 设备结构体
 3 struct xxx_dev_t {
 4     struct cdev cdev;
 5     ...
 6 } xxx_dev;
 7 /* 设备驱动模块加载函数
 8 static int __init xxx_init(void) {
 9     ...
10     cdev_init(&xxx_dev.cdev, &xxx_fops);/* 初始化cdev */
11     xxx_dev.cdev.owner = THIS_MODULE;
12     /* 获取字符设备号*/
13     if (xxx_major) {
14         register_chrdev_region(xxx_dev_no, 1,DEV_NAME);
15     } else {
16         alloc_chrdev_region(&xxx_dev_no, 0, 1,DEV_NAME);
17     }
18     ret = cdev_add(&xxx_dev.cdev,xxx_dev_no, 1); /* 注册设备*/
19     ...
20 }
21
22 /*设备驱动模块卸载函数*/
23 static void __exit xxx_exit(void) {
24     unregister_chrdev_region(xxx_dev_no, 1); /* 释放占用的设备号*/
25     cdev_del(&xxx_dev.cdev); /* 注销设备*/
26     ...
27 } 

2.字符设备驱动读、写、IO控制函数模板

 1 /*字符设备驱动读、写、IO控制函数模板*/
 2 /* 读设备*/
 3 ssize_t xxx_read(struct file *filp, char__user *buf,
 4                  size_t count,loff_t*f_pos) {
 5     ...
 6     copy_to_user(buf, ..., ...);
 7     ...
 8 }
 9
10 /* 写设备*/
11 ssize_t xxx_write(struct file *filp, const char__user *buf,
12                     size_t count,loff_t*f_pos) {
13     ...
14     copy_from_user(..., buf, ...);
15     ...
16 }
17
18 /* ioctl函数 */
19 int xxx_ioctl(struct inode *inode, struct file*filp,
20                 unsigned int cmd, unsigned long arg) {
21     ...
22     switch(cmd) {
23     caseXXX_CMD1:
24         ...
25         break;
26     caseXXX_CMD2:
27         ...
28         break;
29     default:
30     /* 不能支持的命令 */
31          return  - ENOTTY;
32     }
33     return 0;
34 }

在设备驱动的读、写函数中,filp是文件结构体指针,buf是用户空间内存的地址,该地址在内核空间不能直接读写,count 是要读的字节数,f_pos是读的位置相对于文件开头的偏移。

mini2440按键驱动实例

 1 #include <linux/init.d>
 2 #include <linux/module.h>
 3 #include <linux/cdev>
 4 #include <linux/fs.h>
 5 #include <linux/types.h>
 6 #include <linux/uaccess.h>
 7 #include <linux/device.h>
 8
 9 #include <plat/gpio-cfg.h>
10 #include <asm/gpio.h>
11
12 static int major;
13 /* 分配cdev*/
14 struct cdev btn_cdev;
15
16 /* 记录按键值*/
17 static unsigned char key_value;
18
19 /* 2. 实现设备操作*/
20 /* 2.1 read*/
21 static ssize_t button_read(struct file *file, char __user *buf,
22                             size_t count, loff_t *ppos) {
23     int status = 0;
24
25     //1. 获取GPIO的状态
26     status =  s3c2410_gpio_getpin(S3C2410_GPG(0));
27
28     if(status == 1)
29         key_value = 0x50;
30     else
31         key_value = 0x51;
32
33     //2. 上报GPIO的状态
34     copy_to_user(buf, &key_value, sizeof(key_value));
35
36     return count;
37 }
38
39 /* 2.2 设备操作集合*/
40 static struct file_operations btn_fops = {
41     .owner = THIS_MODULE,
42     .read = button_read
43 };
44
45 //设备类
46 static struct class *btn_cls;
47
48 /* 1. 驱动初始化*/
49 static init button_init(void){
50     dev_t dev_id;
51 /* 1.1 申请设备号*/
52     if(major){
53         //静态
54         dev_id = MKDEV(major, 0);
55         register_chrdev_region(dev_id, 1, "button");
56     } else {
57         //动态
58         alloc_chardev_region(&dev_id, 0, 1, "button");
59         major = MAJOR(dev_id);
60     }
61
62 /* 1.2 初始化cdev*/
63     cdev_init(&btn_cdev, &btn_fops);
64
65 /* 1.3 注册cdev*/
66     cdev_add(&btn_cdev, dev_id, 1);
67
68 /* 1.4 自动创建设备节点*/
69 /* 1.4.1 创建设备类*/
70     //sys/class/button
71     btn_cls = class_create(THIS_MODULE, "button");
72 /* 1.4.2 创建设备节点*/
73     device_create(btn_cls, NULL, dev_id, NULL, "button");
74
75 /* 1.4 硬件初始化*/
76    s3c2410_gpio_cfgpin(S3C2410_GPG(0),S3C2410_GPIO_INPUT);
77     return 0;
78
79 }
80
81
82 /* 3. 驱动注销*/
83 static void button_exit(void){
84
85 /* 3.1 删除设备节点*/
86     device_destroy(btn_cls, MKDEV(major, 0));
87     class_destroy(btn_cls);
88
89 /* 3.2 删除cdev*/
90     cdev_del(&btn_cdev);
91
92 /* 3.3 释放设备号*/
93     unregister_chrdev_region(MKDEV(major, 0), 1);
94 }
95
96 module_init(button_init);
97 module_exit(button_exit);
98 MODULE_LICENSE("GPL v2");

时间: 2024-10-01 13:33:34

linux字符设备驱动的相关文章

深入理解Linux字符设备驱动

文章从上层应用访问字符设备驱动开始,一步步地深入分析Linux字符设备的软件层次.组成框架和交互.如何编写驱动.设备文件的创建和mdev原理,对Linux字符设备驱动有全面的讲解. 本文整合之前发表的<Linux字符设备驱动剖析>和<Linux 设备文件的创建和mdev>两篇文章,基于linux字符设备驱动的所有相关知识给读者一个完整的呈现. 一.从最简单的应用程序入手 1.很简单,open设备文件,read.write.ioctl,最后close退出.如下: 二./dev目录与文

(57)Linux驱动开发之三Linux字符设备驱动

1.一般情况下,对每一种设备驱动都会定义一个软件模块,这个工程模块包含.h和.c文件,前者定义该设备驱动的数据结构并声明外部函数,后者进行设备驱动的具体实现. 2.典型的无操作系统下的逻辑开发程序是:这种三层的裸机驱动模型是足够满足低耦合.高内聚的特点的. 3.当有操作系统存在时,设备驱动成为了连接硬件和内核的桥梁,这时候的设备驱动对外表现为操作系统的API,与直接裸机开发不同,裸机开发时的设备驱动是应用工程师的API.如果设备驱动都按照操作系统给出的独立于设备的接口而设计,应用程序将可以使用统

Linux字符设备驱动实现

Linux字符设备驱动实现 要求 编写一个字符设备驱动,并利用对字符设备的同步操作,设计实现一个聊天程序.可以有一个读,一个写进程共享该字符设备,进行聊天:也可以由多个读和多个写进程共享该字符设备,进行聊天 主要过程 实现 字符驱动设备 /* 参考:深入浅出linux设备驱动开发 */ #include <linux/module.h> #include <linux/init.h> #include <linux/fs.h> #include <asm/uacc

linux 字符设备驱动开发详解

一.设备的分类及特点 1.字符设备 字符设备是面向数据流的设备,没有请求缓冲区,对设备的存取只能按顺序按字节的存取而不能随机访问.    Linux下的大多设备都是字符设备.应用程序是通过字符设备节点来访问字符设备的.通常至少需要实现 open, close, read, 和 write 等系统调用.    设备节点一般都由mknod命令都创建在/dev目录下,包含了设备的类型.主/次设备号以及设备的访问权限控制等,如:crw-rw----  1 root  root 4, 64 Feb 18

Linux字符设备驱动剖析

一.先看看设备应用程序 1.很简单,open设备文件,read.write.ioctl,最后close退出.如下: intmain(int argc ,char *argv[]){ unsigned char val[1] = 1; int fd =open("/dev/LED",O_RDWR);//打开设备 write(fd,val,1);//写入设备,这里代表LED全亮 close(fd);//关闭设备 return 0; } 二./dev目录与文件系统 2./dev是根文件系统下

Linux字符设备驱动框架

字符设备是Linux三大设备之一(另外两种是块设备,网络设备),字符设备就是字节流形式通讯的I/O设备,绝大部分设备都是字符设备,常见的字符设备包括鼠标.键盘.显示器.串口等等,当我们执行ls -l /dev的时候,就能看到大量的设备文件,c就是字符设备,b就是块设备,网络设备没有对应的设备文件.编写一个外部模块的字符设备驱动,除了要实现编写一个模块所需要的代码之外,还需要编写作为一个字符设备的代码. 驱动模型 Linux一切皆文件,那么作为一个设备文件,它的操作方法接口封装在struct fi

Linux字符设备驱动注册流程

其中一部分从伯乐在线和网络上摘抄的内容,不用于商业用途. 一.linux系统将设备分为3类:字符设备.块设备.网络设备. 字符设备:是指只能一个字节一个字节读写的设备,不能随机读取设备内存中的某一数据,读取数据需要按照先后数据.字符设备是面向流的设备,常见的字符设备有鼠标.键盘.串口.控制台和LED设备等. 块设备:是指可以从设备的任意位置读取一定长度数据的设备.块设备包括硬盘.磁盘.U盘和SD卡等. 每一个字符设备或块设备都在/d ev目录下对应一个设备文件.linux用户程序通过设备文件(或

Linux字符设备驱动开发的一般方法

.output_wrapper pre code { font-family: Consolas, Inconsolata, Courier, monospace; display: block !important; white-space: pre !important; overflow: auto !important } .output_wrapper a:hover { text-decoration: underline; color: rgb(0, 96, 100) } .out

linux字符设备驱动--基本知识介绍

一.设备驱动的分类 1.字符设备 字符设备是指那些能一个字节一个字节读取数据的设备,如LED灯.键盘.鼠标等.字符设备一般需要在驱动层实现open().close().read().write().ioctl()等函数. 2.块设备 块设备与字符设备类似,一般是像磁盘一样的设备.在块设备中还可以容纳文件系统,并存储大量的信息.在linux系统中,进行块设备读写时,每次只能传输一个或者多个块.linux也可以让应用程序像访问字符设备一样访问块设备,一次只读取一个字节. 3.网络设备 网络设备主要负