3. 字符设备驱动框架：file_operations、设备号与设备节点

字符设备是 Linux 驱动中最基础的设备类型，其核心框架围绕 file_operations 结构体、设备号 和 设备节点 三个要素展开。本章将深入剖析这三者的关系与实现方法，为后续 LED 控制和 GPIO 中断响应打下坚实基础。

3.1 字符设备驱动核心结构

字符设备驱动的本质是向内核注册一组操作函数，使得用户空间可以通过标准的文件 I/O 接口（open、read、write、ioctl 等）与硬件交互。这组操作函数通过 struct file_operations 结构体组织，并与设备号、设备节点绑定。

3.2 file_operations 结构体详解

struct file_operations 定义在 <linux/fs.h> 中，是驱动与 VFS（虚拟文件系统）之间的契约。驱动只需实现需要的回调函数，未实现的成员置为 NULL，内核会使用默认行为。

3.3 主次设备号：设备标识体系

设备号是内核识别设备的唯一标识，由 主设备号（major）和 次设备号（minor）组成，类型为 dev_t（32 位无符号整数，高 12 位为主设备号，低 20 位为次设备号）。

3.3.1 设备号分配方式

3.3.2 设备号操作宏

#include <linux/kdev_t.h>

dev_t devno = MKDEV(major, minor);   // 由主次号合成 dev_t
int major = MAJOR(devno);            // 从 dev_t 提取主设备号
int minor = MINOR(devno);            // 从 dev_t 提取次设备号

3.4 cdev_init 与 cdev_add：字符设备注册

字符设备通过 struct cdev 结构体表示，使用 cdev_init 初始化，cdev_add 向内核注册。标准注册流程如下：

1. 分配设备号：使用 alloc_chrdev_region 或 register_chrdev_region
2. 初始化 cdev：cdev_init(&my_cdev, &my_fops) 绑定 file_operations
3. 添加 cdev：cdev_add(&my_cdev, devno, count) 注册到内核
4. 创建设备节点：手动 mknod 或自动 udev/mdev

#include <linux/cdev.h>
#include <linux/fs.h>

static dev_t dev_num;                 // 设备号
static struct cdev my_cdev;           // 字符设备对象
static struct file_operations my_fops = {
    .owner = THIS_MODULE,
    .open = my_open,
    .release = my_release,
    .unlocked_ioctl = my_ioctl,
};

static int __init my_driver_init(void) {
    // 1. 动态分配设备号
    alloc_chrdev_region(&dev_num, 0, 1, "my_led_driver");
    printk("Major: %d, Minor: %d\n", MAJOR(dev_num), MINOR(dev_num));

    // 2. 初始化 cdev
    cdev_init(&my_cdev, &my_fops);
    my_cdev.owner = THIS_MODULE;

    // 3. 添加 cdev 到内核
    cdev_add(&my_cdev, dev_num, 1);
    return 0;
}

static void __exit my_driver_exit(void) {
    cdev_del(&my_cdev);               // 删除 cdev
    unregister_chrdev_region(dev_num, 1); // 释放设备号
}

module_init(my_driver_init);
module_exit(my_driver_exit);

3.5 设备节点的创建：手动与自动

设备节点是用户空间访问驱动的文件接口，位于 /dev 目录下。创建方式分为手动和自动两种。

3.5.1 手动创建设备节点

使用 mknod 命令手动创建，适用于开发调试阶段：

# 查看主设备号
cat /proc/devices | grep my_led_driver

# 手动创建设备节点（假设主设备号为 240）
sudo mknod /dev/my_led c 240 0
sudo chmod 666 /dev/my_led

3.5.2 自动创建设备节点

使用 Linux 设备模型中的 class_create 和 device_create 接口，配合 udev（用户空间）或 mdev（嵌入式 busybox）自动生成节点。

#include <linux/device.h>

static struct class *my_class;
static struct device *my_device;

static int __init my_driver_init(void) {
    // ... 分配设备号、cdev_init、cdev_add ...

    // 创建类
    my_class = class_create(THIS_MODULE, "my_led_class");
    if (IS_ERR(my_class)) {
        // 错误处理
    }

    // 创建设备节点（自动在 /dev 下生成 my_led_device）
    my_device = device_create(my_class, NULL, dev_num, NULL, "my_led_device");
    if (IS_ERR(my_device)) {
        // 错误处理
    }
    return 0;
}

static void __exit my_driver_exit(void) {
    device_destroy(my_class, dev_num);  // 销毁设备
    class_destroy(my_class);            // 销毁类
    cdev_del(&my_cdev);
    unregister_chrdev_region(dev_num, 1);
}

3.6 完整驱动框架模板

综合以上内容，给出一个可直接复用的字符设备驱动框架模板，包含自动创建设备节点：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "my_device"
#define CLASS_NAME  "my_class"

static int major;
static struct class *dev_class;
static struct device *dev_device;
static struct cdev my_cdev;

// file_operations 回调实现
static int my_open(struct inode *inode, struct file *file) {
    printk("Device opened\n");
    return 0;
}

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

static long my_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
    // 处理控制命令
    return 0;
}

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = my_open,
    .release = my_release,
    .unlocked_ioctl = my_ioctl,
};

static int __init my_init(void) {
    dev_t dev_num;

    // 1. 动态分配设备号
    alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
    major = MAJOR(dev_num);
    printk("Major number: %d\n", major);

    // 2. 初始化并添加 cdev
    cdev_init(&my_cdev, &fops);
    my_cdev.owner = THIS_MODULE;
    cdev_add(&my_cdev, dev_num, 1);

    // 3. 自动创建设备节点
    dev_class = class_create(THIS_MODULE, CLASS_NAME);
    if (IS_ERR(dev_class)) {
        unregister_chrdev_region(dev_num, 1);
        return PTR_ERR(dev_class);
    }

    dev_device = device_create(dev_class, NULL, dev_num, NULL, DEVICE_NAME);
    if (IS_ERR(dev_device)) {
        class_destroy(dev_class);
        unregister_chrdev_region(dev_num, 1);
        return PTR_ERR(dev_device);
    }

    printk("Driver loaded successfully\n");
    return 0;
}

static void __exit my_exit(void) {
    device_destroy(dev_class, MKDEV(major, 0));
    class_destroy(dev_class);
    cdev_del(&my_cdev);
    unregister_chrdev_region(MKDEV(major, 0), 1);
    printk("Driver unloaded\n");
}

module_init(my_init);
module_exit(my_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Character device driver template");

3.7 本章小结