宋宝华的Linux驱动开发实战教程

本文还有配套的精品资源，点击获取

简介：本书由资深Linux技术专家宋宝华编写，为Linux内核驱动开发人员提供了一本全面的教程。从基础概念到高级技术，涵盖了Linux驱动开发的各个方面，包括Linux内核架构、驱动程序工作原理、各类驱动编写技巧，以及DDR内存控制器的驱动开发。书中结合实践案例和代码示例，帮助读者通过理论学习和实际操作，掌握Linux内核模块化机制及内核调试工具的使用，从而提升在硬件设备与操作系统间的驱动程序设计与实现能力。

1. Linux内核基础架构

Linux操作系统作为现代开源软件的典范，其强大和灵活的背后，是精心设计的内核架构。本章节将揭开Linux内核的神秘面纱，为您展示其基础架构的精妙之处。

1.1 Linux内核核心组件

Linux内核由多个核心组件构成，这些组件协同工作，共同确保操作系统的高效和稳定运行。核心组件主要包括进程调度、内存管理、文件系统、网络通信以及安全机制等。

1.2 内核模块化设计

模块化设计是Linux内核的一大特色，它允许系统动态加载和卸载内核模块，而无需重新编译整个内核。这种设计极大地提高了系统的可维护性和扩展性。

1.3 内核与用户空间的通信

Linux内核通过系统调用与用户空间进行通信，这是用户程序访问内核功能的接口。系统调用抽象了硬件操作的复杂性，为开发者提供了一组简化的、一致的接口。

在后续章节中，我们将深入探索驱动程序的工作原理、设备驱动编写基础、以及内核模块化机制等重要主题，进一步揭示Linux内核的深层次奥秘。

2. 驱动程序工作原理及分类

2.1 Linux内核的驱动程序概述

2.1.1 Linux内核驱动程序的概念和作用

Linux内核驱动程序是操作系统内核的一部分，它为硬件设备提供了一个与内核交互的接口。驱动程序的主要职责是管理硬件资源，并为上层应用提供一套标准的、抽象的接口。驱动程序使得硬件设备能够被Linux内核以及运行在内核上的用户空间程序所识别和使用。

驱动程序的核心作用包括以下几个方面： - 硬件控制：驱动程序负责对硬件设备进行直接控制，包括发送命令、配置寄存器等。 - 硬件抽象：为上层应用提供统一的接口，隐藏硬件的细节，简化应用程序的开发。 - 资源管理：负责管理硬件资源，如I/O端口、内存映射、中断等。 - 错误处理：处理硬件错误情况，保障系统的稳定运行。

2.1.2 Linux驱动程序的分类和特点

Linux驱动程序按照其管理的硬件类型和特性大致可以分为三类：字符设备驱动、块设备驱动和网络设备驱动。

• 字符设备驱动：字符设备的特点是数据的输入输出是顺序的，一次一个字符。这类设备不支持随机访问，也没有缓冲区的概念。典型的字符设备驱动包括键盘、鼠标、串口等。

• 块设备驱动：块设备以数据块为单位进行操作，支持随机访问，数据通常存储在有结构的存储介质上。块设备通常具有缓冲区和缓存机制以提高效率。常见的块设备包括硬盘驱动器、固态硬盘、光盘驱动器等。

• 网络设备驱动：网络设备负责处理数据包的发送和接收。它们操作的是网络协议栈中的数据，并且能够处理网络层和传输层的协议。以太网卡、无线网卡等均属于网络设备驱动管理的范畴。

每种类型的驱动程序都有其特定的接口和操作方式，但它们共同遵循Linux内核的驱动模型和编程接口。

2.2 驱动程序与内核的关系

2.2.1 驱动程序在内核中的位置和功能

在Linux内核中，驱动程序是内核的一部分，它们位于内核的模块化层，可以动态地被加载和卸载，这种机制提供了系统的灵活性和可扩展性。驱动程序的核心功能包括： - 硬件发现和初始化：在加载时，驱动程序需要找到它所管理的硬件设备，并执行必要的初始化操作。 - 资源分配和释放：负责分配和管理硬件设备所需的各种资源，如I/O端口、中断号、DMA通道等。 - 请求处理：响应来自用户空间或内核其他部分的请求，完成相应的硬件操作。

