1 /*
2  * drivers/clk/clkdev.c
3  *
4  *  Copyright (C) 2008 Russell King.
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 version 2 as
8  * published by the Free Software Foundation.
9  *
10  * Helper for the clk API to assist looking up a struct clk.
11  */
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/device.h>
15 #include <linux/list.h>
16 #include <linux/errno.h>
17 #include <linux/err.h>
18 #include <linux/string.h>
19 #include <linux/mutex.h>
20 #include <linux/clk.h>
21 #include <linux/clkdev.h>
22 #include <linux/clk-provider.h>
23 #include <linux/of.h>
24 
25 #include "clk.h"
26 
27 static LIST_HEAD(clocks);
28 static DEFINE_MUTEX(clocks_mutex);
29 
30 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
__of_clk_get(struct device_node * np,int index,const char * dev_id,const char * con_id)31 static struct clk *__of_clk_get(struct device_node *np, int index,
32 			       const char *dev_id, const char *con_id)
33 {
34 	struct of_phandle_args clkspec;
35 	struct clk *clk;
36 	int rc;
37 
38 	rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
39 					&clkspec);
40 	if (rc)
41 		return ERR_PTR(rc);
42 
43 	clk = __of_clk_get_from_provider(&clkspec, dev_id, con_id);
44 	of_node_put(clkspec.np);
45 
46 	return clk;
47 }
48 
of_clk_get(struct device_node * np,int index)49 struct clk *of_clk_get(struct device_node *np, int index)
50 {
51 	return __of_clk_get(np, index, np->full_name, NULL);
52 }
53 EXPORT_SYMBOL(of_clk_get);
54 
__of_clk_get_by_name(struct device_node * np,const char * dev_id,const char * name)55 static struct clk *__of_clk_get_by_name(struct device_node *np,
56 					const char *dev_id,
57 					const char *name)
58 {
59 	struct clk *clk = ERR_PTR(-ENOENT);
60 
61 	/* Walk up the tree of devices looking for a clock that matches */
62 	while (np) {
63 		int index = 0;
64 
65 		/*
66 		 * For named clocks, first look up the name in the
67 		 * "clock-names" property.  If it cannot be found, then
68 		 * index will be an error code, and of_clk_get() will fail.
69 		 */
70 		if (name)
71 			index = of_property_match_string(np, "clock-names", name);
72 		clk = __of_clk_get(np, index, dev_id, name);
73 		if (!IS_ERR(clk)) {
74 			break;
75 		} else if (name && index >= 0) {
76 			if (PTR_ERR(clk) != -EPROBE_DEFER)
77 				pr_err("ERROR: could not get clock %pOF:%s(%i)\n",
78 					np, name ? name : "", index);
79 			return clk;
80 		}
81 
82 		/*
83 		 * No matching clock found on this node.  If the parent node
84 		 * has a "clock-ranges" property, then we can try one of its
85 		 * clocks.
86 		 */
87 		np = np->parent;
88 		if (np && !of_get_property(np, "clock-ranges", NULL))
89 			break;
90 	}
91 
92 	return clk;
93 }
94 
95 /**
96  * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
97  * @np: pointer to clock consumer node
98  * @name: name of consumer's clock input, or NULL for the first clock reference
99  *
100  * This function parses the clocks and clock-names properties,
101  * and uses them to look up the struct clk from the registered list of clock
102  * providers.
103  */
of_clk_get_by_name(struct device_node * np,const char * name)104 struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
105 {
106 	if (!np)
107 		return ERR_PTR(-ENOENT);
108 
109 	return __of_clk_get_by_name(np, np->full_name, name);
110 }
111 EXPORT_SYMBOL(of_clk_get_by_name);
112 
113 #else /* defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK) */
114 
__of_clk_get_by_name(struct device_node * np,const char * dev_id,const char * name)115 static struct clk *__of_clk_get_by_name(struct device_node *np,
116 					const char *dev_id,
117 					const char *name)
118 {
119 	return ERR_PTR(-ENOENT);
120 }
121 #endif
122 
123 /*
124  * Find the correct struct clk for the device and connection ID.
125  * We do slightly fuzzy matching here:
126  *  An entry with a NULL ID is assumed to be a wildcard.
127  *  If an entry has a device ID, it must match
128  *  If an entry has a connection ID, it must match
129  * Then we take the most specific entry - with the following
130  * order of precedence: dev+con > dev only > con only.
131  */
clk_find(const char * dev_id,const char * con_id)132 static struct clk_lookup *clk_find(const char *dev_id, const char *con_id)
133 {
134 	struct clk_lookup *p, *cl = NULL;
135 	int match, best_found = 0, best_possible = 0;
136 
137 	if (dev_id)
138 		best_possible += 2;
139 	if (con_id)
140 		best_possible += 1;
141 
142 	list_for_each_entry(p, &clocks, node) {
143 		match = 0;
144 		if (p->dev_id) {
145 			if (!dev_id || strcmp(p->dev_id, dev_id))
146 				continue;
147 			match += 2;
148 		}
149 		if (p->con_id) {
150 			if (!con_id || strcmp(p->con_id, con_id))
151 				continue;
152 			match += 1;
153 		}
154 
155 		if (match > best_found) {
156 			cl = p;
157 			if (match != best_possible)
158 				best_found = match;
159 			else
160 				break;
161 		}
162 	}
163 	return cl;
164 }
165 
clk_get_sys(const char * dev_id,const char * con_id)166 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
167 {
168 	struct clk_lookup *cl;
169 	struct clk *clk = NULL;
170 
171 	mutex_lock(&clocks_mutex);
172 
173 	cl = clk_find(dev_id, con_id);
174 	if (!cl)
175 		goto out;
176 
177 	clk = __clk_create_clk(cl->clk_hw, dev_id, con_id);
178 	if (IS_ERR(clk))
179 		goto out;
180 
181 	if (!__clk_get(clk)) {
182 		__clk_free_clk(clk);
183 		cl = NULL;
184 		goto out;
185 	}
186 
187 out:
188 	mutex_unlock(&clocks_mutex);
189 
190 	return cl ? clk : ERR_PTR(-ENOENT);
191 }
192 EXPORT_SYMBOL(clk_get_sys);
193 
clk_get(struct device * dev,const char * con_id)194 struct clk *clk_get(struct device *dev, const char *con_id)
195 {
196 	const char *dev_id = dev ? dev_name(dev) : NULL;
197 	struct clk *clk;
198 
199 	if (dev && dev->of_node) {
200 		clk = __of_clk_get_by_name(dev->of_node, dev_id, con_id);
201 		if (!IS_ERR(clk) || PTR_ERR(clk) == -EPROBE_DEFER)
202 			return clk;
203 	}
204 
205 	return clk_get_sys(dev_id, con_id);
206 }
207 EXPORT_SYMBOL(clk_get);
208 
clk_put(struct clk * clk)209 void clk_put(struct clk *clk)
210 {
211 	__clk_put(clk);
212 }
213 EXPORT_SYMBOL(clk_put);
214 
__clkdev_add(struct clk_lookup * cl)215 static void __clkdev_add(struct clk_lookup *cl)
216 {
217 	mutex_lock(&clocks_mutex);
218 	list_add_tail(&cl->node, &clocks);
219 	mutex_unlock(&clocks_mutex);
220 }
221 
clkdev_add(struct clk_lookup * cl)222 void clkdev_add(struct clk_lookup *cl)
223 {
224 	if (!cl->clk_hw)
225 		cl->clk_hw = __clk_get_hw(cl->clk);
226 	__clkdev_add(cl);
227 }
228 EXPORT_SYMBOL(clkdev_add);
229 
clkdev_add_table(struct clk_lookup * cl,size_t num)230 void clkdev_add_table(struct clk_lookup *cl, size_t num)
231 {
232 	mutex_lock(&clocks_mutex);
233 	while (num--) {
234 		cl->clk_hw = __clk_get_hw(cl->clk);
235 		list_add_tail(&cl->node, &clocks);
236 		cl++;
237 	}
238 	mutex_unlock(&clocks_mutex);
239 }
240 
241 #define MAX_DEV_ID	20
242 #define MAX_CON_ID	16
243 
244 struct clk_lookup_alloc {
245 	struct clk_lookup cl;
246 	char	dev_id[MAX_DEV_ID];
247 	char	con_id[MAX_CON_ID];
248 };
249 
250 static struct clk_lookup * __ref
vclkdev_alloc(struct clk_hw * hw,const char * con_id,const char * dev_fmt,va_list ap)251 vclkdev_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
252 	va_list ap)
253 {
254 	struct clk_lookup_alloc *cla;
255 
256 	cla = kzalloc(sizeof(*cla), GFP_KERNEL);
257 	if (!cla)
258 		return NULL;
259 
260 	cla->cl.clk_hw = hw;
261 	if (con_id) {
262 		strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
263 		cla->cl.con_id = cla->con_id;
264 	}
265 
266 	if (dev_fmt) {
267 		vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
268 		cla->cl.dev_id = cla->dev_id;
269 	}
270 
271 	return &cla->cl;
272 }
273 
274 static struct clk_lookup *
vclkdev_create(struct clk_hw * hw,const char * con_id,const char * dev_fmt,va_list ap)275 vclkdev_create(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
276 	va_list ap)
277 {
278 	struct clk_lookup *cl;
279 
280 	cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
281 	if (cl)
282 		__clkdev_add(cl);
283 
284 	return cl;
285 }
286 
287 struct clk_lookup * __ref
clkdev_alloc(struct clk * clk,const char * con_id,const char * dev_fmt,...)288 clkdev_alloc(struct clk *clk, const char *con_id, const char *dev_fmt, ...)
289 {
290 	struct clk_lookup *cl;
291 	va_list ap;
292 
293 	va_start(ap, dev_fmt);
294 	cl = vclkdev_alloc(__clk_get_hw(clk), con_id, dev_fmt, ap);
295 	va_end(ap);
296 
297 	return cl;
298 }
299 EXPORT_SYMBOL(clkdev_alloc);
300 
301 struct clk_lookup *
clkdev_hw_alloc(struct clk_hw * hw,const char * con_id,const char * dev_fmt,...)302 clkdev_hw_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt, ...)
303 {
304 	struct clk_lookup *cl;
305 	va_list ap;
306 
307 	va_start(ap, dev_fmt);
308 	cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
309 	va_end(ap);
310 
311 	return cl;
312 }
313 EXPORT_SYMBOL(clkdev_hw_alloc);
314 
315 /**
316  * clkdev_create - allocate and add a clkdev lookup structure
317  * @clk: struct clk to associate with all clk_lookups
318  * @con_id: connection ID string on device
319  * @dev_fmt: format string describing device name
320  *
321  * Returns a clk_lookup structure, which can be later unregistered and
322  * freed.
323  */
clkdev_create(struct clk * clk,const char * con_id,const char * dev_fmt,...)324 struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
325 	const char *dev_fmt, ...)
326 {
327 	struct clk_lookup *cl;
328 	va_list ap;
329 
330 	va_start(ap, dev_fmt);
331 	cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);
332 	va_end(ap);
333 
334 	return cl;
335 }
336 EXPORT_SYMBOL_GPL(clkdev_create);
337 
338 /**
339  * clkdev_hw_create - allocate and add a clkdev lookup structure
340  * @hw: struct clk_hw to associate with all clk_lookups
341  * @con_id: connection ID string on device
342  * @dev_fmt: format string describing device name
343  *
344  * Returns a clk_lookup structure, which can be later unregistered and
345  * freed.
346  */
clkdev_hw_create(struct clk_hw * hw,const char * con_id,const char * dev_fmt,...)347 struct clk_lookup *clkdev_hw_create(struct clk_hw *hw, const char *con_id,
348 	const char *dev_fmt, ...)
349 {
350 	struct clk_lookup *cl;
351 	va_list ap;
352 
353 	va_start(ap, dev_fmt);
354 	cl = vclkdev_create(hw, con_id, dev_fmt, ap);
355 	va_end(ap);
356 
357 	return cl;
358 }
359 EXPORT_SYMBOL_GPL(clkdev_hw_create);
360 
clk_add_alias(const char * alias,const char * alias_dev_name,const char * con_id,struct device * dev)361 int clk_add_alias(const char *alias, const char *alias_dev_name,
362 	const char *con_id, struct device *dev)
363 {
364 	struct clk *r = clk_get(dev, con_id);
365 	struct clk_lookup *l;
366 
367 	if (IS_ERR(r))
368 		return PTR_ERR(r);
369 
370 	l = clkdev_create(r, alias, alias_dev_name ? "%s" : NULL,
371 			  alias_dev_name);
372 	clk_put(r);
373 
374 	return l ? 0 : -ENODEV;
375 }
376 EXPORT_SYMBOL(clk_add_alias);
377 
378 /*
379  * clkdev_drop - remove a clock dynamically allocated
380  */
clkdev_drop(struct clk_lookup * cl)381 void clkdev_drop(struct clk_lookup *cl)
382 {
383 	mutex_lock(&clocks_mutex);
384 	list_del(&cl->node);
385 	mutex_unlock(&clocks_mutex);
386 	kfree(cl);
387 }
388 EXPORT_SYMBOL(clkdev_drop);
389 
__clk_register_clkdev(struct clk_hw * hw,const char * con_id,const char * dev_id,...)390 static struct clk_lookup *__clk_register_clkdev(struct clk_hw *hw,
391 						const char *con_id,
392 						const char *dev_id, ...)
393 {
394 	struct clk_lookup *cl;
395 	va_list ap;
396 
397 	va_start(ap, dev_id);
398 	cl = vclkdev_create(hw, con_id, dev_id, ap);
399 	va_end(ap);
400 
401 	return cl;
402 }
403 
404 /**
405  * clk_register_clkdev - register one clock lookup for a struct clk
406  * @clk: struct clk to associate with all clk_lookups
407  * @con_id: connection ID string on device
408  * @dev_id: string describing device name
409  *
410  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
411  * clkdev.
412  *
413  * To make things easier for mass registration, we detect error clks
414  * from a previous clk_register() call, and return the error code for
415  * those.  This is to permit this function to be called immediately
416  * after clk_register().
417  */
clk_register_clkdev(struct clk * clk,const char * con_id,const char * dev_id)418 int clk_register_clkdev(struct clk *clk, const char *con_id,
419 	const char *dev_id)
420 {
421 	struct clk_lookup *cl;
422 
423 	if (IS_ERR(clk))
424 		return PTR_ERR(clk);
425 
426 	/*
427 	 * Since dev_id can be NULL, and NULL is handled specially, we must
428 	 * pass it as either a NULL format string, or with "%s".
429 	 */
430 	if (dev_id)
431 		cl = __clk_register_clkdev(__clk_get_hw(clk), con_id, "%s",
432 					   dev_id);
433 	else
434 		cl = __clk_register_clkdev(__clk_get_hw(clk), con_id, NULL);
435 
436 	return cl ? 0 : -ENOMEM;
437 }
438 EXPORT_SYMBOL(clk_register_clkdev);
439 
440 /**
441  * clk_hw_register_clkdev - register one clock lookup for a struct clk_hw
442  * @hw: struct clk_hw to associate with all clk_lookups
443  * @con_id: connection ID string on device
444  * @dev_id: format string describing device name
445  *
446  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
447  * clkdev.
448  *
449  * To make things easier for mass registration, we detect error clk_hws
450  * from a previous clk_hw_register_*() call, and return the error code for
451  * those.  This is to permit this function to be called immediately
452  * after clk_hw_register_*().
453  */
clk_hw_register_clkdev(struct clk_hw * hw,const char * con_id,const char * dev_id)454 int clk_hw_register_clkdev(struct clk_hw *hw, const char *con_id,
455 	const char *dev_id)
456 {
457 	struct clk_lookup *cl;
458 
459 	if (IS_ERR(hw))
460 		return PTR_ERR(hw);
461 
462 	/*
463 	 * Since dev_id can be NULL, and NULL is handled specially, we must
464 	 * pass it as either a NULL format string, or with "%s".
465 	 */
466 	if (dev_id)
467 		cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);
468 	else
469 		cl = __clk_register_clkdev(hw, con_id, NULL);
470 
471 	return cl ? 0 : -ENOMEM;
472 }
473 EXPORT_SYMBOL(clk_hw_register_clkdev);
474