【Linux】最基本的字符设备驱动

前面我们介绍到怎么编译出内核模块.ko文件，然后还加载了这个驱动模块。但是，那个驱动代码还不完善，驱动写好后怎么在应用层使用也没有介绍。

字符设备抽象

Linux内核中将字符设备抽象成一个具体的数据结构（struct cdev），我们可以理解为字符设备对象，cdev记录了字符设备的相关信息（设备号、内核对象），字符设备的打开、读写和关闭等操作接口（file_operations），在我们想要添加一个字符设备时，就是将这个对象注册到内核中，通过创建一个文件（设备节点）绑定对象的cdev，当我们对这个文件进行读写操作时，就可以通过虚拟文件系统，在内核中找到这个对象及其操作接口，从而控制设备。

在Linux中，我们使用设备编号来表示设备，主设备号区分设备类别，次设备号标识具体的设备。cdev结构体被内核用来记录设备号，而在使用设备时，我们通常会打开设备节点，通过设备节点的inode结构体和file结构体最终找到file_operations结构体，并从file_operations结构体中得到操作设备的具体方法。

设备号

Linux根目录下有/dev这个文件夹，专门用来存放设备中的驱动程序，我们可以使用ls -l以列表的形式列出所有设备。

一般来说，主设备号指向设备的驱动程序，次设备号指向某个具体的设备。如上图，i2c-3和i2c-4属于不同设备但是共用一套驱动程序。

typedef u32 __kernel_dev_t;typedef __kernel_dev_t               dev_t;

#define MINORBITS    20
#define MINORMASK    ((1U << MINORBITS) - 1)#define MAJOR(dev)   ((unsigned int) ((dev) >> MINORBITS))
#define MINOR(dev)   ((unsigned int) ((dev) & MINORMASK))
#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))

在内核中，dev_t用来表示设备编号，dev_t是一个32位的数，其中，高12位表示主设备号，低20位表示次设备号。 也就是理论上主设备号取值范围：0-2^12，次设备号0-2 ^ 20。

在kdev_t中，设备编号通过移位操作最终得到主/次设备号码，同样主/次设备号也可以通过位运算变成dev_t类型的设备编号， 具体实现参看下面代码MAJOR(dev)、MINOR(dev)和MKDEV(ma,mi)。

cdev结构体

内核通过一个散列表来记录设备编号。

struct cdev {struct kobject kobj;struct module *owner;const struct file_operations *ops;struct list_head list;dev_t dev;unsigned int count;
} __randomize_layout;

• struct kobject kobj： 内嵌的内核对象，通过它将设备统一加入到“Linux设备驱动模型”中管理(如对象的引用计数、电源管理、热插拔、生命周期、与用户通信等)。
• struct module *owner： 字符设备驱动程序所在的内核模块对象的指针。
• const struct file_operations *ops： 文件操作，是字符设备驱动中非常重要的数据结构，在应用程序通过文件系统(VFS)呼叫到设备设备驱动程序中实现的文件操作类函数过程中，ops起着桥梁纽带作用，VFS与文件系统及设备文件之间的接口是file_operations结构体成员函数，这个结构体包含了对文件进行打开、关闭、读写、控制等一系列成员函数。
• struct list_head list： 用于将系统中的字符设备形成链表(这是个内核链表的一个链接因子，可以再内核很多结构体中看到这种结构的身影)。
• dev_t dev： 字符设备的设备号，有主设备和次设备号构成。
• unsigned int count： 属于同一主设备好的次设备号的个数，用于表示设备驱动程序控制的实际同类设备的数量。

设备节点

设备节点是啥呢，其实就是设备文件。设备节点被创建在/dev目录下，是连接内核与用户层的枢纽。

加载了设备驱动后，我们可以通过mknod命令来手动创建设备节点，也可以通过代码实现自动创建设备节点。

应用程序通过一组标准化的调用执行访问设备，这些调用独立于任何特点的驱动程序。而驱动程序负责将这些标准调用映射到实际硬件的特有操作。