2.2.2 驱动程序与硬件交互的机制

驱动程序与硬件设备交互主要依赖于硬件抽象层（HAL），这一层隐藏了硬件的差异性，提供了统一的访问接口。为了实现这些功能，驱动程序与内核之间交互的主要机制包括：

• 内核API：驱动程序通过调用内核提供的API来执行硬件相关的操作，比如内存分配、中断处理等。
• 中断：硬件设备通过中断来通知CPU有事件发生，驱动程序需要注册中断处理函数来响应这些事件。
• 设备文件：在Linux系统中，每一个设备都对应一个设备文件，驱动程序通过操作这些设备文件来控制硬件。

接下来，我们将深入探讨Linux内核中不同类型设备驱动的编写基础，为深入理解内核驱动的开发打下坚实的基础。

3. 各类设备驱动编写基础

在深入探讨Linux设备驱动编写之前，我们需要对驱动程序在操作系统中扮演的角色有一个清晰的认识。设备驱动程序是连接硬件与操作系统内核的桥梁，负责处理硬件设备与软件应用之间的数据传输。本章节将重点介绍字符设备、块设备和网络设备驱动程序编写的基础知识，它们是操作系统中最为常见的三种设备驱动类型。

3.1 字符设备驱动编写基础

字符设备是指数据传输按照字符为单位进行的I/O设备。它们不以固定大小的块进行数据传输，允许随机访问数据流中的任意位置。常见的字符设备包括键盘、鼠标和串口等。在Linux内核中，字符设备驱动程序的编写遵循特定的结构和流程。

3.1.1 字符设备驱动的结构和主要函数

字符设备驱动程序的结构大体上包括设备的打开、关闭、读写、控制以及查询等操作。驱动开发者需要实现一系列函数来满足这些操作的需要。下面的代码块展示了这些函数的基本框架：

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

static int my_open(struct inode *inode, struct file *file) {
    /* 设备打开逻辑 */
}

static int my_release(struct inode *inode, struct file *file) {
    /* 设备关闭逻辑 */
}

static ssize_t my_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) {
    /* 数据读取逻辑 */
}

static ssize_t my_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) {
    /* 数据写入逻辑 */
}

static const struct file_operations my_fops = {
    .owner = THIS_MODULE,
    .open = my_open,
    .release = my_release,
    .read = my_read,
    .write = my_write,
};

int __init my_char_driver_init(void) {
    /* 注册字符设备驱动的初始化逻辑 */
}

void __exit my_char_driver_exit(void) {
    /* 注销字符设备驱动的清理逻辑 */
}

module_init(my_char_driver_init);
module_exit(my_char_driver_exit);

3.1.2 字符设备的注册和注销流程

字符设备的注册和注销是驱动初始化和清理的关键步骤。内核提供了一套接口函数来进行这些操作。注册字符设备涉及到分配一个设备号并注册文件操作函数集合（file_operations）。

int major_number = register_chrdev(0, DEVICE_NAME, &my_fops);

注销字符设备则需要反向操作：

unregister_chrdev(major_number, DEVICE_NAME);

接下来，本章将讨论块设备驱动程序的基础知识。

3.2 块设备驱动编写基础

块设备以固定大小的块来传输数据，例如硬盘和固态硬盘等。它们通常支持随机访问，读写操作可能涉及多个块。与字符设备不同，块设备驱动程序需要处理请求队列和磁盘调度算法。

3.2.1 块设备驱动的框架和关键函数

块设备驱动的核心在于请求队列的管理，开发者需要实现一个请求处理函数来响应块设备的读写请求。

static void my_request(struct request_queue *q) {
    /* 处理块设备请求 */
}

static int my_block_device_init(void) {
    /* 初始化块设备驱动 */
    struct request_queue *my_queue = blk_init_queue(my_request, &my_lock);
    return register_blkdev(major_number, DEVICE_NAME);
}

