clk: sunxi: Move USB clocks to separate file

The USB clocks originally shared code with the gates clocks, but had
additional reset controllers. Move these to a separate file. This will
allow us to add new support for slightly different USB clocks, such as
on the A80, without affecting gates clocks, and also facilitate the
migration of gates clocks to a generic solution.

This also cleans up the USB clocks code slightly, such as adding
newlines, getting rid of the unused clkdev call, using a simple
u32 instead of BITMAP for the clock masks, using BIT() macro to
declare the clock bitmasks, and using of_io_request_and_map() to
get the I/O address.

Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>

3 files changed, 191 insertions, 88 deletions

diff --git a/drivers/clk/sunxi/Makefile b/drivers/clk/sunxi/Makefile
index 3a5292e3fcf8..058f273d6154 100644
--- a/drivers/clk/sunxi/Makefile
+++ b/drivers/clk/sunxi/Makefile
@@ -9,6 +9,7 @@ obj-y += clk-mod0.o
 obj-y += clk-sun8i-mbus.o
 obj-y += clk-sun9i-core.o
 obj-y += clk-sun9i-mmc.o
+obj-y += clk-usb.o
 
 obj-$(CONFIG_MFD_SUN6I_PRCM) += \
         clk-sun6i-ar100.o clk-sun6i-apb0.o clk-sun6i-apb0-gates.o \
