时钟配置不对,驱动再好也白费:Linux 时钟框架入门

写驱动时，你是不是也遇到过这样的问题：设备树里写了 clocks = <&clk 123>，但驱动里不知道怎么获取和使用这个时钟？或者系统启动后某个外设就是不工作，最后发现是时钟没使能？

时钟是数字电路的"心跳"，没有时钟，再好的驱动也跑不起来。今天带你深入了解 Linux 时钟框架，掌握驱动中时钟配置的正确方式。

早期的嵌入式系统，时钟配置是这样的：

// 老式做法：直接操作时钟寄存器
#define CLK_CTRL_REG  0x40011000
#define UART_CLK_EN   (1 << 5)

void uart_init(void) {
    // 使能 UART 时钟
    writel(readl(CLK_CTRL_REG) | UART_CLK_EN, CLK_CTRL_REG);
    
    // 硬编码时钟频率
    uart_set_baudrate(115200, 50000000);  // 假设时钟是 50MHz
}

问题很明显：

• • 不可移植：换一块芯片，时钟寄存器全变了
• • 不可配置：时钟频率硬编码，没法动态调整
• • 不可共享：多个外设共用一个时钟源时，谁来管理？
• • 不可发现：用户空间怎么知道某个外设的时钟频率？

时钟框架就是为了解决这些问题而生的。它的核心思想：时钟是一种可以被申请、配置、使能、禁用的资源。

时钟框架的核心概念

1. 时钟树

一个典型的 SoC 时钟树：

晶振 (24MHz)
  ↓
PLL (倍频到 1GHz)
  ↓
分频器 → CPU 时钟 (1GHz)
       → 总线时钟 (200MHz)
       → 外设时钟 (50MHz)
           ├─ UART 时钟
           ├─ I2C 时钟
           └─ SPI 时钟

在 Linux 中，这棵树由时钟控制器驱动管理。

2. 时钟提供者（Clock Provider）

时钟提供者是产生时钟的硬件模块，通常是 SoC 内部的时钟控制器。

#include <linux/clk-provider.h>

static const struct clk_hw *uart_clk_parents[] = {
    &pll_clk.hw,  // 父时钟：PLL
};

static struct clk_hw uart_clk_hw = {
    .init = CLK_INIT_HW("uart0_clk", &uart_ops, NULL, uart_clk_parents),
};

3. 时钟消费者（Clock Consumer）

时钟消费者是使用时钟的外设驱动。

#include <linux/clk.h>

struct uart_driver {
    struct clk *clk;  // 时钟句柄
};

设备树中的时钟配置

基本用法

// 时钟控制器
clocks: clock-controller@40011000 {
    compatible = "mycompany,clk-controller";
    reg = <0x40011000 0x1000>;
    #clock-cells = <1>;  // 每个时钟需要一个 cell 来标识
    clocks = <&osc>;     // 自己的父时钟
    clock-names = "osc";
};

// UART 设备
uart0: serial@40020000 {
    compatible = "mycompany,uart";
    reg = <0x40020000 0x1000>;
    clocks = <&clocks 123>;  // 引用时钟控制器的第 123 号时钟
    clock-names = "uart_clk";
};

关键属性：

• • clocks：引用时钟，格式 <&时钟节点 时钟ID>
• • clock-names：给时钟起个名字（通常叫 "uart_clk"、"spi_clk" 等）
• • #clock-cells：时钟提供者需要多少个 cell 来标识一个时钟

多个时钟

有些设备需要多个时钟（如核心时钟和总线时钟）：

eth0: ethernet@40030000 {
    compatible = "mycompany,eth";
    reg = <0x40030000 0x1000>;
    clocks = <&clocks 10>, <&clocks 11>;
    clock-names = "core_clk", "bus_clk";
};

在驱动中使用时钟

1. 获取时钟

#include <linux/clk.h>

