Linux驱动入门（一）字符设备驱动基础

小灰灰 2021-10-30 05:54 388阅读 0赞

**Linux驱动入门系列**

[Linux驱动入门（一）字符设备驱动基础][Linux]

[Linux驱动入门（二）操作硬件][Linux 1]

[Linux驱动入门（三）Led驱动][Linux_Led]

[Linux驱动入门（四）非阻塞方式实现按键驱动][Linux 2]

[Linux驱动入门（五）阻塞方式实现按键驱动][Linux 3]

[Linux驱动入门（六）poll机制实现按键驱动][Linux_poll]

[Linux驱动入门（七）使用定时器消除按键抖动][Linux 4]

# Linux驱动入门（一）字符设备驱动基础 #

### 文章目录 ###

*  Linux驱动入门（一）字符设备驱动基础
 *   *  一、驱动简介
     *  二、字符设备驱动概念
     *  三、注册字符设备
     *  四、编译模块
     *  五、加载模块
     *  六、创建设备节点
     *  七、测试

## 一、驱动简介 ##

Linux驱动分为字符设备驱动、块设备驱动、网络设备驱动

*  字符设备驱动
    
    字符设备指必须以串行顺序依次访问的设备，如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));

这样就可以使得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`去操作硬件

如下图所示

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70]

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

--------------------

首先介绍一下设备号

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

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

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

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

--------------------

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70 1]

字符设备驱动就是要完善这个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;
    };

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

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

MAJOR(dev_t dev) //主设备号
    MINOR(dev_t dev) //次设备号

使用下面该宏获取设备号

MKDEV(int major, int minor)

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

*  申请设备号
    
    **动态分配**
    
    此函数指定次设备号和设备号个数，可以动态分配主设备号
    
        /*
         * dev：返回申请到的设备号
         * baseminor：起始次设备号
         * count：申请的设备号个数
         */
        int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
        			const char *name)
    
    **静态分配**
    
    此函数必须主次设备号和设备号个数
    
        /*
         * from：其实设备号
         * count：设备号个数
         */
        int register_chrdev_region(dev_t from, unsigned count, const char *name)
    
    在申请完设备号后，就可以利用此设备号去注册字符设备了
 *  注册字符设备
    
    **和字符设备相关的函数**
    
        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 *);
    
    **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); //将字符设备和申请到的设备号注册进内核

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

**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");

## 四、编译模块 ##

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

这里介绍第二种

将驱动程序编译成模块需要编写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

其中`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

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

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

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

## 六、创建设备节点 ##

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

*  手动创建
    
    在上面驱动程序打印出`major:250; minor:1`，我们可以利用这些信息来创建设备节点
    
    通过下面命令创建设备节点
    
        mknod 设备名 设备类型(字符：c,块：b) 主设备号 从设备号
    
    执行
    
        mknod /dev/mydev c 250 1
    
    运行后就生成了设备节点`/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"); //根据设备号创建设备节点
    
    销毁设备节点
    
        device_destroy(mydev_class, dev_id); //销毁设备节点
        class_destroy(mydev_class); //销毁类
    
    修改后的驱动
    
    **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");
    
    重新编译加载模块
    
    查看`/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;
    }

编译

arm-linux-gcc mydev_test.c

加载模块

insmod mydev.ko

执行测试程序

./a.out

可以看到控制台打印

[ 2639.832633] mydev_open
    [ 2639.833528] mydev_write
    [ 2639.836014] mydev_read

证明驱动程序正常

本篇文章到这里就结束了

[Linux]: https://blog.csdn.net/weixin_42462202/article/details/99887783
[Linux 1]: https://blog.csdn.net/weixin_42462202/article/details/99949396
[Linux_Led]: https://blog.csdn.net/weixin_42462202/article/details/99979562
[Linux 2]: https://blog.csdn.net/weixin_42462202/article/details/99998992
[Linux 3]: https://blog.csdn.net/weixin_42462202/article/details/100011481
[Linux_poll]: https://blog.csdn.net/weixin_42462202/article/details/100017339
[Linux 4]: https://blog.csdn.net/weixin_42462202/article/details/100019418
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70]: /images/20211029/d3c8ddc411fa48199a4d91825b98d1f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70 1]: /images/20211029/328c0271d950412c8a6c2316f9f83cb6.png