Linux common clock framework(2)_clock provider

作者：wowo 发布于：2014-10-23 23:49 分类：电源管理子系统

1. 前言

本文接上篇文章，从clock driver的角度，分析怎么借助common clock framework管理系统的时钟资源。换句话说，就是怎么编写一个clock driver。

由于kernel称clock driver为clock provider（相应的，clock的使用者为clock consumer），因此本文遵循这个规则，统一以clock provider命名。

2. clock有关的DTS

我们在“Linux common clock framework(1)_概述”中讲述clock consumer怎么使用clock时，提到过clock consumer怎么在DTS中指定所使用的clock。这里再做进一步说明。

2.1 clock provider的DTS

我们知道，DTS（Device Tree Source）是用来描述设备信息的，那系统的clock资源，是什么设备呢？换句话，用什么设备表示呢？这决定了clock provider的DTS怎么写。

通常有两种方式：

方式1，将系统所有的clock，抽象为一个虚拟的设备，用一个DTS node表示。这个虚拟的设备称作clock controller，参考如下例子：

   1: /* arch/arm/boot/dts/exynos4210.dtsi */
   2: clock: clock-controller@0x10030000 {
   3:         compatible = "samsung,exynos4210-clock";
   4:         reg = <0x10030000 0x20000>;
   5:         #clock-cells = <1>;
   6: };

clock，该clock设备的名称，clock consumer可以根据该名称引用clock；

#clock-cells，该clock的cells，1表示该clock有多个输出，clock consumer需要通过ID值指定所要使用的clock（很好理解，系统那么多clock，被抽象为1个设备，因而需要额外的ID标识）。

