自学内容网 自学内容网
自学内容网 > 正文

【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第四十六章 自动创建设备节点

🕗 发布于 2024-07-23 09:29 嵌入式硬件  linux  

i.MX8MM处理器采用了先进的14LPCFinFET工艺，提供更快的速度和更高的电源效率;四核Cortex-A53，单核Cortex-M4，多达五个内核 ，主频高达1.8GHz，2G DDR4内存、8G EMMC存储。千兆工业级以太网、MIPI-DSI、USB HOST、WIFI/BT、4G模块、CAN、RS485等接口一应俱全。H264、VP8视频硬编码，H.264、H.265、VP8、VP9视频硬解码，并提供相关历程,支持8路PDM接口、5路SAI接口、2路Speaker。系统支持Android9.0(支持获取root限)Linux4.14.78+Qt5.10.1、Yocto、Ubuntu20、Debian9系统。适用于智能充电桩，物联网，工业控制，医疗，智能交通等，可用于任何通用工业和物联网应用、

【公众号】迅为电子

【粉丝群】258811263（加群获取驱动文档+例程）

第四十六章 自动创建设备节点

本章导读

自动创建设备节点分为两个步骤：

步骤一：使用class_create函数创建一个类。

步骤二：使用device_create函数在我们创建的类下面创建一个设备。

46.1章节讲解了自动创建设备节点的基本概念及使用函数

46.2章节在创建了字符设备的基础上，编写创建类的驱动程序，并编译为驱动模块，测试验证是否创建了类。

46.3章节在46.2章节的基础上，编写创建设备的驱动程序，并编译为驱动模块。编写了应用测试程序，测试验证是否创建了设备。

本章内容对应视频讲解链接（在线观看）：

自动创建设备节点 → https://www.bilibili.com/video/BV1Vy4y1B7ta?p=17

程序源码在网盘资料“iTOP-i.MX8MM开发板\02-i.MX8MM开发板网盘资料汇总(不含光盘内容)\嵌入式Linux开发指南(iTOP-i.MX8MM)手册配套资料\2.驱动程序例程\08-自动创建设备节点”路径下。

46.1 自动创建设备节点简介

Linux 驱动实验中，当我们通过 insmod 命令加载模块后，还需要通过 mknod 命令来手动创建设备节点，这样使用起来太麻烦了，并且不可能每个设备都去这样操作，Linux 系统的存在就是为了方便使用，所以我们来看一下如何实现自动创建设备节点，当加载模块时，在/dev 目录下自动创建相应的设备文件。

怎么自动创建一个设备节点呢？在嵌入式 Linux 中使用 mdev 来实现设备节点文件的自动创建和删除。

udev 是一种工具，它能够根据系统中的硬件设备的状态动态更新设备文件，包括设备文件的创建，删除等。设备文件通常放在/dev 目录下。使用 udev 后，在/dev 目录下就只包含系统中真正存在的设备。而

mdev 是 udev 的简化版本,是 busybox 中所带的程序,最适合用在嵌入式系统,而 udev 一般用在 PC 上的 linux中,相对 mdev 来说要复杂些，所以在嵌入式 Linux 中使用 mdev 来实现设备节点文件的自动创建和删除。

46.1.1 创建和删除类函数

内核中定义了struct class结构体，顾名思义，一个struct class结构体类型变量对应一个类，内核同时提供了class_create用来创建一个类，这个类存放于sysfs下面，一旦创建好了这个类，再调用device_create来在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应device_create，去/sysfs下寻找对应的类从而创建设备节点。

在 Linux 驱动程序中一般通过class_create和class_destroy来完成设备节点的创建和删除。首先要创建一个 class 类结构体，class 结构体定义在 include/linux/device.h 里面。class_create 是个宏，宏定义如下：

#define class_create(owner, name) \
({ \
static struct lock_class_key __key; \
__class_create(owner, name, &__key); \
})
struct class *__class_create(struct module *owner, const char *name,
struct lock_class_key *key)

class_create 一共有两个参数，参数 owner 一般为 THIS_MODULE，参数 name 是类名字。返回值是个指向结构体 class 的指针，也就是创建的类。

卸载驱动程序的时候需要删除掉类，类删除函数为 class_destroy，函数原型如下：

void class_destroy(struct class *cls);

参数 cls 就是要删除的类。

46.1.2 创建设备函数

当使用上节的函数创建完成一个类后，使用 device_create 函数在这个类下创建一个设备。device_create

函数原型如下：

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

