1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com> |
4 | * Copyright (C) 2011-2012 Mike Turquette, Linaro Ltd <mturquette@linaro.org> |
5 | * |
6 | * Fixed rate clock implementation |
7 | */ |
8 | |
9 | #include <linux/clk-provider.h> |
10 | #include <linux/module.h> |
11 | #include <linux/slab.h> |
12 | #include <linux/io.h> |
13 | #include <linux/err.h> |
14 | #include <linux/of.h> |
15 | #include <linux/platform_device.h> |
16 | |
17 | /* |
18 | * DOC: basic fixed-rate clock that cannot gate |
19 | * |
20 | * Traits of this clock: |
21 | * prepare - clk_(un)prepare only ensures parents are prepared |
22 | * enable - clk_enable only ensures parents are enabled |
23 | * rate - rate is always a fixed value. No clk_set_rate support |
24 | * parent - fixed parent. No clk_set_parent support |
25 | */ |
26 | |
27 | #define to_clk_fixed_rate(_hw) container_of(_hw, struct clk_fixed_rate, hw) |
28 | |
29 | static unsigned long clk_fixed_rate_recalc_rate(struct clk_hw *hw, |
30 | unsigned long parent_rate) |
31 | { |
32 | return to_clk_fixed_rate(hw)->fixed_rate; |
33 | } |
34 | |
35 | static unsigned long clk_fixed_rate_recalc_accuracy(struct clk_hw *hw, |
36 | unsigned long parent_accuracy) |
37 | { |
38 | struct clk_fixed_rate *fixed = to_clk_fixed_rate(hw); |
39 | |
40 | if (fixed->flags & CLK_FIXED_RATE_PARENT_ACCURACY) |
41 | return parent_accuracy; |
42 | |
43 | return fixed->fixed_accuracy; |
44 | } |
45 | |
46 | const struct clk_ops clk_fixed_rate_ops = { |
47 | .recalc_rate = clk_fixed_rate_recalc_rate, |
48 | .recalc_accuracy = clk_fixed_rate_recalc_accuracy, |
49 | }; |
50 | EXPORT_SYMBOL_GPL(clk_fixed_rate_ops); |
51 | |
52 | static void devm_clk_hw_register_fixed_rate_release(struct device *dev, void *res) |
53 | { |
54 | struct clk_fixed_rate *fix = res; |
55 | |
56 | /* |
57 | * We can not use clk_hw_unregister_fixed_rate, since it will kfree() |
58 | * the hw, resulting in double free. Just unregister the hw and let |
59 | * devres code kfree() it. |
60 | */ |
61 | clk_hw_unregister(hw: &fix->hw); |
62 | } |
63 | |
64 | struct clk_hw *__clk_hw_register_fixed_rate(struct device *dev, |
65 | struct device_node *np, const char *name, |
66 | const char *parent_name, const struct clk_hw *parent_hw, |
67 | const struct clk_parent_data *parent_data, unsigned long flags, |
68 | unsigned long fixed_rate, unsigned long fixed_accuracy, |
69 | unsigned long clk_fixed_flags, bool devm) |
70 | { |
71 | struct clk_fixed_rate *fixed; |
72 | struct clk_hw *hw; |
73 | struct clk_init_data init = {}; |
74 | int ret = -EINVAL; |
75 | |
76 | /* allocate fixed-rate clock */ |
77 | if (devm) |
78 | fixed = devres_alloc(devm_clk_hw_register_fixed_rate_release, |
79 | sizeof(*fixed), GFP_KERNEL); |
80 | else |
81 | fixed = kzalloc(size: sizeof(*fixed), GFP_KERNEL); |
82 | if (!fixed) |
83 | return ERR_PTR(error: -ENOMEM); |
84 | |
85 | init.name = name; |
86 | init.ops = &clk_fixed_rate_ops; |
87 | init.flags = flags; |
88 | init.parent_names = parent_name ? &parent_name : NULL; |
89 | init.parent_hws = parent_hw ? &parent_hw : NULL; |
90 | init.parent_data = parent_data; |
91 | if (parent_name || parent_hw || parent_data) |
92 | init.num_parents = 1; |
93 | else |
94 | init.num_parents = 0; |
95 | |
96 | /* struct clk_fixed_rate assignments */ |
97 | fixed->flags = clk_fixed_flags; |
98 | fixed->fixed_rate = fixed_rate; |
99 | fixed->fixed_accuracy = fixed_accuracy; |
100 | fixed->hw.init = &init; |
101 | |
102 | /* register the clock */ |
103 | hw = &fixed->hw; |
104 | if (dev || !np) |
105 | ret = clk_hw_register(dev, hw); |
106 | else |
107 | ret = of_clk_hw_register(node: np, hw); |
108 | if (ret) { |
109 | if (devm) |
110 | devres_free(res: fixed); |
111 | else |
112 | kfree(objp: fixed); |
113 | hw = ERR_PTR(error: ret); |
114 | } else if (devm) |
115 | devres_add(dev, res: fixed); |
116 | |
117 | return hw; |
118 | } |
119 | EXPORT_SYMBOL_GPL(__clk_hw_register_fixed_rate); |
120 | |
121 | struct clk *clk_register_fixed_rate(struct device *dev, const char *name, |
122 | const char *parent_name, unsigned long flags, |
123 | unsigned long fixed_rate) |
124 | { |
125 | struct clk_hw *hw; |
126 | |
127 | hw = clk_hw_register_fixed_rate_with_accuracy(dev, name, parent_name, |
128 | flags, fixed_rate, 0); |
129 | if (IS_ERR(ptr: hw)) |
130 | return ERR_CAST(ptr: hw); |
131 | return hw->clk; |
132 | } |
133 | EXPORT_SYMBOL_GPL(clk_register_fixed_rate); |
134 | |
135 | void clk_unregister_fixed_rate(struct clk *clk) |
136 | { |
137 | struct clk_hw *hw; |
138 | |
139 | hw = __clk_get_hw(clk); |
140 | if (!hw) |
141 | return; |
142 | |
143 | clk_unregister(clk); |
144 | kfree(to_clk_fixed_rate(hw)); |
145 | } |
146 | EXPORT_SYMBOL_GPL(clk_unregister_fixed_rate); |
147 | |
148 | void clk_hw_unregister_fixed_rate(struct clk_hw *hw) |
149 | { |
150 | struct clk_fixed_rate *fixed; |
151 | |
152 | fixed = to_clk_fixed_rate(hw); |
153 | |
154 | clk_hw_unregister(hw); |
155 | kfree(objp: fixed); |
156 | } |
157 | EXPORT_SYMBOL_GPL(clk_hw_unregister_fixed_rate); |
158 | |
159 | #ifdef CONFIG_OF |
160 | static struct clk_hw *_of_fixed_clk_setup(struct device_node *node) |
161 | { |
162 | struct clk_hw *hw; |
163 | const char *clk_name = node->name; |
164 | u32 rate; |
165 | u32 accuracy = 0; |
166 | int ret; |
167 | |
168 | if (of_property_read_u32(np: node, propname: "clock-frequency" , out_value: &rate)) |
169 | return ERR_PTR(error: -EIO); |
170 | |
171 | of_property_read_u32(np: node, propname: "clock-accuracy" , out_value: &accuracy); |
172 | |
173 | of_property_read_string(np: node, propname: "clock-output-names" , out_string: &clk_name); |
174 | |
175 | hw = clk_hw_register_fixed_rate_with_accuracy(NULL, clk_name, NULL, |
176 | 0, rate, accuracy); |
177 | if (IS_ERR(ptr: hw)) |
178 | return hw; |
179 | |
180 | ret = of_clk_add_hw_provider(np: node, get: of_clk_hw_simple_get, data: hw); |
181 | if (ret) { |
182 | clk_hw_unregister_fixed_rate(hw); |
183 | return ERR_PTR(error: ret); |
184 | } |
185 | |
186 | return hw; |
187 | } |
188 | |
189 | /** |
190 | * of_fixed_clk_setup() - Setup function for simple fixed rate clock |
191 | * @node: device node for the clock |
192 | */ |
193 | void __init of_fixed_clk_setup(struct device_node *node) |
194 | { |
195 | _of_fixed_clk_setup(node); |
196 | } |
197 | CLK_OF_DECLARE(fixed_clk, "fixed-clock" , of_fixed_clk_setup); |
198 | |
199 | static void of_fixed_clk_remove(struct platform_device *pdev) |
200 | { |
201 | struct clk_hw *hw = platform_get_drvdata(pdev); |
202 | |
203 | of_clk_del_provider(np: pdev->dev.of_node); |
204 | clk_hw_unregister_fixed_rate(hw); |
205 | } |
206 | |
207 | static int of_fixed_clk_probe(struct platform_device *pdev) |
208 | { |
209 | struct clk_hw *hw; |
210 | |
211 | /* |
212 | * This function is not executed when of_fixed_clk_setup |
213 | * succeeded. |
214 | */ |
215 | hw = _of_fixed_clk_setup(node: pdev->dev.of_node); |
216 | if (IS_ERR(ptr: hw)) |
217 | return PTR_ERR(ptr: hw); |
218 | |
219 | platform_set_drvdata(pdev, data: hw); |
220 | |
221 | return 0; |
222 | } |
223 | |
224 | static const struct of_device_id of_fixed_clk_ids[] = { |
225 | { .compatible = "fixed-clock" }, |
226 | { } |
227 | }; |
228 | |
229 | static struct platform_driver of_fixed_clk_driver = { |
230 | .driver = { |
231 | .name = "of_fixed_clk" , |
232 | .of_match_table = of_fixed_clk_ids, |
233 | }, |
234 | .probe = of_fixed_clk_probe, |
235 | .remove_new = of_fixed_clk_remove, |
236 | }; |
237 | builtin_platform_driver(of_fixed_clk_driver); |
238 | #endif |
239 | |