数据结构

在驱动开发过程中，不可避免要涉及到三个重要的内核数据结构。

• 文件操作方式：file_operations
• 文件描述结构体：struct file
• inode结构体：struct inode

file_operations结构体

file_operations就是把系统调用和驱动程序关联起来的关键数据结构。以下代码中只列出本章使用到的部分函数。

struct file_operations {struct module *owner;loff_t (*llseek) (struct file *, loff_t, int);ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);int (*open) (struct inode *, struct file *)int (*release) (struct inode *, struct file *);
};

• llseek： 用于修改文件的当前读写位置，并返回偏移后的位置。参数file传入了对应的文件指针，我们可以看到以上代码中所有的函数都有该形参，通常用于读取文件的信息，如文件类型、读写权限；参数loff_t指定偏移量的大小；参数int是用于指定新位置指定成从文件的某个位置进行偏移，SEEK_SET表示从文件起始处开始偏移；SEEK_CUR表示从当前位置开始偏移；SEEK_END表示从文件结尾开始偏移。
• read： 用于读取设备中的数据，并返回成功读取的字节数。该函数指针被设置为NULL时，会导致系统调用read函数报错，提示“非法参数”。该函数有三个参数：file类型指针变量，char__user*类型的数据缓冲区，__user用于修饰变量，表明该变量所在的地址空间是用户空间的。内核模块不能直接使用该数据，需要使用copy_to_user函数来进行操作。size_t类型变量指定读取的数据大小。
• write： 用于向设备写入数据，并返回成功写入的字节数，write函数的参数用法与read函数类似，不过在访问__user修饰的数据缓冲区，需要使用copy_from_user函数。
• unlocked_ioctl： 提供设备执行相关控制命令的实现方法，它对应于应用程序的fcntl函数以及ioctl函数。在 kernel 3.0 中已经完全删除了 struct file_operations 中的 ioctl 函数指针。
• open： 设备驱动第一个被执行的函数，一般用于硬件的初始化。如果该成员被设置为NULL，则表示这个设备的打开操作永远成功。
• release： 当file结构体被释放时，将会调用该函数。与open函数相反，该函数可以用于释放。

在使用read和write函数时，需要使用copy_to_user函数以及copy_from_user函数来进行数据访问，写入/读取成 功函数返回0，失败则会返回未被拷贝的字节数。

static inline long copy_from_user(void *to, const void __user * from, unsigned long n)
static inline long copy_to_user(void __user *to, const void *from, unsigned long n)

file结构体

内核中用file结构体来表示每个打开的文件，每打开一个文件，内核会创建一个结构体，并将对该文件上的操作函数传递给 该结构体的成员变量f_op，当文件所有实例被关闭后，内核会释放这个结构体。如下代码中，只列出了我们本章需要了解的成员变量。

struct file {
{......}
const struct file_operations *f_op;
/* needed for tty driver, and maybe others */
void *private_data;
{......}
};

• f_op：存放与文件操作相关的一系列函数指针，如open、read、wirte等函数。
• private_data：该指针变量只会用于设备驱动程序中，内核并不会对该成员进行操作。因此，在驱动程序中，通常用于指向描述设备的结构体。

inode结构体

VFS inode 包含文件访问权限、属主、组、大小、生成时间、访问时间、最后修改时间等信息。 它是Linux 管理文件系统的最基本单位，也是文件系统连接任何子目录、文件的桥梁。 内核使用inode结构体在内核内部表示一个文件。

inode结构体包含了一大堆文件相关的信息，但是就针对驱动代码来说，我们只要关心其中的两个域即可：

struct inode {dev_t                     i_rdev;{......}union {struct pipe_inode_info *i_pipe;   /* linux内核管道 */struct block_device    *i_bdev;      /* 如果这是块设备，则设置并使用 */struct cdev            *i_cdev;            /* 如果这是字符设备，则设置并使用 */char                   *i_link;unsigned               i_dir_seq;};{......}
};