static void my_block_device_exit(void) {
    /* 清理块设备驱动 */
    blk_cleanup_queue(my_queue);
    unregister_blkdev(major_number, DEVICE_NAME);
}

module_init(my_block_device_init);
module_exit(my_block_device_exit);

3.2.2 块设备的请求处理流程

块设备驱动程序在处理请求时，可能需要将请求排序，以优化性能和减少寻道时间。内核提供了多种调度策略，如电梯调度（CFQ）、完全公平调度（CFQ）和 Deadline 调度等。

void电梯调度(request_queue_t *q) {
    /* 电梯调度逻辑 */
}

块设备的详细请求处理流程涉及请求队列的创建和管理，这通常需要内核编程者有较深入的理解。

在本章的下一部分，我们将进入网络设备驱动编写的基础知识。

3.3 网络设备驱动编写基础

网络设备驱动负责与网卡硬件交互，发送和接收网络数据包。它必须遵循特定的协议和接口标准，如Linux内核中的网络设备接口（net_device）。

3.3.1 网络设备驱动结构和关键函数

网络设备驱动程序需要实现一系列的回调函数来处理数据包的发送和接收。

static int my_open(struct net_device *dev) {
    /* 打开网络设备 */
}

static int my_stop(struct net_device *dev) {
    /* 关闭网络设备 */
}

static netdev_tx_t my_start_xmit(struct sk_buff *skb, struct net_device *dev) {
    /* 发送数据包 */
}

static const struct net_device_ops my_netdev_ops = {
    .ndo_open = my_open,
    .ndo_stop = my_stop,
    .ndo_start_xmit = my_start_xmit,
};

static void my_setup(struct net_device *dev) {
    /* 设置网络设备接口 */
    dev->netdev_ops = &my_netdev_ops;
}

int __init my_net_device_init(void) {
    /* 注册网络设备驱动 */
    register_netdev(dev);
}

void __exit my_net_device_exit(void) {
    /* 注销网络设备驱动 */
    unregister_netdev(dev);
}

module_init(my_net_device_init);
module_exit(my_net_device_exit);

3.3.2 数据包的接收和发送过程

网络数据包的接收过程通常开始于网卡硬件接收到数据包，触发中断后，驱动程序会从网卡读取数据包，并将其提交到内核的协议栈中。发送过程则是相反，内核协议栈会调用驱动提供的发送函数，并将数据包交给网卡发送出去。

在Linux内核中，网络设备驱动程序的开发比较复杂，因为需要处理各种网络协议和高层的网络功能。这需要开发者对网络协议栈有深入的理解。

本章为Linux设备驱动程序编写提供了基础性的框架和关键点。后续章节将深入讨论具体的开发实践，实战经验和高级优化技巧。

4. I/O接口驱动与DDR内存控制器开发

4.1 I/O接口驱动开发

4.1.1 I/O接口驱动的基本结构

I/O接口驱动是连接操作系统与硬件设备的桥梁，它负责管理硬件设备与系统之间的数据交换。一个典型的I/O接口驱动通常包括初始化、打开、关闭、读、写、控制以及清理等基本操作。初始化函数负责检测硬件设备的存在、申请系统资源、设置数据结构等，而清理函数则是在卸载驱动时执行相反的操作。

在Linux内核中，驱动开发者常常需要实现一系列的标准函数接口，例如：

static int __init my_io_driver_init(void);
static void __exit my_io_driver_exit(void);
static int my_io_driver_open(struct inode *inode, struct file *file);
static int my_io_driver_release(struct inode *inode, struct file *file);
static ssize_t my_io_driver_read(struct file *file, char __user *buf, size_t count, loff_t *ppos);
static ssize_t my_io_driver_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos);
static long my_io_driver_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

这些函数实现了文件操作的接口，使得文件系统能与I/O设备进行交互。

4.1.2 I/O接口的读写操作实现

读写操作是驱动程序中的核心部分之一。在Linux内核中，读写操作通常通过file_operations结构体中的read和write方法来实现。以下是一个简单的例子：