device_create 是个可变参数函数，参数 class 就是设备要创建哪个类下面；参数 parent 是父设备，一般为 NULL，也就是没有父设备；参数 devt 是设备号；参数 drvdata 是设备可能会使用的一些数据，一般为 NULL；参数 fmt 是设备名字，如果设置 fmt=xxx 的话，就会生成/dev/xxx 这个设备文件。返回值就是创建好的设备。

同样的，卸载驱动的时候需要删除掉创建的设备，设备删除函数为 device_destroy，函数原型如下：

void device_destroy(struct class *class, dev_t devt)

参数 class 是要删除的设备所处的类，参数 devt 是要删除的设备号。

46.2 创建类函数

程序源码在网盘资料“iTOP-i.MX8MM开发板\02-i.MX8MM开发板网盘资料汇总(不含光盘内容)\嵌入式Linux开发指南(iTOP-i.MX8MM)手册配套资料\2.驱动程序例程\08-自动创建设备节点\001”路径下。

通过48.1章节自动创建设备节点理论基础的学习，我们已经把基本概念搞懂了。我们在ubuntu的/home/topeet/imx8mm/08/001目录下新建chrdev.c文件。我们可以将上次编写的chrdev.c的基础上进行修改。完整代码如下所示：

/*
 * @Author:topeet
 * @Description:字符设备自动创建设备节点步骤一创建类，创建设备
 */
#include <linux/init.h>   //初始化头文件
#include <linux/module.h> //最基本的文件，支持动态添加和卸载模块。
#include <linux/fs.h>     //包含了文件操作相关struct的定义，例如大名鼎鼎的struct file_operations
#include <linux/kdev_t.h>
#include <linux/cdev.h>        //对字符设备结构cdev以及一系列的操作函数的定义。//包含了cdev 结构及相关函数的定义。
#define DEVICE_NUMBER 1        //定义次设备号的个数
#define DEVICE_SNAME "schrdev" //定义静态注册设备的名称
#define DEVICE_ANAME "achrdev" //定义动态注册设备的名称
#define DEVICE_MINOR_NUMBER 0  //定义次设备号的起始地址
#include <linux/device.h>      //包含了device、class 等结构的定义
#define DEVICE_CLASS_NAME "chrdev_class"
#define DEVICE_NODE_NAME "chrdev_test" //宏定义设备节点的名字
static int major_num, minor_num;       //定义主设备号和次设备号

struct class *class;                   /* 类 */
struct cdev cdev;                      //定义一个cdev结构体
module_param(major_num, int, S_IRUSR); //驱动模块传入普通参数major_num
module_param(minor_num, int, S_IRUSR); //驱动模块传入普通参数minor_num
dev_t dev_num;                         /* 设备号 */

/**
 * @description: 打开设备
 * @param {structinode} *inode：传递给驱动的 inode
 * @param {structfile} *file：设备文件，file 结构体有个叫做 private_data 的成员变量，
 *  一般在 open 的时候将 private_data 指向设备结构体。
 * @return: 0 成功;其他 失败 
 */
int chrdev_open(struct inode *inode, struct file *file)
{
    printk("chrdev_open\n");
    return 0;
}
// 设备操作函数结构体
struct file_operations chrdev_ops = {
    .owner = THIS_MODULE,
    .open = chrdev_open};
/**
 * @description: 驱动入口函数
 * @param {*}无
 * @return {*} 0 成功;其他 失败
 */
static int hello_init(void)
{
    int ret; //函数返回值
    if (major_num)
    {
        /*静态注册设备号*/
        printk("major_num = %d\n", major_num); //打印传入进来的主设备号
        printk("minor_num = %d\n", minor_num); //打印传入进来的次设备号

        dev_num = MKDEV(major_num, minor_num);                              //MKDEV将主设备号和次设备号合并为一个设备号
        ret = register_chrdev_region(dev_num, DEVICE_NUMBER, DEVICE_SNAME); //注册设备号
        if (ret < 0)
        {
            printk("register_chrdev_region error\n");
        }
        printk("register_chrdev_region ok\n"); //静态注册设备号成功
    }
    else
    {
        /*动态注册设备号*/
        ret = alloc_chrdev_region(&dev_num, DEVICE_MINOR_NUMBER, 1, DEVICE_ANAME);
        if (ret < 0)
        {
            printk("alloc_chrdev_region error\n");
        }
        printk("alloc_chrdev_region ok\n"); //动态注册设备号成功

        major_num = MAJOR(dev_num);            //将主设备号取出来
        minor_num = MINOR(dev_num);            //将次设备号取出来
        printk("major_num = %d\n", major_num); //打印传入进来的主设备号
        printk("minor_num = %d\n", minor_num); //打印传入进来的次设备号
    }
    // 初始化 cdev
    cdev.owner = THIS_MODULE;
    cdev_init(&cdev, &chrdev_ops);
    // 向系统注册设备
    cdev_add(&cdev, dev_num, DEVICE_NUMBER);
    // 创建 class 类
    class = class_create(THIS_MODULE, DEVICE_CLASS_NAME);
    return 0;
}
/**
 * @description: 驱动出口函数
 * @param {*}无
 * @return {*}无
 */