static int mydev_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    struct clk *clk;
    
    // 通过名字获取时钟
    clk = devm_clk_get(dev, "uart_clk");
    if (IS_ERR(clk)) {
        dev_err(dev, "Failed to get uart_clk\n");
        return PTR_ERR(clk);
    }
    
    // 如果没有 clock-names，可以用索引获取
    // clk = devm_clk_get_at_index(dev, 0);
    
    return 0;
}

推荐做法：使用 devm_clk_get 而不是 clk_get，确保设备移除时自动释放。

2. 使能时钟

static int mydev_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    struct clk *clk;
    int ret;
    
    clk = devm_clk_get(dev, "uart_clk");
    if (IS_ERR(clk))
        return PTR_ERR(clk);
    
    // 准备时钟（某些时钟需要预热）
    ret = clk_prepare_enable(clk);
    if (ret) {
        dev_err(dev, "Failed to enable clock\n");
        return ret;
    }
    
    // 现在可以使用外设了
    // ...
    
    return 0;
}

重要：clk_prepare_enable 是两步操作：

• • clk_prepare：可能睡眠的操作（如配置 PLL）
• • clk_enable：原子操作，快速使能时钟

3. 设置时钟频率

static int mydev_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    struct clk *clk;
    unsigned long rate;
    int ret;
    
    clk = devm_clk_get(dev, "uart_clk");
    if (IS_ERR(clk))
        return PTR_ERR(clk);
    
    // 设置时钟频率
    ret = clk_set_rate(clk, 50000000);  // 50MHz
    if (ret) {
        dev_err(dev, "Failed to set clock rate\n");
        return ret;
    }
    
    // 获取实际设置的频率（可能不是精确值）
    rate = clk_get_rate(clk);
    dev_info(dev, "Clock rate: %lu Hz\n", rate);
    
    ret = clk_prepare_enable(clk);
    if (ret)
        return ret;
    
    return 0;
}

4. 禁用和取消准备

static void mydev_remove(struct platform_device *pdev)
{
    struct mydev_data *data = platform_get_drvdata(pdev);
    
    // 禁用时钟（原子操作）
    clk_disable_unprepare(data->clk);
    
    // devm_ 版本会自动调用，所以通常不需要手动释放
}

完整示例：UART 驱动中的时钟使用

#include <linux/clk.h>
#include <linux/platform_device.h>

struct myuart_dev {
    void __iomem *base;
    struct clk *clk;
    unsigned long clk_rate;
};

static int myuart_probe(struct platform_device *pdev)
{
    struct myuart_dev *uart;
    struct resource *res;
    int ret;
    
    uart = devm_kzalloc(&pdev->dev, sizeof(*uart), GFP_KERNEL);
    if (!uart)
        return -ENOMEM;
    
    // 获取内存资源
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    uart->base = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(uart->base))
        return PTR_ERR(uart->base);
    
    // 获取时钟
    uart->clk = devm_clk_get(&pdev->dev, "uart_clk");
    if (IS_ERR(uart->clk)) {
        dev_err(&pdev->dev, "Failed to get clock\n");
        return PTR_ERR(uart->clk);
    }
    
    // 设置时钟频率
    ret = clk_set_rate(uart->clk, 50000000);
    if (ret) {
        dev_err(&pdev->dev, "Failed to set clock rate\n");
        return ret;
    }
    
    uart->clk_rate = clk_get_rate(uart->clk);
    dev_info(&pdev->dev, "UART clock: %lu Hz\n", uart->clk_rate);
    
    // 使能时钟
    ret = clk_prepare_enable(uart->clk);
    if (ret) {
        dev_err(&pdev->dev, "Failed to enable clock\n");
        return ret;
    }
    
    // 现在可以初始化 UART 硬件了
    // 波特率发生器会使用 uart->clk_rate 来计算分频系数
    myuart_init_hw(uart, uart->clk_rate);
    
    platform_set_drvdata(pdev, uart);
    return 0;
}