方式2，每一个可输出clock的器件，如“Linux common clock framework(1)_概述”所提及的Oscillator、PLL、Mux等等，都是一个设备，用一个DTS node表示。每一个器件，即是clock provider，也是clock consumer（根节点除外，如OSC），因为它需要接受clock输入，经过处理后，输出clock。参考如下例子（如果能拿到对应的datasheet会更容易理解）：

   1: /* arch/arm/boot/dts/sun4i-a10.dtsi */
   2: clocks {
   3:     #address-cells = <1>;
   4:     #size-cells = <1>;
   5:     ranges;
   6:  
   7:     /*
   8:      * This is a dummy clock, to be used as placeholder on
   9:      * other mux clocks when a specific parent clock is not
  10:      * yet implemented. It should be dropped when the driver
  11:      * is complete.
  12:      */
  13:     dummy: dummy {
  14:         #clock-cells = <0>;
  15:         compatible = "fixed-clock";
  16:         clock-frequency = <0>;
  17:     };
  18:  
  19:     osc24M: osc24M@01c20050 {
  20:         #clock-cells = <0>;
  21:         compatible = "allwinner,sun4i-osc-clk";
  22:         reg = <0x01c20050 0x4>;
  23:         clock-frequency = <24000000>;
  24:     };
  25:  
  26:     osc32k: osc32k {
  27:         #clock-cells = <0>;
  28:         compatible = "fixed-clock";
  29:         clock-frequency = <32768>;
  30:     };
  31:  
  32:     pll1: pll1@01c20000 {
  33:         #clock-cells = <0>;
  34:         compatible = "allwinner,sun4i-pll1-clk";
  35:         reg = <0x01c20000 0x4>;
  36:         clocks = <&osc24M>;
  37:     };
  38:  
  39:     /* dummy is 200M */
  40:     cpu: cpu@01c20054 {
  41:         #clock-cells = <0>;
  42:         compatible = "allwinner,sun4i-cpu-clk";
  43:         reg = <0x01c20054 0x4>;
  44:         clocks = <&osc32k>, <&osc24M>, <&pll1>, <&dummy>;
  45:     };
  46:  
  47:     axi: axi@01c20054 {
  48:         #clock-cells = <0>;
  49:         compatible = "allwinner,sun4i-axi-clk";
  50:         reg = <0x01c20054 0x4>;
  51:         clocks = <&cpu>;
  52:     };
  53:  
  54:     axi_gates: axi_gates@01c2005c {
  55:         #clock-cells = <1>;
  56:         compatible = "allwinner,sun4i-axi-gates-clk";
  57:         reg = <0x01c2005c 0x4>;
  58:         clocks = <&axi>;
  59:         clock-output-names = "axi_dram";
  60:     };
  61:  
  62:     ahb: ahb@01c20054 {
  63:         #clock-cells = <0>;
  64:         compatible = "allwinner,sun4i-ahb-clk";
  65:         reg = <0x01c20054 0x4>;
  66:         clocks = <&axi>;
  67:     };
  68:  
  69:     ahb_gates: ahb_gates@01c20060 {
  70:         #clock-cells = <1>;
  71:         compatible = "allwinner,sun4i-ahb-gates-clk";
  72:         reg = <0x01c20060 0x8>;
  73:         clocks = <&ahb>;
  74:         clock-output-names = "ahb_usb0", "ahb_ehci0",
  75:             "ahb_ohci0", "ahb_ehci1", "ahb_ohci1", "ahb_ss",
  76:             "ahb_dma", "ahb_bist", "ahb_mmc0", "ahb_mmc1",
  77:             "ahb_mmc2", "ahb_mmc3", "ahb_ms", "ahb_nand",
  78:             "ahb_sdram", "ahb_ace",    "ahb_emac", "ahb_ts",
  79:             "ahb_spi0", "ahb_spi1", "ahb_spi2", "ahb_spi3",
  80:             "ahb_pata", "ahb_sata", "ahb_gps", "ahb_ve",
  81:             "ahb_tvd", "ahb_tve0", "ahb_tve1", "ahb_lcd0",
  82:             "ahb_lcd1", "ahb_csi0", "ahb_csi1", "ahb_hdmi",
  83:             "ahb_de_be0", "ahb_de_be1", "ahb_de_fe0",
  84:             "ahb_de_fe1", "ahb_mp", "ahb_mali400";
  85:     };
  86:  
  87:     apb0: apb0@01c20054 {
  88:         #clock-cells = <0>;
  89:         compatible = "allwinner,sun4i-apb0-clk";
  90:         reg = <0x01c20054 0x4>;
  91:         clocks = <&ahb>;
  92:     };
  93:  
  94:     apb0_gates: apb0_gates@01c20068 {
  95:         #clock-cells = <1>;
  96:         compatible = "allwinner,sun4i-apb0-gates-clk";
  97:         reg = <0x01c20068 0x4>;
  98:         clocks = <&apb0>;
  99:         clock-output-names = "apb0_codec", "apb0_spdif",
 100:             "apb0_ac97", "apb0_iis", "apb0_pio", "apb0_ir0",
 101:             "apb0_ir1", "apb0_keypad";
 102:     };
 103:  
 104:     /* dummy is pll62 */
 105:     apb1_mux: apb1_mux@01c20058 {
 106:         #clock-cells = <0>;
 107:         compatible = "allwinner,sun4i-apb1-mux-clk";
 108:         reg = <0x01c20058 0x4>;
 109:         clocks = <&osc24M>, <&dummy>, <&osc32k>;
 110:     };
 111:  
 112:     apb1: apb1@01c20058 {
 113:         #clock-cells = <0>;
 114:         compatible = "allwinner,sun4i-apb1-clk";
 115:         reg = <0x01c20058 0x4>;
 116:         clocks = <&apb1_mux>;
 117:     };
 118:  
 119:     apb1_gates: apb1_gates@01c2006c {
 120:         #clock-cells = <1>;
 121:         compatible = "allwinner,sun4i-apb1-gates-clk";
 122:         reg = <0x01c2006c 0x4>;
 123:         clocks = <&apb1>;
 124:         clock-output-names = "apb1_i2c0", "apb1_i2c1",
 125:             "apb1_i2c2", "apb1_can", "apb1_scr",
 126:             "apb1_ps20", "apb1_ps21", "apb1_uart0",
 127:             "apb1_uart1", "apb1_uart2", "apb1_uart3",
 128:             "apb1_uart4", "apb1_uart5", "apb1_uart6",
 129:             "apb1_uart7";
 130:     };
 131: };

osc24M和osc32k是两个root clock，因此只做clock provider功能。它们的cells均为0，因为直接使用名字即可引用。另外，增加了“clock-frequency”自定义关键字，这样在板子使用的OSC频率改变时，如变为12M，不需要重新编译代码，只需更改DTS的频率即可（这不正是Device Tree的核心思想吗！）。话说回来了，osc24M的命名不是很好，如果频率改变，名称也得改吧，clock consumer的引用也得改吧；

