Merge branch 'clk-parent-rewrite' (early part) into clk-next
[muen/linux.git] / drivers / clk / clkdev.c
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 /*
31  * Find the correct struct clk for the device and connection ID.
32  * We do slightly fuzzy matching here:
33  *  An entry with a NULL ID is assumed to be a wildcard.
34  *  If an entry has a device ID, it must match
35  *  If an entry has a connection ID, it must match
36  * Then we take the most specific entry - with the following
37  * order of precedence: dev+con > dev only > con only.
38  */
39 static struct clk_lookup *clk_find(const char *dev_id, const char *con_id)
40 {
41         struct clk_lookup *p, *cl = NULL;
42         int match, best_found = 0, best_possible = 0;
43
44         if (dev_id)
45                 best_possible += 2;
46         if (con_id)
47                 best_possible += 1;
48
49         list_for_each_entry(p, &clocks, node) {
50                 match = 0;
51                 if (p->dev_id) {
52                         if (!dev_id || strcmp(p->dev_id, dev_id))
53                                 continue;
54                         match += 2;
55                 }
56                 if (p->con_id) {
57                         if (!con_id || strcmp(p->con_id, con_id))
58                                 continue;
59                         match += 1;
60                 }
61
62                 if (match > best_found) {
63                         cl = p;
64                         if (match != best_possible)
65                                 best_found = match;
66                         else
67                                 break;
68                 }
69         }
70         return cl;
71 }
72
73 static struct clk *__clk_get_sys(struct device *dev, const char *dev_id,
74                                  const char *con_id)
75 {
76         struct clk_lookup *cl;
77         struct clk *clk = NULL;
78
79         mutex_lock(&clocks_mutex);
80
81         cl = clk_find(dev_id, con_id);
82         if (!cl)
83                 goto out;
84
85         clk = clk_hw_create_clk(dev, cl->clk_hw, dev_id, con_id);
86         if (IS_ERR(clk))
87                 cl = NULL;
88 out:
89         mutex_unlock(&clocks_mutex);
90
91         return cl ? clk : ERR_PTR(-ENOENT);
92 }
93
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
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
115 void clk_put(struct clk *clk)
116 {
117         __clk_put(clk);
118 }
119 EXPORT_SYMBOL(clk_put);
120
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
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
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      20
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
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                 strlcpy(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 *
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 struct clk_lookup * __ref
194 clkdev_alloc(struct clk *clk, const char *con_id, const char *dev_fmt, ...)
195 {
196         struct clk_lookup *cl;
197         va_list ap;
198
199         va_start(ap, dev_fmt);
200         cl = vclkdev_alloc(__clk_get_hw(clk), con_id, dev_fmt, ap);
201         va_end(ap);
202
203         return cl;
204 }
205 EXPORT_SYMBOL(clkdev_alloc);
206
207 struct clk_lookup *
208 clkdev_hw_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt, ...)
209 {
210         struct clk_lookup *cl;
211         va_list ap;
212
213         va_start(ap, dev_fmt);
214         cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
215         va_end(ap);
216
217         return cl;
218 }
219 EXPORT_SYMBOL(clkdev_hw_alloc);
220
221 /**
222  * clkdev_create - allocate and add a clkdev lookup structure
223  * @clk: struct clk to associate with all clk_lookups
224  * @con_id: connection ID string on device
225  * @dev_fmt: format string describing device name
226  *
227  * Returns a clk_lookup structure, which can be later unregistered and
228  * freed.
229  */
230 struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
231         const char *dev_fmt, ...)
232 {
233         struct clk_lookup *cl;
234         va_list ap;
235
236         va_start(ap, dev_fmt);
237         cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);
238         va_end(ap);
239
240         return cl;
241 }
242 EXPORT_SYMBOL_GPL(clkdev_create);
243
244 /**
245  * clkdev_hw_create - allocate and add a clkdev lookup structure
246  * @hw: struct clk_hw to associate with all clk_lookups
247  * @con_id: connection ID string on device
248  * @dev_fmt: format string describing device name
249  *
250  * Returns a clk_lookup structure, which can be later unregistered and
251  * freed.
252  */
253 struct clk_lookup *clkdev_hw_create(struct clk_hw *hw, const char *con_id,
254         const char *dev_fmt, ...)
255 {
256         struct clk_lookup *cl;
257         va_list ap;
258
259         va_start(ap, dev_fmt);
260         cl = vclkdev_create(hw, con_id, dev_fmt, ap);
261         va_end(ap);
262
263         return cl;
264 }
265 EXPORT_SYMBOL_GPL(clkdev_hw_create);
266
267 int clk_add_alias(const char *alias, const char *alias_dev_name,
268         const char *con_id, struct device *dev)
269 {
270         struct clk *r = clk_get(dev, con_id);
271         struct clk_lookup *l;
272
273         if (IS_ERR(r))
274                 return PTR_ERR(r);
275
276         l = clkdev_create(r, alias, alias_dev_name ? "%s" : NULL,
277                           alias_dev_name);
278         clk_put(r);
279
280         return l ? 0 : -ENODEV;
281 }
282 EXPORT_SYMBOL(clk_add_alias);
283
284 /*
285  * clkdev_drop - remove a clock dynamically allocated
286  */
287 void clkdev_drop(struct clk_lookup *cl)
288 {
289         mutex_lock(&clocks_mutex);
290         list_del(&cl->node);
291         mutex_unlock(&clocks_mutex);
292         kfree(cl);
293 }
294 EXPORT_SYMBOL(clkdev_drop);
295
296 static struct clk_lookup *__clk_register_clkdev(struct clk_hw *hw,
297                                                 const char *con_id,
298                                                 const char *dev_id, ...)
299 {
300         struct clk_lookup *cl;
301         va_list ap;
302
303         va_start(ap, dev_id);
304         cl = vclkdev_create(hw, con_id, dev_id, ap);
305         va_end(ap);
306
307         return cl;
308 }
309
310 static int do_clk_register_clkdev(struct clk_hw *hw,
311         struct clk_lookup **cl, const char *con_id, const char *dev_id)
312 {
313         if (IS_ERR(hw))
314                 return PTR_ERR(hw);
315         /*
316          * Since dev_id can be NULL, and NULL is handled specially, we must
317          * pass it as either a NULL format string, or with "%s".
318          */
319         if (dev_id)
320                 *cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);
321         else
322                 *cl = __clk_register_clkdev(hw, con_id, NULL);
323
324         return *cl ? 0 : -ENOMEM;
325 }
326
327 /**
328  * clk_register_clkdev - register one clock lookup for a struct clk
329  * @clk: struct clk to associate with all clk_lookups
330  * @con_id: connection ID string on device
331  * @dev_id: string describing device name
332  *
333  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
334  * clkdev.
335  *
336  * To make things easier for mass registration, we detect error clks
337  * from a previous clk_register() call, and return the error code for
338  * those.  This is to permit this function to be called immediately
339  * after clk_register().
340  */
341 int clk_register_clkdev(struct clk *clk, const char *con_id,
342         const char *dev_id)
343 {
344         struct clk_lookup *cl;
345
346         if (IS_ERR(clk))
347                 return PTR_ERR(clk);
348
349         return do_clk_register_clkdev(__clk_get_hw(clk), &cl, con_id,
350                                               dev_id);
351 }
352 EXPORT_SYMBOL(clk_register_clkdev);
353
354 /**
355  * clk_hw_register_clkdev - register one clock lookup for a struct clk_hw
356  * @hw: struct clk_hw to associate with all clk_lookups
357  * @con_id: connection ID string on device
358  * @dev_id: format string describing device name
359  *
360  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
361  * clkdev.
362  *
363  * To make things easier for mass registration, we detect error clk_hws
364  * from a previous clk_hw_register_*() call, and return the error code for
365  * those.  This is to permit this function to be called immediately
366  * after clk_hw_register_*().
367  */
368 int clk_hw_register_clkdev(struct clk_hw *hw, const char *con_id,
369         const char *dev_id)
370 {
371         struct clk_lookup *cl;
372
373         return do_clk_register_clkdev(hw, &cl, con_id, dev_id);
374 }
375 EXPORT_SYMBOL(clk_hw_register_clkdev);
376
377 static void devm_clkdev_release(struct device *dev, void *res)
378 {
379         clkdev_drop(*(struct clk_lookup **)res);
380 }
381
382 static int devm_clk_match_clkdev(struct device *dev, void *res, void *data)
383 {
384         struct clk_lookup **l = res;
385
386         return *l == data;
387 }
388
389 /**
390  * devm_clk_release_clkdev - Resource managed clkdev lookup release
391  * @dev: device this lookup is bound
392  * @con_id: connection ID string on device
393  * @dev_id: format string describing device name
394  *
395  * Drop the clkdev lookup created with devm_clk_hw_register_clkdev.
396  * Normally this function will not need to be called and the resource
397  * management code will ensure that the resource is freed.
398  */
399 void devm_clk_release_clkdev(struct device *dev, const char *con_id,
400                              const char *dev_id)
401 {
402         struct clk_lookup *cl;
403         int rval;
404
405         cl = clk_find(dev_id, con_id);
406         WARN_ON(!cl);
407         rval = devres_release(dev, devm_clkdev_release,
408                               devm_clk_match_clkdev, cl);
409         WARN_ON(rval);
410 }
411 EXPORT_SYMBOL(devm_clk_release_clkdev);
412
413 /**
414  * devm_clk_hw_register_clkdev - managed clk lookup registration for clk_hw
415  * @dev: device this lookup is bound
416  * @hw: struct clk_hw to associate with all clk_lookups
417  * @con_id: connection ID string on device
418  * @dev_id: format string describing device name
419  *
420  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
421  * clkdev.
422  *
423  * To make things easier for mass registration, we detect error clk_hws
424  * from a previous clk_hw_register_*() call, and return the error code for
425  * those.  This is to permit this function to be called immediately
426  * after clk_hw_register_*().
427  */
428 int devm_clk_hw_register_clkdev(struct device *dev, struct clk_hw *hw,
429                                 const char *con_id, const char *dev_id)
430 {
431         int rval = -ENOMEM;
432         struct clk_lookup **cl;
433
434         cl = devres_alloc(devm_clkdev_release, sizeof(*cl), GFP_KERNEL);
435         if (cl) {
436                 rval = do_clk_register_clkdev(hw, cl, con_id, dev_id);
437                 if (!rval)
438                         devres_add(dev, cl);
439                 else
440                         devres_free(cl);
441         }
442         return rval;
443 }
444 EXPORT_SYMBOL(devm_clk_hw_register_clkdev);