In einem Artikel verstehen |. Linux-Uhr-Subsystem

Uhr Die Uhr ist der Impuls im SoC, der jede Komponente so steuert, dass sie in ihrem eigenen Tempo läuft. Zum Beispiel CPU-Frequenzeinstellung, Einstellung der Baudrate der seriellen Schnittstelle, Einstellung der I2S-Abtastrate, Einstellung der I2C-Rate usw. Diese unterschiedlichen Takteinstellungen müssen von einer oder mehreren Taktquellen stammen und letztendlich einen Taktbaum bilden. Sie können diesen Uhrenbaum über den Befehl cat /sys/kernel/debug/clk/clk_summary anzeigen.

Das CCF-Framework wird im Kernel zur Verwaltung von Uhren verwendet. Wie in der Abbildung unten gezeigt, ist die rechte Seite der Taktgeber, also der Taktgeber, und die linke Seite ist der Taktgeber des Gerätetreibers, also der Taktgeber.

Uhrenanbieter

• Der Wurzelknoten ist normalerweise ein Oszillator (aktiver Oszillator) oder Quarz (passiver Oszillator).
• Es gibt viele Arten von Zwischenknoten, darunter PLL (Phasenregelkreis, zur Frequenzerhöhung), Divider (Frequenzteiler, zur Frequenzreduzierung), Mux (Auswahl eines aus mehreren Taktpfaden), Gate (zur Steuerung von ON/ AUS).
• Blattknoten sind HW-Blöcke mit spezifischen Funktionen, die den Takt als Eingabe verwenden.

Entsprechend den Eigenschaften der Uhr unterteilt das Uhr-Framework die Uhr in sechs Kategorien: feste Rate, Gate, Entwickler, Mux, fester Faktor und zusammengesetzt.

Datenstruktur

Die oben genannten sechs Kategorien sind im Wesentlichen Taktgeräte. Der Kernel extrahiert die Eigenschaften dieser Takt-HW-Blöcke und verwendet die Struktur clk_hw, um sie wie folgt darzustellen:

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;
};

Nehmen Sie den Vibrator mit fester Frequenz als Beispiel. Seine Datenstruktur ist:

struct clk_fixed_rate {
  //下面是fixed rate这种clock device特有的成员
  struct        clk_hw hw；
  //基类
  unsigned long    fixed_rate;
  unsigned long    fixed_accuracy;
  u8        flags;
};

Dies ist wahrscheinlich bei anderen spezifischen Uhrengeräten der Fall, daher werde ich hier nicht auf Details eingehen.

Hier ist ein Bild, das die Beziehung zwischen diesen Datenstrukturen beschreibt:

Registrierungsmethode

Da wir nun die Datenstruktur verstanden haben, schauen wir uns die Registrierungsmethode jedes Uhrentyps an.

1. Festpreisuhr

Diese Art von Uhr hat eine feste Frequenz. Sie kann nicht ein- oder ausgeschaltet werden, die Frequenz kann nicht angepasst werden und die übergeordnete Uhr ist nicht wählbar. Es kann direkt über die DTS-Konfiguration unterstützt werden. Sie können eine Uhr mit festem Takt auch direkt über die Schnittstelle registrieren, wie folgt:

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);

2. Toruhr

Diese Art von Uhr kann nur ein- und ausgeschaltet werden (.enable/.disable-Rückrufe werden bereitgestellt), und Sie können die folgende Schnittstelle zur Registrierung verwenden:

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

3. Teileruhr

Diese Art von Uhr kann den Frequenzteilungswert festlegen (und somit .recalc_rate/.set_rate/.round_rate-Rückrufe bereitstellen) und kann über die folgenden zwei Schnittstellen registriert werden:

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

4. Mux-Uhr

Diese Art von Uhr kann mehrere Eltern auswählen, da sie den Rückruf .get_parent/.set_parent/.recalc_rate implementiert und über die folgenden zwei Schnittstellen registriert werden kann:

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

5. Uhr mit festem Faktor

Diese Art von Uhr hat einen festen Faktor (d. h. Multiplikator und Teiler). Die Frequenz der Uhr ist die Frequenz der übergeordneten Uhr, multipliziert mit mul und dividiert durch div. Sie wird hauptsächlich für einige Uhren mit festen Frequenzteilungskoeffizienten verwendet . Da die Frequenz der übergeordneten Uhr geändert werden kann, kann auch die Frequenz der Uhr mit festem Faktor geändert werden, sodass auch Rückrufe wie .recalc_rate/.set_rate/.round_rate bereitgestellt werden. Sie können sich über die folgende Schnittstelle registrieren:

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

6. Verbunduhr

Wie der Name schon sagt, handelt es sich um eine Kombination aus Mux, Divider, Gate und anderen Uhren. Sie kann über die folgende Schnittstelle registriert werden:

struct clk *clk_register_composite(struct device *dev, const char *name,
                const char **parent_names, int num_parents,
                struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
                struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
                struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
                unsigned long flags);

Diese Registrierungsfunktionen werden schließlich im Common Clock Framework über die Funktion clk_register registriert und geben einen Struktur-Clk-Zeiger zurück. Wie unten gezeigt:

Speichern Sie dann den zurückgegebenen struct clk-Zeiger in einem Array und rufen Sie die Schnittstelle of_clk_add_provider auf, um das Common Clock Framework zu informieren.

Clock Consumer

获取 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);
}
struct clk *of_clk_get(struct device_node *np, int index)
{
        struct of_phandle_args clkspec;
        struct clk *clk;
        int rc;
 
        if (index return ERR_PTR(-EINVAL);
 
        rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
                                        &clkspec);
        if (rc)
                return ERR_PTR(rc);
       //获取clock指针
        clk = of_clk_get_from_provider(&clkspec);
        of_node_put(clkspec.np);
        return clk;
}

of_clk_get_from_provider 通过便利 of_clk_providers 链表，并调用每一个 provider 的 get 回调函数，获取 clock 指针。如下：

struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
{
        struct of_clk_provider *provider;
        struct clk *clk = ERR_PTR(-ENOENT);
 
        /* Check if we have such a provider in our array */
        mutex_lock(&of_clk_lock);
        list_for_each_entry(provider, &of_clk_providers, link) {
                if (provider->node == clkspec->np)
                        clk = provider->get(clkspec, provider->data);
                if (!IS_ERR(clk))
                        break;
        }
        mutex_unlock(&of_clk_lock);
 
        return clk;
}

至此，Consumer 与 Provider 里讲的 of_clk_add_provider 对应起来了。

操作 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)

总结

Das obige ist der detaillierte Inhalt vonIn einem Artikel verstehen |. Linux-Uhr-Subsystem. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!