]>
Commit | Line | Data |
---|---|---|
91b87a47 LW |
1 | /* |
2 | * Driver for the ICST307 VCO clock found in the ARM Reference designs. | |
3 | * We wrap the custom interface from <asm/hardware/icst.h> into the generic | |
4 | * clock framework. | |
5 | * | |
d430819d | 6 | * Copyright (C) 2012-2015 Linus Walleij |
401301cc LW |
7 | * |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | * | |
91b87a47 LW |
12 | * TODO: when all ARM reference designs are migrated to generic clocks, the |
13 | * ICST clock code from the ARM tree should probably be merged into this | |
14 | * file. | |
15 | */ | |
6d31e3b2 SB |
16 | #include <linux/kernel.h> |
17 | #include <linux/slab.h> | |
18 | #include <linux/export.h> | |
91b87a47 LW |
19 | #include <linux/err.h> |
20 | #include <linux/clk-provider.h> | |
7a9ad671 | 21 | #include <linux/io.h> |
179c8fb3 | 22 | #include <linux/regmap.h> |
384d977d | 23 | #include <linux/mfd/syscon.h> |
91b87a47 LW |
24 | |
25 | #include "clk-icst.h" | |
26 | ||
179c8fb3 LW |
27 | /* Magic unlocking token used on all Versatile boards */ |
28 | #define VERSATILE_LOCK_VAL 0xA05F | |
29 | ||
91b87a47 LW |
30 | /** |
31 | * struct clk_icst - ICST VCO clock wrapper | |
32 | * @hw: corresponding clock hardware entry | |
7a9ad671 LW |
33 | * @vcoreg: VCO register address |
34 | * @lockreg: VCO lock register address | |
91b87a47 LW |
35 | * @params: parameters for this ICST instance |
36 | * @rate: current rate | |
91b87a47 LW |
37 | */ |
38 | struct clk_icst { | |
39 | struct clk_hw hw; | |
179c8fb3 LW |
40 | struct regmap *map; |
41 | u32 vcoreg_off; | |
42 | u32 lockreg_off; | |
a183da63 | 43 | struct icst_params *params; |
91b87a47 | 44 | unsigned long rate; |
91b87a47 LW |
45 | }; |
46 | ||
47 | #define to_icst(_hw) container_of(_hw, struct clk_icst, hw) | |
48 | ||
7a9ad671 | 49 | /** |
179c8fb3 LW |
50 | * vco_get() - get ICST VCO settings from a certain ICST |
51 | * @icst: the ICST clock to get | |
52 | * @vco: the VCO struct to return the value in | |
7a9ad671 | 53 | */ |
179c8fb3 | 54 | static int vco_get(struct clk_icst *icst, struct icst_vco *vco) |
7a9ad671 LW |
55 | { |
56 | u32 val; | |
179c8fb3 LW |
57 | int ret; |
58 | ||
59 | ret = regmap_read(icst->map, icst->vcoreg_off, &val); | |
60 | if (ret) | |
61 | return ret; | |
62 | vco->v = val & 0x1ff; | |
63 | vco->r = (val >> 9) & 0x7f; | |
64 | vco->s = (val >> 16) & 03; | |
65 | return 0; | |
7a9ad671 LW |
66 | } |
67 | ||
68 | /** | |
69 | * vco_set() - commit changes to an ICST VCO | |
179c8fb3 LW |
70 | * @icst: the ICST clock to set |
71 | * @vco: the VCO struct to set the changes from | |
7a9ad671 | 72 | */ |
179c8fb3 | 73 | static int vco_set(struct clk_icst *icst, struct icst_vco vco) |
7a9ad671 LW |
74 | { |
75 | u32 val; | |
179c8fb3 | 76 | int ret; |
7a9ad671 | 77 | |
179c8fb3 LW |
78 | ret = regmap_read(icst->map, icst->vcoreg_off, &val); |
79 | if (ret) | |
80 | return ret; | |
df9cd564 LW |
81 | |
82 | /* Mask the 18 bits used by the VCO */ | |
83 | val &= ~0x7ffff; | |
7a9ad671 LW |
84 | val |= vco.v | (vco.r << 9) | (vco.s << 16); |
85 | ||
86 | /* This magic unlocks the VCO so it can be controlled */ | |
179c8fb3 LW |
87 | ret = regmap_write(icst->map, icst->lockreg_off, VERSATILE_LOCK_VAL); |
88 | if (ret) | |
89 | return ret; | |
90 | ret = regmap_write(icst->map, icst->vcoreg_off, val); | |
91 | if (ret) | |
92 | return ret; | |
7a9ad671 | 93 | /* This locks the VCO again */ |
179c8fb3 LW |
94 | ret = regmap_write(icst->map, icst->lockreg_off, 0); |
95 | if (ret) | |
96 | return ret; | |
97 | return 0; | |
7a9ad671 LW |
98 | } |
99 | ||
91b87a47 LW |
100 | static unsigned long icst_recalc_rate(struct clk_hw *hw, |
101 | unsigned long parent_rate) | |
102 | { | |
103 | struct clk_icst *icst = to_icst(hw); | |
104 | struct icst_vco vco; | |
179c8fb3 | 105 | int ret; |
91b87a47 | 106 | |
a183da63 LW |
107 | if (parent_rate) |
108 | icst->params->ref = parent_rate; | |
179c8fb3 LW |
109 | ret = vco_get(icst, &vco); |
110 | if (ret) { | |
111 | pr_err("ICST: could not get VCO setting\n"); | |
112 | return 0; | |
113 | } | |
91b87a47 LW |
114 | icst->rate = icst_hz(icst->params, vco); |
115 | return icst->rate; | |
116 | } | |
117 | ||
118 | static long icst_round_rate(struct clk_hw *hw, unsigned long rate, | |
119 | unsigned long *prate) | |
120 | { | |
121 | struct clk_icst *icst = to_icst(hw); | |
122 | struct icst_vco vco; | |
123 | ||
124 | vco = icst_hz_to_vco(icst->params, rate); | |
125 | return icst_hz(icst->params, vco); | |
126 | } | |
127 | ||
128 | static int icst_set_rate(struct clk_hw *hw, unsigned long rate, | |
129 | unsigned long parent_rate) | |
130 | { | |
131 | struct clk_icst *icst = to_icst(hw); | |
132 | struct icst_vco vco; | |
133 | ||
a183da63 LW |
134 | if (parent_rate) |
135 | icst->params->ref = parent_rate; | |
91b87a47 LW |
136 | vco = icst_hz_to_vco(icst->params, rate); |
137 | icst->rate = icst_hz(icst->params, vco); | |
179c8fb3 | 138 | return vco_set(icst, vco); |
91b87a47 LW |
139 | } |
140 | ||
141 | static const struct clk_ops icst_ops = { | |
142 | .recalc_rate = icst_recalc_rate, | |
143 | .round_rate = icst_round_rate, | |
144 | .set_rate = icst_set_rate, | |
145 | }; | |
146 | ||
384d977d LW |
147 | static struct clk *icst_clk_setup(struct device *dev, |
148 | const struct clk_icst_desc *desc, | |
149 | const char *name, | |
150 | const char *parent_name, | |
151 | struct regmap *map) | |
91b87a47 LW |
152 | { |
153 | struct clk *clk; | |
154 | struct clk_icst *icst; | |
155 | struct clk_init_data init; | |
a183da63 | 156 | struct icst_params *pclone; |
91b87a47 LW |
157 | |
158 | icst = kzalloc(sizeof(struct clk_icst), GFP_KERNEL); | |
159 | if (!icst) { | |
160 | pr_err("could not allocate ICST clock!\n"); | |
161 | return ERR_PTR(-ENOMEM); | |
162 | } | |
a183da63 LW |
163 | |
164 | pclone = kmemdup(desc->params, sizeof(*pclone), GFP_KERNEL); | |
165 | if (!pclone) { | |
ab7ad353 | 166 | kfree(icst); |
a183da63 LW |
167 | pr_err("could not clone ICST params\n"); |
168 | return ERR_PTR(-ENOMEM); | |
169 | } | |
170 | ||
ae6e694e | 171 | init.name = name; |
91b87a47 LW |
172 | init.ops = &icst_ops; |
173 | init.flags = CLK_IS_ROOT; | |
a183da63 LW |
174 | init.parent_names = (parent_name ? &parent_name : NULL); |
175 | init.num_parents = (parent_name ? 1 : 0); | |
384d977d | 176 | icst->map = map; |
91b87a47 | 177 | icst->hw.init = &init; |
a183da63 | 178 | icst->params = pclone; |
179c8fb3 LW |
179 | icst->vcoreg_off = desc->vco_offset; |
180 | icst->lockreg_off = desc->lock_offset; | |
91b87a47 LW |
181 | |
182 | clk = clk_register(dev, &icst->hw); | |
7bdccef3 LW |
183 | if (IS_ERR(clk)) { |
184 | kfree(pclone); | |
91b87a47 | 185 | kfree(icst); |
7bdccef3 | 186 | } |
91b87a47 LW |
187 | |
188 | return clk; | |
189 | } | |
384d977d LW |
190 | |
191 | struct clk *icst_clk_register(struct device *dev, | |
192 | const struct clk_icst_desc *desc, | |
193 | const char *name, | |
194 | const char *parent_name, | |
195 | void __iomem *base) | |
196 | { | |
197 | struct regmap_config icst_regmap_conf = { | |
198 | .reg_bits = 32, | |
199 | .val_bits = 32, | |
200 | .reg_stride = 4, | |
201 | }; | |
202 | struct regmap *map; | |
203 | ||
204 | map = regmap_init_mmio(dev, base, &icst_regmap_conf); | |
205 | if (IS_ERR(map)) { | |
206 | pr_err("could not initialize ICST regmap\n"); | |
207 | return ERR_CAST(map); | |
208 | } | |
209 | return icst_clk_setup(dev, desc, name, parent_name, map); | |
210 | } | |
a218d7fa | 211 | EXPORT_SYMBOL_GPL(icst_clk_register); |
d430819d LW |
212 | |
213 | #ifdef CONFIG_OF | |
214 | /* | |
215 | * In a device tree, an memory-mapped ICST clock appear as a child | |
216 | * of a syscon node. Assume this and probe it only as a child of a | |
217 | * syscon. | |
218 | */ | |
219 | ||
220 | static const struct icst_params icst525_params = { | |
221 | .vco_max = ICST525_VCO_MAX_5V, | |
222 | .vco_min = ICST525_VCO_MIN, | |
223 | .vd_min = 8, | |
224 | .vd_max = 263, | |
225 | .rd_min = 3, | |
226 | .rd_max = 65, | |
227 | .s2div = icst525_s2div, | |
228 | .idx2s = icst525_idx2s, | |
229 | }; | |
230 | ||
231 | static const struct icst_params icst307_params = { | |
232 | .vco_max = ICST307_VCO_MAX, | |
233 | .vco_min = ICST307_VCO_MIN, | |
234 | .vd_min = 4 + 8, | |
235 | .vd_max = 511 + 8, | |
236 | .rd_min = 1 + 2, | |
237 | .rd_max = 127 + 2, | |
238 | .s2div = icst307_s2div, | |
239 | .idx2s = icst307_idx2s, | |
240 | }; | |
241 | ||
242 | static void __init of_syscon_icst_setup(struct device_node *np) | |
243 | { | |
244 | struct device_node *parent; | |
245 | struct regmap *map; | |
246 | struct clk_icst_desc icst_desc; | |
247 | const char *name = np->name; | |
248 | const char *parent_name; | |
249 | struct clk *regclk; | |
250 | ||
251 | /* We do not release this reference, we are using it perpetually */ | |
252 | parent = of_get_parent(np); | |
253 | if (!parent) { | |
254 | pr_err("no parent node for syscon ICST clock\n"); | |
255 | return; | |
256 | } | |
257 | map = syscon_node_to_regmap(parent); | |
258 | if (IS_ERR(map)) { | |
259 | pr_err("no regmap for syscon ICST clock parent\n"); | |
260 | return; | |
261 | } | |
262 | ||
263 | if (of_property_read_u32(np, "vco-offset", &icst_desc.vco_offset)) { | |
264 | pr_err("no VCO register offset for ICST clock\n"); | |
265 | return; | |
266 | } | |
267 | if (of_property_read_u32(np, "lock-offset", &icst_desc.lock_offset)) { | |
268 | pr_err("no lock register offset for ICST clock\n"); | |
269 | return; | |
270 | } | |
271 | ||
272 | if (of_device_is_compatible(np, "arm,syscon-icst525")) | |
273 | icst_desc.params = &icst525_params; | |
274 | else if (of_device_is_compatible(np, "arm,syscon-icst307")) | |
275 | icst_desc.params = &icst307_params; | |
276 | else { | |
277 | pr_err("unknown ICST clock %s\n", name); | |
278 | return; | |
279 | } | |
280 | ||
281 | /* Parent clock name is not the same as node parent */ | |
282 | parent_name = of_clk_get_parent_name(np, 0); | |
283 | ||
284 | regclk = icst_clk_setup(NULL, &icst_desc, name, parent_name, map); | |
285 | if (IS_ERR(regclk)) { | |
286 | pr_err("error setting up syscon ICST clock %s\n", name); | |
287 | return; | |
288 | } | |
289 | of_clk_add_provider(np, of_clk_src_simple_get, regclk); | |
290 | pr_debug("registered syscon ICST clock %s\n", name); | |
291 | } | |
292 | ||
293 | CLK_OF_DECLARE(arm_syscon_icst525_clk, | |
294 | "arm,syscon-icst525", of_syscon_icst_setup); | |
295 | CLK_OF_DECLARE(arm_syscon_icst307_clk, | |
296 | "arm,syscon-icst307", of_syscon_icst_setup); | |
297 | ||
298 | #endif |