Linux字符设备驱动开发实战：从零编写内核模块与用户空间通信

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

在嵌入式、服务器、桌面乃至移动设备领域，Linux 内核驱动着海量的硬件。从一块简单的 GPIO 引脚到复杂的 PCIe 显卡，硬件的功能最终都需要通过驱动程序来“翻译”给操作系统和应用层。对于开发者而言，理解并能够动手编写一个 Linux 驱动程序，是深入操作系统内核、掌握系统底层运作机制的关键一步。这不仅仅是内核开发者的专属技能，对于从事嵌入式系统、高性能计算、存储或网络开发的工程师来说，理解驱动模型能极大提升问题排查和性能优化的能力。

本文旨在为有一定 C 语言和 Linux 使用基础的开发者，提供一个从零开始编写、编译、加载和测试一个简单字符设备驱动的实战指南。我们将避开复杂的硬件交互，聚焦于驱动开发的核心流程和框架，让你理解一个内核模块是如何被构建、如何与用户空间通信，以及内核编程与普通应用程序开发的核心差异。完成本文的实践后，你将掌握驱动开发的基本骨架，并能在此基础上扩展出更复杂的功能。

1. 理解 Linux 驱动程序与内核模块

在动手写代码之前，必须厘清几个核心概念：驱动程序、内核模块、内核空间与用户空间。这些概念是理解后续所有操作的基础。

1.1 驱动程序是什么？

驱动程序本质上是一段特殊的代码，它充当了硬件设备与操作系统内核之间的“翻译官”和“管理员”。操作系统内核定义了统一的接口（如文件操作struct file_operations），驱动程序则负责实现这些接口，将通用的“打开”、“读取”、“写入”、“关闭”等操作，翻译成操控特定硬件的具体指令（如读写某个芯片的寄存器）。

例如，当你对一个设备文件（如/dev/ttyS0）执行write系统调用时，内核会找到对应的驱动，驱动中的write函数被调用，该函数最终会通过 CPU 的特定指令，将数据写入串口控制器硬件的发送寄存器中。

1.2 内核模块：驱动程序的载体

驱动程序通常以内核模块的形式存在。内核模块是一种可以在 Linux 内核运行时动态加载和卸载的代码对象，它被编译成.ko文件。这与将功能直接编译进内核镜像（vmlinuz）有本质区别。

• 动态加载：使用insmod命令加载模块，使用rmmod命令卸载模块。这带来了极大的灵活性，无需重启系统即可添加或移除驱动功能。
• 运行在内核空间：模块代码运行在 CPU 的最高特权级（Ring 0），与内核本身共享地址空间。这意味着模块代码可以访问所有内存和硬件资源，但同时也意味着一个错误的指针解引用就可能导致整个系统崩溃（内核恐慌，Kernel Panic）。
• 无标准库：模块不能链接 glibc 等用户空间的标准 C 库。它只能使用内核导出的函数和头文件，例如printk代替printf，kmalloc代替malloc。

1.3 内核空间 vs 用户空间

这是 Linux 驱动编程中最重要的分界线。

• 用户空间：普通应用程序运行的地方。拥有独立的虚拟地址空间，受到严格保护，不能直接访问硬件或内核内存。通过“系统调用”接口向内核请求服务。
• 内核空间：内核及所有模块运行的地方。共享同一个地址空间，可以访问所有物理内存和硬件。驱动代码就在这里执行。

当驱动需要与用户程序交换数据时（例如，用户程序read驱动设备），数据需要跨越这个边界进行复制。驱动中常用的copy_to_user和copy_from_user函数就是为此设计的，它们会在复制前进行必要的安全检查。

理解了这个模型，你就明白了为什么驱动代码需要格外小心：它的错误影响是系统级的。

2. 开发环境准备与内核头文件

编写内核模块需要一个完整的 Linux 开发环境，并且最关键的是需要与当前运行内核版本匹配的内核头文件或内核源代码。因为模块必须针对特定的内核版本进行编译。

2.1 基础环境检查

首先，确认你的开发机是一台 Linux 系统（物理机或虚拟机均可）。打开终端，执行以下命令检查系统信息：

# 查看当前内核版本，这是后续获取头文件的关键 uname -r # 示例输出：5.15.0-91-generic # 查看系统发行版信息，用于确定包管理命令 lsb_release -a # 或 cat /etc/os-release

2.2 安装编译工具链和内核头文件

内核模块的编译依赖于gcc、make等工具，以及最重要的内核头文件包。