pll1即是clock provider（cell为0，直接用名字引用），也是clock consumer（clocks关键字，指定输入clock为“osc24M”）；

再看一个复杂一点的，ahb_gates，它是clock provider（cell为1），通过clock-output-names关键字，描述所有的输出时钟。同时它也是clock consumer（由clocks关键字可知输入clock为“ahb”）。需要注意的是，clock-output-names关键字只为了方便clock provider编程方便（后面会讲），clock consumer不能使用（或者可理解为不可见）；

也许您会问，这些DTS描述，怎么使用？怎么和代码关联起来？先不着急，我们慢慢看。

2.2 clock consumer的DTS

在2.1中的方法二，我们已经看到clock consumer的DTS了，因为很多clock provider也是clock consumer。这里再举几个例子，做进一步说明。

例子1（对应2.1中的方式1，来自同一个DTS文件）：

   1: /* arch/arm/boot/dts/exynos4210.dtsi */
   2: mct@10050000 {
   3:         compatible = "samsung,exynos4210-mct";
   4:         ...
   5:         clocks = <&clock 3>, <&clock 344>;
   6:         clock-names = "fin_pll", "mct";
   7:         ...
   8: };

clocks，指明该设备的clock列表，clk_get时，会以它为关键字，去device_node中搜索，以得到对应的struct clk指针；

clocks需要指明的信息，由clock provider的“#clock-cells”规定：为0时，只需要提供一个clock provider name（称作phandle）；为1时，表示phandle有多个输出，则需要额外提供一个ID，指明具体需要使用那个输出。这个例子直接用立即数表示，更好的做法是，将系统所有clock的ID，定义在一个头文件中，而DTS可以包含这个头文件，如“clocks = <&clock CLK_SPI0>”；

clock-names，为clocks指定的那些clock分配一些易于使用的名字，driver可以直接以名字为参数，get clock的句柄（具体可参考“Linux common clock framework(1)_概述”中clk_get相关的接口描述）。

例子2，如果clock provider的“#clock-cells”为0，可直接引用该clock provider的名字，具体可参考2.1中的方式2。

例子3，2.1中方式2有一个clock provider的名字为apb0_gates，它的“#clock-cells”为1，并通过clock-output-names指定了所有的输出clock，那么，clock consumer怎么引用呢？如下（2和.1中的方式2，来自同一个DTS文件）：

   1: /* arch/arm/boot/dts/sun4i-a10.dtsi */
   2: soc@01c20000 {
   3:         compatible = "simple-bus";
   4:         ...
   5:  
   6:         pio: pinctrl@01c20800 {
   7:                 compatible = "allwinner,sun4i-a10-pinctrl";
   8:                 reg = <0x01c20800 0x400>;
   9:                 clocks = <&apb0_gates 5>;
  10:                 ...
  11:         }
  12: }

和例子1一样，指定phandle为“aph0_gates”，ID为5。

2.3 DTS相关的讨论和总结

我们在上面提到了clock provider的两种DTS定义方式，哪一种好呢？

从规范化、条理性的角度，毫无疑问方式2是好的，它真正理解了Device Tree的精髓，并细致的执行。且可以利用很多clock framework的标准实现（后面会讲）。

而方式1的优点是，DTS容易写，相应的clock driver也较为直观，只是注册一个一个clock provider即可，没有什么逻辑可言。换句话说，方式1比较懒。

后面的API描述，蜗蜗会着重从方式2的角度，因为这样才能体会到软件设计中的美学。

注1：上面例子中用到了两个公司的代码，方式1是三星的，方式2是全志的。说实话，全志的代码写的真漂亮，一个默默无闻的白牌公司，比三星这种国际大公司强多了。从这里，我们可以看到中国科技业的未来，还是很乐观的。

3. clock provider有关的API汇整

clock provider的API位于include/linux/clk_provider.h。

3.1 struct clk_hw

由“Linux common clock framework(1)_概述”可知，clock framework使用struct clk结构抽象clock，但该结构对clock consumer是透明的（不需要知道它的内部细节）。同样，struct clk对clock provider也是透明的。framework提供了struct clk_hw结构，从clock provider的角度，描述clock，该结构的定义如下：

   1: struct clk_hw {
   2:         struct clk *clk;
   3:         const struct clk_init_data *init;
   4: };

