電源管理的兩個大方面就是電壓和時鐘。

Clock 時鐘就是 SoC 中的脈搏，由它來控制各個部件按各自的節奏跳動。比如，CPU主頻設置，串口的波特率設置，I2S的采樣率設置，I2C的速率設置等等。這些不同的clock設置，都需要從某個或某幾個時鐘源頭而來，最終開枝散葉，形成一棵時鐘樹。

1. clock驅動構架

Linux的時鐘子系統由CCF（common clock framework）框架管理，CCF向上給用戶提供了通用的時鐘接口，向下給驅動開發者提供硬件操作的接口。

這個也是一個consumer、framework、provider的模式。其中其provider會比較復雜一些，但是往往是由芯片廠商提供，我們編寫設備驅動要使用調頻的時候只需要在consumer里面進行配置使用就可以了。

1.1 Clock Provider介紹

在SoC上器件很多，會形成一個時鐘樹，如下所示：

根節點一般是 Oscillator（有源振蕩器）或者 Crystal（無源振蕩器）。

中間節點有很多種，包括 PLL（鎖相環，用于提升頻率的），Divider（分頻器，用于降頻的），Mux（從多個clock path中選擇一個），Gate（用來控制ON/OFF的）。

葉節點是使用 clock 作為輸入的、有具體功能的 HW block。

可通過

cat /sys/kernel/debug/clk/clk_summary 查看這棵時鐘樹。

image.png

1.2 clock consumer介紹

時鐘的使用者，clock子系統向consumer的提供通用的時鐘API接口，使其可以屏蔽底層硬件差異。提供給consumer操作的API如下：

struct clk *clk_get(struct device *dev, const char *id);
struct clk *devm_clk_get(struct device *dev, const char *id);
int clk_enable(struct clk *clk);//使能時鐘，不會睡眠
void clk_disable(struct clk *clk);//使能時鐘，不會睡眠
unsigned long clk_get_rate(struct clk *clk);
void clk_put(struct clk *clk);
long clk_round_rate(struct clk *clk, unsigned long rate);
int clk_set_rate(struct clk *clk, unsigned long rate);
int clk_set_parent(struct clk *clk, struct clk *parent);
struct clk *clk_get_parent(struct clk *clk);
int clk_prepare(struct clk *clk);
void clk_unprepare(struct clk *clk);
int clk_prepare_enable(struct clk *clk) //使能時鐘，可能會睡眠
void clk_disable_unprepare(struct clk *clk) //禁止時鐘，可能會睡眠
unsigned long clk_get_rate(struct clk *clk) //獲取時鐘頻率

2. Clock Provider

根據 clock 的特點，clock framework 將 clock 分為 fixed rate、gate、devider、mux、fixed factor、composite 六類。

2.1 數據結構表示

上面六類本質上都屬于clock device，內核把這些 clock HW block 的特性抽取出來，用 struct clk_hw 來表示，具體如下

struct clk_hw {
  //指向CCF模塊中對應 clock device 實例
 struct clk_core *core;
  //clk是訪問clk_core的實例。每當consumer通過clk_get對CCF中的clock device（也就是clk_core）發起訪問的時候都需要獲取一個句柄，也就是clk
 struct clk *clk;
  //clock provider driver初始化時的數據，數據被用來初始化clk_hw對應的clk_core數據結構。
 const struct clk_init_data *init;
};

struct clk_init_data {
  //該clock設備的名字
 const char  *name;
  //clock provider driver進行具體的 HW 操作
 const struct clk_ops *ops;
  //描述該clk_hw的拓撲結構
 const char  * const *parent_names;
 const struct clk_parent_data *parent_data;
 const struct clk_hw  **parent_hws;
 u8   num_parents;
 unsigned long  flags;
};

以固定頻率的振動器 fixed rate 為例，它的數據結構是：

struct clk_fixed_rate {
  //下面是fixed rate這種clock device特有的成員
  struct        clk_hw hw；
  //基類
  unsigned long    fixed_rate;
  unsigned long    fixed_accuracy;
  u8        flags;
};

其他clock硬件的表示也是如此。

2.2 clock provider注冊初始化

clock驅動在時鐘子系統中屬于provider，provider是時鐘的提供者，即具體的clock驅動。

clock驅動在Linux剛啟動的時候就要完成，比initcall都要早期，因此clock驅動是在內核中進行實現。

這里也叫clock device，例如上面說的fixed rate，屬于硬件提供服務的。在其啟動的時候根據DTS里面的配置進行注冊。例如fixed rate

CLK_OF_DECLARE(fixed_clk, "fixed-clock", of_fixed_clk_setup); 

struct clk *clk_register_fixed_rate(struct device *dev, const char *name, 
        const char *parent_name, unsigned long flags,
        unsigned long fixed_rate);

其他的device如下：

clk_register_gate
clk_register_divider
clk_register_divider_table
clk_register_mux
clk_register_mux_table
clk_register_fixed_factor
clk_register_composite