• 对于 Ubuntu/Debian 系列：

  sudo apt update sudo apt install build-essential linux-headers-$(uname -r)

  linux-headers-$(uname -r)这个包包含了编译模块所需的所有头文件和 Makefile 模板，它会自动匹配你的内核版本。

• 对于 RHEL/CentOS/Fedora 系列：

  # RHEL/CentOS 7/8 sudo yum install kernel-devel-$(uname -r) gcc make # 或使用 dnf (CentOS 8+, Fedora) sudo dnf install kernel-devel-$(uname -r) gcc make

安装完成后，验证头文件路径是否存在：

ls -d /lib/modules/$(uname -r)/build

这个路径通常是一个指向/usr/src/linux-headers-$(uname -r)的符号链接，它是编译模块时Makefile中KERNEL_DIR的默认值。

2.3 创建项目目录

为我们的驱动项目创建一个独立的工作目录：

mkdir -p ~/projects/simple_char_driver cd ~/projects/simple_char_driver

后续的所有文件都将放在这个目录下。

3. 编写最简单的字符设备驱动

我们将创建一个名为simple_char的字符设备驱动。它不控制真实硬件，而是在内核中维护一段内存缓冲区，用户程序可以像读写文件一样读写这段缓冲区。这是一个典型的“内存设备”驱动，非常适合学习驱动框架。

3.1 驱动源代码：simple_char.c

在项目目录下创建simple_char.c文件，内容如下：

