1 files changed, 339 insertions, 44 deletions

diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 2cf2ea6b77a1..c42e608af6bb 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -21,6 +21,8 @@
 #include <linux/init.h>
 #include <linux/sched.h>
 
+#include "clk.h"
+
 static DEFINE_SPINLOCK(enable_lock);
 static DEFINE_MUTEX(prepare_lock);
 
@@ -92,7 +94,7 @@ static void clk_enable_unlock(unsigned long flags)
 
 /***        debugfs support        ***/
 
-#ifdef CONFIG_COMMON_CLK_DEBUG
+#ifdef CONFIG_DEBUG_FS
 #include <linux/debugfs.h>
 
 static struct dentry *rootdir;
@@ -104,10 +106,11 @@ static void clk_summary_show_one(struct seq_file *s, struct clk *c, int level)
         if (!c)
                 return;
 
-        seq_printf(s, "%*s%-*s %-11d %-12d %-10lu",
+        seq_printf(s, "%*s%-*s %-11d %-12d %-10lu %-11lu",
                    level * 3 + 1, "",
                    30 - level * 3, c->name,
-                   c->enable_count, c->prepare_count, clk_get_rate(c));
+                   c->enable_count, c->prepare_count, clk_get_rate(c),
+                   clk_get_accuracy(c));
         seq_printf(s, "\n");
 }
 
@@ -129,8 +132,8 @@ static int clk_summary_show(struct seq_file *s, void *data)
 {
         struct clk *c;
 
-        seq_printf(s, "   clock                        enable_cnt  prepare_cnt  rate\n");
-        seq_printf(s, "---------------------------------------------------------------------\n");
+        seq_printf(s, "   clock                        enable_cnt  prepare_cnt  rate        accuracy\n");
+        seq_printf(s, "---------------------------------------------------------------------------------\n");
 
         clk_prepare_lock();
 
@@ -167,6 +170,7 @@ static void clk_dump_one(struct seq_file *s, struct clk *c, int level)
         seq_printf(s, "\"enable_count\": %d,", c->enable_count);
         seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
         seq_printf(s, "\"rate\": %lu", clk_get_rate(c));
+        seq_printf(s, "\"accuracy\": %lu", clk_get_accuracy(c));
 }
 
 static void clk_dump_subtree(struct seq_file *s, struct clk *c, int level)
@@ -248,6 +252,11 @@ static int clk_debug_create_one(struct clk *clk, struct dentry *pdentry)
         if (!d)
                 goto err_out;
 
+        d = debugfs_create_u32("clk_accuracy", S_IRUGO, clk->dentry,
+                        (u32 *)&clk->accuracy);
+        if (!d)
+                goto err_out;
+
         d = debugfs_create_x32("clk_flags", S_IRUGO, clk->dentry,
                         (u32 *)&clk->flags);
         if (!d)
@@ -272,7 +281,8 @@ static int clk_debug_create_one(struct clk *clk, struct dentry *pdentry)
         goto out;
 
 err_out:
-        debugfs_remove(clk->dentry);
+        debugfs_remove_recursive(clk->dentry);
+        clk->dentry = NULL;
 out:
         return ret;
 }
@@ -342,6 +352,21 @@ out:
         return ret;
 }
 
+ /**
+ * clk_debug_unregister - remove a clk node from the debugfs clk tree
+ * @clk: the clk being removed from the debugfs clk tree
+ *
+ * Dynamically removes a clk and all it's children clk nodes from the
+ * debugfs clk tree if clk->dentry points to debugfs created by
+ * clk_debug_register in __clk_init.
+ *
+ * Caller must hold prepare_lock.
+ */
+static void clk_debug_unregister(struct clk *clk)
+{
+        debugfs_remove_recursive(clk->dentry);
+}
+
 /**
  * clk_debug_reparent - reparent clk node in the debugfs clk tree
  * @clk: the clk being reparented
@@ -432,6 +457,9 @@ static inline int clk_debug_register(struct clk *clk) { return 0; }
 static inline void clk_debug_reparent(struct clk *clk, struct clk *new_parent)
 {
 }
+static inline void clk_debug_unregister(struct clk *clk)
+{
+}
 #endif
 
 /* caller must hold prepare_lock */
@@ -547,16 +575,19 @@ struct clk_hw *__clk_get_hw(struct clk *clk)
 {
         return !clk ? NULL : clk->hw;
 }