static ssize_t my_io_driver_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    // 读取硬件设备数据到buf指向的用户空间
    // 更新ppos位置指针
    // 返回实际读取的字节数
}

static ssize_t my_io_driver_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    // 从buf指向的用户空间读取数据到内核
    // 写入数据到硬件设备
    // 更新ppos位置指针
    // 返回实际写入的字节数
}

开发者需要在读写函数中，添加与硬件通信的代码，并确保数据交换的安全性和效率。例如，在读操作中，首先需要检查用户提供的缓冲区是否有效，然后锁定数据区域以防止并发访问的问题，最后进行数据的实际传输。

4.2 DDR内存控制器驱动开发

4.2.1 DDR内存控制器的基本原理

DDR内存控制器负责在CPU和DDR内存之间高效地传输数据。DDR控制器通常实现为一组寄存器，这些寄存器通过编程来配置内存操作的时序和模式。DDR控制器支持不同的内存大小、速度和特性。

在开发DDR内存控制器驱动时，需要了解DDR内存的技术规范，比如时序参数、命令和地址映射等。驱动开发者要根据DDR的规格书来设计软件控制逻辑，确保内存的正确初始化和稳定运行。

4.2.2 DDR内存控制器驱动开发要点

在开发DDR内存控制器驱动时，有几个要点是开发者必须考虑的：

1. 初始化序列：DDR内存初始化是一个复杂的过程，需要严格按照内存芯片的要求来设置时序参数。通常，这一过程由一系列初始化命令和设置寄存器的值构成。

2. 时序设置：需要精确控制内存的读写时序，包括CAS延迟、行预充电时间等。错误的时序设置会导致数据损坏或性能下降。

3. 电源管理：现代DDR内存支持动态电源管理，驱动需要能够根据系统负载动态调整内存的工作频率和电压，以降低功耗。

4. 错误检测与处理：驱动程序需要实现错误检测和纠正（ECC）逻辑，以及提供系统内存状态的监控和诊断功能。

在编写DDR内存控制器驱动时，需要密切配合硬件工程师，确保驱动能够与硬件特性相匹配，并充分利用硬件提供的能力。下面是一个简化的伪代码，展示初始化序列的基本步骤：

static int ddr_controller_init(struct device *dev)
{
    // 检查硬件存在性
    if (!check_hardware(dev)) {
        return -ENODEV;
    }

    // 设置DDR时序参数
    configure_timings(dev);

    // 执行DDR复位操作
    reset_ddr_controller(dev);

    // 加载内存校准值
    load_calibration_values(dev);

    // 设置电源管理策略
    set_power_management_policy(dev);

    // 执行内存自检，确认初始化成功
    if (run_memory_self_test(dev) != 0) {
        return -EIO;
    }

    // DDR初始化成功，返回0
    return 0;
}

在上述伪代码中，每个函数都应该详细实现，包括与硬件寄存器交互的具体指令。由于DDR内存控制器对硬件依赖性极强，每一步都必须严格按硬件规格来操作，确保内存模块可以正常工作。

通过这样的驱动开发，系统可以充分利用内存的性能，提供稳定和快速的数据传输能力给其他软件组件使用。

5. Linux内核模块化机制与调试工具

5.1 Linux内核模块化机制

5.1.1 内核模块的概念和作用

内核模块是Linux操作系统中一种扩展内核功能的方式，它允许系统管理员在运行时动态地添加或删除内核代码。这种机制极大地提高了系统的灵活性，使得内核可以根据需要加载或卸载特定的硬件驱动程序或其他功能模块。

内核模块的核心思想是"插件式"设计，与传统的静态链接不同，模块可以独立于主内核映像编译，并且可以在不影响系统其他部分的前提下，单独更新或替换。这种做法减少了系统的启动时间，提高了系统的稳定性，因为不需要重新编译整个内核。

内核模块通常包含以下几部分： - 初始化函数：模块加载时执行，用于设置模块所需资源。 - 清理函数：模块卸载时执行，用于释放模块所占用的资源。 - 模块参数：允许模块加载时配置一些参数。 - 导出符号：使得其他模块可以引用本模块内定义的函数和变量。

