Linux驱动开发简介和入门教程_驱动开发教程-CSDN博客

本文链接：https://blog.csdn.net/weixin_47763623/article/details/144317549

Linux驱动开发简介和入门教程

目标: 从驱动开发的基本过程入手，理解Linux中断机制，并通过一个定时器中断实例加深理解。

1. 驱动程序开发概述

驱动程序是什么？
驱动程序是操作系统与硬件设备之间的桥梁，它为操作系统提供访问硬件的接口。你可以把驱动程序想象成操作系统和硬件设备之间的“中介”，通过它，操作系统可以理解硬件设备的语言并对其进行控制。而硬件设备则通过驱动程序与操作系统进行有效的“沟通”。可以说，没有驱动程序，操作系统就像一个不会说外语的人，无法与硬件设备顺利对话。

Linux中的驱动程序主要分为以下几类：

字符设备驱动：像键盘、鼠标这样的设备，它们按字符流的方式与系统交互。就像你在打字，每次输入一个字符，字符设备就将这个字符传输给操作系统。简单、直接，适用于数据量较小且不需要复杂管理的设备。好的，我们使用图书馆的比喻来解释块设备驱动：
块设备驱动：如硬盘、SSD等存储设备，这类设备按“块”进行数据读写。你可以把块设备想象成一个理想的图书馆，每本书的大小都是相同的（就像块设备的扇区大小）。每当你读取或写入数据时，就相当于你从书架上取下一本书，或者将一本书放回原位。由于每本书的大小固定，图书馆管理员（操作系统）可以迅速定位到特定的书籍，不需要浪费时间去查找，也可以高效地添加或删除书籍。这种方式让大规模管理和访问变得非常高效，因为每次的操作都是固定大小的“书”或“块”。
网络设备驱动：如网卡、无线网卡等网络设备，专门用来处理网络数据包。网络设备驱动就像是快递公司，负责收发各种大小的数据包，确保它们能从一个地方顺利到达另一个地方。它需要确保高效、快速、可靠地传输数据，尤其是在高负载时。

驱动程序与内核模块
驱动程序通常以内核模块的形式加载到内核中，动态扩展内核功能。换句话说，内核模块就像你家里的即插即用设备，不是永远都需要插着的，但只要需要，就可以插入并立即发挥作用。编写驱动程序的第一步就是学会如何编写内核模块，这就像学会用工具拆装家里的电器，首先要理解模块的工作原理和内核的动态加载机制。

通过编写内核模块，Linux可以在运行时动态地加载或卸载驱动程序，让操作系统变得灵活而强大。模块化的设计让内核更加轻便，只有在需要的时候才会加载相关驱动程序，避免占用过多的资源。

2. 驱动程序的基本开发过程

编写一个驱动程序通常需要以下步骤：

定义初始化和清理函数
- 使用 module_init() 注册初始化函数，在模块加载时调用。
- 使用 module_exit() 注册清理函数，在模块卸载时调用。
编写驱动功能
在初始化函数中完成设备注册、资源分配等；在清理函数中释放资源。
编译与加载
- 使用 Makefile 编译模块。
- 使用 insmod 加载模块，rmmod 卸载模块。
- 使用 dmesg 查看模块日志。

代码示例：最小内核模块

#include <linux/init.h>
#include <linux/module.h>

static int __init my_module_init(void) {
    pr_info("Hello, Kernel!\n");
    return 0; // 返回0表示成功
}

static void __exit my_module_exit(void) {
    pr_info("Goodbye, Kernel!\n");
}

