blob: 934cfd18f72ded4a295192f608cc653214c03908 [file] [log] [blame]
Mike Turquetteb24764902012-03-15 23:11:19 -07001/*
2 * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
3 * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Standard functionality for the common clock API. See Documentation/clk.txt
10 */
11
12#include <linux/clk-private.h>
13#include <linux/module.h>
14#include <linux/mutex.h>
15#include <linux/spinlock.h>
16#include <linux/err.h>
17#include <linux/list.h>
18#include <linux/slab.h>
Grant Likely766e6a42012-04-09 14:50:06 -050019#include <linux/of.h>
Stephen Boyd46c87732012-09-24 13:38:04 -070020#include <linux/device.h>
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +053021#include <linux/init.h>
Mike Turquette533ddeb2013-03-28 13:59:02 -070022#include <linux/sched.h>
Mike Turquetteb24764902012-03-15 23:11:19 -070023
24static DEFINE_SPINLOCK(enable_lock);
25static DEFINE_MUTEX(prepare_lock);
26
Mike Turquette533ddeb2013-03-28 13:59:02 -070027static struct task_struct *prepare_owner;
28static struct task_struct *enable_owner;
29
30static int prepare_refcnt;
31static int enable_refcnt;
32
Mike Turquetteb24764902012-03-15 23:11:19 -070033static HLIST_HEAD(clk_root_list);
34static HLIST_HEAD(clk_orphan_list);
35static LIST_HEAD(clk_notifier_list);
36
Mike Turquetteeab89f62013-03-28 13:59:01 -070037/*** locking ***/
38static void clk_prepare_lock(void)
39{
Mike Turquette533ddeb2013-03-28 13:59:02 -070040 if (!mutex_trylock(&prepare_lock)) {
41 if (prepare_owner == current) {
42 prepare_refcnt++;
43 return;
44 }
45 mutex_lock(&prepare_lock);
46 }
47 WARN_ON_ONCE(prepare_owner != NULL);
48 WARN_ON_ONCE(prepare_refcnt != 0);
49 prepare_owner = current;
50 prepare_refcnt = 1;
Mike Turquetteeab89f62013-03-28 13:59:01 -070051}
52
53static void clk_prepare_unlock(void)
54{
Mike Turquette533ddeb2013-03-28 13:59:02 -070055 WARN_ON_ONCE(prepare_owner != current);
56 WARN_ON_ONCE(prepare_refcnt == 0);
57
58 if (--prepare_refcnt)
59 return;
60 prepare_owner = NULL;
Mike Turquetteeab89f62013-03-28 13:59:01 -070061 mutex_unlock(&prepare_lock);
62}
63
64static unsigned long clk_enable_lock(void)
65{
66 unsigned long flags;
Mike Turquette533ddeb2013-03-28 13:59:02 -070067
68 if (!spin_trylock_irqsave(&enable_lock, flags)) {
69 if (enable_owner == current) {
70 enable_refcnt++;
71 return flags;
72 }
73 spin_lock_irqsave(&enable_lock, flags);
74 }
75 WARN_ON_ONCE(enable_owner != NULL);
76 WARN_ON_ONCE(enable_refcnt != 0);
77 enable_owner = current;
78 enable_refcnt = 1;
Mike Turquetteeab89f62013-03-28 13:59:01 -070079 return flags;
80}
81
82static void clk_enable_unlock(unsigned long flags)
83{
Mike Turquette533ddeb2013-03-28 13:59:02 -070084 WARN_ON_ONCE(enable_owner != current);
85 WARN_ON_ONCE(enable_refcnt == 0);
86
87 if (--enable_refcnt)
88 return;
89 enable_owner = NULL;
Mike Turquetteeab89f62013-03-28 13:59:01 -070090 spin_unlock_irqrestore(&enable_lock, flags);
91}
92
Mike Turquetteb24764902012-03-15 23:11:19 -070093/*** debugfs support ***/
94
95#ifdef CONFIG_COMMON_CLK_DEBUG
96#include <linux/debugfs.h>
97
98static struct dentry *rootdir;
99static struct dentry *orphandir;
100static int inited = 0;
101
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530102static void clk_summary_show_one(struct seq_file *s, struct clk *c, int level)
103{
104 if (!c)
105 return;
106
107 seq_printf(s, "%*s%-*s %-11d %-12d %-10lu",
108 level * 3 + 1, "",
109 30 - level * 3, c->name,
110 c->enable_count, c->prepare_count, c->rate);
111 seq_printf(s, "\n");
112}
113
114static void clk_summary_show_subtree(struct seq_file *s, struct clk *c,
115 int level)
116{
117 struct clk *child;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530118
119 if (!c)
120 return;
121
122 clk_summary_show_one(s, c, level);
123
Sasha Levinb67bfe02013-02-27 17:06:00 -0800124 hlist_for_each_entry(child, &c->children, child_node)
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530125 clk_summary_show_subtree(s, child, level + 1);
126}
127
128static int clk_summary_show(struct seq_file *s, void *data)
129{
130 struct clk *c;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530131
132 seq_printf(s, " clock enable_cnt prepare_cnt rate\n");
133 seq_printf(s, "---------------------------------------------------------------------\n");
134
Mike Turquetteeab89f62013-03-28 13:59:01 -0700135 clk_prepare_lock();
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530136
Sasha Levinb67bfe02013-02-27 17:06:00 -0800137 hlist_for_each_entry(c, &clk_root_list, child_node)
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530138 clk_summary_show_subtree(s, c, 0);
139
Sasha Levinb67bfe02013-02-27 17:06:00 -0800140 hlist_for_each_entry(c, &clk_orphan_list, child_node)
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530141 clk_summary_show_subtree(s, c, 0);
142
Mike Turquetteeab89f62013-03-28 13:59:01 -0700143 clk_prepare_unlock();
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530144
145 return 0;
146}
147
148
149static int clk_summary_open(struct inode *inode, struct file *file)
150{
151 return single_open(file, clk_summary_show, inode->i_private);
152}
153
154static const struct file_operations clk_summary_fops = {
155 .open = clk_summary_open,
156 .read = seq_read,
157 .llseek = seq_lseek,
158 .release = single_release,
159};
160
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530161static void clk_dump_one(struct seq_file *s, struct clk *c, int level)
162{
163 if (!c)
164 return;
165
166 seq_printf(s, "\"%s\": { ", c->name);
167 seq_printf(s, "\"enable_count\": %d,", c->enable_count);
168 seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
169 seq_printf(s, "\"rate\": %lu", c->rate);
170}
171
172static void clk_dump_subtree(struct seq_file *s, struct clk *c, int level)
173{
174 struct clk *child;
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530175
176 if (!c)
177 return;
178
179 clk_dump_one(s, c, level);
180
Sasha Levinb67bfe02013-02-27 17:06:00 -0800181 hlist_for_each_entry(child, &c->children, child_node) {
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530182 seq_printf(s, ",");
183 clk_dump_subtree(s, child, level + 1);
184 }
185
186 seq_printf(s, "}");
187}
188
189static int clk_dump(struct seq_file *s, void *data)
190{
191 struct clk *c;
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530192 bool first_node = true;
193
194 seq_printf(s, "{");
195
Mike Turquetteeab89f62013-03-28 13:59:01 -0700196 clk_prepare_lock();
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530197
Sasha Levinb67bfe02013-02-27 17:06:00 -0800198 hlist_for_each_entry(c, &clk_root_list, child_node) {
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530199 if (!first_node)
200 seq_printf(s, ",");
201 first_node = false;
202 clk_dump_subtree(s, c, 0);
203 }
204
Sasha Levinb67bfe02013-02-27 17:06:00 -0800205 hlist_for_each_entry(c, &clk_orphan_list, child_node) {
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530206 seq_printf(s, ",");
207 clk_dump_subtree(s, c, 0);
208 }
209
Mike Turquetteeab89f62013-03-28 13:59:01 -0700210 clk_prepare_unlock();
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530211
212 seq_printf(s, "}");
213 return 0;
214}
215
216
217static int clk_dump_open(struct inode *inode, struct file *file)
218{
219 return single_open(file, clk_dump, inode->i_private);
220}
221
222static const struct file_operations clk_dump_fops = {
223 .open = clk_dump_open,
224 .read = seq_read,
225 .llseek = seq_lseek,
226 .release = single_release,
227};
228
Mike Turquetteb24764902012-03-15 23:11:19 -0700229/* caller must hold prepare_lock */
230static int clk_debug_create_one(struct clk *clk, struct dentry *pdentry)
231{
232 struct dentry *d;
233 int ret = -ENOMEM;
234
235 if (!clk || !pdentry) {
236 ret = -EINVAL;
237 goto out;
238 }
239
240 d = debugfs_create_dir(clk->name, pdentry);
241 if (!d)
242 goto out;
243
244 clk->dentry = d;
245
246 d = debugfs_create_u32("clk_rate", S_IRUGO, clk->dentry,
247 (u32 *)&clk->rate);
248 if (!d)
249 goto err_out;
250
251 d = debugfs_create_x32("clk_flags", S_IRUGO, clk->dentry,
252 (u32 *)&clk->flags);
253 if (!d)
254 goto err_out;
255
256 d = debugfs_create_u32("clk_prepare_count", S_IRUGO, clk->dentry,
257 (u32 *)&clk->prepare_count);
258 if (!d)
259 goto err_out;
260
261 d = debugfs_create_u32("clk_enable_count", S_IRUGO, clk->dentry,
262 (u32 *)&clk->enable_count);
263 if (!d)
264 goto err_out;
265
266 d = debugfs_create_u32("clk_notifier_count", S_IRUGO, clk->dentry,
267 (u32 *)&clk->notifier_count);
268 if (!d)
269 goto err_out;
270
271 ret = 0;
272 goto out;
273
274err_out:
275 debugfs_remove(clk->dentry);
276out:
277 return ret;
278}
279
280/* caller must hold prepare_lock */
281static int clk_debug_create_subtree(struct clk *clk, struct dentry *pdentry)
282{
283 struct clk *child;
Mike Turquetteb24764902012-03-15 23:11:19 -0700284 int ret = -EINVAL;;
285
286 if (!clk || !pdentry)
287 goto out;
288
289 ret = clk_debug_create_one(clk, pdentry);
290
291 if (ret)
292 goto out;
293
Sasha Levinb67bfe02013-02-27 17:06:00 -0800294 hlist_for_each_entry(child, &clk->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700295 clk_debug_create_subtree(child, clk->dentry);
296
297 ret = 0;
298out:
299 return ret;
300}
301
302/**
303 * clk_debug_register - add a clk node to the debugfs clk tree
304 * @clk: the clk being added to the debugfs clk tree
305 *
306 * Dynamically adds a clk to the debugfs clk tree if debugfs has been
307 * initialized. Otherwise it bails out early since the debugfs clk tree
308 * will be created lazily by clk_debug_init as part of a late_initcall.
309 *
310 * Caller must hold prepare_lock. Only clk_init calls this function (so
311 * far) so this is taken care.
312 */
313static int clk_debug_register(struct clk *clk)
314{
315 struct clk *parent;
316 struct dentry *pdentry;
317 int ret = 0;
318
319 if (!inited)
320 goto out;
321
322 parent = clk->parent;
323
324 /*
325 * Check to see if a clk is a root clk. Also check that it is
326 * safe to add this clk to debugfs
327 */
328 if (!parent)
329 if (clk->flags & CLK_IS_ROOT)
330 pdentry = rootdir;
331 else
332 pdentry = orphandir;
333 else
334 if (parent->dentry)
335 pdentry = parent->dentry;
336 else
337 goto out;
338
339 ret = clk_debug_create_subtree(clk, pdentry);
340
341out:
342 return ret;
343}
344
345/**
Ulf Hanssonb33d2122013-04-02 23:09:37 +0200346 * clk_debug_reparent - reparent clk node in the debugfs clk tree
347 * @clk: the clk being reparented
348 * @new_parent: the new clk parent, may be NULL
349 *
350 * Rename clk entry in the debugfs clk tree if debugfs has been
351 * initialized. Otherwise it bails out early since the debugfs clk tree
352 * will be created lazily by clk_debug_init as part of a late_initcall.
353 *
354 * Caller must hold prepare_lock.
355 */
356static void clk_debug_reparent(struct clk *clk, struct clk *new_parent)
357{
358 struct dentry *d;
359 struct dentry *new_parent_d;
360
361 if (!inited)
362 return;
363
364 if (new_parent)
365 new_parent_d = new_parent->dentry;
366 else
367 new_parent_d = orphandir;
368
369 d = debugfs_rename(clk->dentry->d_parent, clk->dentry,
370 new_parent_d, clk->name);
371 if (d)
372 clk->dentry = d;
373 else
374 pr_debug("%s: failed to rename debugfs entry for %s\n",
375 __func__, clk->name);
376}
377
378/**
Mike Turquetteb24764902012-03-15 23:11:19 -0700379 * clk_debug_init - lazily create the debugfs clk tree visualization
380 *
381 * clks are often initialized very early during boot before memory can
382 * be dynamically allocated and well before debugfs is setup.
383 * clk_debug_init walks the clk tree hierarchy while holding
384 * prepare_lock and creates the topology as part of a late_initcall,
385 * thus insuring that clks initialized very early will still be
386 * represented in the debugfs clk tree. This function should only be
387 * called once at boot-time, and all other clks added dynamically will
388 * be done so with clk_debug_register.
389 */
390static int __init clk_debug_init(void)
391{
392 struct clk *clk;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530393 struct dentry *d;
Mike Turquetteb24764902012-03-15 23:11:19 -0700394
395 rootdir = debugfs_create_dir("clk", NULL);
396
397 if (!rootdir)
398 return -ENOMEM;
399
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530400 d = debugfs_create_file("clk_summary", S_IRUGO, rootdir, NULL,
401 &clk_summary_fops);
402 if (!d)
403 return -ENOMEM;
404
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530405 d = debugfs_create_file("clk_dump", S_IRUGO, rootdir, NULL,
406 &clk_dump_fops);
407 if (!d)
408 return -ENOMEM;
409
Mike Turquetteb24764902012-03-15 23:11:19 -0700410 orphandir = debugfs_create_dir("orphans", rootdir);
411
412 if (!orphandir)
413 return -ENOMEM;
414
Mike Turquetteeab89f62013-03-28 13:59:01 -0700415 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700416
Sasha Levinb67bfe02013-02-27 17:06:00 -0800417 hlist_for_each_entry(clk, &clk_root_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700418 clk_debug_create_subtree(clk, rootdir);
419
Sasha Levinb67bfe02013-02-27 17:06:00 -0800420 hlist_for_each_entry(clk, &clk_orphan_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700421 clk_debug_create_subtree(clk, orphandir);
422
423 inited = 1;
424
Mike Turquetteeab89f62013-03-28 13:59:01 -0700425 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700426
427 return 0;
428}
429late_initcall(clk_debug_init);
430#else
431static inline int clk_debug_register(struct clk *clk) { return 0; }
Ulf Hanssonb33d2122013-04-02 23:09:37 +0200432static inline void clk_debug_reparent(struct clk *clk, struct clk *new_parent)
433{
434}
Mike Turquette70d347e2012-03-26 11:53:47 -0700435#endif
Mike Turquetteb24764902012-03-15 23:11:19 -0700436
Mike Turquetteb24764902012-03-15 23:11:19 -0700437/* caller must hold prepare_lock */
Ulf Hansson1c155b32013-03-12 20:26:03 +0100438static void clk_unprepare_unused_subtree(struct clk *clk)
439{
440 struct clk *child;
441
442 if (!clk)
443 return;
444
445 hlist_for_each_entry(child, &clk->children, child_node)
446 clk_unprepare_unused_subtree(child);
447
448 if (clk->prepare_count)
449 return;
450
451 if (clk->flags & CLK_IGNORE_UNUSED)
452 return;
453
Ulf Hansson3cc82472013-03-12 20:26:04 +0100454 if (__clk_is_prepared(clk)) {
455 if (clk->ops->unprepare_unused)
456 clk->ops->unprepare_unused(clk->hw);
457 else if (clk->ops->unprepare)
Ulf Hansson1c155b32013-03-12 20:26:03 +0100458 clk->ops->unprepare(clk->hw);
Ulf Hansson3cc82472013-03-12 20:26:04 +0100459 }
Ulf Hansson1c155b32013-03-12 20:26:03 +0100460}
Sebastian Hesselbarth496620c2013-04-15 08:59:46 +0200461EXPORT_SYMBOL_GPL(__clk_get_flags);
Ulf Hansson1c155b32013-03-12 20:26:03 +0100462
463/* caller must hold prepare_lock */
Mike Turquetteb24764902012-03-15 23:11:19 -0700464static void clk_disable_unused_subtree(struct clk *clk)
465{
466 struct clk *child;
Mike Turquetteb24764902012-03-15 23:11:19 -0700467 unsigned long flags;
468
469 if (!clk)
470 goto out;
471
Sasha Levinb67bfe02013-02-27 17:06:00 -0800472 hlist_for_each_entry(child, &clk->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700473 clk_disable_unused_subtree(child);
474
Mike Turquetteeab89f62013-03-28 13:59:01 -0700475 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700476
477 if (clk->enable_count)
478 goto unlock_out;
479
480 if (clk->flags & CLK_IGNORE_UNUSED)
481 goto unlock_out;
482
Mike Turquette7c045a52012-12-04 11:00:35 -0800483 /*
484 * some gate clocks have special needs during the disable-unused
485 * sequence. call .disable_unused if available, otherwise fall
486 * back to .disable
487 */
488 if (__clk_is_enabled(clk)) {
489 if (clk->ops->disable_unused)
490 clk->ops->disable_unused(clk->hw);
491 else if (clk->ops->disable)
492 clk->ops->disable(clk->hw);
493 }
Mike Turquetteb24764902012-03-15 23:11:19 -0700494
495unlock_out:
Mike Turquetteeab89f62013-03-28 13:59:01 -0700496 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700497
498out:
499 return;
500}
501
Olof Johansson1e435252013-04-27 14:10:18 -0700502static bool clk_ignore_unused;
503static int __init clk_ignore_unused_setup(char *__unused)
504{
505 clk_ignore_unused = true;
506 return 1;
507}
508__setup("clk_ignore_unused", clk_ignore_unused_setup);
509
Mike Turquetteb24764902012-03-15 23:11:19 -0700510static int clk_disable_unused(void)
511{
512 struct clk *clk;
Mike Turquetteb24764902012-03-15 23:11:19 -0700513
Olof Johansson1e435252013-04-27 14:10:18 -0700514 if (clk_ignore_unused) {
515 pr_warn("clk: Not disabling unused clocks\n");
516 return 0;
517 }
518
Mike Turquetteeab89f62013-03-28 13:59:01 -0700519 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700520
Sasha Levinb67bfe02013-02-27 17:06:00 -0800521 hlist_for_each_entry(clk, &clk_root_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700522 clk_disable_unused_subtree(clk);
523
Sasha Levinb67bfe02013-02-27 17:06:00 -0800524 hlist_for_each_entry(clk, &clk_orphan_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700525 clk_disable_unused_subtree(clk);
526
Ulf Hansson1c155b32013-03-12 20:26:03 +0100527 hlist_for_each_entry(clk, &clk_root_list, child_node)
528 clk_unprepare_unused_subtree(clk);
529
530 hlist_for_each_entry(clk, &clk_orphan_list, child_node)
531 clk_unprepare_unused_subtree(clk);
532
Mike Turquetteeab89f62013-03-28 13:59:01 -0700533 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700534
535 return 0;
536}
537late_initcall(clk_disable_unused);
Mike Turquetteb24764902012-03-15 23:11:19 -0700538
539/*** helper functions ***/
540
Russ Dill65800b22012-11-26 11:20:09 -0800541const char *__clk_get_name(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700542{
543 return !clk ? NULL : clk->name;
544}
Niels de Vos48950842012-12-13 13:12:25 +0100545EXPORT_SYMBOL_GPL(__clk_get_name);
Mike Turquetteb24764902012-03-15 23:11:19 -0700546
Russ Dill65800b22012-11-26 11:20:09 -0800547struct clk_hw *__clk_get_hw(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700548{
549 return !clk ? NULL : clk->hw;
550}
551
Russ Dill65800b22012-11-26 11:20:09 -0800552u8 __clk_get_num_parents(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700553{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700554 return !clk ? 0 : clk->num_parents;
Mike Turquetteb24764902012-03-15 23:11:19 -0700555}
556
Russ Dill65800b22012-11-26 11:20:09 -0800557struct clk *__clk_get_parent(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700558{
559 return !clk ? NULL : clk->parent;
560}
561
Russ Dill65800b22012-11-26 11:20:09 -0800562unsigned int __clk_get_enable_count(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700563{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700564 return !clk ? 0 : clk->enable_count;
Mike Turquetteb24764902012-03-15 23:11:19 -0700565}
566
Russ Dill65800b22012-11-26 11:20:09 -0800567unsigned int __clk_get_prepare_count(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700568{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700569 return !clk ? 0 : clk->prepare_count;
Mike Turquetteb24764902012-03-15 23:11:19 -0700570}
571
572unsigned long __clk_get_rate(struct clk *clk)
573{
574 unsigned long ret;
575
576 if (!clk) {
Rajendra Nayak34e44fe2012-03-26 19:01:48 +0530577 ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700578 goto out;
579 }
580
581 ret = clk->rate;
582
583 if (clk->flags & CLK_IS_ROOT)
584 goto out;
585
586 if (!clk->parent)
Rajendra Nayak34e44fe2012-03-26 19:01:48 +0530587 ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700588
589out:
590 return ret;
591}
592
Russ Dill65800b22012-11-26 11:20:09 -0800593unsigned long __clk_get_flags(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700594{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700595 return !clk ? 0 : clk->flags;
Mike Turquetteb24764902012-03-15 23:11:19 -0700596}
597
Ulf Hansson3d6ee282013-03-12 20:26:02 +0100598bool __clk_is_prepared(struct clk *clk)
599{
600 int ret;
601
602 if (!clk)
603 return false;
604
605 /*
606 * .is_prepared is optional for clocks that can prepare
607 * fall back to software usage counter if it is missing
608 */
609 if (!clk->ops->is_prepared) {
610 ret = clk->prepare_count ? 1 : 0;
611 goto out;
612 }
613
614 ret = clk->ops->is_prepared(clk->hw);
615out:
616 return !!ret;
617}
618
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700619bool __clk_is_enabled(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700620{
621 int ret;
622
623 if (!clk)
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700624 return false;
Mike Turquetteb24764902012-03-15 23:11:19 -0700625
626 /*
627 * .is_enabled is only mandatory for clocks that gate
628 * fall back to software usage counter if .is_enabled is missing
629 */
630 if (!clk->ops->is_enabled) {
631 ret = clk->enable_count ? 1 : 0;
632 goto out;
633 }
634
635 ret = clk->ops->is_enabled(clk->hw);
636out:
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700637 return !!ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700638}
639
640static struct clk *__clk_lookup_subtree(const char *name, struct clk *clk)
641{
642 struct clk *child;
643 struct clk *ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700644
645 if (!strcmp(clk->name, name))
646 return clk;
647
Sasha Levinb67bfe02013-02-27 17:06:00 -0800648 hlist_for_each_entry(child, &clk->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -0700649 ret = __clk_lookup_subtree(name, child);
650 if (ret)
651 return ret;
652 }
653
654 return NULL;
655}
656
657struct clk *__clk_lookup(const char *name)
658{
659 struct clk *root_clk;
660 struct clk *ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700661
662 if (!name)
663 return NULL;
664
665 /* search the 'proper' clk tree first */
Sasha Levinb67bfe02013-02-27 17:06:00 -0800666 hlist_for_each_entry(root_clk, &clk_root_list, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -0700667 ret = __clk_lookup_subtree(name, root_clk);
668 if (ret)
669 return ret;
670 }
671
672 /* if not found, then search the orphan tree */
Sasha Levinb67bfe02013-02-27 17:06:00 -0800673 hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -0700674 ret = __clk_lookup_subtree(name, root_clk);
675 if (ret)
676 return ret;
677 }
678
679 return NULL;
680}
681
682/*** clk api ***/
683
684void __clk_unprepare(struct clk *clk)
685{
686 if (!clk)
687 return;
688
689 if (WARN_ON(clk->prepare_count == 0))
690 return;
691
692 if (--clk->prepare_count > 0)
693 return;
694
695 WARN_ON(clk->enable_count > 0);
696
697 if (clk->ops->unprepare)
698 clk->ops->unprepare(clk->hw);
699
700 __clk_unprepare(clk->parent);
701}
702
703/**
704 * clk_unprepare - undo preparation of a clock source
705 * @clk: the clk being unprepare
706 *
707 * clk_unprepare may sleep, which differentiates it from clk_disable. In a
708 * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
709 * if the operation may sleep. One example is a clk which is accessed over
710 * I2c. In the complex case a clk gate operation may require a fast and a slow
711 * part. It is this reason that clk_unprepare and clk_disable are not mutually
712 * exclusive. In fact clk_disable must be called before clk_unprepare.
713 */
714void clk_unprepare(struct clk *clk)
715{
Mike Turquetteeab89f62013-03-28 13:59:01 -0700716 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700717 __clk_unprepare(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700718 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700719}
720EXPORT_SYMBOL_GPL(clk_unprepare);
721
722int __clk_prepare(struct clk *clk)
723{
724 int ret = 0;
725
726 if (!clk)
727 return 0;
728
729 if (clk->prepare_count == 0) {
730 ret = __clk_prepare(clk->parent);
731 if (ret)
732 return ret;
733
734 if (clk->ops->prepare) {
735 ret = clk->ops->prepare(clk->hw);
736 if (ret) {
737 __clk_unprepare(clk->parent);
738 return ret;
739 }
740 }
741 }
742
743 clk->prepare_count++;
744
745 return 0;
746}
747
748/**
749 * clk_prepare - prepare a clock source
750 * @clk: the clk being prepared
751 *
752 * clk_prepare may sleep, which differentiates it from clk_enable. In a simple
753 * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
754 * operation may sleep. One example is a clk which is accessed over I2c. In
755 * the complex case a clk ungate operation may require a fast and a slow part.
756 * It is this reason that clk_prepare and clk_enable are not mutually
757 * exclusive. In fact clk_prepare must be called before clk_enable.
758 * Returns 0 on success, -EERROR otherwise.
759 */
760int clk_prepare(struct clk *clk)
761{
762 int ret;
763
Mike Turquetteeab89f62013-03-28 13:59:01 -0700764 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700765 ret = __clk_prepare(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700766 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700767
768 return ret;
769}
770EXPORT_SYMBOL_GPL(clk_prepare);
771
772static void __clk_disable(struct clk *clk)
773{
774 if (!clk)
775 return;
776
Fengguang Wue47c6a32012-07-30 14:39:54 -0700777 if (WARN_ON(IS_ERR(clk)))
778 return;
779
Mike Turquetteb24764902012-03-15 23:11:19 -0700780 if (WARN_ON(clk->enable_count == 0))
781 return;
782
783 if (--clk->enable_count > 0)
784 return;
785
786 if (clk->ops->disable)
787 clk->ops->disable(clk->hw);
788
789 __clk_disable(clk->parent);
790}
791
792/**
793 * clk_disable - gate a clock
794 * @clk: the clk being gated
795 *
796 * clk_disable must not sleep, which differentiates it from clk_unprepare. In
797 * a simple case, clk_disable can be used instead of clk_unprepare to gate a
798 * clk if the operation is fast and will never sleep. One example is a
799 * SoC-internal clk which is controlled via simple register writes. In the
800 * complex case a clk gate operation may require a fast and a slow part. It is
801 * this reason that clk_unprepare and clk_disable are not mutually exclusive.
802 * In fact clk_disable must be called before clk_unprepare.
803 */
804void clk_disable(struct clk *clk)
805{
806 unsigned long flags;
807
Mike Turquetteeab89f62013-03-28 13:59:01 -0700808 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700809 __clk_disable(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700810 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700811}
812EXPORT_SYMBOL_GPL(clk_disable);
813
814static int __clk_enable(struct clk *clk)
815{
816 int ret = 0;
817
818 if (!clk)
819 return 0;
820
821 if (WARN_ON(clk->prepare_count == 0))
822 return -ESHUTDOWN;
823
824 if (clk->enable_count == 0) {
825 ret = __clk_enable(clk->parent);
826
827 if (ret)
828 return ret;
829
830 if (clk->ops->enable) {
831 ret = clk->ops->enable(clk->hw);
832 if (ret) {
833 __clk_disable(clk->parent);
834 return ret;
835 }
836 }
837 }
838
839 clk->enable_count++;
840 return 0;
841}
842
843/**
844 * clk_enable - ungate a clock
845 * @clk: the clk being ungated
846 *
847 * clk_enable must not sleep, which differentiates it from clk_prepare. In a
848 * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
849 * if the operation will never sleep. One example is a SoC-internal clk which
850 * is controlled via simple register writes. In the complex case a clk ungate
851 * operation may require a fast and a slow part. It is this reason that
852 * clk_enable and clk_prepare are not mutually exclusive. In fact clk_prepare
853 * must be called before clk_enable. Returns 0 on success, -EERROR
854 * otherwise.
855 */
856int clk_enable(struct clk *clk)
857{
858 unsigned long flags;
859 int ret;
860
Mike Turquetteeab89f62013-03-28 13:59:01 -0700861 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700862 ret = __clk_enable(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700863 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700864
865 return ret;
866}
867EXPORT_SYMBOL_GPL(clk_enable);
868
869/**
Mike Turquetteb24764902012-03-15 23:11:19 -0700870 * __clk_round_rate - round the given rate for a clk
871 * @clk: round the rate of this clock
872 *
873 * Caller must hold prepare_lock. Useful for clk_ops such as .set_rate
874 */
875unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)
876{
Shawn Guo81536e02012-04-12 20:50:17 +0800877 unsigned long parent_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700878
879 if (!clk)
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700880 return 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700881
Shawn Guof4d8af22012-04-12 20:50:19 +0800882 if (!clk->ops->round_rate) {
883 if (clk->flags & CLK_SET_RATE_PARENT)
884 return __clk_round_rate(clk->parent, rate);
885 else
886 return clk->rate;
887 }
Mike Turquetteb24764902012-03-15 23:11:19 -0700888
Shawn Guo81536e02012-04-12 20:50:17 +0800889 if (clk->parent)
890 parent_rate = clk->parent->rate;
891
892 return clk->ops->round_rate(clk->hw, rate, &parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -0700893}
894
895/**
896 * clk_round_rate - round the given rate for a clk
897 * @clk: the clk for which we are rounding a rate
898 * @rate: the rate which is to be rounded
899 *
900 * Takes in a rate as input and rounds it to a rate that the clk can actually
901 * use which is then returned. If clk doesn't support round_rate operation
902 * then the parent rate is returned.
903 */
904long clk_round_rate(struct clk *clk, unsigned long rate)
905{
906 unsigned long ret;
907
Mike Turquetteeab89f62013-03-28 13:59:01 -0700908 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700909 ret = __clk_round_rate(clk, rate);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700910 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700911
912 return ret;
913}
914EXPORT_SYMBOL_GPL(clk_round_rate);
915
916/**
917 * __clk_notify - call clk notifier chain
918 * @clk: struct clk * that is changing rate
919 * @msg: clk notifier type (see include/linux/clk.h)
920 * @old_rate: old clk rate
921 * @new_rate: new clk rate
922 *
923 * Triggers a notifier call chain on the clk rate-change notification
924 * for 'clk'. Passes a pointer to the struct clk and the previous
925 * and current rates to the notifier callback. Intended to be called by
926 * internal clock code only. Returns NOTIFY_DONE from the last driver
927 * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
928 * a driver returns that.
929 */
930static int __clk_notify(struct clk *clk, unsigned long msg,
931 unsigned long old_rate, unsigned long new_rate)
932{
933 struct clk_notifier *cn;
934 struct clk_notifier_data cnd;
935 int ret = NOTIFY_DONE;
936
937 cnd.clk = clk;
938 cnd.old_rate = old_rate;
939 cnd.new_rate = new_rate;
940
941 list_for_each_entry(cn, &clk_notifier_list, node) {
942 if (cn->clk == clk) {
943 ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
944 &cnd);
945 break;
946 }
947 }
948
949 return ret;
950}
951
952/**
953 * __clk_recalc_rates
954 * @clk: first clk in the subtree
955 * @msg: notification type (see include/linux/clk.h)
956 *
957 * Walks the subtree of clks starting with clk and recalculates rates as it
958 * goes. Note that if a clk does not implement the .recalc_rate callback then
959 * it is assumed that the clock will take on the rate of it's parent.
960 *
961 * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
962 * if necessary.
963 *
964 * Caller must hold prepare_lock.
965 */
966static void __clk_recalc_rates(struct clk *clk, unsigned long msg)
967{
968 unsigned long old_rate;
969 unsigned long parent_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700970 struct clk *child;
971
972 old_rate = clk->rate;
973
974 if (clk->parent)
975 parent_rate = clk->parent->rate;
976
977 if (clk->ops->recalc_rate)
978 clk->rate = clk->ops->recalc_rate(clk->hw, parent_rate);
979 else
980 clk->rate = parent_rate;
981
982 /*
983 * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
984 * & ABORT_RATE_CHANGE notifiers
985 */
986 if (clk->notifier_count && msg)
987 __clk_notify(clk, msg, old_rate, clk->rate);
988
Sasha Levinb67bfe02013-02-27 17:06:00 -0800989 hlist_for_each_entry(child, &clk->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700990 __clk_recalc_rates(child, msg);
991}
992
993/**
Ulf Hanssona093bde2012-08-31 14:21:28 +0200994 * clk_get_rate - return the rate of clk
995 * @clk: the clk whose rate is being returned
996 *
997 * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
998 * is set, which means a recalc_rate will be issued.
999 * If clk is NULL then returns 0.
1000 */
1001unsigned long clk_get_rate(struct clk *clk)
1002{
1003 unsigned long rate;
1004
Mike Turquetteeab89f62013-03-28 13:59:01 -07001005 clk_prepare_lock();
Ulf Hanssona093bde2012-08-31 14:21:28 +02001006
1007 if (clk && (clk->flags & CLK_GET_RATE_NOCACHE))
1008 __clk_recalc_rates(clk, 0);
1009
1010 rate = __clk_get_rate(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -07001011 clk_prepare_unlock();
Ulf Hanssona093bde2012-08-31 14:21:28 +02001012
1013 return rate;
1014}
1015EXPORT_SYMBOL_GPL(clk_get_rate);
1016
1017/**
Mike Turquetteb24764902012-03-15 23:11:19 -07001018 * __clk_speculate_rates
1019 * @clk: first clk in the subtree
1020 * @parent_rate: the "future" rate of clk's parent
1021 *
1022 * Walks the subtree of clks starting with clk, speculating rates as it
1023 * goes and firing off PRE_RATE_CHANGE notifications as necessary.
1024 *
1025 * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
1026 * pre-rate change notifications and returns early if no clks in the
1027 * subtree have subscribed to the notifications. Note that if a clk does not
1028 * implement the .recalc_rate callback then it is assumed that the clock will
1029 * take on the rate of it's parent.
1030 *
1031 * Caller must hold prepare_lock.
1032 */
1033static int __clk_speculate_rates(struct clk *clk, unsigned long parent_rate)
1034{
Mike Turquetteb24764902012-03-15 23:11:19 -07001035 struct clk *child;
1036 unsigned long new_rate;
1037 int ret = NOTIFY_DONE;
1038
1039 if (clk->ops->recalc_rate)
1040 new_rate = clk->ops->recalc_rate(clk->hw, parent_rate);
1041 else
1042 new_rate = parent_rate;
1043
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001044 /* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
Mike Turquetteb24764902012-03-15 23:11:19 -07001045 if (clk->notifier_count)
1046 ret = __clk_notify(clk, PRE_RATE_CHANGE, clk->rate, new_rate);
1047
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001048 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001049 goto out;
1050
Sasha Levinb67bfe02013-02-27 17:06:00 -08001051 hlist_for_each_entry(child, &clk->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001052 ret = __clk_speculate_rates(child, new_rate);
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001053 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001054 break;
1055 }
1056
1057out:
1058 return ret;
1059}
1060
1061static void clk_calc_subtree(struct clk *clk, unsigned long new_rate)
1062{
1063 struct clk *child;
Mike Turquetteb24764902012-03-15 23:11:19 -07001064
1065 clk->new_rate = new_rate;
1066
Sasha Levinb67bfe02013-02-27 17:06:00 -08001067 hlist_for_each_entry(child, &clk->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001068 if (child->ops->recalc_rate)
1069 child->new_rate = child->ops->recalc_rate(child->hw, new_rate);
1070 else
1071 child->new_rate = new_rate;
1072 clk_calc_subtree(child, child->new_rate);
1073 }
1074}
1075
1076/*
1077 * calculate the new rates returning the topmost clock that has to be
1078 * changed.
1079 */
1080static struct clk *clk_calc_new_rates(struct clk *clk, unsigned long rate)
1081{
1082 struct clk *top = clk;
Shawn Guo81536e02012-04-12 20:50:17 +08001083 unsigned long best_parent_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001084 unsigned long new_rate;
1085
Mike Turquette7452b212012-03-26 14:45:36 -07001086 /* sanity */
1087 if (IS_ERR_OR_NULL(clk))
1088 return NULL;
1089
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001090 /* save parent rate, if it exists */
1091 if (clk->parent)
1092 best_parent_rate = clk->parent->rate;
1093
Mike Turquette7452b212012-03-26 14:45:36 -07001094 /* never propagate up to the parent */
1095 if (!(clk->flags & CLK_SET_RATE_PARENT)) {
1096 if (!clk->ops->round_rate) {
1097 clk->new_rate = clk->rate;
1098 return NULL;
Mike Turquette7452b212012-03-26 14:45:36 -07001099 }
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001100 new_rate = clk->ops->round_rate(clk->hw, rate, &best_parent_rate);
1101 goto out;
Mike Turquette7452b212012-03-26 14:45:36 -07001102 }
1103
1104 /* need clk->parent from here on out */
1105 if (!clk->parent) {
1106 pr_debug("%s: %s has NULL parent\n", __func__, clk->name);
Mike Turquetteb24764902012-03-15 23:11:19 -07001107 return NULL;
1108 }
1109
Mike Turquette7452b212012-03-26 14:45:36 -07001110 if (!clk->ops->round_rate) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001111 top = clk_calc_new_rates(clk->parent, rate);
Viresh Kumar1b2f9902012-04-17 16:45:38 +05301112 new_rate = clk->parent->new_rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07001113
1114 goto out;
1115 }
1116
Mike Turquette7452b212012-03-26 14:45:36 -07001117 new_rate = clk->ops->round_rate(clk->hw, rate, &best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001118
1119 if (best_parent_rate != clk->parent->rate) {
1120 top = clk_calc_new_rates(clk->parent, best_parent_rate);
1121
1122 goto out;
1123 }
1124
1125out:
1126 clk_calc_subtree(clk, new_rate);
1127
1128 return top;
1129}
1130
1131/*
1132 * Notify about rate changes in a subtree. Always walk down the whole tree
1133 * so that in case of an error we can walk down the whole tree again and
1134 * abort the change.
1135 */
1136static struct clk *clk_propagate_rate_change(struct clk *clk, unsigned long event)
1137{
Mike Turquetteb24764902012-03-15 23:11:19 -07001138 struct clk *child, *fail_clk = NULL;
1139 int ret = NOTIFY_DONE;
1140
1141 if (clk->rate == clk->new_rate)
Sachin Kamat5fda6852013-03-13 15:17:49 +05301142 return NULL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001143
1144 if (clk->notifier_count) {
1145 ret = __clk_notify(clk, event, clk->rate, clk->new_rate);
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001146 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001147 fail_clk = clk;
1148 }
1149
Sasha Levinb67bfe02013-02-27 17:06:00 -08001150 hlist_for_each_entry(child, &clk->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001151 clk = clk_propagate_rate_change(child, event);
1152 if (clk)
1153 fail_clk = clk;
1154 }
1155
1156 return fail_clk;
1157}
1158
1159/*
1160 * walk down a subtree and set the new rates notifying the rate
1161 * change on the way
1162 */
1163static void clk_change_rate(struct clk *clk)
1164{
1165 struct clk *child;
1166 unsigned long old_rate;
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001167 unsigned long best_parent_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001168
1169 old_rate = clk->rate;
1170
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001171 if (clk->parent)
1172 best_parent_rate = clk->parent->rate;
1173
Mike Turquetteb24764902012-03-15 23:11:19 -07001174 if (clk->ops->set_rate)
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001175 clk->ops->set_rate(clk->hw, clk->new_rate, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001176
1177 if (clk->ops->recalc_rate)
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001178 clk->rate = clk->ops->recalc_rate(clk->hw, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001179 else
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001180 clk->rate = best_parent_rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07001181
1182 if (clk->notifier_count && old_rate != clk->rate)
1183 __clk_notify(clk, POST_RATE_CHANGE, old_rate, clk->rate);
1184
Sasha Levinb67bfe02013-02-27 17:06:00 -08001185 hlist_for_each_entry(child, &clk->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -07001186 clk_change_rate(child);
1187}
1188
1189/**
1190 * clk_set_rate - specify a new rate for clk
1191 * @clk: the clk whose rate is being changed
1192 * @rate: the new rate for clk
1193 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001194 * In the simplest case clk_set_rate will only adjust the rate of clk.
Mike Turquetteb24764902012-03-15 23:11:19 -07001195 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001196 * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
1197 * propagate up to clk's parent; whether or not this happens depends on the
1198 * outcome of clk's .round_rate implementation. If *parent_rate is unchanged
1199 * after calling .round_rate then upstream parent propagation is ignored. If
1200 * *parent_rate comes back with a new rate for clk's parent then we propagate
1201 * up to clk's parent and set it's rate. Upward propagation will continue
1202 * until either a clk does not support the CLK_SET_RATE_PARENT flag or
1203 * .round_rate stops requesting changes to clk's parent_rate.
Mike Turquetteb24764902012-03-15 23:11:19 -07001204 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001205 * Rate changes are accomplished via tree traversal that also recalculates the
1206 * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
Mike Turquetteb24764902012-03-15 23:11:19 -07001207 *
1208 * Returns 0 on success, -EERROR otherwise.
1209 */
1210int clk_set_rate(struct clk *clk, unsigned long rate)
1211{
1212 struct clk *top, *fail_clk;
1213 int ret = 0;
1214
1215 /* prevent racing with updates to the clock topology */
Mike Turquetteeab89f62013-03-28 13:59:01 -07001216 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001217
1218 /* bail early if nothing to do */
1219 if (rate == clk->rate)
1220 goto out;
1221
Saravana Kannan7e0fa1b2012-05-15 13:43:42 -07001222 if ((clk->flags & CLK_SET_RATE_GATE) && clk->prepare_count) {
Viresh Kumar0e1c0302012-04-11 16:03:42 +05301223 ret = -EBUSY;
1224 goto out;
1225 }
1226
Mike Turquetteb24764902012-03-15 23:11:19 -07001227 /* calculate new rates and get the topmost changed clock */
1228 top = clk_calc_new_rates(clk, rate);
1229 if (!top) {
1230 ret = -EINVAL;
1231 goto out;
1232 }
1233
1234 /* notify that we are about to change rates */
1235 fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
1236 if (fail_clk) {
1237 pr_warn("%s: failed to set %s rate\n", __func__,
1238 fail_clk->name);
1239 clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
1240 ret = -EBUSY;
1241 goto out;
1242 }
1243
1244 /* change the rates */
1245 clk_change_rate(top);
1246
Mike Turquetteb24764902012-03-15 23:11:19 -07001247out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001248 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001249
1250 return ret;
1251}
1252EXPORT_SYMBOL_GPL(clk_set_rate);
1253
1254/**
1255 * clk_get_parent - return the parent of a clk
1256 * @clk: the clk whose parent gets returned
1257 *
1258 * Simply returns clk->parent. Returns NULL if clk is NULL.
1259 */
1260struct clk *clk_get_parent(struct clk *clk)
1261{
1262 struct clk *parent;
1263
Mike Turquetteeab89f62013-03-28 13:59:01 -07001264 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001265 parent = __clk_get_parent(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -07001266 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001267
1268 return parent;
1269}
1270EXPORT_SYMBOL_GPL(clk_get_parent);
1271
1272/*
1273 * .get_parent is mandatory for clocks with multiple possible parents. It is
1274 * optional for single-parent clocks. Always call .get_parent if it is
1275 * available and WARN if it is missing for multi-parent clocks.
1276 *
1277 * For single-parent clocks without .get_parent, first check to see if the
1278 * .parents array exists, and if so use it to avoid an expensive tree
1279 * traversal. If .parents does not exist then walk the tree with __clk_lookup.
1280 */
1281static struct clk *__clk_init_parent(struct clk *clk)
1282{
1283 struct clk *ret = NULL;
1284 u8 index;
1285
1286 /* handle the trivial cases */
1287
1288 if (!clk->num_parents)
1289 goto out;
1290
1291 if (clk->num_parents == 1) {
1292 if (IS_ERR_OR_NULL(clk->parent))
1293 ret = clk->parent = __clk_lookup(clk->parent_names[0]);
1294 ret = clk->parent;
1295 goto out;
1296 }
1297
1298 if (!clk->ops->get_parent) {
1299 WARN(!clk->ops->get_parent,
1300 "%s: multi-parent clocks must implement .get_parent\n",
1301 __func__);
1302 goto out;
1303 };
1304
1305 /*
1306 * Do our best to cache parent clocks in clk->parents. This prevents
1307 * unnecessary and expensive calls to __clk_lookup. We don't set
1308 * clk->parent here; that is done by the calling function
1309 */
1310
1311 index = clk->ops->get_parent(clk->hw);
1312
1313 if (!clk->parents)
1314 clk->parents =
Rajendra Nayak79750592012-06-06 14:41:31 +05301315 kzalloc((sizeof(struct clk*) * clk->num_parents),
Mike Turquetteb24764902012-03-15 23:11:19 -07001316 GFP_KERNEL);
1317
1318 if (!clk->parents)
1319 ret = __clk_lookup(clk->parent_names[index]);
1320 else if (!clk->parents[index])
1321 ret = clk->parents[index] =
1322 __clk_lookup(clk->parent_names[index]);
1323 else
1324 ret = clk->parents[index];
1325
1326out:
1327 return ret;
1328}
1329
Ulf Hanssonb33d2122013-04-02 23:09:37 +02001330static void clk_reparent(struct clk *clk, struct clk *new_parent)
Mike Turquetteb24764902012-03-15 23:11:19 -07001331{
Mike Turquetteb24764902012-03-15 23:11:19 -07001332 hlist_del(&clk->child_node);
1333
1334 if (new_parent)
1335 hlist_add_head(&clk->child_node, &new_parent->children);
1336 else
1337 hlist_add_head(&clk->child_node, &clk_orphan_list);
1338
Mike Turquetteb24764902012-03-15 23:11:19 -07001339 clk->parent = new_parent;
Ulf Hanssonb33d2122013-04-02 23:09:37 +02001340}
Mike Turquetteb24764902012-03-15 23:11:19 -07001341
Ulf Hanssonb33d2122013-04-02 23:09:37 +02001342void __clk_reparent(struct clk *clk, struct clk *new_parent)
1343{
1344 clk_reparent(clk, new_parent);
1345 clk_debug_reparent(clk, new_parent);
Mike Turquetteb24764902012-03-15 23:11:19 -07001346 __clk_recalc_rates(clk, POST_RATE_CHANGE);
1347}
1348
Ulf Hansson031dcc92013-04-02 23:09:38 +02001349static u8 clk_fetch_parent_index(struct clk *clk, struct clk *parent)
Mike Turquetteb24764902012-03-15 23:11:19 -07001350{
Mike Turquetteb24764902012-03-15 23:11:19 -07001351 u8 i;
1352
Rajendra Nayak863b1322012-07-03 12:11:41 +05301353 if (!clk->parents)
Rajendra Nayak79750592012-06-06 14:41:31 +05301354 clk->parents = kzalloc((sizeof(struct clk*) * clk->num_parents),
1355 GFP_KERNEL);
Mike Turquetteb24764902012-03-15 23:11:19 -07001356
1357 /*
Rajendra Nayak863b1322012-07-03 12:11:41 +05301358 * find index of new parent clock using cached parent ptrs,
1359 * or if not yet cached, use string name comparison and cache
1360 * them now to avoid future calls to __clk_lookup.
Mike Turquetteb24764902012-03-15 23:11:19 -07001361 */
Rajendra Nayak863b1322012-07-03 12:11:41 +05301362 for (i = 0; i < clk->num_parents; i++) {
1363 if (clk->parents && clk->parents[i] == parent)
1364 break;
1365 else if (!strcmp(clk->parent_names[i], parent->name)) {
1366 if (clk->parents)
1367 clk->parents[i] = __clk_lookup(parent->name);
1368 break;
1369 }
1370 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001371
Ulf Hansson031dcc92013-04-02 23:09:38 +02001372 return i;
1373}
1374
1375static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
1376{
1377 unsigned long flags;
1378 int ret = 0;
1379 struct clk *old_parent = clk->parent;
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001380 bool migrated_enable = false;
Mike Turquetteb24764902012-03-15 23:11:19 -07001381
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001382 /* migrate prepare */
Mike Turquetteb24764902012-03-15 23:11:19 -07001383 if (clk->prepare_count)
1384 __clk_prepare(parent);
1385
Mike Turquetteeab89f62013-03-28 13:59:01 -07001386 flags = clk_enable_lock();
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001387
1388 /* migrate enable */
1389 if (clk->enable_count) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001390 __clk_enable(parent);
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001391 migrated_enable = true;
1392 }
1393
1394 /* update the clk tree topology */
1395 clk_reparent(clk, parent);
1396
Mike Turquetteeab89f62013-03-28 13:59:01 -07001397 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -07001398
1399 /* change clock input source */
Ulf Hansson031dcc92013-04-02 23:09:38 +02001400 if (parent && clk->ops->set_parent)
1401 ret = clk->ops->set_parent(clk->hw, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001402
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001403 if (ret) {
1404 /*
1405 * The error handling is tricky due to that we need to release
1406 * the spinlock while issuing the .set_parent callback. This
1407 * means the new parent might have been enabled/disabled in
1408 * between, which must be considered when doing rollback.
1409 */
1410 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001411
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001412 clk_reparent(clk, old_parent);
1413
1414 if (migrated_enable && clk->enable_count) {
1415 __clk_disable(parent);
1416 } else if (migrated_enable && (clk->enable_count == 0)) {
1417 __clk_disable(old_parent);
1418 } else if (!migrated_enable && clk->enable_count) {
1419 __clk_disable(parent);
1420 __clk_enable(old_parent);
1421 }
1422
1423 clk_enable_unlock(flags);
1424
1425 if (clk->prepare_count)
1426 __clk_unprepare(parent);
1427
1428 return ret;
1429 }
1430
1431 /* clean up enable for old parent if migration was done */
1432 if (migrated_enable) {
1433 flags = clk_enable_lock();
1434 __clk_disable(old_parent);
1435 clk_enable_unlock(flags);
1436 }
1437
1438 /* clean up prepare for old parent if migration was done */
Mike Turquetteb24764902012-03-15 23:11:19 -07001439 if (clk->prepare_count)
1440 __clk_unprepare(old_parent);
1441
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001442 /* update debugfs with new clk tree topology */
1443 clk_debug_reparent(clk, parent);
1444 return 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001445}
1446
1447/**
1448 * clk_set_parent - switch the parent of a mux clk
1449 * @clk: the mux clk whose input we are switching
1450 * @parent: the new input to clk
1451 *
1452 * Re-parent clk to use parent as it's new input source. If clk has the
1453 * CLK_SET_PARENT_GATE flag set then clk must be gated for this
1454 * operation to succeed. After successfully changing clk's parent
1455 * clk_set_parent will update the clk topology, sysfs topology and
1456 * propagate rate recalculation via __clk_recalc_rates. Returns 0 on
1457 * success, -EERROR otherwise.
1458 */
1459int clk_set_parent(struct clk *clk, struct clk *parent)
1460{
1461 int ret = 0;
Ulf Hansson031dcc92013-04-02 23:09:38 +02001462 u8 p_index = 0;
1463 unsigned long p_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001464
1465 if (!clk || !clk->ops)
1466 return -EINVAL;
1467
Ulf Hansson031dcc92013-04-02 23:09:38 +02001468 /* verify ops for for multi-parent clks */
1469 if ((clk->num_parents > 1) && (!clk->ops->set_parent))
Mike Turquetteb24764902012-03-15 23:11:19 -07001470 return -ENOSYS;
1471
1472 /* prevent racing with updates to the clock topology */
Mike Turquetteeab89f62013-03-28 13:59:01 -07001473 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001474
1475 if (clk->parent == parent)
1476 goto out;
1477
Ulf Hansson031dcc92013-04-02 23:09:38 +02001478 /* check that we are allowed to re-parent if the clock is in use */
1479 if ((clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) {
1480 ret = -EBUSY;
1481 goto out;
1482 }
1483
1484 /* try finding the new parent index */
1485 if (parent) {
1486 p_index = clk_fetch_parent_index(clk, parent);
1487 p_rate = parent->rate;
1488 if (p_index == clk->num_parents) {
1489 pr_debug("%s: clk %s can not be parent of clk %s\n",
1490 __func__, parent->name, clk->name);
1491 ret = -EINVAL;
1492 goto out;
1493 }
1494 }
1495
Mike Turquetteb24764902012-03-15 23:11:19 -07001496 /* propagate PRE_RATE_CHANGE notifications */
1497 if (clk->notifier_count)
Ulf Hansson031dcc92013-04-02 23:09:38 +02001498 ret = __clk_speculate_rates(clk, p_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001499
1500 /* abort if a driver objects */
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001501 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001502 goto out;
1503
Ulf Hansson031dcc92013-04-02 23:09:38 +02001504 /* do the re-parent */
1505 ret = __clk_set_parent(clk, parent, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001506
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001507 /* propagate rate recalculation accordingly */
1508 if (ret)
Mike Turquetteb24764902012-03-15 23:11:19 -07001509 __clk_recalc_rates(clk, ABORT_RATE_CHANGE);
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001510 else
1511 __clk_recalc_rates(clk, POST_RATE_CHANGE);
Mike Turquetteb24764902012-03-15 23:11:19 -07001512
1513out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001514 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001515
1516 return ret;
1517}
1518EXPORT_SYMBOL_GPL(clk_set_parent);
1519
1520/**
1521 * __clk_init - initialize the data structures in a struct clk
1522 * @dev: device initializing this clk, placeholder for now
1523 * @clk: clk being initialized
1524 *
1525 * Initializes the lists in struct clk, queries the hardware for the
1526 * parent and rate and sets them both.
Mike Turquetteb24764902012-03-15 23:11:19 -07001527 */
Mike Turquetted1302a32012-03-29 14:30:40 -07001528int __clk_init(struct device *dev, struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -07001529{
Mike Turquetted1302a32012-03-29 14:30:40 -07001530 int i, ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001531 struct clk *orphan;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001532 struct hlist_node *tmp2;
Mike Turquetteb24764902012-03-15 23:11:19 -07001533
1534 if (!clk)
Mike Turquetted1302a32012-03-29 14:30:40 -07001535 return -EINVAL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001536
Mike Turquetteeab89f62013-03-28 13:59:01 -07001537 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001538
1539 /* check to see if a clock with this name is already registered */
Mike Turquetted1302a32012-03-29 14:30:40 -07001540 if (__clk_lookup(clk->name)) {
1541 pr_debug("%s: clk %s already initialized\n",
1542 __func__, clk->name);
1543 ret = -EEXIST;
Mike Turquetteb24764902012-03-15 23:11:19 -07001544 goto out;
Mike Turquetted1302a32012-03-29 14:30:40 -07001545 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001546
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001547 /* check that clk_ops are sane. See Documentation/clk.txt */
1548 if (clk->ops->set_rate &&
1549 !(clk->ops->round_rate && clk->ops->recalc_rate)) {
1550 pr_warning("%s: %s must implement .round_rate & .recalc_rate\n",
1551 __func__, clk->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07001552 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001553 goto out;
1554 }
1555
1556 if (clk->ops->set_parent && !clk->ops->get_parent) {
1557 pr_warning("%s: %s must implement .get_parent & .set_parent\n",
1558 __func__, clk->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07001559 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001560 goto out;
1561 }
1562
Mike Turquetteb24764902012-03-15 23:11:19 -07001563 /* throw a WARN if any entries in parent_names are NULL */
1564 for (i = 0; i < clk->num_parents; i++)
1565 WARN(!clk->parent_names[i],
1566 "%s: invalid NULL in %s's .parent_names\n",
1567 __func__, clk->name);
1568
1569 /*
1570 * Allocate an array of struct clk *'s to avoid unnecessary string
1571 * look-ups of clk's possible parents. This can fail for clocks passed
1572 * in to clk_init during early boot; thus any access to clk->parents[]
1573 * must always check for a NULL pointer and try to populate it if
1574 * necessary.
1575 *
1576 * If clk->parents is not NULL we skip this entire block. This allows
1577 * for clock drivers to statically initialize clk->parents.
1578 */
Rajendra Nayak9ca1c5a2012-06-06 14:41:30 +05301579 if (clk->num_parents > 1 && !clk->parents) {
1580 clk->parents = kzalloc((sizeof(struct clk*) * clk->num_parents),
Mike Turquetteb24764902012-03-15 23:11:19 -07001581 GFP_KERNEL);
1582 /*
1583 * __clk_lookup returns NULL for parents that have not been
1584 * clk_init'd; thus any access to clk->parents[] must check
1585 * for a NULL pointer. We can always perform lazy lookups for
1586 * missing parents later on.
1587 */
1588 if (clk->parents)
1589 for (i = 0; i < clk->num_parents; i++)
1590 clk->parents[i] =
1591 __clk_lookup(clk->parent_names[i]);
1592 }
1593
1594 clk->parent = __clk_init_parent(clk);
1595
1596 /*
1597 * Populate clk->parent if parent has already been __clk_init'd. If
1598 * parent has not yet been __clk_init'd then place clk in the orphan
1599 * list. If clk has set the CLK_IS_ROOT flag then place it in the root
1600 * clk list.
1601 *
1602 * Every time a new clk is clk_init'd then we walk the list of orphan
1603 * clocks and re-parent any that are children of the clock currently
1604 * being clk_init'd.
1605 */
1606 if (clk->parent)
1607 hlist_add_head(&clk->child_node,
1608 &clk->parent->children);
1609 else if (clk->flags & CLK_IS_ROOT)
1610 hlist_add_head(&clk->child_node, &clk_root_list);
1611 else
1612 hlist_add_head(&clk->child_node, &clk_orphan_list);
1613
1614 /*
1615 * Set clk's rate. The preferred method is to use .recalc_rate. For
1616 * simple clocks and lazy developers the default fallback is to use the
1617 * parent's rate. If a clock doesn't have a parent (or is orphaned)
1618 * then rate is set to zero.
1619 */
1620 if (clk->ops->recalc_rate)
1621 clk->rate = clk->ops->recalc_rate(clk->hw,
1622 __clk_get_rate(clk->parent));
1623 else if (clk->parent)
1624 clk->rate = clk->parent->rate;
1625 else
1626 clk->rate = 0;
1627
1628 /*
1629 * walk the list of orphan clocks and reparent any that are children of
1630 * this clock
1631 */
Sasha Levinb67bfe02013-02-27 17:06:00 -08001632 hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
Martin Fuzzey1f61e5f2012-11-22 20:15:05 +01001633 if (orphan->ops->get_parent) {
1634 i = orphan->ops->get_parent(orphan->hw);
1635 if (!strcmp(clk->name, orphan->parent_names[i]))
1636 __clk_reparent(orphan, clk);
1637 continue;
1638 }
1639
Mike Turquetteb24764902012-03-15 23:11:19 -07001640 for (i = 0; i < orphan->num_parents; i++)
1641 if (!strcmp(clk->name, orphan->parent_names[i])) {
1642 __clk_reparent(orphan, clk);
1643 break;
1644 }
Martin Fuzzey1f61e5f2012-11-22 20:15:05 +01001645 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001646
1647 /*
1648 * optional platform-specific magic
1649 *
1650 * The .init callback is not used by any of the basic clock types, but
1651 * exists for weird hardware that must perform initialization magic.
1652 * Please consider other ways of solving initialization problems before
1653 * using this callback, as it's use is discouraged.
1654 */
1655 if (clk->ops->init)
1656 clk->ops->init(clk->hw);
1657
1658 clk_debug_register(clk);
1659
1660out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001661 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001662
Mike Turquetted1302a32012-03-29 14:30:40 -07001663 return ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07001664}
1665
1666/**
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001667 * __clk_register - register a clock and return a cookie.
1668 *
1669 * Same as clk_register, except that the .clk field inside hw shall point to a
1670 * preallocated (generally statically allocated) struct clk. None of the fields
1671 * of the struct clk need to be initialized.
1672 *
1673 * The data pointed to by .init and .clk field shall NOT be marked as init
1674 * data.
1675 *
1676 * __clk_register is only exposed via clk-private.h and is intended for use with
1677 * very large numbers of clocks that need to be statically initialized. It is
1678 * a layering violation to include clk-private.h from any code which implements
1679 * a clock's .ops; as such any statically initialized clock data MUST be in a
1680 * separate C file from the logic that implements it's operations. Returns 0
1681 * on success, otherwise an error code.
1682 */
1683struct clk *__clk_register(struct device *dev, struct clk_hw *hw)
1684{
1685 int ret;
1686 struct clk *clk;
1687
1688 clk = hw->clk;
1689 clk->name = hw->init->name;
1690 clk->ops = hw->init->ops;
1691 clk->hw = hw;
1692 clk->flags = hw->init->flags;
1693 clk->parent_names = hw->init->parent_names;
1694 clk->num_parents = hw->init->num_parents;
1695
1696 ret = __clk_init(dev, clk);
1697 if (ret)
1698 return ERR_PTR(ret);
1699
1700 return clk;
1701}
1702EXPORT_SYMBOL_GPL(__clk_register);
1703
Stephen Boyd46c87732012-09-24 13:38:04 -07001704static int _clk_register(struct device *dev, struct clk_hw *hw, struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -07001705{
Mike Turquetted1302a32012-03-29 14:30:40 -07001706 int i, ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07001707
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001708 clk->name = kstrdup(hw->init->name, GFP_KERNEL);
1709 if (!clk->name) {
1710 pr_err("%s: could not allocate clk->name\n", __func__);
1711 ret = -ENOMEM;
1712 goto fail_name;
1713 }
1714 clk->ops = hw->init->ops;
Mike Turquetteb24764902012-03-15 23:11:19 -07001715 clk->hw = hw;
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001716 clk->flags = hw->init->flags;
1717 clk->num_parents = hw->init->num_parents;
Mike Turquetteb24764902012-03-15 23:11:19 -07001718 hw->clk = clk;
1719
Mike Turquetted1302a32012-03-29 14:30:40 -07001720 /* allocate local copy in case parent_names is __initdata */
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001721 clk->parent_names = kzalloc((sizeof(char*) * clk->num_parents),
Mike Turquetted1302a32012-03-29 14:30:40 -07001722 GFP_KERNEL);
Mike Turquetteb24764902012-03-15 23:11:19 -07001723
Mike Turquetted1302a32012-03-29 14:30:40 -07001724 if (!clk->parent_names) {
1725 pr_err("%s: could not allocate clk->parent_names\n", __func__);
1726 ret = -ENOMEM;
1727 goto fail_parent_names;
1728 }
1729
1730
1731 /* copy each string name in case parent_names is __initdata */
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001732 for (i = 0; i < clk->num_parents; i++) {
1733 clk->parent_names[i] = kstrdup(hw->init->parent_names[i],
1734 GFP_KERNEL);
Mike Turquetted1302a32012-03-29 14:30:40 -07001735 if (!clk->parent_names[i]) {
1736 pr_err("%s: could not copy parent_names\n", __func__);
1737 ret = -ENOMEM;
1738 goto fail_parent_names_copy;
1739 }
1740 }
1741
1742 ret = __clk_init(dev, clk);
1743 if (!ret)
Stephen Boyd46c87732012-09-24 13:38:04 -07001744 return 0;
Mike Turquetted1302a32012-03-29 14:30:40 -07001745
1746fail_parent_names_copy:
1747 while (--i >= 0)
1748 kfree(clk->parent_names[i]);
1749 kfree(clk->parent_names);
1750fail_parent_names:
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001751 kfree(clk->name);
1752fail_name:
Stephen Boyd46c87732012-09-24 13:38:04 -07001753 return ret;
1754}
1755
1756/**
1757 * clk_register - allocate a new clock, register it and return an opaque cookie
1758 * @dev: device that is registering this clock
1759 * @hw: link to hardware-specific clock data
1760 *
1761 * clk_register is the primary interface for populating the clock tree with new
1762 * clock nodes. It returns a pointer to the newly allocated struct clk which
1763 * cannot be dereferenced by driver code but may be used in conjuction with the
1764 * rest of the clock API. In the event of an error clk_register will return an
1765 * error code; drivers must test for an error code after calling clk_register.
1766 */
1767struct clk *clk_register(struct device *dev, struct clk_hw *hw)
1768{
1769 int ret;
1770 struct clk *clk;
1771
1772 clk = kzalloc(sizeof(*clk), GFP_KERNEL);
1773 if (!clk) {
1774 pr_err("%s: could not allocate clk\n", __func__);
1775 ret = -ENOMEM;
1776 goto fail_out;
1777 }
1778
1779 ret = _clk_register(dev, hw, clk);
1780 if (!ret)
1781 return clk;
1782
Mike Turquetted1302a32012-03-29 14:30:40 -07001783 kfree(clk);
1784fail_out:
1785 return ERR_PTR(ret);
Mike Turquetteb24764902012-03-15 23:11:19 -07001786}
1787EXPORT_SYMBOL_GPL(clk_register);
1788
Mark Brown1df5c932012-04-18 09:07:12 +01001789/**
1790 * clk_unregister - unregister a currently registered clock
1791 * @clk: clock to unregister
1792 *
1793 * Currently unimplemented.
1794 */
1795void clk_unregister(struct clk *clk) {}
1796EXPORT_SYMBOL_GPL(clk_unregister);
1797
Stephen Boyd46c87732012-09-24 13:38:04 -07001798static void devm_clk_release(struct device *dev, void *res)
1799{
1800 clk_unregister(res);
1801}
1802
1803/**
1804 * devm_clk_register - resource managed clk_register()
1805 * @dev: device that is registering this clock
1806 * @hw: link to hardware-specific clock data
1807 *
1808 * Managed clk_register(). Clocks returned from this function are
1809 * automatically clk_unregister()ed on driver detach. See clk_register() for
1810 * more information.
1811 */
1812struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw)
1813{
1814 struct clk *clk;
1815 int ret;
1816
1817 clk = devres_alloc(devm_clk_release, sizeof(*clk), GFP_KERNEL);
1818 if (!clk)
1819 return ERR_PTR(-ENOMEM);
1820
1821 ret = _clk_register(dev, hw, clk);
1822 if (!ret) {
1823 devres_add(dev, clk);
1824 } else {
1825 devres_free(clk);
1826 clk = ERR_PTR(ret);
1827 }
1828
1829 return clk;
1830}
1831EXPORT_SYMBOL_GPL(devm_clk_register);
1832
1833static int devm_clk_match(struct device *dev, void *res, void *data)
1834{
1835 struct clk *c = res;
1836 if (WARN_ON(!c))
1837 return 0;
1838 return c == data;
1839}
1840
1841/**
1842 * devm_clk_unregister - resource managed clk_unregister()
1843 * @clk: clock to unregister
1844 *
1845 * Deallocate a clock allocated with devm_clk_register(). Normally
1846 * this function will not need to be called and the resource management
1847 * code will ensure that the resource is freed.
1848 */
1849void devm_clk_unregister(struct device *dev, struct clk *clk)
1850{
1851 WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk));
1852}
1853EXPORT_SYMBOL_GPL(devm_clk_unregister);
1854
Mike Turquetteb24764902012-03-15 23:11:19 -07001855/*** clk rate change notifiers ***/
1856
1857/**
1858 * clk_notifier_register - add a clk rate change notifier
1859 * @clk: struct clk * to watch
1860 * @nb: struct notifier_block * with callback info
1861 *
1862 * Request notification when clk's rate changes. This uses an SRCU
1863 * notifier because we want it to block and notifier unregistrations are
1864 * uncommon. The callbacks associated with the notifier must not
1865 * re-enter into the clk framework by calling any top-level clk APIs;
1866 * this will cause a nested prepare_lock mutex.
1867 *
1868 * Pre-change notifier callbacks will be passed the current, pre-change
1869 * rate of the clk via struct clk_notifier_data.old_rate. The new,
1870 * post-change rate of the clk is passed via struct
1871 * clk_notifier_data.new_rate.
1872 *
1873 * Post-change notifiers will pass the now-current, post-change rate of
1874 * the clk in both struct clk_notifier_data.old_rate and struct
1875 * clk_notifier_data.new_rate.
1876 *
1877 * Abort-change notifiers are effectively the opposite of pre-change
1878 * notifiers: the original pre-change clk rate is passed in via struct
1879 * clk_notifier_data.new_rate and the failed post-change rate is passed
1880 * in via struct clk_notifier_data.old_rate.
1881 *
1882 * clk_notifier_register() must be called from non-atomic context.
1883 * Returns -EINVAL if called with null arguments, -ENOMEM upon
1884 * allocation failure; otherwise, passes along the return value of
1885 * srcu_notifier_chain_register().
1886 */
1887int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
1888{
1889 struct clk_notifier *cn;
1890 int ret = -ENOMEM;
1891
1892 if (!clk || !nb)
1893 return -EINVAL;
1894
Mike Turquetteeab89f62013-03-28 13:59:01 -07001895 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001896
1897 /* search the list of notifiers for this clk */
1898 list_for_each_entry(cn, &clk_notifier_list, node)
1899 if (cn->clk == clk)
1900 break;
1901
1902 /* if clk wasn't in the notifier list, allocate new clk_notifier */
1903 if (cn->clk != clk) {
1904 cn = kzalloc(sizeof(struct clk_notifier), GFP_KERNEL);
1905 if (!cn)
1906 goto out;
1907
1908 cn->clk = clk;
1909 srcu_init_notifier_head(&cn->notifier_head);
1910
1911 list_add(&cn->node, &clk_notifier_list);
1912 }
1913
1914 ret = srcu_notifier_chain_register(&cn->notifier_head, nb);
1915
1916 clk->notifier_count++;
1917
1918out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001919 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001920
1921 return ret;
1922}
1923EXPORT_SYMBOL_GPL(clk_notifier_register);
1924
1925/**
1926 * clk_notifier_unregister - remove a clk rate change notifier
1927 * @clk: struct clk *
1928 * @nb: struct notifier_block * with callback info
1929 *
1930 * Request no further notification for changes to 'clk' and frees memory
1931 * allocated in clk_notifier_register.
1932 *
1933 * Returns -EINVAL if called with null arguments; otherwise, passes
1934 * along the return value of srcu_notifier_chain_unregister().
1935 */
1936int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
1937{
1938 struct clk_notifier *cn = NULL;
1939 int ret = -EINVAL;
1940
1941 if (!clk || !nb)
1942 return -EINVAL;
1943
Mike Turquetteeab89f62013-03-28 13:59:01 -07001944 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001945
1946 list_for_each_entry(cn, &clk_notifier_list, node)
1947 if (cn->clk == clk)
1948 break;
1949
1950 if (cn->clk == clk) {
1951 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb);
1952
1953 clk->notifier_count--;
1954
1955 /* XXX the notifier code should handle this better */
1956 if (!cn->notifier_head.head) {
1957 srcu_cleanup_notifier_head(&cn->notifier_head);
1958 kfree(cn);
1959 }
1960
1961 } else {
1962 ret = -ENOENT;
1963 }
1964
Mike Turquetteeab89f62013-03-28 13:59:01 -07001965 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001966
1967 return ret;
1968}
1969EXPORT_SYMBOL_GPL(clk_notifier_unregister);
Grant Likely766e6a42012-04-09 14:50:06 -05001970
1971#ifdef CONFIG_OF
1972/**
1973 * struct of_clk_provider - Clock provider registration structure
1974 * @link: Entry in global list of clock providers
1975 * @node: Pointer to device tree node of clock provider
1976 * @get: Get clock callback. Returns NULL or a struct clk for the
1977 * given clock specifier
1978 * @data: context pointer to be passed into @get callback
1979 */
1980struct of_clk_provider {
1981 struct list_head link;
1982
1983 struct device_node *node;
1984 struct clk *(*get)(struct of_phandle_args *clkspec, void *data);
1985 void *data;
1986};
1987
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05301988extern struct of_device_id __clk_of_table[];
1989
1990static const struct of_device_id __clk_of_table_sentinel
1991 __used __section(__clk_of_table_end);
1992
Grant Likely766e6a42012-04-09 14:50:06 -05001993static LIST_HEAD(of_clk_providers);
1994static DEFINE_MUTEX(of_clk_lock);
1995
1996struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
1997 void *data)
1998{
1999 return data;
2000}
2001EXPORT_SYMBOL_GPL(of_clk_src_simple_get);
2002
Shawn Guo494bfec2012-08-22 21:36:27 +08002003struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data)
2004{
2005 struct clk_onecell_data *clk_data = data;
2006 unsigned int idx = clkspec->args[0];
2007
2008 if (idx >= clk_data->clk_num) {
2009 pr_err("%s: invalid clock index %d\n", __func__, idx);
2010 return ERR_PTR(-EINVAL);
2011 }
2012
2013 return clk_data->clks[idx];
2014}
2015EXPORT_SYMBOL_GPL(of_clk_src_onecell_get);
2016
Grant Likely766e6a42012-04-09 14:50:06 -05002017/**
2018 * of_clk_add_provider() - Register a clock provider for a node
2019 * @np: Device node pointer associated with clock provider
2020 * @clk_src_get: callback for decoding clock
2021 * @data: context pointer for @clk_src_get callback.
2022 */
2023int of_clk_add_provider(struct device_node *np,
2024 struct clk *(*clk_src_get)(struct of_phandle_args *clkspec,
2025 void *data),
2026 void *data)
2027{
2028 struct of_clk_provider *cp;
2029
2030 cp = kzalloc(sizeof(struct of_clk_provider), GFP_KERNEL);
2031 if (!cp)
2032 return -ENOMEM;
2033
2034 cp->node = of_node_get(np);
2035 cp->data = data;
2036 cp->get = clk_src_get;
2037
2038 mutex_lock(&of_clk_lock);
2039 list_add(&cp->link, &of_clk_providers);
2040 mutex_unlock(&of_clk_lock);
2041 pr_debug("Added clock from %s\n", np->full_name);
2042
2043 return 0;
2044}
2045EXPORT_SYMBOL_GPL(of_clk_add_provider);
2046
2047/**
2048 * of_clk_del_provider() - Remove a previously registered clock provider
2049 * @np: Device node pointer associated with clock provider
2050 */
2051void of_clk_del_provider(struct device_node *np)
2052{
2053 struct of_clk_provider *cp;
2054
2055 mutex_lock(&of_clk_lock);
2056 list_for_each_entry(cp, &of_clk_providers, link) {
2057 if (cp->node == np) {
2058 list_del(&cp->link);
2059 of_node_put(cp->node);
2060 kfree(cp);
2061 break;
2062 }
2063 }
2064 mutex_unlock(&of_clk_lock);
2065}
2066EXPORT_SYMBOL_GPL(of_clk_del_provider);
2067
2068struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
2069{
2070 struct of_clk_provider *provider;
2071 struct clk *clk = ERR_PTR(-ENOENT);
2072
2073 /* Check if we have such a provider in our array */
2074 mutex_lock(&of_clk_lock);
2075 list_for_each_entry(provider, &of_clk_providers, link) {
2076 if (provider->node == clkspec->np)
2077 clk = provider->get(clkspec, provider->data);
2078 if (!IS_ERR(clk))
2079 break;
2080 }
2081 mutex_unlock(&of_clk_lock);
2082
2083 return clk;
2084}
2085
2086const char *of_clk_get_parent_name(struct device_node *np, int index)
2087{
2088 struct of_phandle_args clkspec;
2089 const char *clk_name;
2090 int rc;
2091
2092 if (index < 0)
2093 return NULL;
2094
2095 rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
2096 &clkspec);
2097 if (rc)
2098 return NULL;
2099
2100 if (of_property_read_string_index(clkspec.np, "clock-output-names",
2101 clkspec.args_count ? clkspec.args[0] : 0,
2102 &clk_name) < 0)
2103 clk_name = clkspec.np->name;
2104
2105 of_node_put(clkspec.np);
2106 return clk_name;
2107}
2108EXPORT_SYMBOL_GPL(of_clk_get_parent_name);
2109
2110/**
2111 * of_clk_init() - Scan and init clock providers from the DT
2112 * @matches: array of compatible values and init functions for providers.
2113 *
2114 * This function scans the device tree for matching clock providers and
2115 * calls their initialization functions
2116 */
2117void __init of_clk_init(const struct of_device_id *matches)
2118{
2119 struct device_node *np;
2120
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05302121 if (!matches)
2122 matches = __clk_of_table;
2123
Grant Likely766e6a42012-04-09 14:50:06 -05002124 for_each_matching_node(np, matches) {
2125 const struct of_device_id *match = of_match_node(matches, np);
2126 of_clk_init_cb_t clk_init_cb = match->data;
2127 clk_init_cb(np);
2128 }
2129}
2130#endif