clk，struct clk指针，由clock framework分配并维护，并在需要时提供给clock consumer使用；

init，描述该clock的静态数据，clock provider负责把系统中每个clock的静态数据准备好，然后交给clock framework的核心逻辑，剩下的事情，clock provider就不用操心了。这个过程，就是clock driver的编写过程，简单吧？该静态数据的数据结构如下。

   1: struct clk_init_data {
   2:         const char              *name;
   3:         const struct clk_ops    *ops;
   4:         const char              **parent_names;
   5:         u8                      num_parents;
   6:         unsigned long           flags;
   7: };

name，该clock的名称；

ops，该clock相关的操作函数集，具体参考下面的描述；

parent_names，该clock所有的parent clock的名称。这是一个字符串数组，保存了所有可能的parent；

num_parents，parent的个数；

flags，一些framework级别的flags，后面会详细说明。

   1: struct clk_ops {
   2:         int             (*prepare)(struct clk_hw *hw);
   3:         void            (*unprepare)(struct clk_hw *hw);
   4:         int             (*is_prepared)(struct clk_hw *hw);
   5:         void            (*unprepare_unused)(struct clk_hw *hw);
   6:         int             (*enable)(struct clk_hw *hw);
   7:         void            (*disable)(struct clk_hw *hw);
   8:         int             (*is_enabled)(struct clk_hw *hw);
   9:         void            (*disable_unused)(struct clk_hw *hw);
  10:         unsigned long   (*recalc_rate)(struct clk_hw *hw,
  11:                                         unsigned long parent_rate);
  12:         long            (*round_rate)(struct clk_hw *hw, unsigned long,
  13:                                         unsigned long *);
  14:         int             (*set_parent)(struct clk_hw *hw, u8 index);
  15:         u8              (*get_parent)(struct clk_hw *hw);
  16:         int             (*set_rate)(struct clk_hw *hw, unsigned long,
  17:                                     unsigned long);
  18:         void            (*init)(struct clk_hw *hw);
  19: };

这是clock的操作函数集， 很多和“Linux common clock framework(1)_概述”中的clock framework通用API一致（通用API会直接调用相应的操作函数）：

is_prepared，判断clock是否已经prepared。可以不提供，clock framework core会维护一个prepare的计数（该计数在clk_prepare调用时加一，在clk_unprepare时减一），并依据该计数判断是否prepared；

unprepare_unused，自动unprepare unused clocks；

is_enabled，和is_prepared类似；

disable_unused，自动disable unused clocks；

注2：clock framework core提供一个clk_disable_unused接口，在系统初始化的late_call中调用，用于关闭unused clocks，这个接口会调用相应clock的.unprepare_unused和.disable_unused函数。

recalc_rate，以parent clock rate为参数，从新计算并返回clock rate；

注3：细心的读者可能会发现，该结构没有提供get_rate函数，因为会有一个rate变量缓存，另外可以使用recalc_rate。

round_rate，该接口有点特别，在返回rounded rate的同时，会通过一个指针，返回round后parent的rate。这和CLK_SET_RATE_PARENT flag有关，后面会详细解释；

init，clock的初始化接口，会在clock被register到内核时调用。

   1: /*
   2:  * flags used across common struct clk.  these flags should only affect the
   3:  * top-level framework.  custom flags for dealing with hardware specifics
   4:  * belong in struct clk_foo
   5:  */
   6: #define CLK_SET_RATE_GATE       BIT(0) /* must be gated across rate change */
   7: #define CLK_SET_PARENT_GATE     BIT(1) /* must be gated across re-parent */
   8: #define CLK_SET_RATE_PARENT     BIT(2) /* propagate rate change up one level */
   9: #define CLK_IGNORE_UNUSED       BIT(3) /* do not gate even if unused */
  10: #define CLK_IS_ROOT             BIT(4) /* root clk, has no parent */
  11: #define CLK_IS_BASIC            BIT(5) /* Basic clk, can't do a to_clk_foo() */
  12: #define CLK_GET_RATE_NOCACHE    BIT(6) /* do not use the cached clk rate */

上面是framework级别的flags，可以使用或的关系，指定多个flags，解释如下：