5.1.2 内核模块的加载和卸载机制

Linux内核模块的加载和卸载机制是通过一系列的函数调用来实现的，其中核心是 insmod 、 modprobe 和 rmmod 。

• insmod ：直接加载一个模块，不考虑模块间的依赖关系。
• modprobe ：在加载模块时，会自动处理模块间的依赖关系，并加载所需的相关模块。
• rmmod ：用于卸载模块。

当模块被加载时，内核首先会执行模块的初始化函数，完成对模块的初始化工作。当模块不再需要时，通过卸载命令，内核会执行模块的清理函数，释放相关资源，并从系统中移除该模块。

内核模块的加载和卸载通常通过 /dev 文件系统中的设备节点进行，这是通过 init_module 和 delete_module 这两个系统调用实现的。在内核代码中，模块管理器会检查模块是否依赖于其他未加载的模块，以及是否有未卸载的模块依赖于该模块。

5.2 内核调试工具使用

5.2.1 常用的内核调试工具介绍

内核调试是内核开发中不可或缺的一部分，它帮助开发者发现和修复问题，提高代码质量。Linux提供了多种工具用于内核调试，常用的有：

• dmesg ：显示内核的消息缓冲区内容，常用于查看系统启动信息、模块加载卸载信息、硬件异常信息等。
• klogd ：内核日志守护进程，它可以将内核消息传递到用户空间的日志系统中。
• kmemcheck ：内存检查工具，它可以检查内核中的内存访问错误。
• ftrace ：动态追踪工具，它可以追踪内核中的函数调用，帮助开发者了解系统的行为。
• kgdb ：内核级的调试工具，与GDB结合使用，支持断点、单步执行等操作。

5.2.2 如何利用调试工具进行问题定位

在使用调试工具定位问题时，通常遵循以下步骤：

1. 确定问题类型和范围 ：了解问题出现的环境和条件，是否有特定的操作或事件触发。
2. 使用 dmesg 查看系统信息 ：通过查看内核消息缓冲区，检查是否有相关的错误或警告信息。
3. 配置内核打印级别 ：通过调整内核的打印级别，可以控制 dmesg 输出的信息量，以便于捕捉到关键信息。
4. 利用 ftrace 追踪函数调用 ：通过 ftrace 的追踪功能，可以观察到特定函数或函数组的调用情况。
5. 使用 kgdb 进行断点调试 ：当需要更深入地了解问题原因时，可以使用 kgdb 设置断点，单步执行代码，观察变量的变化情况。

具体到某一个调试工具的使用，可以以 ftrace 为例进行详细介绍：

# 启用ftrace的函数追踪功能
echo function > /sys/kernel/debug/tracing/current_tracer

# 追踪特定函数
echo 'func_name' > /sys/kernel/debug/tracing/set_ftrace_filter

# 查看追踪结果
cat /sys/kernel/debug/tracing/trace

使用 ftrace 时，可以利用正则表达式匹配多个函数，追踪过程中还可以通过修改 /sys/kernel/debug/tracing/trace 文件内容来控制追踪的开始和停止。

上述步骤和示例可以帮助开发者快速定位问题所在，并通过代码调试来找出问题的根本原因。

6. Linux驱动程序开发实战经验

6.1 驱动开发中常见问题解析

Linux驱动开发涉及到底层硬件操作，因此不可避免地会遇到一些常见问题。本节将讨论驱动程序中常见的同步和并发问题，以及内存管理问题。

6.1.1 驱动程序中的同步和并发问题

同步和并发是多任务操作系统中不可避免的问题。在Linux驱动程序开发中，这些问题尤为关键，因为驱动程序需要处理来自不同线程和中断请求的并发访问。

一个典型的同步问题是竞态条件（Race Condition），当两个或多个进程几乎同时访问和修改共享数据时可能会发生。在驱动程序中，可以使用互斥锁（mutexes）、自旋锁（spinlocks）和信号量（semaphores）来同步数据访问，防止竞态条件的发生。