diff --git a/drivers/clk/sunxi/clk-sunxi.c b/drivers/clk/sunxi/clk-sunxi.c
index 379324eb5486..b6f28ac4f9d5 100644
--- a/drivers/clk/sunxi/clk-sunxi.c
+++ b/drivers/clk/sunxi/clk-sunxi.c
@@ -838,59 +838,6 @@ static void __init sunxi_divider_clk_setup(struct device_node *node,
 
 
 /**
- * sunxi_gates_reset... - reset bits in leaf gate clk registers handling
- */
-
-struct gates_reset_data {
-        void __iomem                    *reg;
-        spinlock_t                      *lock;
-        struct reset_controller_dev     rcdev;
-};
-
-static int sunxi_gates_reset_assert(struct reset_controller_dev *rcdev,
-                              unsigned long id)
-{
-        struct gates_reset_data *data = container_of(rcdev,
-                                                     struct gates_reset_data,
-                                                     rcdev);
-        unsigned long flags;
-        u32 reg;
-
-        spin_lock_irqsave(data->lock, flags);
-
-        reg = readl(data->reg);
-        writel(reg & ~BIT(id), data->reg);
-
-        spin_unlock_irqrestore(data->lock, flags);
-
-        return 0;
-}
-
-static int sunxi_gates_reset_deassert(struct reset_controller_dev *rcdev,
-                                unsigned long id)
-{
-        struct gates_reset_data *data = container_of(rcdev,
-                                                     struct gates_reset_data,
-                                                     rcdev);
-        unsigned long flags;
-        u32 reg;
-
-        spin_lock_irqsave(data->lock, flags);
-
-        reg = readl(data->reg);
-        writel(reg | BIT(id), data->reg);
-
-        spin_unlock_irqrestore(data->lock, flags);
-
-        return 0;
-}
-
-static struct reset_control_ops sunxi_gates_reset_ops = {
-        .assert         = sunxi_gates_reset_assert,
-        .deassert       = sunxi_gates_reset_deassert,
-};
-
-/**
  * sunxi_gates_clk_setup() - Setup function for leaf gates on clocks
  */
 
@@ -898,7 +845,6 @@ static struct reset_control_ops sunxi_gates_reset_ops = {
 
 struct gates_data {
         DECLARE_BITMAP(mask, SUNXI_GATES_MAX_SIZE);
-        u32 reset_mask;
 };
 
 static const struct gates_data sun4i_axi_gates_data __initconst = {
@@ -997,26 +943,10 @@ static const struct gates_data sun8i_a23_apb2_gates_data __initconst = {
         .mask = {0x1F0007},
 };
 
-static const struct gates_data sun4i_a10_usb_gates_data __initconst = {
-        .mask = {0x1C0},
-        .reset_mask = 0x07,
-};
-
-static const struct gates_data sun5i_a13_usb_gates_data __initconst = {
-        .mask = {0x140},
-        .reset_mask = 0x03,
-};
-
-static const struct gates_data sun6i_a31_usb_gates_data __initconst = {
-        .mask = { BIT(18) | BIT(17) | BIT(16) | BIT(10) | BIT(9) | BIT(8) },
-        .reset_mask = BIT(2) | BIT(1) | BIT(0),
-};
-
 static void __init sunxi_gates_clk_setup(struct device_node *node,
                                          struct gates_data *data)
 {
         struct clk_onecell_data *clk_data;
-        struct gates_reset_data *reset_data;
         const char *clk_parent;
         const char *clk_name;
         void __iomem *reg;
@@ -1057,21 +987,6 @@ static void __init sunxi_gates_clk_setup(struct device_node *node,
         clk_data->clk_num = i;
 
         of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
-
-        /* Register a reset controler for gates with reset bits */
-        if (data->reset_mask == 0)
-                return;
-
-        reset_data = kzalloc(sizeof(*reset_data), GFP_KERNEL);
-        if (!reset_data)
-                return;
-
-        reset_data->reg = reg;
-        reset_data->lock = &clk_lock;
-        reset_data->rcdev.nr_resets = __fls(data->reset_mask) + 1;
-        reset_data->rcdev.ops = &sunxi_gates_reset_ops;
-        reset_data->rcdev.of_node = node;
-        reset_controller_register(&reset_data->rcdev);
 }
 
 
@@ -1324,9 +1239,6 @@ static const struct of_device_id clk_gates_match[] __initconst = {
         {.compatible = "allwinner,sun9i-a80-apb1-gates-clk", .data = &sun9i_a80_apb1_gates_data,},
         {.compatible = "allwinner,sun6i-a31-apb2-gates-clk", .data = &sun6i_a31_apb2_gates_data,},
         {.compatible = "allwinner,sun8i-a23-apb2-gates-clk", .data = &sun8i_a23_apb2_gates_data,},
-        {.compatible = "allwinner,sun4i-a10-usb-clk", .data = &sun4i_a10_usb_gates_data,},
-        {.compatible = "allwinner,sun5i-a13-usb-clk", .data = &sun5i_a13_usb_gates_data,},
-        {.compatible = "allwinner,sun6i-a31-usb-clk", .data = &sun6i_a31_usb_gates_data,},
         {}
 };
 
diff --git a/drivers/clk/sunxi/clk-usb.c b/drivers/clk/sunxi/clk-usb.c
new file mode 100644
index 000000000000..f1dcc8fb5a7d
--- /dev/null
+++ b/drivers/clk/sunxi/clk-usb.c
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2013-2015 Emilio López
+ *
+ * Emilio López <emilio@elopez.com.ar>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; 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/clkdev.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/reset-controller.h>
+#include <linux/spinlock.h>
+
+
+/**
+ * sunxi_usb_reset... - reset bits in usb clk registers handling
+ */
+
+struct usb_reset_data {
+        void __iomem                    *reg;
+        spinlock_t                      *lock;
+        struct reset_controller_dev     rcdev;
+};
+
+static int sunxi_usb_reset_assert(struct reset_controller_dev *rcdev,
+                              unsigned long id)
+{
+        struct usb_reset_data *data = container_of(rcdev,
+                                                   struct usb_reset_data,
+                                                   rcdev);
+        unsigned long flags;
+        u32 reg;
+
+        spin_lock_irqsave(data->lock, flags);
+
+        reg = readl(data->reg);
+        writel(reg & ~BIT(id), data->reg);
+
+        spin_unlock_irqrestore(data->lock, flags);
+
+        return 0;
+}
+
+static int sunxi_usb_reset_deassert(struct reset_controller_dev *rcdev,
+                                unsigned long id)
+{
+        struct usb_reset_data *data = container_of(rcdev,
+                                                     struct usb_reset_data,
+                                                     rcdev);
+        unsigned long flags;
+        u32 reg;
+
+        spin_lock_irqsave(data->lock, flags);
+
+        reg = readl(data->reg);
+        writel(reg | BIT(id), data->reg);
+
+        spin_unlock_irqrestore(data->lock, flags);
+
+        return 0;
+}
+
+static struct reset_control_ops sunxi_usb_reset_ops = {
+        .assert         = sunxi_usb_reset_assert,
+        .deassert       = sunxi_usb_reset_deassert,
+};
+
+/**
+ * sunxi_usb_clk_setup() - Setup function for usb gate clocks
+ */
+
+#define SUNXI_USB_MAX_SIZE 32
+
+struct usb_clk_data {
+        u32 clk_mask;
+        u32 reset_mask;
+};
+
+static void __init sunxi_usb_clk_setup(struct device_node *node,
+                                       const struct usb_clk_data *data,
+                                       spinlock_t *lock)
+{
+        struct clk_onecell_data *clk_data;
+        struct usb_reset_data *reset_data;
+        const char *clk_parent;
+        const char *clk_name;
+        void __iomem *reg;
+        int qty;
+        int i = 0;
+        int j = 0;
+
+        reg = of_io_request_and_map(node, 0, of_node_full_name(node));
+        if (IS_ERR(reg))
+                return;
+
+        clk_parent = of_clk_get_parent_name(node, 0);
+        if (!clk_parent)
+                return;
+
+        /* Worst-case size approximation and memory allocation */
+        qty = find_last_bit((unsigned long *)&data->clk_mask,
+                            SUNXI_USB_MAX_SIZE);
+
+        clk_data = kmalloc(sizeof(struct clk_onecell_data), GFP_KERNEL);
+        if (!clk_data)
+                return;
+
+        clk_data->clks = kzalloc((qty+1) * sizeof(struct clk *), GFP_KERNEL);
+        if (!clk_data->clks) {
+                kfree(clk_data);
+                return;
+        }
+
+        for_each_set_bit(i, (unsigned long *)&data->clk_mask,
+                         SUNXI_USB_MAX_SIZE) {
+                of_property_read_string_index(node, "clock-output-names",
+                                              j, &clk_name);
+                clk_data->clks[i] = clk_register_gate(NULL, clk_name,
+                                                      clk_parent, 0,
+                                                      reg, i, 0, lock);
+                WARN_ON(IS_ERR(clk_data->clks[i]));
+
+                j++;
+        }
+
+        /* Adjust to the real max */
+        clk_data->clk_num = i;
+
+        of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
+
+        /* Register a reset controller for usb with reset bits */
+        if (data->reset_mask == 0)
+                return;
+
+        reset_data = kzalloc(sizeof(*reset_data), GFP_KERNEL);
+        if (!reset_data)
+                return;
+
+        reset_data->reg = reg;
+        reset_data->lock = lock;
+        reset_data->rcdev.nr_resets = __fls(data->reset_mask) + 1;
+        reset_data->rcdev.ops = &sunxi_usb_reset_ops;
+        reset_data->rcdev.of_node = node;
+        reset_controller_register(&reset_data->rcdev);
+}
+
+static const struct usb_clk_data sun4i_a10_usb_clk_data __initconst = {
+        .clk_mask = BIT(8) | BIT(7) | BIT(6),
+        .reset_mask = BIT(2) | BIT(1) | BIT(0),
+};
+
+static DEFINE_SPINLOCK(sun4i_a10_usb_lock);
+
+static void __init sun4i_a10_usb_setup(struct device_node *node)
+{
+        sunxi_usb_clk_setup(node, &sun4i_a10_usb_clk_data, &sun4i_a10_usb_lock);
+}
+CLK_OF_DECLARE(sun4i_a10_usb, "allwinner,sun4i-a10-usb-clk", sun4i_a10_usb_setup);
+
+static const struct usb_clk_data sun5i_a13_usb_clk_data __initconst = {
+        .clk_mask = BIT(8) | BIT(6),
+        .reset_mask = BIT(1) | BIT(0),
+};
+
+static void __init sun5i_a13_usb_setup(struct device_node *node)
+{
+        sunxi_usb_clk_setup(node, &sun5i_a13_usb_clk_data, &sun4i_a10_usb_lock);
+}
+CLK_OF_DECLARE(sun5i_a13_usb, "allwinner,sun5i-a13-usb-clk", sun5i_a13_usb_setup);
+
+static const struct usb_clk_data sun6i_a31_usb_clk_data __initconst = {
+        .clk_mask = BIT(18) | BIT(17) | BIT(16) | BIT(10) | BIT(9) | BIT(8),
+        .reset_mask = BIT(2) | BIT(1) | BIT(0),
+};
+
+static void __init sun6i_a31_usb_setup(struct device_node *node)
+{
+        sunxi_usb_clk_setup(node, &sun6i_a31_usb_clk_data, &sun4i_a10_usb_lock);
+}
+CLK_OF_DECLARE(sun6i_a31_usb, "allwinner,sun6i-a31-usb-clk", sun6i_a31_usb_setup);