Linux common clock framework(3)_概述

1
   1: /* include/linux/clk-private.h */

1
   2: struct clk {

1
   3:         const char              *name;

1
   4:         const struct clk_ops    *ops;

1
   5:         struct clk_hw           *hw;

1
   6:         struct clk              *parent;

1
   7:         const char              **parent_names;

1
   8:         struct clk              **parents;

1
   9:         u8                      num_parents;

1
  10:         unsigned long           rate;

1
  11:         unsigned long           new_rate;

1
  12:         unsigned long           flags;

1
  13:         unsigned int            enable_count;

1
  14:         unsigned int            prepare_count;

1
  15:         struct hlist_head       children;

1
  16:         struct hlist_node       child_node;

1
  17:         unsigned int            notifier_count;

1
  18: #ifdef CONFIG_COMMON_CLK_DEBUG

1
  19:         struct dentry           *dentry;

1
  20: #endif

1
  21: };

1
   1: 1 F   f    clk_register      .archarmmach-at91clock.c

1
   2:              int __init clk_register(struct clk *clk)

1
   3: 2 F   v    clk_register      .archarmmach-davinciclock.c

1
   4:              EXPORT_SYMBOL(clk_register);

1
   5: 3 F   f    clk_register      .archarmmach-davinciclock.c

1
   6:              int clk_register(struct clk *clk)

1
   7: 4 F   v    clk_register      .archarmmach-omap1clock.c

1
   8:              EXPORT_SYMBOL(clk_register);

1
   9: 5 F   f    clk_register      .archarmmach-omap1clock.c

1
  10:              int clk_register(struct clk *clk)

1
  11: 6 F   v    clk_register      .archc6xplatformspll.c

1
  12:              EXPORT_SYMBOL(clk_register);

1
  13: 7 F   f    clk_register      .archc6xplatformspll.c

1
  14:              int clk_register(struct clk *clk)

1
  15: 8 F   v    clk_register      .archunicore32kernelclock.c

1
  16:              EXPORT_SYMBOL(clk_register);

1
  17: 9 F   f    clk_register      .archunicore32kernelclock.c

1
  18:              int clk_register(struct clk *clk)

1
  19: 0 F   v    clk_register      .driversclkclk.c

1
  20:              EXPORT_SYMBOL_GPL(clk_register);

1
  21: 1 F   f    clk_register      .driversclkclk.c

1
  22:              struct clk *clk_register(struct device *dev, struct clk_hw *hw)

1
  23: 2 F   v    clk_register      .driversshclkcore.c

1
  24:              EXPORT_SYMBOL_GPL(clk_register);

1
  25: 3 F   f    clk_register      .driversshclkcore.c

1
  26:              int clk_register(struct clk *clk)

1
   1: /**

1
   2:  * clk_register - allocate a new clock, register it and return an opaque cookie

1
   3:  * @dev: device that is registering this clock

1
   4:  * @hw: link to hardware-specific clock data

1
   5:  *

1
   6:  * clk_register is the primary interface for populating the clock tree with new

1
   7:  * clock nodes.  It returns a pointer to the newly allocated struct clk which

1
   8:  * cannot be dereferenced by driver code but may be used in conjuction with the

1
   9:  * rest of the clock API.  In the event of an error clk_register will return an

1
  10:  * error code; drivers must test for an error code after calling clk_register.

1
  11:  */

1
  12: struct clk *clk_register(struct device *dev, struct clk_hw *hw)

