blob: 58ef3dab894a1ef56f7042081eedef1a2bcbf1e2 [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
Stephen Boyd3c373112015-06-19 15:00:46 -070012#include <linux/clk.h>
Michael Turquetteb09d6d92015-01-29 14:22:50 -080013#include <linux/clk-provider.h>
Sylwester Nawrocki86be4082014-06-18 17:29:32 +020014#include <linux/clk/clk-conf.h>
Mike Turquetteb24764902012-03-15 23:11:19 -070015#include <linux/module.h>
16#include <linux/mutex.h>
17#include <linux/spinlock.h>
18#include <linux/err.h>
19#include <linux/list.h>
20#include <linux/slab.h>
Grant Likely766e6a42012-04-09 14:50:06 -050021#include <linux/of.h>
Stephen Boyd46c87732012-09-24 13:38:04 -070022#include <linux/device.h>
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +053023#include <linux/init.h>
Mike Turquette533ddeb2013-03-28 13:59:02 -070024#include <linux/sched.h>
Stephen Boyd562ef0b2015-05-01 12:16:14 -070025#include <linux/clkdev.h>
Mike Turquetteb24764902012-03-15 23:11:19 -070026
Sylwester Nawrockid6782c22013-08-23 17:03:43 +020027#include "clk.h"
28
Mike Turquetteb24764902012-03-15 23:11:19 -070029static DEFINE_SPINLOCK(enable_lock);
30static DEFINE_MUTEX(prepare_lock);
31
Mike Turquette533ddeb2013-03-28 13:59:02 -070032static struct task_struct *prepare_owner;
33static struct task_struct *enable_owner;
34
35static int prepare_refcnt;
36static int enable_refcnt;
37
Mike Turquetteb24764902012-03-15 23:11:19 -070038static HLIST_HEAD(clk_root_list);
39static HLIST_HEAD(clk_orphan_list);
40static LIST_HEAD(clk_notifier_list);
41
Michael Turquetteb09d6d92015-01-29 14:22:50 -080042/*** private data structures ***/
43
44struct clk_core {
45 const char *name;
46 const struct clk_ops *ops;
47 struct clk_hw *hw;
48 struct module *owner;
49 struct clk_core *parent;
50 const char **parent_names;
51 struct clk_core **parents;
52 u8 num_parents;
53 u8 new_parent_index;
54 unsigned long rate;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +010055 unsigned long req_rate;
Michael Turquetteb09d6d92015-01-29 14:22:50 -080056 unsigned long new_rate;
57 struct clk_core *new_parent;
58 struct clk_core *new_child;
59 unsigned long flags;
Heiko Stuebnere6500342015-04-22 22:53:05 +020060 bool orphan;
Michael Turquetteb09d6d92015-01-29 14:22:50 -080061 unsigned int enable_count;
62 unsigned int prepare_count;
Stephen Boyd9783c0d2015-07-16 12:50:27 -070063 unsigned long min_rate;
64 unsigned long max_rate;
Michael Turquetteb09d6d92015-01-29 14:22:50 -080065 unsigned long accuracy;
66 int phase;
67 struct hlist_head children;
68 struct hlist_node child_node;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +010069 struct hlist_head clks;
Michael Turquetteb09d6d92015-01-29 14:22:50 -080070 unsigned int notifier_count;
71#ifdef CONFIG_DEBUG_FS
72 struct dentry *dentry;
Maxime Coquelin8c9a8a82015-06-10 13:28:27 +020073 struct hlist_node debug_node;
Michael Turquetteb09d6d92015-01-29 14:22:50 -080074#endif
75 struct kref ref;
76};
77
Stephen Boyddfc202e2015-02-02 14:37:41 -080078#define CREATE_TRACE_POINTS
79#include <trace/events/clk.h>
80
Michael Turquetteb09d6d92015-01-29 14:22:50 -080081struct clk {
82 struct clk_core *core;
83 const char *dev_id;
84 const char *con_id;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +010085 unsigned long min_rate;
86 unsigned long max_rate;
Stephen Boyd50595f82015-02-06 11:42:44 -080087 struct hlist_node clks_node;
Michael Turquetteb09d6d92015-01-29 14:22:50 -080088};
89
Mike Turquetteeab89f62013-03-28 13:59:01 -070090/*** locking ***/
91static void clk_prepare_lock(void)
92{
Mike Turquette533ddeb2013-03-28 13:59:02 -070093 if (!mutex_trylock(&prepare_lock)) {
94 if (prepare_owner == current) {
95 prepare_refcnt++;
96 return;
97 }
98 mutex_lock(&prepare_lock);
99 }
100 WARN_ON_ONCE(prepare_owner != NULL);
101 WARN_ON_ONCE(prepare_refcnt != 0);
102 prepare_owner = current;
103 prepare_refcnt = 1;
Mike Turquetteeab89f62013-03-28 13:59:01 -0700104}
105
106static void clk_prepare_unlock(void)
107{
Mike Turquette533ddeb2013-03-28 13:59:02 -0700108 WARN_ON_ONCE(prepare_owner != current);
109 WARN_ON_ONCE(prepare_refcnt == 0);
110
111 if (--prepare_refcnt)
112 return;
113 prepare_owner = NULL;
Mike Turquetteeab89f62013-03-28 13:59:01 -0700114 mutex_unlock(&prepare_lock);
115}
116
117static unsigned long clk_enable_lock(void)
Stephen Boyda57aa182015-07-24 12:24:48 -0700118 __acquires(enable_lock)
Mike Turquetteeab89f62013-03-28 13:59:01 -0700119{
120 unsigned long flags;
Mike Turquette533ddeb2013-03-28 13:59:02 -0700121
122 if (!spin_trylock_irqsave(&enable_lock, flags)) {
123 if (enable_owner == current) {
124 enable_refcnt++;
Stephen Boyda57aa182015-07-24 12:24:48 -0700125 __acquire(enable_lock);
Mike Turquette533ddeb2013-03-28 13:59:02 -0700126 return flags;
127 }
128 spin_lock_irqsave(&enable_lock, flags);
129 }
130 WARN_ON_ONCE(enable_owner != NULL);
131 WARN_ON_ONCE(enable_refcnt != 0);
132 enable_owner = current;
133 enable_refcnt = 1;
Mike Turquetteeab89f62013-03-28 13:59:01 -0700134 return flags;
135}
136
137static void clk_enable_unlock(unsigned long flags)
Stephen Boyda57aa182015-07-24 12:24:48 -0700138 __releases(enable_lock)
Mike Turquetteeab89f62013-03-28 13:59:01 -0700139{
Mike Turquette533ddeb2013-03-28 13:59:02 -0700140 WARN_ON_ONCE(enable_owner != current);
141 WARN_ON_ONCE(enable_refcnt == 0);
142
Stephen Boyda57aa182015-07-24 12:24:48 -0700143 if (--enable_refcnt) {
144 __release(enable_lock);
Mike Turquette533ddeb2013-03-28 13:59:02 -0700145 return;
Stephen Boyda57aa182015-07-24 12:24:48 -0700146 }
Mike Turquette533ddeb2013-03-28 13:59:02 -0700147 enable_owner = NULL;
Mike Turquetteeab89f62013-03-28 13:59:01 -0700148 spin_unlock_irqrestore(&enable_lock, flags);
149}
150
Stephen Boyd4dff95d2015-04-30 14:43:22 -0700151static bool clk_core_is_prepared(struct clk_core *core)
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530152{
Stephen Boyd4dff95d2015-04-30 14:43:22 -0700153 /*
154 * .is_prepared is optional for clocks that can prepare
155 * fall back to software usage counter if it is missing
156 */
157 if (!core->ops->is_prepared)
158 return core->prepare_count;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530159
Stephen Boyd4dff95d2015-04-30 14:43:22 -0700160 return core->ops->is_prepared(core->hw);
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530161}
162
Stephen Boyd4dff95d2015-04-30 14:43:22 -0700163static bool clk_core_is_enabled(struct clk_core *core)
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530164{
Stephen Boyd4dff95d2015-04-30 14:43:22 -0700165 /*
166 * .is_enabled is only mandatory for clocks that gate
167 * fall back to software usage counter if .is_enabled is missing
168 */
169 if (!core->ops->is_enabled)
170 return core->enable_count;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530171
Stephen Boyd4dff95d2015-04-30 14:43:22 -0700172 return core->ops->is_enabled(core->hw);
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530173}
174
Stephen Boydd6968fc2015-04-30 13:54:13 -0700175static void clk_unprepare_unused_subtree(struct clk_core *core)
Ulf Hansson1c155b32013-03-12 20:26:03 +0100176{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100177 struct clk_core *child;
Ulf Hansson1c155b32013-03-12 20:26:03 +0100178
Krzysztof Kozlowski496eadf2015-01-09 09:28:10 +0100179 lockdep_assert_held(&prepare_lock);
180
Stephen Boydd6968fc2015-04-30 13:54:13 -0700181 hlist_for_each_entry(child, &core->children, child_node)
Ulf Hansson1c155b32013-03-12 20:26:03 +0100182 clk_unprepare_unused_subtree(child);
183
Stephen Boydd6968fc2015-04-30 13:54:13 -0700184 if (core->prepare_count)
Ulf Hansson1c155b32013-03-12 20:26:03 +0100185 return;
186
Stephen Boydd6968fc2015-04-30 13:54:13 -0700187 if (core->flags & CLK_IGNORE_UNUSED)
Ulf Hansson1c155b32013-03-12 20:26:03 +0100188 return;
189
Stephen Boydd6968fc2015-04-30 13:54:13 -0700190 if (clk_core_is_prepared(core)) {
191 trace_clk_unprepare(core);
192 if (core->ops->unprepare_unused)
193 core->ops->unprepare_unused(core->hw);
194 else if (core->ops->unprepare)
195 core->ops->unprepare(core->hw);
196 trace_clk_unprepare_complete(core);
Ulf Hansson3cc82472013-03-12 20:26:04 +0100197 }
Ulf Hansson1c155b32013-03-12 20:26:03 +0100198}
199
Stephen Boydd6968fc2015-04-30 13:54:13 -0700200static void clk_disable_unused_subtree(struct clk_core *core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700201{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100202 struct clk_core *child;
Mike Turquetteb24764902012-03-15 23:11:19 -0700203 unsigned long flags;
204
Krzysztof Kozlowski496eadf2015-01-09 09:28:10 +0100205 lockdep_assert_held(&prepare_lock);
206
Stephen Boydd6968fc2015-04-30 13:54:13 -0700207 hlist_for_each_entry(child, &core->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700208 clk_disable_unused_subtree(child);
209
Mike Turquetteeab89f62013-03-28 13:59:01 -0700210 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700211
Stephen Boydd6968fc2015-04-30 13:54:13 -0700212 if (core->enable_count)
Mike Turquetteb24764902012-03-15 23:11:19 -0700213 goto unlock_out;
214
Stephen Boydd6968fc2015-04-30 13:54:13 -0700215 if (core->flags & CLK_IGNORE_UNUSED)
Mike Turquetteb24764902012-03-15 23:11:19 -0700216 goto unlock_out;
217
Mike Turquette7c045a52012-12-04 11:00:35 -0800218 /*
219 * some gate clocks have special needs during the disable-unused
220 * sequence. call .disable_unused if available, otherwise fall
221 * back to .disable
222 */
Stephen Boydd6968fc2015-04-30 13:54:13 -0700223 if (clk_core_is_enabled(core)) {
224 trace_clk_disable(core);
225 if (core->ops->disable_unused)
226 core->ops->disable_unused(core->hw);
227 else if (core->ops->disable)
228 core->ops->disable(core->hw);
229 trace_clk_disable_complete(core);
Mike Turquette7c045a52012-12-04 11:00:35 -0800230 }
Mike Turquetteb24764902012-03-15 23:11:19 -0700231
232unlock_out:
Mike Turquetteeab89f62013-03-28 13:59:01 -0700233 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700234}
235
Olof Johansson1e435252013-04-27 14:10:18 -0700236static bool clk_ignore_unused;
237static int __init clk_ignore_unused_setup(char *__unused)
238{
239 clk_ignore_unused = true;
240 return 1;
241}
242__setup("clk_ignore_unused", clk_ignore_unused_setup);
243
Mike Turquetteb24764902012-03-15 23:11:19 -0700244static int clk_disable_unused(void)
245{
Stephen Boydd6968fc2015-04-30 13:54:13 -0700246 struct clk_core *core;
Mike Turquetteb24764902012-03-15 23:11:19 -0700247
Olof Johansson1e435252013-04-27 14:10:18 -0700248 if (clk_ignore_unused) {
249 pr_warn("clk: Not disabling unused clocks\n");
250 return 0;
251 }
252
Mike Turquetteeab89f62013-03-28 13:59:01 -0700253 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700254
Stephen Boydd6968fc2015-04-30 13:54:13 -0700255 hlist_for_each_entry(core, &clk_root_list, child_node)
256 clk_disable_unused_subtree(core);
Mike Turquetteb24764902012-03-15 23:11:19 -0700257
Stephen Boydd6968fc2015-04-30 13:54:13 -0700258 hlist_for_each_entry(core, &clk_orphan_list, child_node)
259 clk_disable_unused_subtree(core);
Mike Turquetteb24764902012-03-15 23:11:19 -0700260
Stephen Boydd6968fc2015-04-30 13:54:13 -0700261 hlist_for_each_entry(core, &clk_root_list, child_node)
262 clk_unprepare_unused_subtree(core);
Ulf Hansson1c155b32013-03-12 20:26:03 +0100263
Stephen Boydd6968fc2015-04-30 13:54:13 -0700264 hlist_for_each_entry(core, &clk_orphan_list, child_node)
265 clk_unprepare_unused_subtree(core);
Ulf Hansson1c155b32013-03-12 20:26:03 +0100266
Mike Turquetteeab89f62013-03-28 13:59:01 -0700267 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700268
269 return 0;
270}
Saravana Kannand41d5802013-05-09 11:35:01 -0700271late_initcall_sync(clk_disable_unused);
Mike Turquetteb24764902012-03-15 23:11:19 -0700272
273/*** helper functions ***/
274
Geert Uytterhoevenb76281c2015-10-16 14:35:21 +0200275const char *__clk_get_name(const struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700276{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100277 return !clk ? NULL : clk->core->name;
Mike Turquetteb24764902012-03-15 23:11:19 -0700278}
Niels de Vos48950842012-12-13 13:12:25 +0100279EXPORT_SYMBOL_GPL(__clk_get_name);
Mike Turquetteb24764902012-03-15 23:11:19 -0700280
Stephen Boyde7df6f62015-08-12 13:04:56 -0700281const char *clk_hw_get_name(const struct clk_hw *hw)
Stephen Boyd1a9c0692015-06-25 15:55:14 -0700282{
283 return hw->core->name;
284}
285EXPORT_SYMBOL_GPL(clk_hw_get_name);
286
Russ Dill65800b22012-11-26 11:20:09 -0800287struct clk_hw *__clk_get_hw(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700288{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100289 return !clk ? NULL : clk->core->hw;
Mike Turquetteb24764902012-03-15 23:11:19 -0700290}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800291EXPORT_SYMBOL_GPL(__clk_get_hw);
Mike Turquetteb24764902012-03-15 23:11:19 -0700292
Stephen Boyde7df6f62015-08-12 13:04:56 -0700293unsigned int clk_hw_get_num_parents(const struct clk_hw *hw)
Stephen Boyd1a9c0692015-06-25 15:55:14 -0700294{
295 return hw->core->num_parents;
296}
297EXPORT_SYMBOL_GPL(clk_hw_get_num_parents);
298
Stephen Boyde7df6f62015-08-12 13:04:56 -0700299struct clk_hw *clk_hw_get_parent(const struct clk_hw *hw)
Stephen Boyd1a9c0692015-06-25 15:55:14 -0700300{
301 return hw->core->parent ? hw->core->parent->hw : NULL;
302}
303EXPORT_SYMBOL_GPL(clk_hw_get_parent);
304
Stephen Boyd4dff95d2015-04-30 14:43:22 -0700305static struct clk_core *__clk_lookup_subtree(const char *name,
306 struct clk_core *core)
307{
308 struct clk_core *child;
309 struct clk_core *ret;
310
311 if (!strcmp(core->name, name))
312 return core;
313
314 hlist_for_each_entry(child, &core->children, child_node) {
315 ret = __clk_lookup_subtree(name, child);
316 if (ret)
317 return ret;
318 }
319
320 return NULL;
321}
322
323static struct clk_core *clk_core_lookup(const char *name)
324{
325 struct clk_core *root_clk;
326 struct clk_core *ret;
327
328 if (!name)
329 return NULL;
330
331 /* search the 'proper' clk tree first */
332 hlist_for_each_entry(root_clk, &clk_root_list, child_node) {
333 ret = __clk_lookup_subtree(name, root_clk);
334 if (ret)
335 return ret;
336 }
337
338 /* if not found, then search the orphan tree */
339 hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) {
340 ret = __clk_lookup_subtree(name, root_clk);
341 if (ret)
342 return ret;
343 }
344
345 return NULL;
346}
347
Stephen Boydd6968fc2015-04-30 13:54:13 -0700348static struct clk_core *clk_core_get_parent_by_index(struct clk_core *core,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100349 u8 index)
James Hogan7ef3dcc2013-07-29 12:24:58 +0100350{
Stephen Boydd6968fc2015-04-30 13:54:13 -0700351 if (!core || index >= core->num_parents)
James Hogan7ef3dcc2013-07-29 12:24:58 +0100352 return NULL;
Masahiro Yamada88cfbef2015-12-28 19:23:01 +0900353
354 if (!core->parents[index])
355 core->parents[index] =
356 clk_core_lookup(core->parent_names[index]);
357
358 return core->parents[index];
James Hogan7ef3dcc2013-07-29 12:24:58 +0100359}
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100360
Stephen Boyde7df6f62015-08-12 13:04:56 -0700361struct clk_hw *
362clk_hw_get_parent_by_index(const struct clk_hw *hw, unsigned int index)
Stephen Boyd1a9c0692015-06-25 15:55:14 -0700363{
364 struct clk_core *parent;
365
366 parent = clk_core_get_parent_by_index(hw->core, index);
367
368 return !parent ? NULL : parent->hw;
369}
370EXPORT_SYMBOL_GPL(clk_hw_get_parent_by_index);
371
Russ Dill65800b22012-11-26 11:20:09 -0800372unsigned int __clk_get_enable_count(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700373{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100374 return !clk ? 0 : clk->core->enable_count;
Mike Turquetteb24764902012-03-15 23:11:19 -0700375}
376
Stephen Boydd6968fc2015-04-30 13:54:13 -0700377static unsigned long clk_core_get_rate_nolock(struct clk_core *core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700378{
379 unsigned long ret;
380
Stephen Boydd6968fc2015-04-30 13:54:13 -0700381 if (!core) {
Rajendra Nayak34e44fe2012-03-26 19:01:48 +0530382 ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700383 goto out;
384 }
385
Stephen Boydd6968fc2015-04-30 13:54:13 -0700386 ret = core->rate;
Mike Turquetteb24764902012-03-15 23:11:19 -0700387
Stephen Boyd47b0eeb2016-02-02 17:24:56 -0800388 if (!core->num_parents)
Mike Turquetteb24764902012-03-15 23:11:19 -0700389 goto out;
390
Stephen Boydd6968fc2015-04-30 13:54:13 -0700391 if (!core->parent)
Rajendra Nayak34e44fe2012-03-26 19:01:48 +0530392 ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700393
394out:
395 return ret;
396}
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100397
Stephen Boyde7df6f62015-08-12 13:04:56 -0700398unsigned long clk_hw_get_rate(const struct clk_hw *hw)
Stephen Boyd1a9c0692015-06-25 15:55:14 -0700399{
400 return clk_core_get_rate_nolock(hw->core);
401}
402EXPORT_SYMBOL_GPL(clk_hw_get_rate);
403
Stephen Boydd6968fc2015-04-30 13:54:13 -0700404static unsigned long __clk_get_accuracy(struct clk_core *core)
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100405{
Stephen Boydd6968fc2015-04-30 13:54:13 -0700406 if (!core)
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100407 return 0;
408
Stephen Boydd6968fc2015-04-30 13:54:13 -0700409 return core->accuracy;
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100410}
411
Russ Dill65800b22012-11-26 11:20:09 -0800412unsigned long __clk_get_flags(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700413{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100414 return !clk ? 0 : clk->core->flags;
Mike Turquetteb24764902012-03-15 23:11:19 -0700415}
Thierry Redingb05c6832013-09-03 09:43:51 +0200416EXPORT_SYMBOL_GPL(__clk_get_flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700417
Stephen Boyde7df6f62015-08-12 13:04:56 -0700418unsigned long clk_hw_get_flags(const struct clk_hw *hw)
Stephen Boyd1a9c0692015-06-25 15:55:14 -0700419{
420 return hw->core->flags;
421}
422EXPORT_SYMBOL_GPL(clk_hw_get_flags);
423
Stephen Boyde7df6f62015-08-12 13:04:56 -0700424bool clk_hw_is_prepared(const struct clk_hw *hw)
Stephen Boyd1a9c0692015-06-25 15:55:14 -0700425{
426 return clk_core_is_prepared(hw->core);
427}
428
Joachim Eastwoodbe68bf82015-10-24 18:55:22 +0200429bool clk_hw_is_enabled(const struct clk_hw *hw)
430{
431 return clk_core_is_enabled(hw->core);
432}
433
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100434bool __clk_is_enabled(struct clk *clk)
435{
436 if (!clk)
437 return false;
438
439 return clk_core_is_enabled(clk->core);
440}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800441EXPORT_SYMBOL_GPL(__clk_is_enabled);
Mike Turquetteb24764902012-03-15 23:11:19 -0700442
Stephen Boyd15a02c12015-01-19 18:05:28 -0800443static bool mux_is_better_rate(unsigned long rate, unsigned long now,
444 unsigned long best, unsigned long flags)
James Hogane366fdd2013-07-29 12:25:02 +0100445{
Stephen Boyd15a02c12015-01-19 18:05:28 -0800446 if (flags & CLK_MUX_ROUND_CLOSEST)
447 return abs(now - rate) < abs(best - rate);
448
449 return now <= rate && now > best;
450}
451
Boris Brezillon0817b622015-07-07 20:48:08 +0200452static int
453clk_mux_determine_rate_flags(struct clk_hw *hw, struct clk_rate_request *req,
Stephen Boyd15a02c12015-01-19 18:05:28 -0800454 unsigned long flags)
James Hogane366fdd2013-07-29 12:25:02 +0100455{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100456 struct clk_core *core = hw->core, *parent, *best_parent = NULL;
Boris Brezillon0817b622015-07-07 20:48:08 +0200457 int i, num_parents, ret;
458 unsigned long best = 0;
459 struct clk_rate_request parent_req = *req;
James Hogane366fdd2013-07-29 12:25:02 +0100460
461 /* if NO_REPARENT flag set, pass through to current parent */
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100462 if (core->flags & CLK_SET_RATE_NO_REPARENT) {
463 parent = core->parent;
Boris Brezillon0817b622015-07-07 20:48:08 +0200464 if (core->flags & CLK_SET_RATE_PARENT) {
465 ret = __clk_determine_rate(parent ? parent->hw : NULL,
466 &parent_req);
467 if (ret)
468 return ret;
469
470 best = parent_req.rate;
471 } else if (parent) {
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100472 best = clk_core_get_rate_nolock(parent);
Boris Brezillon0817b622015-07-07 20:48:08 +0200473 } else {
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100474 best = clk_core_get_rate_nolock(core);
Boris Brezillon0817b622015-07-07 20:48:08 +0200475 }
476
James Hogane366fdd2013-07-29 12:25:02 +0100477 goto out;
478 }
479
480 /* find the parent that can provide the fastest rate <= rate */
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100481 num_parents = core->num_parents;
James Hogane366fdd2013-07-29 12:25:02 +0100482 for (i = 0; i < num_parents; i++) {
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100483 parent = clk_core_get_parent_by_index(core, i);
James Hogane366fdd2013-07-29 12:25:02 +0100484 if (!parent)
485 continue;
Boris Brezillon0817b622015-07-07 20:48:08 +0200486
487 if (core->flags & CLK_SET_RATE_PARENT) {
488 parent_req = *req;
489 ret = __clk_determine_rate(parent->hw, &parent_req);
490 if (ret)
491 continue;
492 } else {
493 parent_req.rate = clk_core_get_rate_nolock(parent);
494 }
495
496 if (mux_is_better_rate(req->rate, parent_req.rate,
497 best, flags)) {
James Hogane366fdd2013-07-29 12:25:02 +0100498 best_parent = parent;
Boris Brezillon0817b622015-07-07 20:48:08 +0200499 best = parent_req.rate;
James Hogane366fdd2013-07-29 12:25:02 +0100500 }
501 }
502
Boris Brezillon57d866e2015-07-09 22:39:38 +0200503 if (!best_parent)
504 return -EINVAL;
505
James Hogane366fdd2013-07-29 12:25:02 +0100506out:
507 if (best_parent)
Boris Brezillon0817b622015-07-07 20:48:08 +0200508 req->best_parent_hw = best_parent->hw;
509 req->best_parent_rate = best;
510 req->rate = best;
James Hogane366fdd2013-07-29 12:25:02 +0100511
Boris Brezillon0817b622015-07-07 20:48:08 +0200512 return 0;
James Hogane366fdd2013-07-29 12:25:02 +0100513}
Stephen Boyd15a02c12015-01-19 18:05:28 -0800514
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100515struct clk *__clk_lookup(const char *name)
516{
517 struct clk_core *core = clk_core_lookup(name);
518
519 return !core ? NULL : core->hw->clk;
520}
521
Stephen Boydd6968fc2015-04-30 13:54:13 -0700522static void clk_core_get_boundaries(struct clk_core *core,
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100523 unsigned long *min_rate,
524 unsigned long *max_rate)
525{
526 struct clk *clk_user;
527
Stephen Boyd9783c0d2015-07-16 12:50:27 -0700528 *min_rate = core->min_rate;
529 *max_rate = core->max_rate;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100530
Stephen Boydd6968fc2015-04-30 13:54:13 -0700531 hlist_for_each_entry(clk_user, &core->clks, clks_node)
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100532 *min_rate = max(*min_rate, clk_user->min_rate);
533
Stephen Boydd6968fc2015-04-30 13:54:13 -0700534 hlist_for_each_entry(clk_user, &core->clks, clks_node)
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100535 *max_rate = min(*max_rate, clk_user->max_rate);
536}
537
Stephen Boyd9783c0d2015-07-16 12:50:27 -0700538void clk_hw_set_rate_range(struct clk_hw *hw, unsigned long min_rate,
539 unsigned long max_rate)
540{
541 hw->core->min_rate = min_rate;
542 hw->core->max_rate = max_rate;
543}
544EXPORT_SYMBOL_GPL(clk_hw_set_rate_range);
545
Stephen Boyd15a02c12015-01-19 18:05:28 -0800546/*
547 * Helper for finding best parent to provide a given frequency. This can be used
548 * directly as a determine_rate callback (e.g. for a mux), or from a more
549 * complex clock that may combine a mux with other operations.
550 */
Boris Brezillon0817b622015-07-07 20:48:08 +0200551int __clk_mux_determine_rate(struct clk_hw *hw,
552 struct clk_rate_request *req)
Stephen Boyd15a02c12015-01-19 18:05:28 -0800553{
Boris Brezillon0817b622015-07-07 20:48:08 +0200554 return clk_mux_determine_rate_flags(hw, req, 0);
Stephen Boyd15a02c12015-01-19 18:05:28 -0800555}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800556EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);
James Hogane366fdd2013-07-29 12:25:02 +0100557
Boris Brezillon0817b622015-07-07 20:48:08 +0200558int __clk_mux_determine_rate_closest(struct clk_hw *hw,
559 struct clk_rate_request *req)
Stephen Boyd15a02c12015-01-19 18:05:28 -0800560{
Boris Brezillon0817b622015-07-07 20:48:08 +0200561 return clk_mux_determine_rate_flags(hw, req, CLK_MUX_ROUND_CLOSEST);
Stephen Boyd15a02c12015-01-19 18:05:28 -0800562}
563EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest);
564
Mike Turquetteb24764902012-03-15 23:11:19 -0700565/*** clk api ***/
566
Stephen Boydd6968fc2015-04-30 13:54:13 -0700567static void clk_core_unprepare(struct clk_core *core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700568{
Stephen Boyda6334722015-05-06 17:00:54 -0700569 lockdep_assert_held(&prepare_lock);
570
Stephen Boydd6968fc2015-04-30 13:54:13 -0700571 if (!core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700572 return;
573
Stephen Boydd6968fc2015-04-30 13:54:13 -0700574 if (WARN_ON(core->prepare_count == 0))
Mike Turquetteb24764902012-03-15 23:11:19 -0700575 return;
576
Stephen Boydd6968fc2015-04-30 13:54:13 -0700577 if (--core->prepare_count > 0)
Mike Turquetteb24764902012-03-15 23:11:19 -0700578 return;
579
Stephen Boydd6968fc2015-04-30 13:54:13 -0700580 WARN_ON(core->enable_count > 0);
Mike Turquetteb24764902012-03-15 23:11:19 -0700581
Stephen Boydd6968fc2015-04-30 13:54:13 -0700582 trace_clk_unprepare(core);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800583
Stephen Boydd6968fc2015-04-30 13:54:13 -0700584 if (core->ops->unprepare)
585 core->ops->unprepare(core->hw);
Mike Turquetteb24764902012-03-15 23:11:19 -0700586
Stephen Boydd6968fc2015-04-30 13:54:13 -0700587 trace_clk_unprepare_complete(core);
588 clk_core_unprepare(core->parent);
Mike Turquetteb24764902012-03-15 23:11:19 -0700589}
590
591/**
592 * clk_unprepare - undo preparation of a clock source
Peter Meerwald24ee1a02013-06-29 15:14:19 +0200593 * @clk: the clk being unprepared
Mike Turquetteb24764902012-03-15 23:11:19 -0700594 *
595 * clk_unprepare may sleep, which differentiates it from clk_disable. In a
596 * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
597 * if the operation may sleep. One example is a clk which is accessed over
598 * I2c. In the complex case a clk gate operation may require a fast and a slow
599 * part. It is this reason that clk_unprepare and clk_disable are not mutually
600 * exclusive. In fact clk_disable must be called before clk_unprepare.
601 */
602void clk_unprepare(struct clk *clk)
603{
Stephen Boyd63589e92014-03-26 16:06:37 -0700604 if (IS_ERR_OR_NULL(clk))
605 return;
606
Mike Turquetteeab89f62013-03-28 13:59:01 -0700607 clk_prepare_lock();
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100608 clk_core_unprepare(clk->core);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700609 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700610}
611EXPORT_SYMBOL_GPL(clk_unprepare);
612
Stephen Boydd6968fc2015-04-30 13:54:13 -0700613static int clk_core_prepare(struct clk_core *core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700614{
615 int ret = 0;
616
Stephen Boyda6334722015-05-06 17:00:54 -0700617 lockdep_assert_held(&prepare_lock);
618
Stephen Boydd6968fc2015-04-30 13:54:13 -0700619 if (!core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700620 return 0;
621
Stephen Boydd6968fc2015-04-30 13:54:13 -0700622 if (core->prepare_count == 0) {
623 ret = clk_core_prepare(core->parent);
Mike Turquetteb24764902012-03-15 23:11:19 -0700624 if (ret)
625 return ret;
626
Stephen Boydd6968fc2015-04-30 13:54:13 -0700627 trace_clk_prepare(core);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800628
Stephen Boydd6968fc2015-04-30 13:54:13 -0700629 if (core->ops->prepare)
630 ret = core->ops->prepare(core->hw);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800631
Stephen Boydd6968fc2015-04-30 13:54:13 -0700632 trace_clk_prepare_complete(core);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800633
634 if (ret) {
Stephen Boydd6968fc2015-04-30 13:54:13 -0700635 clk_core_unprepare(core->parent);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800636 return ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700637 }
638 }
639
Stephen Boydd6968fc2015-04-30 13:54:13 -0700640 core->prepare_count++;
Mike Turquetteb24764902012-03-15 23:11:19 -0700641
642 return 0;
643}
644
645/**
646 * clk_prepare - prepare a clock source
647 * @clk: the clk being prepared
648 *
649 * clk_prepare may sleep, which differentiates it from clk_enable. In a simple
650 * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
651 * operation may sleep. One example is a clk which is accessed over I2c. In
652 * the complex case a clk ungate operation may require a fast and a slow part.
653 * It is this reason that clk_prepare and clk_enable are not mutually
654 * exclusive. In fact clk_prepare must be called before clk_enable.
655 * Returns 0 on success, -EERROR otherwise.
656 */
657int clk_prepare(struct clk *clk)
658{
659 int ret;
660
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100661 if (!clk)
662 return 0;
663
Mike Turquetteeab89f62013-03-28 13:59:01 -0700664 clk_prepare_lock();
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100665 ret = clk_core_prepare(clk->core);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700666 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700667
668 return ret;
669}
670EXPORT_SYMBOL_GPL(clk_prepare);
671
Stephen Boydd6968fc2015-04-30 13:54:13 -0700672static void clk_core_disable(struct clk_core *core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700673{
Stephen Boyda6334722015-05-06 17:00:54 -0700674 lockdep_assert_held(&enable_lock);
675
Stephen Boydd6968fc2015-04-30 13:54:13 -0700676 if (!core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700677 return;
678
Stephen Boydd6968fc2015-04-30 13:54:13 -0700679 if (WARN_ON(core->enable_count == 0))
Mike Turquetteb24764902012-03-15 23:11:19 -0700680 return;
681
Stephen Boydd6968fc2015-04-30 13:54:13 -0700682 if (--core->enable_count > 0)
Mike Turquetteb24764902012-03-15 23:11:19 -0700683 return;
684
Stephen Boydd6968fc2015-04-30 13:54:13 -0700685 trace_clk_disable(core);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800686
Stephen Boydd6968fc2015-04-30 13:54:13 -0700687 if (core->ops->disable)
688 core->ops->disable(core->hw);
Mike Turquetteb24764902012-03-15 23:11:19 -0700689
Stephen Boydd6968fc2015-04-30 13:54:13 -0700690 trace_clk_disable_complete(core);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800691
Stephen Boydd6968fc2015-04-30 13:54:13 -0700692 clk_core_disable(core->parent);
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100693}
694
Mike Turquetteb24764902012-03-15 23:11:19 -0700695/**
696 * clk_disable - gate a clock
697 * @clk: the clk being gated
698 *
699 * clk_disable must not sleep, which differentiates it from clk_unprepare. In
700 * a simple case, clk_disable can be used instead of clk_unprepare to gate a
701 * clk if the operation is fast and will never sleep. One example is a
702 * SoC-internal clk which is controlled via simple register writes. In the
703 * complex case a clk gate operation may require a fast and a slow part. It is
704 * this reason that clk_unprepare and clk_disable are not mutually exclusive.
705 * In fact clk_disable must be called before clk_unprepare.
706 */
707void clk_disable(struct clk *clk)
708{
709 unsigned long flags;
710
Stephen Boyd63589e92014-03-26 16:06:37 -0700711 if (IS_ERR_OR_NULL(clk))
712 return;
713
Mike Turquetteeab89f62013-03-28 13:59:01 -0700714 flags = clk_enable_lock();
Dong Aisheng864e1602015-04-30 14:02:19 -0700715 clk_core_disable(clk->core);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700716 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700717}
718EXPORT_SYMBOL_GPL(clk_disable);
719
Stephen Boydd6968fc2015-04-30 13:54:13 -0700720static int clk_core_enable(struct clk_core *core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700721{
722 int ret = 0;
723
Stephen Boyda6334722015-05-06 17:00:54 -0700724 lockdep_assert_held(&enable_lock);
725
Stephen Boydd6968fc2015-04-30 13:54:13 -0700726 if (!core)
Mike Turquetteb24764902012-03-15 23:11:19 -0700727 return 0;
728
Stephen Boydd6968fc2015-04-30 13:54:13 -0700729 if (WARN_ON(core->prepare_count == 0))
Mike Turquetteb24764902012-03-15 23:11:19 -0700730 return -ESHUTDOWN;
731
Stephen Boydd6968fc2015-04-30 13:54:13 -0700732 if (core->enable_count == 0) {
733 ret = clk_core_enable(core->parent);
Mike Turquetteb24764902012-03-15 23:11:19 -0700734
735 if (ret)
736 return ret;
737
Stephen Boydd6968fc2015-04-30 13:54:13 -0700738 trace_clk_enable(core);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800739
Stephen Boydd6968fc2015-04-30 13:54:13 -0700740 if (core->ops->enable)
741 ret = core->ops->enable(core->hw);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800742
Stephen Boydd6968fc2015-04-30 13:54:13 -0700743 trace_clk_enable_complete(core);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800744
745 if (ret) {
Stephen Boydd6968fc2015-04-30 13:54:13 -0700746 clk_core_disable(core->parent);
Stephen Boyddfc202e2015-02-02 14:37:41 -0800747 return ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700748 }
749 }
750
Stephen Boydd6968fc2015-04-30 13:54:13 -0700751 core->enable_count++;
Mike Turquetteb24764902012-03-15 23:11:19 -0700752 return 0;
753}
754
755/**
756 * clk_enable - ungate a clock
757 * @clk: the clk being ungated
758 *
759 * clk_enable must not sleep, which differentiates it from clk_prepare. In a
760 * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
761 * if the operation will never sleep. One example is a SoC-internal clk which
762 * is controlled via simple register writes. In the complex case a clk ungate
763 * operation may require a fast and a slow part. It is this reason that
764 * clk_enable and clk_prepare are not mutually exclusive. In fact clk_prepare
765 * must be called before clk_enable. Returns 0 on success, -EERROR
766 * otherwise.
767 */
768int clk_enable(struct clk *clk)
769{
770 unsigned long flags;
771 int ret;
772
Dong Aisheng864e1602015-04-30 14:02:19 -0700773 if (!clk)
774 return 0;
775
Mike Turquetteeab89f62013-03-28 13:59:01 -0700776 flags = clk_enable_lock();
Dong Aisheng864e1602015-04-30 14:02:19 -0700777 ret = clk_core_enable(clk->core);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700778 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700779
780 return ret;
781}
782EXPORT_SYMBOL_GPL(clk_enable);
783
Boris Brezillon0817b622015-07-07 20:48:08 +0200784static int clk_core_round_rate_nolock(struct clk_core *core,
785 struct clk_rate_request *req)
Mike Turquetteb24764902012-03-15 23:11:19 -0700786{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100787 struct clk_core *parent;
Boris Brezillon0817b622015-07-07 20:48:08 +0200788 long rate;
Mike Turquetteb24764902012-03-15 23:11:19 -0700789
Krzysztof Kozlowski496eadf2015-01-09 09:28:10 +0100790 lockdep_assert_held(&prepare_lock);
791
Stephen Boydd6968fc2015-04-30 13:54:13 -0700792 if (!core)
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700793 return 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700794
Stephen Boydd6968fc2015-04-30 13:54:13 -0700795 parent = core->parent;
Boris Brezillon0817b622015-07-07 20:48:08 +0200796 if (parent) {
797 req->best_parent_hw = parent->hw;
798 req->best_parent_rate = parent->rate;
799 } else {
800 req->best_parent_hw = NULL;
801 req->best_parent_rate = 0;
802 }
Mike Turquetteb24764902012-03-15 23:11:19 -0700803
Stephen Boydd6968fc2015-04-30 13:54:13 -0700804 if (core->ops->determine_rate) {
Boris Brezillon0817b622015-07-07 20:48:08 +0200805 return core->ops->determine_rate(core->hw, req);
806 } else if (core->ops->round_rate) {
807 rate = core->ops->round_rate(core->hw, req->rate,
808 &req->best_parent_rate);
809 if (rate < 0)
810 return rate;
811
812 req->rate = rate;
813 } else if (core->flags & CLK_SET_RATE_PARENT) {
814 return clk_core_round_rate_nolock(parent, req);
815 } else {
816 req->rate = core->rate;
817 }
818
819 return 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700820}
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100821
822/**
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100823 * __clk_determine_rate - get the closest rate actually supported by a clock
824 * @hw: determine the rate of this clock
825 * @rate: target rate
826 * @min_rate: returned rate must be greater than this rate
827 * @max_rate: returned rate must be less than this rate
828 *
Stephen Boyd6e5ab412015-04-30 15:11:31 -0700829 * Useful for clk_ops such as .set_rate and .determine_rate.
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100830 */
Boris Brezillon0817b622015-07-07 20:48:08 +0200831int __clk_determine_rate(struct clk_hw *hw, struct clk_rate_request *req)
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100832{
Boris Brezillon0817b622015-07-07 20:48:08 +0200833 if (!hw) {
834 req->rate = 0;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100835 return 0;
Boris Brezillon0817b622015-07-07 20:48:08 +0200836 }
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100837
Boris Brezillon0817b622015-07-07 20:48:08 +0200838 return clk_core_round_rate_nolock(hw->core, req);
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +0100839}
840EXPORT_SYMBOL_GPL(__clk_determine_rate);
841
Stephen Boyd1a9c0692015-06-25 15:55:14 -0700842unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate)
843{
844 int ret;
845 struct clk_rate_request req;
846
847 clk_core_get_boundaries(hw->core, &req.min_rate, &req.max_rate);
848 req.rate = rate;
849
850 ret = clk_core_round_rate_nolock(hw->core, &req);
851 if (ret)
852 return 0;
853
854 return req.rate;
855}
856EXPORT_SYMBOL_GPL(clk_hw_round_rate);
857
Mike Turquetteb24764902012-03-15 23:11:19 -0700858/**
859 * clk_round_rate - round the given rate for a clk
860 * @clk: the clk for which we are rounding a rate
861 * @rate: the rate which is to be rounded
862 *
863 * Takes in a rate as input and rounds it to a rate that the clk can actually
864 * use which is then returned. If clk doesn't support round_rate operation
865 * then the parent rate is returned.
866 */
867long clk_round_rate(struct clk *clk, unsigned long rate)
868{
Stephen Boydfc4a05d2015-06-25 17:24:15 -0700869 struct clk_rate_request req;
870 int ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700871
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100872 if (!clk)
873 return 0;
874
Mike Turquetteeab89f62013-03-28 13:59:01 -0700875 clk_prepare_lock();
Stephen Boydfc4a05d2015-06-25 17:24:15 -0700876
877 clk_core_get_boundaries(clk->core, &req.min_rate, &req.max_rate);
878 req.rate = rate;
879
880 ret = clk_core_round_rate_nolock(clk->core, &req);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700881 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700882
Stephen Boydfc4a05d2015-06-25 17:24:15 -0700883 if (ret)
884 return ret;
885
886 return req.rate;
Mike Turquetteb24764902012-03-15 23:11:19 -0700887}
888EXPORT_SYMBOL_GPL(clk_round_rate);
889
890/**
891 * __clk_notify - call clk notifier chain
Stephen Boydd6968fc2015-04-30 13:54:13 -0700892 * @core: clk that is changing rate
Mike Turquetteb24764902012-03-15 23:11:19 -0700893 * @msg: clk notifier type (see include/linux/clk.h)
894 * @old_rate: old clk rate
895 * @new_rate: new clk rate
896 *
897 * Triggers a notifier call chain on the clk rate-change notification
898 * for 'clk'. Passes a pointer to the struct clk and the previous
899 * and current rates to the notifier callback. Intended to be called by
900 * internal clock code only. Returns NOTIFY_DONE from the last driver
901 * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
902 * a driver returns that.
903 */
Stephen Boydd6968fc2015-04-30 13:54:13 -0700904static int __clk_notify(struct clk_core *core, unsigned long msg,
Mike Turquetteb24764902012-03-15 23:11:19 -0700905 unsigned long old_rate, unsigned long new_rate)
906{
907 struct clk_notifier *cn;
908 struct clk_notifier_data cnd;
909 int ret = NOTIFY_DONE;
910
Mike Turquetteb24764902012-03-15 23:11:19 -0700911 cnd.old_rate = old_rate;
912 cnd.new_rate = new_rate;
913
914 list_for_each_entry(cn, &clk_notifier_list, node) {
Stephen Boydd6968fc2015-04-30 13:54:13 -0700915 if (cn->clk->core == core) {
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100916 cnd.clk = cn->clk;
Mike Turquetteb24764902012-03-15 23:11:19 -0700917 ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
918 &cnd);
Mike Turquetteb24764902012-03-15 23:11:19 -0700919 }
920 }
921
922 return ret;
923}
924
925/**
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100926 * __clk_recalc_accuracies
Stephen Boydd6968fc2015-04-30 13:54:13 -0700927 * @core: first clk in the subtree
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100928 *
929 * Walks the subtree of clks starting with clk and recalculates accuracies as
930 * it goes. Note that if a clk does not implement the .recalc_accuracy
Stephen Boyd6e5ab412015-04-30 15:11:31 -0700931 * callback then it is assumed that the clock will take on the accuracy of its
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100932 * parent.
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100933 */
Stephen Boydd6968fc2015-04-30 13:54:13 -0700934static void __clk_recalc_accuracies(struct clk_core *core)
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100935{
936 unsigned long parent_accuracy = 0;
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100937 struct clk_core *child;
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100938
Krzysztof Kozlowski496eadf2015-01-09 09:28:10 +0100939 lockdep_assert_held(&prepare_lock);
940
Stephen Boydd6968fc2015-04-30 13:54:13 -0700941 if (core->parent)
942 parent_accuracy = core->parent->accuracy;
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100943
Stephen Boydd6968fc2015-04-30 13:54:13 -0700944 if (core->ops->recalc_accuracy)
945 core->accuracy = core->ops->recalc_accuracy(core->hw,
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100946 parent_accuracy);
947 else
Stephen Boydd6968fc2015-04-30 13:54:13 -0700948 core->accuracy = parent_accuracy;
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100949
Stephen Boydd6968fc2015-04-30 13:54:13 -0700950 hlist_for_each_entry(child, &core->children, child_node)
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100951 __clk_recalc_accuracies(child);
952}
953
Stephen Boydd6968fc2015-04-30 13:54:13 -0700954static long clk_core_get_accuracy(struct clk_core *core)
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100955{
956 unsigned long accuracy;
957
958 clk_prepare_lock();
Stephen Boydd6968fc2015-04-30 13:54:13 -0700959 if (core && (core->flags & CLK_GET_ACCURACY_NOCACHE))
960 __clk_recalc_accuracies(core);
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100961
Stephen Boydd6968fc2015-04-30 13:54:13 -0700962 accuracy = __clk_get_accuracy(core);
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100963 clk_prepare_unlock();
964
965 return accuracy;
966}
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100967
968/**
969 * clk_get_accuracy - return the accuracy of clk
970 * @clk: the clk whose accuracy is being returned
971 *
972 * Simply returns the cached accuracy of the clk, unless
973 * CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
974 * issued.
975 * If clk is NULL then returns 0.
976 */
977long clk_get_accuracy(struct clk *clk)
978{
979 if (!clk)
980 return 0;
981
982 return clk_core_get_accuracy(clk->core);
983}
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100984EXPORT_SYMBOL_GPL(clk_get_accuracy);
985
Stephen Boydd6968fc2015-04-30 13:54:13 -0700986static unsigned long clk_recalc(struct clk_core *core,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +0100987 unsigned long parent_rate)
Stephen Boyd8f2c2db2014-03-26 16:06:36 -0700988{
Stephen Boydd6968fc2015-04-30 13:54:13 -0700989 if (core->ops->recalc_rate)
990 return core->ops->recalc_rate(core->hw, parent_rate);
Stephen Boyd8f2c2db2014-03-26 16:06:36 -0700991 return parent_rate;
992}
993
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100994/**
Mike Turquetteb24764902012-03-15 23:11:19 -0700995 * __clk_recalc_rates
Stephen Boydd6968fc2015-04-30 13:54:13 -0700996 * @core: first clk in the subtree
Mike Turquetteb24764902012-03-15 23:11:19 -0700997 * @msg: notification type (see include/linux/clk.h)
998 *
999 * Walks the subtree of clks starting with clk and recalculates rates as it
1000 * goes. Note that if a clk does not implement the .recalc_rate callback then
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001001 * it is assumed that the clock will take on the rate of its parent.
Mike Turquetteb24764902012-03-15 23:11:19 -07001002 *
1003 * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
1004 * if necessary.
Mike Turquetteb24764902012-03-15 23:11:19 -07001005 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001006static void __clk_recalc_rates(struct clk_core *core, unsigned long msg)
Mike Turquetteb24764902012-03-15 23:11:19 -07001007{
1008 unsigned long old_rate;
1009 unsigned long parent_rate = 0;
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001010 struct clk_core *child;
Mike Turquetteb24764902012-03-15 23:11:19 -07001011
Krzysztof Kozlowski496eadf2015-01-09 09:28:10 +01001012 lockdep_assert_held(&prepare_lock);
1013
Stephen Boydd6968fc2015-04-30 13:54:13 -07001014 old_rate = core->rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07001015
Stephen Boydd6968fc2015-04-30 13:54:13 -07001016 if (core->parent)
1017 parent_rate = core->parent->rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07001018
Stephen Boydd6968fc2015-04-30 13:54:13 -07001019 core->rate = clk_recalc(core, parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001020
1021 /*
1022 * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
1023 * & ABORT_RATE_CHANGE notifiers
1024 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001025 if (core->notifier_count && msg)
1026 __clk_notify(core, msg, old_rate, core->rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001027
Stephen Boydd6968fc2015-04-30 13:54:13 -07001028 hlist_for_each_entry(child, &core->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -07001029 __clk_recalc_rates(child, msg);
1030}
1031
Stephen Boydd6968fc2015-04-30 13:54:13 -07001032static unsigned long clk_core_get_rate(struct clk_core *core)
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001033{
1034 unsigned long rate;
1035
1036 clk_prepare_lock();
1037
Stephen Boydd6968fc2015-04-30 13:54:13 -07001038 if (core && (core->flags & CLK_GET_RATE_NOCACHE))
1039 __clk_recalc_rates(core, 0);
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001040
Stephen Boydd6968fc2015-04-30 13:54:13 -07001041 rate = clk_core_get_rate_nolock(core);
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001042 clk_prepare_unlock();
1043
1044 return rate;
1045}
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001046
Mike Turquetteb24764902012-03-15 23:11:19 -07001047/**
Ulf Hanssona093bde2012-08-31 14:21:28 +02001048 * clk_get_rate - return the rate of clk
1049 * @clk: the clk whose rate is being returned
1050 *
1051 * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
1052 * is set, which means a recalc_rate will be issued.
1053 * If clk is NULL then returns 0.
1054 */
1055unsigned long clk_get_rate(struct clk *clk)
1056{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001057 if (!clk)
1058 return 0;
Ulf Hanssona093bde2012-08-31 14:21:28 +02001059
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001060 return clk_core_get_rate(clk->core);
Ulf Hanssona093bde2012-08-31 14:21:28 +02001061}
1062EXPORT_SYMBOL_GPL(clk_get_rate);
1063
Stephen Boydd6968fc2015-04-30 13:54:13 -07001064static int clk_fetch_parent_index(struct clk_core *core,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001065 struct clk_core *parent)
James Hogan4935b222013-07-29 12:24:59 +01001066{
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001067 int i;
James Hogan4935b222013-07-29 12:24:59 +01001068
Masahiro Yamada508f8842015-12-28 19:23:08 +09001069 if (!parent)
1070 return -EINVAL;
1071
Masahiro Yamada470b5e22015-12-28 19:23:09 +09001072 for (i = 0; i < core->num_parents; i++)
1073 if (clk_core_get_parent_by_index(core, i) == parent)
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001074 return i;
Tomasz Figada0f0b22013-09-29 02:37:16 +02001075
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001076 return -EINVAL;
James Hogan4935b222013-07-29 12:24:59 +01001077}
1078
Heiko Stuebnere6500342015-04-22 22:53:05 +02001079/*
1080 * Update the orphan status of @core and all its children.
1081 */
1082static void clk_core_update_orphan_status(struct clk_core *core, bool is_orphan)
1083{
1084 struct clk_core *child;
1085
1086 core->orphan = is_orphan;
1087
1088 hlist_for_each_entry(child, &core->children, child_node)
1089 clk_core_update_orphan_status(child, is_orphan);
1090}
1091
Stephen Boydd6968fc2015-04-30 13:54:13 -07001092static void clk_reparent(struct clk_core *core, struct clk_core *new_parent)
James Hogan4935b222013-07-29 12:24:59 +01001093{
Heiko Stuebnere6500342015-04-22 22:53:05 +02001094 bool was_orphan = core->orphan;
1095
Stephen Boydd6968fc2015-04-30 13:54:13 -07001096 hlist_del(&core->child_node);
James Hogan4935b222013-07-29 12:24:59 +01001097
James Hogan903efc52013-08-29 12:10:51 +01001098 if (new_parent) {
Heiko Stuebnere6500342015-04-22 22:53:05 +02001099 bool becomes_orphan = new_parent->orphan;
1100
James Hogan903efc52013-08-29 12:10:51 +01001101 /* avoid duplicate POST_RATE_CHANGE notifications */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001102 if (new_parent->new_child == core)
James Hogan903efc52013-08-29 12:10:51 +01001103 new_parent->new_child = NULL;
1104
Stephen Boydd6968fc2015-04-30 13:54:13 -07001105 hlist_add_head(&core->child_node, &new_parent->children);
Heiko Stuebnere6500342015-04-22 22:53:05 +02001106
1107 if (was_orphan != becomes_orphan)
1108 clk_core_update_orphan_status(core, becomes_orphan);
James Hogan903efc52013-08-29 12:10:51 +01001109 } else {
Stephen Boydd6968fc2015-04-30 13:54:13 -07001110 hlist_add_head(&core->child_node, &clk_orphan_list);
Heiko Stuebnere6500342015-04-22 22:53:05 +02001111 if (!was_orphan)
1112 clk_core_update_orphan_status(core, true);
James Hogan903efc52013-08-29 12:10:51 +01001113 }
James Hogan4935b222013-07-29 12:24:59 +01001114
Stephen Boydd6968fc2015-04-30 13:54:13 -07001115 core->parent = new_parent;
James Hogan4935b222013-07-29 12:24:59 +01001116}
1117
Stephen Boydd6968fc2015-04-30 13:54:13 -07001118static struct clk_core *__clk_set_parent_before(struct clk_core *core,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001119 struct clk_core *parent)
James Hogan4935b222013-07-29 12:24:59 +01001120{
1121 unsigned long flags;
Stephen Boydd6968fc2015-04-30 13:54:13 -07001122 struct clk_core *old_parent = core->parent;
James Hogan4935b222013-07-29 12:24:59 +01001123
1124 /*
1125 * Migrate prepare state between parents and prevent race with
1126 * clk_enable().
1127 *
1128 * If the clock is not prepared, then a race with
1129 * clk_enable/disable() is impossible since we already have the
1130 * prepare lock (future calls to clk_enable() need to be preceded by
1131 * a clk_prepare()).
1132 *
1133 * If the clock is prepared, migrate the prepared state to the new
1134 * parent and also protect against a race with clk_enable() by
1135 * forcing the clock and the new parent on. This ensures that all
1136 * future calls to clk_enable() are practically NOPs with respect to
1137 * hardware and software states.
1138 *
1139 * See also: Comment for clk_set_parent() below.
1140 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001141 if (core->prepare_count) {
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001142 clk_core_prepare(parent);
Dong Aishengd2a5d462015-04-15 22:26:36 +08001143 flags = clk_enable_lock();
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001144 clk_core_enable(parent);
Stephen Boydd6968fc2015-04-30 13:54:13 -07001145 clk_core_enable(core);
Dong Aishengd2a5d462015-04-15 22:26:36 +08001146 clk_enable_unlock(flags);
James Hogan4935b222013-07-29 12:24:59 +01001147 }
1148
1149 /* update the clk tree topology */
1150 flags = clk_enable_lock();
Stephen Boydd6968fc2015-04-30 13:54:13 -07001151 clk_reparent(core, parent);
James Hogan4935b222013-07-29 12:24:59 +01001152 clk_enable_unlock(flags);
1153
Stephen Boyd3fa22522014-01-15 10:47:22 -08001154 return old_parent;
1155}
1156
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001157static void __clk_set_parent_after(struct clk_core *core,
1158 struct clk_core *parent,
1159 struct clk_core *old_parent)
Stephen Boyd3fa22522014-01-15 10:47:22 -08001160{
Dong Aishengd2a5d462015-04-15 22:26:36 +08001161 unsigned long flags;
1162
Stephen Boyd3fa22522014-01-15 10:47:22 -08001163 /*
1164 * Finish the migration of prepare state and undo the changes done
1165 * for preventing a race with clk_enable().
1166 */
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001167 if (core->prepare_count) {
Dong Aishengd2a5d462015-04-15 22:26:36 +08001168 flags = clk_enable_lock();
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001169 clk_core_disable(core);
1170 clk_core_disable(old_parent);
Dong Aishengd2a5d462015-04-15 22:26:36 +08001171 clk_enable_unlock(flags);
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001172 clk_core_unprepare(old_parent);
Stephen Boyd3fa22522014-01-15 10:47:22 -08001173 }
Stephen Boyd3fa22522014-01-15 10:47:22 -08001174}
1175
Stephen Boydd6968fc2015-04-30 13:54:13 -07001176static int __clk_set_parent(struct clk_core *core, struct clk_core *parent,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001177 u8 p_index)
Stephen Boyd3fa22522014-01-15 10:47:22 -08001178{
1179 unsigned long flags;
1180 int ret = 0;
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001181 struct clk_core *old_parent;
Stephen Boyd3fa22522014-01-15 10:47:22 -08001182
Stephen Boydd6968fc2015-04-30 13:54:13 -07001183 old_parent = __clk_set_parent_before(core, parent);
Stephen Boyd3fa22522014-01-15 10:47:22 -08001184
Stephen Boydd6968fc2015-04-30 13:54:13 -07001185 trace_clk_set_parent(core, parent);
Stephen Boyddfc202e2015-02-02 14:37:41 -08001186
James Hogan4935b222013-07-29 12:24:59 +01001187 /* change clock input source */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001188 if (parent && core->ops->set_parent)
1189 ret = core->ops->set_parent(core->hw, p_index);
James Hogan4935b222013-07-29 12:24:59 +01001190
Stephen Boydd6968fc2015-04-30 13:54:13 -07001191 trace_clk_set_parent_complete(core, parent);
Stephen Boyddfc202e2015-02-02 14:37:41 -08001192
James Hogan4935b222013-07-29 12:24:59 +01001193 if (ret) {
1194 flags = clk_enable_lock();
Stephen Boydd6968fc2015-04-30 13:54:13 -07001195 clk_reparent(core, old_parent);
James Hogan4935b222013-07-29 12:24:59 +01001196 clk_enable_unlock(flags);
Dong Aishengc660b2eb2015-07-28 21:19:41 +08001197 __clk_set_parent_after(core, old_parent, parent);
James Hogan4935b222013-07-29 12:24:59 +01001198
James Hogan4935b222013-07-29 12:24:59 +01001199 return ret;
1200 }
1201
Stephen Boydd6968fc2015-04-30 13:54:13 -07001202 __clk_set_parent_after(core, parent, old_parent);
James Hogan4935b222013-07-29 12:24:59 +01001203
James Hogan4935b222013-07-29 12:24:59 +01001204 return 0;
1205}
1206
Ulf Hanssona093bde2012-08-31 14:21:28 +02001207/**
Mike Turquetteb24764902012-03-15 23:11:19 -07001208 * __clk_speculate_rates
Stephen Boydd6968fc2015-04-30 13:54:13 -07001209 * @core: first clk in the subtree
Mike Turquetteb24764902012-03-15 23:11:19 -07001210 * @parent_rate: the "future" rate of clk's parent
1211 *
1212 * Walks the subtree of clks starting with clk, speculating rates as it
1213 * goes and firing off PRE_RATE_CHANGE notifications as necessary.
1214 *
1215 * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
1216 * pre-rate change notifications and returns early if no clks in the
1217 * subtree have subscribed to the notifications. Note that if a clk does not
1218 * implement the .recalc_rate callback then it is assumed that the clock will
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001219 * take on the rate of its parent.
Mike Turquetteb24764902012-03-15 23:11:19 -07001220 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001221static int __clk_speculate_rates(struct clk_core *core,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001222 unsigned long parent_rate)
Mike Turquetteb24764902012-03-15 23:11:19 -07001223{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001224 struct clk_core *child;
Mike Turquetteb24764902012-03-15 23:11:19 -07001225 unsigned long new_rate;
1226 int ret = NOTIFY_DONE;
1227
Krzysztof Kozlowski496eadf2015-01-09 09:28:10 +01001228 lockdep_assert_held(&prepare_lock);
1229
Stephen Boydd6968fc2015-04-30 13:54:13 -07001230 new_rate = clk_recalc(core, parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001231
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001232 /* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001233 if (core->notifier_count)
1234 ret = __clk_notify(core, PRE_RATE_CHANGE, core->rate, new_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001235
Mike Turquette86bcfa22014-02-24 16:08:41 -08001236 if (ret & NOTIFY_STOP_MASK) {
1237 pr_debug("%s: clk notifier callback for clock %s aborted with error %d\n",
Stephen Boydd6968fc2015-04-30 13:54:13 -07001238 __func__, core->name, ret);
Mike Turquetteb24764902012-03-15 23:11:19 -07001239 goto out;
Mike Turquette86bcfa22014-02-24 16:08:41 -08001240 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001241
Stephen Boydd6968fc2015-04-30 13:54:13 -07001242 hlist_for_each_entry(child, &core->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001243 ret = __clk_speculate_rates(child, new_rate);
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001244 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001245 break;
1246 }
1247
1248out:
1249 return ret;
1250}
1251
Stephen Boydd6968fc2015-04-30 13:54:13 -07001252static void clk_calc_subtree(struct clk_core *core, unsigned long new_rate,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001253 struct clk_core *new_parent, u8 p_index)
Mike Turquetteb24764902012-03-15 23:11:19 -07001254{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001255 struct clk_core *child;
Mike Turquetteb24764902012-03-15 23:11:19 -07001256
Stephen Boydd6968fc2015-04-30 13:54:13 -07001257 core->new_rate = new_rate;
1258 core->new_parent = new_parent;
1259 core->new_parent_index = p_index;
James Hogan71472c02013-07-29 12:25:00 +01001260 /* include clk in new parent's PRE_RATE_CHANGE notifications */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001261 core->new_child = NULL;
1262 if (new_parent && new_parent != core->parent)
1263 new_parent->new_child = core;
Mike Turquetteb24764902012-03-15 23:11:19 -07001264
Stephen Boydd6968fc2015-04-30 13:54:13 -07001265 hlist_for_each_entry(child, &core->children, child_node) {
Stephen Boyd8f2c2db2014-03-26 16:06:36 -07001266 child->new_rate = clk_recalc(child, new_rate);
James Hogan71472c02013-07-29 12:25:00 +01001267 clk_calc_subtree(child, child->new_rate, NULL, 0);
Mike Turquetteb24764902012-03-15 23:11:19 -07001268 }
1269}
1270
1271/*
1272 * calculate the new rates returning the topmost clock that has to be
1273 * changed.
1274 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001275static struct clk_core *clk_calc_new_rates(struct clk_core *core,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001276 unsigned long rate)
Mike Turquetteb24764902012-03-15 23:11:19 -07001277{
Stephen Boydd6968fc2015-04-30 13:54:13 -07001278 struct clk_core *top = core;
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001279 struct clk_core *old_parent, *parent;
Shawn Guo81536e02012-04-12 20:50:17 +08001280 unsigned long best_parent_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001281 unsigned long new_rate;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001282 unsigned long min_rate;
1283 unsigned long max_rate;
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001284 int p_index = 0;
Boris Brezillon03bc10a2015-03-29 03:48:48 +02001285 long ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07001286
Mike Turquette7452b212012-03-26 14:45:36 -07001287 /* sanity */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001288 if (IS_ERR_OR_NULL(core))
Mike Turquette7452b212012-03-26 14:45:36 -07001289 return NULL;
1290
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001291 /* save parent rate, if it exists */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001292 parent = old_parent = core->parent;
James Hogan71472c02013-07-29 12:25:00 +01001293 if (parent)
1294 best_parent_rate = parent->rate;
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001295
Stephen Boydd6968fc2015-04-30 13:54:13 -07001296 clk_core_get_boundaries(core, &min_rate, &max_rate);
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001297
James Hogan71472c02013-07-29 12:25:00 +01001298 /* find the closest rate and parent clk/rate */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001299 if (core->ops->determine_rate) {
Boris Brezillon0817b622015-07-07 20:48:08 +02001300 struct clk_rate_request req;
1301
1302 req.rate = rate;
1303 req.min_rate = min_rate;
1304 req.max_rate = max_rate;
1305 if (parent) {
1306 req.best_parent_hw = parent->hw;
1307 req.best_parent_rate = parent->rate;
1308 } else {
1309 req.best_parent_hw = NULL;
1310 req.best_parent_rate = 0;
1311 }
1312
1313 ret = core->ops->determine_rate(core->hw, &req);
Boris Brezillon03bc10a2015-03-29 03:48:48 +02001314 if (ret < 0)
1315 return NULL;
1316
Boris Brezillon0817b622015-07-07 20:48:08 +02001317 best_parent_rate = req.best_parent_rate;
1318 new_rate = req.rate;
1319 parent = req.best_parent_hw ? req.best_parent_hw->core : NULL;
Stephen Boydd6968fc2015-04-30 13:54:13 -07001320 } else if (core->ops->round_rate) {
1321 ret = core->ops->round_rate(core->hw, rate,
Boris Brezillon0817b622015-07-07 20:48:08 +02001322 &best_parent_rate);
Boris Brezillon03bc10a2015-03-29 03:48:48 +02001323 if (ret < 0)
1324 return NULL;
1325
1326 new_rate = ret;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001327 if (new_rate < min_rate || new_rate > max_rate)
1328 return NULL;
Stephen Boydd6968fc2015-04-30 13:54:13 -07001329 } else if (!parent || !(core->flags & CLK_SET_RATE_PARENT)) {
James Hogan71472c02013-07-29 12:25:00 +01001330 /* pass-through clock without adjustable parent */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001331 core->new_rate = core->rate;
James Hogan71472c02013-07-29 12:25:00 +01001332 return NULL;
1333 } else {
1334 /* pass-through clock with adjustable parent */
1335 top = clk_calc_new_rates(parent, rate);
1336 new_rate = parent->new_rate;
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001337 goto out;
Mike Turquette7452b212012-03-26 14:45:36 -07001338 }
1339
James Hogan71472c02013-07-29 12:25:00 +01001340 /* some clocks must be gated to change parent */
1341 if (parent != old_parent &&
Stephen Boydd6968fc2015-04-30 13:54:13 -07001342 (core->flags & CLK_SET_PARENT_GATE) && core->prepare_count) {
James Hogan71472c02013-07-29 12:25:00 +01001343 pr_debug("%s: %s not gated but wants to reparent\n",
Stephen Boydd6968fc2015-04-30 13:54:13 -07001344 __func__, core->name);
Mike Turquetteb24764902012-03-15 23:11:19 -07001345 return NULL;
1346 }
1347
James Hogan71472c02013-07-29 12:25:00 +01001348 /* try finding the new parent index */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001349 if (parent && core->num_parents > 1) {
1350 p_index = clk_fetch_parent_index(core, parent);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001351 if (p_index < 0) {
James Hogan71472c02013-07-29 12:25:00 +01001352 pr_debug("%s: clk %s can not be parent of clk %s\n",
Stephen Boydd6968fc2015-04-30 13:54:13 -07001353 __func__, parent->name, core->name);
James Hogan71472c02013-07-29 12:25:00 +01001354 return NULL;
1355 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001356 }
1357
Stephen Boydd6968fc2015-04-30 13:54:13 -07001358 if ((core->flags & CLK_SET_RATE_PARENT) && parent &&
James Hogan71472c02013-07-29 12:25:00 +01001359 best_parent_rate != parent->rate)
1360 top = clk_calc_new_rates(parent, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001361
1362out:
Stephen Boydd6968fc2015-04-30 13:54:13 -07001363 clk_calc_subtree(core, new_rate, parent, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001364
1365 return top;
1366}
1367
1368/*
1369 * Notify about rate changes in a subtree. Always walk down the whole tree
1370 * so that in case of an error we can walk down the whole tree again and
1371 * abort the change.
1372 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001373static struct clk_core *clk_propagate_rate_change(struct clk_core *core,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001374 unsigned long event)
Mike Turquetteb24764902012-03-15 23:11:19 -07001375{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001376 struct clk_core *child, *tmp_clk, *fail_clk = NULL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001377 int ret = NOTIFY_DONE;
1378
Stephen Boydd6968fc2015-04-30 13:54:13 -07001379 if (core->rate == core->new_rate)
Sachin Kamat5fda6852013-03-13 15:17:49 +05301380 return NULL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001381
Stephen Boydd6968fc2015-04-30 13:54:13 -07001382 if (core->notifier_count) {
1383 ret = __clk_notify(core, event, core->rate, core->new_rate);
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001384 if (ret & NOTIFY_STOP_MASK)
Stephen Boydd6968fc2015-04-30 13:54:13 -07001385 fail_clk = core;
Mike Turquetteb24764902012-03-15 23:11:19 -07001386 }
1387
Stephen Boydd6968fc2015-04-30 13:54:13 -07001388 hlist_for_each_entry(child, &core->children, child_node) {
James Hogan71472c02013-07-29 12:25:00 +01001389 /* Skip children who will be reparented to another clock */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001390 if (child->new_parent && child->new_parent != core)
James Hogan71472c02013-07-29 12:25:00 +01001391 continue;
1392 tmp_clk = clk_propagate_rate_change(child, event);
1393 if (tmp_clk)
1394 fail_clk = tmp_clk;
1395 }
1396
Stephen Boydd6968fc2015-04-30 13:54:13 -07001397 /* handle the new child who might not be in core->children yet */
1398 if (core->new_child) {
1399 tmp_clk = clk_propagate_rate_change(core->new_child, event);
James Hogan71472c02013-07-29 12:25:00 +01001400 if (tmp_clk)
1401 fail_clk = tmp_clk;
Mike Turquetteb24764902012-03-15 23:11:19 -07001402 }
1403
1404 return fail_clk;
1405}
1406
1407/*
1408 * walk down a subtree and set the new rates notifying the rate
1409 * change on the way
1410 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001411static void clk_change_rate(struct clk_core *core)
Mike Turquetteb24764902012-03-15 23:11:19 -07001412{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001413 struct clk_core *child;
Tero Kristo067bb172014-08-21 16:47:45 +03001414 struct hlist_node *tmp;
Mike Turquetteb24764902012-03-15 23:11:19 -07001415 unsigned long old_rate;
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001416 unsigned long best_parent_rate = 0;
Stephen Boyd3fa22522014-01-15 10:47:22 -08001417 bool skip_set_rate = false;
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001418 struct clk_core *old_parent;
Mike Turquetteb24764902012-03-15 23:11:19 -07001419
Stephen Boydd6968fc2015-04-30 13:54:13 -07001420 old_rate = core->rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07001421
Stephen Boydd6968fc2015-04-30 13:54:13 -07001422 if (core->new_parent)
1423 best_parent_rate = core->new_parent->rate;
1424 else if (core->parent)
1425 best_parent_rate = core->parent->rate;
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001426
Heiko Stuebner2eb8c712015-12-22 22:27:58 +01001427 if (core->flags & CLK_SET_RATE_UNGATE) {
1428 unsigned long flags;
1429
1430 clk_core_prepare(core);
1431 flags = clk_enable_lock();
1432 clk_core_enable(core);
1433 clk_enable_unlock(flags);
1434 }
1435
Stephen Boydd6968fc2015-04-30 13:54:13 -07001436 if (core->new_parent && core->new_parent != core->parent) {
1437 old_parent = __clk_set_parent_before(core, core->new_parent);
1438 trace_clk_set_parent(core, core->new_parent);
Stephen Boyd3fa22522014-01-15 10:47:22 -08001439
Stephen Boydd6968fc2015-04-30 13:54:13 -07001440 if (core->ops->set_rate_and_parent) {
Stephen Boyd3fa22522014-01-15 10:47:22 -08001441 skip_set_rate = true;
Stephen Boydd6968fc2015-04-30 13:54:13 -07001442 core->ops->set_rate_and_parent(core->hw, core->new_rate,
Stephen Boyd3fa22522014-01-15 10:47:22 -08001443 best_parent_rate,
Stephen Boydd6968fc2015-04-30 13:54:13 -07001444 core->new_parent_index);
1445 } else if (core->ops->set_parent) {
1446 core->ops->set_parent(core->hw, core->new_parent_index);
Stephen Boyd3fa22522014-01-15 10:47:22 -08001447 }
1448
Stephen Boydd6968fc2015-04-30 13:54:13 -07001449 trace_clk_set_parent_complete(core, core->new_parent);
1450 __clk_set_parent_after(core, core->new_parent, old_parent);
Stephen Boyd3fa22522014-01-15 10:47:22 -08001451 }
1452
Stephen Boydd6968fc2015-04-30 13:54:13 -07001453 trace_clk_set_rate(core, core->new_rate);
Stephen Boyddfc202e2015-02-02 14:37:41 -08001454
Stephen Boydd6968fc2015-04-30 13:54:13 -07001455 if (!skip_set_rate && core->ops->set_rate)
1456 core->ops->set_rate(core->hw, core->new_rate, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001457
Stephen Boydd6968fc2015-04-30 13:54:13 -07001458 trace_clk_set_rate_complete(core, core->new_rate);
Stephen Boyddfc202e2015-02-02 14:37:41 -08001459
Stephen Boydd6968fc2015-04-30 13:54:13 -07001460 core->rate = clk_recalc(core, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001461
Heiko Stuebner2eb8c712015-12-22 22:27:58 +01001462 if (core->flags & CLK_SET_RATE_UNGATE) {
1463 unsigned long flags;
1464
1465 flags = clk_enable_lock();
1466 clk_core_disable(core);
1467 clk_enable_unlock(flags);
1468 clk_core_unprepare(core);
1469 }
1470
Stephen Boydd6968fc2015-04-30 13:54:13 -07001471 if (core->notifier_count && old_rate != core->rate)
1472 __clk_notify(core, POST_RATE_CHANGE, old_rate, core->rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001473
Michael Turquette85e88fa2015-06-20 12:18:03 -07001474 if (core->flags & CLK_RECALC_NEW_RATES)
1475 (void)clk_calc_new_rates(core, core->new_rate);
Bartlomiej Zolnierkiewiczd8d91982015-04-03 18:43:44 +02001476
Tero Kristo067bb172014-08-21 16:47:45 +03001477 /*
1478 * Use safe iteration, as change_rate can actually swap parents
1479 * for certain clock types.
1480 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001481 hlist_for_each_entry_safe(child, tmp, &core->children, child_node) {
James Hogan71472c02013-07-29 12:25:00 +01001482 /* Skip children who will be reparented to another clock */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001483 if (child->new_parent && child->new_parent != core)
James Hogan71472c02013-07-29 12:25:00 +01001484 continue;
Mike Turquetteb24764902012-03-15 23:11:19 -07001485 clk_change_rate(child);
James Hogan71472c02013-07-29 12:25:00 +01001486 }
1487
Stephen Boydd6968fc2015-04-30 13:54:13 -07001488 /* handle the new child who might not be in core->children yet */
1489 if (core->new_child)
1490 clk_change_rate(core->new_child);
Mike Turquetteb24764902012-03-15 23:11:19 -07001491}
1492
Stephen Boydd6968fc2015-04-30 13:54:13 -07001493static int clk_core_set_rate_nolock(struct clk_core *core,
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001494 unsigned long req_rate)
1495{
1496 struct clk_core *top, *fail_clk;
1497 unsigned long rate = req_rate;
1498 int ret = 0;
1499
Stephen Boydd6968fc2015-04-30 13:54:13 -07001500 if (!core)
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001501 return 0;
1502
1503 /* bail early if nothing to do */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001504 if (rate == clk_core_get_rate_nolock(core))
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001505 return 0;
1506
Stephen Boydd6968fc2015-04-30 13:54:13 -07001507 if ((core->flags & CLK_SET_RATE_GATE) && core->prepare_count)
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001508 return -EBUSY;
1509
1510 /* calculate new rates and get the topmost changed clock */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001511 top = clk_calc_new_rates(core, rate);
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001512 if (!top)
1513 return -EINVAL;
1514
1515 /* notify that we are about to change rates */
1516 fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
1517 if (fail_clk) {
1518 pr_debug("%s: failed to set %s rate\n", __func__,
1519 fail_clk->name);
1520 clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
1521 return -EBUSY;
1522 }
1523
1524 /* change the rates */
1525 clk_change_rate(top);
1526
Stephen Boydd6968fc2015-04-30 13:54:13 -07001527 core->req_rate = req_rate;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001528
1529 return ret;
1530}
1531
Mike Turquetteb24764902012-03-15 23:11:19 -07001532/**
1533 * clk_set_rate - specify a new rate for clk
1534 * @clk: the clk whose rate is being changed
1535 * @rate: the new rate for clk
1536 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001537 * In the simplest case clk_set_rate will only adjust the rate of clk.
Mike Turquetteb24764902012-03-15 23:11:19 -07001538 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001539 * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
1540 * propagate up to clk's parent; whether or not this happens depends on the
1541 * outcome of clk's .round_rate implementation. If *parent_rate is unchanged
1542 * after calling .round_rate then upstream parent propagation is ignored. If
1543 * *parent_rate comes back with a new rate for clk's parent then we propagate
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001544 * up to clk's parent and set its rate. Upward propagation will continue
Mike Turquette5654dc92012-03-26 11:51:34 -07001545 * until either a clk does not support the CLK_SET_RATE_PARENT flag or
1546 * .round_rate stops requesting changes to clk's parent_rate.
Mike Turquetteb24764902012-03-15 23:11:19 -07001547 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001548 * Rate changes are accomplished via tree traversal that also recalculates the
1549 * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
Mike Turquetteb24764902012-03-15 23:11:19 -07001550 *
1551 * Returns 0 on success, -EERROR otherwise.
1552 */
1553int clk_set_rate(struct clk *clk, unsigned long rate)
1554{
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001555 int ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07001556
Mike Turquette89ac8d72013-08-21 23:58:09 -07001557 if (!clk)
1558 return 0;
1559
Mike Turquetteb24764902012-03-15 23:11:19 -07001560 /* prevent racing with updates to the clock topology */
Mike Turquetteeab89f62013-03-28 13:59:01 -07001561 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001562
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001563 ret = clk_core_set_rate_nolock(clk->core, rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001564
Mike Turquetteeab89f62013-03-28 13:59:01 -07001565 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001566
1567 return ret;
1568}
1569EXPORT_SYMBOL_GPL(clk_set_rate);
1570
1571/**
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01001572 * clk_set_rate_range - set a rate range for a clock source
1573 * @clk: clock source
1574 * @min: desired minimum clock rate in Hz, inclusive
1575 * @max: desired maximum clock rate in Hz, inclusive
1576 *
1577 * Returns success (0) or negative errno.
1578 */
1579int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max)
1580{
1581 int ret = 0;
1582
1583 if (!clk)
1584 return 0;
1585
1586 if (min > max) {
1587 pr_err("%s: clk %s dev %s con %s: invalid range [%lu, %lu]\n",
1588 __func__, clk->core->name, clk->dev_id, clk->con_id,
1589 min, max);
1590 return -EINVAL;
1591 }
1592
1593 clk_prepare_lock();
1594
1595 if (min != clk->min_rate || max != clk->max_rate) {
1596 clk->min_rate = min;
1597 clk->max_rate = max;
1598 ret = clk_core_set_rate_nolock(clk->core, clk->core->req_rate);
1599 }
1600
1601 clk_prepare_unlock();
1602
1603 return ret;
1604}
1605EXPORT_SYMBOL_GPL(clk_set_rate_range);
1606
1607/**
1608 * clk_set_min_rate - set a minimum clock rate for a clock source
1609 * @clk: clock source
1610 * @rate: desired minimum clock rate in Hz, inclusive
1611 *
1612 * Returns success (0) or negative errno.
1613 */
1614int clk_set_min_rate(struct clk *clk, unsigned long rate)
1615{
1616 if (!clk)
1617 return 0;
1618
1619 return clk_set_rate_range(clk, rate, clk->max_rate);
1620}
1621EXPORT_SYMBOL_GPL(clk_set_min_rate);
1622
1623/**
1624 * clk_set_max_rate - set a maximum clock rate for a clock source
1625 * @clk: clock source
1626 * @rate: desired maximum clock rate in Hz, inclusive
1627 *
1628 * Returns success (0) or negative errno.
1629 */
1630int clk_set_max_rate(struct clk *clk, unsigned long rate)
1631{
1632 if (!clk)
1633 return 0;
1634
1635 return clk_set_rate_range(clk, clk->min_rate, rate);
1636}
1637EXPORT_SYMBOL_GPL(clk_set_max_rate);
1638
1639/**
Mike Turquetteb24764902012-03-15 23:11:19 -07001640 * clk_get_parent - return the parent of a clk
1641 * @clk: the clk whose parent gets returned
1642 *
1643 * Simply returns clk->parent. Returns NULL if clk is NULL.
1644 */
1645struct clk *clk_get_parent(struct clk *clk)
1646{
1647 struct clk *parent;
1648
Stephen Boydfc4a05d2015-06-25 17:24:15 -07001649 if (!clk)
1650 return NULL;
1651
Mike Turquetteeab89f62013-03-28 13:59:01 -07001652 clk_prepare_lock();
Stephen Boydfc4a05d2015-06-25 17:24:15 -07001653 /* TODO: Create a per-user clk and change callers to call clk_put */
1654 parent = !clk->core->parent ? NULL : clk->core->parent->hw->clk;
Mike Turquetteeab89f62013-03-28 13:59:01 -07001655 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001656
1657 return parent;
1658}
1659EXPORT_SYMBOL_GPL(clk_get_parent);
1660
Stephen Boydd6968fc2015-04-30 13:54:13 -07001661static struct clk_core *__clk_init_parent(struct clk_core *core)
Mike Turquetteb24764902012-03-15 23:11:19 -07001662{
Masahiro Yamada5146e0b2015-12-28 19:23:04 +09001663 u8 index = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001664
Masahiro Yamada2430a942016-02-09 20:19:14 +09001665 if (core->num_parents > 1 && core->ops->get_parent)
Masahiro Yamada5146e0b2015-12-28 19:23:04 +09001666 index = core->ops->get_parent(core->hw);
Mike Turquetteb24764902012-03-15 23:11:19 -07001667
Masahiro Yamada5146e0b2015-12-28 19:23:04 +09001668 return clk_core_get_parent_by_index(core, index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001669}
1670
Stephen Boydd6968fc2015-04-30 13:54:13 -07001671static void clk_core_reparent(struct clk_core *core,
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001672 struct clk_core *new_parent)
Ulf Hanssonb33d2122013-04-02 23:09:37 +02001673{
Stephen Boydd6968fc2015-04-30 13:54:13 -07001674 clk_reparent(core, new_parent);
1675 __clk_recalc_accuracies(core);
1676 __clk_recalc_rates(core, POST_RATE_CHANGE);
Mike Turquetteb24764902012-03-15 23:11:19 -07001677}
1678
Tomeu Vizoso42c86542015-03-11 11:34:25 +01001679void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent)
1680{
1681 if (!hw)
1682 return;
1683
1684 clk_core_reparent(hw->core, !new_parent ? NULL : new_parent->core);
1685}
1686
Mike Turquetteb24764902012-03-15 23:11:19 -07001687/**
Thierry Reding4e88f3d2015-01-21 17:13:00 +01001688 * clk_has_parent - check if a clock is a possible parent for another
1689 * @clk: clock source
1690 * @parent: parent clock source
Mike Turquetteb24764902012-03-15 23:11:19 -07001691 *
Thierry Reding4e88f3d2015-01-21 17:13:00 +01001692 * This function can be used in drivers that need to check that a clock can be
1693 * the parent of another without actually changing the parent.
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001694 *
Thierry Reding4e88f3d2015-01-21 17:13:00 +01001695 * Returns true if @parent is a possible parent for @clk, false otherwise.
Mike Turquetteb24764902012-03-15 23:11:19 -07001696 */
Thierry Reding4e88f3d2015-01-21 17:13:00 +01001697bool clk_has_parent(struct clk *clk, struct clk *parent)
1698{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001699 struct clk_core *core, *parent_core;
Thierry Reding4e88f3d2015-01-21 17:13:00 +01001700 unsigned int i;
1701
1702 /* NULL clocks should be nops, so return success if either is NULL. */
1703 if (!clk || !parent)
1704 return true;
1705
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001706 core = clk->core;
1707 parent_core = parent->core;
1708
Thierry Reding4e88f3d2015-01-21 17:13:00 +01001709 /* Optimize for the case where the parent is already the parent. */
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001710 if (core->parent == parent_core)
Thierry Reding4e88f3d2015-01-21 17:13:00 +01001711 return true;
1712
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001713 for (i = 0; i < core->num_parents; i++)
1714 if (strcmp(core->parent_names[i], parent_core->name) == 0)
Thierry Reding4e88f3d2015-01-21 17:13:00 +01001715 return true;
1716
1717 return false;
1718}
1719EXPORT_SYMBOL_GPL(clk_has_parent);
1720
Stephen Boydd6968fc2015-04-30 13:54:13 -07001721static int clk_core_set_parent(struct clk_core *core, struct clk_core *parent)
Mike Turquetteb24764902012-03-15 23:11:19 -07001722{
1723 int ret = 0;
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001724 int p_index = 0;
Ulf Hansson031dcc92013-04-02 23:09:38 +02001725 unsigned long p_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001726
Stephen Boydd6968fc2015-04-30 13:54:13 -07001727 if (!core)
Mike Turquette89ac8d72013-08-21 23:58:09 -07001728 return 0;
1729
Mike Turquetteb24764902012-03-15 23:11:19 -07001730 /* prevent racing with updates to the clock topology */
Mike Turquetteeab89f62013-03-28 13:59:01 -07001731 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001732
Stephen Boydd6968fc2015-04-30 13:54:13 -07001733 if (core->parent == parent)
Mike Turquetteb24764902012-03-15 23:11:19 -07001734 goto out;
1735
Stephen Boydb61c43c2015-02-02 14:11:25 -08001736 /* verify ops for for multi-parent clks */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001737 if ((core->num_parents > 1) && (!core->ops->set_parent)) {
Stephen Boydb61c43c2015-02-02 14:11:25 -08001738 ret = -ENOSYS;
1739 goto out;
1740 }
1741
Ulf Hansson031dcc92013-04-02 23:09:38 +02001742 /* check that we are allowed to re-parent if the clock is in use */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001743 if ((core->flags & CLK_SET_PARENT_GATE) && core->prepare_count) {
Ulf Hansson031dcc92013-04-02 23:09:38 +02001744 ret = -EBUSY;
1745 goto out;
1746 }
1747
1748 /* try finding the new parent index */
1749 if (parent) {
Stephen Boydd6968fc2015-04-30 13:54:13 -07001750 p_index = clk_fetch_parent_index(core, parent);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001751 if (p_index < 0) {
Ulf Hansson031dcc92013-04-02 23:09:38 +02001752 pr_debug("%s: clk %s can not be parent of clk %s\n",
Stephen Boydd6968fc2015-04-30 13:54:13 -07001753 __func__, parent->name, core->name);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001754 ret = p_index;
Ulf Hansson031dcc92013-04-02 23:09:38 +02001755 goto out;
1756 }
Masahiro Yamadae8f0e682015-12-28 19:23:10 +09001757 p_rate = parent->rate;
Ulf Hansson031dcc92013-04-02 23:09:38 +02001758 }
1759
Mike Turquetteb24764902012-03-15 23:11:19 -07001760 /* propagate PRE_RATE_CHANGE notifications */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001761 ret = __clk_speculate_rates(core, p_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001762
1763 /* abort if a driver objects */
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001764 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001765 goto out;
1766
Ulf Hansson031dcc92013-04-02 23:09:38 +02001767 /* do the re-parent */
Stephen Boydd6968fc2015-04-30 13:54:13 -07001768 ret = __clk_set_parent(core, parent, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001769
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001770 /* propagate rate an accuracy recalculation accordingly */
1771 if (ret) {
Stephen Boydd6968fc2015-04-30 13:54:13 -07001772 __clk_recalc_rates(core, ABORT_RATE_CHANGE);
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001773 } else {
Stephen Boydd6968fc2015-04-30 13:54:13 -07001774 __clk_recalc_rates(core, POST_RATE_CHANGE);
1775 __clk_recalc_accuracies(core);
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001776 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001777
1778out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001779 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001780
1781 return ret;
1782}
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001783
1784/**
1785 * clk_set_parent - switch the parent of a mux clk
1786 * @clk: the mux clk whose input we are switching
1787 * @parent: the new input to clk
1788 *
1789 * Re-parent clk to use parent as its new input source. If clk is in
1790 * prepared state, the clk will get enabled for the duration of this call. If
1791 * that's not acceptable for a specific clk (Eg: the consumer can't handle
1792 * that, the reparenting is glitchy in hardware, etc), use the
1793 * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
1794 *
1795 * After successfully changing clk's parent clk_set_parent will update the
1796 * clk topology, sysfs topology and propagate rate recalculation via
1797 * __clk_recalc_rates.
1798 *
1799 * Returns 0 on success, -EERROR otherwise.
1800 */
1801int clk_set_parent(struct clk *clk, struct clk *parent)
1802{
1803 if (!clk)
1804 return 0;
1805
1806 return clk_core_set_parent(clk->core, parent ? parent->core : NULL);
1807}
Mike Turquetteb24764902012-03-15 23:11:19 -07001808EXPORT_SYMBOL_GPL(clk_set_parent);
1809
1810/**
Mike Turquettee59c5372014-02-18 21:21:25 -08001811 * clk_set_phase - adjust the phase shift of a clock signal
1812 * @clk: clock signal source
1813 * @degrees: number of degrees the signal is shifted
1814 *
1815 * Shifts the phase of a clock signal by the specified
1816 * degrees. Returns 0 on success, -EERROR otherwise.
1817 *
1818 * This function makes no distinction about the input or reference
1819 * signal that we adjust the clock signal phase against. For example
1820 * phase locked-loop clock signal generators we may shift phase with
1821 * respect to feedback clock signal input, but for other cases the
1822 * clock phase may be shifted with respect to some other, unspecified
1823 * signal.
1824 *
1825 * Additionally the concept of phase shift does not propagate through
1826 * the clock tree hierarchy, which sets it apart from clock rates and
1827 * clock accuracy. A parent clock phase attribute does not have an
1828 * impact on the phase attribute of a child clock.
1829 */
1830int clk_set_phase(struct clk *clk, int degrees)
1831{
Stephen Boyd08b95752015-02-02 14:09:43 -08001832 int ret = -EINVAL;
Mike Turquettee59c5372014-02-18 21:21:25 -08001833
1834 if (!clk)
Stephen Boyd08b95752015-02-02 14:09:43 -08001835 return 0;
Mike Turquettee59c5372014-02-18 21:21:25 -08001836
1837 /* sanity check degrees */
1838 degrees %= 360;
1839 if (degrees < 0)
1840 degrees += 360;
1841
1842 clk_prepare_lock();
1843
Stephen Boyddfc202e2015-02-02 14:37:41 -08001844 trace_clk_set_phase(clk->core, degrees);
1845
Stephen Boyd08b95752015-02-02 14:09:43 -08001846 if (clk->core->ops->set_phase)
1847 ret = clk->core->ops->set_phase(clk->core->hw, degrees);
Mike Turquettee59c5372014-02-18 21:21:25 -08001848
Stephen Boyddfc202e2015-02-02 14:37:41 -08001849 trace_clk_set_phase_complete(clk->core, degrees);
1850
Mike Turquettee59c5372014-02-18 21:21:25 -08001851 if (!ret)
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001852 clk->core->phase = degrees;
Mike Turquettee59c5372014-02-18 21:21:25 -08001853
Mike Turquettee59c5372014-02-18 21:21:25 -08001854 clk_prepare_unlock();
1855
Mike Turquettee59c5372014-02-18 21:21:25 -08001856 return ret;
1857}
Maxime Ripard9767b04f2015-01-20 22:23:43 +01001858EXPORT_SYMBOL_GPL(clk_set_phase);
Mike Turquettee59c5372014-02-18 21:21:25 -08001859
Stephen Boydd6968fc2015-04-30 13:54:13 -07001860static int clk_core_get_phase(struct clk_core *core)
Mike Turquettee59c5372014-02-18 21:21:25 -08001861{
Stephen Boyd1f3e1982015-04-30 14:21:56 -07001862 int ret;
Mike Turquettee59c5372014-02-18 21:21:25 -08001863
1864 clk_prepare_lock();
Stephen Boydd6968fc2015-04-30 13:54:13 -07001865 ret = core->phase;
Mike Turquettee59c5372014-02-18 21:21:25 -08001866 clk_prepare_unlock();
1867
Mike Turquettee59c5372014-02-18 21:21:25 -08001868 return ret;
1869}
1870
1871/**
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01001872 * clk_get_phase - return the phase shift of a clock signal
1873 * @clk: clock signal source
1874 *
1875 * Returns the phase shift of a clock node in degrees, otherwise returns
1876 * -EERROR.
1877 */
1878int clk_get_phase(struct clk *clk)
1879{
1880 if (!clk)
1881 return 0;
1882
1883 return clk_core_get_phase(clk->core);
1884}
Stephen Boyd4dff95d2015-04-30 14:43:22 -07001885EXPORT_SYMBOL_GPL(clk_get_phase);
Mike Turquetteb24764902012-03-15 23:11:19 -07001886
1887/**
Michael Turquette3d3801e2015-02-25 09:11:01 -08001888 * clk_is_match - check if two clk's point to the same hardware clock
1889 * @p: clk compared against q
1890 * @q: clk compared against p
1891 *
1892 * Returns true if the two struct clk pointers both point to the same hardware
1893 * clock node. Put differently, returns true if struct clk *p and struct clk *q
1894 * share the same struct clk_core object.
1895 *
1896 * Returns false otherwise. Note that two NULL clks are treated as matching.
1897 */
1898bool clk_is_match(const struct clk *p, const struct clk *q)
1899{
1900 /* trivial case: identical struct clk's or both NULL */
1901 if (p == q)
1902 return true;
1903
Geert Uytterhoeven3fe003f2015-10-29 20:55:00 +01001904 /* true if clk->core pointers match. Avoid dereferencing garbage */
Michael Turquette3d3801e2015-02-25 09:11:01 -08001905 if (!IS_ERR_OR_NULL(p) && !IS_ERR_OR_NULL(q))
1906 if (p->core == q->core)
1907 return true;
1908
1909 return false;
1910}
1911EXPORT_SYMBOL_GPL(clk_is_match);
1912
Stephen Boyd4dff95d2015-04-30 14:43:22 -07001913/*** debugfs support ***/
1914
1915#ifdef CONFIG_DEBUG_FS
1916#include <linux/debugfs.h>
1917
1918static struct dentry *rootdir;
1919static int inited = 0;
1920static DEFINE_MUTEX(clk_debug_lock);
1921static HLIST_HEAD(clk_debug_list);
1922
1923static struct hlist_head *all_lists[] = {
1924 &clk_root_list,
1925 &clk_orphan_list,
1926 NULL,
1927};
1928
1929static struct hlist_head *orphan_list[] = {
1930 &clk_orphan_list,
1931 NULL,
1932};
1933
1934static void clk_summary_show_one(struct seq_file *s, struct clk_core *c,
1935 int level)
1936{
1937 if (!c)
1938 return;
1939
1940 seq_printf(s, "%*s%-*s %11d %12d %11lu %10lu %-3d\n",
1941 level * 3 + 1, "",
1942 30 - level * 3, c->name,
1943 c->enable_count, c->prepare_count, clk_core_get_rate(c),
1944 clk_core_get_accuracy(c), clk_core_get_phase(c));
1945}
1946
1947static void clk_summary_show_subtree(struct seq_file *s, struct clk_core *c,
1948 int level)
1949{
1950 struct clk_core *child;
1951
1952 if (!c)
1953 return;
1954
1955 clk_summary_show_one(s, c, level);
1956
1957 hlist_for_each_entry(child, &c->children, child_node)
1958 clk_summary_show_subtree(s, child, level + 1);
1959}
1960
1961static int clk_summary_show(struct seq_file *s, void *data)
1962{
1963 struct clk_core *c;
1964 struct hlist_head **lists = (struct hlist_head **)s->private;
1965
1966 seq_puts(s, " clock enable_cnt prepare_cnt rate accuracy phase\n");
1967 seq_puts(s, "----------------------------------------------------------------------------------------\n");
1968
1969 clk_prepare_lock();
1970
1971 for (; *lists; lists++)
1972 hlist_for_each_entry(c, *lists, child_node)
1973 clk_summary_show_subtree(s, c, 0);
1974
1975 clk_prepare_unlock();
1976
1977 return 0;
1978}
1979
1980
1981static int clk_summary_open(struct inode *inode, struct file *file)
1982{
1983 return single_open(file, clk_summary_show, inode->i_private);
1984}
1985
1986static const struct file_operations clk_summary_fops = {
1987 .open = clk_summary_open,
1988 .read = seq_read,
1989 .llseek = seq_lseek,
1990 .release = single_release,
1991};
1992
1993static void clk_dump_one(struct seq_file *s, struct clk_core *c, int level)
1994{
1995 if (!c)
1996 return;
1997
Stefan Wahren7cb81132015-04-29 16:36:43 +00001998 /* This should be JSON format, i.e. elements separated with a comma */
Stephen Boyd4dff95d2015-04-30 14:43:22 -07001999 seq_printf(s, "\"%s\": { ", c->name);
2000 seq_printf(s, "\"enable_count\": %d,", c->enable_count);
2001 seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
Stefan Wahren7cb81132015-04-29 16:36:43 +00002002 seq_printf(s, "\"rate\": %lu,", clk_core_get_rate(c));
2003 seq_printf(s, "\"accuracy\": %lu,", clk_core_get_accuracy(c));
Stephen Boyd4dff95d2015-04-30 14:43:22 -07002004 seq_printf(s, "\"phase\": %d", clk_core_get_phase(c));
2005}
2006
2007static void clk_dump_subtree(struct seq_file *s, struct clk_core *c, int level)
2008{
2009 struct clk_core *child;
2010
2011 if (!c)
2012 return;
2013
2014 clk_dump_one(s, c, level);
2015
2016 hlist_for_each_entry(child, &c->children, child_node) {
2017 seq_printf(s, ",");
2018 clk_dump_subtree(s, child, level + 1);
2019 }
2020
2021 seq_printf(s, "}");
2022}
2023
2024static int clk_dump(struct seq_file *s, void *data)
2025{
2026 struct clk_core *c;
2027 bool first_node = true;
2028 struct hlist_head **lists = (struct hlist_head **)s->private;
2029
2030 seq_printf(s, "{");
2031
2032 clk_prepare_lock();
2033
2034 for (; *lists; lists++) {
2035 hlist_for_each_entry(c, *lists, child_node) {
2036 if (!first_node)
2037 seq_puts(s, ",");
2038 first_node = false;
2039 clk_dump_subtree(s, c, 0);
2040 }
2041 }
2042
2043 clk_prepare_unlock();
2044
Felipe Balbi70e9f4d2015-05-01 09:48:37 -05002045 seq_puts(s, "}\n");
Stephen Boyd4dff95d2015-04-30 14:43:22 -07002046 return 0;
2047}
2048
2049
2050static int clk_dump_open(struct inode *inode, struct file *file)
2051{
2052 return single_open(file, clk_dump, inode->i_private);
2053}
2054
2055static const struct file_operations clk_dump_fops = {
2056 .open = clk_dump_open,
2057 .read = seq_read,
2058 .llseek = seq_lseek,
2059 .release = single_release,
2060};
2061
2062static int clk_debug_create_one(struct clk_core *core, struct dentry *pdentry)
2063{
2064 struct dentry *d;
2065 int ret = -ENOMEM;
2066
2067 if (!core || !pdentry) {
2068 ret = -EINVAL;
2069 goto out;
2070 }
2071
2072 d = debugfs_create_dir(core->name, pdentry);
2073 if (!d)
2074 goto out;
2075
2076 core->dentry = d;
2077
2078 d = debugfs_create_u32("clk_rate", S_IRUGO, core->dentry,
2079 (u32 *)&core->rate);
2080 if (!d)
2081 goto err_out;
2082
2083 d = debugfs_create_u32("clk_accuracy", S_IRUGO, core->dentry,
2084 (u32 *)&core->accuracy);
2085 if (!d)
2086 goto err_out;
2087
2088 d = debugfs_create_u32("clk_phase", S_IRUGO, core->dentry,
2089 (u32 *)&core->phase);
2090 if (!d)
2091 goto err_out;
2092
2093 d = debugfs_create_x32("clk_flags", S_IRUGO, core->dentry,
2094 (u32 *)&core->flags);
2095 if (!d)
2096 goto err_out;
2097
2098 d = debugfs_create_u32("clk_prepare_count", S_IRUGO, core->dentry,
2099 (u32 *)&core->prepare_count);
2100 if (!d)
2101 goto err_out;
2102
2103 d = debugfs_create_u32("clk_enable_count", S_IRUGO, core->dentry,
2104 (u32 *)&core->enable_count);
2105 if (!d)
2106 goto err_out;
2107
2108 d = debugfs_create_u32("clk_notifier_count", S_IRUGO, core->dentry,
2109 (u32 *)&core->notifier_count);
2110 if (!d)
2111 goto err_out;
2112
2113 if (core->ops->debug_init) {
2114 ret = core->ops->debug_init(core->hw, core->dentry);
2115 if (ret)
2116 goto err_out;
2117 }
2118
2119 ret = 0;
2120 goto out;
2121
2122err_out:
2123 debugfs_remove_recursive(core->dentry);
2124 core->dentry = NULL;
2125out:
2126 return ret;
2127}
2128
2129/**
Stephen Boyd6e5ab412015-04-30 15:11:31 -07002130 * clk_debug_register - add a clk node to the debugfs clk directory
2131 * @core: the clk being added to the debugfs clk directory
Stephen Boyd4dff95d2015-04-30 14:43:22 -07002132 *
Stephen Boyd6e5ab412015-04-30 15:11:31 -07002133 * Dynamically adds a clk to the debugfs clk directory if debugfs has been
2134 * initialized. Otherwise it bails out early since the debugfs clk directory
Stephen Boyd4dff95d2015-04-30 14:43:22 -07002135 * will be created lazily by clk_debug_init as part of a late_initcall.
2136 */
2137static int clk_debug_register(struct clk_core *core)
2138{
2139 int ret = 0;
2140
2141 mutex_lock(&clk_debug_lock);
2142 hlist_add_head(&core->debug_node, &clk_debug_list);
2143
2144 if (!inited)
2145 goto unlock;
2146
2147 ret = clk_debug_create_one(core, rootdir);
2148unlock:
2149 mutex_unlock(&clk_debug_lock);
2150
2151 return ret;
2152}
2153
2154 /**
Stephen Boyd6e5ab412015-04-30 15:11:31 -07002155 * clk_debug_unregister - remove a clk node from the debugfs clk directory
2156 * @core: the clk being removed from the debugfs clk directory
Stephen Boyd4dff95d2015-04-30 14:43:22 -07002157 *
Stephen Boyd6e5ab412015-04-30 15:11:31 -07002158 * Dynamically removes a clk and all its child nodes from the
2159 * debugfs clk directory if clk->dentry points to debugfs created by
Stephen Boyd4dff95d2015-04-30 14:43:22 -07002160 * clk_debug_register in __clk_init.
2161 */
2162static void clk_debug_unregister(struct clk_core *core)
2163{
2164 mutex_lock(&clk_debug_lock);
2165 hlist_del_init(&core->debug_node);
2166 debugfs_remove_recursive(core->dentry);
2167 core->dentry = NULL;
2168 mutex_unlock(&clk_debug_lock);
2169}
2170
2171struct dentry *clk_debugfs_add_file(struct clk_hw *hw, char *name, umode_t mode,
2172 void *data, const struct file_operations *fops)
2173{
2174 struct dentry *d = NULL;
2175
2176 if (hw->core->dentry)
2177 d = debugfs_create_file(name, mode, hw->core->dentry, data,
2178 fops);
2179
2180 return d;
2181}
2182EXPORT_SYMBOL_GPL(clk_debugfs_add_file);
2183
2184/**
Stephen Boyd6e5ab412015-04-30 15:11:31 -07002185 * clk_debug_init - lazily populate the debugfs clk directory
Stephen Boyd4dff95d2015-04-30 14:43:22 -07002186 *
Stephen Boyd6e5ab412015-04-30 15:11:31 -07002187 * clks are often initialized very early during boot before memory can be
2188 * dynamically allocated and well before debugfs is setup. This function
2189 * populates the debugfs clk directory once at boot-time when we know that
2190 * debugfs is setup. It should only be called once at boot-time, all other clks
2191 * added dynamically will be done so with clk_debug_register.
Stephen Boyd4dff95d2015-04-30 14:43:22 -07002192 */
2193static int __init clk_debug_init(void)
2194{
2195 struct clk_core *core;
2196 struct dentry *d;
2197
2198 rootdir = debugfs_create_dir("clk", NULL);
2199
2200 if (!rootdir)
2201 return -ENOMEM;
2202
2203 d = debugfs_create_file("clk_summary", S_IRUGO, rootdir, &all_lists,
2204 &clk_summary_fops);
2205 if (!d)
2206 return -ENOMEM;
2207
2208 d = debugfs_create_file("clk_dump", S_IRUGO, rootdir, &all_lists,
2209 &clk_dump_fops);
2210 if (!d)
2211 return -ENOMEM;
2212
2213 d = debugfs_create_file("clk_orphan_summary", S_IRUGO, rootdir,
2214 &orphan_list, &clk_summary_fops);
2215 if (!d)
2216 return -ENOMEM;
2217
2218 d = debugfs_create_file("clk_orphan_dump", S_IRUGO, rootdir,
2219 &orphan_list, &clk_dump_fops);
2220 if (!d)
2221 return -ENOMEM;
2222
2223 mutex_lock(&clk_debug_lock);
2224 hlist_for_each_entry(core, &clk_debug_list, debug_node)
2225 clk_debug_create_one(core, rootdir);
2226
2227 inited = 1;
2228 mutex_unlock(&clk_debug_lock);
2229
2230 return 0;
2231}
2232late_initcall(clk_debug_init);
2233#else
2234static inline int clk_debug_register(struct clk_core *core) { return 0; }
2235static inline void clk_debug_reparent(struct clk_core *core,
2236 struct clk_core *new_parent)
2237{
2238}
2239static inline void clk_debug_unregister(struct clk_core *core)
2240{
2241}
2242#endif
2243
Michael Turquette3d3801e2015-02-25 09:11:01 -08002244/**
Masahiro Yamada858d5882015-12-28 19:23:06 +09002245 * __clk_is_ancestor - check if a clk_core is a possible ancestor of another
2246 * @core: clock core
2247 * @ancestor: ancestor clock core
2248 *
2249 * Returns true if there is a possibility that @ancestor can be an ancestor
2250 * of @core, false otherwise.
2251 *
2252 * This function can be used against @core or @ancestor that has not been
2253 * registered yet.
2254 */
2255static bool __clk_is_ancestor(struct clk_core *core, struct clk_core *ancestor)
2256{
2257 struct clk_core *parent;
2258 int i;
2259
2260 for (i = 0; i < core->num_parents; i++) {
2261 parent = clk_core_get_parent_by_index(core, i);
2262 /*
2263 * If ancestor has not been added to clk_{root,orphan}_list
2264 * yet, clk_core_lookup() cannot find it. If parent is NULL,
2265 * compare the name strings, too.
2266 */
2267 if ((parent && (parent == ancestor ||
2268 __clk_is_ancestor(parent, ancestor))) ||
2269 (!parent && !strcmp(core->parent_names[i], ancestor->name)))
2270 return true;
2271 }
2272
2273 return false;
2274}
2275
2276/**
Masahiro Yamadabe45ebf2015-12-28 19:22:57 +09002277 * __clk_core_init - initialize the data structures in a struct clk_core
Masahiro Yamadad35c80c2015-12-28 19:22:56 +09002278 * @core: clk_core being initialized
Mike Turquetteb24764902012-03-15 23:11:19 -07002279 *
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002280 * Initializes the lists in struct clk_core, queries the hardware for the
Mike Turquetteb24764902012-03-15 23:11:19 -07002281 * parent and rate and sets them both.
Mike Turquetteb24764902012-03-15 23:11:19 -07002282 */
Masahiro Yamadabe45ebf2015-12-28 19:22:57 +09002283static int __clk_core_init(struct clk_core *core)
Mike Turquetteb24764902012-03-15 23:11:19 -07002284{
Mike Turquetted1302a32012-03-29 14:30:40 -07002285 int i, ret = 0;
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002286 struct clk_core *orphan;
Sasha Levinb67bfe02013-02-27 17:06:00 -08002287 struct hlist_node *tmp2;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002288 unsigned long rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07002289
Masahiro Yamadad35c80c2015-12-28 19:22:56 +09002290 if (!core)
Mike Turquetted1302a32012-03-29 14:30:40 -07002291 return -EINVAL;
Mike Turquetteb24764902012-03-15 23:11:19 -07002292
Mike Turquetteeab89f62013-03-28 13:59:01 -07002293 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002294
2295 /* check to see if a clock with this name is already registered */
Stephen Boydd6968fc2015-04-30 13:54:13 -07002296 if (clk_core_lookup(core->name)) {
Mike Turquetted1302a32012-03-29 14:30:40 -07002297 pr_debug("%s: clk %s already initialized\n",
Stephen Boydd6968fc2015-04-30 13:54:13 -07002298 __func__, core->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07002299 ret = -EEXIST;
Mike Turquetteb24764902012-03-15 23:11:19 -07002300 goto out;
Mike Turquetted1302a32012-03-29 14:30:40 -07002301 }
Mike Turquetteb24764902012-03-15 23:11:19 -07002302
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07002303 /* check that clk_ops are sane. See Documentation/clk.txt */
Stephen Boydd6968fc2015-04-30 13:54:13 -07002304 if (core->ops->set_rate &&
2305 !((core->ops->round_rate || core->ops->determine_rate) &&
2306 core->ops->recalc_rate)) {
Masahiro Yamadac44fccb2015-12-28 19:23:03 +09002307 pr_err("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n",
2308 __func__, core->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07002309 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07002310 goto out;
2311 }
2312
Stephen Boydd6968fc2015-04-30 13:54:13 -07002313 if (core->ops->set_parent && !core->ops->get_parent) {
Masahiro Yamadac44fccb2015-12-28 19:23:03 +09002314 pr_err("%s: %s must implement .get_parent & .set_parent\n",
2315 __func__, core->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07002316 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07002317 goto out;
2318 }
2319
Masahiro Yamada3c8e77d2015-12-28 19:23:04 +09002320 if (core->num_parents > 1 && !core->ops->get_parent) {
2321 pr_err("%s: %s must implement .get_parent as it has multi parents\n",
2322 __func__, core->name);
2323 ret = -EINVAL;
2324 goto out;
2325 }
2326
Stephen Boydd6968fc2015-04-30 13:54:13 -07002327 if (core->ops->set_rate_and_parent &&
2328 !(core->ops->set_parent && core->ops->set_rate)) {
Masahiro Yamadac44fccb2015-12-28 19:23:03 +09002329 pr_err("%s: %s must implement .set_parent & .set_rate\n",
Stephen Boydd6968fc2015-04-30 13:54:13 -07002330 __func__, core->name);
Stephen Boyd3fa22522014-01-15 10:47:22 -08002331 ret = -EINVAL;
2332 goto out;
2333 }
2334
Mike Turquetteb24764902012-03-15 23:11:19 -07002335 /* throw a WARN if any entries in parent_names are NULL */
Stephen Boydd6968fc2015-04-30 13:54:13 -07002336 for (i = 0; i < core->num_parents; i++)
2337 WARN(!core->parent_names[i],
Mike Turquetteb24764902012-03-15 23:11:19 -07002338 "%s: invalid NULL in %s's .parent_names\n",
Stephen Boydd6968fc2015-04-30 13:54:13 -07002339 __func__, core->name);
Mike Turquetteb24764902012-03-15 23:11:19 -07002340
Masahiro Yamada858d5882015-12-28 19:23:06 +09002341 /* If core is an ancestor of itself, it would make a loop. */
2342 if (__clk_is_ancestor(core, core)) {
2343 pr_err("%s: %s would create circular parent\n", __func__,
2344 core->name);
2345 ret = -EINVAL;
2346 goto out;
2347 }
2348
Stephen Boydd6968fc2015-04-30 13:54:13 -07002349 core->parent = __clk_init_parent(core);
Mike Turquetteb24764902012-03-15 23:11:19 -07002350
2351 /*
Stephen Boydd6968fc2015-04-30 13:54:13 -07002352 * Populate core->parent if parent has already been __clk_init'd. If
Mike Turquetteb24764902012-03-15 23:11:19 -07002353 * parent has not yet been __clk_init'd then place clk in the orphan
Stephen Boyd47b0eeb2016-02-02 17:24:56 -08002354 * list. If clk doesn't have any parents then place it in the root
Mike Turquetteb24764902012-03-15 23:11:19 -07002355 * clk list.
2356 *
2357 * Every time a new clk is clk_init'd then we walk the list of orphan
2358 * clocks and re-parent any that are children of the clock currently
2359 * being clk_init'd.
2360 */
Heiko Stuebnere6500342015-04-22 22:53:05 +02002361 if (core->parent) {
Stephen Boydd6968fc2015-04-30 13:54:13 -07002362 hlist_add_head(&core->child_node,
2363 &core->parent->children);
Heiko Stuebnere6500342015-04-22 22:53:05 +02002364 core->orphan = core->parent->orphan;
Stephen Boyd47b0eeb2016-02-02 17:24:56 -08002365 } else if (!core->num_parents) {
Stephen Boydd6968fc2015-04-30 13:54:13 -07002366 hlist_add_head(&core->child_node, &clk_root_list);
Heiko Stuebnere6500342015-04-22 22:53:05 +02002367 core->orphan = false;
2368 } else {
Stephen Boydd6968fc2015-04-30 13:54:13 -07002369 hlist_add_head(&core->child_node, &clk_orphan_list);
Heiko Stuebnere6500342015-04-22 22:53:05 +02002370 core->orphan = true;
2371 }
Mike Turquetteb24764902012-03-15 23:11:19 -07002372
2373 /*
Boris BREZILLON5279fc42013-12-21 10:34:47 +01002374 * Set clk's accuracy. The preferred method is to use
2375 * .recalc_accuracy. For simple clocks and lazy developers the default
2376 * fallback is to use the parent's accuracy. If a clock doesn't have a
2377 * parent (or is orphaned) then accuracy is set to zero (perfect
2378 * clock).
2379 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07002380 if (core->ops->recalc_accuracy)
2381 core->accuracy = core->ops->recalc_accuracy(core->hw,
2382 __clk_get_accuracy(core->parent));
2383 else if (core->parent)
2384 core->accuracy = core->parent->accuracy;
Boris BREZILLON5279fc42013-12-21 10:34:47 +01002385 else
Stephen Boydd6968fc2015-04-30 13:54:13 -07002386 core->accuracy = 0;
Boris BREZILLON5279fc42013-12-21 10:34:47 +01002387
2388 /*
Maxime Ripard9824cf72014-07-14 13:53:27 +02002389 * Set clk's phase.
2390 * Since a phase is by definition relative to its parent, just
2391 * query the current clock phase, or just assume it's in phase.
2392 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07002393 if (core->ops->get_phase)
2394 core->phase = core->ops->get_phase(core->hw);
Maxime Ripard9824cf72014-07-14 13:53:27 +02002395 else
Stephen Boydd6968fc2015-04-30 13:54:13 -07002396 core->phase = 0;
Maxime Ripard9824cf72014-07-14 13:53:27 +02002397
2398 /*
Mike Turquetteb24764902012-03-15 23:11:19 -07002399 * Set clk's rate. The preferred method is to use .recalc_rate. For
2400 * simple clocks and lazy developers the default fallback is to use the
2401 * parent's rate. If a clock doesn't have a parent (or is orphaned)
2402 * then rate is set to zero.
2403 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07002404 if (core->ops->recalc_rate)
2405 rate = core->ops->recalc_rate(core->hw,
2406 clk_core_get_rate_nolock(core->parent));
2407 else if (core->parent)
2408 rate = core->parent->rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07002409 else
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002410 rate = 0;
Stephen Boydd6968fc2015-04-30 13:54:13 -07002411 core->rate = core->req_rate = rate;
Mike Turquetteb24764902012-03-15 23:11:19 -07002412
2413 /*
Masahiro Yamada0e8f6e42015-12-28 19:23:07 +09002414 * walk the list of orphan clocks and reparent any that newly finds a
2415 * parent.
Mike Turquetteb24764902012-03-15 23:11:19 -07002416 */
Sasha Levinb67bfe02013-02-27 17:06:00 -08002417 hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
Masahiro Yamada0e8f6e42015-12-28 19:23:07 +09002418 struct clk_core *parent = __clk_init_parent(orphan);
Martin Fuzzey1f61e5f2012-11-22 20:15:05 +01002419
Masahiro Yamada0e8f6e42015-12-28 19:23:07 +09002420 if (parent)
2421 clk_core_reparent(orphan, parent);
2422 }
Mike Turquetteb24764902012-03-15 23:11:19 -07002423
2424 /*
2425 * optional platform-specific magic
2426 *
2427 * The .init callback is not used by any of the basic clock types, but
2428 * exists for weird hardware that must perform initialization magic.
2429 * Please consider other ways of solving initialization problems before
Peter Meerwald24ee1a02013-06-29 15:14:19 +02002430 * using this callback, as its use is discouraged.
Mike Turquetteb24764902012-03-15 23:11:19 -07002431 */
Stephen Boydd6968fc2015-04-30 13:54:13 -07002432 if (core->ops->init)
2433 core->ops->init(core->hw);
Mike Turquetteb24764902012-03-15 23:11:19 -07002434
Stephen Boydd6968fc2015-04-30 13:54:13 -07002435 kref_init(&core->ref);
Mike Turquetteb24764902012-03-15 23:11:19 -07002436out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07002437 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002438
Stephen Boyd89f7e9d2014-12-12 15:04:16 -08002439 if (!ret)
Stephen Boydd6968fc2015-04-30 13:54:13 -07002440 clk_debug_register(core);
Stephen Boyd89f7e9d2014-12-12 15:04:16 -08002441
Mike Turquetted1302a32012-03-29 14:30:40 -07002442 return ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07002443}
2444
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002445struct clk *__clk_create_clk(struct clk_hw *hw, const char *dev_id,
2446 const char *con_id)
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002447{
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002448 struct clk *clk;
2449
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002450 /* This is to allow this function to be chained to others */
Masahiro Yamadac1de1352015-11-20 14:38:49 +09002451 if (IS_ERR_OR_NULL(hw))
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002452 return (struct clk *) hw;
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002453
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002454 clk = kzalloc(sizeof(*clk), GFP_KERNEL);
2455 if (!clk)
2456 return ERR_PTR(-ENOMEM);
2457
2458 clk->core = hw->core;
2459 clk->dev_id = dev_id;
2460 clk->con_id = con_id;
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002461 clk->max_rate = ULONG_MAX;
2462
2463 clk_prepare_lock();
Stephen Boyd50595f82015-02-06 11:42:44 -08002464 hlist_add_head(&clk->clks_node, &hw->core->clks);
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002465 clk_prepare_unlock();
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002466
2467 return clk;
2468}
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002469
Stephen Boyd73e0e492015-02-06 11:42:43 -08002470void __clk_free_clk(struct clk *clk)
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002471{
2472 clk_prepare_lock();
Stephen Boyd50595f82015-02-06 11:42:44 -08002473 hlist_del(&clk->clks_node);
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002474 clk_prepare_unlock();
2475
2476 kfree(clk);
2477}
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002478
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002479/**
2480 * clk_register - allocate a new clock, register it and return an opaque cookie
2481 * @dev: device that is registering this clock
2482 * @hw: link to hardware-specific clock data
2483 *
2484 * clk_register is the primary interface for populating the clock tree with new
2485 * clock nodes. It returns a pointer to the newly allocated struct clk which
Shailendra Vermaa59a5162015-05-21 00:06:48 +05302486 * cannot be dereferenced by driver code but may be used in conjunction with the
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002487 * rest of the clock API. In the event of an error clk_register will return an
2488 * error code; drivers must test for an error code after calling clk_register.
2489 */
2490struct clk *clk_register(struct device *dev, struct clk_hw *hw)
Mike Turquetteb24764902012-03-15 23:11:19 -07002491{
Mike Turquetted1302a32012-03-29 14:30:40 -07002492 int i, ret;
Stephen Boydd6968fc2015-04-30 13:54:13 -07002493 struct clk_core *core;
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002494
Stephen Boydd6968fc2015-04-30 13:54:13 -07002495 core = kzalloc(sizeof(*core), GFP_KERNEL);
2496 if (!core) {
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002497 ret = -ENOMEM;
2498 goto fail_out;
2499 }
Mike Turquetteb24764902012-03-15 23:11:19 -07002500
Stephen Boydd6968fc2015-04-30 13:54:13 -07002501 core->name = kstrdup_const(hw->init->name, GFP_KERNEL);
2502 if (!core->name) {
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002503 ret = -ENOMEM;
2504 goto fail_name;
2505 }
Stephen Boydd6968fc2015-04-30 13:54:13 -07002506 core->ops = hw->init->ops;
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002507 if (dev && dev->driver)
Stephen Boydd6968fc2015-04-30 13:54:13 -07002508 core->owner = dev->driver->owner;
2509 core->hw = hw;
2510 core->flags = hw->init->flags;
2511 core->num_parents = hw->init->num_parents;
Stephen Boyd9783c0d2015-07-16 12:50:27 -07002512 core->min_rate = 0;
2513 core->max_rate = ULONG_MAX;
Stephen Boydd6968fc2015-04-30 13:54:13 -07002514 hw->core = core;
Mike Turquetteb24764902012-03-15 23:11:19 -07002515
Mike Turquetted1302a32012-03-29 14:30:40 -07002516 /* allocate local copy in case parent_names is __initdata */
Stephen Boydd6968fc2015-04-30 13:54:13 -07002517 core->parent_names = kcalloc(core->num_parents, sizeof(char *),
Tomasz Figa96a7ed92013-09-29 02:37:15 +02002518 GFP_KERNEL);
Mike Turquetteb24764902012-03-15 23:11:19 -07002519
Stephen Boydd6968fc2015-04-30 13:54:13 -07002520 if (!core->parent_names) {
Mike Turquetted1302a32012-03-29 14:30:40 -07002521 ret = -ENOMEM;
2522 goto fail_parent_names;
2523 }
2524
2525
2526 /* copy each string name in case parent_names is __initdata */
Stephen Boydd6968fc2015-04-30 13:54:13 -07002527 for (i = 0; i < core->num_parents; i++) {
2528 core->parent_names[i] = kstrdup_const(hw->init->parent_names[i],
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002529 GFP_KERNEL);
Stephen Boydd6968fc2015-04-30 13:54:13 -07002530 if (!core->parent_names[i]) {
Mike Turquetted1302a32012-03-29 14:30:40 -07002531 ret = -ENOMEM;
2532 goto fail_parent_names_copy;
2533 }
2534 }
2535
Masahiro Yamada176d1162015-12-28 19:23:00 +09002536 /* avoid unnecessary string look-ups of clk_core's possible parents. */
2537 core->parents = kcalloc(core->num_parents, sizeof(*core->parents),
2538 GFP_KERNEL);
2539 if (!core->parents) {
2540 ret = -ENOMEM;
2541 goto fail_parents;
2542 };
2543
Stephen Boydd6968fc2015-04-30 13:54:13 -07002544 INIT_HLIST_HEAD(&core->clks);
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002545
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002546 hw->clk = __clk_create_clk(hw, NULL, NULL);
2547 if (IS_ERR(hw->clk)) {
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002548 ret = PTR_ERR(hw->clk);
Masahiro Yamada176d1162015-12-28 19:23:00 +09002549 goto fail_parents;
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002550 }
Mike Turquetted1302a32012-03-29 14:30:40 -07002551
Masahiro Yamadabe45ebf2015-12-28 19:22:57 +09002552 ret = __clk_core_init(core);
Mike Turquetted1302a32012-03-29 14:30:40 -07002553 if (!ret)
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002554 return hw->clk;
2555
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002556 __clk_free_clk(hw->clk);
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002557 hw->clk = NULL;
Mike Turquetted1302a32012-03-29 14:30:40 -07002558
Masahiro Yamada176d1162015-12-28 19:23:00 +09002559fail_parents:
2560 kfree(core->parents);
Mike Turquetted1302a32012-03-29 14:30:40 -07002561fail_parent_names_copy:
2562 while (--i >= 0)
Stephen Boydd6968fc2015-04-30 13:54:13 -07002563 kfree_const(core->parent_names[i]);
2564 kfree(core->parent_names);
Mike Turquetted1302a32012-03-29 14:30:40 -07002565fail_parent_names:
Stephen Boydd6968fc2015-04-30 13:54:13 -07002566 kfree_const(core->name);
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002567fail_name:
Stephen Boydd6968fc2015-04-30 13:54:13 -07002568 kfree(core);
Mike Turquetted1302a32012-03-29 14:30:40 -07002569fail_out:
2570 return ERR_PTR(ret);
Mike Turquetteb24764902012-03-15 23:11:19 -07002571}
2572EXPORT_SYMBOL_GPL(clk_register);
2573
Stephen Boyd6e5ab412015-04-30 15:11:31 -07002574/* Free memory allocated for a clock. */
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002575static void __clk_release(struct kref *ref)
2576{
Stephen Boydd6968fc2015-04-30 13:54:13 -07002577 struct clk_core *core = container_of(ref, struct clk_core, ref);
2578 int i = core->num_parents;
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002579
Krzysztof Kozlowski496eadf2015-01-09 09:28:10 +01002580 lockdep_assert_held(&prepare_lock);
2581
Stephen Boydd6968fc2015-04-30 13:54:13 -07002582 kfree(core->parents);
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002583 while (--i >= 0)
Stephen Boydd6968fc2015-04-30 13:54:13 -07002584 kfree_const(core->parent_names[i]);
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002585
Stephen Boydd6968fc2015-04-30 13:54:13 -07002586 kfree(core->parent_names);
2587 kfree_const(core->name);
2588 kfree(core);
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002589}
2590
2591/*
2592 * Empty clk_ops for unregistered clocks. These are used temporarily
2593 * after clk_unregister() was called on a clock and until last clock
2594 * consumer calls clk_put() and the struct clk object is freed.
2595 */
2596static int clk_nodrv_prepare_enable(struct clk_hw *hw)
2597{
2598 return -ENXIO;
2599}
2600
2601static void clk_nodrv_disable_unprepare(struct clk_hw *hw)
2602{
2603 WARN_ON_ONCE(1);
2604}
2605
2606static int clk_nodrv_set_rate(struct clk_hw *hw, unsigned long rate,
2607 unsigned long parent_rate)
2608{
2609 return -ENXIO;
2610}
2611
2612static int clk_nodrv_set_parent(struct clk_hw *hw, u8 index)
2613{
2614 return -ENXIO;
2615}
2616
2617static const struct clk_ops clk_nodrv_ops = {
2618 .enable = clk_nodrv_prepare_enable,
2619 .disable = clk_nodrv_disable_unprepare,
2620 .prepare = clk_nodrv_prepare_enable,
2621 .unprepare = clk_nodrv_disable_unprepare,
2622 .set_rate = clk_nodrv_set_rate,
2623 .set_parent = clk_nodrv_set_parent,
2624};
2625
Mark Brown1df5c932012-04-18 09:07:12 +01002626/**
2627 * clk_unregister - unregister a currently registered clock
2628 * @clk: clock to unregister
Mark Brown1df5c932012-04-18 09:07:12 +01002629 */
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002630void clk_unregister(struct clk *clk)
2631{
2632 unsigned long flags;
2633
Stephen Boyd6314b672014-09-04 23:37:49 -07002634 if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
2635 return;
2636
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002637 clk_debug_unregister(clk->core);
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002638
2639 clk_prepare_lock();
2640
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002641 if (clk->core->ops == &clk_nodrv_ops) {
2642 pr_err("%s: unregistered clock: %s\n", __func__,
2643 clk->core->name);
Insu Yun4106a3d2016-01-30 10:12:04 -05002644 goto unlock;
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002645 }
2646 /*
2647 * Assign empty clock ops for consumers that might still hold
2648 * a reference to this clock.
2649 */
2650 flags = clk_enable_lock();
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002651 clk->core->ops = &clk_nodrv_ops;
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002652 clk_enable_unlock(flags);
2653
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002654 if (!hlist_empty(&clk->core->children)) {
2655 struct clk_core *child;
Stephen Boyd874f2242014-04-18 16:29:43 -07002656 struct hlist_node *t;
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002657
2658 /* Reparent all children to the orphan list. */
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002659 hlist_for_each_entry_safe(child, t, &clk->core->children,
2660 child_node)
2661 clk_core_set_parent(child, NULL);
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002662 }
2663
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002664 hlist_del_init(&clk->core->child_node);
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002665
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002666 if (clk->core->prepare_count)
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002667 pr_warn("%s: unregistering prepared clock: %s\n",
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002668 __func__, clk->core->name);
2669 kref_put(&clk->core->ref, __clk_release);
Insu Yun4106a3d2016-01-30 10:12:04 -05002670unlock:
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002671 clk_prepare_unlock();
2672}
Mark Brown1df5c932012-04-18 09:07:12 +01002673EXPORT_SYMBOL_GPL(clk_unregister);
2674
Stephen Boyd46c87732012-09-24 13:38:04 -07002675static void devm_clk_release(struct device *dev, void *res)
2676{
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002677 clk_unregister(*(struct clk **)res);
Stephen Boyd46c87732012-09-24 13:38:04 -07002678}
2679
2680/**
2681 * devm_clk_register - resource managed clk_register()
2682 * @dev: device that is registering this clock
2683 * @hw: link to hardware-specific clock data
2684 *
2685 * Managed clk_register(). Clocks returned from this function are
2686 * automatically clk_unregister()ed on driver detach. See clk_register() for
2687 * more information.
2688 */
2689struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw)
2690{
2691 struct clk *clk;
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002692 struct clk **clkp;
Stephen Boyd46c87732012-09-24 13:38:04 -07002693
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002694 clkp = devres_alloc(devm_clk_release, sizeof(*clkp), GFP_KERNEL);
2695 if (!clkp)
Stephen Boyd46c87732012-09-24 13:38:04 -07002696 return ERR_PTR(-ENOMEM);
2697
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002698 clk = clk_register(dev, hw);
2699 if (!IS_ERR(clk)) {
2700 *clkp = clk;
2701 devres_add(dev, clkp);
Stephen Boyd46c87732012-09-24 13:38:04 -07002702 } else {
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002703 devres_free(clkp);
Stephen Boyd46c87732012-09-24 13:38:04 -07002704 }
2705
2706 return clk;
2707}
2708EXPORT_SYMBOL_GPL(devm_clk_register);
2709
2710static int devm_clk_match(struct device *dev, void *res, void *data)
2711{
2712 struct clk *c = res;
2713 if (WARN_ON(!c))
2714 return 0;
2715 return c == data;
2716}
2717
2718/**
2719 * devm_clk_unregister - resource managed clk_unregister()
2720 * @clk: clock to unregister
2721 *
2722 * Deallocate a clock allocated with devm_clk_register(). Normally
2723 * this function will not need to be called and the resource management
2724 * code will ensure that the resource is freed.
2725 */
2726void devm_clk_unregister(struct device *dev, struct clk *clk)
2727{
2728 WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk));
2729}
2730EXPORT_SYMBOL_GPL(devm_clk_unregister);
2731
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002732/*
2733 * clkdev helpers
2734 */
2735int __clk_get(struct clk *clk)
2736{
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002737 struct clk_core *core = !clk ? NULL : clk->core;
2738
2739 if (core) {
2740 if (!try_module_get(core->owner))
Sylwester Nawrocki00efcb12014-01-07 13:03:43 +01002741 return 0;
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002742
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002743 kref_get(&core->ref);
Sylwester Nawrocki00efcb12014-01-07 13:03:43 +01002744 }
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002745 return 1;
2746}
2747
2748void __clk_put(struct clk *clk)
2749{
Tomeu Vizoso10cdfe52014-12-02 08:54:19 +01002750 struct module *owner;
2751
Sylwester Nawrocki00efcb12014-01-07 13:03:43 +01002752 if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002753 return;
2754
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002755 clk_prepare_lock();
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002756
Stephen Boyd50595f82015-02-06 11:42:44 -08002757 hlist_del(&clk->clks_node);
Tomeu Vizosoec02ace2015-02-06 15:13:01 +01002758 if (clk->min_rate > clk->core->req_rate ||
2759 clk->max_rate < clk->core->req_rate)
2760 clk_core_set_rate_nolock(clk->core, clk->core->req_rate);
2761
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002762 owner = clk->core->owner;
2763 kref_put(&clk->core->ref, __clk_release);
2764
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002765 clk_prepare_unlock();
2766
Tomeu Vizoso10cdfe52014-12-02 08:54:19 +01002767 module_put(owner);
Tomeu Vizoso1c8e6002015-01-23 12:03:31 +01002768
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002769 kfree(clk);
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002770}
2771
Mike Turquetteb24764902012-03-15 23:11:19 -07002772/*** clk rate change notifiers ***/
2773
2774/**
2775 * clk_notifier_register - add a clk rate change notifier
2776 * @clk: struct clk * to watch
2777 * @nb: struct notifier_block * with callback info
2778 *
2779 * Request notification when clk's rate changes. This uses an SRCU
2780 * notifier because we want it to block and notifier unregistrations are
2781 * uncommon. The callbacks associated with the notifier must not
2782 * re-enter into the clk framework by calling any top-level clk APIs;
2783 * this will cause a nested prepare_lock mutex.
2784 *
Masahiro Yamada198bb592015-11-30 16:40:51 +09002785 * In all notification cases (pre, post and abort rate change) the original
2786 * clock rate is passed to the callback via struct clk_notifier_data.old_rate
2787 * and the new frequency is passed via struct clk_notifier_data.new_rate.
Mike Turquetteb24764902012-03-15 23:11:19 -07002788 *
Mike Turquetteb24764902012-03-15 23:11:19 -07002789 * clk_notifier_register() must be called from non-atomic context.
2790 * Returns -EINVAL if called with null arguments, -ENOMEM upon
2791 * allocation failure; otherwise, passes along the return value of
2792 * srcu_notifier_chain_register().
2793 */
2794int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
2795{
2796 struct clk_notifier *cn;
2797 int ret = -ENOMEM;
2798
2799 if (!clk || !nb)
2800 return -EINVAL;
2801
Mike Turquetteeab89f62013-03-28 13:59:01 -07002802 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002803
2804 /* search the list of notifiers for this clk */
2805 list_for_each_entry(cn, &clk_notifier_list, node)
2806 if (cn->clk == clk)
2807 break;
2808
2809 /* if clk wasn't in the notifier list, allocate new clk_notifier */
2810 if (cn->clk != clk) {
2811 cn = kzalloc(sizeof(struct clk_notifier), GFP_KERNEL);
2812 if (!cn)
2813 goto out;
2814
2815 cn->clk = clk;
2816 srcu_init_notifier_head(&cn->notifier_head);
2817
2818 list_add(&cn->node, &clk_notifier_list);
2819 }
2820
2821 ret = srcu_notifier_chain_register(&cn->notifier_head, nb);
2822
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002823 clk->core->notifier_count++;
Mike Turquetteb24764902012-03-15 23:11:19 -07002824
2825out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07002826 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002827
2828 return ret;
2829}
2830EXPORT_SYMBOL_GPL(clk_notifier_register);
2831
2832/**
2833 * clk_notifier_unregister - remove a clk rate change notifier
2834 * @clk: struct clk *
2835 * @nb: struct notifier_block * with callback info
2836 *
2837 * Request no further notification for changes to 'clk' and frees memory
2838 * allocated in clk_notifier_register.
2839 *
2840 * Returns -EINVAL if called with null arguments; otherwise, passes
2841 * along the return value of srcu_notifier_chain_unregister().
2842 */
2843int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
2844{
2845 struct clk_notifier *cn = NULL;
2846 int ret = -EINVAL;
2847
2848 if (!clk || !nb)
2849 return -EINVAL;
2850
Mike Turquetteeab89f62013-03-28 13:59:01 -07002851 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002852
2853 list_for_each_entry(cn, &clk_notifier_list, node)
2854 if (cn->clk == clk)
2855 break;
2856
2857 if (cn->clk == clk) {
2858 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb);
2859
Tomeu Vizoso035a61c2015-01-23 12:03:30 +01002860 clk->core->notifier_count--;
Mike Turquetteb24764902012-03-15 23:11:19 -07002861
2862 /* XXX the notifier code should handle this better */
2863 if (!cn->notifier_head.head) {
2864 srcu_cleanup_notifier_head(&cn->notifier_head);
Lai Jiangshan72b53222013-06-03 17:17:15 +08002865 list_del(&cn->node);
Mike Turquetteb24764902012-03-15 23:11:19 -07002866 kfree(cn);
2867 }
2868
2869 } else {
2870 ret = -ENOENT;
2871 }
2872
Mike Turquetteeab89f62013-03-28 13:59:01 -07002873 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002874
2875 return ret;
2876}
2877EXPORT_SYMBOL_GPL(clk_notifier_unregister);
Grant Likely766e6a42012-04-09 14:50:06 -05002878
2879#ifdef CONFIG_OF
2880/**
2881 * struct of_clk_provider - Clock provider registration structure
2882 * @link: Entry in global list of clock providers
2883 * @node: Pointer to device tree node of clock provider
2884 * @get: Get clock callback. Returns NULL or a struct clk for the
2885 * given clock specifier
2886 * @data: context pointer to be passed into @get callback
2887 */
2888struct of_clk_provider {
2889 struct list_head link;
2890
2891 struct device_node *node;
2892 struct clk *(*get)(struct of_phandle_args *clkspec, void *data);
2893 void *data;
2894};
2895
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05302896static const struct of_device_id __clk_of_table_sentinel
2897 __used __section(__clk_of_table_end);
2898
Grant Likely766e6a42012-04-09 14:50:06 -05002899static LIST_HEAD(of_clk_providers);
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002900static DEFINE_MUTEX(of_clk_mutex);
2901
Grant Likely766e6a42012-04-09 14:50:06 -05002902struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
2903 void *data)
2904{
2905 return data;
2906}
2907EXPORT_SYMBOL_GPL(of_clk_src_simple_get);
2908
Shawn Guo494bfec2012-08-22 21:36:27 +08002909struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data)
2910{
2911 struct clk_onecell_data *clk_data = data;
2912 unsigned int idx = clkspec->args[0];
2913
2914 if (idx >= clk_data->clk_num) {
Geert Uytterhoeven7e963532015-10-16 17:12:32 +02002915 pr_err("%s: invalid clock index %u\n", __func__, idx);
Shawn Guo494bfec2012-08-22 21:36:27 +08002916 return ERR_PTR(-EINVAL);
2917 }
2918
2919 return clk_data->clks[idx];
2920}
2921EXPORT_SYMBOL_GPL(of_clk_src_onecell_get);
2922
Grant Likely766e6a42012-04-09 14:50:06 -05002923/**
2924 * of_clk_add_provider() - Register a clock provider for a node
2925 * @np: Device node pointer associated with clock provider
2926 * @clk_src_get: callback for decoding clock
2927 * @data: context pointer for @clk_src_get callback.
2928 */
2929int of_clk_add_provider(struct device_node *np,
2930 struct clk *(*clk_src_get)(struct of_phandle_args *clkspec,
2931 void *data),
2932 void *data)
2933{
2934 struct of_clk_provider *cp;
Sylwester Nawrocki86be4082014-06-18 17:29:32 +02002935 int ret;
Grant Likely766e6a42012-04-09 14:50:06 -05002936
2937 cp = kzalloc(sizeof(struct of_clk_provider), GFP_KERNEL);
2938 if (!cp)
2939 return -ENOMEM;
2940
2941 cp->node = of_node_get(np);
2942 cp->data = data;
2943 cp->get = clk_src_get;
2944
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002945 mutex_lock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002946 list_add(&cp->link, &of_clk_providers);
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002947 mutex_unlock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002948 pr_debug("Added clock from %s\n", np->full_name);
2949
Sylwester Nawrocki86be4082014-06-18 17:29:32 +02002950 ret = of_clk_set_defaults(np, true);
2951 if (ret < 0)
2952 of_clk_del_provider(np);
2953
2954 return ret;
Grant Likely766e6a42012-04-09 14:50:06 -05002955}
2956EXPORT_SYMBOL_GPL(of_clk_add_provider);
2957
2958/**
2959 * of_clk_del_provider() - Remove a previously registered clock provider
2960 * @np: Device node pointer associated with clock provider
2961 */
2962void of_clk_del_provider(struct device_node *np)
2963{
2964 struct of_clk_provider *cp;
2965
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002966 mutex_lock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002967 list_for_each_entry(cp, &of_clk_providers, link) {
2968 if (cp->node == np) {
2969 list_del(&cp->link);
2970 of_node_put(cp->node);
2971 kfree(cp);
2972 break;
2973 }
2974 }
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002975 mutex_unlock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002976}
2977EXPORT_SYMBOL_GPL(of_clk_del_provider);
2978
Stephen Boyd73e0e492015-02-06 11:42:43 -08002979struct clk *__of_clk_get_from_provider(struct of_phandle_args *clkspec,
2980 const char *dev_id, const char *con_id)
Grant Likely766e6a42012-04-09 14:50:06 -05002981{
2982 struct of_clk_provider *provider;
Jean-Francois Moinea34cd462013-11-25 19:47:04 +01002983 struct clk *clk = ERR_PTR(-EPROBE_DEFER);
Grant Likely766e6a42012-04-09 14:50:06 -05002984
Stephen Boyd306c3422015-02-05 15:39:11 -08002985 if (!clkspec)
2986 return ERR_PTR(-EINVAL);
2987
Grant Likely766e6a42012-04-09 14:50:06 -05002988 /* Check if we have such a provider in our array */
Stephen Boyd306c3422015-02-05 15:39:11 -08002989 mutex_lock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002990 list_for_each_entry(provider, &of_clk_providers, link) {
2991 if (provider->node == clkspec->np)
2992 clk = provider->get(clkspec, provider->data);
Stephen Boyd73e0e492015-02-06 11:42:43 -08002993 if (!IS_ERR(clk)) {
2994 clk = __clk_create_clk(__clk_get_hw(clk), dev_id,
2995 con_id);
2996
2997 if (!IS_ERR(clk) && !__clk_get(clk)) {
2998 __clk_free_clk(clk);
2999 clk = ERR_PTR(-ENOENT);
3000 }
3001
Grant Likely766e6a42012-04-09 14:50:06 -05003002 break;
Stephen Boyd73e0e492015-02-06 11:42:43 -08003003 }
Grant Likely766e6a42012-04-09 14:50:06 -05003004 }
Stephen Boyd306c3422015-02-05 15:39:11 -08003005 mutex_unlock(&of_clk_mutex);
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02003006
3007 return clk;
3008}
3009
Stephen Boyd306c3422015-02-05 15:39:11 -08003010/**
3011 * of_clk_get_from_provider() - Lookup a clock from a clock provider
3012 * @clkspec: pointer to a clock specifier data structure
3013 *
3014 * This function looks up a struct clk from the registered list of clock
3015 * providers, an input is a clock specifier data structure as returned
3016 * from the of_parse_phandle_with_args() function call.
3017 */
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02003018struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
3019{
Stephen Boyd306c3422015-02-05 15:39:11 -08003020 return __of_clk_get_from_provider(clkspec, NULL, __func__);
Grant Likely766e6a42012-04-09 14:50:06 -05003021}
Andrew F. Davisfb4dd222016-02-12 12:50:16 -06003022EXPORT_SYMBOL_GPL(of_clk_get_from_provider);
Grant Likely766e6a42012-04-09 14:50:06 -05003023
Mike Turquettef6102742013-10-07 23:12:13 -07003024int of_clk_get_parent_count(struct device_node *np)
3025{
3026 return of_count_phandle_with_args(np, "clocks", "#clock-cells");
3027}
3028EXPORT_SYMBOL_GPL(of_clk_get_parent_count);
3029
Grant Likely766e6a42012-04-09 14:50:06 -05003030const char *of_clk_get_parent_name(struct device_node *np, int index)
3031{
3032 struct of_phandle_args clkspec;
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00003033 struct property *prop;
Grant Likely766e6a42012-04-09 14:50:06 -05003034 const char *clk_name;
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00003035 const __be32 *vp;
3036 u32 pv;
Grant Likely766e6a42012-04-09 14:50:06 -05003037 int rc;
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00003038 int count;
Stephen Boyd0a4807c2015-10-14 14:03:07 -07003039 struct clk *clk;
Grant Likely766e6a42012-04-09 14:50:06 -05003040
Grant Likely766e6a42012-04-09 14:50:06 -05003041 rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
3042 &clkspec);
3043 if (rc)
3044 return NULL;
3045
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00003046 index = clkspec.args_count ? clkspec.args[0] : 0;
3047 count = 0;
3048
3049 /* if there is an indices property, use it to transfer the index
3050 * specified into an array offset for the clock-output-names property.
3051 */
3052 of_property_for_each_u32(clkspec.np, "clock-indices", prop, vp, pv) {
3053 if (index == pv) {
3054 index = count;
3055 break;
3056 }
3057 count++;
3058 }
Masahiro Yamada8da411c2015-12-03 11:20:35 +09003059 /* We went off the end of 'clock-indices' without finding it */
3060 if (prop && !vp)
3061 return NULL;
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00003062
Grant Likely766e6a42012-04-09 14:50:06 -05003063 if (of_property_read_string_index(clkspec.np, "clock-output-names",
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00003064 index,
Stephen Boyd0a4807c2015-10-14 14:03:07 -07003065 &clk_name) < 0) {
3066 /*
3067 * Best effort to get the name if the clock has been
3068 * registered with the framework. If the clock isn't
3069 * registered, we return the node name as the name of
3070 * the clock as long as #clock-cells = 0.
3071 */
3072 clk = of_clk_get_from_provider(&clkspec);
3073 if (IS_ERR(clk)) {
3074 if (clkspec.args_count == 0)
3075 clk_name = clkspec.np->name;
3076 else
3077 clk_name = NULL;
3078 } else {
3079 clk_name = __clk_get_name(clk);
3080 clk_put(clk);
3081 }
3082 }
3083
Grant Likely766e6a42012-04-09 14:50:06 -05003084
3085 of_node_put(clkspec.np);
3086 return clk_name;
3087}
3088EXPORT_SYMBOL_GPL(of_clk_get_parent_name);
3089
Dinh Nguyen2e61dfb2015-06-05 11:26:13 -05003090/**
3091 * of_clk_parent_fill() - Fill @parents with names of @np's parents and return
3092 * number of parents
3093 * @np: Device node pointer associated with clock provider
3094 * @parents: pointer to char array that hold the parents' names
3095 * @size: size of the @parents array
3096 *
3097 * Return: number of parents for the clock node.
3098 */
3099int of_clk_parent_fill(struct device_node *np, const char **parents,
3100 unsigned int size)
3101{
3102 unsigned int i = 0;
3103
3104 while (i < size && (parents[i] = of_clk_get_parent_name(np, i)) != NULL)
3105 i++;
3106
3107 return i;
3108}
3109EXPORT_SYMBOL_GPL(of_clk_parent_fill);
3110
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003111struct clock_provider {
3112 of_clk_init_cb_t clk_init_cb;
3113 struct device_node *np;
3114 struct list_head node;
3115};
3116
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003117/*
3118 * This function looks for a parent clock. If there is one, then it
3119 * checks that the provider for this parent clock was initialized, in
3120 * this case the parent clock will be ready.
3121 */
3122static int parent_ready(struct device_node *np)
3123{
3124 int i = 0;
3125
3126 while (true) {
3127 struct clk *clk = of_clk_get(np, i);
3128
3129 /* this parent is ready we can check the next one */
3130 if (!IS_ERR(clk)) {
3131 clk_put(clk);
3132 i++;
3133 continue;
3134 }
3135
3136 /* at least one parent is not ready, we exit now */
3137 if (PTR_ERR(clk) == -EPROBE_DEFER)
3138 return 0;
3139
3140 /*
3141 * Here we make assumption that the device tree is
3142 * written correctly. So an error means that there is
3143 * no more parent. As we didn't exit yet, then the
3144 * previous parent are ready. If there is no clock
3145 * parent, no need to wait for them, then we can
3146 * consider their absence as being ready
3147 */
3148 return 1;
3149 }
3150}
3151
Grant Likely766e6a42012-04-09 14:50:06 -05003152/**
3153 * of_clk_init() - Scan and init clock providers from the DT
3154 * @matches: array of compatible values and init functions for providers.
3155 *
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003156 * This function scans the device tree for matching clock providers
Sylwester Nawrockie5ca8fb42014-03-27 12:08:36 +01003157 * and calls their initialization functions. It also does it by trying
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003158 * to follow the dependencies.
Grant Likely766e6a42012-04-09 14:50:06 -05003159 */
3160void __init of_clk_init(const struct of_device_id *matches)
3161{
Alex Elder7f7ed582013-08-22 11:31:31 -05003162 const struct of_device_id *match;
Grant Likely766e6a42012-04-09 14:50:06 -05003163 struct device_node *np;
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003164 struct clock_provider *clk_provider, *next;
3165 bool is_init_done;
3166 bool force = false;
Stephen Boyd2573a022015-07-06 16:50:00 -07003167 LIST_HEAD(clk_provider_list);
Grant Likely766e6a42012-04-09 14:50:06 -05003168
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05303169 if (!matches)
Tero Kristo819b4862013-10-22 11:39:36 +03003170 matches = &__clk_of_table;
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05303171
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003172 /* First prepare the list of the clocks providers */
Alex Elder7f7ed582013-08-22 11:31:31 -05003173 for_each_matching_node_and_match(np, matches, &match) {
Stephen Boyd2e3b19f2015-07-06 16:48:19 -07003174 struct clock_provider *parent;
3175
3176 parent = kzalloc(sizeof(*parent), GFP_KERNEL);
3177 if (!parent) {
3178 list_for_each_entry_safe(clk_provider, next,
3179 &clk_provider_list, node) {
3180 list_del(&clk_provider->node);
Julia Lawall6bc9d9d2015-10-21 22:41:36 +02003181 of_node_put(clk_provider->np);
Stephen Boyd2e3b19f2015-07-06 16:48:19 -07003182 kfree(clk_provider);
3183 }
Julia Lawall6bc9d9d2015-10-21 22:41:36 +02003184 of_node_put(np);
Stephen Boyd2e3b19f2015-07-06 16:48:19 -07003185 return;
3186 }
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003187
3188 parent->clk_init_cb = match->data;
Julia Lawall6bc9d9d2015-10-21 22:41:36 +02003189 parent->np = of_node_get(np);
Sylwester Nawrocki3f6d4392014-03-27 11:43:32 +01003190 list_add_tail(&parent->node, &clk_provider_list);
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003191 }
3192
3193 while (!list_empty(&clk_provider_list)) {
3194 is_init_done = false;
3195 list_for_each_entry_safe(clk_provider, next,
3196 &clk_provider_list, node) {
3197 if (force || parent_ready(clk_provider->np)) {
Sylwester Nawrocki86be4082014-06-18 17:29:32 +02003198
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003199 clk_provider->clk_init_cb(clk_provider->np);
Sylwester Nawrocki86be4082014-06-18 17:29:32 +02003200 of_clk_set_defaults(clk_provider->np, true);
3201
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003202 list_del(&clk_provider->node);
Julia Lawall6bc9d9d2015-10-21 22:41:36 +02003203 of_node_put(clk_provider->np);
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003204 kfree(clk_provider);
3205 is_init_done = true;
3206 }
3207 }
3208
3209 /*
Sylwester Nawrockie5ca8fb42014-03-27 12:08:36 +01003210 * We didn't manage to initialize any of the
Gregory CLEMENT1771b102014-02-24 19:10:13 +01003211 * remaining providers during the last loop, so now we
3212 * initialize all the remaining ones unconditionally
3213 * in case the clock parent was not mandatory
3214 */
3215 if (!is_init_done)
3216 force = true;
Grant Likely766e6a42012-04-09 14:50:06 -05003217 }
3218}
3219#endif