举一个使用互斥锁的例子：

DEFINE_MUTEX(my_mutex);

void my_function(struct my_struct *data) {
    mutex_lock(&my_mutex);
    // 修改或访问共享数据
    ...
    mutex_unlock(&my_mutex);
}

6.1.2 驱动程序的内存管理问题

内存管理错误会导致系统崩溃（kernel panic）或内存泄露，因此需要谨慎处理。在编写驱动程序时，尤其要注意动态分配和释放内存时的错误处理。

Linux内核提供了kmalloc()和kfree()函数用于动态内存分配和释放。需要注意的是，内核内存是有限的资源，因此必须保证分配的内存最终都会被释放。

void *ptr;
ptr = kmalloc(sizeof(struct my_struct), GFP_KERNEL);
if (!ptr)
    return -ENOMEM; // 分配失败，返回错误码

// 使用ptr进行操作...

kfree(ptr); // 操作完成后释放内存

6.2 驱动程序优化和维护

6.2.1 驱动程序的性能优化策略

性能优化是驱动程序开发中的一个重要方面，尤其是在资源有限的嵌入式系统中。性能优化策略包括减少中断处理函数中的工作量，使用DMA（直接内存访问）进行数据传输，以及避免在中断上下文中进行耗时的操作。

另外，使用锁和锁无关的同步机制（如原子操作和顺序锁）可以减少开销，提高效率。

6.2.2 驱动程序的维护和升级方法

驱动程序的维护和升级往往需要特别注意向后兼容性。在发布新版本时，应该提供清晰的更新指南，并确保新旧版本之间的无缝过渡。在维护过程中，版本控制（如git）是必不可少的工具，它可以帮助跟踪代码变更、协同开发以及回滚到旧版本。

6.3 驱动开发案例分析

6.3.1 一个字符设备驱动开发案例

字符设备驱动是Linux内核中常见的驱动类型之一，它提供对设备进行字节级访问的能力。在这个案例中，我们将通过一个简单的字符设备驱动示例来展示驱动程序的结构和主要函数。

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

#define DEVICE_NAME "mymajordev"
#define CLASS_NAME "mychardevclass"

static int majorNumber;
static struct class* chardevClass = NULL;
static struct cdev mychar_cdev;

static int dev_open(struct inode *inodep, struct file *filep) {
    printk(KERN_INFO "MyChar: Device has been opened\n");
    return 0;
}

static ssize_t dev_read(struct file *filep, char *buffer, size_t len, loff_t *offset) {
    printk(KERN_INFO "MyChar: Device has been read from\n");
    return 0; // 此处应根据实际情况进行读操作
}

static ssize_t dev_write(struct file *filep, const char *buffer, size_t len, loff_t *offset) {
    printk(KERN_INFO "MyChar: Device has been written to\n");
    return len; // 此处应根据实际情况进行写操作
}

static int dev_release(struct inode *inodep, struct file *filep) {
    printk(KERN_INFO "MyChar: Device successfully closed\n");
    return 0;
}

static struct file_operations fops = {
    .open = dev_open,
    .read = dev_read,
    .write = dev_write,
    .release = dev_release,
};

static int __init chardev_init(void) {
    printk(KERN_INFO "MyChar: Initializing the MyChar device\n");
    majorNumber = register_chrdev(0, DEVICE_NAME, &fops);
    if (majorNumber < 0) {
        printk(KERN_ALERT "MyChar failed to register a major number\n");
        return majorNumber;
    }
    printk(KERN_INFO "MyChar: registered correctly with major number %d\n", majorNumber);

    chardevClass = class_create(THIS_MODULE, CLASS_NAME);
    if (IS_ERR(chardevClass)) {
        unregister_chrdev(majorNumber, DEVICE_NAME);
        printk(KERN_ALERT "Failed to register device class\n");
        return PTR_ERR(chardevClass);
    }

    if (device_create(chardevClass, NULL, MKDEV(majorNumber, 0), NULL, DEVICE_NAME) == NULL) {
        class_destroy(chardevClass);
        unregister_chrdev(majorNumber, DEVICE_NAME);
        printk(KERN_ALERT "Failed to create the device\n");
        return -1;
    }

    cdev_init(&mychar_cdev, &fops);
    if (cdev_add(&mychar_cdev, MKDEV(majorNumber, 0), 1) == -1) {
        device_destroy(chardevClass, MKDEV(majorNumber, 0));
        class_destroy(chardevClass);
        unregister_chrdev(majorNumber, DEVICE_NAME);
        printk(KERN_ALERT "Failed to add cdev\n");
        return -1;
    }

    return 0;
}

