ARM: msm: Migrate to common clock framework

Move the existing clock code in mach-msm to the common clock
framework. We lose our capability to set the rate of and enable a
clock through debugfs. This is ok though because the debugfs
features are mainly used for testing and development of new clock
code.

To maintain compatibility with the original MSM clock code we
make a wrapper for clk_reset() that calls the struct msm_clk
specific reset function. This is necessary for the usb and sdcc
devices on MSM until a better suited API is made available.

Cc: Saravana Kannan <skannan@codeaurora.org>
Acked-by: Mike Turquette <mturquette@linaro.org>
Signed-off-by: Stephen Boyd <sboyd@codeaurora.org>
Signed-off-by: David Brown <davidb@codeaurora.org>

1 files changed, 74 insertions, 44 deletions

diff --git a/arch/arm/mach-msm/clock-pcom.c b/arch/arm/mach-msm/clock-pcom.c
index 632173186a69..9a80449518e6 100644
--- a/arch/arm/mach-msm/clock-pcom.c
+++ b/arch/arm/mach-msm/clock-pcom.c
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2007 Google, Inc.
- * Copyright (c) 2007-2010, Code Aurora Forum. All rights reserved.
+ * Copyright (c) 2007-2012, The Linux Foundation. All rights reserved.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
@@ -13,9 +13,12 @@
  *
  */
 
+#include <linux/kernel.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
+#include <linux/clk-provider.h>
+#include <linux/clkdev.h>
 
 #include <mach/clk.h>
 
@@ -23,11 +26,20 @@
 #include "clock.h"
 #include "clock-pcom.h"
 
-/*
- * glue for the proc_comm interface
- */
-static int pc_clk_enable(unsigned id)
+struct clk_pcom {
+        unsigned id;
+        unsigned long flags;
+        struct msm_clk msm_clk;
+};
+
+static inline struct clk_pcom *to_clk_pcom(struct clk_hw *hw)
 {
+        return container_of(to_msm_clk(hw), struct clk_pcom, msm_clk);
+}
+
+static int pc_clk_enable(struct clk_hw *hw)
+{
+        unsigned id = to_clk_pcom(hw)->id;
         int rc = msm_proc_comm(PCOM_CLKCTL_RPC_ENABLE, &id, NULL);
         if (rc < 0)
                 return rc;
@@ -35,14 +47,16 @@ static int pc_clk_enable(unsigned id)
                 return (int)id < 0 ? -EINVAL : 0;
 }
 
-static void pc_clk_disable(unsigned id)
+static void pc_clk_disable(struct clk_hw *hw)
 {
+        unsigned id = to_clk_pcom(hw)->id;
         msm_proc_comm(PCOM_CLKCTL_RPC_DISABLE, &id, NULL);
 }
 
-int pc_clk_reset(unsigned id, enum clk_reset_action action)
+static int pc_clk_reset(struct clk_hw *hw, enum clk_reset_action action)
 {
         int rc;
+        unsigned id = to_clk_pcom(hw)->id;
 
         if (action == CLK_RESET_ASSERT)
                 rc = msm_proc_comm(PCOM_CLKCTL_RPC_RESET_ASSERT, &id, NULL);
@@ -55,83 +69,99 @@ int pc_clk_reset(unsigned id, enum clk_reset_action action)
                 return (int)id < 0 ? -EINVAL : 0;
 }
 
