blob: af0dbccb375d19423da4e6143845df3ac85b696d [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}
Saravana Kannand41d5802013-05-09 11:35:01 -0700537late_initcall_sync(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;
Mike Turquetteb24764902012-03-15 23:11:19 -07001380
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001381 /*
1382 * Migrate prepare state between parents and prevent race with
1383 * clk_enable().
1384 *
1385 * If the clock is not prepared, then a race with
1386 * clk_enable/disable() is impossible since we already have the
1387 * prepare lock (future calls to clk_enable() need to be preceded by
1388 * a clk_prepare()).
1389 *
1390 * If the clock is prepared, migrate the prepared state to the new
1391 * parent and also protect against a race with clk_enable() by
1392 * forcing the clock and the new parent on. This ensures that all
1393 * future calls to clk_enable() are practically NOPs with respect to
1394 * hardware and software states.
1395 *
1396 * See also: Comment for clk_set_parent() below.
1397 */
1398 if (clk->prepare_count) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001399 __clk_prepare(parent);
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001400 clk_enable(parent);
1401 clk_enable(clk);
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001402 }
1403
1404 /* update the clk tree topology */
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001405 flags = clk_enable_lock();
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001406 clk_reparent(clk, parent);
Mike Turquetteeab89f62013-03-28 13:59:01 -07001407 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -07001408
1409 /* change clock input source */
Ulf Hansson031dcc92013-04-02 23:09:38 +02001410 if (parent && clk->ops->set_parent)
1411 ret = clk->ops->set_parent(clk->hw, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001412
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001413 if (ret) {
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001414 flags = clk_enable_lock();
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001415 clk_reparent(clk, old_parent);
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001416 clk_enable_unlock(flags);
1417
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001418 if (clk->prepare_count) {
1419 clk_disable(clk);
1420 clk_disable(parent);
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001421 __clk_unprepare(parent);
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001422 }
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001423 return ret;
1424 }
1425
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001426 /*
1427 * Finish the migration of prepare state and undo the changes done
1428 * for preventing a race with clk_enable().
1429 */
1430 if (clk->prepare_count) {
1431 clk_disable(clk);
1432 clk_disable(old_parent);
Mike Turquetteb24764902012-03-15 23:11:19 -07001433 __clk_unprepare(old_parent);
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001434 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001435
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001436 /* update debugfs with new clk tree topology */
1437 clk_debug_reparent(clk, parent);
1438 return 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001439}
1440
1441/**
1442 * clk_set_parent - switch the parent of a mux clk
1443 * @clk: the mux clk whose input we are switching
1444 * @parent: the new input to clk
1445 *
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001446 * Re-parent clk to use parent as its new input source. If clk is in
1447 * prepared state, the clk will get enabled for the duration of this call. If
1448 * that's not acceptable for a specific clk (Eg: the consumer can't handle
1449 * that, the reparenting is glitchy in hardware, etc), use the
1450 * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
1451 *
1452 * After successfully changing clk's parent clk_set_parent will update the
1453 * clk topology, sysfs topology and propagate rate recalculation via
1454 * __clk_recalc_rates.
1455 *
1456 * Returns 0 on success, -EERROR otherwise.
Mike Turquetteb24764902012-03-15 23:11:19 -07001457 */
1458int clk_set_parent(struct clk *clk, struct clk *parent)
1459{
1460 int ret = 0;
Ulf Hansson031dcc92013-04-02 23:09:38 +02001461 u8 p_index = 0;
1462 unsigned long p_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001463
1464 if (!clk || !clk->ops)
1465 return -EINVAL;
1466
Ulf Hansson031dcc92013-04-02 23:09:38 +02001467 /* verify ops for for multi-parent clks */
1468 if ((clk->num_parents > 1) && (!clk->ops->set_parent))
Mike Turquetteb24764902012-03-15 23:11:19 -07001469 return -ENOSYS;
1470
1471 /* prevent racing with updates to the clock topology */
Mike Turquetteeab89f62013-03-28 13:59:01 -07001472 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001473
1474 if (clk->parent == parent)
1475 goto out;
1476
Ulf Hansson031dcc92013-04-02 23:09:38 +02001477 /* check that we are allowed to re-parent if the clock is in use */
1478 if ((clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) {
1479 ret = -EBUSY;
1480 goto out;
1481 }
1482
1483 /* try finding the new parent index */
1484 if (parent) {
1485 p_index = clk_fetch_parent_index(clk, parent);
1486 p_rate = parent->rate;
1487 if (p_index == clk->num_parents) {
1488 pr_debug("%s: clk %s can not be parent of clk %s\n",
1489 __func__, parent->name, clk->name);
1490 ret = -EINVAL;
1491 goto out;
1492 }
1493 }
1494
Mike Turquetteb24764902012-03-15 23:11:19 -07001495 /* propagate PRE_RATE_CHANGE notifications */
1496 if (clk->notifier_count)
Ulf Hansson031dcc92013-04-02 23:09:38 +02001497 ret = __clk_speculate_rates(clk, p_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001498
1499 /* abort if a driver objects */
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001500 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001501 goto out;
1502
Ulf Hansson031dcc92013-04-02 23:09:38 +02001503 /* do the re-parent */
1504 ret = __clk_set_parent(clk, parent, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001505
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001506 /* propagate rate recalculation accordingly */
1507 if (ret)
Mike Turquetteb24764902012-03-15 23:11:19 -07001508 __clk_recalc_rates(clk, ABORT_RATE_CHANGE);
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001509 else
1510 __clk_recalc_rates(clk, POST_RATE_CHANGE);
Mike Turquetteb24764902012-03-15 23:11:19 -07001511
1512out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001513 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001514
1515 return ret;
1516}
1517EXPORT_SYMBOL_GPL(clk_set_parent);
1518
1519/**
1520 * __clk_init - initialize the data structures in a struct clk
1521 * @dev: device initializing this clk, placeholder for now
1522 * @clk: clk being initialized
1523 *
1524 * Initializes the lists in struct clk, queries the hardware for the
1525 * parent and rate and sets them both.
Mike Turquetteb24764902012-03-15 23:11:19 -07001526 */
Mike Turquetted1302a32012-03-29 14:30:40 -07001527int __clk_init(struct device *dev, struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -07001528{
Mike Turquetted1302a32012-03-29 14:30:40 -07001529 int i, ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001530 struct clk *orphan;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001531 struct hlist_node *tmp2;
Mike Turquetteb24764902012-03-15 23:11:19 -07001532
1533 if (!clk)
Mike Turquetted1302a32012-03-29 14:30:40 -07001534 return -EINVAL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001535
Mike Turquetteeab89f62013-03-28 13:59:01 -07001536 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001537
1538 /* check to see if a clock with this name is already registered */
Mike Turquetted1302a32012-03-29 14:30:40 -07001539 if (__clk_lookup(clk->name)) {
1540 pr_debug("%s: clk %s already initialized\n",
1541 __func__, clk->name);
1542 ret = -EEXIST;
Mike Turquetteb24764902012-03-15 23:11:19 -07001543 goto out;
Mike Turquetted1302a32012-03-29 14:30:40 -07001544 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001545
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001546 /* check that clk_ops are sane. See Documentation/clk.txt */
1547 if (clk->ops->set_rate &&
1548 !(clk->ops->round_rate && clk->ops->recalc_rate)) {
1549 pr_warning("%s: %s must implement .round_rate & .recalc_rate\n",
1550 __func__, clk->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07001551 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001552 goto out;
1553 }
1554
1555 if (clk->ops->set_parent && !clk->ops->get_parent) {
1556 pr_warning("%s: %s must implement .get_parent & .set_parent\n",
1557 __func__, clk->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07001558 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001559 goto out;
1560 }
1561
Mike Turquetteb24764902012-03-15 23:11:19 -07001562 /* throw a WARN if any entries in parent_names are NULL */
1563 for (i = 0; i < clk->num_parents; i++)
1564 WARN(!clk->parent_names[i],
1565 "%s: invalid NULL in %s's .parent_names\n",
1566 __func__, clk->name);
1567
1568 /*
1569 * Allocate an array of struct clk *'s to avoid unnecessary string
1570 * look-ups of clk's possible parents. This can fail for clocks passed
1571 * in to clk_init during early boot; thus any access to clk->parents[]
1572 * must always check for a NULL pointer and try to populate it if
1573 * necessary.
1574 *
1575 * If clk->parents is not NULL we skip this entire block. This allows
1576 * for clock drivers to statically initialize clk->parents.
1577 */
Rajendra Nayak9ca1c5a2012-06-06 14:41:30 +05301578 if (clk->num_parents > 1 && !clk->parents) {
1579 clk->parents = kzalloc((sizeof(struct clk*) * clk->num_parents),
Mike Turquetteb24764902012-03-15 23:11:19 -07001580 GFP_KERNEL);
1581 /*
1582 * __clk_lookup returns NULL for parents that have not been
1583 * clk_init'd; thus any access to clk->parents[] must check
1584 * for a NULL pointer. We can always perform lazy lookups for
1585 * missing parents later on.
1586 */
1587 if (clk->parents)
1588 for (i = 0; i < clk->num_parents; i++)
1589 clk->parents[i] =
1590 __clk_lookup(clk->parent_names[i]);
1591 }
1592
1593 clk->parent = __clk_init_parent(clk);
1594
1595 /*
1596 * Populate clk->parent if parent has already been __clk_init'd. If
1597 * parent has not yet been __clk_init'd then place clk in the orphan
1598 * list. If clk has set the CLK_IS_ROOT flag then place it in the root
1599 * clk list.
1600 *
1601 * Every time a new clk is clk_init'd then we walk the list of orphan
1602 * clocks and re-parent any that are children of the clock currently
1603 * being clk_init'd.
1604 */
1605 if (clk->parent)
1606 hlist_add_head(&clk->child_node,
1607 &clk->parent->children);
1608 else if (clk->flags & CLK_IS_ROOT)
1609 hlist_add_head(&clk->child_node, &clk_root_list);
1610 else
1611 hlist_add_head(&clk->child_node, &clk_orphan_list);
1612
1613 /*
1614 * Set clk's rate. The preferred method is to use .recalc_rate. For
1615 * simple clocks and lazy developers the default fallback is to use the
1616 * parent's rate. If a clock doesn't have a parent (or is orphaned)
1617 * then rate is set to zero.
1618 */
1619 if (clk->ops->recalc_rate)
1620 clk->rate = clk->ops->recalc_rate(clk->hw,
1621 __clk_get_rate(clk->parent));
1622 else if (clk->parent)
1623 clk->rate = clk->parent->rate;
1624 else
1625 clk->rate = 0;
1626
1627 /*
1628 * walk the list of orphan clocks and reparent any that are children of
1629 * this clock
1630 */
Sasha Levinb67bfe02013-02-27 17:06:00 -08001631 hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
Martin Fuzzey1f61e5f2012-11-22 20:15:05 +01001632 if (orphan->ops->get_parent) {
1633 i = orphan->ops->get_parent(orphan->hw);
1634 if (!strcmp(clk->name, orphan->parent_names[i]))
1635 __clk_reparent(orphan, clk);
1636 continue;
1637 }
1638
Mike Turquetteb24764902012-03-15 23:11:19 -07001639 for (i = 0; i < orphan->num_parents; i++)
1640 if (!strcmp(clk->name, orphan->parent_names[i])) {
1641 __clk_reparent(orphan, clk);
1642 break;
1643 }
Martin Fuzzey1f61e5f2012-11-22 20:15:05 +01001644 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001645
1646 /*
1647 * optional platform-specific magic
1648 *
1649 * The .init callback is not used by any of the basic clock types, but
1650 * exists for weird hardware that must perform initialization magic.
1651 * Please consider other ways of solving initialization problems before
1652 * using this callback, as it's use is discouraged.
1653 */
1654 if (clk->ops->init)
1655 clk->ops->init(clk->hw);
1656
1657 clk_debug_register(clk);
1658
1659out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001660 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001661
Mike Turquetted1302a32012-03-29 14:30:40 -07001662 return ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07001663}
1664
1665/**
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001666 * __clk_register - register a clock and return a cookie.
1667 *
1668 * Same as clk_register, except that the .clk field inside hw shall point to a
1669 * preallocated (generally statically allocated) struct clk. None of the fields
1670 * of the struct clk need to be initialized.
1671 *
1672 * The data pointed to by .init and .clk field shall NOT be marked as init
1673 * data.
1674 *
1675 * __clk_register is only exposed via clk-private.h and is intended for use with
1676 * very large numbers of clocks that need to be statically initialized. It is
1677 * a layering violation to include clk-private.h from any code which implements
1678 * a clock's .ops; as such any statically initialized clock data MUST be in a
1679 * separate C file from the logic that implements it's operations. Returns 0
1680 * on success, otherwise an error code.
1681 */
1682struct clk *__clk_register(struct device *dev, struct clk_hw *hw)
1683{
1684 int ret;
1685 struct clk *clk;
1686
1687 clk = hw->clk;
1688 clk->name = hw->init->name;
1689 clk->ops = hw->init->ops;
1690 clk->hw = hw;
1691 clk->flags = hw->init->flags;
1692 clk->parent_names = hw->init->parent_names;
1693 clk->num_parents = hw->init->num_parents;
1694
1695 ret = __clk_init(dev, clk);
1696 if (ret)
1697 return ERR_PTR(ret);
1698
1699 return clk;
1700}
1701EXPORT_SYMBOL_GPL(__clk_register);
1702
Stephen Boyd46c87732012-09-24 13:38:04 -07001703static int _clk_register(struct device *dev, struct clk_hw *hw, struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -07001704{
Mike Turquetted1302a32012-03-29 14:30:40 -07001705 int i, ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07001706
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001707 clk->name = kstrdup(hw->init->name, GFP_KERNEL);
1708 if (!clk->name) {
1709 pr_err("%s: could not allocate clk->name\n", __func__);
1710 ret = -ENOMEM;
1711 goto fail_name;
1712 }
1713 clk->ops = hw->init->ops;
Mike Turquetteb24764902012-03-15 23:11:19 -07001714 clk->hw = hw;
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001715 clk->flags = hw->init->flags;
1716 clk->num_parents = hw->init->num_parents;
Mike Turquetteb24764902012-03-15 23:11:19 -07001717 hw->clk = clk;
1718
Mike Turquetted1302a32012-03-29 14:30:40 -07001719 /* allocate local copy in case parent_names is __initdata */
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001720 clk->parent_names = kzalloc((sizeof(char*) * clk->num_parents),
Mike Turquetted1302a32012-03-29 14:30:40 -07001721 GFP_KERNEL);
Mike Turquetteb24764902012-03-15 23:11:19 -07001722
Mike Turquetted1302a32012-03-29 14:30:40 -07001723 if (!clk->parent_names) {
1724 pr_err("%s: could not allocate clk->parent_names\n", __func__);
1725 ret = -ENOMEM;
1726 goto fail_parent_names;
1727 }
1728
1729
1730 /* copy each string name in case parent_names is __initdata */
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001731 for (i = 0; i < clk->num_parents; i++) {
1732 clk->parent_names[i] = kstrdup(hw->init->parent_names[i],
1733 GFP_KERNEL);
Mike Turquetted1302a32012-03-29 14:30:40 -07001734 if (!clk->parent_names[i]) {
1735 pr_err("%s: could not copy parent_names\n", __func__);
1736 ret = -ENOMEM;
1737 goto fail_parent_names_copy;
1738 }
1739 }
1740
1741 ret = __clk_init(dev, clk);
1742 if (!ret)
Stephen Boyd46c87732012-09-24 13:38:04 -07001743 return 0;
Mike Turquetted1302a32012-03-29 14:30:40 -07001744
1745fail_parent_names_copy:
1746 while (--i >= 0)
1747 kfree(clk->parent_names[i]);
1748 kfree(clk->parent_names);
1749fail_parent_names:
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001750 kfree(clk->name);
1751fail_name:
Stephen Boyd46c87732012-09-24 13:38:04 -07001752 return ret;
1753}
1754
1755/**
1756 * clk_register - allocate a new clock, register it and return an opaque cookie
1757 * @dev: device that is registering this clock
1758 * @hw: link to hardware-specific clock data
1759 *
1760 * clk_register is the primary interface for populating the clock tree with new
1761 * clock nodes. It returns a pointer to the newly allocated struct clk which
1762 * cannot be dereferenced by driver code but may be used in conjuction with the
1763 * rest of the clock API. In the event of an error clk_register will return an
1764 * error code; drivers must test for an error code after calling clk_register.
1765 */
1766struct clk *clk_register(struct device *dev, struct clk_hw *hw)
1767{
1768 int ret;
1769 struct clk *clk;
1770
1771 clk = kzalloc(sizeof(*clk), GFP_KERNEL);
1772 if (!clk) {
1773 pr_err("%s: could not allocate clk\n", __func__);
1774 ret = -ENOMEM;
1775 goto fail_out;
1776 }
1777
1778 ret = _clk_register(dev, hw, clk);
1779 if (!ret)
1780 return clk;
1781
Mike Turquetted1302a32012-03-29 14:30:40 -07001782 kfree(clk);
1783fail_out:
1784 return ERR_PTR(ret);
Mike Turquetteb24764902012-03-15 23:11:19 -07001785}
1786EXPORT_SYMBOL_GPL(clk_register);
1787
Mark Brown1df5c932012-04-18 09:07:12 +01001788/**
1789 * clk_unregister - unregister a currently registered clock
1790 * @clk: clock to unregister
1791 *
1792 * Currently unimplemented.
1793 */
1794void clk_unregister(struct clk *clk) {}
1795EXPORT_SYMBOL_GPL(clk_unregister);
1796
Stephen Boyd46c87732012-09-24 13:38:04 -07001797static void devm_clk_release(struct device *dev, void *res)
1798{
1799 clk_unregister(res);
1800}
1801
1802/**
1803 * devm_clk_register - resource managed clk_register()
1804 * @dev: device that is registering this clock
1805 * @hw: link to hardware-specific clock data
1806 *
1807 * Managed clk_register(). Clocks returned from this function are
1808 * automatically clk_unregister()ed on driver detach. See clk_register() for
1809 * more information.
1810 */
1811struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw)
1812{
1813 struct clk *clk;
1814 int ret;
1815
1816 clk = devres_alloc(devm_clk_release, sizeof(*clk), GFP_KERNEL);
1817 if (!clk)
1818 return ERR_PTR(-ENOMEM);
1819
1820 ret = _clk_register(dev, hw, clk);
1821 if (!ret) {
1822 devres_add(dev, clk);
1823 } else {
1824 devres_free(clk);
1825 clk = ERR_PTR(ret);
1826 }
1827
1828 return clk;
1829}
1830EXPORT_SYMBOL_GPL(devm_clk_register);
1831
1832static int devm_clk_match(struct device *dev, void *res, void *data)
1833{
1834 struct clk *c = res;
1835 if (WARN_ON(!c))
1836 return 0;
1837 return c == data;
1838}
1839
1840/**
1841 * devm_clk_unregister - resource managed clk_unregister()
1842 * @clk: clock to unregister
1843 *
1844 * Deallocate a clock allocated with devm_clk_register(). Normally
1845 * this function will not need to be called and the resource management
1846 * code will ensure that the resource is freed.
1847 */
1848void devm_clk_unregister(struct device *dev, struct clk *clk)
1849{
1850 WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk));
1851}
1852EXPORT_SYMBOL_GPL(devm_clk_unregister);
1853
Mike Turquetteb24764902012-03-15 23:11:19 -07001854/*** clk rate change notifiers ***/
1855
1856/**
1857 * clk_notifier_register - add a clk rate change notifier
1858 * @clk: struct clk * to watch
1859 * @nb: struct notifier_block * with callback info
1860 *
1861 * Request notification when clk's rate changes. This uses an SRCU
1862 * notifier because we want it to block and notifier unregistrations are
1863 * uncommon. The callbacks associated with the notifier must not
1864 * re-enter into the clk framework by calling any top-level clk APIs;
1865 * this will cause a nested prepare_lock mutex.
1866 *
1867 * Pre-change notifier callbacks will be passed the current, pre-change
1868 * rate of the clk via struct clk_notifier_data.old_rate. The new,
1869 * post-change rate of the clk is passed via struct
1870 * clk_notifier_data.new_rate.
1871 *
1872 * Post-change notifiers will pass the now-current, post-change rate of
1873 * the clk in both struct clk_notifier_data.old_rate and struct
1874 * clk_notifier_data.new_rate.
1875 *
1876 * Abort-change notifiers are effectively the opposite of pre-change
1877 * notifiers: the original pre-change clk rate is passed in via struct
1878 * clk_notifier_data.new_rate and the failed post-change rate is passed
1879 * in via struct clk_notifier_data.old_rate.
1880 *
1881 * clk_notifier_register() must be called from non-atomic context.
1882 * Returns -EINVAL if called with null arguments, -ENOMEM upon
1883 * allocation failure; otherwise, passes along the return value of
1884 * srcu_notifier_chain_register().
1885 */
1886int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
1887{
1888 struct clk_notifier *cn;
1889 int ret = -ENOMEM;
1890
1891 if (!clk || !nb)
1892 return -EINVAL;
1893
Mike Turquetteeab89f62013-03-28 13:59:01 -07001894 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001895
1896 /* search the list of notifiers for this clk */
1897 list_for_each_entry(cn, &clk_notifier_list, node)
1898 if (cn->clk == clk)
1899 break;
1900
1901 /* if clk wasn't in the notifier list, allocate new clk_notifier */
1902 if (cn->clk != clk) {
1903 cn = kzalloc(sizeof(struct clk_notifier), GFP_KERNEL);
1904 if (!cn)
1905 goto out;
1906
1907 cn->clk = clk;
1908 srcu_init_notifier_head(&cn->notifier_head);
1909
1910 list_add(&cn->node, &clk_notifier_list);
1911 }
1912
1913 ret = srcu_notifier_chain_register(&cn->notifier_head, nb);
1914
1915 clk->notifier_count++;
1916
1917out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001918 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001919
1920 return ret;
1921}
1922EXPORT_SYMBOL_GPL(clk_notifier_register);
1923
1924/**
1925 * clk_notifier_unregister - remove a clk rate change notifier
1926 * @clk: struct clk *
1927 * @nb: struct notifier_block * with callback info
1928 *
1929 * Request no further notification for changes to 'clk' and frees memory
1930 * allocated in clk_notifier_register.
1931 *
1932 * Returns -EINVAL if called with null arguments; otherwise, passes
1933 * along the return value of srcu_notifier_chain_unregister().
1934 */
1935int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
1936{
1937 struct clk_notifier *cn = NULL;
1938 int ret = -EINVAL;
1939
1940 if (!clk || !nb)
1941 return -EINVAL;
1942
Mike Turquetteeab89f62013-03-28 13:59:01 -07001943 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001944
1945 list_for_each_entry(cn, &clk_notifier_list, node)
1946 if (cn->clk == clk)
1947 break;
1948
1949 if (cn->clk == clk) {
1950 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb);
1951
1952 clk->notifier_count--;
1953
1954 /* XXX the notifier code should handle this better */
1955 if (!cn->notifier_head.head) {
1956 srcu_cleanup_notifier_head(&cn->notifier_head);
1957 kfree(cn);
1958 }
1959
1960 } else {
1961 ret = -ENOENT;
1962 }
1963
Mike Turquetteeab89f62013-03-28 13:59:01 -07001964 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001965
1966 return ret;
1967}
1968EXPORT_SYMBOL_GPL(clk_notifier_unregister);
Grant Likely766e6a42012-04-09 14:50:06 -05001969
1970#ifdef CONFIG_OF
1971/**
1972 * struct of_clk_provider - Clock provider registration structure
1973 * @link: Entry in global list of clock providers
1974 * @node: Pointer to device tree node of clock provider
1975 * @get: Get clock callback. Returns NULL or a struct clk for the
1976 * given clock specifier
1977 * @data: context pointer to be passed into @get callback
1978 */
1979struct of_clk_provider {
1980 struct list_head link;
1981
1982 struct device_node *node;
1983 struct clk *(*get)(struct of_phandle_args *clkspec, void *data);
1984 void *data;
1985};
1986
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05301987extern struct of_device_id __clk_of_table[];
1988
1989static const struct of_device_id __clk_of_table_sentinel
1990 __used __section(__clk_of_table_end);
1991
Grant Likely766e6a42012-04-09 14:50:06 -05001992static LIST_HEAD(of_clk_providers);
1993static DEFINE_MUTEX(of_clk_lock);
1994
1995struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
1996 void *data)
1997{
1998 return data;
1999}
2000EXPORT_SYMBOL_GPL(of_clk_src_simple_get);
2001
Shawn Guo494bfec2012-08-22 21:36:27 +08002002struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data)
2003{
2004 struct clk_onecell_data *clk_data = data;
2005 unsigned int idx = clkspec->args[0];
2006
2007 if (idx >= clk_data->clk_num) {
2008 pr_err("%s: invalid clock index %d\n", __func__, idx);
2009 return ERR_PTR(-EINVAL);
2010 }
2011
2012 return clk_data->clks[idx];
2013}
2014EXPORT_SYMBOL_GPL(of_clk_src_onecell_get);
2015
Grant Likely766e6a42012-04-09 14:50:06 -05002016/**
2017 * of_clk_add_provider() - Register a clock provider for a node
2018 * @np: Device node pointer associated with clock provider
2019 * @clk_src_get: callback for decoding clock
2020 * @data: context pointer for @clk_src_get callback.
2021 */
2022int of_clk_add_provider(struct device_node *np,
2023 struct clk *(*clk_src_get)(struct of_phandle_args *clkspec,
2024 void *data),
2025 void *data)
2026{
2027 struct of_clk_provider *cp;
2028
2029 cp = kzalloc(sizeof(struct of_clk_provider), GFP_KERNEL);
2030 if (!cp)
2031 return -ENOMEM;
2032
2033 cp->node = of_node_get(np);
2034 cp->data = data;
2035 cp->get = clk_src_get;
2036
2037 mutex_lock(&of_clk_lock);
2038 list_add(&cp->link, &of_clk_providers);
2039 mutex_unlock(&of_clk_lock);
2040 pr_debug("Added clock from %s\n", np->full_name);
2041
2042 return 0;
2043}
2044EXPORT_SYMBOL_GPL(of_clk_add_provider);
2045
2046/**
2047 * of_clk_del_provider() - Remove a previously registered clock provider
2048 * @np: Device node pointer associated with clock provider
2049 */
2050void of_clk_del_provider(struct device_node *np)
2051{
2052 struct of_clk_provider *cp;
2053
2054 mutex_lock(&of_clk_lock);
2055 list_for_each_entry(cp, &of_clk_providers, link) {
2056 if (cp->node == np) {
2057 list_del(&cp->link);
2058 of_node_put(cp->node);
2059 kfree(cp);
2060 break;
2061 }
2062 }
2063 mutex_unlock(&of_clk_lock);
2064}
2065EXPORT_SYMBOL_GPL(of_clk_del_provider);
2066
2067struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
2068{
2069 struct of_clk_provider *provider;
2070 struct clk *clk = ERR_PTR(-ENOENT);
2071
2072 /* Check if we have such a provider in our array */
2073 mutex_lock(&of_clk_lock);
2074 list_for_each_entry(provider, &of_clk_providers, link) {
2075 if (provider->node == clkspec->np)
2076 clk = provider->get(clkspec, provider->data);
2077 if (!IS_ERR(clk))
2078 break;
2079 }
2080 mutex_unlock(&of_clk_lock);
2081
2082 return clk;
2083}
2084
2085const char *of_clk_get_parent_name(struct device_node *np, int index)
2086{
2087 struct of_phandle_args clkspec;
2088 const char *clk_name;
2089 int rc;
2090
2091 if (index < 0)
2092 return NULL;
2093
2094 rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
2095 &clkspec);
2096 if (rc)
2097 return NULL;
2098
2099 if (of_property_read_string_index(clkspec.np, "clock-output-names",
2100 clkspec.args_count ? clkspec.args[0] : 0,
2101 &clk_name) < 0)
2102 clk_name = clkspec.np->name;
2103
2104 of_node_put(clkspec.np);
2105 return clk_name;
2106}
2107EXPORT_SYMBOL_GPL(of_clk_get_parent_name);
2108
2109/**
2110 * of_clk_init() - Scan and init clock providers from the DT
2111 * @matches: array of compatible values and init functions for providers.
2112 *
2113 * This function scans the device tree for matching clock providers and
2114 * calls their initialization functions
2115 */
2116void __init of_clk_init(const struct of_device_id *matches)
2117{
2118 struct device_node *np;
2119
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05302120 if (!matches)
2121 matches = __clk_of_table;
2122
Grant Likely766e6a42012-04-09 14:50:06 -05002123 for_each_matching_node(np, matches) {
2124 const struct of_device_id *match = of_match_node(matches, np);
2125 of_clk_init_cb_t clk_init_cb = match->data;
2126 clk_init_cb(np);
2127 }
2128}
2129#endif