+EXPORT_SYMBOL_GPL(__clk_get_hw);
 
 u8 __clk_get_num_parents(struct clk *clk)
 {
         return !clk ? 0 : clk->num_parents;
 }
+EXPORT_SYMBOL_GPL(__clk_get_num_parents);
 
 struct clk *__clk_get_parent(struct clk *clk)
 {
         return !clk ? NULL : clk->parent;
 }
+EXPORT_SYMBOL_GPL(__clk_get_parent);
 
 struct clk *clk_get_parent_by_index(struct clk *clk, u8 index)
 {
@@ -570,6 +601,7 @@ struct clk *clk_get_parent_by_index(struct clk *clk, u8 index)
         else
                 return clk->parents[index];
 }
+EXPORT_SYMBOL_GPL(clk_get_parent_by_index);
 
 unsigned int __clk_get_enable_count(struct clk *clk)
 {
@@ -601,6 +633,15 @@ unsigned long __clk_get_rate(struct clk *clk)
 out:
         return ret;
 }
+EXPORT_SYMBOL_GPL(__clk_get_rate);
+
+unsigned long __clk_get_accuracy(struct clk *clk)
+{
+        if (!clk)
+                return 0;
+
+        return clk->accuracy;
+}
 
 unsigned long __clk_get_flags(struct clk *clk)
 {
@@ -649,6 +690,7 @@ bool __clk_is_enabled(struct clk *clk)
 out:
         return !!ret;
 }
+EXPORT_SYMBOL_GPL(__clk_is_enabled);
 
 static struct clk *__clk_lookup_subtree(const char *name, struct clk *clk)
 {
@@ -740,6 +782,7 @@ out:
 
         return best;
 }
+EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);
 
 /***        clk api        ***/
 
@@ -1016,6 +1059,59 @@ static int __clk_notify(struct clk *clk, unsigned long msg,
 }
 
 /**
+ * __clk_recalc_accuracies
+ * @clk: first clk in the subtree
+ *
+ * Walks the subtree of clks starting with clk and recalculates accuracies as
+ * it goes.  Note that if a clk does not implement the .recalc_accuracy
+ * callback then it is assumed that the clock will take on the accuracy of it's
+ * parent.
+ *
+ * Caller must hold prepare_lock.
+ */
+static void __clk_recalc_accuracies(struct clk *clk)
+{
+        unsigned long parent_accuracy = 0;
+        struct clk *child;
+
+        if (clk->parent)
+                parent_accuracy = clk->parent->accuracy;
+
+        if (clk->ops->recalc_accuracy)
+                clk->accuracy = clk->ops->recalc_accuracy(clk->hw,
+                                                          parent_accuracy);
+        else
+                clk->accuracy = parent_accuracy;
+
+        hlist_for_each_entry(child, &clk->children, child_node)
+                __clk_recalc_accuracies(child);
+}
+
+/**
+ * clk_get_accuracy - return the accuracy of clk
+ * @clk: the clk whose accuracy is being returned
+ *
+ * Simply returns the cached accuracy of the clk, unless
+ * CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
+ * issued.
+ * If clk is NULL then returns 0.
+ */
+long clk_get_accuracy(struct clk *clk)
+{
+        unsigned long accuracy;
+
+        clk_prepare_lock();
+        if (clk && (clk->flags & CLK_GET_ACCURACY_NOCACHE))
+                __clk_recalc_accuracies(clk);
+
+        accuracy = __clk_get_accuracy(clk);
+        clk_prepare_unlock();
+
+        return accuracy;
+}
+EXPORT_SYMBOL_GPL(clk_get_accuracy);
+
+/**
  * __clk_recalc_rates
  * @clk: first clk in the subtree
  * @msg: notification type (see include/linux/clk.h)
@@ -1129,10 +1225,9 @@ static void clk_reparent(struct clk *clk, struct clk *new_parent)
         clk->parent = new_parent;
 }
 
-static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
+static struct clk *__clk_set_parent_before(struct clk *clk, struct clk *parent)
 {
         unsigned long flags;
-        int ret = 0;
         struct clk *old_parent = clk->parent;
 
         /*
@@ -1163,6 +1258,34 @@ static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
         clk_reparent(clk, parent);
         clk_enable_unlock(flags);
 
+        return old_parent;
+}
+
+static void __clk_set_parent_after(struct clk *clk, struct clk *parent,
+                struct clk *old_parent)
+{
+        /*
+         * Finish the migration of prepare state and undo the changes done
+         * for preventing a race with clk_enable().
+         */
+        if (clk->prepare_count) {
+                clk_disable(clk);
+                clk_disable(old_parent);
+                __clk_unprepare(old_parent);
+        }
+
+        /* update debugfs with new clk tree topology */
+        clk_debug_reparent(clk, parent);
+}
+
+static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
+{
+        unsigned long flags;
+        int ret = 0;
+        struct clk *old_parent;
+
+        old_parent = __clk_set_parent_before(clk, parent);
+
         /* change clock input source */
         if (parent && clk->ops->set_parent)
                 ret = clk->ops->set_parent(clk->hw, p_index);
@@ -1180,18 +1303,8 @@ static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
                 return ret;
         }
 