CLK_SET_RATE_GATE，表示在改变该clock的rate时，必须gated（关闭）；
CLK_SET_PARENT_GATE，表示在改变该clock的parent时，必须gated（关闭）；
CLK_SET_RATE_PARENT，表示改变该clock的rate时，要将该改变传递到上层parent（下面再详细说明）；
CLK_IGNORE_UNUSED，忽略disable unused的调用；
CLK_IS_ROOT，该clock为root clock，没有parent；
CLK_IS_BASIC，不再使用了；
CLK_GET_RATE_NOCACHE，get rate时，不要从缓存中拿，而是从新计算。

注4：round_rate和CLK_SET_RATE_PARENT
当clock consumer调用clk_round_rate获取一个近似的rate时，如果该clock没有提供.round_rate函数，有两种方法：
1）在没有设置CLK_SET_RATE_PARENT标志时，直接返回该clock的cache rate
2）如果设置了CLK_SET_RATE_PARENT标志，则会询问parent，即调用clk_round_rate获取parent clock能提供的、最接近该rate的值。这是什么意思呢？也就是说，如果parent clock可以得到一个近似的rate值，那么通过改变parent clock，就能得到所需的clock。
在后续的clk_set_rate接口中，会再次使用该flag，如果置位，则会在设置rate时，传递到parent clock，因此parent clock的rate可能会重设。
讲的很拗口，我觉得我也没说清楚，那么最好的方案就是：在写clock driver时，最好不用这个flag，简单的就是最好的（前提是能满足需求）。

3.2 clock tree建立相关的API

3.2.1 clk_register

系统中，每一个clock都有一个struct clk_hw变量描述，clock provider需要使用register相关的接口，将这些clock注册到kernel，clock framework的核心代码会把它们转换为struct clk变量，并以tree的形式组织起来。这些接口的原型如下：

   1: /**
   2:  * clk_register - allocate a new clock, register it and return an opaque cookie
   3:  * @dev: device that is registering this clock
   4:  * @hw: link to hardware-specific clock data
   5:  *
   6:  * clk_register is the primary interface for populating the clock tree with new
   7:  * clock nodes.  It returns a pointer to the newly allocated struct clk which
   8:  * cannot be dereferenced by driver code but may be used in conjuction with the
   9:  * rest of the clock API.  In the event of an error clk_register will return an
  10:  * error code; drivers must test for an error code after calling clk_register.
  11:  */
  12: struct clk *clk_register(struct device *dev, struct clk_hw *hw);
  13: struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw);
  14:  
  15: void clk_unregister(struct clk *clk);
  16: void devm_clk_unregister(struct device *dev, struct clk *clk);

这些API比较简单（复杂的是怎么填充struct clk_hw变量），register接口接受一个填充好的struct clk_hw指针，将它转换为sruct clk结构，并根据parent的名字，添加到clock tree中。

不过，clock framework所做的远比这周到，它基于clk_register，又封装了其它接口，使clock provider在注册clock时，连struct clk_hw都不需要关心，而是直接使用类似人类语言的方式，下面继续。

3.2.2 clock分类及register

根据clock的特点，clock framework将clock分为fixed rate、gate、devider、mux、fixed factor、composite六类，每一类clock都有相似的功能、相似的控制方式，因而可以使用相同的逻辑s，统一处理，这充分体现了面向对象的思想。

1）fixed rate clock

这一类clock具有固定的频率，不能开关、不能调整频率、不能选择parent、不需要提供任何的clk_ops回调函数，是最简单的一类clock。

可以直接通过DTS配置的方式支持，clock framework core能直接从DTS中解出clock信息，并自动注册到kernel，不需要任何driver支持。

clock framework使用struct clk_fixed_rate结构抽象这一类clock，另外提供了一个接口，可以直接注册fixed rate clock，如下：

   1: /**
   2:  * struct clk_fixed_rate - fixed-rate clock
   3:  * @hw:         handle between common and hardware-specific interfaces
   4:  * @fixed_rate: constant frequency of clock
   5:  */
   6: struct clk_fixed_rate {
   7:         struct          clk_hw hw;
   8:         unsigned long   fixed_rate;
   9:         u8              flags;
  10: };
  11:  
  12: extern const struct clk_ops clk_fixed_rate_ops;
  13: struct clk *clk_register_fixed_rate(struct device *dev, const char *name,
  14:                 const char *parent_name, unsigned long flags,
  15:                 unsigned long fixed_rate);