1
  13: {

1
  14:     int i, ret;

1
  15:     struct clk *clk;

1
  16: 

1
  17:     clk = kzalloc(sizeof(*clk), GFP_KERNEL);

1
  18:     if (!clk) {

1
  19:         pr_err("%s: could not allocate clkn", __func__);

1
  20:         ret = -ENOMEM;

1
  21:         goto fail_out;

1
  22:     }

1
  23: 

1
  24:     clk->name = kstrdup(hw->init->name, GFP_KERNEL);

1
  25:     if (!clk->name) {

1
  26:         pr_err("%s: could not allocate clk->namen", __func__);

1
  27:         ret = -ENOMEM;

1
  28:         goto fail_name;

1
  29:     }

1
  30:     clk->ops = hw->init->ops;

1
  31:     if (dev && dev->driver)

1
  32:         clk->owner = dev->driver->owner;

1
  33:     clk->hw = hw;

1
  34:     clk->flags = hw->init->flags;

1
  35:     clk->num_parents = hw->init->num_parents;

1
  36:     hw->clk = clk;

1
  37: 

1
  38:     /* allocate local copy in case parent_names is __initdata */

1
  39:     clk->parent_names = kcalloc(clk->num_parents, sizeof(char *),

1
  40:                     GFP_KERNEL);

1
  41: 

1
  42:     if (!clk->parent_names) {

1
  43:         pr_err("%s: could not allocate clk->parent_namesn", __func__);

1
  44:         ret = -ENOMEM;

1
  45:         goto fail_parent_names;

1
  46:     }

1
  47: 

1
  48: 

1
  49:     /* copy each string name in case parent_names is __initdata */

1
  50:     for (i = 0; i < clk->num_parents; i++) {

1
  51:         clk->parent_names[i] = kstrdup(hw->init->parent_names[i],

1
  52:                         GFP_KERNEL);

1
  53:         if (!clk->parent_names[i]) {

1
  54:             pr_err("%s: could not copy parent_namesn", __func__);

1
  55:             ret = -ENOMEM;

1
  56:             goto fail_parent_names_copy;

1
  57:         }

1
  58:     }

1
  59: 

1
  60:     ret = __clk_init(dev, clk);

1
  61:     if (!ret)

1
  62:         return clk;

1
  63: 

1
  64: fail_parent_names_copy:

1
  65:     while (--i >= 0)

1
  66:         kfree(clk->parent_names[i]);

1
  67:     kfree(clk->parent_names);

1
  68: fail_parent_names:

1
  69:     kfree(clk->name);

1
  70: fail_name:

1
  71:     kfree(clk);

1
  72: fail_out:

1
  73:     return ERR_PTR(ret);

1
  74: }

1
  75: EXPORT_SYMBOL_GPL(clk_register);

1
   1: /**

1
   2:  * __clk_init - initialize the data structures in a struct clk

1
   3:  * @dev:    device initializing this clk, placeholder for now

1
   4:  * @clk:    clk being initialized

1
   5:  *

1
   6:  * Initializes the lists in struct clk, queries the hardware for the

1
   7:  * parent and rate and sets them both.

1
   8:  */

1
   9: int __clk_init(struct device *dev, struct clk *clk)