-        /*
-         * Finish the migration of prepare state and undo the changes done
-         * for preventing a race with clk_enable().
-         */
-        if (clk->prepare_count) {
-                clk_disable(clk);
-                clk_disable(old_parent);
-                __clk_unprepare(old_parent);
-        }
+        __clk_set_parent_after(clk, parent, old_parent);
 
-        /* update debugfs with new clk tree topology */
-        clk_debug_reparent(clk, parent);
         return 0;
 }
 
@@ -1376,17 +1489,32 @@ static void clk_change_rate(struct clk *clk)
         struct clk *child;
         unsigned long old_rate;
         unsigned long best_parent_rate = 0;
+        bool skip_set_rate = false;
+        struct clk *old_parent;
 
         old_rate = clk->rate;
 
-        /* set parent */
-        if (clk->new_parent && clk->new_parent != clk->parent)
-                __clk_set_parent(clk, clk->new_parent, clk->new_parent_index);
-
-        if (clk->parent)
+        if (clk->new_parent)
+                best_parent_rate = clk->new_parent->rate;
+        else if (clk->parent)
                 best_parent_rate = clk->parent->rate;
 
-        if (clk->ops->set_rate)
+        if (clk->new_parent && clk->new_parent != clk->parent) {
+                old_parent = __clk_set_parent_before(clk, clk->new_parent);
+
+                if (clk->ops->set_rate_and_parent) {
+                        skip_set_rate = true;
+                        clk->ops->set_rate_and_parent(clk->hw, clk->new_rate,
+                                        best_parent_rate,
+                                        clk->new_parent_index);
+                } else if (clk->ops->set_parent) {
+                        clk->ops->set_parent(clk->hw, clk->new_parent_index);
+                }
+
+                __clk_set_parent_after(clk, clk->new_parent, old_parent);
+        }
+
+        if (!skip_set_rate && clk->ops->set_rate)
                 clk->ops->set_rate(clk->hw, clk->new_rate, best_parent_rate);
 
         if (clk->ops->recalc_rate)
@@ -1551,6 +1679,7 @@ void __clk_reparent(struct clk *clk, struct clk *new_parent)
 {
         clk_reparent(clk, new_parent);
         clk_debug_reparent(clk, new_parent);
+        __clk_recalc_accuracies(clk);
         __clk_recalc_rates(clk, POST_RATE_CHANGE);
 }
 
@@ -1621,11 +1750,13 @@ int clk_set_parent(struct clk *clk, struct clk *parent)
         /* do the re-parent */
         ret = __clk_set_parent(clk, parent, p_index);
 
-        /* propagate rate recalculation accordingly */
-        if (ret)
+        /* propagate rate an accuracy recalculation accordingly */
+        if (ret) {
                 __clk_recalc_rates(clk, ABORT_RATE_CHANGE);
-        else
+        } else {
                 __clk_recalc_rates(clk, POST_RATE_CHANGE);
+                __clk_recalc_accuracies(clk);
+        }
 
 out:
         clk_prepare_unlock();
@@ -1678,6 +1809,14 @@ int __clk_init(struct device *dev, struct clk *clk)
                 goto out;
         }
 