static void __exit chardev_exit(void) {
    cdev_del(&mychar_cdev);
    device_destroy(chardevClass, MKDEV(majorNumber, 0));
    class_unregister(chardevClass);
    class_destroy(chardevClass);
    unregister_chrdev(majorNumber, DEVICE_NAME);
    printk(KERN_INFO "MyChar: Goodbye from the LKM!\n");
}

module_init(chardev_init);
module_exit(chardev_exit);

这个例子中，我们创建了一个简单的字符设备驱动，它注册了一个主设备号，定义了文件操作函数，并在退出时进行了清理工作。

6.3.2 一个网络设备驱动开发案例

网络设备驱动比字符设备驱动更为复杂，因为它需要处理复杂的网络协议栈和数据包的接收与发送。在此案例中，我们将简要介绍网络设备驱动的基本结构。

#include <linux/netdevice.h>

static struct net_device *my_net_dev;

static int my_net_open(struct net_device *dev) {
    printk(KERN_INFO "MyNet: Device is now open\n");
    // 执行打开网络设备的操作...
    return 0;
}

static int my_net_close(struct net_device *dev) {
    printk(KERN_INFO "MyNet: Device has been closed\n");
    // 执行关闭网络设备的操作...
    return 0;
}

static netdev_tx_t my_net_start_xmit(struct sk_buff *skb, struct net_device *dev) {
    printk(KERN_INFO "MyNet: Data packet is being sent\n");
    // 执行数据包发送的操作...
    dev_kfree_skb(skb);
    return NETDEV_TX_OK;
}

static const struct net_device_ops my_net_device_ops = {
    .ndo_open = my_net_open,
    .ndo_stop = my_net_close,
    .ndo_start_xmit = my_net_start_xmit,
    // 其他回调函数...
};

static int __init my_net_init(void) {
    // 分配和设置net_device结构...
    my_net_dev = alloc_netdev(sizeof(struct my_priv), "my%d", NET_NAME_UNKNOWN, ether_setup);
    if (!my_net_dev) {
        printk(KERN_ERR "MyNet: Error alloc_netdev\n");
        return -ENOMEM;
    }

    my_net_dev->netdev_ops = &my_net_device_ops;
    register_netdev(my_net_dev);
    printk(KERN_INFO "MyNet: Network interface registered\n");
    return 0;
}

static void __exit my_net_exit(void) {
    unregister_netdev(my_net_dev);
    free_netdev(my_net_dev);
    printk(KERN_INFO "MyNet: Network interface unregistered\n");
}

module_init(my_net_init);
module_exit(my_net_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("My Network Driver");

这个网络设备驱动的基本示例中，我们定义了打开、关闭和发送数据包的操作。在实际驱动程序中，还会有更多的工作，如中断处理、硬件寄存器的配置、物理层的交互等。

本文还有配套的精品资源，点击获取

简介：本书由资深Linux技术专家宋宝华编写，为Linux内核驱动开发人员提供了一本全面的教程。从基础概念到高级技术，涵盖了Linux驱动开发的各个方面，包括Linux内核架构、驱动程序工作原理、各类驱动编写技巧，以及DDR内存控制器的驱动开发。书中结合实践案例和代码示例，帮助读者通过理论学习和实际操作，掌握Linux内核模块化机制及内核调试工具的使用，从而提升在硬件设备与操作系统间的驱动程序设计与实现能力。

本文还有配套的精品资源，点击获取