车辆TBOX科普 第38次 从移植到设备树配置与字符设备驱动

一、嵌入式Linux移植

嵌入式Linux移植是将Linux内核适配到特定硬件平台的过程。它涉及选择合适的内核版本、配置内核选项、编译内核和根文件系统，并最终部署到目标设备。移植的目的是确保Linux系统能够充分利用硬件资源，同时保持稳定性和性能。在阶段三的开发中，移植通常是第41-50步的核心任务，它为后续的驱动开发奠定基础。

1.1 嵌入式Linux移植概述

Linux内核是操作系统的核心，负责管理硬件资源、进程调度和系统调用。在嵌入式系统中，硬件资源往往有限（如低功耗CPU、有限内存），因此移植过程需要针对性地优化内核。移植的主要挑战包括硬件兼容性、启动流程定制和资源管理。一个成功的移植可以显著提升系统效率，减少功耗和启动时间。

移植过程通常包括以下步骤：

硬件分析：了解目标硬件的架构（如ARM、MIPS）、外设（如UART、GPIO）和内存布局。内核选择：选择适合的Linux内核版本（如稳定版LTS），平衡功能与稳定性。内核配置：使用工具如
make menuconfig定制内核选项，启用或禁用不必要的模块以减小体积。内核编译：交叉编译内核，生成可在目标硬件上运行的镜像。根文件系统构建：创建最小根文件系统，包含必要的库和工具。部署与测试：将内核和根文件系统烧录到设备，并通过串口或网络进行调试。

在嵌入式项目中，移植往往需要与硬件团队紧密合作，确保软件与硬件匹配。例如，在ARM平台上，可能需要处理特定的启动加载器（如U-Boot）和设备树文件。

1.2 嵌入式Linux移植步骤详解

以下是一个典型的嵌入式Linux移植流程，以ARM平台为例。假设我们使用Linux内核5.10版本，目标设备是一块自定义的ARM Cortex-A9开发板。

步骤1：硬件分析
首先，收集硬件规格，包括CPU架构、内存大小、存储类型（如eMMC或NAND Flash）以及外设列表（如以太网、USB、GPIO）。这些信息将指导内核配置和设备树编写。例如，如果硬件使用UART作为调试接口，我们需要确保内核支持该UART驱动。

步骤2：内核选择与获取
从kernel.org下载Linux 5.10稳定版源码。使用Git克隆仓库：

git clone https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
cd linux
git checkout v5.10

步骤3：内核配置
进入源码目录，运行
make menuconfig启动配置界面。根据硬件需求，启用必要选项：

在”General setup”中，设置交叉编译工具链（如arm-linux-gnueabihf-）。在”System Type”中，选择ARM架构和具体芯片（如Cortex-A9）。在”Device Drivers”中，启用外设驱动（如网络、串口）。禁用不必要的模块（如桌面特性）以减小内核大小。

配置完成后，保存为
.config文件。然后，使用
make olddefconfig自动处理依赖关系。

步骤4：内核编译
使用交叉编译工具链编译内核。假设工具链已安装，运行：

export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabihf-
make zImage
make modules
make dtbs

这将生成内核镜像
zImage、设备树二进制文件
dtbs和内核模块。编译时间可能较长，取决于硬件性能。

步骤5：根文件系统构建
根文件系统包含系统运行所需的用户空间工具。可以使用BusyBox构建最小系统：

wget https://busybox.net/downloads/busybox-1.35.0.tar.bz2
tar -xf busybox-1.35.0.tar.bz2
cd busybox-1.35.0
make menuconfig  # 选择静态编译
make && make install

然后，创建目录结构（如
/bin、
/etc），并复制BusyBox输出。最后，使用工具如
genext2fs生成根文件系统镜像。

步骤6：部署与测试
将
zImage、设备树文件和根文件系统烧录到目标设备的存储中。使用U-Boot引导系统：

# 在U-Boot命令行中设置启动参数
setenv bootargs console=ttyS0,115200 root=/dev/mmcblk0p2
bootz 0x8000 0x1000000 0x2000000

通过串口连接，查看启动日志，确认系统正常启动。如果遇到问题，使用
dmesg和日志工具调试。

1.3 移植中的常见挑战与解决方案

在移植过程中，常见问题包括启动失败、驱动不兼容和性能瓶颈。以下是一些解决方案：

启动失败：检查U-Boot配置、设备树文件和内核参数。使用早期控制台输出调试。内存问题：确保内核配置正确映射内存，避免内存溢出。外设不工作：验证设备树配置和驱动加载顺序。

移植完成后，系统应稳定运行，为设备树配置和驱动开发提供平台。接下来，我们将探讨设备树配置，它是嵌入式Linux硬件抽象的关键。

二、设备树（Device Tree）配置

