4 * Copyright (C) 2008 Russell King.
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.
10 * Helper for the clk API to assist looking up a struct clk.
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>
27 static LIST_HEAD(clocks);
28 static DEFINE_MUTEX(clocks_mutex);
30 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
31 static struct clk *__of_clk_get(struct device_node *np, int index,
32 const char *dev_id, const char *con_id)
34 struct of_phandle_args clkspec;
38 rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
43 clk = __of_clk_get_from_provider(&clkspec, dev_id, con_id);
44 of_node_put(clkspec.np);
49 struct clk *of_clk_get(struct device_node *np, int index)
51 return __of_clk_get(np, index, np->full_name, NULL);
53 EXPORT_SYMBOL(of_clk_get);
56 * Beware the return values when np is valid, but no clock provider is found.
57 * If name == NULL, the function returns -ENOENT.
58 * If name != NULL, the function returns -EINVAL. This is because __of_clk_get()
59 * is called even if of_property_match_string() returns an error.
61 static struct clk *__of_clk_get_by_name(struct device_node *np,
65 struct clk *clk = ERR_PTR(-ENOENT);
67 /* Walk up the tree of devices looking for a clock that matches */
72 * For named clocks, first look up the name in the
73 * "clock-names" property. If it cannot be found, then
74 * index will be an error code, and of_clk_get() will fail.
77 index = of_property_match_string(np, "clock-names", name);
78 clk = __of_clk_get(np, index, dev_id, name);
81 } else if (name && index >= 0) {
82 if (PTR_ERR(clk) != -EPROBE_DEFER)
83 pr_err("ERROR: could not get clock %pOF:%s(%i)\n",
84 np, name ? name : "", index);
89 * No matching clock found on this node. If the parent node
90 * has a "clock-ranges" property, then we can try one of its
94 if (np && !of_get_property(np, "clock-ranges", NULL))
102 * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
103 * @np: pointer to clock consumer node
104 * @name: name of consumer's clock input, or NULL for the first clock reference
106 * This function parses the clocks and clock-names properties,
107 * and uses them to look up the struct clk from the registered list of clock
110 struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
113 return ERR_PTR(-ENOENT);
115 return __of_clk_get_by_name(np, np->full_name, name);
117 EXPORT_SYMBOL(of_clk_get_by_name);
119 #else /* defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK) */
121 static struct clk *__of_clk_get_by_name(struct device_node *np,
125 return ERR_PTR(-ENOENT);
130 * Find the correct struct clk for the device and connection ID.
131 * We do slightly fuzzy matching here:
132 * An entry with a NULL ID is assumed to be a wildcard.
133 * If an entry has a device ID, it must match
134 * If an entry has a connection ID, it must match
135 * Then we take the most specific entry - with the following
136 * order of precedence: dev+con > dev only > con only.
138 static struct clk_lookup *clk_find(const char *dev_id, const char *con_id)
140 struct clk_lookup *p, *cl = NULL;
141 int match, best_found = 0, best_possible = 0;
148 list_for_each_entry(p, &clocks, node) {
151 if (!dev_id || strcmp(p->dev_id, dev_id))
156 if (!con_id || strcmp(p->con_id, con_id))
161 if (match > best_found) {
163 if (match != best_possible)
172 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
174 struct clk_lookup *cl;
175 struct clk *clk = NULL;
177 mutex_lock(&clocks_mutex);
179 cl = clk_find(dev_id, con_id);
183 clk = __clk_create_clk(cl->clk_hw, dev_id, con_id);
187 if (!__clk_get(clk)) {
194 mutex_unlock(&clocks_mutex);
196 return cl ? clk : ERR_PTR(-ENOENT);
198 EXPORT_SYMBOL(clk_get_sys);
200 struct clk *clk_get(struct device *dev, const char *con_id)
202 const char *dev_id = dev ? dev_name(dev) : NULL;
205 if (dev && dev->of_node) {
206 clk = __of_clk_get_by_name(dev->of_node, dev_id, con_id);
207 if (!IS_ERR(clk) || PTR_ERR(clk) == -EPROBE_DEFER)
211 return clk_get_sys(dev_id, con_id);
213 EXPORT_SYMBOL(clk_get);
215 void clk_put(struct clk *clk)
219 EXPORT_SYMBOL(clk_put);
221 static void __clkdev_add(struct clk_lookup *cl)
223 mutex_lock(&clocks_mutex);
224 list_add_tail(&cl->node, &clocks);
225 mutex_unlock(&clocks_mutex);
228 void clkdev_add(struct clk_lookup *cl)
231 cl->clk_hw = __clk_get_hw(cl->clk);
234 EXPORT_SYMBOL(clkdev_add);
236 void clkdev_add_table(struct clk_lookup *cl, size_t num)
238 mutex_lock(&clocks_mutex);
240 cl->clk_hw = __clk_get_hw(cl->clk);
241 list_add_tail(&cl->node, &clocks);
244 mutex_unlock(&clocks_mutex);
247 #define MAX_DEV_ID 20
248 #define MAX_CON_ID 16
250 struct clk_lookup_alloc {
251 struct clk_lookup cl;
252 char dev_id[MAX_DEV_ID];
253 char con_id[MAX_CON_ID];
256 static struct clk_lookup * __ref
257 vclkdev_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
260 struct clk_lookup_alloc *cla;
262 cla = kzalloc(sizeof(*cla), GFP_KERNEL);
268 strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
269 cla->cl.con_id = cla->con_id;
273 vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
274 cla->cl.dev_id = cla->dev_id;
280 static struct clk_lookup *
281 vclkdev_create(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
284 struct clk_lookup *cl;
286 cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
293 struct clk_lookup * __ref
294 clkdev_alloc(struct clk *clk, const char *con_id, const char *dev_fmt, ...)
296 struct clk_lookup *cl;
299 va_start(ap, dev_fmt);
300 cl = vclkdev_alloc(__clk_get_hw(clk), con_id, dev_fmt, ap);
305 EXPORT_SYMBOL(clkdev_alloc);
308 clkdev_hw_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt, ...)
310 struct clk_lookup *cl;
313 va_start(ap, dev_fmt);
314 cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
319 EXPORT_SYMBOL(clkdev_hw_alloc);
322 * clkdev_create - allocate and add a clkdev lookup structure
323 * @clk: struct clk to associate with all clk_lookups
324 * @con_id: connection ID string on device
325 * @dev_fmt: format string describing device name
327 * Returns a clk_lookup structure, which can be later unregistered and
330 struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
331 const char *dev_fmt, ...)
333 struct clk_lookup *cl;
336 va_start(ap, dev_fmt);
337 cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);
342 EXPORT_SYMBOL_GPL(clkdev_create);
345 * clkdev_hw_create - allocate and add a clkdev lookup structure
346 * @hw: struct clk_hw to associate with all clk_lookups
347 * @con_id: connection ID string on device
348 * @dev_fmt: format string describing device name
350 * Returns a clk_lookup structure, which can be later unregistered and
353 struct clk_lookup *clkdev_hw_create(struct clk_hw *hw, const char *con_id,
354 const char *dev_fmt, ...)
356 struct clk_lookup *cl;
359 va_start(ap, dev_fmt);
360 cl = vclkdev_create(hw, con_id, dev_fmt, ap);
365 EXPORT_SYMBOL_GPL(clkdev_hw_create);
367 int clk_add_alias(const char *alias, const char *alias_dev_name,
368 const char *con_id, struct device *dev)
370 struct clk *r = clk_get(dev, con_id);
371 struct clk_lookup *l;
376 l = clkdev_create(r, alias, alias_dev_name ? "%s" : NULL,
380 return l ? 0 : -ENODEV;
382 EXPORT_SYMBOL(clk_add_alias);
385 * clkdev_drop - remove a clock dynamically allocated
387 void clkdev_drop(struct clk_lookup *cl)
389 mutex_lock(&clocks_mutex);
391 mutex_unlock(&clocks_mutex);
394 EXPORT_SYMBOL(clkdev_drop);
396 static struct clk_lookup *__clk_register_clkdev(struct clk_hw *hw,
398 const char *dev_id, ...)
400 struct clk_lookup *cl;
403 va_start(ap, dev_id);
404 cl = vclkdev_create(hw, con_id, dev_id, ap);
410 static int do_clk_register_clkdev(struct clk_hw *hw,
411 struct clk_lookup **cl, const char *con_id, const char *dev_id)
416 * Since dev_id can be NULL, and NULL is handled specially, we must
417 * pass it as either a NULL format string, or with "%s".
420 *cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);
422 *cl = __clk_register_clkdev(hw, con_id, NULL);
424 return *cl ? 0 : -ENOMEM;
428 * clk_register_clkdev - register one clock lookup for a struct clk
429 * @clk: struct clk to associate with all clk_lookups
430 * @con_id: connection ID string on device
431 * @dev_id: string describing device name
433 * con_id or dev_id may be NULL as a wildcard, just as in the rest of
436 * To make things easier for mass registration, we detect error clks
437 * from a previous clk_register() call, and return the error code for
438 * those. This is to permit this function to be called immediately
439 * after clk_register().
441 int clk_register_clkdev(struct clk *clk, const char *con_id,
444 struct clk_lookup *cl;
449 return do_clk_register_clkdev(__clk_get_hw(clk), &cl, con_id,
452 EXPORT_SYMBOL(clk_register_clkdev);
455 * clk_hw_register_clkdev - register one clock lookup for a struct clk_hw
456 * @hw: struct clk_hw to associate with all clk_lookups
457 * @con_id: connection ID string on device
458 * @dev_id: format string describing device name
460 * con_id or dev_id may be NULL as a wildcard, just as in the rest of
463 * To make things easier for mass registration, we detect error clk_hws
464 * from a previous clk_hw_register_*() call, and return the error code for
465 * those. This is to permit this function to be called immediately
466 * after clk_hw_register_*().
468 int clk_hw_register_clkdev(struct clk_hw *hw, const char *con_id,
471 struct clk_lookup *cl;
473 return do_clk_register_clkdev(hw, &cl, con_id, dev_id);
475 EXPORT_SYMBOL(clk_hw_register_clkdev);
477 static void devm_clkdev_release(struct device *dev, void *res)
479 clkdev_drop(*(struct clk_lookup **)res);
482 static int devm_clk_match_clkdev(struct device *dev, void *res, void *data)
484 struct clk_lookup **l = res;
490 * devm_clk_release_clkdev - Resource managed clkdev lookup release
491 * @dev: device this lookup is bound
492 * @con_id: connection ID string on device
493 * @dev_id: format string describing device name
495 * Drop the clkdev lookup created with devm_clk_hw_register_clkdev.
496 * Normally this function will not need to be called and the resource
497 * management code will ensure that the resource is freed.
499 void devm_clk_release_clkdev(struct device *dev, const char *con_id,
502 struct clk_lookup *cl;
505 cl = clk_find(dev_id, con_id);
507 rval = devres_release(dev, devm_clkdev_release,
508 devm_clk_match_clkdev, cl);
511 EXPORT_SYMBOL(devm_clk_release_clkdev);
514 * devm_clk_hw_register_clkdev - managed clk lookup registration for clk_hw
515 * @dev: device this lookup is bound
516 * @hw: struct clk_hw to associate with all clk_lookups
517 * @con_id: connection ID string on device
518 * @dev_id: format string describing device name
520 * con_id or dev_id may be NULL as a wildcard, just as in the rest of
523 * To make things easier for mass registration, we detect error clk_hws
524 * from a previous clk_hw_register_*() call, and return the error code for
525 * those. This is to permit this function to be called immediately
526 * after clk_hw_register_*().
528 int devm_clk_hw_register_clkdev(struct device *dev, struct clk_hw *hw,
529 const char *con_id, const char *dev_id)
532 struct clk_lookup **cl;
534 cl = devres_alloc(devm_clkdev_release, sizeof(*cl), GFP_KERNEL);
536 rval = do_clk_register_clkdev(hw, cl, con_id, dev_id);
544 EXPORT_SYMBOL(devm_clk_hw_register_clkdev);