static void hello_exit(void)
{
    //注销设备号
    unregister_chrdev_region(MKDEV(major_num, minor_num), DEVICE_NUMBER);
    //删除设备
    cdev_del(&cdev);
    //删除类
    class_destroy(class);
    printk("gooodbye! \n");
}
// 将上面两个函数指定为驱动的入口和出口函数
module_init(hello_init);
module_exit(hello_exit);
//  LICENSE 和作者信息
MODULE_LICENSE("GPL");
MODULE_AUTHOR("topeet");

这里我们以iTOP-IMX8MM开发板为例，将编写的代码编译成模块。我们将chrdev.c文件拷贝到Ubuntu的/home/topeet/imx8mm/08下。将上次编译chrdev.c的Makefile文件和build.sh文件拷贝到chrdev.c同级目录下，修改Makefile为：

obj-m += chrdev.o
KDIR:=/home/topeet/linux/linux-imx
PWD?=$(shell pwd)
all:
make -C $(KDIR) M=$(PWD) modules ARCH=arm64
clean:
make -C $(KDIR) M=$(PWD) clean

文件如下图所示：

编译驱动成功如下图所示：

我们通过nfs将编译好的驱动程序加载模块。如果创建类成功了以后，他会在开发板的/sys/class/下面生成一个名为“chrdev_class”的类。现在没有加载驱动的情况，如下图所示：

ls /sys/class

 

我们输入以下命令，加载驱动模块，如下图所示：

insmod chrdev.ko  

ls /sys/class

 

到此为止，我们的类创建好了。

46.3 创建设备函数

程序源码在网盘资料“iTOP-i.MX8MM开发板\02-i.MX8MM开发板网盘资料汇总(不含光盘内容)\嵌入式Linux开发指南(iTOP-i.MX8MM)手册配套资料\2.驱动程序例程\08-自动创建设备节点\002”路径下。

在46.2章节代码的基础上添加创建设备的代码，如下所示：

/*
 * @Author:topeet
 * @Description:字符设备自动创建设备节点步骤一创建类，创建设备
 */
#include <linux/init.h>   //初始化头文件
#include <linux/module.h> //最基本的文件，支持动态添加和卸载模块。
#include <linux/fs.h>     //包含了文件操作相关struct的定义，例如大名鼎鼎的struct file_operations
#include <linux/kdev_t.h>
#include <linux/cdev.h>        //对字符设备结构cdev以及一系列的操作函数的定义。//包含了cdev 结构及相关函数的定义。
#define DEVICE_NUMBER 1        //定义次设备号的个数
#define DEVICE_SNAME "schrdev" //定义静态注册设备的名称
#define DEVICE_ANAME "achrdev" //定义动态注册设备的名称
#define DEVICE_MINOR_NUMBER 0  //定义次设备号的起始地址
#include <linux/device.h>      //包含了device、class 等结构的定义
#define DEVICE_CLASS_NAME "chrdev_class"
#define DEVICE_NODE_NAME "chrdev_test" //宏定义设备节点的名字
static int major_num, minor_num;       //定义主设备号和次设备号

struct class *class;                   /* 类 */
struct device *device;                 /* 设备 */
struct cdev cdev;                      //定义一个cdev结构体
module_param(major_num, int, S_IRUSR); //驱动模块传入普通参数major_num
module_param(minor_num, int, S_IRUSR); //驱动模块传入普通参数minor_num
dev_t dev_num;                         /* 设备号 */

/**
 * @description: 打开设备
 * @param {structinode} *inode：传递给驱动的 inode
 * @param {structfile} *file：设备文件，file 结构体有个叫做 private_data 的成员变量，
 *  一般在 open 的时候将 private_data 指向设备结构体。
 * @return: 0 成功;其他 失败 
 */
int chrdev_open(struct inode *inode, struct file *file)
{
    printk("chrdev_open\n");
    return 0;
}
// 设备操作函数结构体
struct file_operations chrdev_ops = {
    .owner = THIS_MODULE,
    .open = chrdev_open};