1
  10: {

1
  11:     int i, ret = 0;

1
  12:     struct clk *orphan;

1
  13:     struct hlist_node *tmp2;

1
  14: 

1
  15:     if (!clk)

1
  16:         return -EINVAL;

1
  17: 

1
  18:     clk_prepare_lock();

1
  19: 

1
  20:     /* check to see if a clock with this name is already registered */

1
  21:     if (__clk_lookup(clk->name)) {

1
  22:         pr_debug("%s: clk %s already initializedn",

1
  23:                 __func__, clk->name);

1
  24:         ret = -EEXIST;

1
  25:         goto out;

1
  26:     }

1
  27: 

1
  28:     /* check that clk_ops are sane.  See Documentation/clk.txt */

1
  29:     if (clk->ops->set_rate &&

1
  30:             !(clk->ops->round_rate && clk->ops->recalc_rate)) {

1
  31:         pr_warning("%s: %s must implement .round_rate & .recalc_raten",

1
  32:                 __func__, clk->name);

1
  33:         ret = -EINVAL;

1
  34:         goto out;

1
  35:     }

1
  36: 

1
  37:     if (clk->ops->set_parent && !clk->ops->get_parent) {

1
  38:         pr_warning("%s: %s must implement .get_parent & .set_parentn",

1
  39:                 __func__, clk->name);

1
  40:         ret = -EINVAL;

1
  41:         goto out;

1
  42:     }

1
  43: 

1
  44:     /* throw a WARN if any entries in parent_names are NULL */

1
  45:     for (i = 0; i < clk->num_parents; i++)

1
  46:         WARN(!clk->parent_names[i],

1
  47:                 "%s: invalid NULL in %s's .parent_namesn",

1
  48:                 __func__, clk->name);

1
  49: 

1
  50:     /*

1
  51:      * Allocate an array of struct clk *'s to avoid unnecessary string

1
  52:      * look-ups of clk's possible parents.  This can fail for clocks passed

1
  53:      * in to clk_init during early boot; thus any access to clk->parents[]

1
  54:      * must always check for a NULL pointer and try to populate it if

1
  55:      * necessary.

1
  56:      *

1
  57:      * If clk->parents is not NULL we skip this entire block.  This allows

1
  58:      * for clock drivers to statically initialize clk->parents.

1
  59:      */

1
  60:     if (clk->num_parents > 1 && !clk->parents) {

1
  61:         clk->parents = kzalloc((sizeof(struct clk*) * clk->num_parents),

1
  62:                 GFP_KERNEL);

1
  63:         /*

1
  64:          * __clk_lookup returns NULL for parents that have not been

1
  65:          * clk_init'd; thus any access to clk->parents[] must check

1
  66:          * for a NULL pointer.  We can always perform lazy lookups for

1
  67:          * missing parents later on.

1
  68:          */

1
  69:         if (clk->parents)

1
  70:             for (i = 0; i < clk->num_parents; i++)

1
  71:                 clk->parents[i] =

1
  72:                     __clk_lookup(clk->parent_names[i]);

1
  73:     }

1
  74: 

1
  75:     clk->parent = __clk_init_parent(clk);

1
  76: 

1
  77:     /*

1
  78:      * Populate clk->parent if parent has already been __clk_init'd.  If

1
  79:      * parent has not yet been __clk_init'd then place clk in the orphan

1
  80:      * list.  If clk has set the CLK_IS_ROOT flag then place it in the root

1
  81:      * clk list.

1
  82:      *

1
  83:      * Every time a new clk is clk_init'd then we walk the list of orphan

1
  84:      * clocks and re-parent any that are children of the clock currently

1
  85:      * being clk_init'd.

1
  86:      */

1
  87:     if (clk->parent)

1
  88:         hlist_add_head(&clk->child_node,

1
  89:                 &clk->parent->children);

1
  90:     else if (clk->flags & CLK_IS_ROOT)

1
  91:         hlist_add_head(&clk->child_node, &clk_root_list);

1
  92:     else

1
  93:         hlist_add_head(&clk->child_node, &clk_orphan_list);

1
  94: 

1
  95:     /*

1
  96:      * Set clk's rate.  The preferred method is to use .recalc_rate.  For

1
  97:      * simple clocks and lazy developers the default fallback is to use the

1
  98:      * parent's rate.  If a clock doesn't have a parent (or is orphaned)

1
  99:      * then rate is set to zero.

1
 100:      */

1
 101:     if (clk->ops->recalc_rate)

1
 102:         clk->rate = clk->ops->recalc_rate(clk->hw,

1
 103:                 __clk_get_rate(clk->parent));

1
 104:     else if (clk->parent)

1
 105:         clk->rate = clk->parent->rate;

1
 106:     else

1
 107:         clk->rate = 0;

1
 108: 

1
 109:     /*

1
 110:      * walk the list of orphan clocks and reparent any that are children of

1
 111:      * this clock

1
 112:      */

1
 113:     hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {

1
 114:         if (orphan->ops->get_parent) {

1
 115:             i = orphan->ops->get_parent(orphan->hw);

1
 116:             if (!strcmp(clk->name, orphan->parent_names[i]))

1
 117:                 __clk_reparent(orphan, clk);

1
 118:             continue;

1
 119:         }

1
 120: 

1
 121:         for (i = 0; i < orphan->num_parents; i++)

1
 122:             if (!strcmp(clk->name, orphan->parent_names[i])) {

1
 123:                 __clk_reparent(orphan, clk);

1
 124:                 break;

1
 125:             }

1
 126:      }

1
 127: 

1
 128:     /*

1
 129:      * optional platform-specific magic

1
 130:      *

1
 131:      * The .init callback is not used by any of the basic clock types, but

1
 132:      * exists for weird hardware that must perform initialization magic.

1
 133:      * Please consider other ways of solving initialization problems before

1
 134:      * using this callback, as it's use is discouraged.

1
 135:      */

1
 136:     if (clk->ops->init)

1
 137:         clk->ops->init(clk->hw);

1
 138: 

1
 139:     clk_debug_register(clk);

1
 140: 

1
 141: out:

1
 142:     clk_prepare_unlock();

1
 143: 

1
 144:     return ret;

1
 145: }