• dev_t i_rdev： 表示设备文件的结点，这个域实际上包含了设备号。
• struct cdev *i_cdev： struct cdev是内核的一个内部结构，它是用来表示字符设备的，当inode结点指向一个字符设备文件时，此域为一个指向inode结构的指针。

字符设备驱动程序框架

在驱动入口函数中

1. 分配设备号
2. 注册字符设备
3. 创建设备节点

在驱动出口函数中

1. 删除字符设备
2. 归还设备号
3. 删除设备节点

已弃用的注册字符设备函数

static inline int register_chrdev(unsigned int major, const char *name,const struct file_operations *fops)
static inline void unregister_chrdev(unsigned int major, const char *name)

这一组函数时Linux版本2.4之前的注册方式，每注册一个字符设备，都还会连续注册0~255个次设备，使他们绑定在同一个file_operationis操作方法结构体上，而我们在大多数情况下，都只会用到极少的次设备号，所以会造成资源的极大浪费。所以现在很少用它。

字符设备号的申请和释放

静态申请

register_chrdev_region函数用于静态地为一个字符设备申请一个或多个设备编号

int register_chrdev_region(dev_t from, unsigned count, const char *name)
void unregister_chrdev_region(dev_t from, unsigned count)

参数：

• from：dev_t类型的变量，用于指定字符设备的起始设备号，如果要注册的设备号已经被其他的设备注册了，那么就会导致注册失败。
• count：指定要申请的设备号个数，count的值不可以太大，否则会与下一个主设备号重叠。
• name：用于指定该设备的名称。

返回值： 返回0表示申请成功，失败则返回错误码。

静态申请设备号是我们人为确定好了设备号，再去申请设备号，属于静态申请。可以通过命令cat /proc/devices来查询内核已使用的主设备号。

动态申请

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
void unregister_chrdev_region(dev_t from, unsigned count)

参数：

• dev：指向dev_t类型数据的指针变量，用于存放分配到的设备编号的起始值；
• baseminor：次设备号的起始值，通常情况下，设置为0；
• count、name：同register_chrdev_region类型，用于指定需要分配的设备编号的个数以及设备的名称。

返回值： 返回0表示申请成功，失败则返回错误码

字符设备的注册和注销

前面我们已经提到过了，编写一个字符设备最重要的事情，就是要实现file_operations这个结构体中的函数。 实现之后，如何将该结构体与我们的字符设备结构体相关联呢？内核提供了cdev_init函数，来实现这个过程。

void cdev_init(struct cdev *cdev, const struct file_operations *fops) 

参数：

• cdev：struct cdev类型的指针变量，指向需要关联的字符设备结构体；
• fops：file_operations类型的结构体指针变量，一般将实现操作该设备的结构体file_operations结构体作为实参。

返回值： 无

cdev_add函数用于向内核的cdev_map散列表添加一个新的字符设备

int cdev_add(struct cdev *p, dev_t dev, unsigned count)

参数：

• p：struct cdev类型的指针，用于指定需要添加的字符设备；
• dev：dev_t类型变量，用于指定设备的起始编号；
• count：指定注册多少个设备。

返回值： 错误码

从系统中删除cdev，cdev设备将无法再打开，但任何已经打开的cdev将保持不变， 即使在cdev_del返回后，它们的FOP仍然可以调用。

void cdev_del(struct cdev *p)

参数：

• p：struct cdev类型的指针，用于指定需要删除的字符设备；

返回值： 无

设备节点的创建和销毁

创建类的定义在/linux-4.1.15/include/linux/device.h中。

#define class_create(owner, name)       
({                      static struct lock_class_key __key; __class_create(owner, name, &__key);    
})

删除类：

extern void class_destroy(struct class *cls)

struct device *device_create(struct class *class, struct device *parent,dev_t devt, void *drvdata, const char *fmt, ...)

参数：

