字符设备框架搭建
（1）创建工程
新建驱动开发项目文件目录
1、添加头文件路径
因为是编写 Linux 驱动，因此会用到 Linux 源码中的函数。我们需要在 VSCode 中添加 Linux
源码中的头文件路径。打开 VSCode，按下“Crtl+Shift+P”打开 VSCode 的控制台，然后输入
“C/C++: Edit configurations(JSON) ”，打开 C/C++编辑配置文件
打开以后会自动在.vscode 目录下生成一个名为 c_cpp_properties.json 的文件
对该文件进行修改，修改后的c_cpp_properties.json 为
{
"configurations": [
{
"name": "Linux",
"includePath": [
"${workspaceFolder}/**",
"/home/f3161/linux/IMX6ULL/linux/include",
"/home/f3161/linux/IMX6ULL/linux/arch/arm/include",
"/home/f3161/linux/IMX6ULL/linux/arch/arm/include/generated/"
],
"defines": [],
"compilerPath": "/usr/bin/clang",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "clang-x64"
}
],
"version": 4
}其中 includPath内为内核目录，修改成自己具体的目录
2、Makefile文件
新建Makefile文件，输入内容如下
KERNELDIR := /home/f3161/linux/IMX6ULL/linux
CURRENT_PATH := $(shell pwd)
obj-m := xxx.o
build: kernel_modules
kernel_modules:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean第一行为内核路径
第三行是生成的.ko文件名，需要与.c文件对应。
（2）编写驱动程序xxx.c
1、头文件
xxx.c头文件（包含了后续所有常见实验的头文件在内）如下
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#define XXX_CNT 1 //设备号个数
#define XXX_NAME "xxx" //设备号名字2、注册驱动
/* 驱动入口函数 */
static int __init xxx_init(void)
{
int ret = 0;
return ret;
}
/* 驱动出口函数 */
static void __exit xxx_exit(void)
{
}
module_init(xxx_init);
module_exit(xxx_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("FANG");注意驱动入口出口函数的参数。
3、添加设备结构体
//设备结构体
struct xxx_dev{
dev_t devid;//设备号
int major;//主设备号
int minor;//次设备号
struct cdev cdev; //字符设备
struct class *class;//类
struct device *device;//设备
struct device_node *nd;//设备树节点
int xxx_gpio; //GPIO编号
};
struct xxx_dev xxx;devid:每个设备都有一个设备号，设备号由主设备号（major）和次设备号两部分组成
cdev：用来注册字符设备
class，device：来于自动创建设备节点
xxx_gpio： 设备所用的GPIO编号（设备树需要）
4、申请设备号
在入口函数static int __init xxx_init(void)中添加
xxx.major = 0;
if(xxx.major){ //给定设备号
xxx.devid = MKDEV(xxx.major, 0);
ret = register_chrdev_region(xxx.devid, DTSLED_CNT, XXX_NAME);
}else{ // 申请设备号
ret = alloc_chrdev_region(&xxx.devid, 0, DTSLED_CNT, XXX_NAME);
xxx.major = MAJOR(xxx.devid);
}
if(ret<0){
goto fail_devid;
}其中，DTSLED_CNT表示设备号个数，需要.c文件开头添加宏 #define DTSLED_CNT 1
XXX_NAME表示设备号名字，添加宏 #define XXX_NAME "xxx"
MKDEV用于将给定的主设备号和次设备号的值（这里是0）组合成 dev_t 类型的设备号。
register_chrdev_region函数使用给定的主设备号和次设备号注册设备号
函数原型：int register_chrdev_region(dev_t from, unsigned count, const char *name)
参数 from 是要申请的起始设备号，也就是给定的设备号；参数 count 是要申请的数量，一般都是一个；参数 name 是设备名字。
alloc_chrdev_region函数是在没有指定设备号时申请设备号
函数原型：int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
参数dev是申请到的设备号，baseminor是次设备号起始地址（一般用0），count和name同上。
如果申请失败，则goto fail_devid（后面提及）
在驱动出口函数static void __exit disled_exit(void)中，需要释放设备号
unregister_chrdev_region(xxx.devid, DTSLED_CNT);5、添加字符设备操作集
static const struct file_operations xxx_fops = {
.owner = THIS_MODULE,
.write = xxx_write,
.open = xxx_open,
.read = xxx_read,
.release = xxx_release,
};添加字符设备操作集对应的函数
static int xxx_open(struct inode *inode, struct file *filp){
filp->private_data = &xxx;
return 0;
}
static ssize_t xxx_write(struct file *filp, const char __user *buf, size_t count,loff_t *ppos){
struct xxx_dev *dev = (struct xxx_dev*)filp->private_data;
return 0;
}
static int xxx_release(struct inode *inode, struct file *filp){
struct xxx_dev *dev = (struct xxx_dev*)filp->private_data;
return 0;
}
static ssize_t xxx_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt)
{
struct xxx_dev *dev = (struct xxx_dev *)filp->private_data;
return 0;
}其中设置了文件的私有属性，将设备结构体作为私有数据添加到设备文件中。在上述函数中使用dev变量代替xxx_dev
xxx_write函数
xxx_write函数表示用户空间（应用程序）传递给内核（驱动程序）的数据并且打印出来,因为用户空间内存不能直接访问内核空间的内存，所以需要借助函数 copy_from_user 将用户空间的数据复制到 writebuf 这个内核空间中。
函数原型：
static inline long copy_from_user(void __user *to, const void *from, unsigned long n)
参数 to 表示目的（驱动程序数据），参数 from 表示源（应用程序数据），参数 n 表示要复制的数据长度。如果复制成功，返回值为 0，如果复制失败则返回负数。
所以修改后的xxx_write()函数:——>将应用程序中的数据传递给驱动程序
static char writebuf[100];
static ssize_t xxx_write(struct file *filp,const char __user *buf, size_t cnt, loff_t *offt)
{
int retvalue = 0;/* 接收用户空间传递给内核的数据并且打印出来 */
retvalue = copy_from_user(writebuf, buf, cnt);
if(retvalue == 0){
printk("kernel recevdata:%s\r\n", writebuf);
}else{
printk("kernel recevdata failed!\r\n");
}
return 0;
}xxx_read函数
xxx_read函数表示内核（驱动程序）向用户空间（应用程序）传递的数据 ，因为内核空间不能直接操作用户空间的内存，因此需要借助 copy_to_user 函数来完成内核空间的数据到用户空间的复制。
函数原型：
static inline long copy_to_user(void __user *to, const void *from, unsigned long n)
参数 to 表示目的（应用程序数据），参数 from 表示源（驱动程序数据），参数 n 表示要复制的数据长度。如果复制成功，返回值为 0，如果复制失败则返回负数。
所以修改后的xxx_read()函数:——>将驱动程序中的kerneldata变量的数据传递给应用程序
static char kerneldata[] = {"kernel data!"};
static char readbuf[100];
static ssize_t xxx_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt)
{
int retvalue = 0;
memcpy(readbuf, kerneldata, sizeof(kerneldata));
retvalue = copy_to_user(buf, readbuf, cnt);
if(retvalue == 0){
printk("kernel senddata ok!\r\n");
}else{
printk("kernel senddata failed!\r\n");
}
return 0;
}6、注册字符设备
在入口函数static int __init xxx_init(void)中添加
xxx.cdev.owner = THIS_MODULE;
cdev_init(&xxx.cdev, &xxx_fops);
ret = cdev_add(&xxx.cdev, xxx.devid, XXX_CNT);
if(ret<0){
goto fail_cdev;
}
cdev_init函数对字符设备进行初始化。
函数原型：void cdev_init(struct cdev *cdev, const struct file_operations *fops)
参数 cdev 就是要初始化的 cdev 结构体变量，参数 fops 就是字符设备文件操作函数集合（标题5中内容）。
cdev_add函数用于向 Linux 系统添加字符设备(cdev 结构体变量)。
函数原型：int cdev_add(struct cdev *p, dev_t dev, unsigned count)
参数 p 指向要添加的字符设备(cdev 结构体变量)，参数 dev 就是设备所使用的设备号，参
数 count 是要添加的设备数量。
注：如果字符设备注册失败，则goto fail_cdev
在驱动出口函数static void __exit disled_exit(void)中，需要删除字符设备
cdev_del(&xxx.cdev);7、自动创建设备节点
设备树是采用树形结构来描述板子上的设备信息的文件，每个设备都是一个节点，叫做设备节点。
需要在入口函数static int __init xxx_init(void)中创建设备节点，
xxx.class = class_create(THIS_MODULE,XXX_NAME);
if(IS_ERR(xxx.class)){
ret = PTR_ERR(xxx.class);
goto fail_class;
}
xxx.device = device_create(xxx.class, NULL, xxx.devid, NULL, XXX_NAME);
if(IS_ERR(xxx.device)){
ret = PTR_ERR(xxx.device);
goto fail_device;
}class_create函数用于创建类
函数原型：struct class *class_create (struct module *owner, const char *name)
参数 owner 一般为 THIS_MODULE，参数 name 是类名字。
返回值是个指向结构体 class 的指针，也就是创建的类。
注：如果类创建失败，需要goto _class
在驱动出口函数static void __exit disled_exit(void)中，需要摧毁类
class_destroy(xxx.class);device_create函数用于创建设备
函数原型：struct device *device_create(struct class *class,
struct device *parent,
dev_t devt,
void *drvdata,
const char *fmt, ...)
参数 class 就是设备要创建哪个类；
参数 parent 是父设备，一般为 NULL，也就是没有父设备；
参数 devt 是设备号；
参数 drvdata 是设备可能会使用的一些数据，一般为 NULL；
参数 fmt 是设备名字，如果设置 fmt=xxx 的话，就会生成/dev/xxx这个设备文件；
返回值就是创建好的设备。
注：如果创建失败，则goto fail_device
在驱动出口函数static void __exit disled_exit(void)中，需要摧毁设备
device_destroy(xxx.class, xxx.devid);8、创建失败goto和return
在入口函数static int __init xxx_init(void)最后中添加goto内容
return 0;
fail_rs:
fail_findnd:
device_destroy(xxx.class, xxx.devid);
fail_device://创建设备失败
class_destroy(xxx.class);
fail_class://创建类失败
cdev_del(&xxx.cdev);
fail_cdev://字符设备失败
unregister_chrdev_region(xxx.devid, XXX_CNT);
fail_devid://设备号失败
return ret;如果创建成功，则返回 0，否则返回ret为负数，其中各种goto顺序不能乱，比如如果申请字符设备失败，说明设备号已经申请成功，需要释放设备号；如果创建类失败，说明字符设备和设备号创建成功，需要释放。代码依次执行。
9、驱动出口函数编写
该函数中需要释放字符设备，设备号，类，设备
static void __exit xxx_exit(void){
//删除设备
cdev_del(&xxx.cdev);
//释放设备号
unregister_chrdev_region(xxx.devid, XXX_CNT);
//摧毁设备
device_destroy(xxx.class, xxx.devid);
//摧毁类
class_destroy(xxx.class);
}函数原型：void cdev_del(struct cdev *p)
参数 p 就是要删除的字符设备。
函数原型是：void unregister_chrdev_region(dev_t from, unsigned count)
参数from：要释放的设备号。count：表示从 from 开始，要释放的设备号数量。
函数原型：void device_destroy(struct class *class, dev_t devt)
参数 class 是要删除的设备所处的类，参数 devt 是要删除的设备号。（在驱动出口函数中，需要先摧毁设备，再摧毁类）
函数原型：void class_destroy(struct class *cls);
参数 cls 就是要删除的类。
10、xxx.c整体代码
xxx.c文件
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#define XXX_CNT 1 //设备号个数
#define XXX_NAME "xxx" //设备号名字
//设备结构体
struct xxx_dev{
dev_t devid;//设备号
int major;//主设备号
struct cdev cdev; //字符设备
struct class *class;//类
struct device *device;//设备
struct device_node *nd;//设备树节点
int xxx_gpio; //GPIO编号
};
struct xxx_dev xxx;
static int xxx_open(struct inode *inode, struct file *filp){
filp->private_data = &xxx;
return 0;
}
static ssize_t xxx_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos){
struct xxx_dev *dev = (struct xxx_dev*)filp->private_data;
return 0;
}
static int xxx_release(struct inode *inode, struct file *filp){
struct xxx_dev *dev = (struct xxx_dev*)filp->private_data;
return 0;
}
static ssize_t xxx_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt)
{
struct xxx_dev *dev = (struct xxx_dev *)filp->private_data;
return 0;
}
static const struct file_operations xxx_fops = {
.owner = THIS_MODULE,
.write = xxx_write,
.open = xxx_open,
.release = xxx_release,
.read = xxx_read,
};
//驱动入口函数
static int __init xxx_init(void){
int ret = 0;
//注册设备号
xxx.major = 0;
if(xxx.major){ //给定设备号
xxx.devid = MKDEV(xxx.major, 0);
ret = register_chrdev_region(xxx.devid, XXX_CNT, XXX_NAME);
}else{ // 申请设备号
ret = alloc_chrdev_region(&xxx.devid, 0, XXX_CNT, XXX_NAME);
xxx.major = MAJOR(xxx.devid);
}
if(ret<0){
goto fail_devid;
}
//添加字符设备
xxx.cdev.owner = THIS_MODULE;
cdev_init(&xxx.cdev, &xxx_fops);
ret = cdev_add(&xxx.cdev, xxx.devid, XXX_CNT);
if(ret<0)
goto fail_cdev;
//自动创建设备节点
xxx.class = class_create(THIS_MODULE,XXX_NAME);
if(IS_ERR(xxx.class)){
ret = PTR_ERR(xxx.class);
goto fail_class;
}
xxx.device = device_create(xxx.class, NULL,xxx.devid, NULL, XXX_NAME);
if(IS_ERR(xxx.device)){
ret = PTR_ERR(xxx.device);
goto fail_device;
}
return 0;
fail_device:
class_destroy(xxx.class);
fail_class:
cdev_del(&xxx.cdev);
fail_cdev:
unregister_chrdev_region(xxx.devid, XXX_CNT);
fail_devid:
return ret;
}
//驱动出口函数
static void __exit xxx_exit(void){
//删除设备
cdev_del(&xxx.cdev);
//释放设备号
unregister_chrdev_region(xxx.devid, XXX_CNT);
//摧毁设备
device_destroy(xxx.class, xxx.devid);
//摧毁类
class_destroy(xxx.class);
}
//注册驱动
module_init(xxx_init);
module_exit(xxx_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("FANG");(3)应用程序编写
编写xxx.c文件对应的应用程序代码文件xxxApp.c，用于读取设备驱动文件
1、头文件
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "linux/ioctl.h"2、 main函数
int main(int argc, char *argv[]){
return 0;
}其中，argc是应用程序参数个数
argv是具体的参数内容（字符串形式）
3、open函数
int fd = 0,ret=0;
char *filename;
filename = argv[1];
fd = open(filename, O_RDWR);
if(fd < 0){
printf("can not open file %s\n",filename);
return -1;
}open()函数原型为 int open(const char *pathname, int flags);
参数 pathname：要打开的设备或者文件名，这里是第二个参数argv[1]
flags：文件打开模式，以下三种模式必选其一：
O_RDONLY 只读模式
O_WRONLY 只写模式
O_RDWR 读写模式
如果文件打开成功的话返回文件的文件描述符（int），即fd，后续代码通过这个文件描述符完成对文件的操作。
4、read函数
char readbuf[100];//从驱动读取到的数据存到readbuf中
ret = read(fd, radbuf, 10);
if(ret < 0){
printf("read file %s failed!\n", filename);
return -1;
}
read() 函数原型：ssize_t read(int fd, void *buf, size_t count)
参数 fd：要读取的文件描述符，读取文件之前要先用 open 函数打开文件，open 函数打开文件成
功以后会得到文件描述符。
buf：数据读取到此 buf 中。
count：要读取的数据长度，也就是字节数。
返回值：读取成功的话返回读取到的字节数；如果返回 0 表示读取到了文件末尾；如果返
回负值，表示读取失败。
5、write函数
char writebuf[100];//应用程序向驱动写的数据
ret = write(fd,writebuf,sizeof(writebuf));
if(ret<0){
printf("write file %s failed!\n" ,filename);
close(fd);
return -1;
}write()函数原型：ssize_t write(int fd, const void *buf, size_t count);
参数 fd：要进行写操作的文件描述符，写文件之前要先用 open 函数打开文件，open 函数打开文
件成功以后会得到文件描述符。
buf：要写入的数据。
count：要写入的数据长度，也就是字节数。
返回值：写入成功的话返回写入的字节数；如果返回 0 表示没有写入任何数据；如果返回负值，表示写入失败。
6、close函数
close(fd); close() 函数原型：int close(int fd);
参数： fd：要关闭的文件描述符。
返回值：0 表示关闭成功，负值表示关闭失败。
（4）程序测试
1、驱动程序编译
驱动程序文件xxx.c目录下终端运行make编译，生成xxx.ko文件
make已知：开发版根文件系统通过NFS挂载到ubuntu目录下。
将编译得到的xxx.ko文件拷贝到ubuntu的挂载目录nfs下的lib/modules/4.1.15/中
cp xxx.ko /home/f3161/linux/nfs/lib/modules/4.1.15/ -f2、应用程序编译
对应用程序xxxApp.c进行编译，生成xxxApp文件
arm-linux-gnueabihf-gcc xxxApp.c -o xxxApp将编译得到的xxxApp文件拷贝到ubuntu的挂载目录nfs下的lib/modules/4.1.15/中
cp xxxApp /home/f3161/linux/nfs/lib/modules/4.1.15/ -f3、开发板终端运行
在windows电脑下使用putty软件与开发板串口通信，作为串口终端使用。
第一次加载驱动的时候需要运行命令depmod
depmod运行modprobe xxx.ko命令加载驱动
modprobe xxx.ko输入“lsmod”命令即可查看当前系统中存在的模块
lsmod
输入命令查看当前系统中的设备
cat /proc/devices加载应用程序，其中后面可以添加参数
./xxxApp /dev/xxx卸载驱动
rmmod xxx.ko
4300
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
