Linux字符设备驱动开发

Narcotis

已于 2024-09-27 11:13:17 修改

阅读量801

点赞数 14

文章标签： linux arm开发学习嵌入式 c++ Linux驱动

于 2024-09-27 11:04:15 首次发布

本文链接：https://blog.csdn.net/weixin_44251074/article/details/142588397

版权

Linux 字符设备驱动开发是内核模块开发中的一个重要部分，主要用于处理字节流数据设备（如串口、键盘、鼠标等）。字符设备驱动的核心任务是定义如何与用户空间程序交互，通常通过一组文件操作函数进行。这些函数会映射到 open、read、write 等系统调用。

下面将详细介绍字符设备驱动开发的步骤，包括编写、注册、操作函数实现、测试等。

1. 字符设备驱动开发流程

步骤 1: 创建一个内核模块

字符设备驱动是作为内核模块加载的，可以动态加载到 Linux 内核中。我们从编写一个简单的字符设备驱动模块开始。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>         // 文件系统支持
#include <linux/cdev.h>       // 字符设备支持
#include <linux/uaccess.h>    // 用户空间访问支持

#define DEVICE_NAME "mychardev"
#define BUFFER_SIZE 1024

static int major;                          // 主设备号
static char device_buffer[BUFFER_SIZE];     // 设备数据缓冲区
static struct cdev my_cdev;                // 字符设备结构体
static dev_t dev_num;                      // 设备号

// 文件操作函数
static int device_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device opened\n");
    return 0;
}

static int device_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device closed\n");
    return 0;
}

static ssize_t device_read(struct file *file, char __user *buffer, size_t len, loff_t *offset) {
    size_t bytes_read = len < BUFFER_SIZE ? len : BUFFER_SIZE;
    if (copy_to_user(buffer, device_buffer, bytes_read)) {
        return -EFAULT;
    }
    printk(KERN_INFO "Read %zu bytes from device\n", bytes_read);
    return bytes_read;
}

static ssize_t device_write(struct file *file, const char __user *buffer, size_t len, loff_t *offset) {
    size_t bytes_write = len < BUFFER_SIZE ? len : BUFFER_SIZE;
    if (copy_from_user(device_buffer, buffer, bytes_write)) {
        return -EFAULT;
    }
    printk(KERN_INFO "Wrote %zu bytes to device\n", bytes_write);
    return bytes_write;
}

// 文件操作函数结构体
static struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = device_open,
    .release = device_release,
    .read = device_read,
    .write = device_write,
};

// 模块加载时的初始化函数
static int __init mychardev_init(void) {
    // 动态分配主设备号和次设备号
    alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
    major = MAJOR(dev_num);
    printk(KERN_INFO "Registered with major number %d\n", major);

    // 初始化 cdev 结构体并添加到系统
    cdev_init(&my_cdev, &fops);
    cdev_add(&my_cdev, dev_num, 1);

    return 0;
}

// 模块卸载时的清理函数
static void __exit mychardev_exit(void) {
    // 删除 cdev
    cdev_del(&my_cdev);
    // 释放设备号
    unregister_chrdev_region(dev_num, 1);
    printk(KERN_INFO "Device unregistered\n");
}

module_init(mychardev_init);
module_exit(mychardev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Example Author");
MODULE_DESCRIPTION("A simple character device driver");

步骤 2: 编写 Makefile

为了编译驱动模块，需要编写一个 Makefile 来调用内核构建系统。

obj-m += mychardev.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

步骤 3: 编译驱动

编译驱动：

make

生成的模块文件为 mychardev.ko。

步骤 4: 加载和卸载驱动

加载字符设备驱动模块：

sudo insmod mychardev.ko

检查是否成功加载驱动：

dmesg | tail

卸载模块：

sudo rmmod mychardev

步骤 5: 创建设备文件

Linux 使用设备文件与用户空间通信。驱动模块加载时，需要为字符设备创建设备文件。

首先通过 /proc/devices 查看分配的主设备号：

cat /proc/devices | grep mychardev

使用 mknod 创建设备文件：

sudo mknod /dev/mychardev c <major_number> 0
sudo chmod 666 /dev/mychardev

2. 文件操作函数实现

1. `open` 和 `release` 函数

这些函数会在打开和关闭设备文件时被调用。它们通常用于初始化设备或者释放设备资源。

open：每次用户空间程序通过 open() 调用打开设备文件时调用，通常用于设备初始化。
release：每次关闭设备文件时调用，用于释放资源。

static int device_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device opened\n");
    return 0;
}

static int device_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device closed\n");
    return 0;
}

2. `read` 和 `write` 函数

