嵌入式Linux驱动开发教程

⚡ 嵌入式Linux驱动开发概述

嵌入式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结构体,并处理设备枚举、配置选择、端点传输等过程。

⚙️ Linux内核模块与编译机制

〔1〕内核模块基础

内核模块(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查看。

〔2〕Makefile构建系统

内核模块编译依赖内核源码树。典型Makefile如下:

示例:模块编译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

说明:

若使用交叉编译(如ARM平台),需设置CROSS_COMPILE与ARCH变量:

交叉编译示例

CROSS_COMPILE := arm-linux-gnueabihf-
ARCH := arm
KERNELDIR := /path/to/kernel/source
# 编译命令:make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-

〔3〕模块参数与导出符号

模块可通过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模块可用

⚡ 字符设备驱动开发核心

〔1〕字符设备数据结构

字符设备通过struct cdev结构体描述,需注册到内核设备模型。关键步骤包括:

  1. 分配struct cdev实例
  2. 初始化cdev_init(&cdev, &fops)
  3. 设置file_operations操作集
  4. 分配设备号(alloc_chrdev_region或register_chrdev_region)
  5. 添加设备到内核(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;
}

〔2〕用户空间与内核空间数据传递

安全传递数据需使用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;
}

错误码说明:

〔3〕阻塞与非阻塞I/O

字符设备驱动可支持阻塞/非阻塞读写。通过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设备驱动模型

Platform总线是Linux内核为脱离硬件总线(如PCI、USB)的设备提供的虚拟总线,广泛用于集成外设控制器(如GPIO、UART、SPI控制器)的驱动管理。

〔1〕Platform设备与驱动分离

平台设备通过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);

〔2〕Probe函数与资源管理

probe函数在设备与驱动匹配时调用,负责申请资源(内存、中断、GPIO等)并初始化硬件:

示例:UART驱动probe实现

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

说明:

〔3〕与串口子系统集成

Linux内核提供统一的串口框架(serial_core),驱动需实现uart_ops结构体并注册到串口子系统。典型步骤包括:

  1. 定义struct uart_port(硬件寄存器信息)
  2. 实现uart_ops中的start_tx、stop_tx、set_termios等函数
  3. 调用uart_add_one_port注册端口

该方式使UART设备可被/dev/ttyS*访问,并兼容stty、minicom等工具。

⚡ 设备树(Device Tree)详解

〔1〕设备树基础结构

设备树(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";
    };
};

〔2〕关键属性说明

〔3〕设备树与驱动关联

驱动通过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函数。

⚙️ 中断处理机制

〔1〕中断注册与处理函数

中断处理分上下两半(Top Half & Bottom Half):

内核提供三种Bottom Half机制:

  1. 软中断(softirq)
  2. 任务队列(tasklet)
  3. 工作队列(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);
}

〔2〕共享中断处理

多个设备共享同一中断线时,需在注册时传递唯一dev_id,并在处理函数中通过dev_id识别设备:

示例:共享中断注册

request_irq(irq, my_irq_handler, IRQF_SHARED, "my-device", &my_dev_struct);

〔3〕中断上下文限制

中断上下文中禁止:

推荐使用spinlock_t保护共享数据,并配合local_irq_disable禁用本地中断。

⚡ 内存管理与DMA

〔1〕内核内存分配

内核内存分配函数:

flags参数决定内存属性:

常用GFP标志

标志说明
GFP_KERNEL常规分配,可休眠
GFP_ATOMIC中断上下文使用,不可休眠
GFP_DMA分配DMA可用内存
GFP_HIGHMEM分配高端内存

〔2〕设备内存映射

设备寄存器需通过ioremap映射为内核虚拟地址:

示例:寄存器映射

void __iomem *base = ioremap(res->start, resource_size(res));
if (!base)
    return -ENOMEM;
// 使用后释放
iounmap(base);

〔3〕DMA内存管理

为外设提供可访问的内存缓冲区,需使用一致性DMA映射:

示例: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);

说明:

⚙️ 电源管理机制

〔1〕设备电源状态转换

内核电源管理框架(CONFIG_PM)支持设备状态转换:

示例:电源管理操作集

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

〔2〕自动电源管理(Runtime PM)

Runtime PM允许设备在空闲时自动进入低功耗状态:

示例:Runtime PM使用

// 初始化时启用
pm_runtime_enable(&pdev->dev);
// 设备使用前
pm_runtime_get_sync(&pdev->dev);
// 使用后
pm_runtime_put(&pdev->dev);

内核在设备计数为0时自动调用runtime_suspend。

⚡ 驱动调试技巧

〔1〕内核日志级别控制

通过printk日志级别控制输出:

日志级别定义

级别宏说明
0KERN_EMERG系统不可用
1KERN_ALERT必须立即处理
2KERN_CRIT严重错误
3KERN_ERR错误状态
4KERN_WARNING警告
5KERN_NOTICE正常但需注意
6KERN_INFO信息性消息
7KERN_DEBUG调试信息

默认日志级别可通过/proc/sys/kernel/printk调整:

示例:调整日志级别

echo 8 > /proc/sys/kernel/printk  # 显示所有级别日志

〔2〕动态调试(Dynamic Debug)

启用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

〔3〕调试工具链

⚠️ 调试建议

  • 优先使用WARN_ON、BUILD_BUG_ON检查错误条件
  • 关键路径添加dev_info日志便于追踪
  • 避免在中断上下文使用printk(可能导致死锁)

⚡ 综合项目实战:GPIO LED驱动

下面构建一个完整驱动,实现通过用户空间写入字符控制GPIO LED亮灭。

〔1〕硬件连接

假设使用NXP i.MX6ULL开发板,LED连接至GPIO1_IO03(对应物理引脚:B14)。

〔2〕设备树配置

设备树节点

&{/soc@0 {
    gpio-leds {
        compatible = "gpio-leds";
        led1 {
            gpios = <&gpio1 3 GPIO_ACTIVE_HIGH>;
            linux,default-trigger = "none";
            default-state = "off";
        };
    };
};

〔3〕驱动实现

完整驱动代码

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

〔4〕测试方法

用户空间测试

# 加载驱动后
echo '1' > /dev/gpioled   # LED亮
echo '0' > /dev/gpioled   # LED灭
# 查看设备信息
ls -l /dev/gpioled