/**
 * @description: 驱动入口函数
 * @param {*}无
 * @return {*} 0 成功;其他 失败
 */
static int hello_init(void)
{
    int ret; //函数返回值
    if (major_num)
    {
        /*静态注册设备号*/
        printk("major_num = %d\n", major_num); //打印传入进来的主设备号
        printk("minor_num = %d\n", minor_num); //打印传入进来的次设备号

        dev_num = MKDEV(major_num, minor_num);                              //MKDEV将主设备号和次设备号合并为一个设备号
        ret = register_chrdev_region(dev_num, DEVICE_NUMBER, DEVICE_SNAME); //注册设备号
        if (ret < 0)
        {
            printk("register_chrdev_region error\n");
        }
        printk("register_chrdev_region ok\n"); //静态注册设备号成功
    }
    else
    {
        /*动态注册设备号*/
        ret = alloc_chrdev_region(&dev_num, DEVICE_MINOR_NUMBER, 1, DEVICE_ANAME);
        if (ret < 0)
        {
            printk("alloc_chrdev_region error\n");
        }
        printk("alloc_chrdev_region ok\n"); //动态注册设备号成功

        major_num = MAJOR(dev_num);            //将主设备号取出来
        minor_num = MINOR(dev_num);            //将次设备号取出来
        printk("major_num = %d\n", major_num); //打印传入进来的主设备号
        printk("minor_num = %d\n", minor_num); //打印传入进来的次设备号
    }
    // 初始化 cdev
    cdev.owner = THIS_MODULE;
    cdev_init(&cdev, &chrdev_ops);
    // 向系统注册设备
    cdev_add(&cdev, dev_num, DEVICE_NUMBER);
    // 创建 class 类
    class = class_create(THIS_MODULE, DEVICE_CLASS_NAME);
    // 在 class 类下创建设备
    device = device_create(class, NULL, dev_num, NULL, DEVICE_NODE_NAME);
    return 0;
}
/**
 * @description: 驱动出口函数
 * @param {*}无
 * @return {*}无
 */
static void hello_exit(void)
{
    //注销设备号
    unregister_chrdev_region(MKDEV(major_num, minor_num), DEVICE_NUMBER);
    //删除设备
    cdev_del(&cdev);
    //注销设备
    device_destroy(class, dev_num);
    //删除类
    class_destroy(class);
    printk("gooodbye! \n");
}
// 将上面两个函数指定为驱动的入口和出口函数
module_init(hello_init);
module_exit(hello_exit);
//  LICENSE 和作者信息
MODULE_LICENSE("GPL");
MODULE_AUTHOR("topeet");

编写应用测试程序如下所示：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc,char *argv[])
{
    int fd;
    char buf[64] = {0};
    fd = open("/dev/chrdev_test",O_RDWR);  //打开设备节点
    if(fd < 0)
    {
        perror("open error \n");
        return fd;
    }
    //read(fd,buf,sizeof(buf)); //从文件中读取数据放入缓冲区中
    close(fd);
    return 0;
}

我们将app.c文件拷贝到Ubuntu的/home/topeet/imx8mm/08/002目录下，输入以下命令编译app.c。

将46.3章节编写好的驱动代码编译，如下图所示： 

首先我们将46.2章节加载的驱动卸载掉，再加载新编译好的的驱动，如下图所示：

insmod chrdev.ko

 

我们输入以下命令查看/sys/class下面是否生成类，如下图所示：

ls /sys/class/chrdev_class/

 

我们输入以下命令查看下是否生成了设备节点

ls /dev/chrdev_test

 

我们接下来验证生成的设备节点是否可以使用，输入以下命令运行app，如下图所示，应用程序成功打开了设备节点。 

现在我们已经成功地自动创建了设备节点。

本章节学习完之后，字符设备的整个流程想必大家已经很清楚了，字符设备在你的脑海里已经有了相关的框架。有的同学会有疑问“还没有教点灯，控制蜂鸣器，怎么字符设备就学习完了呀”，像点灯，控制蜂鸣器不是我们学习驱动的重点，框架才是重中之重。如果框架学习的非常清楚了，通过应用层可以操作我们的驱动，那么你去控制led，蜂鸣器就非常简单了。所以这就是很多人看了很多视频，学习了点灯，控制蜂鸣器，学习却始终不得要领的原因了。

 


原文地址：https://blog.csdn.net/BeiJingXunWei/article/details/140613543

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024