字符设备驱动

字符设备指必须以串行顺序依次访问的设备，如led、触摸屏、鼠标等

通过open、close、read、write等系统调用访问
块设备驱动

块设备可以按任意顺序访问，以块为单位进行操作，如硬盘、EMMC等

块设备和字符设备的驱动设计有很大的差异，但是也可以通过open、close、read、write等系统调用进行访问，不过一般都是使用文件系统来进行管理
网络设备驱动

网络设备是面向数据包的接收和发送设计的，在文件系统中并没有对应的设备结点，通过socket接口进行访问

本文主要讲解字符设备

二、字符设备驱动概念

Linux下一切皆文件，例如一个led设备，在文件系统中表现为一个设备节点/dev/led，应用层通过open、read、write等系统调用就可以控制led

例如想让led亮，就打开设备文件写1

int fd;
int val = 1;

fd = open("/dev/led", xxx);
write(fd, &val, sizeof(val));
12345
1
2
3
4
5
6

这样就可以使得led被点亮了

现在思考一个问题，为什么这样就可以使led点亮？

要想让led点亮，必须操作硬件，操作硬件这部分工作就是led的驱动所完成的

最简单的方式就是，应用层对led进行open操作，那么就对应led驱动程序中的一个led_open。应用层对led进行write操作，就对应led驱动程序的一个led_write操作，然后在led_write操作中去操控硬件，进而控制led

那么对led设备节点进行open、write系统调用，怎么才能调用到驱动程序的led_open、led_write呢？

当应用层调用open、read、write等操作时，会引发一个异常，导致系统变为内核态，然后再去执行相应的系统调用sys_open、sys_read、sys_write等

在sys_open、sys_read、sys_write中会去找到相应的驱动程序，然后再调用驱动程序的open、read、write去操作硬件

如下图所示

在这里插入图片描述

那么在虚拟文件系统中调用sys_open，是怎么找到led驱动程序而不是其他驱动呢？

首先介绍一下设备号

每一个设备都有一个设备号，使用32位表示，其中高12位表示主设备号，低20位表示次设备号

使用ls /dev/led -l查看设备，可以得到下面信息

crw-rw----    1 root     0          10, 131 Jan  1 12:00 /dev/led
1
1
2

其中10, 131表示设备号，10表示主设备号，131表示次设备号

为了方便理解，我们可以认为内核中有一个字符设备数组，以主设备号为下标，字符设备本身为数组元素，字符设备中有一个文件操作集，设置了一系列的操作函数(如led_open、led_write、led_read)

sys_open等系统调用通过设备文件的主设备好找到数组中的一项，通过字符设备的文件操作集合调用到led驱动中的led_open等函数

在这里插入图片描述

字符设备驱动就是要完善这个fops(文件操作集)，然后指定设备号，向内核注册字符设备

三、注册字符设备

首先看一下字符设备对象

struct file_operations {
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	int (*open) (struct inode *, struct file *);
    ...
};

struct cdev {
	struct kobject kobj;
	struct module *owner; /* 所属模块 */
	const struct file_operations *ops; /* 文件操作集 */
	struct list_head list;
	dev_t dev; /* 设备号 */
	unsigned int count;
};
1234567891011121314
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

其中的dev_t成员定义了设备号，为32位，高12位为主设备号，低20位为次设备号

内核使用下面两个宏获取主次设备号

MAJOR(dev_t dev) //主设备号
MINOR(dev_t dev) //次设备号
12
1
2
3

使用下面该宏获取设备号

MKDEV(int major, int minor)
1
1
2

每个字符设备都有自己对应的设备号范围，下面介绍怎么申请设备号

申请设备号

动态分配

此函数指定次设备号和设备号个数，可以动态分配主设备号

/*
 * dev：返回申请到的设备号
 * baseminor：起始次设备号
 * count：申请的设备号个数
 */
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
			const char *name)
1234567
1
2
3
4
5
6
7
8

静态分配

此函数必须主次设备号和设备号个数