1
   1: struct clk *clk_register_fixed_rate(struct device *dev, const char *name,

1
   2:                 const char *parent_name, unsigned long flags,

1
   3:                 unsigned long fixed_rate)

1
   4: {

1
   5:         struct clk_fixed_rate *fixed;

1
   6:         struct clk *clk;

1
   7:         struct clk_init_data init;

1
   8: 

1
   9:         /* allocate fixed-rate clock */

1
  10:         fixed = kzalloc(sizeof(struct clk_fixed_rate), GFP_KERNEL);

1
  11:         if (!fixed) {

1
  12:                 pr_err("%s: could not allocate fixed clkn", __func__);

1
  13:                 return ERR_PTR(-ENOMEM);

1
  14:         }

1
  15: 

1
  16:         init.name = name;

1
  17:         init.ops = &clk_fixed_rate_ops;

1
  18:         init.flags = flags | CLK_IS_BASIC;

1
  19:         init.parent_names = (parent_name ? &parent_name: NULL);

1
  20:         init.num_parents = (parent_name ? 1 : 0);

1
  21: 

1
  22:         /* struct clk_fixed_rate assignments */

1
  23:         fixed->fixed_rate = fixed_rate;

1
  24:         fixed->hw.init = &init;

1
  25: 

1
  26:         /* register the clock */

1
  27:         clk = clk_register(dev, &fixed->hw);

1
  28: 

1
  29:         if (IS_ERR(clk))

1
  30:                 kfree(fixed);

1
  31: 

1
  32:         return clk;

1
  33: }

1
   1: struct clk_fixed_rate {

1
   2:         struct          clk_hw hw;

1
   3:         unsigned long   fixed_rate;

1
   4:         u8              flags;

1
   5: };

1
   1: #define to_clk_fixed_rate(_hw) container_of(_hw, struct clk_fixed_rate, hw)

1
   2: 

1
   3: static unsigned long clk_fixed_rate_recalc_rate(struct clk_hw *hw,

1
   4:                 unsigned long parent_rate)

1
   5: {

1
   6:         return to_clk_fixed_rate(hw)->fixed_rate;

1
   7: }

1
   8: 

1
   9: const struct clk_ops clk_fixed_rate_ops = {

1
  10:         .recalc_rate = clk_fixed_rate_recalc_rate,

1
  11: };

1
  12: EXPORT_SYMBOL_GPL(clk_fixed_rate_ops);

1
   1: #ifdef CONFIG_OF

1
   2: /**

1
   3:  * of_fixed_clk_setup() - Setup function for simple fixed rate clock

1
   4:  */

1
   5: void of_fixed_clk_setup(struct device_node *node)

1
   6: {

1
   7:         struct clk *clk;

1
   8:         const char *clk_name = node->name;

1
   9:         u32 rate;

1
  10: 

1
  11:         if (of_property_read_u32(node, "clock-frequency", &rate))

1
  12:                 return;

1
  13: 

1
  14:         of_property_read_string(node, "clock-output-names", &clk_name);

1
  15: 

1
  16:         clk = clk_register_fixed_rate(NULL, clk_name, NULL, CLK_IS_ROOT, rate);

1
  17:         if (!IS_ERR(clk))

1
  18:                 of_clk_add_provider(node, of_clk_src_simple_get, clk);

1
  19: }

1
  20: EXPORT_SYMBOL_GPL(of_fixed_clk_setup);

1
  21: CLK_OF_DECLARE(fixed_clk, "fixed-clock", of_fixed_clk_setup);

1
  22: #endif

1
   1: /* drivers/clk/clk.c */