module_init(my_module_init);
module_exit(my_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("YourName");
MODULE_DESCRIPTION("A simple Linux module");

Makefile 示例

obj-m := my_module.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. Linux中的中断机制

3.1 硬件中断与软件中断

硬件中断：由设备发出的信号引起，例如键盘按下或网络包到达。
软件中断：由内核或用户程序触发，用于完成延迟任务等。

3.2 上下半部处理模型

ISR（中断服务程序）：快速响应中断，完成必要操作后退出。ISR运行在中断上下文中，必须尽量短小高效，不可阻塞。
Tasklet 和 Workqueue：延迟处理较慢的任务，避免长时间占用中断上下文。两者用于把一些较长时间的处理任务推迟到稍后的进程上下文中执行。

3.3 Tasklet 与 Workqueue

选择 tasklet 还是 workqueue 主要取决于任务的性质、执行上下文的要求以及任务的复杂度。它们各自有不同的使用场景，了解它们的差异有助于你做出合适的选择。

3.3.1 选择 Tasklet 的场景

短小且快速的任务：
- Tasklet 适用于那些执行时间较短且不会阻塞的任务。由于它运行在 中断上下文 中，因此必须确保任务不会导致系统挂起或引起阻塞。如果任务需要快速完成并且在中断处理后立即执行，tasklet 是合适的选择。
避免阻塞操作：
- Tasklet 运行在 软中断上下文 中，因此不允许在其中执行可能会阻塞的操作（例如 sleep、wait、I/O 操作等）。如果任务需要涉及这些操作，则不适合使用 tasklet。
需要高效的中断处理：
- Tasklet 通常用于响应中断的场景，特别是处理需要迅速、尽量短暂的任务。因为它可以延迟处理任务，并且在软中断上下文中执行，避免了阻塞操作的执行。
多个 tasklet 需要调度：
- 如果你需要在不同的上下文中执行多个任务，并且这些任务具有不同的优先级，tasklet 提供了较为简单的优先级管理机制，可以为每个 tasklet 设置优先级，从而控制任务的执行顺序。

3.3.2 选择 Workqueue 的场景

较复杂、可能需要阻塞的任务：
- Workqueue 适合那些较为复杂且可能需要阻塞操作的任务。它在 进程上下文 中执行，允许任务阻塞或者调用那些会休眠的内核函数（例如 msleep()、wait_event()、I/O 操作等）。如果任务需要阻塞操作或更长的处理时间，workqueue 是理想选择。
需要高延迟的任务：
- 如果任务不需要立即执行，或者可以在稍后的时刻处理，workqueue 提供了延迟执行的机制，可以将任务排队并在合适的时机在进程上下文中执行。适用于那些对实时性要求不高，但执行过程较长的任务。
适用于多个不同类型的任务：
- Workqueue 可以调度多种类型的任务，特别是那些涉及 I/O 操作、文件系统、网络等复杂工作。如果需要执行的任务比较复杂，且不适合在中断上下文中执行（比如需要等待某些资源），workqueue 提供了更多灵活性。
任务顺序不敏感或可并行化：
- Workqueue 不支持像 tasklet 那样的优先级机制。如果多个任务可以并行执行并且任务顺序不重要，workqueue 更适合，因为它会在进程上下文中顺序执行排队的任务。

3.3.3 Tasklet 与 Workqueue 的比较

特性	Tasklet	Workqueue
执行上下文	中断上下文（软中断上下文）	进程上下文
执行时间	适用于快速执行的短任务	适用于较长时间或复杂的任务
是否支持阻塞	不支持阻塞操作	支持阻塞操作
任务调度机制	通过软中断调度，执行优先级较高的任务	由内核线程调度，任务按顺序执行
优先级控制	支持优先级控制，适合管理多个短任务	不支持优先级控制，适合执行顺序不敏感的任务
适用场景	适合中断驱动的、低延迟、快速执行的任务	适合需要更多时间、I/O 操作或可阻塞的复杂任务

4. 中断相关的API介绍

4.1 注册和释放中断

注册中断处理程序：
使用 request_irq()，为指定中断号注册 ISR。

int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, 
                const char *name, void *dev);

释放中断：
使用 free_irq() 释放中断号，避免资源泄漏。
```
void free_irq(unsigned int irq, void *dev);
```

4.2 中断开关控制

禁用本地中断：
```
local_irq_disable();
```
启用本地中断：
```
local_irq_enable();
```

4.3 中断上下文检查接口

检查是否在中断上下文：
```
int in_interrupt(void);
```
返回非零值表示当前处于中断上下文，包括硬中断和软中断。
检查是否在硬中断上下文：
```
int in_irq(void);
```
返回非零值表示当前处于硬中断上下文。
检查是否在软中断上下文：
```
int in_softirq(void);
```
返回非零值表示当前处于软中断上下文。

