Commit | Line | Data |
---|---|---|
6089ef19 CYT |
1 | /* |
2 | * Copyright 2013-2015 Emilio López | |
3 | * | |
4 | * Emilio López <emilio@elopez.com.ar> | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | */ | |
16 | ||
17 | #include <linux/clk-provider.h> | |
18 | #include <linux/clkdev.h> | |
19 | #include <linux/of.h> | |
20 | #include <linux/of_address.h> | |
21 | #include <linux/reset-controller.h> | |
22 | #include <linux/spinlock.h> | |
23 | ||
24 | ||
25 | /** | |
26 | * sunxi_usb_reset... - reset bits in usb clk registers handling | |
27 | */ | |
28 | ||
29 | struct usb_reset_data { | |
30 | void __iomem *reg; | |
31 | spinlock_t *lock; | |
71f32f56 | 32 | struct clk *clk; |
6089ef19 CYT |
33 | struct reset_controller_dev rcdev; |
34 | }; | |
35 | ||
36 | static int sunxi_usb_reset_assert(struct reset_controller_dev *rcdev, | |
37 | unsigned long id) | |
38 | { | |
39 | struct usb_reset_data *data = container_of(rcdev, | |
40 | struct usb_reset_data, | |
41 | rcdev); | |
42 | unsigned long flags; | |
43 | u32 reg; | |
44 | ||
71f32f56 | 45 | clk_prepare_enable(data->clk); |
6089ef19 CYT |
46 | spin_lock_irqsave(data->lock, flags); |
47 | ||
48 | reg = readl(data->reg); | |
49 | writel(reg & ~BIT(id), data->reg); | |
50 | ||
51 | spin_unlock_irqrestore(data->lock, flags); | |
71f32f56 | 52 | clk_disable_unprepare(data->clk); |
6089ef19 CYT |
53 | |
54 | return 0; | |
55 | } | |
56 | ||
57 | static int sunxi_usb_reset_deassert(struct reset_controller_dev *rcdev, | |
58 | unsigned long id) | |
59 | { | |
60 | struct usb_reset_data *data = container_of(rcdev, | |
61 | struct usb_reset_data, | |
62 | rcdev); | |
63 | unsigned long flags; | |
64 | u32 reg; | |
65 | ||
71f32f56 | 66 | clk_prepare_enable(data->clk); |
6089ef19 CYT |
67 | spin_lock_irqsave(data->lock, flags); |
68 | ||
69 | reg = readl(data->reg); | |
70 | writel(reg | BIT(id), data->reg); | |
71 | ||
72 | spin_unlock_irqrestore(data->lock, flags); | |
71f32f56 | 73 | clk_disable_unprepare(data->clk); |
6089ef19 CYT |
74 | |
75 | return 0; | |
76 | } | |
77 | ||
78 | static struct reset_control_ops sunxi_usb_reset_ops = { | |
79 | .assert = sunxi_usb_reset_assert, | |
80 | .deassert = sunxi_usb_reset_deassert, | |
81 | }; | |
82 | ||
83 | /** | |
84 | * sunxi_usb_clk_setup() - Setup function for usb gate clocks | |
85 | */ | |
86 | ||
87 | #define SUNXI_USB_MAX_SIZE 32 | |
88 | ||
89 | struct usb_clk_data { | |
90 | u32 clk_mask; | |
91 | u32 reset_mask; | |
71f32f56 | 92 | bool reset_needs_clk; |
6089ef19 CYT |
93 | }; |
94 | ||
95 | static void __init sunxi_usb_clk_setup(struct device_node *node, | |
96 | const struct usb_clk_data *data, | |
97 | spinlock_t *lock) | |
98 | { | |
99 | struct clk_onecell_data *clk_data; | |
100 | struct usb_reset_data *reset_data; | |
101 | const char *clk_parent; | |
102 | const char *clk_name; | |
103 | void __iomem *reg; | |
104 | int qty; | |
105 | int i = 0; | |
106 | int j = 0; | |
107 | ||
108 | reg = of_io_request_and_map(node, 0, of_node_full_name(node)); | |
109 | if (IS_ERR(reg)) | |
110 | return; | |
111 | ||
112 | clk_parent = of_clk_get_parent_name(node, 0); | |
113 | if (!clk_parent) | |
114 | return; | |
115 | ||
116 | /* Worst-case size approximation and memory allocation */ | |
117 | qty = find_last_bit((unsigned long *)&data->clk_mask, | |
118 | SUNXI_USB_MAX_SIZE); | |
119 | ||
120 | clk_data = kmalloc(sizeof(struct clk_onecell_data), GFP_KERNEL); | |
121 | if (!clk_data) | |
122 | return; | |
123 | ||
124 | clk_data->clks = kzalloc((qty+1) * sizeof(struct clk *), GFP_KERNEL); | |
125 | if (!clk_data->clks) { | |
126 | kfree(clk_data); | |
127 | return; | |
128 | } | |
129 | ||
130 | for_each_set_bit(i, (unsigned long *)&data->clk_mask, | |
131 | SUNXI_USB_MAX_SIZE) { | |
132 | of_property_read_string_index(node, "clock-output-names", | |
133 | j, &clk_name); | |
134 | clk_data->clks[i] = clk_register_gate(NULL, clk_name, | |
135 | clk_parent, 0, | |
136 | reg, i, 0, lock); | |
137 | WARN_ON(IS_ERR(clk_data->clks[i])); | |
138 | ||
139 | j++; | |
140 | } | |
141 | ||
142 | /* Adjust to the real max */ | |
143 | clk_data->clk_num = i; | |
144 | ||
145 | of_clk_add_provider(node, of_clk_src_onecell_get, clk_data); | |
146 | ||
147 | /* Register a reset controller for usb with reset bits */ | |
148 | if (data->reset_mask == 0) | |
149 | return; | |
150 | ||
151 | reset_data = kzalloc(sizeof(*reset_data), GFP_KERNEL); | |
152 | if (!reset_data) | |
153 | return; | |
154 | ||
71f32f56 CYT |
155 | if (data->reset_needs_clk) { |
156 | reset_data->clk = of_clk_get(node, 0); | |
157 | if (IS_ERR(reset_data->clk)) { | |
158 | pr_err("Could not get clock for reset controls\n"); | |
159 | kfree(reset_data); | |
160 | return; | |
161 | } | |
162 | } | |
163 | ||
6089ef19 CYT |
164 | reset_data->reg = reg; |
165 | reset_data->lock = lock; | |
166 | reset_data->rcdev.nr_resets = __fls(data->reset_mask) + 1; | |
167 | reset_data->rcdev.ops = &sunxi_usb_reset_ops; | |
168 | reset_data->rcdev.of_node = node; | |
169 | reset_controller_register(&reset_data->rcdev); | |
170 | } | |
171 | ||
172 | static const struct usb_clk_data sun4i_a10_usb_clk_data __initconst = { | |
173 | .clk_mask = BIT(8) | BIT(7) | BIT(6), | |
174 | .reset_mask = BIT(2) | BIT(1) | BIT(0), | |
175 | }; | |
176 | ||
177 | static DEFINE_SPINLOCK(sun4i_a10_usb_lock); | |
178 | ||
179 | static void __init sun4i_a10_usb_setup(struct device_node *node) | |
180 | { | |
181 | sunxi_usb_clk_setup(node, &sun4i_a10_usb_clk_data, &sun4i_a10_usb_lock); | |
182 | } | |
183 | CLK_OF_DECLARE(sun4i_a10_usb, "allwinner,sun4i-a10-usb-clk", sun4i_a10_usb_setup); | |
184 | ||
185 | static const struct usb_clk_data sun5i_a13_usb_clk_data __initconst = { | |
186 | .clk_mask = BIT(8) | BIT(6), | |
187 | .reset_mask = BIT(1) | BIT(0), | |
188 | }; | |
189 | ||
190 | static void __init sun5i_a13_usb_setup(struct device_node *node) | |
191 | { | |
192 | sunxi_usb_clk_setup(node, &sun5i_a13_usb_clk_data, &sun4i_a10_usb_lock); | |
193 | } | |
194 | CLK_OF_DECLARE(sun5i_a13_usb, "allwinner,sun5i-a13-usb-clk", sun5i_a13_usb_setup); | |
195 | ||
196 | static const struct usb_clk_data sun6i_a31_usb_clk_data __initconst = { | |
197 | .clk_mask = BIT(18) | BIT(17) | BIT(16) | BIT(10) | BIT(9) | BIT(8), | |
198 | .reset_mask = BIT(2) | BIT(1) | BIT(0), | |
199 | }; | |
200 | ||
201 | static void __init sun6i_a31_usb_setup(struct device_node *node) | |
202 | { | |
203 | sunxi_usb_clk_setup(node, &sun6i_a31_usb_clk_data, &sun4i_a10_usb_lock); | |
204 | } | |
205 | CLK_OF_DECLARE(sun6i_a31_usb, "allwinner,sun6i-a31-usb-clk", sun6i_a31_usb_setup); | |
71f32f56 | 206 | |
ec80749d HG |
207 | static const struct usb_clk_data sun8i_a23_usb_clk_data __initconst = { |
208 | .clk_mask = BIT(16) | BIT(11) | BIT(10) | BIT(9) | BIT(8), | |
209 | .reset_mask = BIT(2) | BIT(1) | BIT(0), | |
210 | }; | |
211 | ||
212 | static void __init sun8i_a23_usb_setup(struct device_node *node) | |
213 | { | |
214 | sunxi_usb_clk_setup(node, &sun8i_a23_usb_clk_data, &sun4i_a10_usb_lock); | |
215 | } | |
216 | CLK_OF_DECLARE(sun8i_a23_usb, "allwinner,sun8i-a23-usb-clk", sun8i_a23_usb_setup); | |
217 | ||
71f32f56 CYT |
218 | static const struct usb_clk_data sun9i_a80_usb_mod_data __initconst = { |
219 | .clk_mask = BIT(6) | BIT(5) | BIT(4) | BIT(3) | BIT(2) | BIT(1), | |
220 | .reset_mask = BIT(19) | BIT(18) | BIT(17), | |
221 | .reset_needs_clk = 1, | |
222 | }; | |
223 | ||
224 | static DEFINE_SPINLOCK(a80_usb_mod_lock); | |
225 | ||
226 | static void __init sun9i_a80_usb_mod_setup(struct device_node *node) | |
227 | { | |
228 | sunxi_usb_clk_setup(node, &sun9i_a80_usb_mod_data, &a80_usb_mod_lock); | |
229 | } | |
230 | CLK_OF_DECLARE(sun9i_a80_usb_mod, "allwinner,sun9i-a80-usb-mod-clk", sun9i_a80_usb_mod_setup); | |
231 | ||
232 | static const struct usb_clk_data sun9i_a80_usb_phy_data __initconst = { | |
233 | .clk_mask = BIT(10) | BIT(5) | BIT(4) | BIT(3) | BIT(2) | BIT(1), | |
234 | .reset_mask = BIT(21) | BIT(20) | BIT(19) | BIT(18) | BIT(17), | |
235 | .reset_needs_clk = 1, | |
236 | }; | |
237 | ||
238 | static DEFINE_SPINLOCK(a80_usb_phy_lock); | |
239 | ||
240 | static void __init sun9i_a80_usb_phy_setup(struct device_node *node) | |
241 | { | |
242 | sunxi_usb_clk_setup(node, &sun9i_a80_usb_phy_data, &a80_usb_phy_lock); | |
243 | } | |
244 | CLK_OF_DECLARE(sun9i_a80_usb_phy, "allwinner,sun9i-a80-usb-phy-clk", sun9i_a80_usb_phy_setup); |