Linux设备树深度剖析（下）

转载于 2025-11-24 20:39:56 发布 · 25 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://mp.weixin.qq.com/s/u0mx8WmFyqH7Vli2Kp2qHQ

文章标签：

#Linux驱动 #设备树

Linux内核同时被 2 个专栏收录

119 篇文章

订阅专栏

Linux驱动

18 篇文章

订阅专栏

接前一篇文章：Linux设备树深度剖析（中）

7. 实战：简单GPIO设备实现

7.1 设备树定义

// my-gpio-device.dts
/dts-v1/;
/plugin/;

/ {
    compatible = "my-company,my-board";
    
    fragment@0 {
        target = <&gpio>;
        __overlay__ {
            my_gpio_pins: my_gpio_pins {
                pins = "PA10", "PA11";
                function = "gpio_out";
            };
        };
    };
    
    fragment@1 {
        target-path = "/";
        __overlay__ {
            my_gpio_device {
                compatible = "my-company,my-gpio-device";
                status = "okay";
                pinctrl-names = "default";
                pinctrl-0 = <&my_gpio_pins>;
                
                led-gpios = <&pio 0 10 GPIO_ACTIVE_HIGH>,  /* PA10 */
                           <&pio 0 11 GPIO_ACTIVE_HIGH>;  /* PA11 */
                
                button-gpios = <&pio 0 12 GPIO_ACTIVE_LOW>;
                
                device-name = "my-custom-device";
                clock-frequency = <100000>;
            };
        };
    };
};

7.2 对应驱动程序

// my-gpio-driver.c
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/gpio/consumer.h>
#include <linux/interrupt.h>
#include <linux/of.h>

struct my_gpio_data {
    struct gpio_desc *leds[2];
    struct gpio_desc *button;
    int irq;
    struct device *dev;
};

static irqreturn_t button_irq_handler(int irq, void *dev_id)
{
    struct my_gpio_data *priv = dev_id;
    
    // 读取按钮状态并控制LED
    int state = gpiod_get_value(priv->button);
    gpiod_set_value(priv->leds[0], state);
    gpiod_set_value(priv->leds[1], !state);
    
    dev_info(priv->dev, "Button state: %d\n", state);
    return IRQ_HANDLED;
}

static int my_gpio_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    struct device_node *np = dev->of_node;
    struct my_gpio_data *priv;
    int ret, i;
    u32 clock_freq;
    const char *device_name;
    
    priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;
    
    priv->dev = dev;
    
    // 获取LED GPIOs
    for (i = 0; i < 2; i++) {
        priv->leds[i] = devm_gpiod_get_index(dev, "led", i, GPIOD_OUT_LOW);
        if (IS_ERR(priv->leds[i])) {
            dev_err(dev, "failed to get LED GPIO %d\n", i);
            return PTR_ERR(priv->leds[i]);
        }
    }
    
    // 获取按钮GPIO
    priv->button = devm_gpiod_get(dev, "button", GPIOD_IN);
    if (IS_ERR(priv->button)) {
        dev_err(dev, "failed to get button GPIO\n");
        return PTR_ERR(priv->button);
    }
    
    // 获取设备树属性
    ret = of_property_read_string(np, "device-name", &device_name);
    if (ret)
        device_name = "default";
    
    ret = of_property_read_u32(np, "clock-frequency", &clock_freq);
    if (ret)
        clock_freq = 100000; // 默认值
    
    dev_info(dev, "Device %s probed, clock frequency: %d Hz\n", 
             device_name, clock_freq);
    
    // 设置中断
    priv->irq = gpiod_to_irq(priv->button);
    ret = devm_request_irq(dev, priv->irq, button_irq_handler,
                          IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
                          "my-gpio-button", priv);
    if (ret) {
        dev_err(dev, "failed to request IRQ: %d\n", ret);
        return ret;
    }
    
    platform_set_drvdata(pdev, priv);
    return 0;
}

static int my_gpio_remove(struct platform_device *pdev)
{
    struct my_gpio_data *priv = platform_get_drvdata(pdev);
    
    // 关闭LEDs
    gpiod_set_value(priv->leds[0], 0);
    gpiod_set_value(priv->leds[1], 0);
    
    dev_info(&pdev->dev, "Device removed\n");
    return 0;
}

static const struct of_device_id my_gpio_of_match[] = {
    { .compatible = "my-company,my-gpio-device" },
    {}
};
MODULE_DEVICE_TABLE(of, my_gpio_of_match);

static struct platform_driver my_gpio_driver = {
    .probe = my_gpio_probe,
    .remove = my_gpio_remove,
    .driver = {
        .name = "my-gpio-device",
        .of_match_table = my_gpio_of_match,
    },
};

module_platform_driver(my_gpio_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple GPIO device driver with Device Tree support");

8. 设备树调试与诊断

8.1 常用工具命令

工具命令	功能描述	使用示例
dtc	设备树编译器	dtc -I dtb -O dts -o output.dts input.dtb
fdtdump	显示DTB内容	fdtdump input.dtb
dtc -O dtb	编译DTS为DTB	dtc -O dtb -o output.dtb input.dts
of_find_node_by_name	内核调试函数	在驱动中查找节点
cat /proc/device-tree	查看已加载设备树	find /proc/device-tree -type f

8.2 调试技巧与最佳实践

# 1. 检查设备树语法
dtc -I dts -O dtb -o /dev/null my-device.dts

# 2. 反编译现有DTB
dtc -I dtb -O dts -o extracted.dts /boot/device_tree.dtb

# 3. 查看内核解析的设备树
ls /proc/device-tree/
cat /proc/device-tree/compatible

# 4. 检查设备是否成功匹配
cat /sys/firmware/devicetree/base/device@1000/compatible
dmesg | grep -i "device tree"

# 5. 调试驱动匹配
echo -n "my-company,my-device" > /sys/bus/platform/drivers/my-driver/new_id

8.3 内核调试配置

// 在驱动中添加调试输出
#define DEBUG

static int my_driver_probe(struct platform_device *pdev)
{
    struct device_node *np = pdev->dev.of_node;
    
    // 打印设备树信息
    dev_dbg(&pdev->dev, "Device tree node: %s\n", np->full_name);
    
    // 遍历属性
    struct property *prop;
    for_each_property_of_node(np, prop) {
        dev_dbg(&pdev->dev, "Property: %s\n", prop->name);
    }
    
    return 0;
}

9. 设备树设计模式与最佳实践

9.1 设计原则总结

9.2 常见陷阱与解决方案

// 错误示例 - 缺少必要的属性
mydevice@10000000 {
    compatible = "my-company,my-device";
    // 缺少reg属性!
};

// 正确示例
mydevice@10000000 {
    compatible = "my-company,my-device";
    reg = <0x10000000 0x1000>;
    interrupts = <0 25 4>;
    clocks = <&myclock>;
    clock-names = "core";
};