clock provider一般不需要直接使用struct clk_fixed_rate结构，因为clk_register_fixed_rate接口是非常方便的；

clk_register_fixed_rate接口以clock name、parent name、fixed_rate为参数，创建一个具有固定频率的clock，该clock的clk_ops也是clock framework提供的，不需要provider关心；

如果使用DTS的话，clk_register_fixed_rate都不需要，直接在DTS中配置即可，后面会说明。

2）gate clock

这一类clock只可开关（会提供.enable/.disable回调），可使用下面接口注册：

   1: struct clk *clk_register_gate(struct device *dev, const char *name,
   2:                 const char *parent_name, unsigned long flags,
   3:                 void __iomem *reg, u8 bit_idx,
   4:                 u8 clk_gate_flags, spinlock_t *lock);

需要提供的参数包括：

name，clock的名称；

parent_name，parent clock的名称，没有的话可留空；

flags，可参考3.1中的说明；

reg，控制该clock开关的寄存器地址（虚拟地址）；

bit_idx，控制clock开关的bit位（是1开，还是0开，可通过下面gate特有的flag指定）；

clk_gate_flags，gate clock特有的flag，当前只有一种：CLK_GATE_SET_TO_DISABLE，clock开关控制的方式，如果置位，表示写1关闭clock，反之亦然；

lock，如果clock开关时需要互斥，可提供一个spinlock。

3）divider clock

这一类clock可以设置分频值（因而会提供.recalc_rate/.set_rate/.round_rate回调），可通过下面两个接口注册：

   1: struct clk *clk_register_divider(struct device *dev, const char *name,
   2:                 const char *parent_name, unsigned long flags,
   3:                 void __iomem *reg, u8 shift, u8 width,
   4:                 u8 clk_divider_flags, spinlock_t *lock);

该接口用于注册分频比规则的clock：

reg，控制clock分频比的寄存器；

shift，控制分频比的bit在寄存器中的偏移；

width，控制分频比的bit位数，默认情况下，实际的divider值是寄存器值加1。如果有其它例外，可使用下面的的flag指示；

clk_divider_flags，divider clock特有的flag，包括：

        CLK_DIVIDER_ONE_BASED，实际的divider值就是寄存器值（0是无效的，除非设置CLK_DIVIDER_ALLOW_ZERO flag）；
        CLK_DIVIDER_POWER_OF_TWO，实际的divider值是寄存器值得2次方；
        CLK_DIVIDER_ALLOW_ZERO，divider值可以为0（不改变，视硬件支持而定）。

如有需要其他分频方式，就需要使用另外一个接口，如下：

   1: struct clk *clk_register_divider_table(struct device *dev, const char *name,
   2:                 const char *parent_name, unsigned long flags,
   3:                 void __iomem *reg, u8 shift, u8 width,
   4:                 u8 clk_divider_flags, const struct clk_div_table *table,
   5:                 spinlock_t *lock);

该接口用于注册分频比不规则的clock，和上面接口比较，差别在于divider值和寄存器值得对应关系由一个table决定，该table的原型为：

struct clk_div_table {
        unsigned int    val;
        unsigned int    div;
};

其中val表示寄存器值，div表示分频值，它们的关系也可以通过clk_divider_flags改变。

4）mux clock

这一类clock可以选择多个parent，因为会实现.get_parent/.set_parent/.recalc_rate回调，可通过下面两个接口注册：

   1: struct clk *clk_register_mux(struct device *dev, const char *name,
   2:                 const char **parent_names, u8 num_parents, unsigned long flags,
   3:                 void __iomem *reg, u8 shift, u8 width,
   4:                 u8 clk_mux_flags, spinlock_t *lock);

该接口可注册mux控制比较规则的clock（类似divider clock）：

parent_names，一个字符串数组，用于描述所有可能的parent clock；

num_parents，parent clock的个数；

reg、shift、width，选择parent的寄存器、偏移、宽度，默认情况下，寄存器值为0时，对应第一个parent，依此类推。如有例外，可通过下面的flags，以及另外一个接口实现；