這些注冊函數最終都會通過函數?clk_register?注冊到 Common Clock Framework 中，返回為 struct clk 指針。如下所示：

在內核的drivers/clk目錄下，可以看到各個芯片廠商對各自芯片clock驅動的實現：

2.3 DTS配置

例如時鐘源：

clocks{
 osc24M:osc24M{
  compatible = "fixed-clock";
  #clock-cells = <0>;
  clock-output-name = "osc24M";
  clock-frequency = <24000000>;
 };
};

clock驅動編寫的基本步驟：

實現struct clk_ops相關成員函數

定義分配struct clk_onecell_data結構體，初始化相關數據

定義分配struct clk_init_data結構體，初始化相關數據

調用clk_register將時鐘注冊進框架

調用clk_register_clkdev注冊時鐘設備

調用of_clk_add_provider，將clk provider存放到of_clk_provider鏈表中管理

調用CLK_OF_DECLARE聲明驅動

2.4 clock驅動實現舉例：

這里以fixed_clk為例

fixed_clk針對像PLL這種具有固定頻率的時鐘，對于PLL，我們只需要實現.recalc_rate函數。

設備樹：

#define PLL0_CLK 0

clocks{
 osc24M:osc24M{
  compatible = "fixed-clock";
  #clock-cells = <0>;
  clock-output-names = "osc24M";
  clock-frequency = <24000000>;
 };
 pll0:pll0{
  compatible = "xx, choogle-fixed-clk";
  #clock-cells = <0>;
  clock-id = ;
  clock-frequency = <1000000000>;
  clock-output-names = "pll0";
  clocks = <&osc24M>;
 };
};

驅動：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define CLOCK_BASE 0X12340000
#define CLOCK_SIZE 0X1000

struct xx_fixed_clk{
    void __iomem *reg;//保存映射后寄存器基址
    unsigned long fixed_rate;//頻率
    int id;//clock id
    struct clk_hw*;
}；
static unsigned long xx_pll0_fixed_clk_recalc_rate(struct clk_hw *hw, unsigned long parent_rate)
{
 unsigned long recalc_rate;
 //硬件操作：查詢寄存器，獲得分頻系數，計算頻率然后返回
 return recalc_rate;
}

static struct clk_ops xx_pll0_fixed_clk_ops = {
 .recalc_rate  =   xx_pll0_fixed_clk_recalc_rate,
};

struct clk_ops *xx_fixed_clk_ops[] = {
 &xx_pll0_fixed_clk_ops,
};

struct clk * __init xx_register_fixed_clk(const char *name, const char *parent_name,
       void __iomem *res_reg, u32 fixed_rate, int id, 
       const struct clk_ops *ops)
{
 struct xx_fixed_clk *fixed_clk;
 struct clk *clk;
 struct clk_init_data init = {};

 fixed_clk = kzalloc(sizeof(*fixed_clk), GFP_KERNEL);
 if (!fixed_clk)
  return ERR_PTR(-ENOMEM);

    //初始化struct clk_init_data數據
 init.name = name;
 init.flags = CLK_IS_BASIC;
 init.parent_names = parent_name ? &parent_name : NULL;
 init.num_parents = parent_name ? 1 : 0;

 fixed_clk->reg = res_reg;//保存映射后的基址
 fixed_clk->fixed_rate = fixed_rate;//保存頻率
 fixed_clk->id = id;//保存clock id

 fixed_clk->hw.init = &init;

    //時鐘注冊
 clk = clk_register(NULL, &fixed_clk->hw);
 if (IS_ERR(clk))
  kfree(fixed_clk);

 return clk;
}

static void __init of_xx_fixed_clk_init(struct device_node *np)
{
 struct clk_onecell_data *clk_data;
 const char *clk_name = np->name;
 
 const char *parent_name = of_clk_get_parent_name(np, 0);
 void __iomem *res_reg = ioremap(CLOCK_BASE, CLOCK_SIZE);//寄存器基址映射

 u32 rate = -1;
 int clock_id, index, number;

 clk_data = kmalloc(sizeof(struct clk_onecell_data), GFP_KERNEL);
 if (!clk_data )
  return;

 number = of_property_count_u32_elems(np, "clock-id");
 clk_data->clks = kcalloc(number, sizeof(struct clk*), GFP_KERNEL);
 if (!clk_data->clks)
  goto err_free_data;

 of_property_read_u32(np, "clock-frequency", &rate);


 /**
 * 操作寄存器：初始化PLL時鐘頻率
 * ......
 */

 for (index=0; indexclks[index] = xx_register_fixed_clk(clk_name, parent_name, 
       res_reg, rate, clock_id, ak_fixed_clk_ops[pll_id]);
  if (IS_ERR(clk_data->clks[index])) {
   pr_err("%s register fixed clk failed: clk_name:%s, index = %d
",
     __func__, clk_name, index);
   WARN_ON(true);
   continue;
  }
  clk_register_clkdev(clk_data->clks[index], clk_name, NULL);//注冊時鐘設備
 }

 clk_data->clk_num = number;
 if (number == 1) {
  of_clk_add_provider(np, of_clk_src_simple_get, clk_data->clks[0]);
 } else {
  of_clk_add_provider(np, of_clk_src_onecell_get, clk_data);
 }
 return;

err_free_data:
 kfree(clk_data);

}

