1.概念

字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节 流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、IIC、SPI， LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。

在 Linux 中一切皆为文件，驱动加载成功以后会在“/dev”目录下生成一个相应的文件，应 用程序通过对这个名为“/dev/xxx”(xxx 是具体的驱动文件名字)的文件进行相应的操作即可实 现对硬件的操作。

2.对驱动的操作

在应用层，对文件操作接口无非就是open, read,write, close，ioctl等接口，这些接口都是c库接口。应用层到glibc接口之后，通过系统调用，陷入进入内核，找到相应的驱动或者inode节点的操作函数，完成对硬件的操作，如下图所示：

3.字符设备驱动开发接口

从应用层角度看，需要open,read,write,close,ioctl等接口，那内核层也应该实现相应的接口，这就对应到了file_operations 的结构体了此结构体就是 Linux 内核驱动操作函数集合。如下：

示例代码 40.1.1 file_operations 结构体
1588 struct file_operations {
1589 struct module *owner;
1590 loff_t (*llseek) (struct file *, loff_t, int);
1591 ssize_t (*read) (struct file *, char __user *, size_t, loff_t 
*);
1592 ssize_t (*write) (struct file *, const char __user *, size_t,
loff_t *);
1593 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
1594 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
1595 int (*iterate) (struct file *, struct dir_context *);
1596 unsigned int (*poll) (struct file *, struct poll_table_struct 
*);
1597 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned
long);
1598 long (*compat_ioctl) (struct file *, unsigned int, unsigned
long);
1599 int (*mmap) (struct file *, struct vm_area_struct *);
1600 int (*mremap)(struct file *, struct vm_area_struct *);
1601 int (*open) (struct inode *, struct file *);
1602 int (*flush) (struct file *, fl_owner_t id);
1603 int (*release) (struct inode *, struct file *);
1604 int (*fsync) (struct file *, loff_t, loff_t, int datasync);
1605 int (*aio_fsync) (struct kiocb *, int datasync);
1606 int (*fasync) (int, struct file *, int);
1607 int (*lock) (struct file *, int, struct file_lock *);
1608 ssize_t (*sendpage) (struct file *, struct page *, int, size_t,
loff_t *, int);
1609 unsigned long (*get_unmapped_area)(struct file *, unsigned long,
unsigned long, unsigned long, unsigned long);
1610 int (*check_flags)(int);
1611 int (*flock) (struct file *, int, struct file_lock *);
1612 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *,
loff_t *, size_t, unsigned int);
1613 ssize_t (*splice_read)(struct file *, loff_t *, struct
pipe_inode_info *, size_t, unsigned int);
1614 int (*setlease)(struct file *, long, struct file_lock **, void
**);
1615 long (*fallocate)(struct file *file, int mode, loff_t offset,
1616 loff_t len);
1617 void (*show_fdinfo)(struct seq_file *m, struct file *f);
1618 #ifndef CONFIG_MMU
1619 unsigned (*mmap_capabilities)(struct file *);
1620 #endif
1621 };

这些函数我们不需要都实现，应用层需要使用哪些，驱动层再实现即可 。如果驱动层不实现，应用层直接使用接口会返回报错，这个时候我们使用perror可以查看错误。

4.驱动层实现字符设备的API说明

4.1.注册字符设备函数

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

参数说明：

major：主设备号，Linux 下每个设备都有一个设备号，设备号分为主设备号和次设备号两 部分，关于设备号后面会详细讲解。

name：设备名字

fops：结构体 file_operations 类型指针，指向设备的操作函数集合变量。

注意：该函数一般是在驱动模块的入口函数 xxx_init 中进行的，也可能在platform总线driver的probe函数 

4.2.注销字符设备函数

static inline void unregister_chrdev(unsigned int major, const char *name)

参数说明:

major：要注销的设备对应的主设备号。

name：要注销的设备对应的设备名。 

 注意：该函数一般是在驱动模块 的出口函数 xxx_exit 中进行，也可能在platform总线driver的remove函数 

 通过这两个函数就可以完成一个简单的字符设备驱动的注册了，接下来只需要实现结构体 file_operations里面的某一些函数就可以了·，是不是感觉很简单。