// simple_char.c #include <linux/init.h> // 模块初始化和清理宏 #include <linux/module.h> // 模块相关核心头文件 #include <linux/kernel.h> // 内核打印函数 printk #include <linux/fs.h> // 文件操作结构 file_operations #include <linux/cdev.h> // 字符设备结构 cdev #include <linux/slab.h> // 内核内存分配函数 kmalloc/kfree #include <linux/uaccess.h> // 用户/内核空间数据拷贝函数 #define DEVICE_NAME "simple_char" #define CLASS_NAME "simple_char_class" #define BUFFER_SIZE 1024 MODULE_LICENSE("GPL"); MODULE_AUTHOR("Your Name"); MODULE_DESCRIPTION("A simple character device driver for learning."); MODULE_VERSION("0.1"); static int major_number = 0; // 动态分配主设备号 static struct class* simple_char_class = NULL; static struct cdev simple_char_cdev; // 驱动内部缓冲区 static char *device_buffer = NULL; static int buffer_offset = 0; // 设备打开函数 static int simple_char_open(struct inode *inodep, struct file *filep) { printk(KERN_INFO "simple_char: Device has been opened.\n"); return 0; // 返回0表示成功 } // 设备关闭函数 static int simple_char_release(struct inode *inodep, struct file *filep) { printk(KERN_INFO "simple_char: Device has been closed.\n"); return 0; } // 设备读函数 static ssize_t simple_char_read(struct file *filep, char __user *buffer, size_t len, loff_t *offset) { int bytes_to_read; int bytes_not_copied; // 计算还能读多少字节（从buffer_offset开始到缓冲区末尾） bytes_to_read = BUFFER_SIZE - buffer_offset; if (bytes_to_read > len) { bytes_to_read = len; } if (bytes_to_read == 0) { printk(KERN_INFO "simple_char: No data to read.\n"); return 0; // 返回0表示EOF } // 将内核缓冲区数据拷贝到用户空间 bytes_not_copied = copy_to_user(buffer, device_buffer + buffer_offset, bytes_to_read); if (bytes_not_copied) { printk(KERN_ERR "simple_char: Failed to copy %d bytes to user.\n", bytes_not_copied); return -EFAULT; // 返回错误码 } printk(KERN_INFO "simple_char: Sent %d bytes to user.\n", bytes_to_read - bytes_not_copied); buffer_offset += bytes_to_read - bytes_not_copied; return bytes_to_read - bytes_not_copied; // 返回成功拷贝的字节数 } // 设备写函数 static ssize_t simple_char_write(struct file *filep, const char __user *buffer, size_t len, loff_t *offset) { int bytes_not_copied; int bytes_to_write = len; // 检查写入是否会超出缓冲区 if (buffer_offset + bytes_to_write > BUFFER_SIZE) { bytes_to_write = BUFFER_SIZE - buffer_offset; if (bytes_to_write <= 0) { printk(KERN_WARNING "simple_char: Device buffer is full.\n"); return -ENOSPC; // 返回设备无空间错误 } } // 将用户空间数据拷贝到内核缓冲区 bytes_not_copied = copy_from_user(device_buffer + buffer_offset, buffer, bytes_to_write); if (bytes_not_copied) { printk(KERN_ERR "simple_char: Failed to copy %d bytes from user.\n", bytes_not_copied); return -EFAULT; } printk(KERN_INFO "simple_char: Received %d bytes from user.\n", bytes_to_write - bytes_not_copied); buffer_offset += bytes_to_write - bytes_not_copied; return bytes_to_write - bytes_not_copied; // 返回成功写入的字节数 } // 文件操作结构体，定义驱动支持的操作 static struct file_operations fops = { .owner = THIS_MODULE, .open = simple_char_open, .read = simple_char_read, .write = simple_char_write, .release = simple_char_release, }; // 模块初始化函数（加载时调用） static int __init simple_char_init(void) { int retval; dev_t dev_num; printk(KERN_INFO "simple_char: Initializing the driver.\n"); // 1. 动态申请一个主设备号（和次设备号0） retval = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME); if (retval < 0) { printk(KERN_ALERT "simple_char: Failed to allocate chrdev region. Error %d\n", retval); return retval; } major_number = MAJOR(dev_num); printk(KERN_INFO "simple_char: Registered with major number %d\n", major_number); // 2. 初始化字符设备结构体，并关联文件操作 cdev_init(&simple_char_cdev, &fops); simple_char_cdev.owner = THIS_MODULE; // 3. 将字符设备添加到系统 retval = cdev_add(&simple_char_cdev, dev_num, 1); if (retval < 0) { printk(KERN_ALERT "simple_char: Failed to add cdev. Error %d\n", retval); unregister_chrdev_region(dev_num, 1); return retval; } // 4. 在 /sys/class/ 下创建设备类（用于 udev/mdev 自动创建设备节点） simple_char_class = class_create(THIS_MODULE, CLASS_NAME); if (IS_ERR(simple_char_class)) { printk(KERN_ALERT "simple_char: Failed to create device class.\n"); cdev_del(&simple_char_cdev); unregister_chrdev_region(dev_num, 1); return PTR_ERR(simple_char_class); } // 5. 在 /dev/ 下自动创建设备节点 device_create(simple_char_class, NULL, dev_num, NULL, DEVICE_NAME); // 6. 为内部缓冲区分配内存 device_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL); if (!device_buffer) { printk(KERN_ALERT "simple_char: Failed to allocate buffer memory.\n"); device_destroy(simple_char_class, dev_num); class_destroy(simple_char_class); cdev_del(&simple_char_cdev); unregister_chrdev_region(dev_num, 1); return -ENOMEM; } memset(device_buffer, 0, BUFFER_SIZE); buffer_offset = 0; printk(KERN_INFO "simple_char: Driver initialized successfully.\n"); return 0; } // 模块清理函数（卸载时调用） static void __exit simple_char_exit(void) { dev_t dev_num = MKDEV(major_number, 0); printk(KERN_INFO "simple_char: Removing the driver.\n"); // 销毁 /dev/ 下的设备节点 device_destroy(simple_char_class, dev_num); // 销毁设备类 class_destroy(simple_char_class); // 从系统中删除字符设备 cdev_del(&simple_char_cdev); // 释放设备号 unregister_chrdev_region(dev_num, 1); // 释放内核缓冲区 if (device_buffer) { kfree(device_buffer); } printk(KERN_INFO "simple_char: Driver removed.\n"); } // 指定模块的入口和出口函数 module_init(simple_char_init); module_exit(simple_char_exit);

3.2 驱动编译文件：Makefile

内核模块的编译需要特殊的 Makefile。在同一个目录下创建Makefile文件（注意 M 大写）：

# Makefile for simple_char driver obj-m += simple_char.o # 内核源码目录，通常指向已安装的头文件 KERNEL_DIR ?= /lib/modules/$(shell uname -r)/build # 当前模块源码目录 PWD := $(shell pwd) all: $(MAKE) -C $(KERNEL_DIR) M=$(PWD) modules clean: $(MAKE) -C $(KERNEL_DIR) M=$(PWD) clean # 安装模块（需要root权限） install: sudo insmod simple_char.ko # 卸载模块（需要root权限） uninstall: sudo rmmod simple_char # 查看内核日志 log: dmesg | tail -20

这个 Makefile 的关键是obj-m += simple_char.o，它告诉内核构建系统我们要构建一个名为simple_char.ko的模块。-C $(KERNEL_DIR) M=$(PWD)表示切换到内核源码目录，并使用当前目录的规则进行构建。

