CLK: ti: add support for ti divider-clock

This patch adds support for TI divider clock binding, which simply uses
the basic clock divider to provide the features needed.

Signed-off-by: Tero Kristo <t-kristo@ti.com>
Acked-by: Tony Lindgren <tony@atomide.com>
Signed-off-by: Mike Turquette <mturquette@linaro.org>

3 files changed, 489 insertions, 2 deletions

diff --git a/drivers/clk/ti/Makefile b/drivers/clk/ti/Makefile
index ac4ea50672ed..8690b0b442c0 100644
--- a/drivers/clk/ti/Makefile
+++ b/drivers/clk/ti/Makefile
@@ -1,4 +1,4 @@
 ifneq ($(CONFIG_OF),)
 obj-y                                   += clk.o autoidle.o
-clk-common                              = dpll.o composite.o
+clk-common                              = dpll.o composite.o divider.o
 endif
diff --git a/drivers/clk/ti/composite.c b/drivers/clk/ti/composite.c
index 6539b650cae0..ffb8db4829bf 100644
--- a/drivers/clk/ti/composite.c
+++ b/drivers/clk/ti/composite.c
@@ -31,7 +31,7 @@
 static unsigned long ti_composite_recalc_rate(struct clk_hw *hw,
                                               unsigned long parent_rate)
 {
-        return clk_divider_ops.recalc_rate(hw, parent_rate);
+        return ti_clk_divider_ops.recalc_rate(hw, parent_rate);
 }
 
 static long ti_composite_round_rate(struct clk_hw *hw, unsigned long rate,
diff --git a/drivers/clk/ti/divider.c b/drivers/clk/ti/divider.c
new file mode 100644
index 000000000000..a15e445570b2
--- /dev/null
+++ b/drivers/clk/ti/divider.c
@@ -0,0 +1,487 @@
+/*
+ * TI Divider Clock
+ *
+ * Copyright (C) 2013 Texas Instruments, Inc.
+ *
+ * Tero Kristo <t-kristo@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/clk-provider.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/clk/ti.h>
+
+#undef pr_fmt
+#define pr_fmt(fmt) "%s: " fmt, __func__
+
+#define to_clk_divider(_hw) container_of(_hw, struct clk_divider, hw)
+
+#define div_mask(d)     ((1 << ((d)->width)) - 1)
+
+static unsigned int _get_table_maxdiv(const struct clk_div_table *table)
+{
+        unsigned int maxdiv = 0;
+        const struct clk_div_table *clkt;
+
+        for (clkt = table; clkt->div; clkt++)
+                if (clkt->div > maxdiv)
+                        maxdiv = clkt->div;
+        return maxdiv;
+}
+
+static unsigned int _get_maxdiv(struct clk_divider *divider)
+{
+        if (divider->flags & CLK_DIVIDER_ONE_BASED)
+                return div_mask(divider);
+        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+                return 1 << div_mask(divider);
+        if (divider->table)
+                return _get_table_maxdiv(divider->table);
+        return div_mask(divider) + 1;
+}
+
+static unsigned int _get_table_div(const struct clk_div_table *table,
+                                   unsigned int val)
+{
+        const struct clk_div_table *clkt;
+
+        for (clkt = table; clkt->div; clkt++)
+                if (clkt->val == val)
+                        return clkt->div;
+        return 0;
+}
+
+static unsigned int _get_div(struct clk_divider *divider, unsigned int val)
+{
+        if (divider->flags & CLK_DIVIDER_ONE_BASED)
+                return val;
+        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+                return 1 << val;
+        if (divider->table)
+                return _get_table_div(divider->table, val);
+        return val + 1;
+}
+
+static unsigned int _get_table_val(const struct clk_div_table *table,
+                                   unsigned int div)
+{
+        const struct clk_div_table *clkt;
+
+        for (clkt = table; clkt->div; clkt++)
+                if (clkt->div == div)
+                        return clkt->val;
+        return 0;
+}
+
+static unsigned int _get_val(struct clk_divider *divider, u8 div)
+{
+        if (divider->flags & CLK_DIVIDER_ONE_BASED)
+                return div;
+        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+                return __ffs(div);
+        if (divider->table)
+                return  _get_table_val(divider->table, div);
+        return div - 1;
+}
+
+static unsigned long ti_clk_divider_recalc_rate(struct clk_hw *hw,
+                                                unsigned long parent_rate)
+{
+        struct clk_divider *divider = to_clk_divider(hw);
+        unsigned int div, val;
+
+        val = ti_clk_ll_ops->clk_readl(divider->reg) >> divider->shift;
+        val &= div_mask(divider);
+
+        div = _get_div(divider, val);
+        if (!div) {
+                WARN(!(divider->flags & CLK_DIVIDER_ALLOW_ZERO),
+                     "%s: Zero divisor and CLK_DIVIDER_ALLOW_ZERO not set\n",
+                     __clk_get_name(hw->clk));
+                return parent_rate;
+        }
+
+        return parent_rate / div;
+}
+
+/*
+ * The reverse of DIV_ROUND_UP: The maximum number which
+ * divided by m is r
+ */
+#define MULT_ROUND_UP(r, m) ((r) * (m) + (m) - 1)
+
+static bool _is_valid_table_div(const struct clk_div_table *table,
+                                unsigned int div)
+{
+        const struct clk_div_table *clkt;
+
+        for (clkt = table; clkt->div; clkt++)
+                if (clkt->div == div)
+                        return true;
+        return false;
+}
+
+static bool _is_valid_div(struct clk_divider *divider, unsigned int div)
+{
+        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+                return is_power_of_2(div);
+        if (divider->table)
+                return _is_valid_table_div(divider->table, div);
+        return true;
+}
+
+static int ti_clk_divider_bestdiv(struct clk_hw *hw, unsigned long rate,
+                                  unsigned long *best_parent_rate)
+{
+        struct clk_divider *divider = to_clk_divider(hw);
+        int i, bestdiv = 0;
+        unsigned long parent_rate, best = 0, now, maxdiv;
+        unsigned long parent_rate_saved = *best_parent_rate;
+
+        if (!rate)
+                rate = 1;
+
+        maxdiv = _get_maxdiv(divider);
+
+        if (!(__clk_get_flags(hw->clk) & CLK_SET_RATE_PARENT)) {
+                parent_rate = *best_parent_rate;
+                bestdiv = DIV_ROUND_UP(parent_rate, rate);
+                bestdiv = bestdiv == 0 ? 1 : bestdiv;
+                bestdiv = bestdiv > maxdiv ? maxdiv : bestdiv;
+                return bestdiv;
+        }
+
+        /*
+         * The maximum divider we can use without overflowing
+         * unsigned long in rate * i below
+         */
+        maxdiv = min(ULONG_MAX / rate, maxdiv);
+
+        for (i = 1; i <= maxdiv; i++) {
+                if (!_is_valid_div(divider, i))