4.3.实现结构体 file_operations的部分函数

这个结构体的定义在 include/linux/fs.h里面，每一个函数类型都有定义好，把需要实现的函数拷贝到自己的源文件里面进行实现即可。或者我们可以到linux其他字符设备里面看看别人怎么实现的，包含哪些头文件，我们直接抄作业。

如：

/* 打开设备 */
static int chrtest_open(struct inode *inode, struct file *filp)
{
/* 用户实现具体功能 */
    return 0;
}

/* 从设备读取 */
static ssize_t chrtest_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
/* 用户实现具体功能 */
    return 0;
}

/* 向设备写数据 */
static ssize_t chrtest_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    /* 用户实现具体功能 */
    return 0;
}


/* 关闭/释放设备 */
static int chrtest_release(struct inode *inode, struct file *filp)
{
    /* 用户实现具体功能 */
    return 0;
}

static struct file_operations test_fops = {
.owner = THIS_MODULE, 
.open = chrtest_open,
.read = chrtest_read,
.write = chrtest_write,
.release = chrtest_release,
};

4.4.设备号

 现在万事俱备，只欠设备号了。

Linux 中每个设备都有一个设备号，设备号由主设备号和次设备号两部分 组成，主设备号表示某一个具体的驱动，次设备号表示使用这个驱动的各个设备，通过设备号可以定位到相应的设备，可以说这是一种标识。

Linux 使用 一个名为 dev_t 的数据类型表示设备号，dev_t 定义在文件 include/linux/types.h 里面，定义如下：

typedef __u32 __kernel_dev_t;

typedef __kernel_dev_t dev_t;

这 32 位的数据构成了主设备号和次设备号两部分，其中高 12 位为主设备号，低 20 位为次设备号。

看到位操作不要慌，内核大佬都给我们考虑好了，include/linux/kdev_t.h 封装了很多宏给开发者使用。

#define MINORBITS 20  /** 表示次设备号位数，一共是 20 位 */
#define MINORMASK ((1U << MINORBITS) - 1)   /**  表示次设备号掩码 */

#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))   /** 用于从 dev_t 中获取主设备号，将 dev_t 右移 20 位即可 */
#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))   /** 用于从 dev_t 中获取次设备号，取 dev_t 的低 20 位的值即可 */
#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))   /** 用于将给定的主设备号和次设备号的值组合成 dev_t 类型的设备号 */

4.1.设备号的分配

知道了设备号组成规则，那怎么分配呢？？？

目前有两种分配方式，一种是静态，一种是动态的。

4.1.1.静态分配设备号

有一些常用的设备号已经被 Linux 内核开发者给分配掉 了，具体分配的内容可以查看文档 Documentation/devices.txt。可以使用“cat /proc/devices”命令即可查看当前系统中所有已经使用了的设备号。

注意：可能cat /proc/devices查看某一个设备号没有被使用，但是在Documentation/devices.txt文档里面占用了，我们就尽量不要使用了，防止冲突，当然只是学习就无所谓了。

4.1.2.动态分配设备号

静态分配设备号需要我们检查当前系统中所有被使用了的设备号，然后挑选一个没有使用 的。而且静态分配设备号很容易带来冲突问题，Linux 社区推荐使用动态分配设备号，在注册字 符设备之前先申请一个设备号，系统会自动给你一个没有被使用的设备号，这样就避免了冲突。 卸载驱动的时候释放掉这个设备号即可，

4.1.2.1设备号的申请函数

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)。

参数如：

dev：保存申请到的设备号。

baseminor：次设备号起始地址，

alloc_chrdev_region 可以申请一段连续的多个设备号，这 些设备号的主设备号一样，但是次设备号不同，次设备号以 baseminor 为起始地址地址开始递 增。一般 baseminor 为 0，也就是说次设备号从 0 开始。

count：要申请的设备号数量。

name：设备名字。

4.1.2.2.设备号释放函数

注销字符设备之后要释放掉设备号，设备号释放函数如下：

void unregister_chrdev_region(dev_t from, unsigned count) 

参数：

from：要释放的设备号。

count：表示从 from 开始，要释放的设备号数量。