4. 编译、加载与测试驱动

现在，我们已经有了驱动源码和构建脚本，可以开始编译和测试了。

4.1 编译驱动模块

在项目目录下，直接执行make命令：

make

如果一切顺利，你将看到类似以下的输出，并生成simple_char.ko文件：

make -C /lib/modules/5.15.0-91-generic/build M=/home/yourname/projects/simple_char_driver modules make[1]: Entering directory '/usr/src/linux-headers-5.15.0-91-generic' CC [M] /home/yourname/projects/simple_char_driver/simple_char.o MODPOST /home/yourname/projects/simple_char_driver/Module.symvers CC [M] /home/yourname/projects/simple_char_driver/simple_char.mod.o LD [M] /home/yourname/projects/simple_char_driver/simple_char.ko make[1]: Leaving directory '/usr/src/linux-headers-5.15.0-91-generic'

simple_char.ko就是我们编译好的内核模块。

4.2 加载驱动模块

加载模块需要 root 权限，使用insmod命令：

sudo insmod simple_char.ko

加载后，可以通过dmesg命令查看内核日志，确认我们的初始化函数被调用：

dmesg | tail -5

你应该能看到类似这样的输出：

[ 1234.567890] simple_char: Initializing the driver. [ 1234.567891] simple_char: Registered with major number 243 [ 1234.567892] simple_char: Driver initialized successfully.

注意记录下分配的主设备号（例如 243），稍后有用。

4.3 检查设备节点

我们的驱动在初始化时，通过device_create在/dev/目录下自动创建了设备节点。使用ls命令查看：

ls -l /dev/simple_char

输出应类似于：

crw------- 1 root root 243, 0 Mar 10 15:30 /dev/simple_char

c表示字符设备，243, 0分别是主设备号和次设备号。主设备号与dmesg中打印的一致。

4.4 编写用户空间测试程序

创建一个简单的 C 程序test_driver.c来测试驱动的读写功能：

// test_driver.c #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <unistd.h> #include <string.h> int main() { int fd; char write_buf[] = "Hello from userspace!"; char read_buf[1024] = {0}; ssize_t ret; // 1. 打开设备文件 fd = open("/dev/simple_char", O_RDWR); if (fd < 0) { perror("Failed to open the device"); return -1; } printf("Device opened successfully.\n"); // 2. 向设备写入数据 ret = write(fd, write_buf, strlen(write_buf)); if (ret < 0) { perror("Failed to write to the device"); close(fd); return -1; } printf("Wrote %zd bytes to device: %s\n", ret, write_buf); // 3. 从设备读取数据（注意：我们的驱动读操作会移动内部偏移量） // 为了读到刚写入的数据，可以先关闭再打开，或者驱动实现lseek。这里我们简单读取。 // 由于我们写入后偏移量在末尾，直接读会返回0。我们先重新打开。 close(fd); fd = open("/dev/simple_char", O_RDWR); if (fd < 0) { perror("Failed to reopen the device"); return -1; } ret = read(fd, read_buf, sizeof(read_buf) - 1); if (ret < 0) { perror("Failed to read from the device"); close(fd); return -1; } read_buf[ret] = '\0'; // 确保字符串结束 printf("Read %zd bytes from device: %s\n", ret, read_buf); // 4. 关闭设备 close(fd); printf("Test completed.\n"); return 0; }

编译这个测试程序：

gcc -o test_driver test_driver.c

4.5 运行测试并观察结果

首先，确保设备文件权限允许当前用户读写（或者用sudo运行测试程序）。我们先用sudo测试：

sudo ./test_driver

预期输出：

Device opened successfully. Wrote 21 bytes to device: Hello from userspace! Read 21 bytes from device: Hello from userspace! Test completed.

同时，观察内核日志，可以看到驱动打印的信息：

sudo dmesg | tail -10

输出应包含：

[ 1234.567893] simple_char: Device has been opened. [ 1234.567894] simple_char: Received 21 bytes from user. [ 1234.567895] simple_char: Device has been closed. [ 1234.567896] simple_char: Device has been opened. [ 1234.567897] simple_char: Sent 21 bytes to user. [ 1234.567898] simple_char: Device has been closed.

这证明了用户空间的write和read系统调用成功触发了驱动中对应的simple_char_write和simple_char_read函数，并且数据通过copy_from_user和copy_to_user在内核与用户空间之间正确传递。