• class：指向这个设备应该注册到的struct类的指针；
• parent：指向此新设备的父结构设备(如果有)的指针；
• devt：要添加的char设备号；
• drvdata：要添加到设备进行回调的数据；
• fmt：输入设备名称。

返回值： 成功时返回 struct device 结构体指针, 错误时返回ERR_PTR().

删除使用device_create函数创建的设备

void device_destroy(struct class *class, dev_t devt)

参数：

• class：指向注册此设备的struct类的指针；
• devt：以前注册的设备号；

返回值： 无

除了使用代码创建设备节点，还可以使用mknod命令创建设备节点。

用法：mknod 设备名 设备类型 主设备号 次设备号

如：

mknod /dev/haptics c 200 0

这个class和device具体是什么，我们后面再介绍，目前我们只管这样用就行。

源码

/**  Silicon Integrated Co., Ltd haptic sih688x haptic driver file**  Copyright (c) 2021 kugua <[e-mail]>** This program is free software; you can redistribute it and/or modify it* under the terms of the GNU General Public License version 2 as published by* the Free Software Foundation*/#include <linux/init.h>  //包含宏定义的头文件
#include <linux/module.h>   //包含初始化加载模块的头文件
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <linux/device.h>#define HAPTICS_DEV_MAJOR 200
#define HAPTICS_DEV_MINOR 0
#define HAPTICS_DEV_NAME  "haptics"
#define HAPTICS_DEV_CNT   1#define HAPTICS_DEV_CLASS_NAME "haptics"
#define HAPTICS_DEV_NODE_NAME  "haptics"#define BUFF_SIZE 128
//数据缓冲区
static char vbuf[BUFF_SIZE]="this is driver";static dev_t dev_id;//设备号
static struct cdev haptics_dev;//设备
struct class *class; 
struct device *device; static int major = HAPTICS_DEV_MAJOR;//主设备号
static int minor = HAPTICS_DEV_MINOR;//次设备号//打开设备
static int haptics_open(struct inode* inode,struct file * filp)
{printk("%s\n",__FUNCTION__);return 0;
}//关闭设备
static int haptics_release(struct inode* inode ,struct file* filp)
{printk("%s\n",__FUNCTION__);return 0;
}//读设备
static ssize_t haptics_read(struct file* filp, char __user *buf,size_t count,loff_t* ppos)
{unsigned long p = *ppos;int ret;	int tmp = count ;if (p >= BUFF_SIZE)return 0;if (tmp > BUFF_SIZE - p)tmp = BUFF_SIZE - p;ret = copy_to_user(buf, vbuf+p, tmp);*ppos +=tmp;return tmp;
}//写设备
static ssize_t haptics_write(struct file* filp,const char __user *buf,size_t count,loff_t* ppos)
{unsigned long p = *ppos;int ret;int tmp = count ;if (p > BUFF_SIZE)return 0;if (tmp > BUFF_SIZE - p)tmp = BUFF_SIZE - p;memset(vbuf,0,BUFF_SIZE);ret = copy_from_user(vbuf, buf, tmp);*ppos += tmp;return tmp;
}static struct file_operations haptics_fops=
{.owner = THIS_MODULE,.open = haptics_open,.release = haptics_release,.read = haptics_read,.write = haptics_write,
};static int __init haptics_init(void)
{int ret = 0;//内核层只能使用printk，不能使用printfprintk(KERN_EMERG "%s\n",__FUNCTION__); //输出等级为0//申请设备号if(major){dev_id = MKDEV(major,minor);//静态申请ret = register_chrdev_region(dev_id, HAPTICS_DEV_CNT, HAPTICS_DEV_NAME);if(0 == ret){printk("register_chrdev_region ok,major=%d minor=%d\n",MAJOR(dev_id),MINOR(dev_id));}}else{//动态申请ret = alloc_chrdev_region(&dev_id, minor, HAPTICS_DEV_CNT, HAPTICS_DEV_NAME);if(0 == ret){printk("alloc_chrdev_region ok,major=%d minor=%d\n",MAJOR(dev_id),MINOR(dev_id));}}//注册字符设备haptics_dev.owner = THIS_MODULE;cdev_init(&haptics_dev,&haptics_fops);cdev_add(&haptics_dev,dev_id,HAPTICS_DEV_CNT);//自动创建设备节点class = class_create(THIS_MODULE,HAPTICS_DEV_CLASS_NAME);device = device_create(class,NULL,dev_id,NULL,HAPTICS_DEV_NODE_NAME);return 0;
}static void __exit haptics_exit(void)
{printk(KERN_EMERG "%s\n",__FUNCTION__); //输出等级为0//释放设备号unregister_chrdev_region(dev_id,HAPTICS_DEV_CNT);//注销字符设备cdev_del(&haptics_dev);//删除设备节点device_destroy(class,dev_id);class_destroy(class);
}module_init(haptics_init);//驱动入口
module_exit(haptics_exit);//驱动出口MODULE_AUTHOR("<[e-mail]>");//声明作者信息
MODULE_DESCRIPTION("Haptic Driver V1.0.0"); //对这个模块作一个简单的描述
MODULE_LICENSE("GPL v2");//声明开源许可证// "GPL" 是指明 这是GNU General Public License的任意版本// “GPL v2” 是指明 这仅声明为GPL的第二版本