4.1.2.3.注意

register_chrdev第一个参数给0也是动态申请的，但是这样就确定不了设备号，无法注销设备号，导致设备泄露，可能有其他方法，目前还没有发现，所以动态申请还是使用alloc_chrdev_region好一点，后面会单独出一篇博客将该接口使用demo.

 ok，目前一切准备工作都准备完成了，开始进行测试。

5.测试

5.1.驱动代码：

todo: 暂时贴到博客，后续会整理放到gitee上面。

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>


#define CHRDEVBASE_MAJOR	200		/* 主设备号 */
#define CHRDEVBASE_NAME		"chrdevbase" 	/* 设备名     */


/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int chrdevbase_open(struct inode *inode, struct file *filp)
{
	printk("chrdevbase open!\r\n");
	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t chrdevbase_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	
	printk("chrdevbase read!\r\n");
	return 0;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t chrdevbase_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	printk("chrdevbase write!\r\n");
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int chrdevbase_release(struct inode *inode, struct file *filp)
{
	printk("chrdevbase release！\r\n");
	return 0;
}

/*
 * 设备操作函数结构体
 */
static struct file_operations chrdevbase_fops = {
	.owner = THIS_MODULE,	
	.open = chrdevbase_open,
	.read = chrdevbase_read,
	.write = chrdevbase_write,
	.release = chrdevbase_release,
};

/*
 * @description	: 驱动入口函数 
 * @param 		: 无
 * @return 		: 0 成功;其他 失败
 */
static int __init chrdevbase_init(void)
{
	int retvalue = 0;

	/* 注册字符设备驱动 */
	retvalue = register_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME, &chrdevbase_fops);
	if(retvalue < 0){
		printk("chrdevbase driver register failed\r\n");
	}
	printk("chrdevbase init!\r\n");
	return 0;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit chrdevbase_exit(void)
{
	/* 注销字符设备驱动 */
	unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME);
	printk("chrdevbase exit!\r\n");
}

/* 
 * 将上面两个函数指定为驱动的入口和出口函数 
 */
module_init(chrdevbase_init);
module_exit(chrdevbase_exit);

/* 
 * LICENSE和作者信息
 */
MODULE_LICENSE("GPL");
MODULE_AUTHOR("seven");

5.2.应用层测试用例

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

static char usrdata[] = {"usr data!"};

/*
 * @description		: main主程序
 * @param - argc 	: argv数组元素个数
 * @param - argv 	: 具体参数
 * @return 			: 0 成功;其他 失败
 */
int main(int argc, char *argv[])
{
	int fd, retvalue;
	char *filename;
	char readbuf[100], writebuf[100];
	if(argc != 2){
		printf("Error Usage!\r\n");
		return -1;
	}

	filename = argv[1];

	/* 打开驱动文件 */
	fd  = open(filename, O_RDWR);
	if(fd < 0){
		printf("Can't open file %s\r\n", filename);
		return -1;
	}

	retvalue = write(fd, writebuf, 50);
	if(retvalue < 0){
		perror("write error");
		printf("write file %s failed!\r\n", filename);
	}

	/* 关闭设备 */
	retvalue = close(fd);
	if(retvalue < 0){
		printf("Can't close file %s\r\n", filename);
		return -1;
	}

	return 0;
}

5.3.  创建设备节点

mknod /dev/chrdevbase c 200 0 创建设备节点。

其中“mknod”是创建节点命令，“/dev/chrdevbase”是要创建的节点文件，“c”表示这是个 字符设备，“200”是设备的主设备号，“0”是设备的次设备号。创建完成以后就会存在 /dev/chrdevbase 这个文件，可以使用“ls /dev/chrdevbase -l”命令查看。有没有感觉这样很麻烦，每换一个设备号，又得重新创建设备节点，能不能自动创建呢？？当然可以了，内核udev提供了自动创建设备节点的功能。由于篇幅问题，将在下一篇文章里面进行解释怎么使用udev的接口自动创建设备。

5.4.测试结果：

 

 由于篇幅太长，测试用例就没写那么多，测试一些奇怪的使用方法，将在后面慢慢补齐。