blob: ea2ca9ff267739a2a646d45f7c4140cba41cba31 [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
Sylwester Nawrockid6782c22013-08-23 17:03:43 +020024#include "clk.h"
25
Mike Turquetteb24764902012-03-15 23:11:19 -070026static DEFINE_SPINLOCK(enable_lock);
27static DEFINE_MUTEX(prepare_lock);
28
Mike Turquette533ddeb2013-03-28 13:59:02 -070029static struct task_struct *prepare_owner;
30static struct task_struct *enable_owner;
31
32static int prepare_refcnt;
33static int enable_refcnt;
34
Mike Turquetteb24764902012-03-15 23:11:19 -070035static HLIST_HEAD(clk_root_list);
36static HLIST_HEAD(clk_orphan_list);
37static LIST_HEAD(clk_notifier_list);
38
Mike Turquetteeab89f62013-03-28 13:59:01 -070039/*** locking ***/
40static void clk_prepare_lock(void)
41{
Mike Turquette533ddeb2013-03-28 13:59:02 -070042 if (!mutex_trylock(&prepare_lock)) {
43 if (prepare_owner == current) {
44 prepare_refcnt++;
45 return;
46 }
47 mutex_lock(&prepare_lock);
48 }
49 WARN_ON_ONCE(prepare_owner != NULL);
50 WARN_ON_ONCE(prepare_refcnt != 0);
51 prepare_owner = current;
52 prepare_refcnt = 1;
Mike Turquetteeab89f62013-03-28 13:59:01 -070053}
54
55static void clk_prepare_unlock(void)
56{
Mike Turquette533ddeb2013-03-28 13:59:02 -070057 WARN_ON_ONCE(prepare_owner != current);
58 WARN_ON_ONCE(prepare_refcnt == 0);
59
60 if (--prepare_refcnt)
61 return;
62 prepare_owner = NULL;
Mike Turquetteeab89f62013-03-28 13:59:01 -070063 mutex_unlock(&prepare_lock);
64}
65
66static unsigned long clk_enable_lock(void)
67{
68 unsigned long flags;
Mike Turquette533ddeb2013-03-28 13:59:02 -070069
70 if (!spin_trylock_irqsave(&enable_lock, flags)) {
71 if (enable_owner == current) {
72 enable_refcnt++;
73 return flags;
74 }
75 spin_lock_irqsave(&enable_lock, flags);
76 }
77 WARN_ON_ONCE(enable_owner != NULL);
78 WARN_ON_ONCE(enable_refcnt != 0);
79 enable_owner = current;
80 enable_refcnt = 1;
Mike Turquetteeab89f62013-03-28 13:59:01 -070081 return flags;
82}
83
84static void clk_enable_unlock(unsigned long flags)
85{
Mike Turquette533ddeb2013-03-28 13:59:02 -070086 WARN_ON_ONCE(enable_owner != current);
87 WARN_ON_ONCE(enable_refcnt == 0);
88
89 if (--enable_refcnt)
90 return;
91 enable_owner = NULL;
Mike Turquetteeab89f62013-03-28 13:59:01 -070092 spin_unlock_irqrestore(&enable_lock, flags);
93}
94
Mike Turquetteb24764902012-03-15 23:11:19 -070095/*** debugfs support ***/
96
Mike Turquetteea72dc22013-12-18 21:38:52 -080097#ifdef CONFIG_DEBUG_FS
Mike Turquetteb24764902012-03-15 23:11:19 -070098#include <linux/debugfs.h>
99
100static struct dentry *rootdir;
101static struct dentry *orphandir;
102static int inited = 0;
103
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530104static void clk_summary_show_one(struct seq_file *s, struct clk *c, int level)
105{
106 if (!c)
107 return;
108
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100109 seq_printf(s, "%*s%-*s %-11d %-12d %-10lu %-11lu",
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530110 level * 3 + 1, "",
111 30 - level * 3, c->name,
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100112 c->enable_count, c->prepare_count, clk_get_rate(c),
113 clk_get_accuracy(c));
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530114 seq_printf(s, "\n");
115}
116
117static void clk_summary_show_subtree(struct seq_file *s, struct clk *c,
118 int level)
119{
120 struct clk *child;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530121
122 if (!c)
123 return;
124
125 clk_summary_show_one(s, c, level);
126
Sasha Levinb67bfe02013-02-27 17:06:00 -0800127 hlist_for_each_entry(child, &c->children, child_node)
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530128 clk_summary_show_subtree(s, child, level + 1);
129}
130
131static int clk_summary_show(struct seq_file *s, void *data)
132{
133 struct clk *c;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530134
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100135 seq_printf(s, " clock enable_cnt prepare_cnt rate accuracy\n");
136 seq_printf(s, "---------------------------------------------------------------------------------\n");
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530137
Mike Turquetteeab89f62013-03-28 13:59:01 -0700138 clk_prepare_lock();
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530139
Sasha Levinb67bfe02013-02-27 17:06:00 -0800140 hlist_for_each_entry(c, &clk_root_list, child_node)
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530141 clk_summary_show_subtree(s, c, 0);
142
Sasha Levinb67bfe02013-02-27 17:06:00 -0800143 hlist_for_each_entry(c, &clk_orphan_list, child_node)
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530144 clk_summary_show_subtree(s, c, 0);
145
Mike Turquetteeab89f62013-03-28 13:59:01 -0700146 clk_prepare_unlock();
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530147
148 return 0;
149}
150
151
152static int clk_summary_open(struct inode *inode, struct file *file)
153{
154 return single_open(file, clk_summary_show, inode->i_private);
155}
156
157static const struct file_operations clk_summary_fops = {
158 .open = clk_summary_open,
159 .read = seq_read,
160 .llseek = seq_lseek,
161 .release = single_release,
162};
163
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530164static void clk_dump_one(struct seq_file *s, struct clk *c, int level)
165{
166 if (!c)
167 return;
168
169 seq_printf(s, "\"%s\": { ", c->name);
170 seq_printf(s, "\"enable_count\": %d,", c->enable_count);
171 seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
Peter De Schrijver670decd2013-06-05 18:06:35 +0300172 seq_printf(s, "\"rate\": %lu", clk_get_rate(c));
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100173 seq_printf(s, "\"accuracy\": %lu", clk_get_accuracy(c));
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530174}
175
176static void clk_dump_subtree(struct seq_file *s, struct clk *c, int level)
177{
178 struct clk *child;
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530179
180 if (!c)
181 return;
182
183 clk_dump_one(s, c, level);
184
Sasha Levinb67bfe02013-02-27 17:06:00 -0800185 hlist_for_each_entry(child, &c->children, child_node) {
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530186 seq_printf(s, ",");
187 clk_dump_subtree(s, child, level + 1);
188 }
189
190 seq_printf(s, "}");
191}
192
193static int clk_dump(struct seq_file *s, void *data)
194{
195 struct clk *c;
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530196 bool first_node = true;
197
198 seq_printf(s, "{");
199
Mike Turquetteeab89f62013-03-28 13:59:01 -0700200 clk_prepare_lock();
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530201
Sasha Levinb67bfe02013-02-27 17:06:00 -0800202 hlist_for_each_entry(c, &clk_root_list, child_node) {
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530203 if (!first_node)
204 seq_printf(s, ",");
205 first_node = false;
206 clk_dump_subtree(s, c, 0);
207 }
208
Sasha Levinb67bfe02013-02-27 17:06:00 -0800209 hlist_for_each_entry(c, &clk_orphan_list, child_node) {
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530210 seq_printf(s, ",");
211 clk_dump_subtree(s, c, 0);
212 }
213
Mike Turquetteeab89f62013-03-28 13:59:01 -0700214 clk_prepare_unlock();
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530215
216 seq_printf(s, "}");
217 return 0;
218}
219
220
221static int clk_dump_open(struct inode *inode, struct file *file)
222{
223 return single_open(file, clk_dump, inode->i_private);
224}
225
226static const struct file_operations clk_dump_fops = {
227 .open = clk_dump_open,
228 .read = seq_read,
229 .llseek = seq_lseek,
230 .release = single_release,
231};
232
Mike Turquetteb24764902012-03-15 23:11:19 -0700233/* caller must hold prepare_lock */
234static int clk_debug_create_one(struct clk *clk, struct dentry *pdentry)
235{
236 struct dentry *d;
237 int ret = -ENOMEM;
238
239 if (!clk || !pdentry) {
240 ret = -EINVAL;
241 goto out;
242 }
243
244 d = debugfs_create_dir(clk->name, pdentry);
245 if (!d)
246 goto out;
247
248 clk->dentry = d;
249
250 d = debugfs_create_u32("clk_rate", S_IRUGO, clk->dentry,
251 (u32 *)&clk->rate);
252 if (!d)
253 goto err_out;
254
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100255 d = debugfs_create_u32("clk_accuracy", S_IRUGO, clk->dentry,
256 (u32 *)&clk->accuracy);
257 if (!d)
258 goto err_out;
259
Mike Turquetteb24764902012-03-15 23:11:19 -0700260 d = debugfs_create_x32("clk_flags", S_IRUGO, clk->dentry,
261 (u32 *)&clk->flags);
262 if (!d)
263 goto err_out;
264
265 d = debugfs_create_u32("clk_prepare_count", S_IRUGO, clk->dentry,
266 (u32 *)&clk->prepare_count);
267 if (!d)
268 goto err_out;
269
270 d = debugfs_create_u32("clk_enable_count", S_IRUGO, clk->dentry,
271 (u32 *)&clk->enable_count);
272 if (!d)
273 goto err_out;
274
275 d = debugfs_create_u32("clk_notifier_count", S_IRUGO, clk->dentry,
276 (u32 *)&clk->notifier_count);
277 if (!d)
278 goto err_out;
279
280 ret = 0;
281 goto out;
282
283err_out:
Alex Elderb5f98e62013-11-27 09:39:49 -0600284 debugfs_remove_recursive(clk->dentry);
285 clk->dentry = NULL;
Mike Turquetteb24764902012-03-15 23:11:19 -0700286out:
287 return ret;
288}
289
290/* caller must hold prepare_lock */
291static int clk_debug_create_subtree(struct clk *clk, struct dentry *pdentry)
292{
293 struct clk *child;
Mike Turquetteb24764902012-03-15 23:11:19 -0700294 int ret = -EINVAL;;
295
296 if (!clk || !pdentry)
297 goto out;
298
299 ret = clk_debug_create_one(clk, pdentry);
300
301 if (ret)
302 goto out;
303
Sasha Levinb67bfe02013-02-27 17:06:00 -0800304 hlist_for_each_entry(child, &clk->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700305 clk_debug_create_subtree(child, clk->dentry);
306
307 ret = 0;
308out:
309 return ret;
310}
311
312/**
313 * clk_debug_register - add a clk node to the debugfs clk tree
314 * @clk: the clk being added to the debugfs clk tree
315 *
316 * Dynamically adds a clk to the debugfs clk tree if debugfs has been
317 * initialized. Otherwise it bails out early since the debugfs clk tree
318 * will be created lazily by clk_debug_init as part of a late_initcall.
319 *
320 * Caller must hold prepare_lock. Only clk_init calls this function (so
321 * far) so this is taken care.
322 */
323static int clk_debug_register(struct clk *clk)
324{
325 struct clk *parent;
326 struct dentry *pdentry;
327 int ret = 0;
328
329 if (!inited)
330 goto out;
331
332 parent = clk->parent;
333
334 /*
335 * Check to see if a clk is a root clk. Also check that it is
336 * safe to add this clk to debugfs
337 */
338 if (!parent)
339 if (clk->flags & CLK_IS_ROOT)
340 pdentry = rootdir;
341 else
342 pdentry = orphandir;
343 else
344 if (parent->dentry)
345 pdentry = parent->dentry;
346 else
347 goto out;
348
349 ret = clk_debug_create_subtree(clk, pdentry);
350
351out:
352 return ret;
353}
354
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +0200355 /**
356 * clk_debug_unregister - remove a clk node from the debugfs clk tree
357 * @clk: the clk being removed from the debugfs clk tree
358 *
359 * Dynamically removes a clk and all it's children clk nodes from the
360 * debugfs clk tree if clk->dentry points to debugfs created by
361 * clk_debug_register in __clk_init.
362 *
363 * Caller must hold prepare_lock.
364 */
365static void clk_debug_unregister(struct clk *clk)
366{
367 debugfs_remove_recursive(clk->dentry);
368}
369
Mike Turquetteb24764902012-03-15 23:11:19 -0700370/**
Ulf Hanssonb33d2122013-04-02 23:09:37 +0200371 * clk_debug_reparent - reparent clk node in the debugfs clk tree
372 * @clk: the clk being reparented
373 * @new_parent: the new clk parent, may be NULL
374 *
375 * Rename clk entry in the debugfs clk tree if debugfs has been
376 * initialized. Otherwise it bails out early since the debugfs clk tree
377 * will be created lazily by clk_debug_init as part of a late_initcall.
378 *
379 * Caller must hold prepare_lock.
380 */
381static void clk_debug_reparent(struct clk *clk, struct clk *new_parent)
382{
383 struct dentry *d;
384 struct dentry *new_parent_d;
385
386 if (!inited)
387 return;
388
389 if (new_parent)
390 new_parent_d = new_parent->dentry;
391 else
392 new_parent_d = orphandir;
393
394 d = debugfs_rename(clk->dentry->d_parent, clk->dentry,
395 new_parent_d, clk->name);
396 if (d)
397 clk->dentry = d;
398 else
399 pr_debug("%s: failed to rename debugfs entry for %s\n",
400 __func__, clk->name);
401}
402
403/**
Mike Turquetteb24764902012-03-15 23:11:19 -0700404 * clk_debug_init - lazily create the debugfs clk tree visualization
405 *
406 * clks are often initialized very early during boot before memory can
407 * be dynamically allocated and well before debugfs is setup.
408 * clk_debug_init walks the clk tree hierarchy while holding
409 * prepare_lock and creates the topology as part of a late_initcall,
410 * thus insuring that clks initialized very early will still be
411 * represented in the debugfs clk tree. This function should only be
412 * called once at boot-time, and all other clks added dynamically will
413 * be done so with clk_debug_register.
414 */
415static int __init clk_debug_init(void)
416{
417 struct clk *clk;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530418 struct dentry *d;
Mike Turquetteb24764902012-03-15 23:11:19 -0700419
420 rootdir = debugfs_create_dir("clk", NULL);
421
422 if (!rootdir)
423 return -ENOMEM;
424
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530425 d = debugfs_create_file("clk_summary", S_IRUGO, rootdir, NULL,
426 &clk_summary_fops);
427 if (!d)
428 return -ENOMEM;
429
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530430 d = debugfs_create_file("clk_dump", S_IRUGO, rootdir, NULL,
431 &clk_dump_fops);
432 if (!d)
433 return -ENOMEM;
434
Mike Turquetteb24764902012-03-15 23:11:19 -0700435 orphandir = debugfs_create_dir("orphans", rootdir);
436
437 if (!orphandir)
438 return -ENOMEM;
439
Mike Turquetteeab89f62013-03-28 13:59:01 -0700440 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700441
Sasha Levinb67bfe02013-02-27 17:06:00 -0800442 hlist_for_each_entry(clk, &clk_root_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700443 clk_debug_create_subtree(clk, rootdir);
444
Sasha Levinb67bfe02013-02-27 17:06:00 -0800445 hlist_for_each_entry(clk, &clk_orphan_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700446 clk_debug_create_subtree(clk, orphandir);
447
448 inited = 1;
449
Mike Turquetteeab89f62013-03-28 13:59:01 -0700450 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700451
452 return 0;
453}
454late_initcall(clk_debug_init);
455#else
456static inline int clk_debug_register(struct clk *clk) { return 0; }
Ulf Hanssonb33d2122013-04-02 23:09:37 +0200457static inline void clk_debug_reparent(struct clk *clk, struct clk *new_parent)
458{
459}
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +0200460static inline void clk_debug_unregister(struct clk *clk)
461{
462}
Mike Turquette70d347e2012-03-26 11:53:47 -0700463#endif
Mike Turquetteb24764902012-03-15 23:11:19 -0700464
Mike Turquetteb24764902012-03-15 23:11:19 -0700465/* caller must hold prepare_lock */
Ulf Hansson1c155b32013-03-12 20:26:03 +0100466static void clk_unprepare_unused_subtree(struct clk *clk)
467{
468 struct clk *child;
469
470 if (!clk)
471 return;
472
473 hlist_for_each_entry(child, &clk->children, child_node)
474 clk_unprepare_unused_subtree(child);
475
476 if (clk->prepare_count)
477 return;
478
479 if (clk->flags & CLK_IGNORE_UNUSED)
480 return;
481
Ulf Hansson3cc82472013-03-12 20:26:04 +0100482 if (__clk_is_prepared(clk)) {
483 if (clk->ops->unprepare_unused)
484 clk->ops->unprepare_unused(clk->hw);
485 else if (clk->ops->unprepare)
Ulf Hansson1c155b32013-03-12 20:26:03 +0100486 clk->ops->unprepare(clk->hw);
Ulf Hansson3cc82472013-03-12 20:26:04 +0100487 }
Ulf Hansson1c155b32013-03-12 20:26:03 +0100488}
489
490/* caller must hold prepare_lock */
Mike Turquetteb24764902012-03-15 23:11:19 -0700491static void clk_disable_unused_subtree(struct clk *clk)
492{
493 struct clk *child;
Mike Turquetteb24764902012-03-15 23:11:19 -0700494 unsigned long flags;
495
496 if (!clk)
497 goto out;
498
Sasha Levinb67bfe02013-02-27 17:06:00 -0800499 hlist_for_each_entry(child, &clk->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700500 clk_disable_unused_subtree(child);
501
Mike Turquetteeab89f62013-03-28 13:59:01 -0700502 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700503
504 if (clk->enable_count)
505 goto unlock_out;
506
507 if (clk->flags & CLK_IGNORE_UNUSED)
508 goto unlock_out;
509
Mike Turquette7c045a52012-12-04 11:00:35 -0800510 /*
511 * some gate clocks have special needs during the disable-unused
512 * sequence. call .disable_unused if available, otherwise fall
513 * back to .disable
514 */
515 if (__clk_is_enabled(clk)) {
516 if (clk->ops->disable_unused)
517 clk->ops->disable_unused(clk->hw);
518 else if (clk->ops->disable)
519 clk->ops->disable(clk->hw);
520 }
Mike Turquetteb24764902012-03-15 23:11:19 -0700521
522unlock_out:
Mike Turquetteeab89f62013-03-28 13:59:01 -0700523 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700524
525out:
526 return;
527}
528
Olof Johansson1e435252013-04-27 14:10:18 -0700529static bool clk_ignore_unused;
530static int __init clk_ignore_unused_setup(char *__unused)
531{
532 clk_ignore_unused = true;
533 return 1;
534}
535__setup("clk_ignore_unused", clk_ignore_unused_setup);
536
Mike Turquetteb24764902012-03-15 23:11:19 -0700537static int clk_disable_unused(void)
538{
539 struct clk *clk;
Mike Turquetteb24764902012-03-15 23:11:19 -0700540
Olof Johansson1e435252013-04-27 14:10:18 -0700541 if (clk_ignore_unused) {
542 pr_warn("clk: Not disabling unused clocks\n");
543 return 0;
544 }
545
Mike Turquetteeab89f62013-03-28 13:59:01 -0700546 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700547
Sasha Levinb67bfe02013-02-27 17:06:00 -0800548 hlist_for_each_entry(clk, &clk_root_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700549 clk_disable_unused_subtree(clk);
550
Sasha Levinb67bfe02013-02-27 17:06:00 -0800551 hlist_for_each_entry(clk, &clk_orphan_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700552 clk_disable_unused_subtree(clk);
553
Ulf Hansson1c155b32013-03-12 20:26:03 +0100554 hlist_for_each_entry(clk, &clk_root_list, child_node)
555 clk_unprepare_unused_subtree(clk);
556
557 hlist_for_each_entry(clk, &clk_orphan_list, child_node)
558 clk_unprepare_unused_subtree(clk);
559
Mike Turquetteeab89f62013-03-28 13:59:01 -0700560 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700561
562 return 0;
563}
Saravana Kannand41d5802013-05-09 11:35:01 -0700564late_initcall_sync(clk_disable_unused);
Mike Turquetteb24764902012-03-15 23:11:19 -0700565
566/*** helper functions ***/
567
Russ Dill65800b22012-11-26 11:20:09 -0800568const char *__clk_get_name(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700569{
570 return !clk ? NULL : clk->name;
571}
Niels de Vos48950842012-12-13 13:12:25 +0100572EXPORT_SYMBOL_GPL(__clk_get_name);
Mike Turquetteb24764902012-03-15 23:11:19 -0700573
Russ Dill65800b22012-11-26 11:20:09 -0800574struct clk_hw *__clk_get_hw(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700575{
576 return !clk ? NULL : clk->hw;
577}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800578EXPORT_SYMBOL_GPL(__clk_get_hw);
Mike Turquetteb24764902012-03-15 23:11:19 -0700579
Russ Dill65800b22012-11-26 11:20:09 -0800580u8 __clk_get_num_parents(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700581{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700582 return !clk ? 0 : clk->num_parents;
Mike Turquetteb24764902012-03-15 23:11:19 -0700583}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800584EXPORT_SYMBOL_GPL(__clk_get_num_parents);
Mike Turquetteb24764902012-03-15 23:11:19 -0700585
Russ Dill65800b22012-11-26 11:20:09 -0800586struct clk *__clk_get_parent(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700587{
588 return !clk ? NULL : clk->parent;
589}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800590EXPORT_SYMBOL_GPL(__clk_get_parent);
Mike Turquetteb24764902012-03-15 23:11:19 -0700591
James Hogan7ef3dcc2013-07-29 12:24:58 +0100592struct clk *clk_get_parent_by_index(struct clk *clk, u8 index)
593{
594 if (!clk || index >= clk->num_parents)
595 return NULL;
596 else if (!clk->parents)
597 return __clk_lookup(clk->parent_names[index]);
598 else if (!clk->parents[index])
599 return clk->parents[index] =
600 __clk_lookup(clk->parent_names[index]);
601 else
602 return clk->parents[index];
603}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800604EXPORT_SYMBOL_GPL(clk_get_parent_by_index);
James Hogan7ef3dcc2013-07-29 12:24:58 +0100605
Russ Dill65800b22012-11-26 11:20:09 -0800606unsigned int __clk_get_enable_count(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700607{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700608 return !clk ? 0 : clk->enable_count;
Mike Turquetteb24764902012-03-15 23:11:19 -0700609}
610
Russ Dill65800b22012-11-26 11:20:09 -0800611unsigned int __clk_get_prepare_count(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700612{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700613 return !clk ? 0 : clk->prepare_count;
Mike Turquetteb24764902012-03-15 23:11:19 -0700614}
615
616unsigned long __clk_get_rate(struct clk *clk)
617{
618 unsigned long ret;
619
620 if (!clk) {
Rajendra Nayak34e44fe2012-03-26 19:01:48 +0530621 ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700622 goto out;
623 }
624
625 ret = clk->rate;
626
627 if (clk->flags & CLK_IS_ROOT)
628 goto out;
629
630 if (!clk->parent)
Rajendra Nayak34e44fe2012-03-26 19:01:48 +0530631 ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700632
633out:
634 return ret;
635}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800636EXPORT_SYMBOL_GPL(__clk_get_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -0700637
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100638unsigned long __clk_get_accuracy(struct clk *clk)
639{
640 if (!clk)
641 return 0;
642
643 return clk->accuracy;
644}
645
Russ Dill65800b22012-11-26 11:20:09 -0800646unsigned long __clk_get_flags(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700647{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700648 return !clk ? 0 : clk->flags;
Mike Turquetteb24764902012-03-15 23:11:19 -0700649}
Thierry Redingb05c6832013-09-03 09:43:51 +0200650EXPORT_SYMBOL_GPL(__clk_get_flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700651
Ulf Hansson3d6ee282013-03-12 20:26:02 +0100652bool __clk_is_prepared(struct clk *clk)
653{
654 int ret;
655
656 if (!clk)
657 return false;
658
659 /*
660 * .is_prepared is optional for clocks that can prepare
661 * fall back to software usage counter if it is missing
662 */
663 if (!clk->ops->is_prepared) {
664 ret = clk->prepare_count ? 1 : 0;
665 goto out;
666 }
667
668 ret = clk->ops->is_prepared(clk->hw);
669out:
670 return !!ret;
671}
672
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700673bool __clk_is_enabled(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700674{
675 int ret;
676
677 if (!clk)
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700678 return false;
Mike Turquetteb24764902012-03-15 23:11:19 -0700679
680 /*
681 * .is_enabled is only mandatory for clocks that gate
682 * fall back to software usage counter if .is_enabled is missing
683 */
684 if (!clk->ops->is_enabled) {
685 ret = clk->enable_count ? 1 : 0;
686 goto out;
687 }
688
689 ret = clk->ops->is_enabled(clk->hw);
690out:
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700691 return !!ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700692}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800693EXPORT_SYMBOL_GPL(__clk_is_enabled);
Mike Turquetteb24764902012-03-15 23:11:19 -0700694
695static struct clk *__clk_lookup_subtree(const char *name, struct clk *clk)
696{
697 struct clk *child;
698 struct clk *ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700699
700 if (!strcmp(clk->name, name))
701 return clk;
702
Sasha Levinb67bfe02013-02-27 17:06:00 -0800703 hlist_for_each_entry(child, &clk->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -0700704 ret = __clk_lookup_subtree(name, child);
705 if (ret)
706 return ret;
707 }
708
709 return NULL;
710}
711
712struct clk *__clk_lookup(const char *name)
713{
714 struct clk *root_clk;
715 struct clk *ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700716
717 if (!name)
718 return NULL;
719
720 /* search the 'proper' clk tree first */
Sasha Levinb67bfe02013-02-27 17:06:00 -0800721 hlist_for_each_entry(root_clk, &clk_root_list, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -0700722 ret = __clk_lookup_subtree(name, root_clk);
723 if (ret)
724 return ret;
725 }
726
727 /* if not found, then search the orphan tree */
Sasha Levinb67bfe02013-02-27 17:06:00 -0800728 hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -0700729 ret = __clk_lookup_subtree(name, root_clk);
730 if (ret)
731 return ret;
732 }
733
734 return NULL;
735}
736
James Hogane366fdd2013-07-29 12:25:02 +0100737/*
738 * Helper for finding best parent to provide a given frequency. This can be used
739 * directly as a determine_rate callback (e.g. for a mux), or from a more
740 * complex clock that may combine a mux with other operations.
741 */
742long __clk_mux_determine_rate(struct clk_hw *hw, unsigned long rate,
743 unsigned long *best_parent_rate,
744 struct clk **best_parent_p)
745{
746 struct clk *clk = hw->clk, *parent, *best_parent = NULL;
747 int i, num_parents;
748 unsigned long parent_rate, best = 0;
749
750 /* if NO_REPARENT flag set, pass through to current parent */
751 if (clk->flags & CLK_SET_RATE_NO_REPARENT) {
752 parent = clk->parent;
753 if (clk->flags & CLK_SET_RATE_PARENT)
754 best = __clk_round_rate(parent, rate);
755 else if (parent)
756 best = __clk_get_rate(parent);
757 else
758 best = __clk_get_rate(clk);
759 goto out;
760 }
761
762 /* find the parent that can provide the fastest rate <= rate */
763 num_parents = clk->num_parents;
764 for (i = 0; i < num_parents; i++) {
765 parent = clk_get_parent_by_index(clk, i);
766 if (!parent)
767 continue;
768 if (clk->flags & CLK_SET_RATE_PARENT)
769 parent_rate = __clk_round_rate(parent, rate);
770 else
771 parent_rate = __clk_get_rate(parent);
772 if (parent_rate <= rate && parent_rate > best) {
773 best_parent = parent;
774 best = parent_rate;
775 }
776 }
777
778out:
779 if (best_parent)
780 *best_parent_p = best_parent;
781 *best_parent_rate = best;
782
783 return best;
784}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800785EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);
James Hogane366fdd2013-07-29 12:25:02 +0100786
Mike Turquetteb24764902012-03-15 23:11:19 -0700787/*** clk api ***/
788
789void __clk_unprepare(struct clk *clk)
790{
791 if (!clk)
792 return;
793
794 if (WARN_ON(clk->prepare_count == 0))
795 return;
796
797 if (--clk->prepare_count > 0)
798 return;
799
800 WARN_ON(clk->enable_count > 0);
801
802 if (clk->ops->unprepare)
803 clk->ops->unprepare(clk->hw);
804
805 __clk_unprepare(clk->parent);
806}
807
808/**
809 * clk_unprepare - undo preparation of a clock source
Peter Meerwald24ee1a02013-06-29 15:14:19 +0200810 * @clk: the clk being unprepared
Mike Turquetteb24764902012-03-15 23:11:19 -0700811 *
812 * clk_unprepare may sleep, which differentiates it from clk_disable. In a
813 * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
814 * if the operation may sleep. One example is a clk which is accessed over
815 * I2c. In the complex case a clk gate operation may require a fast and a slow
816 * part. It is this reason that clk_unprepare and clk_disable are not mutually
817 * exclusive. In fact clk_disable must be called before clk_unprepare.
818 */
819void clk_unprepare(struct clk *clk)
820{
Mike Turquetteeab89f62013-03-28 13:59:01 -0700821 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700822 __clk_unprepare(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700823 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700824}
825EXPORT_SYMBOL_GPL(clk_unprepare);
826
827int __clk_prepare(struct clk *clk)
828{
829 int ret = 0;
830
831 if (!clk)
832 return 0;
833
834 if (clk->prepare_count == 0) {
835 ret = __clk_prepare(clk->parent);
836 if (ret)
837 return ret;
838
839 if (clk->ops->prepare) {
840 ret = clk->ops->prepare(clk->hw);
841 if (ret) {
842 __clk_unprepare(clk->parent);
843 return ret;
844 }
845 }
846 }
847
848 clk->prepare_count++;
849
850 return 0;
851}
852
853/**
854 * clk_prepare - prepare a clock source
855 * @clk: the clk being prepared
856 *
857 * clk_prepare may sleep, which differentiates it from clk_enable. In a simple
858 * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
859 * operation may sleep. One example is a clk which is accessed over I2c. In
860 * the complex case a clk ungate operation may require a fast and a slow part.
861 * It is this reason that clk_prepare and clk_enable are not mutually
862 * exclusive. In fact clk_prepare must be called before clk_enable.
863 * Returns 0 on success, -EERROR otherwise.
864 */
865int clk_prepare(struct clk *clk)
866{
867 int ret;
868
Mike Turquetteeab89f62013-03-28 13:59:01 -0700869 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700870 ret = __clk_prepare(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700871 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700872
873 return ret;
874}
875EXPORT_SYMBOL_GPL(clk_prepare);
876
877static void __clk_disable(struct clk *clk)
878{
879 if (!clk)
880 return;
881
Fengguang Wue47c6a32012-07-30 14:39:54 -0700882 if (WARN_ON(IS_ERR(clk)))
883 return;
884
Mike Turquetteb24764902012-03-15 23:11:19 -0700885 if (WARN_ON(clk->enable_count == 0))
886 return;
887
888 if (--clk->enable_count > 0)
889 return;
890
891 if (clk->ops->disable)
892 clk->ops->disable(clk->hw);
893
894 __clk_disable(clk->parent);
895}
896
897/**
898 * clk_disable - gate a clock
899 * @clk: the clk being gated
900 *
901 * clk_disable must not sleep, which differentiates it from clk_unprepare. In
902 * a simple case, clk_disable can be used instead of clk_unprepare to gate a
903 * clk if the operation is fast and will never sleep. One example is a
904 * SoC-internal clk which is controlled via simple register writes. In the
905 * complex case a clk gate operation may require a fast and a slow part. It is
906 * this reason that clk_unprepare and clk_disable are not mutually exclusive.
907 * In fact clk_disable must be called before clk_unprepare.
908 */
909void clk_disable(struct clk *clk)
910{
911 unsigned long flags;
912
Mike Turquetteeab89f62013-03-28 13:59:01 -0700913 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700914 __clk_disable(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700915 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700916}
917EXPORT_SYMBOL_GPL(clk_disable);
918
919static int __clk_enable(struct clk *clk)
920{
921 int ret = 0;
922
923 if (!clk)
924 return 0;
925
926 if (WARN_ON(clk->prepare_count == 0))
927 return -ESHUTDOWN;
928
929 if (clk->enable_count == 0) {
930 ret = __clk_enable(clk->parent);
931
932 if (ret)
933 return ret;
934
935 if (clk->ops->enable) {
936 ret = clk->ops->enable(clk->hw);
937 if (ret) {
938 __clk_disable(clk->parent);
939 return ret;
940 }
941 }
942 }
943
944 clk->enable_count++;
945 return 0;
946}
947
948/**
949 * clk_enable - ungate a clock
950 * @clk: the clk being ungated
951 *
952 * clk_enable must not sleep, which differentiates it from clk_prepare. In a
953 * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
954 * if the operation will never sleep. One example is a SoC-internal clk which
955 * is controlled via simple register writes. In the complex case a clk ungate
956 * operation may require a fast and a slow part. It is this reason that
957 * clk_enable and clk_prepare are not mutually exclusive. In fact clk_prepare
958 * must be called before clk_enable. Returns 0 on success, -EERROR
959 * otherwise.
960 */
961int clk_enable(struct clk *clk)
962{
963 unsigned long flags;
964 int ret;
965
Mike Turquetteeab89f62013-03-28 13:59:01 -0700966 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700967 ret = __clk_enable(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700968 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700969
970 return ret;
971}
972EXPORT_SYMBOL_GPL(clk_enable);
973
974/**
Mike Turquetteb24764902012-03-15 23:11:19 -0700975 * __clk_round_rate - round the given rate for a clk
976 * @clk: round the rate of this clock
Peter Meerwald24ee1a02013-06-29 15:14:19 +0200977 * @rate: the rate which is to be rounded
Mike Turquetteb24764902012-03-15 23:11:19 -0700978 *
979 * Caller must hold prepare_lock. Useful for clk_ops such as .set_rate
980 */
981unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)
982{
Shawn Guo81536e02012-04-12 20:50:17 +0800983 unsigned long parent_rate = 0;
James Hogan71472c02013-07-29 12:25:00 +0100984 struct clk *parent;
Mike Turquetteb24764902012-03-15 23:11:19 -0700985
986 if (!clk)
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700987 return 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700988
James Hogan71472c02013-07-29 12:25:00 +0100989 parent = clk->parent;
990 if (parent)
991 parent_rate = parent->rate;
Mike Turquetteb24764902012-03-15 23:11:19 -0700992
James Hogan71472c02013-07-29 12:25:00 +0100993 if (clk->ops->determine_rate)
994 return clk->ops->determine_rate(clk->hw, rate, &parent_rate,
995 &parent);
996 else if (clk->ops->round_rate)
997 return clk->ops->round_rate(clk->hw, rate, &parent_rate);
998 else if (clk->flags & CLK_SET_RATE_PARENT)
999 return __clk_round_rate(clk->parent, rate);
1000 else
1001 return clk->rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07001002}
1003
1004/**
1005 * clk_round_rate - round the given rate for a clk
1006 * @clk: the clk for which we are rounding a rate
1007 * @rate: the rate which is to be rounded
1008 *
1009 * Takes in a rate as input and rounds it to a rate that the clk can actually
1010 * use which is then returned. If clk doesn't support round_rate operation
1011 * then the parent rate is returned.
1012 */
1013long clk_round_rate(struct clk *clk, unsigned long rate)
1014{
1015 unsigned long ret;
1016
Mike Turquetteeab89f62013-03-28 13:59:01 -07001017 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001018 ret = __clk_round_rate(clk, rate);
Mike Turquetteeab89f62013-03-28 13:59:01 -07001019 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001020
1021 return ret;
1022}
1023EXPORT_SYMBOL_GPL(clk_round_rate);
1024
1025/**
1026 * __clk_notify - call clk notifier chain
1027 * @clk: struct clk * that is changing rate
1028 * @msg: clk notifier type (see include/linux/clk.h)
1029 * @old_rate: old clk rate
1030 * @new_rate: new clk rate
1031 *
1032 * Triggers a notifier call chain on the clk rate-change notification
1033 * for 'clk'. Passes a pointer to the struct clk and the previous
1034 * and current rates to the notifier callback. Intended to be called by
1035 * internal clock code only. Returns NOTIFY_DONE from the last driver
1036 * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
1037 * a driver returns that.
1038 */
1039static int __clk_notify(struct clk *clk, unsigned long msg,
1040 unsigned long old_rate, unsigned long new_rate)
1041{
1042 struct clk_notifier *cn;
1043 struct clk_notifier_data cnd;
1044 int ret = NOTIFY_DONE;
1045
1046 cnd.clk = clk;
1047 cnd.old_rate = old_rate;
1048 cnd.new_rate = new_rate;
1049
1050 list_for_each_entry(cn, &clk_notifier_list, node) {
1051 if (cn->clk == clk) {
1052 ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
1053 &cnd);
1054 break;
1055 }
1056 }
1057
1058 return ret;
1059}
1060
1061/**
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001062 * __clk_recalc_accuracies
1063 * @clk: first clk in the subtree
1064 *
1065 * Walks the subtree of clks starting with clk and recalculates accuracies as
1066 * it goes. Note that if a clk does not implement the .recalc_accuracy
1067 * callback then it is assumed that the clock will take on the accuracy of it's
1068 * parent.
1069 *
1070 * Caller must hold prepare_lock.
1071 */
1072static void __clk_recalc_accuracies(struct clk *clk)
1073{
1074 unsigned long parent_accuracy = 0;
1075 struct clk *child;
1076
1077 if (clk->parent)
1078 parent_accuracy = clk->parent->accuracy;
1079
1080 if (clk->ops->recalc_accuracy)
1081 clk->accuracy = clk->ops->recalc_accuracy(clk->hw,
1082 parent_accuracy);
1083 else
1084 clk->accuracy = parent_accuracy;
1085
1086 hlist_for_each_entry(child, &clk->children, child_node)
1087 __clk_recalc_accuracies(child);
1088}
1089
1090/**
1091 * clk_get_accuracy - return the accuracy of clk
1092 * @clk: the clk whose accuracy is being returned
1093 *
1094 * Simply returns the cached accuracy of the clk, unless
1095 * CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
1096 * issued.
1097 * If clk is NULL then returns 0.
1098 */
1099long clk_get_accuracy(struct clk *clk)
1100{
1101 unsigned long accuracy;
1102
1103 clk_prepare_lock();
1104 if (clk && (clk->flags & CLK_GET_ACCURACY_NOCACHE))
1105 __clk_recalc_accuracies(clk);
1106
1107 accuracy = __clk_get_accuracy(clk);
1108 clk_prepare_unlock();
1109
1110 return accuracy;
1111}
1112EXPORT_SYMBOL_GPL(clk_get_accuracy);
1113
1114/**
Mike Turquetteb24764902012-03-15 23:11:19 -07001115 * __clk_recalc_rates
1116 * @clk: first clk in the subtree
1117 * @msg: notification type (see include/linux/clk.h)
1118 *
1119 * Walks the subtree of clks starting with clk and recalculates rates as it
1120 * goes. Note that if a clk does not implement the .recalc_rate callback then
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001121 * it is assumed that the clock will take on the rate of its parent.
Mike Turquetteb24764902012-03-15 23:11:19 -07001122 *
1123 * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
1124 * if necessary.
1125 *
1126 * Caller must hold prepare_lock.
1127 */
1128static void __clk_recalc_rates(struct clk *clk, unsigned long msg)
1129{
1130 unsigned long old_rate;
1131 unsigned long parent_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001132 struct clk *child;
1133
1134 old_rate = clk->rate;
1135
1136 if (clk->parent)
1137 parent_rate = clk->parent->rate;
1138
1139 if (clk->ops->recalc_rate)
1140 clk->rate = clk->ops->recalc_rate(clk->hw, parent_rate);
1141 else
1142 clk->rate = parent_rate;
1143
1144 /*
1145 * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
1146 * & ABORT_RATE_CHANGE notifiers
1147 */
1148 if (clk->notifier_count && msg)
1149 __clk_notify(clk, msg, old_rate, clk->rate);
1150
Sasha Levinb67bfe02013-02-27 17:06:00 -08001151 hlist_for_each_entry(child, &clk->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -07001152 __clk_recalc_rates(child, msg);
1153}
1154
1155/**
Ulf Hanssona093bde2012-08-31 14:21:28 +02001156 * clk_get_rate - return the rate of clk
1157 * @clk: the clk whose rate is being returned
1158 *
1159 * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
1160 * is set, which means a recalc_rate will be issued.
1161 * If clk is NULL then returns 0.
1162 */
1163unsigned long clk_get_rate(struct clk *clk)
1164{
1165 unsigned long rate;
1166
Mike Turquetteeab89f62013-03-28 13:59:01 -07001167 clk_prepare_lock();
Ulf Hanssona093bde2012-08-31 14:21:28 +02001168
1169 if (clk && (clk->flags & CLK_GET_RATE_NOCACHE))
1170 __clk_recalc_rates(clk, 0);
1171
1172 rate = __clk_get_rate(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -07001173 clk_prepare_unlock();
Ulf Hanssona093bde2012-08-31 14:21:28 +02001174
1175 return rate;
1176}
1177EXPORT_SYMBOL_GPL(clk_get_rate);
1178
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001179static int clk_fetch_parent_index(struct clk *clk, struct clk *parent)
James Hogan4935b222013-07-29 12:24:59 +01001180{
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001181 int i;
James Hogan4935b222013-07-29 12:24:59 +01001182
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001183 if (!clk->parents) {
Tomasz Figa96a7ed92013-09-29 02:37:15 +02001184 clk->parents = kcalloc(clk->num_parents,
1185 sizeof(struct clk *), GFP_KERNEL);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001186 if (!clk->parents)
1187 return -ENOMEM;
1188 }
James Hogan4935b222013-07-29 12:24:59 +01001189
1190 /*
1191 * find index of new parent clock using cached parent ptrs,
1192 * or if not yet cached, use string name comparison and cache
1193 * them now to avoid future calls to __clk_lookup.
1194 */
1195 for (i = 0; i < clk->num_parents; i++) {
Tomasz Figada0f0b22013-09-29 02:37:16 +02001196 if (clk->parents[i] == parent)
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001197 return i;
Tomasz Figada0f0b22013-09-29 02:37:16 +02001198
1199 if (clk->parents[i])
1200 continue;
1201
1202 if (!strcmp(clk->parent_names[i], parent->name)) {
1203 clk->parents[i] = __clk_lookup(parent->name);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001204 return i;
James Hogan4935b222013-07-29 12:24:59 +01001205 }
1206 }
1207
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001208 return -EINVAL;
James Hogan4935b222013-07-29 12:24:59 +01001209}
1210
1211static void clk_reparent(struct clk *clk, struct clk *new_parent)
1212{
1213 hlist_del(&clk->child_node);
1214
James Hogan903efc52013-08-29 12:10:51 +01001215 if (new_parent) {
1216 /* avoid duplicate POST_RATE_CHANGE notifications */
1217 if (new_parent->new_child == clk)
1218 new_parent->new_child = NULL;
1219
James Hogan4935b222013-07-29 12:24:59 +01001220 hlist_add_head(&clk->child_node, &new_parent->children);
James Hogan903efc52013-08-29 12:10:51 +01001221 } else {
James Hogan4935b222013-07-29 12:24:59 +01001222 hlist_add_head(&clk->child_node, &clk_orphan_list);
James Hogan903efc52013-08-29 12:10:51 +01001223 }
James Hogan4935b222013-07-29 12:24:59 +01001224
1225 clk->parent = new_parent;
1226}
1227
Stephen Boyd3fa22522014-01-15 10:47:22 -08001228static struct clk *__clk_set_parent_before(struct clk *clk, struct clk *parent)
James Hogan4935b222013-07-29 12:24:59 +01001229{
1230 unsigned long flags;
James Hogan4935b222013-07-29 12:24:59 +01001231 struct clk *old_parent = clk->parent;
1232
1233 /*
1234 * Migrate prepare state between parents and prevent race with
1235 * clk_enable().
1236 *
1237 * If the clock is not prepared, then a race with
1238 * clk_enable/disable() is impossible since we already have the
1239 * prepare lock (future calls to clk_enable() need to be preceded by
1240 * a clk_prepare()).
1241 *
1242 * If the clock is prepared, migrate the prepared state to the new
1243 * parent and also protect against a race with clk_enable() by
1244 * forcing the clock and the new parent on. This ensures that all
1245 * future calls to clk_enable() are practically NOPs with respect to
1246 * hardware and software states.
1247 *
1248 * See also: Comment for clk_set_parent() below.
1249 */
1250 if (clk->prepare_count) {
1251 __clk_prepare(parent);
1252 clk_enable(parent);
1253 clk_enable(clk);
1254 }
1255
1256 /* update the clk tree topology */
1257 flags = clk_enable_lock();
1258 clk_reparent(clk, parent);
1259 clk_enable_unlock(flags);
1260
Stephen Boyd3fa22522014-01-15 10:47:22 -08001261 return old_parent;
1262}
1263
1264static void __clk_set_parent_after(struct clk *clk, struct clk *parent,
1265 struct clk *old_parent)
1266{
1267 /*
1268 * Finish the migration of prepare state and undo the changes done
1269 * for preventing a race with clk_enable().
1270 */
1271 if (clk->prepare_count) {
1272 clk_disable(clk);
1273 clk_disable(old_parent);
1274 __clk_unprepare(old_parent);
1275 }
1276
1277 /* update debugfs with new clk tree topology */
1278 clk_debug_reparent(clk, parent);
1279}
1280
1281static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
1282{
1283 unsigned long flags;
1284 int ret = 0;
1285 struct clk *old_parent;
1286
1287 old_parent = __clk_set_parent_before(clk, parent);
1288
James Hogan4935b222013-07-29 12:24:59 +01001289 /* change clock input source */
1290 if (parent && clk->ops->set_parent)
1291 ret = clk->ops->set_parent(clk->hw, p_index);
1292
1293 if (ret) {
1294 flags = clk_enable_lock();
1295 clk_reparent(clk, old_parent);
1296 clk_enable_unlock(flags);
1297
1298 if (clk->prepare_count) {
1299 clk_disable(clk);
1300 clk_disable(parent);
1301 __clk_unprepare(parent);
1302 }
1303 return ret;
1304 }
1305
Stephen Boyd3fa22522014-01-15 10:47:22 -08001306 __clk_set_parent_after(clk, parent, old_parent);
James Hogan4935b222013-07-29 12:24:59 +01001307
James Hogan4935b222013-07-29 12:24:59 +01001308 return 0;
1309}
1310
Ulf Hanssona093bde2012-08-31 14:21:28 +02001311/**
Mike Turquetteb24764902012-03-15 23:11:19 -07001312 * __clk_speculate_rates
1313 * @clk: first clk in the subtree
1314 * @parent_rate: the "future" rate of clk's parent
1315 *
1316 * Walks the subtree of clks starting with clk, speculating rates as it
1317 * goes and firing off PRE_RATE_CHANGE notifications as necessary.
1318 *
1319 * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
1320 * pre-rate change notifications and returns early if no clks in the
1321 * subtree have subscribed to the notifications. Note that if a clk does not
1322 * implement the .recalc_rate callback then it is assumed that the clock will
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001323 * take on the rate of its parent.
Mike Turquetteb24764902012-03-15 23:11:19 -07001324 *
1325 * Caller must hold prepare_lock.
1326 */
1327static int __clk_speculate_rates(struct clk *clk, unsigned long parent_rate)
1328{
Mike Turquetteb24764902012-03-15 23:11:19 -07001329 struct clk *child;
1330 unsigned long new_rate;
1331 int ret = NOTIFY_DONE;
1332
1333 if (clk->ops->recalc_rate)
1334 new_rate = clk->ops->recalc_rate(clk->hw, parent_rate);
1335 else
1336 new_rate = parent_rate;
1337
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001338 /* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
Mike Turquetteb24764902012-03-15 23:11:19 -07001339 if (clk->notifier_count)
1340 ret = __clk_notify(clk, PRE_RATE_CHANGE, clk->rate, new_rate);
1341
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001342 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001343 goto out;
1344
Sasha Levinb67bfe02013-02-27 17:06:00 -08001345 hlist_for_each_entry(child, &clk->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001346 ret = __clk_speculate_rates(child, new_rate);
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001347 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001348 break;
1349 }
1350
1351out:
1352 return ret;
1353}
1354
James Hogan71472c02013-07-29 12:25:00 +01001355static void clk_calc_subtree(struct clk *clk, unsigned long new_rate,
1356 struct clk *new_parent, u8 p_index)
Mike Turquetteb24764902012-03-15 23:11:19 -07001357{
1358 struct clk *child;
Mike Turquetteb24764902012-03-15 23:11:19 -07001359
1360 clk->new_rate = new_rate;
James Hogan71472c02013-07-29 12:25:00 +01001361 clk->new_parent = new_parent;
1362 clk->new_parent_index = p_index;
1363 /* include clk in new parent's PRE_RATE_CHANGE notifications */
1364 clk->new_child = NULL;
1365 if (new_parent && new_parent != clk->parent)
1366 new_parent->new_child = clk;
Mike Turquetteb24764902012-03-15 23:11:19 -07001367
Sasha Levinb67bfe02013-02-27 17:06:00 -08001368 hlist_for_each_entry(child, &clk->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001369 if (child->ops->recalc_rate)
1370 child->new_rate = child->ops->recalc_rate(child->hw, new_rate);
1371 else
1372 child->new_rate = new_rate;
James Hogan71472c02013-07-29 12:25:00 +01001373 clk_calc_subtree(child, child->new_rate, NULL, 0);
Mike Turquetteb24764902012-03-15 23:11:19 -07001374 }
1375}
1376
1377/*
1378 * calculate the new rates returning the topmost clock that has to be
1379 * changed.
1380 */
1381static struct clk *clk_calc_new_rates(struct clk *clk, unsigned long rate)
1382{
1383 struct clk *top = clk;
James Hogan71472c02013-07-29 12:25:00 +01001384 struct clk *old_parent, *parent;
Shawn Guo81536e02012-04-12 20:50:17 +08001385 unsigned long best_parent_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001386 unsigned long new_rate;
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001387 int p_index = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001388
Mike Turquette7452b212012-03-26 14:45:36 -07001389 /* sanity */
1390 if (IS_ERR_OR_NULL(clk))
1391 return NULL;
1392
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001393 /* save parent rate, if it exists */
James Hogan71472c02013-07-29 12:25:00 +01001394 parent = old_parent = clk->parent;
1395 if (parent)
1396 best_parent_rate = parent->rate;
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001397
James Hogan71472c02013-07-29 12:25:00 +01001398 /* find the closest rate and parent clk/rate */
1399 if (clk->ops->determine_rate) {
1400 new_rate = clk->ops->determine_rate(clk->hw, rate,
1401 &best_parent_rate,
1402 &parent);
1403 } else if (clk->ops->round_rate) {
1404 new_rate = clk->ops->round_rate(clk->hw, rate,
1405 &best_parent_rate);
1406 } else if (!parent || !(clk->flags & CLK_SET_RATE_PARENT)) {
1407 /* pass-through clock without adjustable parent */
1408 clk->new_rate = clk->rate;
1409 return NULL;
1410 } else {
1411 /* pass-through clock with adjustable parent */
1412 top = clk_calc_new_rates(parent, rate);
1413 new_rate = parent->new_rate;
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001414 goto out;
Mike Turquette7452b212012-03-26 14:45:36 -07001415 }
1416
James Hogan71472c02013-07-29 12:25:00 +01001417 /* some clocks must be gated to change parent */
1418 if (parent != old_parent &&
1419 (clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) {
1420 pr_debug("%s: %s not gated but wants to reparent\n",
1421 __func__, clk->name);
Mike Turquetteb24764902012-03-15 23:11:19 -07001422 return NULL;
1423 }
1424
James Hogan71472c02013-07-29 12:25:00 +01001425 /* try finding the new parent index */
1426 if (parent) {
1427 p_index = clk_fetch_parent_index(clk, parent);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001428 if (p_index < 0) {
James Hogan71472c02013-07-29 12:25:00 +01001429 pr_debug("%s: clk %s can not be parent of clk %s\n",
1430 __func__, parent->name, clk->name);
1431 return NULL;
1432 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001433 }
1434
James Hogan71472c02013-07-29 12:25:00 +01001435 if ((clk->flags & CLK_SET_RATE_PARENT) && parent &&
1436 best_parent_rate != parent->rate)
1437 top = clk_calc_new_rates(parent, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001438
1439out:
James Hogan71472c02013-07-29 12:25:00 +01001440 clk_calc_subtree(clk, new_rate, parent, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001441
1442 return top;
1443}
1444
1445/*
1446 * Notify about rate changes in a subtree. Always walk down the whole tree
1447 * so that in case of an error we can walk down the whole tree again and
1448 * abort the change.
1449 */
1450static struct clk *clk_propagate_rate_change(struct clk *clk, unsigned long event)
1451{
James Hogan71472c02013-07-29 12:25:00 +01001452 struct clk *child, *tmp_clk, *fail_clk = NULL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001453 int ret = NOTIFY_DONE;
1454
1455 if (clk->rate == clk->new_rate)
Sachin Kamat5fda6852013-03-13 15:17:49 +05301456 return NULL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001457
1458 if (clk->notifier_count) {
1459 ret = __clk_notify(clk, event, clk->rate, clk->new_rate);
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001460 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001461 fail_clk = clk;
1462 }
1463
Sasha Levinb67bfe02013-02-27 17:06:00 -08001464 hlist_for_each_entry(child, &clk->children, child_node) {
James Hogan71472c02013-07-29 12:25:00 +01001465 /* Skip children who will be reparented to another clock */
1466 if (child->new_parent && child->new_parent != clk)
1467 continue;
1468 tmp_clk = clk_propagate_rate_change(child, event);
1469 if (tmp_clk)
1470 fail_clk = tmp_clk;
1471 }
1472
1473 /* handle the new child who might not be in clk->children yet */
1474 if (clk->new_child) {
1475 tmp_clk = clk_propagate_rate_change(clk->new_child, event);
1476 if (tmp_clk)
1477 fail_clk = tmp_clk;
Mike Turquetteb24764902012-03-15 23:11:19 -07001478 }
1479
1480 return fail_clk;
1481}
1482
1483/*
1484 * walk down a subtree and set the new rates notifying the rate
1485 * change on the way
1486 */
1487static void clk_change_rate(struct clk *clk)
1488{
1489 struct clk *child;
1490 unsigned long old_rate;
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001491 unsigned long best_parent_rate = 0;
Stephen Boyd3fa22522014-01-15 10:47:22 -08001492 bool skip_set_rate = false;
1493 struct clk *old_parent;
Mike Turquetteb24764902012-03-15 23:11:19 -07001494
1495 old_rate = clk->rate;
1496
Stephen Boyd3fa22522014-01-15 10:47:22 -08001497 if (clk->new_parent)
1498 best_parent_rate = clk->new_parent->rate;
1499 else if (clk->parent)
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001500 best_parent_rate = clk->parent->rate;
1501
Stephen Boyd3fa22522014-01-15 10:47:22 -08001502 if (clk->new_parent && clk->new_parent != clk->parent) {
1503 old_parent = __clk_set_parent_before(clk, clk->new_parent);
1504
1505 if (clk->ops->set_rate_and_parent) {
1506 skip_set_rate = true;
1507 clk->ops->set_rate_and_parent(clk->hw, clk->new_rate,
1508 best_parent_rate,
1509 clk->new_parent_index);
1510 } else if (clk->ops->set_parent) {
1511 clk->ops->set_parent(clk->hw, clk->new_parent_index);
1512 }
1513
1514 __clk_set_parent_after(clk, clk->new_parent, old_parent);
1515 }
1516
1517 if (!skip_set_rate && clk->ops->set_rate)
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001518 clk->ops->set_rate(clk->hw, clk->new_rate, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001519
1520 if (clk->ops->recalc_rate)
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001521 clk->rate = clk->ops->recalc_rate(clk->hw, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001522 else
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001523 clk->rate = best_parent_rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07001524
1525 if (clk->notifier_count && old_rate != clk->rate)
1526 __clk_notify(clk, POST_RATE_CHANGE, old_rate, clk->rate);
1527
James Hogan71472c02013-07-29 12:25:00 +01001528 hlist_for_each_entry(child, &clk->children, child_node) {
1529 /* Skip children who will be reparented to another clock */
1530 if (child->new_parent && child->new_parent != clk)
1531 continue;
Mike Turquetteb24764902012-03-15 23:11:19 -07001532 clk_change_rate(child);
James Hogan71472c02013-07-29 12:25:00 +01001533 }
1534
1535 /* handle the new child who might not be in clk->children yet */
1536 if (clk->new_child)
1537 clk_change_rate(clk->new_child);
Mike Turquetteb24764902012-03-15 23:11:19 -07001538}
1539
1540/**
1541 * clk_set_rate - specify a new rate for clk
1542 * @clk: the clk whose rate is being changed
1543 * @rate: the new rate for clk
1544 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001545 * In the simplest case clk_set_rate will only adjust the rate of clk.
Mike Turquetteb24764902012-03-15 23:11:19 -07001546 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001547 * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
1548 * propagate up to clk's parent; whether or not this happens depends on the
1549 * outcome of clk's .round_rate implementation. If *parent_rate is unchanged
1550 * after calling .round_rate then upstream parent propagation is ignored. If
1551 * *parent_rate comes back with a new rate for clk's parent then we propagate
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001552 * up to clk's parent and set its rate. Upward propagation will continue
Mike Turquette5654dc92012-03-26 11:51:34 -07001553 * until either a clk does not support the CLK_SET_RATE_PARENT flag or
1554 * .round_rate stops requesting changes to clk's parent_rate.
Mike Turquetteb24764902012-03-15 23:11:19 -07001555 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001556 * Rate changes are accomplished via tree traversal that also recalculates the
1557 * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
Mike Turquetteb24764902012-03-15 23:11:19 -07001558 *
1559 * Returns 0 on success, -EERROR otherwise.
1560 */
1561int clk_set_rate(struct clk *clk, unsigned long rate)
1562{
1563 struct clk *top, *fail_clk;
1564 int ret = 0;
1565
Mike Turquette89ac8d72013-08-21 23:58:09 -07001566 if (!clk)
1567 return 0;
1568
Mike Turquetteb24764902012-03-15 23:11:19 -07001569 /* prevent racing with updates to the clock topology */
Mike Turquetteeab89f62013-03-28 13:59:01 -07001570 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001571
1572 /* bail early if nothing to do */
Peter De Schrijver34e452a2013-06-05 18:06:36 +03001573 if (rate == clk_get_rate(clk))
Mike Turquetteb24764902012-03-15 23:11:19 -07001574 goto out;
1575
Saravana Kannan7e0fa1b2012-05-15 13:43:42 -07001576 if ((clk->flags & CLK_SET_RATE_GATE) && clk->prepare_count) {
Viresh Kumar0e1c0302012-04-11 16:03:42 +05301577 ret = -EBUSY;
1578 goto out;
1579 }
1580
Mike Turquetteb24764902012-03-15 23:11:19 -07001581 /* calculate new rates and get the topmost changed clock */
1582 top = clk_calc_new_rates(clk, rate);
1583 if (!top) {
1584 ret = -EINVAL;
1585 goto out;
1586 }
1587
1588 /* notify that we are about to change rates */
1589 fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
1590 if (fail_clk) {
1591 pr_warn("%s: failed to set %s rate\n", __func__,
1592 fail_clk->name);
1593 clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
1594 ret = -EBUSY;
1595 goto out;
1596 }
1597
1598 /* change the rates */
1599 clk_change_rate(top);
1600
Mike Turquetteb24764902012-03-15 23:11:19 -07001601out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001602 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001603
1604 return ret;
1605}
1606EXPORT_SYMBOL_GPL(clk_set_rate);
1607
1608/**
1609 * clk_get_parent - return the parent of a clk
1610 * @clk: the clk whose parent gets returned
1611 *
1612 * Simply returns clk->parent. Returns NULL if clk is NULL.
1613 */
1614struct clk *clk_get_parent(struct clk *clk)
1615{
1616 struct clk *parent;
1617
Mike Turquetteeab89f62013-03-28 13:59:01 -07001618 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001619 parent = __clk_get_parent(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -07001620 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001621
1622 return parent;
1623}
1624EXPORT_SYMBOL_GPL(clk_get_parent);
1625
1626/*
1627 * .get_parent is mandatory for clocks with multiple possible parents. It is
1628 * optional for single-parent clocks. Always call .get_parent if it is
1629 * available and WARN if it is missing for multi-parent clocks.
1630 *
1631 * For single-parent clocks without .get_parent, first check to see if the
1632 * .parents array exists, and if so use it to avoid an expensive tree
1633 * traversal. If .parents does not exist then walk the tree with __clk_lookup.
1634 */
1635static struct clk *__clk_init_parent(struct clk *clk)
1636{
1637 struct clk *ret = NULL;
1638 u8 index;
1639
1640 /* handle the trivial cases */
1641
1642 if (!clk->num_parents)
1643 goto out;
1644
1645 if (clk->num_parents == 1) {
1646 if (IS_ERR_OR_NULL(clk->parent))
1647 ret = clk->parent = __clk_lookup(clk->parent_names[0]);
1648 ret = clk->parent;
1649 goto out;
1650 }
1651
1652 if (!clk->ops->get_parent) {
1653 WARN(!clk->ops->get_parent,
1654 "%s: multi-parent clocks must implement .get_parent\n",
1655 __func__);
1656 goto out;
1657 };
1658
1659 /*
1660 * Do our best to cache parent clocks in clk->parents. This prevents
1661 * unnecessary and expensive calls to __clk_lookup. We don't set
1662 * clk->parent here; that is done by the calling function
1663 */
1664
1665 index = clk->ops->get_parent(clk->hw);
1666
1667 if (!clk->parents)
1668 clk->parents =
Tomasz Figa96a7ed92013-09-29 02:37:15 +02001669 kcalloc(clk->num_parents, sizeof(struct clk *),
Mike Turquetteb24764902012-03-15 23:11:19 -07001670 GFP_KERNEL);
1671
James Hogan7ef3dcc2013-07-29 12:24:58 +01001672 ret = clk_get_parent_by_index(clk, index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001673
1674out:
1675 return ret;
1676}
1677
Ulf Hanssonb33d2122013-04-02 23:09:37 +02001678void __clk_reparent(struct clk *clk, struct clk *new_parent)
1679{
1680 clk_reparent(clk, new_parent);
1681 clk_debug_reparent(clk, new_parent);
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001682 __clk_recalc_accuracies(clk);
Mike Turquetteb24764902012-03-15 23:11:19 -07001683 __clk_recalc_rates(clk, POST_RATE_CHANGE);
1684}
1685
Mike Turquetteb24764902012-03-15 23:11:19 -07001686/**
1687 * clk_set_parent - switch the parent of a mux clk
1688 * @clk: the mux clk whose input we are switching
1689 * @parent: the new input to clk
1690 *
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001691 * Re-parent clk to use parent as its new input source. If clk is in
1692 * prepared state, the clk will get enabled for the duration of this call. If
1693 * that's not acceptable for a specific clk (Eg: the consumer can't handle
1694 * that, the reparenting is glitchy in hardware, etc), use the
1695 * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
1696 *
1697 * After successfully changing clk's parent clk_set_parent will update the
1698 * clk topology, sysfs topology and propagate rate recalculation via
1699 * __clk_recalc_rates.
1700 *
1701 * Returns 0 on success, -EERROR otherwise.
Mike Turquetteb24764902012-03-15 23:11:19 -07001702 */
1703int clk_set_parent(struct clk *clk, struct clk *parent)
1704{
1705 int ret = 0;
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001706 int p_index = 0;
Ulf Hansson031dcc92013-04-02 23:09:38 +02001707 unsigned long p_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001708
Mike Turquette89ac8d72013-08-21 23:58:09 -07001709 if (!clk)
1710 return 0;
1711
1712 if (!clk->ops)
Mike Turquetteb24764902012-03-15 23:11:19 -07001713 return -EINVAL;
1714
Ulf Hansson031dcc92013-04-02 23:09:38 +02001715 /* verify ops for for multi-parent clks */
1716 if ((clk->num_parents > 1) && (!clk->ops->set_parent))
Mike Turquetteb24764902012-03-15 23:11:19 -07001717 return -ENOSYS;
1718
1719 /* prevent racing with updates to the clock topology */
Mike Turquetteeab89f62013-03-28 13:59:01 -07001720 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001721
1722 if (clk->parent == parent)
1723 goto out;
1724
Ulf Hansson031dcc92013-04-02 23:09:38 +02001725 /* check that we are allowed to re-parent if the clock is in use */
1726 if ((clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) {
1727 ret = -EBUSY;
1728 goto out;
1729 }
1730
1731 /* try finding the new parent index */
1732 if (parent) {
1733 p_index = clk_fetch_parent_index(clk, parent);
1734 p_rate = parent->rate;
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001735 if (p_index < 0) {
Ulf Hansson031dcc92013-04-02 23:09:38 +02001736 pr_debug("%s: clk %s can not be parent of clk %s\n",
1737 __func__, parent->name, clk->name);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001738 ret = p_index;
Ulf Hansson031dcc92013-04-02 23:09:38 +02001739 goto out;
1740 }
1741 }
1742
Mike Turquetteb24764902012-03-15 23:11:19 -07001743 /* propagate PRE_RATE_CHANGE notifications */
Soren Brinkmannf3aab5d2013-04-16 10:06:50 -07001744 ret = __clk_speculate_rates(clk, p_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001745
1746 /* abort if a driver objects */
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001747 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001748 goto out;
1749
Ulf Hansson031dcc92013-04-02 23:09:38 +02001750 /* do the re-parent */
1751 ret = __clk_set_parent(clk, parent, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001752
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001753 /* propagate rate an accuracy recalculation accordingly */
1754 if (ret) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001755 __clk_recalc_rates(clk, ABORT_RATE_CHANGE);
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001756 } else {
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001757 __clk_recalc_rates(clk, POST_RATE_CHANGE);
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001758 __clk_recalc_accuracies(clk);
1759 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001760
1761out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001762 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001763
1764 return ret;
1765}
1766EXPORT_SYMBOL_GPL(clk_set_parent);
1767
1768/**
1769 * __clk_init - initialize the data structures in a struct clk
1770 * @dev: device initializing this clk, placeholder for now
1771 * @clk: clk being initialized
1772 *
1773 * Initializes the lists in struct clk, queries the hardware for the
1774 * parent and rate and sets them both.
Mike Turquetteb24764902012-03-15 23:11:19 -07001775 */
Mike Turquetted1302a32012-03-29 14:30:40 -07001776int __clk_init(struct device *dev, struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -07001777{
Mike Turquetted1302a32012-03-29 14:30:40 -07001778 int i, ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001779 struct clk *orphan;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001780 struct hlist_node *tmp2;
Mike Turquetteb24764902012-03-15 23:11:19 -07001781
1782 if (!clk)
Mike Turquetted1302a32012-03-29 14:30:40 -07001783 return -EINVAL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001784
Mike Turquetteeab89f62013-03-28 13:59:01 -07001785 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001786
1787 /* check to see if a clock with this name is already registered */
Mike Turquetted1302a32012-03-29 14:30:40 -07001788 if (__clk_lookup(clk->name)) {
1789 pr_debug("%s: clk %s already initialized\n",
1790 __func__, clk->name);
1791 ret = -EEXIST;
Mike Turquetteb24764902012-03-15 23:11:19 -07001792 goto out;
Mike Turquetted1302a32012-03-29 14:30:40 -07001793 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001794
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001795 /* check that clk_ops are sane. See Documentation/clk.txt */
1796 if (clk->ops->set_rate &&
James Hogan71472c02013-07-29 12:25:00 +01001797 !((clk->ops->round_rate || clk->ops->determine_rate) &&
1798 clk->ops->recalc_rate)) {
1799 pr_warning("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n",
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001800 __func__, clk->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07001801 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001802 goto out;
1803 }
1804
1805 if (clk->ops->set_parent && !clk->ops->get_parent) {
1806 pr_warning("%s: %s must implement .get_parent & .set_parent\n",
1807 __func__, clk->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07001808 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001809 goto out;
1810 }
1811
Stephen Boyd3fa22522014-01-15 10:47:22 -08001812 if (clk->ops->set_rate_and_parent &&
1813 !(clk->ops->set_parent && clk->ops->set_rate)) {
1814 pr_warn("%s: %s must implement .set_parent & .set_rate\n",
1815 __func__, clk->name);
1816 ret = -EINVAL;
1817 goto out;
1818 }
1819
Mike Turquetteb24764902012-03-15 23:11:19 -07001820 /* throw a WARN if any entries in parent_names are NULL */
1821 for (i = 0; i < clk->num_parents; i++)
1822 WARN(!clk->parent_names[i],
1823 "%s: invalid NULL in %s's .parent_names\n",
1824 __func__, clk->name);
1825
1826 /*
1827 * Allocate an array of struct clk *'s to avoid unnecessary string
1828 * look-ups of clk's possible parents. This can fail for clocks passed
1829 * in to clk_init during early boot; thus any access to clk->parents[]
1830 * must always check for a NULL pointer and try to populate it if
1831 * necessary.
1832 *
1833 * If clk->parents is not NULL we skip this entire block. This allows
1834 * for clock drivers to statically initialize clk->parents.
1835 */
Rajendra Nayak9ca1c5a2012-06-06 14:41:30 +05301836 if (clk->num_parents > 1 && !clk->parents) {
Tomasz Figa96a7ed92013-09-29 02:37:15 +02001837 clk->parents = kcalloc(clk->num_parents, sizeof(struct clk *),
1838 GFP_KERNEL);
Mike Turquetteb24764902012-03-15 23:11:19 -07001839 /*
1840 * __clk_lookup returns NULL for parents that have not been
1841 * clk_init'd; thus any access to clk->parents[] must check
1842 * for a NULL pointer. We can always perform lazy lookups for
1843 * missing parents later on.
1844 */
1845 if (clk->parents)
1846 for (i = 0; i < clk->num_parents; i++)
1847 clk->parents[i] =
1848 __clk_lookup(clk->parent_names[i]);
1849 }
1850
1851 clk->parent = __clk_init_parent(clk);
1852
1853 /*
1854 * Populate clk->parent if parent has already been __clk_init'd. If
1855 * parent has not yet been __clk_init'd then place clk in the orphan
1856 * list. If clk has set the CLK_IS_ROOT flag then place it in the root
1857 * clk list.
1858 *
1859 * Every time a new clk is clk_init'd then we walk the list of orphan
1860 * clocks and re-parent any that are children of the clock currently
1861 * being clk_init'd.
1862 */
1863 if (clk->parent)
1864 hlist_add_head(&clk->child_node,
1865 &clk->parent->children);
1866 else if (clk->flags & CLK_IS_ROOT)
1867 hlist_add_head(&clk->child_node, &clk_root_list);
1868 else
1869 hlist_add_head(&clk->child_node, &clk_orphan_list);
1870
1871 /*
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001872 * Set clk's accuracy. The preferred method is to use
1873 * .recalc_accuracy. For simple clocks and lazy developers the default
1874 * fallback is to use the parent's accuracy. If a clock doesn't have a
1875 * parent (or is orphaned) then accuracy is set to zero (perfect
1876 * clock).
1877 */
1878 if (clk->ops->recalc_accuracy)
1879 clk->accuracy = clk->ops->recalc_accuracy(clk->hw,
1880 __clk_get_accuracy(clk->parent));
1881 else if (clk->parent)
1882 clk->accuracy = clk->parent->accuracy;
1883 else
1884 clk->accuracy = 0;
1885
1886 /*
Mike Turquetteb24764902012-03-15 23:11:19 -07001887 * Set clk's rate. The preferred method is to use .recalc_rate. For
1888 * simple clocks and lazy developers the default fallback is to use the
1889 * parent's rate. If a clock doesn't have a parent (or is orphaned)
1890 * then rate is set to zero.
1891 */
1892 if (clk->ops->recalc_rate)
1893 clk->rate = clk->ops->recalc_rate(clk->hw,
1894 __clk_get_rate(clk->parent));
1895 else if (clk->parent)
1896 clk->rate = clk->parent->rate;
1897 else
1898 clk->rate = 0;
1899
Stephen Boyd3a5aec22013-10-16 00:40:03 -07001900 clk_debug_register(clk);
Mike Turquetteb24764902012-03-15 23:11:19 -07001901 /*
1902 * walk the list of orphan clocks and reparent any that are children of
1903 * this clock
1904 */
Sasha Levinb67bfe02013-02-27 17:06:00 -08001905 hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
Alex Elder12d298862013-09-05 08:33:24 -05001906 if (orphan->num_parents && orphan->ops->get_parent) {
Martin Fuzzey1f61e5f2012-11-22 20:15:05 +01001907 i = orphan->ops->get_parent(orphan->hw);
1908 if (!strcmp(clk->name, orphan->parent_names[i]))
1909 __clk_reparent(orphan, clk);
1910 continue;
1911 }
1912
Mike Turquetteb24764902012-03-15 23:11:19 -07001913 for (i = 0; i < orphan->num_parents; i++)
1914 if (!strcmp(clk->name, orphan->parent_names[i])) {
1915 __clk_reparent(orphan, clk);
1916 break;
1917 }
Martin Fuzzey1f61e5f2012-11-22 20:15:05 +01001918 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001919
1920 /*
1921 * optional platform-specific magic
1922 *
1923 * The .init callback is not used by any of the basic clock types, but
1924 * exists for weird hardware that must perform initialization magic.
1925 * Please consider other ways of solving initialization problems before
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001926 * using this callback, as its use is discouraged.
Mike Turquetteb24764902012-03-15 23:11:19 -07001927 */
1928 if (clk->ops->init)
1929 clk->ops->init(clk->hw);
1930
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02001931 kref_init(&clk->ref);
Mike Turquetteb24764902012-03-15 23:11:19 -07001932out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001933 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001934
Mike Turquetted1302a32012-03-29 14:30:40 -07001935 return ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07001936}
1937
1938/**
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001939 * __clk_register - register a clock and return a cookie.
1940 *
1941 * Same as clk_register, except that the .clk field inside hw shall point to a
1942 * preallocated (generally statically allocated) struct clk. None of the fields
1943 * of the struct clk need to be initialized.
1944 *
1945 * The data pointed to by .init and .clk field shall NOT be marked as init
1946 * data.
1947 *
1948 * __clk_register is only exposed via clk-private.h and is intended for use with
1949 * very large numbers of clocks that need to be statically initialized. It is
1950 * a layering violation to include clk-private.h from any code which implements
1951 * a clock's .ops; as such any statically initialized clock data MUST be in a
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001952 * separate C file from the logic that implements its operations. Returns 0
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001953 * on success, otherwise an error code.
1954 */
1955struct clk *__clk_register(struct device *dev, struct clk_hw *hw)
1956{
1957 int ret;
1958 struct clk *clk;
1959
1960 clk = hw->clk;
1961 clk->name = hw->init->name;
1962 clk->ops = hw->init->ops;
1963 clk->hw = hw;
1964 clk->flags = hw->init->flags;
1965 clk->parent_names = hw->init->parent_names;
1966 clk->num_parents = hw->init->num_parents;
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02001967 if (dev && dev->driver)
1968 clk->owner = dev->driver->owner;
1969 else
1970 clk->owner = NULL;
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001971
1972 ret = __clk_init(dev, clk);
1973 if (ret)
1974 return ERR_PTR(ret);
1975
1976 return clk;
1977}
1978EXPORT_SYMBOL_GPL(__clk_register);
1979
Stephen Boyd46c87732012-09-24 13:38:04 -07001980static int _clk_register(struct device *dev, struct clk_hw *hw, struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -07001981{
Mike Turquetted1302a32012-03-29 14:30:40 -07001982 int i, ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07001983
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001984 clk->name = kstrdup(hw->init->name, GFP_KERNEL);
1985 if (!clk->name) {
1986 pr_err("%s: could not allocate clk->name\n", __func__);
1987 ret = -ENOMEM;
1988 goto fail_name;
1989 }
1990 clk->ops = hw->init->ops;
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02001991 if (dev && dev->driver)
1992 clk->owner = dev->driver->owner;
Mike Turquetteb24764902012-03-15 23:11:19 -07001993 clk->hw = hw;
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001994 clk->flags = hw->init->flags;
1995 clk->num_parents = hw->init->num_parents;
Mike Turquetteb24764902012-03-15 23:11:19 -07001996 hw->clk = clk;
1997
Mike Turquetted1302a32012-03-29 14:30:40 -07001998 /* allocate local copy in case parent_names is __initdata */
Tomasz Figa96a7ed92013-09-29 02:37:15 +02001999 clk->parent_names = kcalloc(clk->num_parents, sizeof(char *),
2000 GFP_KERNEL);
Mike Turquetteb24764902012-03-15 23:11:19 -07002001
Mike Turquetted1302a32012-03-29 14:30:40 -07002002 if (!clk->parent_names) {
2003 pr_err("%s: could not allocate clk->parent_names\n", __func__);
2004 ret = -ENOMEM;
2005 goto fail_parent_names;
2006 }
2007
2008
2009 /* copy each string name in case parent_names is __initdata */
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002010 for (i = 0; i < clk->num_parents; i++) {
2011 clk->parent_names[i] = kstrdup(hw->init->parent_names[i],
2012 GFP_KERNEL);
Mike Turquetted1302a32012-03-29 14:30:40 -07002013 if (!clk->parent_names[i]) {
2014 pr_err("%s: could not copy parent_names\n", __func__);
2015 ret = -ENOMEM;
2016 goto fail_parent_names_copy;
2017 }
2018 }
2019
2020 ret = __clk_init(dev, clk);
2021 if (!ret)
Stephen Boyd46c87732012-09-24 13:38:04 -07002022 return 0;
Mike Turquetted1302a32012-03-29 14:30:40 -07002023
2024fail_parent_names_copy:
2025 while (--i >= 0)
2026 kfree(clk->parent_names[i]);
2027 kfree(clk->parent_names);
2028fail_parent_names:
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002029 kfree(clk->name);
2030fail_name:
Stephen Boyd46c87732012-09-24 13:38:04 -07002031 return ret;
2032}
2033
2034/**
2035 * clk_register - allocate a new clock, register it and return an opaque cookie
2036 * @dev: device that is registering this clock
2037 * @hw: link to hardware-specific clock data
2038 *
2039 * clk_register is the primary interface for populating the clock tree with new
2040 * clock nodes. It returns a pointer to the newly allocated struct clk which
2041 * cannot be dereferenced by driver code but may be used in conjuction with the
2042 * rest of the clock API. In the event of an error clk_register will return an
2043 * error code; drivers must test for an error code after calling clk_register.
2044 */
2045struct clk *clk_register(struct device *dev, struct clk_hw *hw)
2046{
2047 int ret;
2048 struct clk *clk;
2049
2050 clk = kzalloc(sizeof(*clk), GFP_KERNEL);
2051 if (!clk) {
2052 pr_err("%s: could not allocate clk\n", __func__);
2053 ret = -ENOMEM;
2054 goto fail_out;
2055 }
2056
2057 ret = _clk_register(dev, hw, clk);
2058 if (!ret)
2059 return clk;
2060
Mike Turquetted1302a32012-03-29 14:30:40 -07002061 kfree(clk);
2062fail_out:
2063 return ERR_PTR(ret);
Mike Turquetteb24764902012-03-15 23:11:19 -07002064}
2065EXPORT_SYMBOL_GPL(clk_register);
2066
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002067/*
2068 * Free memory allocated for a clock.
2069 * Caller must hold prepare_lock.
2070 */
2071static void __clk_release(struct kref *ref)
2072{
2073 struct clk *clk = container_of(ref, struct clk, ref);
2074 int i = clk->num_parents;
2075
2076 kfree(clk->parents);
2077 while (--i >= 0)
2078 kfree(clk->parent_names[i]);
2079
2080 kfree(clk->parent_names);
2081 kfree(clk->name);
2082 kfree(clk);
2083}
2084
2085/*
2086 * Empty clk_ops for unregistered clocks. These are used temporarily
2087 * after clk_unregister() was called on a clock and until last clock
2088 * consumer calls clk_put() and the struct clk object is freed.
2089 */
2090static int clk_nodrv_prepare_enable(struct clk_hw *hw)
2091{
2092 return -ENXIO;
2093}
2094
2095static void clk_nodrv_disable_unprepare(struct clk_hw *hw)
2096{
2097 WARN_ON_ONCE(1);
2098}
2099
2100static int clk_nodrv_set_rate(struct clk_hw *hw, unsigned long rate,
2101 unsigned long parent_rate)
2102{
2103 return -ENXIO;
2104}
2105
2106static int clk_nodrv_set_parent(struct clk_hw *hw, u8 index)
2107{
2108 return -ENXIO;
2109}
2110
2111static const struct clk_ops clk_nodrv_ops = {
2112 .enable = clk_nodrv_prepare_enable,
2113 .disable = clk_nodrv_disable_unprepare,
2114 .prepare = clk_nodrv_prepare_enable,
2115 .unprepare = clk_nodrv_disable_unprepare,
2116 .set_rate = clk_nodrv_set_rate,
2117 .set_parent = clk_nodrv_set_parent,
2118};
2119
Mark Brown1df5c932012-04-18 09:07:12 +01002120/**
2121 * clk_unregister - unregister a currently registered clock
2122 * @clk: clock to unregister
Mark Brown1df5c932012-04-18 09:07:12 +01002123 */
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002124void clk_unregister(struct clk *clk)
2125{
2126 unsigned long flags;
2127
2128 if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
2129 return;
2130
2131 clk_prepare_lock();
2132
2133 if (clk->ops == &clk_nodrv_ops) {
2134 pr_err("%s: unregistered clock: %s\n", __func__, clk->name);
2135 goto out;
2136 }
2137 /*
2138 * Assign empty clock ops for consumers that might still hold
2139 * a reference to this clock.
2140 */
2141 flags = clk_enable_lock();
2142 clk->ops = &clk_nodrv_ops;
2143 clk_enable_unlock(flags);
2144
2145 if (!hlist_empty(&clk->children)) {
2146 struct clk *child;
2147
2148 /* Reparent all children to the orphan list. */
2149 hlist_for_each_entry(child, &clk->children, child_node)
2150 clk_set_parent(child, NULL);
2151 }
2152
2153 clk_debug_unregister(clk);
2154
2155 hlist_del_init(&clk->child_node);
2156
2157 if (clk->prepare_count)
2158 pr_warn("%s: unregistering prepared clock: %s\n",
2159 __func__, clk->name);
2160
2161 kref_put(&clk->ref, __clk_release);
2162out:
2163 clk_prepare_unlock();
2164}
Mark Brown1df5c932012-04-18 09:07:12 +01002165EXPORT_SYMBOL_GPL(clk_unregister);
2166
Stephen Boyd46c87732012-09-24 13:38:04 -07002167static void devm_clk_release(struct device *dev, void *res)
2168{
2169 clk_unregister(res);
2170}
2171
2172/**
2173 * devm_clk_register - resource managed clk_register()
2174 * @dev: device that is registering this clock
2175 * @hw: link to hardware-specific clock data
2176 *
2177 * Managed clk_register(). Clocks returned from this function are
2178 * automatically clk_unregister()ed on driver detach. See clk_register() for
2179 * more information.
2180 */
2181struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw)
2182{
2183 struct clk *clk;
2184 int ret;
2185
2186 clk = devres_alloc(devm_clk_release, sizeof(*clk), GFP_KERNEL);
2187 if (!clk)
2188 return ERR_PTR(-ENOMEM);
2189
2190 ret = _clk_register(dev, hw, clk);
2191 if (!ret) {
2192 devres_add(dev, clk);
2193 } else {
2194 devres_free(clk);
2195 clk = ERR_PTR(ret);
2196 }
2197
2198 return clk;
2199}
2200EXPORT_SYMBOL_GPL(devm_clk_register);
2201
2202static int devm_clk_match(struct device *dev, void *res, void *data)
2203{
2204 struct clk *c = res;
2205 if (WARN_ON(!c))
2206 return 0;
2207 return c == data;
2208}
2209
2210/**
2211 * devm_clk_unregister - resource managed clk_unregister()
2212 * @clk: clock to unregister
2213 *
2214 * Deallocate a clock allocated with devm_clk_register(). Normally
2215 * this function will not need to be called and the resource management
2216 * code will ensure that the resource is freed.
2217 */
2218void devm_clk_unregister(struct device *dev, struct clk *clk)
2219{
2220 WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk));
2221}
2222EXPORT_SYMBOL_GPL(devm_clk_unregister);
2223
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002224/*
2225 * clkdev helpers
2226 */
2227int __clk_get(struct clk *clk)
2228{
2229 if (clk && !try_module_get(clk->owner))
2230 return 0;
2231
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002232 kref_get(&clk->ref);
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002233 return 1;
2234}
2235
2236void __clk_put(struct clk *clk)
2237{
2238 if (WARN_ON_ONCE(IS_ERR(clk)))
2239 return;
2240
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002241 clk_prepare_lock();
2242 kref_put(&clk->ref, __clk_release);
2243 clk_prepare_unlock();
2244
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002245 if (clk)
2246 module_put(clk->owner);
2247}
2248
Mike Turquetteb24764902012-03-15 23:11:19 -07002249/*** clk rate change notifiers ***/
2250
2251/**
2252 * clk_notifier_register - add a clk rate change notifier
2253 * @clk: struct clk * to watch
2254 * @nb: struct notifier_block * with callback info
2255 *
2256 * Request notification when clk's rate changes. This uses an SRCU
2257 * notifier because we want it to block and notifier unregistrations are
2258 * uncommon. The callbacks associated with the notifier must not
2259 * re-enter into the clk framework by calling any top-level clk APIs;
2260 * this will cause a nested prepare_lock mutex.
2261 *
Soren Brinkmann5324fda2014-01-22 11:48:37 -08002262 * In all notification cases cases (pre, post and abort rate change) the
2263 * original clock rate is passed to the callback via struct
2264 * clk_notifier_data.old_rate and the new frequency is passed via struct
Mike Turquetteb24764902012-03-15 23:11:19 -07002265 * clk_notifier_data.new_rate.
2266 *
Mike Turquetteb24764902012-03-15 23:11:19 -07002267 * clk_notifier_register() must be called from non-atomic context.
2268 * Returns -EINVAL if called with null arguments, -ENOMEM upon
2269 * allocation failure; otherwise, passes along the return value of
2270 * srcu_notifier_chain_register().
2271 */
2272int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
2273{
2274 struct clk_notifier *cn;
2275 int ret = -ENOMEM;
2276
2277 if (!clk || !nb)
2278 return -EINVAL;
2279
Mike Turquetteeab89f62013-03-28 13:59:01 -07002280 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002281
2282 /* search the list of notifiers for this clk */
2283 list_for_each_entry(cn, &clk_notifier_list, node)
2284 if (cn->clk == clk)
2285 break;
2286
2287 /* if clk wasn't in the notifier list, allocate new clk_notifier */
2288 if (cn->clk != clk) {
2289 cn = kzalloc(sizeof(struct clk_notifier), GFP_KERNEL);
2290 if (!cn)
2291 goto out;
2292
2293 cn->clk = clk;
2294 srcu_init_notifier_head(&cn->notifier_head);
2295
2296 list_add(&cn->node, &clk_notifier_list);
2297 }
2298
2299 ret = srcu_notifier_chain_register(&cn->notifier_head, nb);
2300
2301 clk->notifier_count++;
2302
2303out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07002304 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002305
2306 return ret;
2307}
2308EXPORT_SYMBOL_GPL(clk_notifier_register);
2309
2310/**
2311 * clk_notifier_unregister - remove a clk rate change notifier
2312 * @clk: struct clk *
2313 * @nb: struct notifier_block * with callback info
2314 *
2315 * Request no further notification for changes to 'clk' and frees memory
2316 * allocated in clk_notifier_register.
2317 *
2318 * Returns -EINVAL if called with null arguments; otherwise, passes
2319 * along the return value of srcu_notifier_chain_unregister().
2320 */
2321int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
2322{
2323 struct clk_notifier *cn = NULL;
2324 int ret = -EINVAL;
2325
2326 if (!clk || !nb)
2327 return -EINVAL;
2328
Mike Turquetteeab89f62013-03-28 13:59:01 -07002329 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002330
2331 list_for_each_entry(cn, &clk_notifier_list, node)
2332 if (cn->clk == clk)
2333 break;
2334
2335 if (cn->clk == clk) {
2336 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb);
2337
2338 clk->notifier_count--;
2339
2340 /* XXX the notifier code should handle this better */
2341 if (!cn->notifier_head.head) {
2342 srcu_cleanup_notifier_head(&cn->notifier_head);
Lai Jiangshan72b53222013-06-03 17:17:15 +08002343 list_del(&cn->node);
Mike Turquetteb24764902012-03-15 23:11:19 -07002344 kfree(cn);
2345 }
2346
2347 } else {
2348 ret = -ENOENT;
2349 }
2350
Mike Turquetteeab89f62013-03-28 13:59:01 -07002351 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002352
2353 return ret;
2354}
2355EXPORT_SYMBOL_GPL(clk_notifier_unregister);
Grant Likely766e6a42012-04-09 14:50:06 -05002356
2357#ifdef CONFIG_OF
2358/**
2359 * struct of_clk_provider - Clock provider registration structure
2360 * @link: Entry in global list of clock providers
2361 * @node: Pointer to device tree node of clock provider
2362 * @get: Get clock callback. Returns NULL or a struct clk for the
2363 * given clock specifier
2364 * @data: context pointer to be passed into @get callback
2365 */
2366struct of_clk_provider {
2367 struct list_head link;
2368
2369 struct device_node *node;
2370 struct clk *(*get)(struct of_phandle_args *clkspec, void *data);
2371 void *data;
2372};
2373
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05302374static const struct of_device_id __clk_of_table_sentinel
2375 __used __section(__clk_of_table_end);
2376
Grant Likely766e6a42012-04-09 14:50:06 -05002377static LIST_HEAD(of_clk_providers);
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002378static DEFINE_MUTEX(of_clk_mutex);
2379
2380/* of_clk_provider list locking helpers */
2381void of_clk_lock(void)
2382{
2383 mutex_lock(&of_clk_mutex);
2384}
2385
2386void of_clk_unlock(void)
2387{
2388 mutex_unlock(&of_clk_mutex);
2389}
Grant Likely766e6a42012-04-09 14:50:06 -05002390
2391struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
2392 void *data)
2393{
2394 return data;
2395}
2396EXPORT_SYMBOL_GPL(of_clk_src_simple_get);
2397
Shawn Guo494bfec2012-08-22 21:36:27 +08002398struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data)
2399{
2400 struct clk_onecell_data *clk_data = data;
2401 unsigned int idx = clkspec->args[0];
2402
2403 if (idx >= clk_data->clk_num) {
2404 pr_err("%s: invalid clock index %d\n", __func__, idx);
2405 return ERR_PTR(-EINVAL);
2406 }
2407
2408 return clk_data->clks[idx];
2409}
2410EXPORT_SYMBOL_GPL(of_clk_src_onecell_get);
2411
Grant Likely766e6a42012-04-09 14:50:06 -05002412/**
2413 * of_clk_add_provider() - Register a clock provider for a node
2414 * @np: Device node pointer associated with clock provider
2415 * @clk_src_get: callback for decoding clock
2416 * @data: context pointer for @clk_src_get callback.
2417 */
2418int of_clk_add_provider(struct device_node *np,
2419 struct clk *(*clk_src_get)(struct of_phandle_args *clkspec,
2420 void *data),
2421 void *data)
2422{
2423 struct of_clk_provider *cp;
2424
2425 cp = kzalloc(sizeof(struct of_clk_provider), GFP_KERNEL);
2426 if (!cp)
2427 return -ENOMEM;
2428
2429 cp->node = of_node_get(np);
2430 cp->data = data;
2431 cp->get = clk_src_get;
2432
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002433 mutex_lock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002434 list_add(&cp->link, &of_clk_providers);
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002435 mutex_unlock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002436 pr_debug("Added clock from %s\n", np->full_name);
2437
2438 return 0;
2439}
2440EXPORT_SYMBOL_GPL(of_clk_add_provider);
2441
2442/**
2443 * of_clk_del_provider() - Remove a previously registered clock provider
2444 * @np: Device node pointer associated with clock provider
2445 */
2446void of_clk_del_provider(struct device_node *np)
2447{
2448 struct of_clk_provider *cp;
2449
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002450 mutex_lock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002451 list_for_each_entry(cp, &of_clk_providers, link) {
2452 if (cp->node == np) {
2453 list_del(&cp->link);
2454 of_node_put(cp->node);
2455 kfree(cp);
2456 break;
2457 }
2458 }
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002459 mutex_unlock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002460}
2461EXPORT_SYMBOL_GPL(of_clk_del_provider);
2462
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002463struct clk *__of_clk_get_from_provider(struct of_phandle_args *clkspec)
Grant Likely766e6a42012-04-09 14:50:06 -05002464{
2465 struct of_clk_provider *provider;
2466 struct clk *clk = ERR_PTR(-ENOENT);
2467
2468 /* Check if we have such a provider in our array */
Grant Likely766e6a42012-04-09 14:50:06 -05002469 list_for_each_entry(provider, &of_clk_providers, link) {
2470 if (provider->node == clkspec->np)
2471 clk = provider->get(clkspec, provider->data);
2472 if (!IS_ERR(clk))
2473 break;
2474 }
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002475
2476 return clk;
2477}
2478
2479struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
2480{
2481 struct clk *clk;
2482
2483 mutex_lock(&of_clk_mutex);
2484 clk = __of_clk_get_from_provider(clkspec);
2485 mutex_unlock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002486
2487 return clk;
2488}
2489
Mike Turquettef6102742013-10-07 23:12:13 -07002490int of_clk_get_parent_count(struct device_node *np)
2491{
2492 return of_count_phandle_with_args(np, "clocks", "#clock-cells");
2493}
2494EXPORT_SYMBOL_GPL(of_clk_get_parent_count);
2495
Grant Likely766e6a42012-04-09 14:50:06 -05002496const char *of_clk_get_parent_name(struct device_node *np, int index)
2497{
2498 struct of_phandle_args clkspec;
2499 const char *clk_name;
2500 int rc;
2501
2502 if (index < 0)
2503 return NULL;
2504
2505 rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
2506 &clkspec);
2507 if (rc)
2508 return NULL;
2509
2510 if (of_property_read_string_index(clkspec.np, "clock-output-names",
2511 clkspec.args_count ? clkspec.args[0] : 0,
2512 &clk_name) < 0)
2513 clk_name = clkspec.np->name;
2514
2515 of_node_put(clkspec.np);
2516 return clk_name;
2517}
2518EXPORT_SYMBOL_GPL(of_clk_get_parent_name);
2519
2520/**
2521 * of_clk_init() - Scan and init clock providers from the DT
2522 * @matches: array of compatible values and init functions for providers.
2523 *
2524 * This function scans the device tree for matching clock providers and
2525 * calls their initialization functions
2526 */
2527void __init of_clk_init(const struct of_device_id *matches)
2528{
Alex Elder7f7ed582013-08-22 11:31:31 -05002529 const struct of_device_id *match;
Grant Likely766e6a42012-04-09 14:50:06 -05002530 struct device_node *np;
2531
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05302532 if (!matches)
Tero Kristo819b4862013-10-22 11:39:36 +03002533 matches = &__clk_of_table;
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05302534
Alex Elder7f7ed582013-08-22 11:31:31 -05002535 for_each_matching_node_and_match(np, matches, &match) {
Grant Likely766e6a42012-04-09 14:50:06 -05002536 of_clk_init_cb_t clk_init_cb = match->data;
2537 clk_init_cb(np);
2538 }
2539}
2540#endif