/*
 * from：其实设备号
 * count：设备号个数
 */
int register_chrdev_region(dev_t from, unsigned count, const char *name)
12345
1
2
3
4
5
6

在申请完设备号后，就可以利用此设备号去注册字符设备了

注册字符设备

和字符设备相关的函数

void cdev_init(struct cdev *, struct file_operations *);
struct cdev *cdev_alloc(void);
void cdev_put(struct cdev *p);
int cdev_add(struct cdev *, dev_t, unsigned);
void cdev_del(struct cdev *);
12345
1
2
3
4
5
6

cdev_init：用来关联字符设备和fops，其中file_operations就是一个文件操作集，里面设置了一系列的操作函数(例如open、read、write)

cdev_alloc：分配一个字符设备对象

cdev_add：注册字符设备

cdev_del：注销一个字符设备

注册一个字符设备的步骤

struct cdev *cdev_alloc(void); //分配字符设备

void cdev_init(struct cdev *, struct file_operations *); //绑定一个fops

int cdev_add(struct cdev *, dev_t, unsigned); //将字符设备和申请到的设备号注册进内核
12345
1
2
3
4
5
6

下面是一个简单的字符设备驱动

mydev.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>

static dev_t dev_id;
static struct cdev *mydev;

ssize_t mydev_read(struct file *file, char __user *data, size_t size, loff_t * loff)
{
    printk("mydev_read\n");
    
    return 0;
}

ssize_t mydev_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
{
    printk("mydev_write\n");

    return 0;
}

int mydev_open(struct inode *inode, struct file *file)
{
    printk("mydev_open\n");

    return 0;
}

/* 文件操作集合 */
static struct file_operations mydev_fops = {
	.owner = THIS_MODULE,
    .read   = mydev_read,
    .open   = mydev_open,
    .write  = mydev_write,
};

static __init int mydev_init(void)
{
    /* 申请设备号 */
    alloc_chrdev_region(&dev_id, 1, 1, "mydev");

    /* 分配字符设备 */
    mydev = cdev_alloc();

    /* 设置字符设备 */
    cdev_init(mydev, &mydev_fops);

    /* 注册字符设备 */
    cdev_add(mydev, dev_id, 1);

    /* 打印申请到的主次设备号 */
    printk("major:%d; minor:%d\n", MAJOR(dev_id), MINOR(dev_id));

    return 0;
}

static __exit void mydev_exit(void)
{
    cdev_del(mydev);
    kfree(mydev);
    unregister_chrdev_region(dev_id, 1);
}

module_init(mydev_init);
module_exit(mydev_exit);

MODULE_LICENSE("GPL");
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

四、编译模块

编写以驱动程序后，我们应该如何编译驱动程序，有两种方法，一种是将驱动程序和内核编译到一起，一种是单独将驱动程序编写成模块

这里介绍第二种

将驱动程序编译成模块需要编写Makefile

Makefile如下

KERN_DIR = /work/linux/kernel/

all:
        make -C $(KERN_DIR) M=`pwd` modules

clean:
        make -C $(KERN_DIR) M=`pwd` modules clean
        rm -rf modules.order

obj-m   += mydev.o
12345678910
1
2
3
4
5
6
7
8
9
10
11

其中KERN_DIR = /work/linux/kernel/表示内核源码树，这个需要根据你自己内核所在的路径修改

obj-m += mydev.o表明要编译mydev.c文件

make -C $(KERN_DIR) M=pwd modules表明跳转到内核源码树，编译模块

将Makefile和mydev.c放到一起，执行make，可以得到驱动模块mydev.ko

五、加载模块

使用insmod xxx.ko可以加载驱动模块

使用lsmod可以查看当前加载的模块

使用rmmod xxx可以卸载已加载的驱动模块

将上面的生成的mydev.ko拷贝到实验平台，执行insmod mydev.ko

一旦加载模块，内核就会运行module_init(mydev_init)指定的模块入口，mydev_init函数中，我们申请的设备号，注册了字符设备，并打印了主次设备号