CLK_OF_DECLARE(xx_fixed_clk, "xx,xx-fixed-clk", of_xx_fixed_clk_init);

3. clock consumer

主要就是獲取clock和操作clock。

3.1 獲取clock

即通過 clock 名稱獲取 struct clk 指針的過程，由 clk_get、devm_clk_get、clk_get_sys、of_clk_get、of_clk_get_by_name、of_clk_get_from_provider 等接口負責實現，這里以 clk_get 為例，分析其實現過程：

struct clk *clk_get(struct device *dev, const char *con_id)
{
 const char *dev_id = dev ? dev_name(dev) : NULL;
 struct clk *clk;

 if (dev) {
  //通過掃描所有“clock-names”中的值，和傳入的name比較，如果相同，獲得它的index（即“clock-names”中的第幾個），調用of_clk_get，取得clock指針。
  clk = __of_clk_get_by_name(dev->of_node, dev_id, con_id);
  if (!IS_ERR(clk) || PTR_ERR(clk) == -EPROBE_DEFER)
   return clk;
 }

 return clk_get_sys(dev_id, con_id);
}

3.2 操作clock

//啟動clock前的準備工作/停止clock后的善后工作。可能會睡眠。
int clk_prepare(struct clk *clk)
void clk_unprepare(struct clk *clk)
 
//啟動/停止clock。不會睡眠。
static inline int clk_enable(struct clk *clk)
static inline void clk_disable(struct clk *clk)

//clock頻率的獲取和設置
static inline unsigned long clk_get_rate(struct clk *clk)
static inline int clk_set_rate(struct clk *clk, unsigned long rate)
static inline long clk_round_rate(struct clk *clk, unsigned long rate)

//獲取/選擇clock的parent clock
static inline int clk_set_parent(struct clk *clk, struct clk *parent)
static inline struct clk *clk_get_parent(struct clk *clk)
 
//將clk_prepare和clk_enable組合起來，一起調用。將clk_disable和clk_unprepare組合起來，一起調用
static inline int clk_prepare_enable(struct clk *clk)
static inline void clk_disable_unprepare(struct clk *clk)

3.3 實例操作

我們在驅動consumer開發的時候需要使用clock，這時需要在DTS里面配置，例如mmc設備：

 mmc0:mmc0@0x12345678{
  compatible = "xx,xx-mmc0";
  ......
  clocks = <&peri PERI_MCI0>;//指定mmc0的時鐘來自PERI_MCI0，PERI_MCI0的父時鐘是peri
  clocks-names = "mmc0"; //時鐘名，調用devm_clk_get獲取時鐘時，可以傳入該名字
        ......
 };

以mmc的設備節點為例，上述mmc0指定了時鐘來自PERI_MCI0，PERI_MCI0的父時鐘是peri，并將所指定的時鐘給它命名為"mmc0"。

使用方法如下：

/* 1、獲取時鐘 */
host->clk = devm_clk_get(&pdev->dev, NULL); //或者devm_clk_get(&pdev->dev, "mmc0")
 if (IS_ERR(host->clk)) {
  dev_err(dev, "failed to find clock source
");
  ret = PTR_ERR(host->clk);
  goto probe_out_free_dev;
 }

/* 2、使能時鐘 */
ret = clk_prepare_enable(host->clk);
if (ret) {
 dev_err(dev, "failed to enable clock source.
");
 goto probe_out_free_dev;
}

probe_out_free_dev:
 kfree(host);

在驅動中操作時鐘，第一步需要獲取struct clk指針句柄，后續都通過該指針進行操作，例如：設置頻率：

ret = clk_set_rate(host->clk, 300000);

獲得頻率：

ret = clk_get_rate(host->clk);

注意：devm_clk_get()的兩個參數是二選一，可以都傳入，也可以只傳入一個參數。

像i2c、mmc等這些外設驅動，通常只需要使能門控即可，因為這些外設并不是時鐘源，它們只有開關。如果直接調用clk_ser_rate函數設置頻率，clk_set_rate會向上傳遞，即設置它的父時鐘頻率。例如在該例子中直接調用clk_set_rate函數，最終設置的是時鐘源peri的頻率。

4. SoC硬件中的使用

在硬件中一般將clock的控制和reset搞到一起，形成一個CRU（clock reset unit）。每個子系統例如NPU需要有自己獨立的CRU，CRU里面有PLL

電源管理寫了這么多篇，慢慢套路就可以摸清楚了，抓住主要構架思路，剩下的就是招式問題了。DTS、consumer，framework、provier、硬件樹形組織等。先弄清楚這些東西，不論調試什么問題就比較快了。

審核編輯：黃飛

?