clk: add DT clock binding support

Based on work 1st by Ben Herrenschmidt and Jeremy Kerr, then by Grant
Likely, this patch adds support to clk_get to allow drivers to retrieve
clock data from the device tree.

Platforms scan for clocks in DT with of_clk_init and a match table, and
the register a provider through of_clk_add_provider. The provider's
clk_src_get function will be called when a device references the
provider's OF node for a clock reference.

v6 (Rob Herring):
    - Return error values instead of NULL to match clock framework
      expectations

v5 (Rob Herring):
    - Move from drivers/of into common clock subsystem
    - Squashed "dt/clock: add a simple provider get function" and
      "dt/clock: add function to get parent clock name"
    - Rebase to 3.4-rc1
    - Drop CONFIG_OF_CLOCK and just use CONFIG_OF
    - Add missing EXPORT_SYMBOL to various functions
    - s/clock-output-name/clock-output-names/
    - Define that fixed-clock binding is a single output

v4 (Rob Herring):
    - Rework for common clk subsystem
    - Add of_clk_get_parent_name function

v3: - Clarified documentation

v2: - fixed errant ';' causing compile error
    - Editorial fixes from Shawn Guo
    - merged in adding lookup to clkdev
    - changed property names to match established convention. After
      working with the binding a bit it really made more sense to follow the
      lead of 'reg', 'gpios' and 'interrupts' by making the input simply
      'clocks' & 'clock-names' instead of 'clock-input-*', and to only use
      clock-output* for the producer nodes. (Sorry Shawn, this will mean
      you need to change some code, but it should be trivial)
    - Add ability to inherit clocks from parent nodes by using an empty
      'clock-ranges' property.  Useful for busses.  I could use some feedback
      on the new property name, 'clock-ranges' doesn't feel right to me.

Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
Signed-off-by: Rob Herring <rob.herring@calxeda.com>
Reviewed-by: Shawn Guo <shawn.guo@freescale.com>
Cc: Sascha Hauer <kernel@pengutronix.de>
Signed-off-by: Mike Turquette <mturquette@linaro.org>

2 files changed, 217 insertions, 0 deletions

diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 46317cbc088f..c87fdd710560 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -16,6 +16,7 @@
 #include <linux/err.h>
 #include <linux/list.h>
 #include <linux/slab.h>
+#include <linux/of.h>
 
 static DEFINE_SPINLOCK(enable_lock);
 static DEFINE_MUTEX(prepare_lock);
@@ -1550,3 +1551,142 @@ int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
         return ret;
 }
 EXPORT_SYMBOL_GPL(clk_notifier_unregister);