static void myuart_remove(struct platform_device *pdev)
{
    struct myuart_dev *uart = platform_get_drvdata(pdev);
    
    // 禁用时钟（devm_ 版本会自动调用，这里只是示例）
    clk_disable_unprepare(uart->clk);
}

高级用法：时钟动态切换

有些场景需要在运行时改变时钟频率（如动态电压频率调节 DVFS）：

static int mydev_set_performance(struct device *dev, int level)
{
    struct mydev_data *data = dev_get_drvdata(dev);
    unsigned long rate;
    int ret;
    
    switch (level) {
    case PERFORMANCE_LOW:
        rate = 24000000;  // 24MHz
        break;
    case PERFORMANCE_HIGH:
        rate = 100000000;  // 100MHz
        break;
    default:
        return -EINVAL;
    }
    
    // 改变时钟频率
    ret = clk_set_rate(data->clk, rate);
    if (ret) {
        dev_err(dev, "Failed to set clock rate\n");
        return ret;
    }
    
    data->clk_rate = clk_get_rate(data->clk);
    dev_info(dev, "Clock changed to %lu Hz\n", data->clk_rate);
    
    // 可能需要重新配置硬件以适应新的时钟频率
    mydev_reconfigure(data, data->clk_rate);
    
    return 0;
}

常见问题与调试

问题 1：时钟获取失败

[    1.234567] mydev: Failed to get uart_clk: -2

原因：

• • 设备树中没有 clocks 属性
• • clock-names 不匹配
• • 时钟提供者驱动没有注册

调试：

# 查看设备树中的时钟配置
cat /proc/device-tree/*/clocks

# 查看系统时钟树
cat /sys/kernel/debug/clk/clk_summary

问题 2：时钟使能失败

[    1.234567] mydev: Failed to enable clock: -5

原因：

• • 时钟硬件故障
• • 时钟父时钟未使能
• • 时钟配置冲突

调试：

# 查看时钟状态
cat /sys/kernel/debug/clk/clk_summary | grep uart

# 手动使能时钟（测试用）
echo 1 > /sys/kernel/debug/clk/uart0_clk/enable

问题 3：时钟频率不对

症状：外设工作异常，如 UART 波特率错误。

原因：

• • 设备树中时钟 ID 错误
• • 时钟父时钟频率不对
• • 驱动中没有调用 clk_set_rate

调试：

# 查看实际时钟频率
cat /sys/kernel/debug/clk/clk_summary | grep uart

# 在驱动中打印
dev_info(dev, "Clock rate: %lu Hz\n", clk_get_rate(clk));

最佳实践

1. 1. 始终使用 devm_ 版本：devm_clk_get、devm_clk_get_enabled 等，确保设备移除时自动禁用和释放时钟。
2. 2. 先准备再使能：使用 clk_prepare_enable 而不是单独的 clk_enable，除非你确定时钟不需要准备。
3. 3. 检查时钟频率：clk_set_rate 可能不会设置精确的频率，用 clk_get_rate 确认实际值。
4. 4. 处理时钟缺失：不是所有硬件都有时钟控制（如简单的 GPIO 设备），驱动应该能处理 clocks 属性不存在的情况。
5. 5. 文档化时钟需求：在设备树绑定文档中说明驱动需要哪些时钟，时钟名称是什么。

总结

时钟框架是 Linux 驱动基础设施的重要组成部分。正确使用时钟框架，能让你的驱动：

• • 可移植：不需要硬编码时钟寄存器和频率
• • 可配置：支持动态频率调节
• • 可管理：时钟资源被统一管理，避免冲突
• • 可调试：可以通过 sysfs 和 debugfs 查看时钟状态

下次当你写驱动时，别忘了先看看设备树中的 clocks 属性，然后在 probe 函数中正确获取和使能时钟。这是驱动能正常工作的第一步。

最后提醒：时钟框架虽然强大，但也不要过度使用。简单的设备可能不需要时钟管理，硬要加上只会增加复杂度。理解你的硬件需求，选择合适的时钟管理方式。