xref: /openbmc/linux/drivers/clk/clkdev.c (revision 6d0881a0)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * drivers/clk/clkdev.c
4  *
5  *  Copyright (C) 2008 Russell King.
6  *
7  * Helper for the clk API to assist looking up a struct clk.
8  */
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/device.h>
12 #include <linux/list.h>
13 #include <linux/errno.h>
14 #include <linux/err.h>
15 #include <linux/string.h>
16 #include <linux/mutex.h>
17 #include <linux/clk.h>
18 #include <linux/clkdev.h>
19 #include <linux/clk-provider.h>
20 #include <linux/of.h>
21 
22 #include "clk.h"
23 
24 static LIST_HEAD(clocks);
25 static DEFINE_MUTEX(clocks_mutex);
26 
27 /*
28  * Find the correct struct clk for the device and connection ID.
29  * We do slightly fuzzy matching here:
30  *  An entry with a NULL ID is assumed to be a wildcard.
31  *  If an entry has a device ID, it must match
32  *  If an entry has a connection ID, it must match
33  * Then we take the most specific entry - with the following
34  * order of precedence: dev+con > dev only > con only.
35  */
clk_find(const char * dev_id,const char * con_id)36 static struct clk_lookup *clk_find(const char *dev_id, const char *con_id)
37 {
38 	struct clk_lookup *p, *cl = NULL;
39 	int match, best_found = 0, best_possible = 0;
40 
41 	if (dev_id)
42 		best_possible += 2;
43 	if (con_id)
44 		best_possible += 1;
45 
46 	lockdep_assert_held(&clocks_mutex);
47 
48 	list_for_each_entry(p, &clocks, node) {
49 		match = 0;
50 		if (p->dev_id) {
51 			if (!dev_id || strcmp(p->dev_id, dev_id))
52 				continue;
53 			match += 2;
54 		}
55 		if (p->con_id) {
56 			if (!con_id || strcmp(p->con_id, con_id))
57 				continue;
58 			match += 1;
59 		}
60 
61 		if (match > best_found) {
62 			cl = p;
63 			if (match != best_possible)
64 				best_found = match;
65 			else
66 				break;
67 		}
68 	}
69 	return cl;
70 }
71 
clk_find_hw(const char * dev_id,const char * con_id)72 struct clk_hw *clk_find_hw(const char *dev_id, const char *con_id)
73 {
74 	struct clk_lookup *cl;
75 	struct clk_hw *hw = ERR_PTR(-ENOENT);
76 
77 	mutex_lock(&clocks_mutex);
78 	cl = clk_find(dev_id, con_id);
79 	if (cl)
80 		hw = cl->clk_hw;
81 	mutex_unlock(&clocks_mutex);
82 
83 	return hw;
84 }
85 
__clk_get_sys(struct device * dev,const char * dev_id,const char * con_id)86 static struct clk *__clk_get_sys(struct device *dev, const char *dev_id,
87 				 const char *con_id)
88 {
89 	struct clk_hw *hw = clk_find_hw(dev_id, con_id);
90 
91 	return clk_hw_create_clk(dev, hw, dev_id, con_id);
92 }
93 
clk_get_sys(const char * dev_id,const char * con_id)94 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
95 {
96 	return __clk_get_sys(NULL, dev_id, con_id);
97 }
98 EXPORT_SYMBOL(clk_get_sys);
99 
clk_get(struct device * dev,const char * con_id)100 struct clk *clk_get(struct device *dev, const char *con_id)
101 {
102 	const char *dev_id = dev ? dev_name(dev) : NULL;
103 	struct clk_hw *hw;
104 
105 	if (dev && dev->of_node) {
106 		hw = of_clk_get_hw(dev->of_node, 0, con_id);
107 		if (!IS_ERR(hw) || PTR_ERR(hw) == -EPROBE_DEFER)
108 			return clk_hw_create_clk(dev, hw, dev_id, con_id);
109 	}
110 
111 	return __clk_get_sys(dev, dev_id, con_id);
112 }
113 EXPORT_SYMBOL(clk_get);
114 
clk_put(struct clk * clk)115 void clk_put(struct clk *clk)
116 {
117 	__clk_put(clk);
118 }
119 EXPORT_SYMBOL(clk_put);
120 
__clkdev_add(struct clk_lookup * cl)121 static void __clkdev_add(struct clk_lookup *cl)
122 {
123 	mutex_lock(&clocks_mutex);
124 	list_add_tail(&cl->node, &clocks);
125 	mutex_unlock(&clocks_mutex);
126 }
127 
clkdev_add(struct clk_lookup * cl)128 void clkdev_add(struct clk_lookup *cl)
129 {
130 	if (!cl->clk_hw)
131 		cl->clk_hw = __clk_get_hw(cl->clk);
132 	__clkdev_add(cl);
133 }
134 EXPORT_SYMBOL(clkdev_add);
135 
clkdev_add_table(struct clk_lookup * cl,size_t num)136 void clkdev_add_table(struct clk_lookup *cl, size_t num)
137 {
138 	mutex_lock(&clocks_mutex);
139 	while (num--) {
140 		cl->clk_hw = __clk_get_hw(cl->clk);
141 		list_add_tail(&cl->node, &clocks);
142 		cl++;
143 	}
144 	mutex_unlock(&clocks_mutex);
145 }
146 
147 #define MAX_DEV_ID	24
148 #define MAX_CON_ID	16
149 
150 struct clk_lookup_alloc {
151 	struct clk_lookup cl;
152 	char	dev_id[MAX_DEV_ID];
153 	char	con_id[MAX_CON_ID];
154 };
155 
156 static struct clk_lookup * __ref
vclkdev_alloc(struct clk_hw * hw,const char * con_id,const char * dev_fmt,va_list ap)157 vclkdev_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
158 	va_list ap)
159 {
160 	struct clk_lookup_alloc *cla;
161 
162 	cla = kzalloc(sizeof(*cla), GFP_KERNEL);
163 	if (!cla)
164 		return NULL;
165 
166 	cla->cl.clk_hw = hw;
167 	if (con_id) {
168 		strscpy(cla->con_id, con_id, sizeof(cla->con_id));
169 		cla->cl.con_id = cla->con_id;
170 	}
171 
172 	if (dev_fmt) {
173 		vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
174 		cla->cl.dev_id = cla->dev_id;
175 	}
176 
177 	return &cla->cl;
178 }
179 
180 static struct clk_lookup *
vclkdev_create(struct clk_hw * hw,const char * con_id,const char * dev_fmt,va_list ap)181 vclkdev_create(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
182 	va_list ap)
183 {
184 	struct clk_lookup *cl;
185 
186 	cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
187 	if (cl)
188 		__clkdev_add(cl);
189 
190 	return cl;
191 }
192 
193 /**
194  * clkdev_create - allocate and add a clkdev lookup structure
195  * @clk: struct clk to associate with all clk_lookups
196  * @con_id: connection ID string on device
197  * @dev_fmt: format string describing device name
198  *
199  * Returns a clk_lookup structure, which can be later unregistered and
200  * freed.
201  */
clkdev_create(struct clk * clk,const char * con_id,const char * dev_fmt,...)202 struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
203 	const char *dev_fmt, ...)
204 {
205 	struct clk_lookup *cl;
206 	va_list ap;
207 
208 	va_start(ap, dev_fmt);
209 	cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);
210 	va_end(ap);
211 
212 	return cl;
213 }
214 EXPORT_SYMBOL_GPL(clkdev_create);
215 
216 /**
217  * clkdev_hw_create - allocate and add a clkdev lookup structure
218  * @hw: struct clk_hw to associate with all clk_lookups
219  * @con_id: connection ID string on device
220  * @dev_fmt: format string describing device name
221  *
222  * Returns a clk_lookup structure, which can be later unregistered and
223  * freed.
224  */
clkdev_hw_create(struct clk_hw * hw,const char * con_id,const char * dev_fmt,...)225 struct clk_lookup *clkdev_hw_create(struct clk_hw *hw, const char *con_id,
226 	const char *dev_fmt, ...)
227 {
228 	struct clk_lookup *cl;
229 	va_list ap;
230 
231 	va_start(ap, dev_fmt);
232 	cl = vclkdev_create(hw, con_id, dev_fmt, ap);
233 	va_end(ap);
234 
235 	return cl;
236 }
237 EXPORT_SYMBOL_GPL(clkdev_hw_create);
238 
clk_add_alias(const char * alias,const char * alias_dev_name,const char * con_id,struct device * dev)239 int clk_add_alias(const char *alias, const char *alias_dev_name,
240 	const char *con_id, struct device *dev)
241 {
242 	struct clk *r = clk_get(dev, con_id);
243 	struct clk_lookup *l;
244 
245 	if (IS_ERR(r))
246 		return PTR_ERR(r);
247 
248 	l = clkdev_create(r, alias, alias_dev_name ? "%s" : NULL,
249 			  alias_dev_name);
250 	clk_put(r);
251 
252 	return l ? 0 : -ENODEV;
253 }
254 EXPORT_SYMBOL(clk_add_alias);
255 
256 /*
257  * clkdev_drop - remove a clock dynamically allocated
258  */
clkdev_drop(struct clk_lookup * cl)259 void clkdev_drop(struct clk_lookup *cl)
260 {
261 	mutex_lock(&clocks_mutex);
262 	list_del(&cl->node);
263 	mutex_unlock(&clocks_mutex);
264 	kfree(cl);
265 }
266 EXPORT_SYMBOL(clkdev_drop);
267 
__clk_register_clkdev(struct clk_hw * hw,const char * con_id,const char * dev_id,...)268 static struct clk_lookup *__clk_register_clkdev(struct clk_hw *hw,
269 						const char *con_id,
270 						const char *dev_id, ...)
271 {
272 	struct clk_lookup *cl;
273 	va_list ap;
274 
275 	va_start(ap, dev_id);
276 	cl = vclkdev_create(hw, con_id, dev_id, ap);
277 	va_end(ap);
278 
279 	return cl;
280 }
281 
do_clk_register_clkdev(struct clk_hw * hw,struct clk_lookup ** cl,const char * con_id,const char * dev_id)282 static int do_clk_register_clkdev(struct clk_hw *hw,
283 	struct clk_lookup **cl, const char *con_id, const char *dev_id)
284 {
285 	if (IS_ERR(hw))
286 		return PTR_ERR(hw);
287 	/*
288 	 * Since dev_id can be NULL, and NULL is handled specially, we must
289 	 * pass it as either a NULL format string, or with "%s".
290 	 */
291 	if (dev_id)
292 		*cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);
293 	else
294 		*cl = __clk_register_clkdev(hw, con_id, NULL);
295 
296 	return *cl ? 0 : -ENOMEM;
297 }
298 
299 /**
300  * clk_register_clkdev - register one clock lookup for a struct clk
301  * @clk: struct clk to associate with all clk_lookups
302  * @con_id: connection ID string on device
303  * @dev_id: string describing device name
304  *
305  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
306  * clkdev.
307  *
308  * To make things easier for mass registration, we detect error clks
309  * from a previous clk_register() call, and return the error code for
310  * those.  This is to permit this function to be called immediately
311  * after clk_register().
312  */
clk_register_clkdev(struct clk * clk,const char * con_id,const char * dev_id)313 int clk_register_clkdev(struct clk *clk, const char *con_id,
314 	const char *dev_id)
315 {
316 	struct clk_lookup *cl;
317 
318 	if (IS_ERR(clk))
319 		return PTR_ERR(clk);
320 
321 	return do_clk_register_clkdev(__clk_get_hw(clk), &cl, con_id,
322 					      dev_id);
323 }
324 EXPORT_SYMBOL(clk_register_clkdev);
325 
326 /**
327  * clk_hw_register_clkdev - register one clock lookup for a struct clk_hw
328  * @hw: struct clk_hw to associate with all clk_lookups
329  * @con_id: connection ID string on device
330  * @dev_id: format string describing device name
331  *
332  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
333  * clkdev.
334  *
335  * To make things easier for mass registration, we detect error clk_hws
336  * from a previous clk_hw_register_*() call, and return the error code for
337  * those.  This is to permit this function to be called immediately
338  * after clk_hw_register_*().
339  */
clk_hw_register_clkdev(struct clk_hw * hw,const char * con_id,const char * dev_id)340 int clk_hw_register_clkdev(struct clk_hw *hw, const char *con_id,
341 	const char *dev_id)
342 {
343 	struct clk_lookup *cl;
344 
345 	return do_clk_register_clkdev(hw, &cl, con_id, dev_id);
346 }
347 EXPORT_SYMBOL(clk_hw_register_clkdev);
348 
devm_clkdev_release(void * res)349 static void devm_clkdev_release(void *res)
350 {
351 	clkdev_drop(res);
352 }
353 
354 /**
355  * devm_clk_hw_register_clkdev - managed clk lookup registration for clk_hw
356  * @dev: device this lookup is bound
357  * @hw: struct clk_hw to associate with all clk_lookups
358  * @con_id: connection ID string on device
359  * @dev_id: format string describing device name
360  *
361  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
362  * clkdev.
363  *
364  * To make things easier for mass registration, we detect error clk_hws
365  * from a previous clk_hw_register_*() call, and return the error code for
366  * those.  This is to permit this function to be called immediately
367  * after clk_hw_register_*().
368  */
devm_clk_hw_register_clkdev(struct device * dev,struct clk_hw * hw,const char * con_id,const char * dev_id)369 int devm_clk_hw_register_clkdev(struct device *dev, struct clk_hw *hw,
370 				const char *con_id, const char *dev_id)
371 {
372 	struct clk_lookup *cl;
373 	int rval;
374 
375 	rval = do_clk_register_clkdev(hw, &cl, con_id, dev_id);
376 	if (rval)
377 		return rval;
378 
379 	return devm_add_action_or_reset(dev, devm_clkdev_release, cl);
380 }
381 EXPORT_SYMBOL(devm_clk_hw_register_clkdev);
382