还有应用层代码

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
/*
argc:应用程序参数个数，包括应用程序本身
argv[]:具体的参数内容，字符串形式
./main <filename> <r:w> r表示读 w表示写
*/int main(int argc,char * argv[])
{char *wbuf = "Hello World\n";char rbuf[128];char* filename;int fd=0;if(argc!=3){printf("error usage\n");return -1;}filename=argv[1];fd = open(filename,O_RDWR);if(fd<0){printf("can not open file %s\n",filename);return -2;}if(0 == strcmp(argv[2],"r")){read(fd, rbuf, 128);//打印读取的内容printf("The content : %s\n", rbuf);}else if(0 == strcmp(argv[2],"w")){write(fd, wbuf, strlen(wbuf));}else{printf("error usage\n");}close(fd);
}

root@RK3588:/# insmod haptics.ko
[   53.773224] haptics_init
[   53.773264] register_chrdev_region ok,major=200 minor=0
root@RK3588:/# ./main /dev/haptics w
[   56.270812] haptics_open
[   56.270867] haptics_release
root@RK3588:/# ./main /dev/haptics r
[   59.249993] haptics_open
The content : Hello World[   59.250155] haptics_release
root@RK3588:/#

优化源码

对于上述驱动代码，有几点需要优化

1. class名称、node名称一般与驱动名称一致
2. 我们定义了很多全局变量，其实我们可以抽象出一个设备结构体，这个结构体去包含那些成员变量
3. 一套驱动代码，是需要兼容多个设备的，所以应该尽量少用全局变量，需要思考如何兼容多设备

/**  Silicon Integrated Co., Ltd haptic sih688x haptic driver file**  Copyright (c) 2021 heater <[e-mail]>** This program is free software; you can redistribute it and/or modify it* under the terms of the GNU General Public License version 2 as published by* the Free Software Foundation*/#include <linux/init.h>  //包含宏定义的头文件
#include <linux/module.h>   //包含初始化加载模块的头文件
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <linux/device.h>#define HAPTICS_CDEV_MAJOR 200
#define HAPTICS_CDEV_MINOR 0
#define HAPTICS_CDEV_NAME  "haptics"
#define HAPTICS_CDEV_CNT   1#define BUFF_SIZE 128struct haptics_dev
{struct cdev haptics_cdev;//字符设备dev_t dev_id;//设备号struct class *class; //类struct device *device; //设备int major;//主设备号int minor;//次设备号char vbuf[BUFF_SIZE];//数据缓冲区
};struct haptics_dev mdev;//定义一个设备结构体//打开设备
static int haptics_open(struct inode* inode,struct file * filp)
{printk("%s\n",__FUNCTION__);return 0;
}//关闭设备
static int haptics_release(struct inode* inode ,struct file* filp)
{printk("%s\n",__FUNCTION__);return 0;
}//读设备
static ssize_t haptics_read(struct file* filp, char __user *buf,size_t count,loff_t* ppos)
{unsigned long p = *ppos;int ret;	int tmp = count ;if (p >= BUFF_SIZE)return 0;if (tmp > BUFF_SIZE - p)tmp = BUFF_SIZE - p;ret = copy_to_user(buf, mdev.vbuf+p, tmp);*ppos +=tmp;return tmp;
}//写设备
static ssize_t haptics_write(struct file* filp,const char __user *buf,size_t count,loff_t* ppos)
{unsigned long p = *ppos;int ret;int tmp = count ;if (p > BUFF_SIZE)return 0;if (tmp > BUFF_SIZE - p)tmp = BUFF_SIZE - p;memset(mdev.vbuf,0,BUFF_SIZE);ret = copy_from_user(mdev.vbuf, buf, tmp);*ppos += tmp;return tmp;
}static struct file_operations haptics_fops=
{.owner = THIS_MODULE,.open = haptics_open,.release = haptics_release,.read = haptics_read,.write = haptics_write,
};static int __init haptics_init(void)
{int ret = 0;//内核层只能使用printk，不能使用printfprintk(KERN_EMERG "%s\n",__FUNCTION__); //输出等级为0mdev.major = HAPTICS_CDEV_MAJOR;//预定义的主设备号mdev.minor = HAPTICS_CDEV_MINOR;//预定义的次设备号//申请设备号if(mdev.major)//如果预定义的主设备号不为0，则需要静态申请设备号{mdev.dev_id = MKDEV(mdev.major,mdev.minor);//静态申请ret = register_chrdev_region(mdev.dev_id, HAPTICS_CDEV_CNT, HAPTICS_CDEV_NAME);if(0 == ret){printk("register_chrdev_region ok,major=%d minor=%d\n",MAJOR(mdev.dev_id),MINOR(mdev.dev_id));}}else//如果预定义的主设备号为0，则需要动态申请设备号{//动态申请ret = alloc_chrdev_region(&mdev.dev_id, mdev.minor, HAPTICS_CDEV_CNT, HAPTICS_CDEV_NAME);if(0 == ret){mdev.major = MAJOR(mdev.dev_id);mdev.minor = MINOR(mdev.dev_id);printk("alloc_chrdev_region ok,major=%d minor=%d\n",MAJOR(mdev.dev_id),MINOR(mdev.dev_id));}}//注册字符设备mdev.haptics_cdev.owner = THIS_MODULE;cdev_init(&mdev.haptics_cdev,&haptics_fops);cdev_add(&mdev.haptics_cdev,mdev.dev_id,HAPTICS_CDEV_CNT);//自动创建设备节点mdev.class = class_create(THIS_MODULE,HAPTICS_CDEV_NAME);mdev.device = device_create(mdev.class,NULL,mdev.dev_id,NULL,HAPTICS_CDEV_NAME);return 0;
}static void __exit haptics_exit(void)
{//释放设备号unregister_chrdev_region(mdev.dev_id,HAPTICS_CDEV_CNT);//注销字符设备cdev_del(&mdev.haptics_cdev);//删除设备节点device_destroy(mdev.class,mdev.dev_id);class_destroy(mdev.class);printk(KERN_EMERG "%s\n",__FUNCTION__); //输出等级为0
}module_init(haptics_init);//驱动入口
module_exit(haptics_exit);//驱动出口MODULE_AUTHOR("<[e-mail]>");//声明作者信息
MODULE_DESCRIPTION("Haptics Driver V1.0.0"); //对这个模块作一个简单的描述
MODULE_LICENSE("GPL v2");//声明开源许可证// "GPL" 是指明 这是GNU General Public License的任意版本// “GPL v2” 是指明 这仅声明为GPL的第二版本