可以看到打印信息

major:250; minor:1
1
1
2

表示主设备号250，次设备号1（你所看到的可能不同）

此时模块已经加载了，我们可以通过cat /proc/devices查看到我们已经注册了字符设备

但是在/dev目录下并没有生成设备节点，我们暂时还无法对设备进行操作，下面介绍如何创建设备节点

六、创建设备节点

创建设备节点分为手动创建和自动创建，下面分别介绍

手动创建

在上面驱动程序打印出major:250; minor:1，我们可以利用这些信息来创建设备节点

通过下面命令创建设备节点
```
mknod 设备名 设备类型(字符：c,块：b) 主设备号 从设备号
1
1
2
```
执行
```
mknod /dev/mydev c 250 1
1
1
2
```
运行后就生成了设备节点/dev/mydev

自动创建

自动创建利用的是udev机制或者mdev机制，当驱动在/sys创建相关的设备信息时，udev或者mdev会根据这些信息创建设备节点

下面介绍创建设备节点

static struct class *mydev_class;

mydev_class = class_create(THIS_MODULE, "mydev"); //创建一个类
device_create(mydev_class, NULL, dev_id, NULL, "mydev"); //根据设备号创建设备节点
1234
1
2
3
4
5

销毁设备节点

device_destroy(mydev_class, dev_id); //销毁设备节点
class_destroy(mydev_class); //销毁类
12
1
2
3

修改后的驱动

mydev.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>

static dev_t dev_id;
static struct cdev *mydev;
static struct class *mydev_class;

ssize_t mydev_read(struct file *file, char __user *data, size_t size, loff_t * loff)
{
    printk("mydev_read\n");
    
    return 0;
}

ssize_t mydev_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
{
    printk("mydev_write\n");

    return 0;
}

int mydev_open(struct inode *inode, struct file *file)
{
    printk("mydev_open\n");

    return 0;
}

static struct file_operations mydev_fops = {
	.owner = THIS_MODULE,
    .read   = mydev_read,
    .open   = mydev_open,
    .write  = mydev_write,
};

static __init int mydev_init(void)
{
    /* 申请设备号 */
    alloc_chrdev_region(&dev_id, 1, 1, "mydev");

    /* 分配字符设备 */
    mydev = cdev_alloc();

    /* 设置字符设备 */
    cdev_init(mydev, &mydev_fops);

    /* 注册字符设备 */
    cdev_add(mydev, dev_id, 1);

    /* 打印申请到的主次设备号 */
    printk("major:%d; minor:%d\n", MAJOR(dev_id), MINOR(dev_id));

	mydev_class = class_create(THIS_MODULE, "mydev");
	device_create(mydev_class, NULL, dev_id, NULL, "mydev");

    return 0;
}

static __exit void mydev_exit(void)
{
    device_destroy(mydev_class, dev_id);
    class_destroy(mydev_class);

    cdev_del(mydev);
    kfree(mydev);
    unregister_chrdev_region(dev_id, 1);
}

module_init(mydev_init);
module_exit(mydev_exit);

MODULE_LICENSE("GPL");
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

重新编译加载模块

查看/sys/dev/char目录，会发现多了一些信息250:1

此时查看ls /dev/mydev，会发现/dev目录已经有了mydev了

七、测试

每个驱动程序写完之后，都需要编写应用程序测试

下面是我们的测试程序

mydev_test.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char* argv[])
{
    int val = 1;

    int fd = open("/dev/mydev", O_RDWR);

    write(fd, &val, sizeof(val));

    read(fd, &val, sizeof(val));

    return 0;
}
123456789101112131415161718
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

编译

arm-linux-gcc mydev_test.c
1
1
2

加载模块

insmod mydev.ko
1
1
2

执行测试程序

./a.out
1
1
2

可以看到控制台打印

[ 2639.832633] mydev_open
[ 2639.833528] mydev_write
[ 2639.836014] mydev_read
123
1
2
3
4

证明驱动程序正常

本篇文章到这里就结束了

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/384769