设备树是一种硬件描述语言，用于将硬件信息从内核代码中分离出来。它使得同一内核可以支持多种硬件平台，无需重新编译。在嵌入式Linux中，设备树文件（.dts）在启动时由引导加载器传递给内核，内核解析后加载相应驱动。掌握设备树配置是阶段三（第51-55步）的重要目标，它能显著简化移植和维护工作。

2.1 设备树概述与基本原理

设备树的起源可以追溯到Open Firmware标准，后来被Linux社区采纳为ARM等平台的硬件描述机制。在传统嵌入式系统中，硬件信息硬编码在内核中，导致代码臃肿和移植困难。设备树通过文本文件描述硬件拓扑（如CPU、内存、外设），实现了硬件与软件的分离。

设备树的基本结构包括：

节点（Node）：表示硬件组件，如一个设备或总线。属性（Property）：描述节点的特性，如地址、中断号。兼容性（Compatible）：用于匹配内核驱动。

设备树文件使用DTS（Device Tree Source）格式编写，编译后生成DTB（Device Tree Blob）二进制文件，由内核解析。例如，一个简单的GPIO设备可能描述为：

gpio0: gpio@10000000 {
    compatible = "vendor,gpio-example";
    reg = <0x10000000 0x1000>;
    interrupts = <0 10 4>;
};

这表示一个GPIO设备位于地址0x10000000，使用中断号10。

设备树的优势包括：

可移植性：同一内核支持不同硬件，只需更换设备树文件。可维护性：硬件变更只需修改设备树，无需重新编译内核。动态配置：在启动时加载，适应多种场景。

2.2 设备树语法与结构详解

设备树语法类似于C语言，包括节点、属性和引用。以下是一个基本设备树示例，描述一个假设的ARM平台：

/dts-v1/;

/ {
    model = "Example ARM Board";
    compatible = "vendor,example-board";
    #address-cells = <1>;
    #size-cells = <1>;

    cpus {
        #address-cells = <1>;
        #size-cells = <0>;
        cpu@0 {
            device_type = "cpu";
            compatible = "arm,cortex-a9";
            reg = <0>;
        };
    };

    memory@80000000 {
        device_type = "memory";
        reg = <0x80000000 0x10000000>; // 256MB内存
    };

    soc {
        #address-cells = <1>;
        #size-cells = <1>;
        compatible = "simple-bus";
        ranges;

        serial@101f0000 {
            compatible = "arm,pl011";
            reg = <0x101f0000 0x1000>;
            interrupts = <0 12 4>;
            status = "okay";
        };

        gpio@101f1000 {
            compatible = "vendor,gpio-example";
            reg = <0x101f1000 0x1000>;
            gpio-controller;
            #gpio-cells = <2>;
        };
    };
};

解释：


/ 是根节点，包含模型和兼容性属性。
cpus 节点描述CPU信息。
memory 节点定义内存地址和大小。
soc 节点表示系统芯片，包含串口和GPIO子节点。属性如
reg 定义地址范围，
interrupts 定义中断号。

设备树编译使用DTC（Device Tree Compiler）：

dtc -I dts -O dtb -o example.dtb example.dts

生成的DTB文件在启动时传递给内核。

2.3 设备树配置实践与示例

在实际项目中，设备树配置需要根据硬件手册编写。以下是一个常见场景：配置一个LED设备通过GPIO控制。

假设硬件中，LED连接在GPIO引脚5上，使用GPIO控制器地址0x101f1000。设备树节点如下：

leds {
    compatible = "gpio-leds";
    led0 {
        label = "user-led";
        gpios = <&gpio0 5 0>; // 引用GPIO控制器，引脚5，主动高电平
        linux,default-trigger = "heartbeat";
    };
};

在内核配置中，需要启用LED和GPIO支持：

make menuconfig
# 在Device Drivers -> LED Support中启用"LED Class Support"和"GPIO LED Support"

编译设备树后，部署到系统。启动后，LED应闪烁，表示配置成功。

设备树调试常用方法：

使用
/proc/device-tree查看解析后的设备树。通过
dmesg | grep of_检查设备树加载日志。使用工具如
fdtdump分析DTB文件。

设备树配置是嵌入式Linux开发的关键技能，它简化了硬件管理。接下来，我们将进入字符设备驱动开发，实现与硬件的直接交互。

三、字符设备驱动开发

字符设备驱动是Linux驱动的一种类型，用于处理以字节流方式访问的设备，如串口、键盘或自定义硬件。在阶段三（第56-60步），字符设备驱动开发是核心任务，它允许用户空间应用程序通过文件接口（如
/dev下的设备文件）与硬件通信。开发字符设备驱动涉及注册设备、实现文件操作函数和处理中断。

3.1 字符设备驱动概述

Linux驱动分为字符设备、块设备和网络设备。字符设备的特点是：