+        if (clk->ops->set_rate_and_parent &&
+                        !(clk->ops->set_parent && clk->ops->set_rate)) {
+                pr_warn("%s: %s must implement .set_parent & .set_rate\n",
+                                __func__, clk->name);
+                ret = -EINVAL;
+                goto out;
+        }
+
         /* throw a WARN if any entries in parent_names are NULL */
         for (i = 0; i < clk->num_parents; i++)
                 WARN(!clk->parent_names[i],
@@ -1730,6 +1869,21 @@ int __clk_init(struct device *dev, struct clk *clk)
                 hlist_add_head(&clk->child_node, &clk_orphan_list);
 
         /*
+         * Set clk's accuracy.  The preferred method is to use
+         * .recalc_accuracy. For simple clocks and lazy developers the default
+         * fallback is to use the parent's accuracy.  If a clock doesn't have a
+         * parent (or is orphaned) then accuracy is set to zero (perfect
+         * clock).
+         */
+        if (clk->ops->recalc_accuracy)
+                clk->accuracy = clk->ops->recalc_accuracy(clk->hw,
+                                        __clk_get_accuracy(clk->parent));
+        else if (clk->parent)
+                clk->accuracy = clk->parent->accuracy;
+        else
+                clk->accuracy = 0;
+
+        /*
          * Set clk's rate.  The preferred method is to use .recalc_rate.  For
          * simple clocks and lazy developers the default fallback is to use the
          * parent's rate.  If a clock doesn't have a parent (or is orphaned)
@@ -1743,6 +1897,7 @@ int __clk_init(struct device *dev, struct clk *clk)
         else
                 clk->rate = 0;
 
+        clk_debug_register(clk);
         /*
          * walk the list of orphan clocks and reparent any that are children of
          * this clock
@@ -1773,8 +1928,7 @@ int __clk_init(struct device *dev, struct clk *clk)
         if (clk->ops->init)
                 clk->ops->init(clk->hw);
 
-        clk_debug_register(clk);
-
+        kref_init(&clk->ref);
 out:
         clk_prepare_unlock();
 
@@ -1810,6 +1964,10 @@ struct clk *__clk_register(struct device *dev, struct clk_hw *hw)
         clk->flags = hw->init->flags;
         clk->parent_names = hw->init->parent_names;
         clk->num_parents = hw->init->num_parents;
+        if (dev && dev->driver)
+                clk->owner = dev->driver->owner;
+        else
+                clk->owner = NULL;
 
         ret = __clk_init(dev, clk);
         if (ret)
@@ -1830,6 +1988,8 @@ static int _clk_register(struct device *dev, struct clk_hw *hw, struct clk *clk)
                 goto fail_name;
         }
         clk->ops = hw->init->ops;
+        if (dev && dev->driver)
+                clk->owner = dev->driver->owner;
         clk->hw = hw;
         clk->flags = hw->init->flags;
         clk->num_parents = hw->init->num_parents;
@@ -1904,13 +2064,104 @@ fail_out:
 }
 EXPORT_SYMBOL_GPL(clk_register);
 
+/*
+ * Free memory allocated for a clock.
+ * Caller must hold prepare_lock.
+ */
+static void __clk_release(struct kref *ref)
+{
+        struct clk *clk = container_of(ref, struct clk, ref);
+        int i = clk->num_parents;
+
+        kfree(clk->parents);
+        while (--i >= 0)
+                kfree(clk->parent_names[i]);
+
+        kfree(clk->parent_names);
+        kfree(clk->name);
+        kfree(clk);
+}
+
+/*
+ * Empty clk_ops for unregistered clocks. These are used temporarily
+ * after clk_unregister() was called on a clock and until last clock
+ * consumer calls clk_put() and the struct clk object is freed.
+ */
+static int clk_nodrv_prepare_enable(struct clk_hw *hw)
+{
+        return -ENXIO;
+}
+
+static void clk_nodrv_disable_unprepare(struct clk_hw *hw)
+{
+        WARN_ON_ONCE(1);
+}
+
+static int clk_nodrv_set_rate(struct clk_hw *hw, unsigned long rate,
+                                        unsigned long parent_rate)
+{
+        return -ENXIO;
+}
+
+static int clk_nodrv_set_parent(struct clk_hw *hw, u8 index)
+{
+        return -ENXIO;
+}
+
+static const struct clk_ops clk_nodrv_ops = {
+        .enable         = clk_nodrv_prepare_enable,
+        .disable        = clk_nodrv_disable_unprepare,
+        .prepare        = clk_nodrv_prepare_enable,
+        .unprepare      = clk_nodrv_disable_unprepare,
+        .set_rate       = clk_nodrv_set_rate,
+        .set_parent     = clk_nodrv_set_parent,
+};
+
 /**
  * clk_unregister - unregister a currently registered clock
  * @clk: clock to unregister
- *
- * Currently unimplemented.
  */
-void clk_unregister(struct clk *clk) {}
+void clk_unregister(struct clk *clk)
+{
+        unsigned long flags;
+
+       if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
+               return;
+
+        clk_prepare_lock();
+
+        if (clk->ops == &clk_nodrv_ops) {
+                pr_err("%s: unregistered clock: %s\n", __func__, clk->name);
+                goto out;
+        }
+        /*
+         * Assign empty clock ops for consumers that might still hold
+         * a reference to this clock.
+         */
+        flags = clk_enable_lock();
+        clk->ops = &clk_nodrv_ops;
+        clk_enable_unlock(flags);
+
+        if (!hlist_empty(&clk->children)) {
+                struct clk *child;
+
+                /* Reparent all children to the orphan list. */
+                hlist_for_each_entry(child, &clk->children, child_node)
+                        clk_set_parent(child, NULL);
+        }
+
+        clk_debug_unregister(clk);
+
+        hlist_del_init(&clk->child_node);
+
+        if (clk->prepare_count)
+                pr_warn("%s: unregistering prepared clock: %s\n",
+                                        __func__, clk->name);
+
+        kref_put(&clk->ref, __clk_release);
+out:
+        clk_prepare_unlock();
+}
 EXPORT_SYMBOL_GPL(clk_unregister);
 
 static void devm_clk_release(struct device *dev, void *res)
@@ -1970,6 +2221,32 @@ void devm_clk_unregister(struct device *dev, struct clk *clk)
 }
 EXPORT_SYMBOL_GPL(devm_clk_unregister);
 