4.6 卸载驱动模块

测试完成后，卸载模块：

sudo rmmod simple_char

再次查看dmesg，会看到清理函数被调用：

[ 1234.567899] simple_char: Removing the driver. [ 1234.567900] simple_char: Driver removed.

同时，/dev/simple_char设备节点会自动消失。

5. 驱动代码关键机制详解

现在，让我们回过头来深入理解驱动代码中的几个关键部分。

5.1 模块的入口与出口：module_init与module_exit

• module_init(simple_char_init)：告诉内核，当模块被insmod加载时，应该调用simple_char_init函数。这个函数负责所有初始化工作：分配设备号、注册设备、创建设备节点、分配内存等。
• module_exit(simple_char_exit)：告诉内核，当模块被rmmod卸载时，应该调用simple_char_exit函数。这个函数必须仔细清理初始化函数分配的所有资源（设备号、设备节点、内存等），否则会导致资源泄漏。

注意：内核模块没有main函数，它的生命周期由insmod和rmmod控制。

5.2 设备号管理：alloc_chrdev_region与unregister_chrdev_region

设备号是内核识别设备的唯一标识，由主设备号（Major）和次设备号（Minor）组成。

• alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME)：动态向内核申请一个未被使用的主设备号（从0开始分配一个次设备号）。dev_num会包含分配到的完整设备号。使用MAJOR(dev_num)可以提取主设备号。
• unregister_chrdev_region(dev_num, 1)：在模块卸载时，释放申请的设备号。

5.3 字符设备核心：cdev_init与cdev_add

struct cdev是内核中代表一个字符设备的核心结构。

• cdev_init(&simple_char_cdev, &fops)：初始化cdev结构，并将其与我们的文件操作函数集fops关联起来。
• cdev_add(&simple_char_cdev, dev_num, 1)：将初始化好的cdev添加到内核系统中，使其生效。第三个参数1表示此设备号关联的设备数量（我们只有一个设备）。

5.4 文件操作接口：struct file_operations

这是驱动与用户空间交互的桥梁。用户程序对设备文件的所有操作（open,read,write,close等），最终都会映射到这个结构体中对应的函数指针。

static struct file_operations fops = { .owner = THIS_MODULE, .open = simple_char_open, .read = simple_char_read, .write = simple_char_write, .release = simple_char_release, };

• .owner：通常设为THIS_MODULE，防止模块在使用中被意外卸载。
• .open/.release：对应open()和close()系统调用。
• .read/.write：对应read()和write()系统调用。它们的参数__user *buffer表示指针指向用户空间内存，不能直接解引用，必须使用copy_from_user/copy_to_user。

5.5 自动创建设备节点：class_create与device_create

现代 Linux 系统使用 udev（或嵌入式系统的 mdev）机制自动管理/dev下的设备节点。

1. class_create(THIS_MODULE, CLASS_NAME)：在/sys/class/下创建一个名为simple_char_class的类。这会在/sys/class/simple_char_class生成一个目录。
2. device_create(simple_char_class, NULL, dev_num, NULL, DEVICE_NAME)：在上述类下创建设备。这会触发 udev 规则，自动在/dev/下创建名为simple_char的设备节点。这比手动使用mknod命令更规范、更自动化。

5.6 内核内存分配：kmalloc与kfree

驱动运行在内核空间，不能使用用户空间的malloc/free。

• device_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL)：在内核空间分配一块大小为BUFFER_SIZE的内存。GFP_KERNEL是常用的分配标志，表示在普通内核上下文中进行可能引起睡眠的分配。
• kfree(device_buffer)：释放由kmalloc分配的内存。必须配对使用，否则会造成内核内存泄漏。

5.7 内核打印：printk

printk是内核的“printf”，用于输出日志到内核环形缓冲区。可以通过dmesg命令查看。KERN_INFO,KERN_ERR等是日志级别，影响其在控制台和日志文件中的显示。

6. 常见问题与排查路径

编写和运行内核模块时，会遇到各种错误。以下是几个典型问题及其排查方法。

6.1 编译错误：Makefile或头文件问题

6.2 加载/卸载错误：模块验证失败

6.3 运行时错误：权限或功能异常

6.4 功能逻辑错误

7. 生产环境驱动开发的最佳实践

学习示例驱动后，要编写用于真实项目的驱动，还需要遵循更多工程实践。

7.1 错误处理与资源清理