-static int pc_clk_set_rate(unsigned id, unsigned rate)
+static int pc_clk_set_rate(struct clk_hw *hw, unsigned long new_rate,
+                           unsigned long p_rate)
 {
-        /* The rate _might_ be rounded off to the nearest KHz value by the
+        struct clk_pcom *p = to_clk_pcom(hw);
+        unsigned id = p->id, rate = new_rate;
+        int rc;
+
+        /*
+         * The rate _might_ be rounded off to the nearest KHz value by the
          * remote function. So a return value of 0 doesn't necessarily mean
          * that the exact rate was set successfully.
          */
-        int rc = msm_proc_comm(PCOM_CLKCTL_RPC_SET_RATE, &id, &rate);
-        if (rc < 0)
-                return rc;
-        else
-                return (int)id < 0 ? -EINVAL : 0;
-}
-
-static int pc_clk_set_min_rate(unsigned id, unsigned rate)
-{
-        int rc = msm_proc_comm(PCOM_CLKCTL_RPC_MIN_RATE, &id, &rate);
-        if (rc < 0)
-                return rc;
+        if (p->flags & CLKFLAG_MIN)
+                rc = msm_proc_comm(PCOM_CLKCTL_RPC_MIN_RATE, &id, &rate);
         else
-                return (int)id < 0 ? -EINVAL : 0;
-}
-
-static int pc_clk_set_max_rate(unsigned id, unsigned rate)
-{
-        int rc = msm_proc_comm(PCOM_CLKCTL_RPC_MAX_RATE, &id, &rate);
+                rc = msm_proc_comm(PCOM_CLKCTL_RPC_SET_RATE, &id, &rate);
         if (rc < 0)
                 return rc;
         else
                 return (int)id < 0 ? -EINVAL : 0;
 }
 
-static unsigned pc_clk_get_rate(unsigned id)
+static unsigned long pc_clk_recalc_rate(struct clk_hw *hw, unsigned long p_rate)
 {
+        unsigned id = to_clk_pcom(hw)->id;
         if (msm_proc_comm(PCOM_CLKCTL_RPC_RATE, &id, NULL))
                 return 0;
         else
                 return id;
 }
 
-static unsigned pc_clk_is_enabled(unsigned id)
+static int pc_clk_is_enabled(struct clk_hw *hw)
 {
+        unsigned id = to_clk_pcom(hw)->id;
         if (msm_proc_comm(PCOM_CLKCTL_RPC_ENABLED, &id, NULL))
                 return 0;
         else
                 return id;
 }
 
-static long pc_clk_round_rate(unsigned id, unsigned rate)
+static long pc_clk_round_rate(struct clk_hw *hw, unsigned long rate,
+                              unsigned long *p_rate)
 {
-
         /* Not really supported; pc_clk_set_rate() does rounding on it's own. */
         return rate;
 }
 
-static bool pc_clk_is_local(unsigned id)
-{
-        return false;
-}
-
-struct clk_ops clk_ops_pcom = {
+static struct clk_ops clk_ops_pcom = {
         .enable = pc_clk_enable,
         .disable = pc_clk_disable,
-        .auto_off = pc_clk_disable,
-        .reset = pc_clk_reset,
         .set_rate = pc_clk_set_rate,
-        .set_min_rate = pc_clk_set_min_rate,
-        .set_max_rate = pc_clk_set_max_rate,
-        .get_rate = pc_clk_get_rate,
+        .recalc_rate = pc_clk_recalc_rate,
         .is_enabled = pc_clk_is_enabled,
         .round_rate = pc_clk_round_rate,
-        .is_local = pc_clk_is_local,
 };
 
 static int msm_clock_pcom_probe(struct platform_device *pdev)
 {
         const struct pcom_clk_pdata *pdata = pdev->dev.platform_data;
-        msm_clock_init(pdata->lookup, pdata->num_lookups);
+        int i, ret;
+
+        for (i = 0; i < pdata->num_lookups; i++) {
+                const struct clk_pcom_desc *desc = &pdata->lookup[i];
+                struct clk *c;
+                struct clk_pcom *p;
+                struct clk_hw *hw;
+                struct clk_init_data init;
+
+                p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
+                if (!p)
+                        return -ENOMEM;
+
+                p->id = desc->id;
+                p->flags = desc->flags;
+                p->msm_clk.reset = pc_clk_reset;
+
+                hw = &p->msm_clk.hw;
+                hw->init = &init;
+
+                init.name = desc->name;
+                init.ops = &clk_ops_pcom;
+                init.num_parents = 0;
+                init.flags = CLK_IS_ROOT;
+
+                if (!(p->flags & CLKFLAG_AUTO_OFF))
+                        init.flags |= CLK_IGNORE_UNUSED;
+
+                c = devm_clk_register(&pdev->dev, hw);
+                ret = clk_register_clkdev(c, desc->con, desc->dev);
+                if (ret)
+                        return ret;
+        }
+
         return 0;
 }