1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright 2016 Maxime Ripard
4 *
5 * Maxime Ripard <maxime.ripard@free-electrons.com>
6 */
7
8 #include <linux/clk.h>
9 #include <linux/clk-provider.h>
10 #include <linux/device.h>
11 #include <linux/iopoll.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14
15 #include "ccu_common.h"
16 #include "ccu_gate.h"
17 #include "ccu_reset.h"
18
19 struct sunxi_ccu {
20 const struct sunxi_ccu_desc *desc;
21 spinlock_t lock;
22 struct ccu_reset reset;
23 };
24
ccu_helper_wait_for_lock(struct ccu_common * common,u32 lock)25 void ccu_helper_wait_for_lock(struct ccu_common *common, u32 lock)
26 {
27 void __iomem *addr;
28 u32 reg;
29
30 if (!lock)
31 return;
32
33 if (common->features & CCU_FEATURE_LOCK_REG)
34 addr = common->base + common->lock_reg;
35 else
36 addr = common->base + common->reg;
37
38 WARN_ON(readl_relaxed_poll_timeout(addr, reg, reg & lock, 100, 70000));
39 }
40 EXPORT_SYMBOL_NS_GPL(ccu_helper_wait_for_lock, SUNXI_CCU);
41
ccu_is_better_rate(struct ccu_common * common,unsigned long target_rate,unsigned long current_rate,unsigned long best_rate)42 bool ccu_is_better_rate(struct ccu_common *common,
43 unsigned long target_rate,
44 unsigned long current_rate,
45 unsigned long best_rate)
46 {
47 unsigned long min_rate, max_rate;
48
49 clk_hw_get_rate_range(&common->hw, &min_rate, &max_rate);
50
51 if (current_rate > max_rate)
52 return false;
53
54 if (current_rate < min_rate)
55 return false;
56
57 if (common->features & CCU_FEATURE_CLOSEST_RATE)
58 return abs(current_rate - target_rate) < abs(best_rate - target_rate);
59
60 return current_rate <= target_rate && current_rate > best_rate;
61 }
62 EXPORT_SYMBOL_NS_GPL(ccu_is_better_rate, SUNXI_CCU);
63
64 /*
65 * This clock notifier is called when the frequency of a PLL clock is
66 * changed. In common PLL designs, changes to the dividers take effect
67 * almost immediately, while changes to the multipliers (implemented
68 * as dividers in the feedback loop) take a few cycles to work into
69 * the feedback loop for the PLL to stablize.
70 *
71 * Sometimes when the PLL clock rate is changed, the decrease in the
72 * divider is too much for the decrease in the multiplier to catch up.
73 * The PLL clock rate will spike, and in some cases, might lock up
74 * completely.
75 *
76 * This notifier callback will gate and then ungate the clock,
77 * effectively resetting it, so it proceeds to work. Care must be
78 * taken to reparent consumers to other temporary clocks during the
79 * rate change, and that this notifier callback must be the first
80 * to be registered.
81 */
ccu_pll_notifier_cb(struct notifier_block * nb,unsigned long event,void * data)82 static int ccu_pll_notifier_cb(struct notifier_block *nb,
83 unsigned long event, void *data)
84 {
85 struct ccu_pll_nb *pll = to_ccu_pll_nb(nb);
86 int ret = 0;
87
88 if (event != POST_RATE_CHANGE)
89 goto out;
90
91 ccu_gate_helper_disable(pll->common, pll->enable);
92
93 ret = ccu_gate_helper_enable(pll->common, pll->enable);
94 if (ret)
95 goto out;
96
97 ccu_helper_wait_for_lock(pll->common, pll->lock);
98
99 out:
100 return notifier_from_errno(ret);
101 }
102
ccu_pll_notifier_register(struct ccu_pll_nb * pll_nb)103 int ccu_pll_notifier_register(struct ccu_pll_nb *pll_nb)
104 {
105 pll_nb->clk_nb.notifier_call = ccu_pll_notifier_cb;
106
107 return clk_notifier_register(pll_nb->common->hw.clk,
108 &pll_nb->clk_nb);
109 }
110 EXPORT_SYMBOL_NS_GPL(ccu_pll_notifier_register, SUNXI_CCU);
111
sunxi_ccu_probe(struct sunxi_ccu * ccu,struct device * dev,struct device_node * node,void __iomem * reg,const struct sunxi_ccu_desc * desc)112 static int sunxi_ccu_probe(struct sunxi_ccu *ccu, struct device *dev,
113 struct device_node *node, void __iomem *reg,
114 const struct sunxi_ccu_desc *desc)
115 {
116 struct ccu_reset *reset;
117 int i, ret;
118
119 ccu->desc = desc;
120
121 spin_lock_init(&ccu->lock);
122
123 for (i = 0; i < desc->num_ccu_clks; i++) {
124 struct ccu_common *cclk = desc->ccu_clks[i];
125
126 if (!cclk)
127 continue;
128
129 cclk->base = reg;
130 cclk->lock = &ccu->lock;
131 }
132
133 for (i = 0; i < desc->hw_clks->num ; i++) {
134 struct clk_hw *hw = desc->hw_clks->hws[i];
135 struct ccu_common *common = hw_to_ccu_common(hw);
136 const char *name;
137
138 if (!hw)
139 continue;
140
141 name = hw->init->name;
142 if (dev)
143 ret = clk_hw_register(dev, hw);
144 else
145 ret = of_clk_hw_register(node, hw);
146 if (ret) {
147 pr_err("Couldn't register clock %d - %s\n", i, name);
148 goto err_clk_unreg;
149 }
150
151 if (common->max_rate)
152 clk_hw_set_rate_range(hw, common->min_rate,
153 common->max_rate);
154 else
155 WARN(common->min_rate,
156 "No max_rate, ignoring min_rate of clock %d - %s\n",
157 i, name);
158 }
159
160 ret = of_clk_add_hw_provider(node, of_clk_hw_onecell_get,
161 desc->hw_clks);
162 if (ret)
163 goto err_clk_unreg;
164
165 reset = &ccu->reset;
166 reset->rcdev.of_node = node;
167 reset->rcdev.ops = &ccu_reset_ops;
168 reset->rcdev.owner = dev ? dev->driver->owner : THIS_MODULE;
169 reset->rcdev.nr_resets = desc->num_resets;
170 reset->base = reg;
171 reset->lock = &ccu->lock;
172 reset->reset_map = desc->resets;
173
174 ret = reset_controller_register(&reset->rcdev);
175 if (ret)
176 goto err_del_provider;
177
178 return 0;
179
180 err_del_provider:
181 of_clk_del_provider(node);
182 err_clk_unreg:
183 while (--i >= 0) {
184 struct clk_hw *hw = desc->hw_clks->hws[i];
185
186 if (!hw)
187 continue;
188 clk_hw_unregister(hw);
189 }
190 return ret;
191 }
192
devm_sunxi_ccu_release(struct device * dev,void * res)193 static void devm_sunxi_ccu_release(struct device *dev, void *res)
194 {
195 struct sunxi_ccu *ccu = res;
196 const struct sunxi_ccu_desc *desc = ccu->desc;
197 int i;
198
199 reset_controller_unregister(&ccu->reset.rcdev);
200 of_clk_del_provider(dev->of_node);
201
202 for (i = 0; i < desc->hw_clks->num; i++) {
203 struct clk_hw *hw = desc->hw_clks->hws[i];
204
205 if (!hw)
206 continue;
207 clk_hw_unregister(hw);
208 }
209 }
210
devm_sunxi_ccu_probe(struct device * dev,void __iomem * reg,const struct sunxi_ccu_desc * desc)211 int devm_sunxi_ccu_probe(struct device *dev, void __iomem *reg,
212 const struct sunxi_ccu_desc *desc)
213 {
214 struct sunxi_ccu *ccu;
215 int ret;
216
217 ccu = devres_alloc(devm_sunxi_ccu_release, sizeof(*ccu), GFP_KERNEL);
218 if (!ccu)
219 return -ENOMEM;
220
221 ret = sunxi_ccu_probe(ccu, dev, dev->of_node, reg, desc);
222 if (ret) {
223 devres_free(ccu);
224 return ret;
225 }
226
227 devres_add(dev, ccu);
228
229 return 0;
230 }
231 EXPORT_SYMBOL_NS_GPL(devm_sunxi_ccu_probe, SUNXI_CCU);
232
of_sunxi_ccu_probe(struct device_node * node,void __iomem * reg,const struct sunxi_ccu_desc * desc)233 void of_sunxi_ccu_probe(struct device_node *node, void __iomem *reg,
234 const struct sunxi_ccu_desc *desc)
235 {
236 struct sunxi_ccu *ccu;
237 int ret;
238
239 ccu = kzalloc(sizeof(*ccu), GFP_KERNEL);
240 if (!ccu)
241 return;
242
243 ret = sunxi_ccu_probe(ccu, NULL, node, reg, desc);
244 if (ret) {
245 pr_err("%pOF: probing clocks failed: %d\n", node, ret);
246 kfree(ccu);
247 }
248 }
249
250 MODULE_LICENSE("GPL");
251