5. 定时器中断的驱动实例

5.1 示例：定时器驱动

这个示例展示了如何使用定时器和任务处理机制（tasklet）在 Linux 内核模块中进行定时器中断处理。我们将设置一个定时器，它每隔一秒触发一次，并在中断服务例程（ISR）中调度一个任务（tasklet）进行下半部分的处理。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/timer.h>
#include <linux/interrupt.h>

static struct timer_list my_timer;
static char my_data[] = "Tasklet example data";

/* Tasklet 的定义和初始化 */
static void my_tasklet_handler(struct tasklet_struct *tasklet);
static DECLARE_TASKLET(my_tasklet, my_tasklet_handler);

/* 下半部分处理函数 */
static void my_tasklet_handler(struct tasklet_struct *tasklet) {
    pr_info("Tasklet executing: %s at jiffies: %ld\n", my_data, jiffies);

    // 判断是否在中断上下文中
    if (in_interrupt()) {
        pr_info("Tasklet executing in interrupt context, 硬件中断=%ld, 软中断=%ld\n", in_hardirq(), in_softirq());
    }
    else {
        pr_info("Tasklet executing in process context\n");
    }
}

/* 上半部分中断处理函数 */
static void timer_callback(struct timer_list *t) {
    pr_info("Timer ISR: Triggering tasklet at jiffies: %ld\n", jiffies);

    // 判断是在中断上下文中，具体是硬件中断还是软中断
    if (in_interrupt()) {
        pr_info("Timer ISR executing in interrupt context, 硬件中断=%ld, 软中断=%ld\n", in_hardirq(), in_softirq());
    }

    /* 调度下半部分任务 */
    tasklet_schedule(&my_tasklet);

    /* 重启定时器 */
    mod_timer(&my_timer, jiffies + msecs_to_jiffies(1000));
}

static int __init my_timer_init(void) {
    pr_info("Initializing timer and tasklet...\n");

    /* 初始化定时器并设置回调 */
    timer_setup(&my_timer, timer_callback, 0);

    /* 设置定时器1秒后触发 */
    mod_timer(&my_timer, jiffies + msecs_to_jiffies(1000));
    return 0;
}

static void __exit my_timer_exit(void) {
    /* 删除定时器 */
    del_timer(&my_timer);

    /* 清除 Tasklet */
    tasklet_kill(&my_tasklet);

    pr_info("Timer and Tasklet removed\n");
}

module_init(my_timer_init);
module_exit(my_timer_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("YourName");
MODULE_DESCRIPTION("A timer module with ISR and Tasklet");

5.2 代码解析

模块初始化：
- 在 my_timer_init 中，我们使用 timer_setup 初始化定时器，并设置回调函数 timer_callback。然后使用 mod_timer 设置定时器每隔1秒触发一次。
- 每次定时器触发时，会执行 timer_callback 回调函数。回调函数中，我们会检查当前是否在中断上下文中，并将任务（tasklet）调度到后续处理。
任务调度：
- 在 timer_callback 函数中，调用 tasklet_schedule 函数将任务调度到软中断上下文。tasklet_schedule 会将 my_tasklet_handler 函数排队等待执行。
任务执行：
- 当任务被执行时，my_tasklet_handler 会被调用。它会判断是否在中断上下文中，并输出相应的信息。
- 如果任务在中断上下文中执行（比如软中断），它会打印硬中断和软中断的状态；如果在进程上下文中执行，则会显示“Tasklet executing in process context”。
模块退出：
- 在 my_timer_exit 中，删除定时器并清除任务（tasklet）以确保资源释放。

5.3 关键点

定时器和任务调度：在本例中，我们使用定时器触发中断，并在回调函数中调度下半部分任务（tasklet）。定时器通常用于需要定期执行的任务，而 tasklet 用于执行需要稍后完成的工作，避免在中断上下文中做过多的工作。
中断上下文与进程上下文：通过 in_interrupt 和 in_hardirq 等函数，可以检查任务是否在中断上下文中执行。当然, 我们知道Tasklet 是运行在软中断上下文的。