clk_mux_flags，mux clock特有的flag：

        CLK_MUX_INDEX_ONE，寄存器值不是从0开始，而是从1开始；
        CLK_MUX_INDEX_BIT，寄存器值为2的幂。

   1: struct clk *clk_register_mux_table(struct device *dev, const char *name,
   2:                 const char **parent_names, u8 num_parents, unsigned long flags,
   3:                 void __iomem *reg, u8 shift, u32 mask,
   4:                 u8 clk_mux_flags, u32 *table, spinlock_t *lock);

该接口通过一个table，注册mux控制不规则的clock，原理和divider clock类似，不再详细介绍。

5）fixed factor clock

这一类clock具有固定的factor（即multiplier和divider），clock的频率是由parent clock的频率，乘以mul，除以div，多用于一些具有固定分频系数的clock。由于parent clock的频率可以改变，因而fix factor clock也可该改变频率，因此也会提供.recalc_rate/.set_rate/.round_rate等回调。

可通过下面接口注册：

   1: struct clk *clk_register_fixed_factor(struct device *dev, const char *name,
   2:                 const char *parent_name, unsigned long flags,
   3:                 unsigned int mult, unsigned int div);

另外，这一类接口和fixed rateclock类似，不需要提供driver，只需要配置dts即可。

6）composite clock

顾名思义，就是mux、divider、gate等clock的组合，可通过下面接口注册：

   1: struct clk *clk_register_composite(struct device *dev, const char *name,
   2:                 const char **parent_names, int num_parents,
   3:                 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
   4:                 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
   5:                 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
   6:                 unsigned long flags);

看着有点复杂，但理解了上面1~5类clock，这里就只剩下苦力了，耐心一点，就可以了。

3.2.3 DTS相关的API

再回到第2章DTS相关的介绍，clock driver使用一个DTS node描述一个clock provider，而clock consumer则会使用类似“clocks = <&clock  32>, <&clock 45>;”的形式引用，clock framework会自行把这些抽象的数字转换成实际的struct clk结构，怎么做的呢？肯定离不开clock provider的帮助。

3.2.1和3.2.2小节所描述的regitser接口，负责把clocks抽象为一个一个的struct clock，与此同时，clock provider需要把这些struct clk结构保存起来，并调用clock framework的接口，将这些对应信息告知framework的OF模块，这样才可以帮助将clock consumer的DTS描述转换为struct clk结构。该接口如下：

   1: int of_clk_add_provider(struct device_node *np,
   2:                         struct clk *(*clk_src_get)(struct of_phandle_args *args,
   3:                                                    void *data),
   4:                         void *data);

np，device_node指针，clock provider在和自己的DTS匹配时获得；

clk_src_get，获取struct clk指针的回调函数，由clock provider根据实际的逻辑实现，参数说明如下：

        args，struct of_phandle_args类型的指针，由DTS在解析参数时传递。例如上面的“clocks = <&clock  32>, <&clock 45>;”，32、45就是通过这个指针传进来的；

        data，保存struct clk结构的指针，通常是一个数组，具体由provider决定。

data，和回调函数中的data意义相同，只是这里由provider提供，get时由clock framework core传递给回调函数。

对于常用的one cell clock provider（第2章的例子），clock framework core提供一个默认的会调用函数，如下：

   1: struct clk_onecell_data {
   2:         struct clk **clks;
   3:         unsigned int clk_num;
   4: };
   5: struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data);

其中data指针为struct clk_onecell_data结构，该结构提供了clk指针和clk_num的对应，clock provider在regitser clocks时，同时维护一个clk和num对应的数组，并调用of_clk_add_provider接口告知clock framework core即可。

4. 使用clock framework编写clock驱动的步骤

编写clock driver的步骤大概如下：

1）分析硬件的clock tree，按照上面所描述的分类，讲这些clock分类。

2）将clock tree在DTS中描述出来，需要注意以下几2点：

        a）对于fixed rate clocks，.compatible固定填充"fixed-clock"，并提供"clock-frequency"和"clock-output-names"关键字。之后不需要再driver中做任何处理，clock framework core会帮我们搞定一切。

        b）同样，对于fixed factor clock，.compatible为"fixed-factor-clock"，并提供"clock-div"、"clock-mult"和"clock-output-names"关键字。clock framework core会帮我们搞定一切。

        切记，尽量利用kernel已有资源，不要多写一行代码，简洁的就是美的！

3）对于不能由clock framework core处理的clock，需要在driver中使用struct of_device_id进行匹配，并在初始化时，调用OF模块，查找所有的DTS匹配项，并执行合适的regitser接口，注册clock。