+
+#ifdef CONFIG_OF
+/**
+ * struct of_clk_provider - Clock provider registration structure
+ * @link: Entry in global list of clock providers
+ * @node: Pointer to device tree node of clock provider
+ * @get: Get clock callback.  Returns NULL or a struct clk for the
+ *       given clock specifier
+ * @data: context pointer to be passed into @get callback
+ */
+struct of_clk_provider {
+        struct list_head link;
+
+        struct device_node *node;
+        struct clk *(*get)(struct of_phandle_args *clkspec, void *data);
+        void *data;
+};
+
+static LIST_HEAD(of_clk_providers);
+static DEFINE_MUTEX(of_clk_lock);
+
+struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
+                                     void *data)
+{
+        return data;
+}
+EXPORT_SYMBOL_GPL(of_clk_src_simple_get);
+
+/**
+ * of_clk_add_provider() - Register a clock provider for a node
+ * @np: Device node pointer associated with clock provider
+ * @clk_src_get: callback for decoding clock
+ * @data: context pointer for @clk_src_get callback.
+ */
+int of_clk_add_provider(struct device_node *np,
+                        struct clk *(*clk_src_get)(struct of_phandle_args *clkspec,
+                                                   void *data),
+                        void *data)
+{
+        struct of_clk_provider *cp;
+
+        cp = kzalloc(sizeof(struct of_clk_provider), GFP_KERNEL);
+        if (!cp)
+                return -ENOMEM;
+
+        cp->node = of_node_get(np);
+        cp->data = data;
+        cp->get = clk_src_get;
+
+        mutex_lock(&of_clk_lock);
+        list_add(&cp->link, &of_clk_providers);
+        mutex_unlock(&of_clk_lock);
+        pr_debug("Added clock from %s\n", np->full_name);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(of_clk_add_provider);
+
+/**
+ * of_clk_del_provider() - Remove a previously registered clock provider
+ * @np: Device node pointer associated with clock provider
+ */
+void of_clk_del_provider(struct device_node *np)
+{
+        struct of_clk_provider *cp;
+
+        mutex_lock(&of_clk_lock);
+        list_for_each_entry(cp, &of_clk_providers, link) {
+                if (cp->node == np) {
+                        list_del(&cp->link);
+                        of_node_put(cp->node);
+                        kfree(cp);
+                        break;
+                }
+        }
+        mutex_unlock(&of_clk_lock);
+}
+EXPORT_SYMBOL_GPL(of_clk_del_provider);
+
+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;
+}
+
+const char *of_clk_get_parent_name(struct device_node *np, int index)
+{
+        struct of_phandle_args clkspec;
+        const char *clk_name;
+        int rc;
+
+        if (index < 0)
+                return NULL;
+
+        rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
+                                        &clkspec);
+        if (rc)
+                return NULL;
+
+        if (of_property_read_string_index(clkspec.np, "clock-output-names",
+                                          clkspec.args_count ? clkspec.args[0] : 0,
+                                          &clk_name) < 0)
+                clk_name = clkspec.np->name;
+
+        of_node_put(clkspec.np);
+        return clk_name;
+}
+EXPORT_SYMBOL_GPL(of_clk_get_parent_name);
+
+/**
+ * of_clk_init() - Scan and init clock providers from the DT
+ * @matches: array of compatible values and init functions for providers.
+ *
+ * This function scans the device tree for matching clock providers and
+ * calls their initialization functions
+ */
+void __init of_clk_init(const struct of_device_id *matches)
+{
+        struct device_node *np;
+
+        for_each_matching_node(np, matches) {
+                const struct of_device_id *match = of_match_node(matches, np);
+                of_clk_init_cb_t clk_init_cb = match->data;
+                clk_init_cb(np);
+        }
+}
+#endif
diff --git a/drivers/clk/clkdev.c b/drivers/clk/clkdev.c
index c535cf8c5770..20649b3c88fe 100644
--- a/drivers/clk/clkdev.c
+++ b/drivers/clk/clkdev.c
@@ -19,10 +19,80 @@
 #include <linux/mutex.h>
 #include <linux/clk.h>
 #include <linux/clkdev.h>
+#include <linux/of.h>
 
 static LIST_HEAD(clocks);
 static DEFINE_MUTEX(clocks_mutex);
 
+#ifdef CONFIG_OF
+struct clk *of_clk_get(struct device_node *np, int index)
+{
+        struct of_phandle_args clkspec;
+        struct clk *clk;
+        int rc;
+
+        if (index < 0)
+                return ERR_PTR(-EINVAL);
+
+        rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
+                                        &clkspec);
+        if (rc)
+                return ERR_PTR(rc);
+
+        clk = of_clk_get_from_provider(&clkspec);
+        of_node_put(clkspec.np);
+        return clk;
+}
+EXPORT_SYMBOL(of_clk_get);
+
+/**
+ * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
+ * @np: pointer to clock consumer node
+ * @name: name of consumer's clock input, or NULL for the first clock reference
+ *
+ * This function parses the clocks and clock-names properties,
+ * and uses them to look up the struct clk from the registered list of clock
+ * providers.
+ */
+struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
+{
+        struct clk *clk = ERR_PTR(-ENOENT);
+
+        /* Walk up the tree of devices looking for a clock that matches */
+        while (np) {
+                int index = 0;
+
+                /*
+                 * For named clocks, first look up the name in the
+                 * "clock-names" property.  If it cannot be found, then
+                 * index will be an error code, and of_clk_get() will fail.
+                 */
+                if (name)
+                        index = of_property_match_string(np, "clock-names", name);
+                clk = of_clk_get(np, index);
+                if (!IS_ERR(clk))
+                        break;
+                else if (name && index >= 0) {
+                        pr_err("ERROR: could not get clock %s:%s(%i)\n",
+                                np->full_name, name ? name : "", index);
+                        return clk;
+                }
+
+                /*
+                 * No matching clock found on this node.  If the parent node
+                 * has a "clock-ranges" property, then we can try one of its
+                 * clocks.
+                 */
+                np = np->parent;
+                if (np && !of_get_property(np, "clock-ranges", NULL))
+                        break;
+        }
+
+        return clk;
+}
+EXPORT_SYMBOL(of_clk_get_by_name);
+#endif
+
 /*
  * Find the correct struct clk for the device and connection ID.
  * We do slightly fuzzy matching here:
@@ -83,6 +153,13 @@ EXPORT_SYMBOL(clk_get_sys);
 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) {
+                clk = of_clk_get_by_name(dev->of_node, con_id);
+                if (clk && __clk_get(clk))
+                        return clk;
+        }
 
         return clk_get_sys(dev_id, con_id);
 }