嵌入式Linux驱动开发是连接硬件与操作系统的桥梁,是嵌入式系统开发的核心环节。驱动程序作为内核的一部分运行于内核空间,负责管理特定硬件设备,为上层应用提供统一、标准化的访问接口。不同于用户空间程序,驱动程序需严格遵循内核API规范,具备高实时性、高稳定性与低资源消耗特性。
本教程面向具备C语言基础、熟悉Linux基本操作的开发者,以嵌入式Linux驱动开发教程为主线,系统讲解从内核模块编写、字符设备驱动构建,到现代设备树机制、中断处理、内存管理、电源管理等关键模块的完整知识体系。课程设计突出实战性,所有示例均基于主流ARM Cortex-A系列处理器(如NXP i.MX6ULL、TI AM3358、Rockchip RK3566)及Linux内核5.15 LTS版本,确保技术前瞻性与工程实用性统一。
驱动开发不同于应用程序开发的核心差异在于:它运行在内核上下文中,任何错误(如空指针解引用、内存泄漏、竞态条件)都可能导致系统崩溃(Kernel Panic)。因此,驱动开发者必须深入理解内核数据结构(如struct file_operations、struct device、struct platform_device)、同步原语(自旋锁、互斥量、RCU)及内存屏障机制。本教程通过大量真实案例,帮助开发者建立严谨的内核编程思维。
典型驱动类型包括:字符设备(如串口、GPIO控制)、块设备(如SD卡控制器)、网络设备(如以太网驱动)、USB设备类驱动(如UVC摄像头、CDC ACM串口)等。每类驱动均有其特定的数据流模型与生命周期管理方式。例如,字符设备驱动需实现open、read、write、ioctl等接口;而USB驱动则需通过USB子系统注册usb_driver结构体,并处理设备枚举、配置选择、端点传输等过程。
内核模块(Kernel Module)是一种可动态加载/卸载的代码单元,无需重新编译内核即可扩展功能。模块程序以C语言编写,需包含头文件<linux/init.h>、<linux/module.h>,并实现module_init()与module_exit()宏指定的初始化与清理函数。
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE("GPL");
MODULE_AUTHOR("XServX");
MODULE_DESCRIPTION("A minimal kernel module");
static int __init hello_init(void)
{
printk(KERN_INFO "Hello driver loaded\n");
return 0;
}
static void __exit hello_exit(void)
{
printk(KERN_INFO "Hello driver unloaded\n");
}
module_init(hello_init);
module_exit(hello_exit);
模块加载后可通过dmesg查看printk输出。需注意:内核日志级别需与/proc/sys/kernel/printk配置匹配(默认为4,仅显示≥4级日志)。模块信息可通过lsmod、modinfo hello.ko查看。
内核模块编译依赖内核源码树。典型Makefile如下:
obj-m += hello.o
KERNELDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
all:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
$(MAKE) -C $(KERNELDIR) M=$(PWD) clean
说明:
obj-m指定生成的模块目标文件(.ko)-C切换至内核构建目录M=$(PWD)告知内核在当前目录构建外部模块若使用交叉编译(如ARM平台),需设置CROSS_COMPILE与ARCH变量:
CROSS_COMPILE := arm-linux-gnueabihf-
ARCH := arm
KERNELDIR := /path/to/kernel/source
# 编译命令:make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
模块可通过module_param宏接收运行时参数:
static int debug_level = 1;
module_param(debug_level, int, 0644);
MODULE_PARM_DESC(debug_level, "Debug level (1=info, 2=verbose)");
static char *user_name = "guest";
module_param(user_name, charp, 0644);
加载时指定参数:insmod hello.ko debug_level=2 user_name=driver_dev
模块可导出符号供其他模块使用(需谨慎):
EXPORT_SYMBOL(my_function);
EXPORT_SYMBOL_GPL(my_variable); // 仅GPL模块可用
字符设备通过struct cdev结构体描述,需注册到内核设备模型。关键步骤包括:
struct cdev实例cdev_init(&cdev, &fops)file_operations操作集alloc_chrdev_region或register_chrdev_region)cdev_add)static dev_t dev_num;
static struct cdev my_cdev;
static struct class *my_class;
static struct device *my_device;
static ssize_t my_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
// 实现读逻辑
}
static const struct file_operations my_fops = {
.owner = THIS_MODULE,
.read = my_read,
};
static int __init chardev_init(void)
{
// 1. 分配设备号
if (alloc_chrdev_region(&dev_num, 0, 1, "mychar") < 0) {
return -1;
}
// 2. 初始化cdev
cdev_init(&my_cdev, &my_fops);
my_cdev.owner = THIS_MODULE;
// 3. 添加设备
if (cdev_add(&my_cdev, dev_num, 1) < 0) {
unregister_chrdev_region(dev_num, 1);
return -1;
}
// 4. 创建设备类与设备节点
my_class = class_create(THIS_MODULE, "myclass");
my_device = device_create(my_class, NULL, dev_num, NULL, "mydev");
return 0;
}
安全传递数据需使用copy_to_user与copy_from_user,禁止直接访问用户空间指针:
static ssize_t my_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
char kbuf[64];
size_t len = min(count, sizeof(kbuf)-1);
if (copy_from_user(kbuf, buf, len))
return -EFAULT;
kbuf[len] = '\0';
printk(KERN_INFO "Received: %s\n", kbuf);
return len;
}
错误码说明:
-EFAULT:用户空间地址无效-EINVAL:参数非法-ENOMEM:内存不足字符设备驱动可支持阻塞/非阻塞读写。通过wait_queue_head_t实现等待队列:
static DECLARE_WAIT_QUEUE_HEAD(read_wait);
static ssize_t my_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
if (data_available == 0) {
if (file->f_flags & O_NONBLOCK)
return -EAGAIN;
if (wait_event_interruptible(read_wait, data_available))
return -ERESTARTSYS;
}
// 复制数据到用户空间
}
数据就绪时调用wake_up(&read_wait)唤醒等待进程。
Platform总线是Linux内核为脱离硬件总线(如PCI、USB)的设备提供的虚拟总线,广泛用于集成外设控制器(如GPIO、UART、SPI控制器)的驱动管理。
平台设备通过struct platform_device描述,驱动通过struct platform_driver注册。内核通过name字段匹配设备与驱动。
// 设备树节点:
// &uart1 {
// status = "okay";
// };
// 驱动匹配表:
static const struct of_device_id my_of_match[] = {
{ .compatible = "myvendor,my-uart" },
{ }
};
MODULE_DEVICE_TABLE(of, my_of_match);
static struct platform_driver my_uart_driver = {
.driver = {
.name = "my-uart",
.of_match_table = my_of_match,
},
.probe = my_uart_probe,
.remove = my_uart_remove,
};
module_platform_driver(my_uart_driver);
probe函数在设备与驱动匹配时调用,负责申请资源(内存、中断、GPIO等)并初始化硬件:
static int my_uart_probe(struct platform_device *pdev)
{
struct resource *res;
void __iomem *base;
int irq;
// 获取内存资源(寄存器基地址)
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
base = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(base))
return PTR_ERR(base);
// 获取中断号
irq = platform_get_irq(pdev, 0);
if (irq < 0)
return irq;
// 请求中断
return devm_request_irq(&pdev->dev, irq, my_uart_irq, 0, "my-uart", NULL);
}
说明:
devm_ioremap_resource:自动管理映射内存,设备移除时自动释放platform_get_resource:从设备树或平台数据获取资源devm_request_irq:设备管理型中断注册,避免手动释放Linux内核提供统一的串口框架(serial_core),驱动需实现uart_ops结构体并注册到串口子系统。典型步骤包括:
struct uart_port(硬件寄存器信息)uart_ops中的start_tx、stop_tx、set_termios等函数uart_add_one_port注册端口该方式使UART设备可被/dev/ttyS*访问,并兼容stty、minicom等工具。
设备树(Device Tree)是描述硬件信息的树状数据结构,由.dts源文件编译为.dtb二进制Blob,由Bootloader传递给内核。典型结构如下:
/dts-v1/;
/include/ "soc.dtsi"
/ {
model = "MyBoard";
compatible = "myvendor,myboard", "arm,cortex-a9";
cpus {
#address-cells = <1>;
#size-cells = <0>;
cpu@0 {
compatible = "arm,cortex-a9";
device_type = "cpu";
reg = <0>;
};
};
memory@80000000 {
device_type = "memory";
reg = <0x80000000 0x20000000>;
};
uart1: serial@12c20000 {
compatible = "arm,pl011", "arm,primecell";
reg = <0x12c20000 0x1000>;
interrupts = <37>;
clock-names = "uartclk", "apb_pclk";
clocks = <&clkuart1 &&clkapb>;
status = "disabled";
};
};
compatible:设备兼容性列表,驱动通过该字段匹配设备reg:寄存器地址与长度(格式:<address length>)interrupts:中断号及触发方式(如<37 IRQ_TYPE_LEVEL_HIGH>)clocks:时钟提供者节点引用status:设备状态("okay"启用,"disabled"禁用)驱动通过of_match_table与设备树compatible匹配:
static const struct of_device_id pl011_of_match[] = {
{ .compatible = "arm,pl011", },
{ .compatible = "arm,primecell", },
{ }
};
MODULE_DEVICE_TABLE(of, pl011_of_match);
static struct platform_driver pl011_driver = {
.driver = {
.name = "uart-pl011",
.of_match_table = pl011_of_match,
},
.probe = pl011_probe,
};
内核启动时,设备树解析后创建platform_device,触发驱动probe函数。
中断处理分上下两半(Top Half & Bottom Half):
内核提供三种Bottom Half机制:
softirq)tasklet)workqueue)static irqreturn_t my_irq_handler(int irq, void *dev_id)
{
// Top Half:读取状态寄存器,清除中断标志
u32 status = readl(base + INT_STATUS);
if (!(status & MY_IRQ_FLAG))
return IRQ_NONE;
// 清除中断
writel(status, base + INT_STATUS);
// 启动Bottom Half
tasklet_schedule(&my_tasklet);
return IRQ_HANDLED;
}
static void my_tasklet_func(unsigned long data)
{
// Bottom Half:处理数据、唤醒等待进程
complete_data_transfer();
wake_up(&read_wait);
}
多个设备共享同一中断线时,需在注册时传递唯一dev_id,并在处理函数中通过dev_id识别设备:
request_irq(irq, my_irq_handler, IRQF_SHARED, "my-device", &my_dev_struct);
中断上下文中禁止:
mutex_lock、msleep)推荐使用spinlock_t保护共享数据,并配合local_irq_disable禁用本地中断。
内核内存分配函数:
kmalloc(size, flags):分配连续物理内存(小块,<128KB)vmalloc(size):分配连续虚拟内存(可非连续物理页)alloc_pages(gfp_mask, order):分配2^order页(大块内存)flags参数决定内存属性:
| 标志 | 说明 |
|---|---|
GFP_KERNEL | 常规分配,可休眠 |
GFP_ATOMIC | 中断上下文使用,不可休眠 |
GFP_DMA | 分配DMA可用内存 |
GFP_HIGHMEM | 分配高端内存 |
设备寄存器需通过ioremap映射为内核虚拟地址:
void __iomem *base = ioremap(res->start, resource_size(res));
if (!base)
return -ENOMEM;
// 使用后释放
iounmap(base);
为外设提供可访问的内存缓冲区,需使用一致性DMA映射:
dma_addr_t dma_handle;
void *buf = dma_alloc_coherent(&pdev->dev, SIZE, &dma_handle, GFP_KERNEL);
// 使用后释放
dma_free_coherent(&pdev->dev, SIZE, buf, dma_handle);
说明:
dma_handle为设备可见的物理地址buf为CPU可见的虚拟地址内核电源管理框架(CONFIG_PM)支持设备状态转换:
PM_EVENT_ON:设备运行PM_EVENT_SUSPEND:挂起设备PM_EVENT_RESUME:恢复设备static int my_suspend(struct device *dev)
{
struct my_data *data = dev_get_drvdata(dev);
// 保存状态
data->saved_reg = readl(base + REG);
// 关闭时钟/电源
clk_disable_unprepare(data->clk);
return 0;
}
static int my_resume(struct device *dev)
{
struct my_data *data = dev_get_drvdata(dev);
// 恢复时钟/电源
clk_prepare_enable(data->clk);
// 恢复寄存器
writel(data->saved_reg, base + REG);
return 0;
}
static const struct dev_pm_ops my_pm_ops = {
.suspend = my_suspend,
.resume = my_resume,
};
// 驱动中关联:
.driver = { .pm = &my_pm_ops, }
Runtime PM允许设备在空闲时自动进入低功耗状态:
// 初始化时启用
pm_runtime_enable(&pdev->dev);
// 设备使用前
pm_runtime_get_sync(&pdev->dev);
// 使用后
pm_runtime_put(&pdev->dev);
内核在设备计数为0时自动调用runtime_suspend。
通过printk日志级别控制输出:
| 级别 | 宏 | 说明 |
|---|---|---|
| 0 | KERN_EMERG | 系统不可用 |
| 1 | KERN_ALERT | 必须立即处理 |
| 2 | KERN_CRIT | 严重错误 |
| 3 | KERN_ERR | 错误状态 |
| 4 | KERN_WARNING | 警告 |
| 5 | KERN_NOTICE | 正常但需注意 |
| 6 | KERN_INFO | 信息性消息 |
| 7 | KERN_DEBUG | 调试信息 |
默认日志级别可通过/proc/sys/kernel/printk调整:
echo 8 > /proc/sys/kernel/printk # 显示所有级别日志
启用CONFIG_DYNAMIC_DEBUG后,可通过/proc/dynamic_debug/control动态控制日志:
# 启用所有驱动的调试日志
echo 'file drivers/my/*.c +p' > /proc/dynamic_debug/control
# 启用特定函数日志
echo 'file drivers/my/driver.c func my_init +p' > /proc/dynamic_debug/control
gdb + gdbserver:远程内核调试(需CONFIG_GDB_SCRIPTS)kgdb:内核级调试器ftrace:函数调用跟踪perf:性能分析sysrq:通过键盘触发内核操作(如Alt+SysRq+f释放内存)WARN_ON、BUILD_BUG_ON检查错误条件dev_info日志便于追踪printk(可能导致死锁)下面构建一个完整驱动,实现通过用户空间写入字符控制GPIO LED亮灭。
假设使用NXP i.MX6ULL开发板,LED连接至GPIO1_IO03(对应物理引脚:B14)。
&{/soc@0 {
gpio-leds {
compatible = "gpio-leds";
led1 {
gpios = <&gpio1 3 GPIO_ACTIVE_HIGH>;
linux,default-trigger = "none";
default-state = "off";
};
};
};
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/gpio/consumer.h>
#include <linux/uaccess.h>
#define DEV_NAME "gpioled"
#define MAJOR_NUM 240
static dev_t dev_num;
static struct cdev my_cdev;
static struct class *my_class;
static struct device *my_device;
static struct gpio_desc *led_gpiod;
static ssize_t gpioled_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
char kbuf[2];
int ret;
if (count > sizeof(kbuf)-1)
count = sizeof(kbuf)-1;
if (copy_from_user(kbuf, buf, count))
return -EFAULT;
kbuf[count] = '\0';
if (kbuf[0] == '1')
gpiod_set_value(led_gpiod, 1);
else if (kbuf[0] == '0')
gpiod_set_value(led_gpiod, 0);
else
return -EINVAL;
return count;
}
static const struct file_operations gpioled_fops = {
.owner = THIS_MODULE,
.write = gpioled_write,
};
static int __init gpioled_init(void)
{
int ret;
// 获取GPIO
led_gpiod = gpiod_get(NULL, "led1", GPIOD_OUT_LOW);
if (IS_ERR(led_gpiod)) {
pr_err("Failed to get GPIO\n");
return PTR_ERR(led_gpiod);
}
// 注册设备号
ret = alloc_chrdev_region(&dev_num, 0, 1, DEV_NAME);
if (ret < 0) {
pr_err("Failed to alloc chrdev region\n");
goto err_gpio;
}
// 初始化cdev
cdev_init(&my_cdev, &gpioled_fops);
my_cdev.owner = THIS_MODULE;
// 添加设备
ret = cdev_add(&my_cdev, dev_num, 1);
if (ret < 0) {
pr_err("Failed to add cdev\n");
goto err_region;
}
// 创建设备节点
my_class = class_create(THIS_MODULE, DEV_NAME);
if (IS_ERR(my_class)) {
pr_err("Failed to create class\n");
ret = PTR_ERR(my_class);
goto err_cdev;
}
my_device = device_create(my_class, NULL, dev_num, NULL, DEV_NAME);
if (IS_ERR(my_device)) {
pr_err("Failed to create device\n");
ret = PTR_ERR(my_device);
goto err_class;
}
return 0;
err_class:
class_destroy(my_class);
err_cdev:
cdev_del(&my_cdev);
err_region:
unregister_chrdev_region(dev_num, 1);
err_gpio:
gpiod_put(led_gpiod);
return ret;
}
static void __exit gpioled_exit(void)
{
device_destroy(my_class, dev_num);
class_destroy(my_class);
cdev_del(&my_cdev);
unregister_chrdev_region(dev_num, 1);
gpiod_put(led_gpiod);
}
module_init(gpioled_init);
module_exit(gpioled_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("XServX");
MODULE_DESCRIPTION("GPIO LED driver for embedded Linux");
# 加载驱动后
echo '1' > /dev/gpioled # LED亮
echo '0' > /dev/gpioled # LED灭
# 查看设备信息
ls -l /dev/gpioled