4）注册clock的同时，将返回的struct clk指针，保存在一个数组中，并调用of_clk_add_provider接口，告知clock framework core。

5）最后，也是最重要的一点，多看kernel源代码，多模仿，多抄几遍，什么都熟悉了！

 

原创文章，转发请注明出处。蜗窝科技，www.wowotech.net。

标签: Linux framework clock provider dts

« 防冲突机制介绍 | arm64 linux移植»

评论：

Li Chen
2023-02-06 11:59
dts需要准确的描述硬件，如果SoC的所有clk相关setting都是放在一个module，比如clk module或者某个system controller，那么就应该放在一个node里，否则应该放在自己独立的node
回复
小希
2022-03-30 11:52
mux clock的parent选择只能通过回调函数.set_parent()来实现吗？
“reg、shift、width，选择parent的寄存器、偏移、宽度，默认情况下，寄存器值为0时，对应第一个parent，依此类推。”这句话怎么理解呀？不就是通过给寄存器赋值来实现选择哪个时钟源吗？寄存器值为0时，对应第一个parent，这里的寄存器值0是怎么获取的，寄存器默认的复位值，还是通过什么方式给寄存器赋值为0呢？
@wowo @各位大神
回复
pxpxx
2020-06-17 11:48
不是很认同方式2比方式1好，我的理解是因为时钟树是固定的，不会变化，所以没必要在设备树中分开定义，设备树只定义可能有变化的情况就可以了。现在5.x的内核都是采用方式1的形式，全志的芯片也改成方式1了。
回复
xilinx-zynq
2020-04-17 13:05
clock-names = "s_axi_lite_aclk m_axi_mm2s_aclk m_axis_mm2s_aclk";
                        clocks = <0x1 0x12 0x1 0x10 0x6 0x1 0x10 0x6>;
这种clock配置怎么理解？
回复
zaixi
2018-03-10 16:49
CLK_DIVIDER_ONE_BASED，实际的divider值就是寄存器值

这里有笔误，应该是实际值加上1
回复
zaixi
2018-03-10 16:57
@zaixi：sorry，没问题，是我自己看错了
回复
小亮
2017-10-10 14:45
@wowo 现在内核又加入了 fractional-divider 类型的clock支持。
http://www.spinics.net/lists/u-boot-v2/msg22600.html，这是加入该类型clock的patch链接
回复
wowo
2017-10-10 16:34
@小亮：多谢分享。能否帮忙解释一下这种类型的clock的涵义以及应用场景呢？
回复
wink
2016-12-06 14:58
看到了我司的代码 ^_^
回复
wowo
2016-12-06 17:04
@wink：哈哈～～
回复
jim
2016-09-08 14:01
"注1：上面例子中用到了两个公司的代码，方式1是三星的，方式2是全志的。说实话，全志的代码写的真漂亮，一个默默无闻的白牌公司，比三星这种国际大公司强多了。从这里，我们可以看到中国科技业的未来，还是很乐观的。"
全志的code并不全是自己写的，很大一部分都是外包给free electrons的，比如下面这个ppt的上就写着，链接：
http://events.linuxfoundation.org/sites/events/files/slides/ripard-dmaengine.pdf
我还在很多其他地方的ppt中看到过类似的owner维护sunxi soc的信息，就不一一列举了
回复
wowo
2016-09-08 18:19
@jim：确实如此，我也是后来才知道的，呵呵~~~
回复
Renkangshuo
2016-09-01 17:43
现在正在学习linux clock subsystem ，看了您的博客， 受益很大， 谢谢您！！！！
回复
wowo
2016-09-02 08:45
@Renkangshuo：不客气，希望可以多交流~~~
回复
ooonebook
2016-08-26 14:45
之前看高通clock框架的时候，看这篇文章感觉差异挺大，就没细看。
现在在移植tiny210的过程发现开机过程中获取PLL的频率出来都是0导致crash，
看了一下代码懵圈了，再来看这篇文章，瞬间理解了好多~膜拜一下wowo~哈哈
回复
wowo
2016-08-26 15:26
@ooonebook：结合实际的需求去看代码，效果才是比较好的~~~
回复

发表评论：

Copyright @ 2013-2015 蜗窝科技 All rights reserved. Powered by emlog