字节流访问：数据以顺序字节流读写，不支持随机访问。简单接口：通过
open、
read、
write等系统调用操作。典型例子：串口、打印机、传感器。

驱动开发在内核空间进行，需要遵循Linux驱动模型。一个基本的字符设备驱动包括：

设备注册：使用
register_chrdev或新式
cdev接口。文件操作：实现
struct file_operations中的函数，如
read、
write。内存管理：使用内核API分配缓冲区。中断处理：注册中断处理函数，处理硬件事件。

驱动开发环境需要内核头文件和交叉编译工具。代码必须稳健，避免内核崩溃。

3.2 字符设备驱动开发步骤

以下是一个简单的字符设备驱动示例，实现一个虚拟设备“mydev”，支持读写操作。假设驱动用于一个假设的硬件设备，地址通过设备树配置。

步骤1：定义驱动结构
首先，在驱动源码中定义必要的数据结构：

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

#define DEVICE_NAME "mydev"
#define CLASS_NAME "myclass"

static int major_num;
static struct class *myclass = NULL;
static struct cdev my_cdev;

static char device_buffer[256] = {0}; // 模拟设备缓冲区

// 文件操作函数
static int mydev_open(struct inode *inodep, struct file *filep) {
    printk(KERN_INFO "mydev: Device opened
");
    return 0;
}

static ssize_t mydev_read(struct file *filep, char *buffer, size_t len, loff_t *offset) {
    if (copy_to_user(buffer, device_buffer, len) != 0) {
        return -EFAULT;
    }
    printk(KERN_INFO "mydev: Read %zu bytes
", len);
    return len;
}

static ssize_t mydev_write(struct file *filep, const char *buffer, size_t len, loff_t *offset) {
    if (copy_from_user(device_buffer, buffer, len) != 0) {
        return -EFAULT;
    }
    printk(KERN_INFO "mydev: Written %zu bytes
", len);
    return len;
}

static int mydev_release(struct inode *inodep, struct file *filep) {
    printk(KERN_INFO "mydev: Device closed
");
    return 0;
}

static struct file_operations fops = {
    .open = mydev_open,
    .read = mydev_read,
    .write = mydev_write,
    .release = mydev_release,
};

步骤2：设备注册与初始化
在模块初始化函数中注册设备：

static int __init mydev_init(void) {
    int ret;
    dev_t dev_num;

    // 动态分配主设备号
    ret = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
    if (ret < 0) {
        printk(KERN_ALERT "mydev: Failed to allocate device number
");
        return ret;
    }
    major_num = MAJOR(dev_num);

    // 初始化cdev结构
    cdev_init(&my_cdev, &fops);
    my_cdev.owner = THIS_MODULE;

    // 添加cdev到系统
    ret = cdev_add(&my_cdev, dev_num, 1);
    if (ret < 0) {
        unregister_chrdev_region(dev_num, 1);
        printk(KERN_ALERT "mydev: Failed to add cdev
");
        return ret;
    }

    // 创建设备类和设备文件
    myclass = class_create(THIS_MODULE, CLASS_NAME);
    if (IS_ERR(myclass)) {
        cdev_del(&my_cdev);
        unregister_chrdev_region(dev_num, 1);
        return PTR_ERR(myclass);
    }

    device_create(myclass, NULL, dev_num, NULL, DEVICE_NAME);
    printk(KERN_INFO "mydev: Device registered with major number %d
", major_num);
    return 0;
}

static void __exit mydev_exit(void) {
    dev_t dev_num = MKDEV(major_num, 0);
    device_destroy(myclass, dev_num);
    class_destroy(myclass);
    cdev_del(&my_cdev);
    unregister_chrdev_region(dev_num, 1);
    printk(KERN_INFO "mydev: Device unregistered
");
}

module_init(mydev_init);
module_exit(mydev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple character device driver");

步骤3：编译与加载驱动
编写Makefile，使用内核构建系统编译：

obj-m += mydev.o
KDIR := /path/to/your/linux-kernel

all:
    make -C $(KDIR) M=$(PWD) modules

clean:
    make -C $(KDIR) M=$(PWD) clean

编译后，加载驱动：

insmod mydev.ko

检查
/dev/mydev是否创建，使用
cat /proc/devices查看设备号。

步骤4：测试驱动
编写用户空间测试程序：

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main() {
    int fd;
    char buf[100];

    fd = open("/dev/mydev", O_RDWR);
    if (fd < 0) {
        perror("Failed to open device");
        return -1;
    }

    write(fd, "Hello from user!", 16);
    read(fd, buf, 16);
    printf("Read from device: %s
", buf);

    close(fd);
    return 0;
}

编译并运行测试程序，观察内核日志中的输出。

3.3 驱动开发中的高级主题

在实际项目中，驱动开发可能涉及更复杂的功能：

中断处理：使用
request_irq注册中断处理函数，处理硬件事件。IOCTL接口：通过
ioctl实现自定义命令。电源管理：实现
suspend和
resume函数。设备树集成：在设备树中定义设备，驱动通过
of_match_table匹配。

例如，添加设备树支持：
在设备树中定义节点：

mydev@10000000 {
    compatible = "vendor,mydev";
    reg = <0x10000000 0x1000>;
    interrupts = <0 20 4>;
};

在驱动中，添加OF匹配：

static const struct of_device_id mydev_of_match[] = {
    { .compatible = "vendor,mydev" },
    { }
};
MODULE_DEVICE_TABLE(of, mydev_of_match);

然后在初始化中解析设备树属性。

驱动开发完成后，系统可以高效地与硬件交互。接下来，我们通过一个综合案例整合所有知识。

四、综合案例：嵌入式LED控制项目

为了将嵌入式Linux移植、设备树配置和字符设备驱动开发结合起来，我们设计一个简单项目：在自定义ARM开发板上控制一个LED。假设硬件包括一个GPIO连接的LED，我们将完成系统移植、设备树描述和驱动编写。

4.1 项目概述

硬件：ARM Cortex-A9板，LED连接GPIO引脚5。目标：通过用户程序控制LED开关。步骤：
移植Linux内核到硬件。在设备树中描述GPIO和LED。编写字符设备驱动，实现GPIO控制。测试整体功能。

4.2 实施步骤

步骤1：嵌入式Linux移植
参考第一节，完成内核编译和部署。确保内核支持GPIO和LED驱动。

步骤2：设备树配置
在设备树文件中添加LED节点：

/dts-v1/;
/ {
    compatible = "vendor,led-board";
    model = "LED Control Board";

    leds {
        compatible = "gpio-leds";
        led0 {
            label = "user-led";
            gpios = <&gpio0 5 0>;
            default-state = "off";
        };
    };
};

编译设备树并部署。

步骤3：字符设备驱动开发
编写驱动，使用GPIO子系统控制LED：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "leddev"
#define LED_GPIO 5

static int led_open(struct inode *inodep, struct file *filep) {
    if (gpio_request(LED_GPIO, "led-gpio") < 0) {
        printk(KERN_ALERT "leddev: GPIO request failed
");
        return -EBUSY;
    }
    gpio_direction_output(LED_GPIO, 0);
    return 0;
}

static ssize_t led_write(struct file *filep, const char *buffer, size_t len, loff_t *offset) {
    char state;
    if (copy_from_user(&state, buffer, 1) != 0) return -EFAULT;
    gpio_set_value(LED_GPIO, state - '0');
    return len;
}

static int led_release(struct inode *inodep, struct file *filep) {
    gpio_free(LED_GPIO);
    return 0;
}

static struct file_operations led_fops = {
    .open = led_open,
    .write = led_write,
    .release = led_release,
};

static int __init led_init(void) {
    int ret;
    ret = register_chrdev(0, DEVICE_NAME, &led_fops);
    if (ret < 0) {
        printk(KERN_ALERT "leddev: Registration failed
");
        return ret;
    }
    printk(KERN_INFO "leddev: Driver loaded
");
    return 0;
}

static void __exit led_exit(void) {
    unregister_chrdev(0, DEVICE_NAME);
    printk(KERN_INFO "leddev: Driver unloaded
");
}

module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");

编译并加载驱动。

步骤4：测试
编写用户程序：

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd = open("/dev/leddev", O_WRONLY);
    if (fd < 0) {
        perror("Open failed");
        return -1;
    }
    write(fd, "1", 1); // LED开
    sleep(2);
    write(fd, "0", 1); // LED关
    close(fd);
    return 0;
}

运行程序，LED应闪烁。

4.3 项目总结

这个案例展示了嵌入式Linux开发的完整流程：从系统移植到驱动实现。通过整合设备树和驱动，我们实现了硬件控制，体现了阶段三学习的核心技能。

结论

本文详细介绍了嵌入式Linux底层软件与驱动开发的关键技术：嵌入式Linux移植、设备树配置和字符设备驱动开发。通过理论解释、步骤指南和实际示例，我们涵盖了阶段三（第41-60步）的核心内容。

嵌入式Linux移植是基础，确保系统在目标硬件上运行。我们学习了从硬件分析到部署测试的全过程。设备树配置简化了硬件管理，通过描述性语言实现内核与硬件的解耦。字符设备驱动开发允许用户空间与硬件交互，我们实现了简单的驱动并集成设备树。

这些技能是嵌入式Linux开发的核心，掌握它们后，您可以应对更复杂的项目，如多设备驱动或实时系统优化。进一步学习建议包括探索内核模块编程、调试技巧和社区资源（如Linux内核文档）。

希望本文能帮助您在嵌入式领域取得进步。如果您有疑问或建议，欢迎在评论区讨论！