内核编程必须极其谨慎地处理错误和释放资源。我们的示例中，初始化函数simple_char_init采用了“goto”风格或“级联检查”风格进行错误回滚。这是内核代码的常见模式：任何一步失败，都必须回滚之前所有成功的步骤。

retval = step1(); if (retval) goto err_step1; retval = step2(); if (retval) goto err_step2; // ... 初始化成功 return 0; err_step2: undo_step2(); err_step1: undo_step1(); return retval;

7.2 并发控制

我们的示例驱动没有考虑并发访问。如果两个进程同时读写/dev/simple_char，会导致缓冲区数据混乱。真实驱动必须使用内核提供的同步机制：

• 互斥锁 (mutex)：用于保护临界区，防止多个执行路径同时访问共享数据。
• 自旋锁 (spinlock)：用于在中断上下文或不能睡眠的上下文中保护非常短小的临界区。
• 信号量 (semaphore)：用于控制对有限资源的访问。

需要在驱动数据结构中加入锁，并在open,read,write等函数中恰当加锁/解锁。

7.3 实现ioctl接口

read/write用于数据流传输。对于设备控制命令（如设置波特率、读取状态寄存器），需要使用ioctl系统调用。驱动需要实现.unlocked_ioctl或.compat_ioctl操作，并定义自己的命令号（通常使用_IOR,_IOW,_IOWR宏生成）。

7.4 支持阻塞与非阻塞 I/O

文件描述符可以设置为非阻塞模式 (O_NONBLOCK)。驱动需要检查filep->f_flags & O_NONBLOCK，如果设备暂无数据可读或空间可写，在非阻塞模式下应返回-EAGAIN，在阻塞模式下则应让进程睡眠（使用wait_queue），直到条件满足。

7.5 考虑电源管理与热插拔

对于可热插拔设备（如 USB、PCIe），驱动需要实现相应的探测 (probe) 和移除 (remove) 函数，并注册到对应的总线驱动模型。还需要考虑系统休眠/唤醒时的电源管理回调。

7.6 完善的日志与调试支持

• 动态调试：使用pr_debug,dev_dbg等宏，配合内核的dynamic debug功能，可以在需要时动态开启调试信息，避免生产环境日志泛滥。
• Sysfs 接口：通过 Sysfs 暴露一些设备状态、统计信息或调试开关到用户空间 (/sys/class/...)。
• Debugfs：对于复杂的调试需求，可以使用 debugfs 创建更丰富的调试文件接口。

7.7 代码风格与文档

Linux 内核有严格的代码风格要求（如缩进使用一个 Tab，长度不超过 80 列等）。使用scripts/checkpatch.pl检查代码。为驱动添加适当的MODULE_DESCRIPTION和内核文档注释 (kernel-doc)。

8. 下一步学习与扩展方向

掌握了这个简单的字符设备驱动框架后，你可以沿着以下几个方向深入学习：

1. 控制真实硬件：学习 CPU 的 Memory-Mapped I/O (MMIO) 或 Port I/O，通过ioremap等函数将硬件寄存器地址映射到内核虚拟地址，然后在驱动中读写这些地址来控制 GPIO、UART、I2C 等外设。
2. 深入内核子系统：学习 Platform Driver、I2C Driver、SPI Driver、USB Driver 等特定总线或子系统的驱动模型。它们提供了更结构化的框架来集成设备。
3. 中断处理：硬件通常通过中断来通知 CPU 事件发生。学习如何在驱动中注册中断处理函数 (request_irq)，并编写上半部（Top Half）和下半部（Bottom Half，如 tasklet, workqueue）处理程序。
4. 内核同步机制：深入学习自旋锁、互斥锁、信号量、完成量、RCU 等机制的适用场景和正确用法。
5. 内存管理：了解kmalloc,vmalloc,get_free_pages的区别，学习 DMA 内存映射 (dma_alloc_coherent)。
6. 阅读经典驱动源码：Linux 内核源码树中drivers/char/、drivers/misc/下有许多简单的驱动示例，drivers/usb/、drivers/net/下有复杂的驱动，是极佳的学习材料。
7. 使用调试工具：学习使用printk级别控制、strace、perf、systemtap、kgdb等工具进行驱动调试和性能分析。

驱动开发是连接硬件与软件的桥梁，需要同时对硬件特性和操作系统原理有深入理解。从这个小例子出发，保持耐心，逐步实践和探索，你就能逐渐掌握这门核心的系统编程技能。记住，内核编程无小事，每一次修改都可能影响系统稳定性，因此严谨的测试和代码审查至关重要。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度