1
   2: /**

1
   3:  * of_clk_init() - Scan and init clock providers from the DT

1
   4:  * @matches: array of compatible values and init functions for providers.

1
   5:  *

1
   6:  * This function scans the device tree for matching clock providers and

1
   7:  * calls their initialization functions

1
   8:  */

1
   9: void __init of_clk_init(const struct of_device_id *matches)

1
  10: {

1
  11:         struct device_node *np;

1
  12: 

1
  13:         if (!matches)

1
  14:                 matches = __clk_of_table;

1
  15: 

1
  16:         for_each_matching_node(np, matches) {

1
  17:                 const struct of_device_id *match = of_match_node(matches, np);

1
  18:                 of_clk_init_cb_t clk_init_cb = match->data;

1
  19:                 clk_init_cb(np);

1
  20:         }

1
  21: }

1
   1: struct clk *clk_get(struct device *dev, const char *con_id)

1
   2: {

1
   3:         const char *dev_id = dev ? dev_name(dev) : NULL;

1
   4:         struct clk *clk;

1
   5: 

1
   6:         if (dev) {

1
   7:                 clk = of_clk_get_by_name(dev->of_node, con_id);

1
   8:                 if (!IS_ERR(clk) && __clk_get(clk))

1
   9:                         return clk;

1
  10:         }

1
  11: 

1
  12:         return clk_get_sys(dev_id, con_id);

1
  13: }

1
   1: struct clk *of_clk_get_by_name(struct device_node *np, const char *name)

1
   2: {

1
   3:         struct clk *clk = ERR_PTR(-ENOENT);

1
   4: 

1
   5:         /* Walk up the tree of devices looking for a clock that matches */

1
   6:         while (np) {

1
   7:                 int index = 0;

1
   8: 

1
   9:                 /*

1
  10:                  * For named clocks, first look up the name in the

1
  11:                  * "clock-names" property.  If it cannot be found, then

1
  12:                  * index will be an error code, and of_clk_get() will fail.

1
  13:                  */

1
  14:                 if (name)

1
  15:                         index = of_property_match_string(np, "clock-names", name);

1
  16:                 clk = of_clk_get(np, index);

1
  17:                 if (!IS_ERR(clk))

1
  18:                         break;

1
  19:                 else if (name && index >= 0) {

1
  20:                         pr_err("ERROR: could not get clock %s:%s(%i)n",

1
  21:                                 np->full_name, name ? name : "", index);

1
  22:                         return clk;

1
  23:                 }

1
  24: 

1
  25:                 /*

1
  26:                  * No matching clock found on this node.  If the parent node

1
  27:                  * has a "clock-ranges" property, then we can try one of its

1
  28:                  * clocks.

1
  29:                  */

1
  30:                 np = np->parent;

1
  31:                 if (np && !of_get_property(np, "clock-ranges", NULL))

1
  32:                         break;

1
  33:         }

1
  34: 

1
  35:         return clk;

1
  36: }

1
   1: struct clk *of_clk_get(struct device_node *np, int index)

1
   2: {

1
   3:         struct of_phandle_args clkspec;

1
   4:         struct clk *clk;

1
   5:         int rc;

1
   6: 

1
   7:         if (index < 0)

1
   8:                 return ERR_PTR(-EINVAL);

1
   9: 

1
  10:         rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,

1
  11:                                         &clkspec);

1
  12:         if (rc)

1
  13:                 return ERR_PTR(rc);

1
  14: 

1
  15:         clk = of_clk_get_from_provider(&clkspec);

1
  16:         of_node_put(clkspec.np);

1
  17:         return clk;

1
  18: }

1
   1: struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)

1
   2: {

1
   3:         struct of_clk_provider *provider;

1
   4:         struct clk *clk = ERR_PTR(-ENOENT);

1
   5: 

1
   6:         /* Check if we have such a provider in our array */

1
   7:         mutex_lock(&of_clk_lock);

1
   8:         list_for_each_entry(provider, &of_clk_providers, link) {

1
   9:                 if (provider->node == clkspec->np)

1
  10:                         clk = provider->get(clkspec, provider->data);

1
  11:                 if (!IS_ERR(clk))

1
  12:                         break;

1
  13:         }

1
  14:         mutex_unlock(&of_clk_lock);

1
  15: 

1
  16:         return clk;

1
  17: }

