Comprendre en un seul article le sous-système d'horloge Linux

Horloge L'horloge est l'impulsion du SoC, qui contrôle chaque composant pour qu'il fonctionne à son propre rythme. Par exemple, le réglage de la fréquence du processeur, le réglage du débit en bauds du port série, le réglage du taux d'échantillonnage I2S, le réglage du débit I2C, etc. Ces différents réglages d'horloge doivent provenir d'une ou plusieurs sources d'horloge, et former finalement un arbre d'horloge. Vous pouvez afficher cette arborescence d'horloge via la commande cat /sys/kernel/debug/clk/clk_summary.

Le framework CCF est utilisé dans le noyau pour gérer les horloges. Comme le montre la figure ci-dessous, le côté droit est le fournisseur d'horloge, c'est-à-dire le fournisseur d'horloge ; le côté gauche est le consommateur d'horloge du pilote de périphérique, c'est-à-dire le consommateur d'horloge.

Fournisseur d'horloge

• Le nœud racine est généralement un oscillateur (oscillateur actif) ou un cristal (oscillateur passif).
• Il existe de nombreux types de nœuds intermédiaires, notamment PLL (boucle à verrouillage de phase, utilisée pour augmenter la fréquence), Divider (diviseur de fréquence, utilisé pour réduire la fréquence), Mux (sélectionnez-en un parmi plusieurs chemins d'horloge), Gate (utilisé pour contrôler ON/ DÉSACTIVÉ).
• Les nœuds feuilles sont des blocs matériels dotés de fonctions spécifiques qui utilisent l'horloge comme entrée.

Selon les caractéristiques de l'horloge, le cadre de l'horloge divise l'horloge en six catégories : taux fixe, porte, devise, multiplexeur, facteur fixe et composite.

Structure des données

Les six catégories ci-dessus sont essentiellement des périphériques d'horloge. Le noyau extrait les caractéristiques de ces blocs matériels d'horloge et utilise la struct clk_hw pour les représenter, comme suit :

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

Prenons l'exemple du vibrateur à taux fixe. Sa structure de données est :

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

C’est probablement le cas pour d’autres appareils d’horloge spécifiques, je n’entrerai donc pas dans les détails ici.

Voici une image décrivant la relation entre ces structures de données :

Méthode d'inscription

Maintenant que nous comprenons la structure des données, examinons la méthode d'enregistrement de chaque type d'appareil d'horloge.

1. horloge à taux fixe

Ce type d'horloge a une fréquence fixe. Elle ne peut pas être allumée ou éteinte, la fréquence ne peut pas être ajustée et le parent ne peut pas être sélectionné. Il peut être pris en charge directement via la configuration DTS. Vous pouvez également enregistrer une horloge à débit fixe directement via l'interface, comme suit :

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. horloge de porte

Ce type d'horloge ne peut être activé et désactivé (des rappels .enable/.disable seront fournis), et vous pouvez utiliser l'interface suivante pour vous inscrire :

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. horloge diviseuse

Ce type d'horloge peut définir la valeur de division de fréquence (fournissant ainsi des rappels .recalc_rate/.set_rate/.round_rate) et peut être enregistré via les deux interfaces suivantes :

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. horloge multiplex

Ce type d'horloge peut sélectionner plusieurs parents car il implémentera le rappel .get_parent/.set_parent/.recalc_rate et peut être enregistré via les deux interfaces suivantes :

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. horloge à facteur fixe

Ce type d'horloge a un facteur fixe (c'est-à-dire un multiplicateur et un diviseur). La fréquence de l'horloge est la fréquence de l'horloge parent, multipliée par mul et divisée par div. Elle est principalement utilisée pour certaines horloges avec des coefficients de division de fréquence fixes. . Étant donné que la fréquence de l'horloge parent peut être modifiée, la fréquence de l'horloge à facteur fixe peut également être modifiée, donc des rappels tels que .recalc_rate/.set_rate/.round_rate sont également fournis. Vous pouvez vous inscrire via l'interface suivante :

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. horloge composite

Comme son nom l'indique, il s'agit d'une combinaison d'horloges telles qu'un multiplexeur, un diviseur, une porte, etc., qui peuvent être enregistrées via l'interface suivante :

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

Ces fonctions d'enregistrement seront éventuellement enregistrées dans le Common Clock Framework via la fonction clk_register, renvoyant un pointeur struct clk. Comme indiqué ci-dessous :

Ensuite, enregistrez le pointeur struct clk renvoyé dans un tableau et appelez l'interface of_clk_add_provider pour informer le Common Clock Framework.

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)

总结

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!