+/*
+ * clkdev helpers
+ */
+int __clk_get(struct clk *clk)
+{
+        if (clk) {
+                if (!try_module_get(clk->owner))
+                        return 0;
+
+                kref_get(&clk->ref);
+        }
+        return 1;
+}
+
+void __clk_put(struct clk *clk)
+{
+        if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
+                return;
+
+        clk_prepare_lock();
+        kref_put(&clk->ref, __clk_release);
+        clk_prepare_unlock();
+
+        module_put(clk->owner);
+}
+
 /***        clk rate change notifiers        ***/
 
 /**
@@ -2104,13 +2381,22 @@ struct of_clk_provider {
         void *data;
 };
 
-extern struct of_device_id __clk_of_table[];
-
 static const struct of_device_id __clk_of_table_sentinel
         __used __section(__clk_of_table_end);
 
 static LIST_HEAD(of_clk_providers);
-static DEFINE_MUTEX(of_clk_lock);
+static DEFINE_MUTEX(of_clk_mutex);
+
+/* of_clk_provider list locking helpers */
+void of_clk_lock(void)
+{
+        mutex_lock(&of_clk_mutex);
+}
+
+void of_clk_unlock(void)
+{
+        mutex_unlock(&of_clk_mutex);
+}
 
 struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
                                      void *data)
@@ -2154,9 +2440,9 @@ int of_clk_add_provider(struct device_node *np,
         cp->data = data;
         cp->get = clk_src_get;
 
-        mutex_lock(&of_clk_lock);
+        mutex_lock(&of_clk_mutex);
         list_add(&cp->link, &of_clk_providers);
-        mutex_unlock(&of_clk_lock);
+        mutex_unlock(&of_clk_mutex);
         pr_debug("Added clock from %s\n", np->full_name);
 
         return 0;
@@ -2171,7 +2457,7 @@ void of_clk_del_provider(struct device_node *np)
 {
         struct of_clk_provider *cp;
 
-        mutex_lock(&of_clk_lock);
+        mutex_lock(&of_clk_mutex);
         list_for_each_entry(cp, &of_clk_providers, link) {
                 if (cp->node == np) {
                         list_del(&cp->link);
@@ -2180,24 +2466,33 @@ void of_clk_del_provider(struct device_node *np)
                         break;
                 }
         }
-        mutex_unlock(&of_clk_lock);
+        mutex_unlock(&of_clk_mutex);
 }
 EXPORT_SYMBOL_GPL(of_clk_del_provider);
 
-struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
+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;
+}
+
+struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
+{
+        struct clk *clk;
+
+        mutex_lock(&of_clk_mutex);
+        clk = __of_clk_get_from_provider(clkspec);
+        mutex_unlock(&of_clk_mutex);
 
         return clk;
 }
@@ -2245,7 +2540,7 @@ void __init of_clk_init(const struct of_device_id *matches)
         struct device_node *np;
 
         if (!matches)
-                matches = __clk_of_table;
+                matches = &__clk_of_table;
 
         for_each_matching_node_and_match(np, matches, &match) {
                 of_clk_init_cb_t clk_init_cb = match->data;