这些函数分别实现用户空间程序对设备的读取和写入操作。

read：读取设备的数据，用户空间调用 read() 时触发。
write：将用户空间的数据写入设备，用户空间调用 write() 时触发。

static ssize_t device_read(struct file *file, char __user *buffer, size_t len, loff_t *offset) {
    size_t bytes_read = len < BUFFER_SIZE ? len : BUFFER_SIZE;
    if (copy_to_user(buffer, device_buffer, bytes_read)) {
        return -EFAULT;
    }
    printk(KERN_INFO "Read %zu bytes from device\n", bytes_read);
    return bytes_read;
}

static ssize_t device_write(struct file *file, const char __user *buffer, size_t len, loff_t *offset) {
    size_t bytes_write = len < BUFFER_SIZE ? len : BUFFER_SIZE;
    if (copy_from_user(device_buffer, buffer, bytes_write)) {
        return -EFAULT;
    }
    printk(KERN_INFO "Wrote %zu bytes to device\n", bytes_write);
    return bytes_write;
}

3. 设备号分配与 `cdev` 结构

字符设备必须注册到内核中，以使内核能够通过设备号找到驱动程序。主设备号用于标识驱动程序，次设备号用于标识设备实例。

使用 alloc_chrdev_region 动态分配设备号。
使用 cdev_init 和 cdev_add 将字符设备添加到内核中。
使用 cdev_del 删除设备。

alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
cdev_init(&my_cdev, &fops);
cdev_add(&my_cdev, dev_num, 1);

4. 测试驱动

编写一个简单的用户空间测试程序来与字符设备驱动交互。

用户空间测试程序

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

#define DEVICE_PATH "/dev/mychardev"
#define BUFFER_SIZE 1024

int main() {
    int fd;
    char write_buffer[BUFFER_SIZE] = "Hello, Kernel!";
    char read_buffer[BUFFER_SIZE];

    // 打开设备文件
    fd = open(DEVICE_PATH, O_RDWR);
    if (fd < 0) {
        perror("Failed to open the device");
        return EXIT_FAILURE;
    }

    // 写数据到设备
    printf("Writing to device: %s\n", write_buffer);
    if (write(fd, write_buffer, strlen(write_buffer)) < 0) {
        perror("Failed to write to the device");
        close(fd);
        return EXIT_FAILURE;
    }

    // 清空读取缓冲区
    memset(read_buffer, 0, sizeof(read_buffer));

    // 从设备读取数据
    if (read(fd, read_buffer, sizeof(read_buffer)) < 0) {
        perror("Failed to read from the device");
        close(fd);
        return EXIT_FAILURE;
    }

    // 输出从设备读取到的数据
    printf("Read from device: %s\n", read_buffer);

    // 关闭设备文件
    close(fd);

    return EXIT_SUCCESS;
}

当成功编写、加载并测试字符设备驱动时，用户空间程序会通过标准输出显示与驱动交互的结果。下面是驱动程序的纯输出示例，假设测试程序成功与字符设备驱动交互：

用户空间测试程序输出

Writing to device: Hello, Kernel!
Read from device: Hello, Kernel!

内核日志 (`dmesg`) 输出

[  123.456789] Registered with major number 240
[  123.456890] Device opened
[  123.457123] Wrote 13 bytes to device
[  123.457345] Read 13 bytes from device
[  123.457567] Device closed

输出解释

用户空间测试程序输出：
- 测试程序将字符串 "Hello, Kernel!" 写入字符设备，并随后读取回相同的字符串。
- Writing to device: Hello, Kernel! 表示程序已成功向设备写入数据。
- Read from device: Hello, Kernel! 表示程序已成功从设备读取数据。
内核日志 (dmesg) 输出：
- Registered with major number 240 表示字符设备驱动成功注册，并分配了主设备号 240。
- Device opened 表示设备文件被打开，说明用户空间程序调用了 open() 系统调用。
- Wrote 13 bytes to device 表示用户空间程序写入了 13 字节的数据到设备。
- Read 13 bytes from device 表示用户空间程序从设备读取了 13 字节的数据。
- Device closed 表示设备文件被关闭，说明用户空间程序调用了 close() 系统调用。

这些输出可以帮助你确认驱动程序的各个操作函数被正确调用，并且用户空间程序与字符设备的交互是成功的。

5. 总结

通过上述步骤可以开发一个简单的字符设备驱动程序。字符设备驱动的核心是通过 file _operations 结构体实现的操作函数，包括 open、read、write 和 release 等。在用户空间编写简单的测试程序，使用 open()、read()、write() 系统调用与字符设备进行交互，从而验证驱动程序的正确性。