1
   1: int __clk_prepare(struct clk *clk)

1
   2: {

1
   3:         int ret = 0;

1
   4: 

1
   5:         if (!clk)

1
   6:                 return 0;

1
   7: 

1
   8:         if (clk->prepare_count == 0) {

1
   9:                 ret = __clk_prepare(clk->parent);

1
  10:                 if (ret)

1
  11:                         return ret;

1
  12: 

1
  13:                 if (clk->ops->prepare) {

1
  14:                         ret = clk->ops->prepare(clk->hw);

1
  15:                         if (ret) {

1
  16:                                 __clk_unprepare(clk->parent);

1
  17:                                 return ret;

1
  18:                         }

1
  19:                 }

1
  20:         }

1
  21: 

1
  22:         clk->prepare_count++;

1
  23: 

1
  24:         return 0;

1
  25: }

1
   1: /**

1
   2:  * clk_get_rate - return the rate of clk

1
   3:  * @clk: the clk whose rate is being returned

1
   4:  *

1
   5:  * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag

1
   6:  * is set, which means a recalc_rate will be issued.

1
   7:  * If clk is NULL then returns 0.

1
   8:  */

1
   9: unsigned long clk_get_rate(struct clk *clk)

1
  10: {

1
  11:         unsigned long rate;

1
  12: 

1
  13:         clk_prepare_lock();

1
  14: 

1
  15:         if (clk && (clk->flags & CLK_GET_RATE_NOCACHE))

1
  16:                 __clk_recalc_rates(clk, 0);

1
  17: 

1
  18:         rate = __clk_get_rate(clk);

1
  19:         clk_prepare_unlock();

1
  20: 

1
  21:         return rate;

1
  22: }

1
  23: EXPORT_SYMBOL_GPL(clk_get_rate);

1
   1: unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)

1
   2: {

1
   3:         unsigned long parent_rate = 0;

1
   4: 

1
   5:         if (!clk)

1
   6:                 return 0;

1
   7: 

1
   8:         if (!clk->ops->round_rate) {

1
   9:                 if (clk->flags & CLK_SET_RATE_PARENT)

1
  10:                         return __clk_round_rate(clk->parent, rate);

1
  11:                 else

1
  12:                         return clk->rate;

1
  13:         }

1
  14: 

1
  15:         if (clk->parent)

1
  16:                 parent_rate = clk->parent->rate;

1
  17: 

1
  18:         return clk->ops->round_rate(clk->hw, rate, &parent_rate);

1
  19: }

1
   1: int clk_set_rate(struct clk *clk, unsigned long rate)

1
   2: {

1
   3:         struct clk *top, *fail_clk;

1
   4:         int ret = 0;

1
   5: 

1
   6:         /* prevent racing with updates to the clock topology */

1
   7:         clk_prepare_lock();

1
   8: 

1
   9:         /* bail early if nothing to do */

1
  10:         if (rate == clk->rate)

1
  11:                 goto out;

1
  12: 

1
  13:         if ((clk->flags & CLK_SET_RATE_GATE) && clk->prepare_count) {

1
  14:                 ret = -EBUSY;

1
  15:                 goto out;

1
  16:         }

1
  17: 

1
  18:         /* calculate new rates and get the topmost changed clock */

1
  19:         top = clk_calc_new_rates(clk, rate);

1
  20:         if (!top) {

1
  21:                 ret = -EINVAL;

1
  22:                 goto out;

1
  23:         }

1
  24: 

1
  25:         /* notify that we are about to change rates */

1
  26:         fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);

1
  27:         if (fail_clk) {

1
  28:                 pr_warn("%s: failed to set %s raten", __func__,

1
  29:                                 fail_clk->name);

1
  30:                 clk_propagate_rate_change(top, ABORT_RATE_CHANGE);

1
  31:                 ret = -EBUSY;

1
  32:                 goto out;

1
  33:         }

1
  34: 

1
  35:         /* change the rates */

1
  36:         clk_change_rate(top);

1
  37: 

1
  38: out:

1
  39:         clk_prepare_unlock();

1
  40: 

1
  41:         return ret;

1
  42: }