首页 > 系统相关> > 嵌入式Linux字符设备自动创建设备节点

嵌入式Linux字符设备自动创建设备节点

2022-01-18 10:02:32 作者：互联网

自动创建设备节点分为俩个步骤：
步骤一：使用 class_create 函数创建一个类。
步骤二：使用 device_create 函数在我们创建的类下面创建一个设备。
自动创建设备节点简介
Linux 驱动实验中，当我们通过 insmod 命令加载模块后，还需要通过 mknod 命令来手动创建设备节点，这样使用起来太麻烦了，并且不可能每个设备都去这样操作， Linux 系统的存在就是为了方便使用，所以我们来看一下如何实现自动创建设备节点，当加载模块时，在/dev 目录下自动创建相应的设备文件。怎么自动创建一个设备节点呢？在嵌入式 Linux 中使用 mdev 来实现设备节点文件的自动创建和删除。
udev 是一种工具，它能够根据系统中的硬件设备的状态动态更新设备文件，包括设备文件的创建，删除等。设备文件通常放在/dev 目录下。使用 udev 后，在/dev 目录下就只包含系统中真正存在的设备。而mdev 是 udev 的简化版本,是 busybox 中所带的程序,最适合用在嵌入式系统,而 udev 一般用在 PC 上的linux 中,相对 mdev 来说要复杂些，所以在嵌入式 Linux 中使用 mdev 来实现设备节点文件的自动创建和删除。

创建和删除类函数
内核中定义了 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 就是要删除的类。

创建设备函数
当使用上节的函数创建完成一个类后，使用 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 是要删除的设备号。
创建类函数
chrdev.c文件完整代码如下所示：

#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" //宏定义类名

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;

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
};

static int hello_init(void)
{
    int ret; //函数返回值
    if (major_num)
    {
         /*静态注册设备号*/
         printk("major_num = %d\n", major_num); //打印传入进来的主设备号
         printk("minor_num = %d\n", minor_num); //打印传入进来的次设备号
         //MKDEV 将主设备号和次设备号合并为一个设备号
         dev_num = MKDEV(major_num, minor_num);
         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.owner = THIS_MODULE;
    //cdev_init 函数初始化 cdev 结构体成员变量
    cdev_init(&cdev, &chrdev_ops);
    //完成字符设备注册到内核
    cdev_add(&cdev, dev_num, DEVICE_NUMBER);
    //创建类
    class = class_create(THIS_MODULE, DEVICE_CLASS_NAME);
    return 0;
}

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);
MODULE_LICENSE("GPL");

将代码编译成模块，Makefile 为：

obj-m += chrdev.o #先写生成的中间文件的名字是什么， -m 的意思是把我们的驱动编译成模块
KDIR:= /home/XXXX/driver/imx6ull/linux-imx-rel_imx_4.1.15_2.1.0_ga/
PWD?=$(shell pwd) #获取当前目录的变量
all:
    make -C $(KDIR) M=$(PWD) modules #make 会进入内核源码的路径， 然后把当前路径下的代码编译成模块

如果创建类成功了以后，他会在开发板的/sys/class/下面生成一个名为“chrdev_class” 的类。现在没有加载驱动的情况，如下图所示：ls /sys/class

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

cd /mnt/nfs/imx6ull/14chrdev/
insmod chrdev.ko
ls /sys/class

创建设备函数

在前面代码的基础上添加创建设备的代码，如下所示：

#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("zuomu");

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

#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;
    } 
    close(fd);
    return 0;
}

输入以下命令编译app.c。编译好的应用程序在其他开发板上面也可以运行。
arm-none-linux-gnueabi-gcc app.c -o app -static
将前面加载的驱动卸载掉，再加载新编译好的的驱动，如下图所示：
rmmod chrdev
insmod chrdev.ko

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

输入以下命令查看下是否生成了设备节点ls /dev/chrdev_test

接下来验证生成的设备节点是否可以使用，我们拷贝生成的 APP 可执行文件到 Ubuntu 的/home/topeet/driver/imx6ull/14chrdev 目录下，输入以下命令运行，如下图所示，应用程序成功打开了设备节点。

标签：dev,嵌入式,chrdev,num,cdev,Linux,class,设备
来源： https://blog.csdn.net/yangxueyangxue/article/details/122553056