blob: bacc06ff939b090bffb9ef9759ac9b9058520a98 [file] [log] [blame]
Mike Turquetteb24764902012-03-15 23:11:19 -07001/*
2 * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
3 * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Standard functionality for the common clock API. See Documentation/clk.txt
10 */
11
12#include <linux/clk-private.h>
Sylwester Nawrocki86be4082014-06-18 17:29:32 +020013#include <linux/clk/clk-conf.h>
Mike Turquetteb24764902012-03-15 23:11:19 -070014#include <linux/module.h>
15#include <linux/mutex.h>
16#include <linux/spinlock.h>
17#include <linux/err.h>
18#include <linux/list.h>
19#include <linux/slab.h>
Grant Likely766e6a42012-04-09 14:50:06 -050020#include <linux/of.h>
Stephen Boyd46c87732012-09-24 13:38:04 -070021#include <linux/device.h>
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +053022#include <linux/init.h>
Mike Turquette533ddeb2013-03-28 13:59:02 -070023#include <linux/sched.h>
Mike Turquetteb24764902012-03-15 23:11:19 -070024
Sylwester Nawrockid6782c22013-08-23 17:03:43 +020025#include "clk.h"
26
Mike Turquetteb24764902012-03-15 23:11:19 -070027static DEFINE_SPINLOCK(enable_lock);
28static DEFINE_MUTEX(prepare_lock);
29
Mike Turquette533ddeb2013-03-28 13:59:02 -070030static struct task_struct *prepare_owner;
31static struct task_struct *enable_owner;
32
33static int prepare_refcnt;
34static int enable_refcnt;
35
Mike Turquetteb24764902012-03-15 23:11:19 -070036static HLIST_HEAD(clk_root_list);
37static HLIST_HEAD(clk_orphan_list);
38static LIST_HEAD(clk_notifier_list);
39
Mike Turquetteeab89f62013-03-28 13:59:01 -070040/*** locking ***/
41static void clk_prepare_lock(void)
42{
Mike Turquette533ddeb2013-03-28 13:59:02 -070043 if (!mutex_trylock(&prepare_lock)) {
44 if (prepare_owner == current) {
45 prepare_refcnt++;
46 return;
47 }
48 mutex_lock(&prepare_lock);
49 }
50 WARN_ON_ONCE(prepare_owner != NULL);
51 WARN_ON_ONCE(prepare_refcnt != 0);
52 prepare_owner = current;
53 prepare_refcnt = 1;
Mike Turquetteeab89f62013-03-28 13:59:01 -070054}
55
56static void clk_prepare_unlock(void)
57{
Mike Turquette533ddeb2013-03-28 13:59:02 -070058 WARN_ON_ONCE(prepare_owner != current);
59 WARN_ON_ONCE(prepare_refcnt == 0);
60
61 if (--prepare_refcnt)
62 return;
63 prepare_owner = NULL;
Mike Turquetteeab89f62013-03-28 13:59:01 -070064 mutex_unlock(&prepare_lock);
65}
66
67static unsigned long clk_enable_lock(void)
68{
69 unsigned long flags;
Mike Turquette533ddeb2013-03-28 13:59:02 -070070
71 if (!spin_trylock_irqsave(&enable_lock, flags)) {
72 if (enable_owner == current) {
73 enable_refcnt++;
74 return flags;
75 }
76 spin_lock_irqsave(&enable_lock, flags);
77 }
78 WARN_ON_ONCE(enable_owner != NULL);
79 WARN_ON_ONCE(enable_refcnt != 0);
80 enable_owner = current;
81 enable_refcnt = 1;
Mike Turquetteeab89f62013-03-28 13:59:01 -070082 return flags;
83}
84
85static void clk_enable_unlock(unsigned long flags)
86{
Mike Turquette533ddeb2013-03-28 13:59:02 -070087 WARN_ON_ONCE(enable_owner != current);
88 WARN_ON_ONCE(enable_refcnt == 0);
89
90 if (--enable_refcnt)
91 return;
92 enable_owner = NULL;
Mike Turquetteeab89f62013-03-28 13:59:01 -070093 spin_unlock_irqrestore(&enable_lock, flags);
94}
95
Mike Turquetteb24764902012-03-15 23:11:19 -070096/*** debugfs support ***/
97
Mike Turquetteea72dc22013-12-18 21:38:52 -080098#ifdef CONFIG_DEBUG_FS
Mike Turquetteb24764902012-03-15 23:11:19 -070099#include <linux/debugfs.h>
100
101static struct dentry *rootdir;
Mike Turquetteb24764902012-03-15 23:11:19 -0700102static int inited = 0;
103
Sachin Kamat6b44c8542014-07-01 11:56:34 +0530104static struct hlist_head *all_lists[] = {
105 &clk_root_list,
106 &clk_orphan_list,
107 NULL,
108};
109
110static struct hlist_head *orphan_list[] = {
111 &clk_orphan_list,
112 NULL,
113};
114
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530115static void clk_summary_show_one(struct seq_file *s, struct clk *c, int level)
116{
117 if (!c)
118 return;
119
Geert Uytterhoevenfb8abb72014-03-25 12:16:24 +0100120 seq_printf(s, "%*s%-*s %11d %12d %11lu %10lu\n",
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530121 level * 3 + 1, "",
122 30 - level * 3, c->name,
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100123 c->enable_count, c->prepare_count, clk_get_rate(c),
124 clk_get_accuracy(c));
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530125}
126
127static void clk_summary_show_subtree(struct seq_file *s, struct clk *c,
128 int level)
129{
130 struct clk *child;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530131
132 if (!c)
133 return;
134
135 clk_summary_show_one(s, c, level);
136
Sasha Levinb67bfe02013-02-27 17:06:00 -0800137 hlist_for_each_entry(child, &c->children, child_node)
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530138 clk_summary_show_subtree(s, child, level + 1);
139}
140
141static int clk_summary_show(struct seq_file *s, void *data)
142{
143 struct clk *c;
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300144 struct hlist_head **lists = (struct hlist_head **)s->private;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530145
Geert Uytterhoevenfb8abb72014-03-25 12:16:24 +0100146 seq_puts(s, " clock enable_cnt prepare_cnt rate accuracy\n");
147 seq_puts(s, "--------------------------------------------------------------------------------\n");
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530148
Mike Turquetteeab89f62013-03-28 13:59:01 -0700149 clk_prepare_lock();
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530150
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300151 for (; *lists; lists++)
152 hlist_for_each_entry(c, *lists, child_node)
153 clk_summary_show_subtree(s, c, 0);
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530154
Mike Turquetteeab89f62013-03-28 13:59:01 -0700155 clk_prepare_unlock();
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530156
157 return 0;
158}
159
160
161static int clk_summary_open(struct inode *inode, struct file *file)
162{
163 return single_open(file, clk_summary_show, inode->i_private);
164}
165
166static const struct file_operations clk_summary_fops = {
167 .open = clk_summary_open,
168 .read = seq_read,
169 .llseek = seq_lseek,
170 .release = single_release,
171};
172
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530173static void clk_dump_one(struct seq_file *s, struct clk *c, int level)
174{
175 if (!c)
176 return;
177
178 seq_printf(s, "\"%s\": { ", c->name);
179 seq_printf(s, "\"enable_count\": %d,", c->enable_count);
180 seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
Peter De Schrijver670decd2013-06-05 18:06:35 +0300181 seq_printf(s, "\"rate\": %lu", clk_get_rate(c));
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100182 seq_printf(s, "\"accuracy\": %lu", clk_get_accuracy(c));
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530183}
184
185static void clk_dump_subtree(struct seq_file *s, struct clk *c, int level)
186{
187 struct clk *child;
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530188
189 if (!c)
190 return;
191
192 clk_dump_one(s, c, level);
193
Sasha Levinb67bfe02013-02-27 17:06:00 -0800194 hlist_for_each_entry(child, &c->children, child_node) {
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530195 seq_printf(s, ",");
196 clk_dump_subtree(s, child, level + 1);
197 }
198
199 seq_printf(s, "}");
200}
201
202static int clk_dump(struct seq_file *s, void *data)
203{
204 struct clk *c;
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530205 bool first_node = true;
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300206 struct hlist_head **lists = (struct hlist_head **)s->private;
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530207
208 seq_printf(s, "{");
209
Mike Turquetteeab89f62013-03-28 13:59:01 -0700210 clk_prepare_lock();
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530211
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300212 for (; *lists; lists++) {
213 hlist_for_each_entry(c, *lists, child_node) {
214 if (!first_node)
215 seq_puts(s, ",");
216 first_node = false;
217 clk_dump_subtree(s, c, 0);
218 }
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530219 }
220
Mike Turquetteeab89f62013-03-28 13:59:01 -0700221 clk_prepare_unlock();
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530222
223 seq_printf(s, "}");
224 return 0;
225}
226
227
228static int clk_dump_open(struct inode *inode, struct file *file)
229{
230 return single_open(file, clk_dump, inode->i_private);
231}
232
233static const struct file_operations clk_dump_fops = {
234 .open = clk_dump_open,
235 .read = seq_read,
236 .llseek = seq_lseek,
237 .release = single_release,
238};
239
Mike Turquetteb24764902012-03-15 23:11:19 -0700240/* caller must hold prepare_lock */
241static int clk_debug_create_one(struct clk *clk, struct dentry *pdentry)
242{
243 struct dentry *d;
244 int ret = -ENOMEM;
245
246 if (!clk || !pdentry) {
247 ret = -EINVAL;
248 goto out;
249 }
250
251 d = debugfs_create_dir(clk->name, pdentry);
252 if (!d)
253 goto out;
254
255 clk->dentry = d;
256
257 d = debugfs_create_u32("clk_rate", S_IRUGO, clk->dentry,
258 (u32 *)&clk->rate);
259 if (!d)
260 goto err_out;
261
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100262 d = debugfs_create_u32("clk_accuracy", S_IRUGO, clk->dentry,
263 (u32 *)&clk->accuracy);
264 if (!d)
265 goto err_out;
266
Mike Turquetteb24764902012-03-15 23:11:19 -0700267 d = debugfs_create_x32("clk_flags", S_IRUGO, clk->dentry,
268 (u32 *)&clk->flags);
269 if (!d)
270 goto err_out;
271
272 d = debugfs_create_u32("clk_prepare_count", S_IRUGO, clk->dentry,
273 (u32 *)&clk->prepare_count);
274 if (!d)
275 goto err_out;
276
277 d = debugfs_create_u32("clk_enable_count", S_IRUGO, clk->dentry,
278 (u32 *)&clk->enable_count);
279 if (!d)
280 goto err_out;
281
282 d = debugfs_create_u32("clk_notifier_count", S_IRUGO, clk->dentry,
283 (u32 *)&clk->notifier_count);
284 if (!d)
285 goto err_out;
286
Chris Brandabeab452014-07-03 14:01:29 -0700287 if (clk->ops->debug_init) {
288 ret = clk->ops->debug_init(clk->hw, clk->dentry);
289 if (ret)
Alex Elderc646cbf2014-03-21 06:43:56 -0500290 goto err_out;
Chris Brandabeab452014-07-03 14:01:29 -0700291 }
Alex Elderc646cbf2014-03-21 06:43:56 -0500292
Mike Turquetteb24764902012-03-15 23:11:19 -0700293 ret = 0;
294 goto out;
295
296err_out:
Alex Elderb5f98e62013-11-27 09:39:49 -0600297 debugfs_remove_recursive(clk->dentry);
298 clk->dentry = NULL;
Mike Turquetteb24764902012-03-15 23:11:19 -0700299out:
300 return ret;
301}
302
303/* caller must hold prepare_lock */
304static int clk_debug_create_subtree(struct clk *clk, struct dentry *pdentry)
305{
306 struct clk *child;
Mike Turquetteb24764902012-03-15 23:11:19 -0700307 int ret = -EINVAL;;
308
309 if (!clk || !pdentry)
310 goto out;
311
312 ret = clk_debug_create_one(clk, pdentry);
313
314 if (ret)
315 goto out;
316
Sasha Levinb67bfe02013-02-27 17:06:00 -0800317 hlist_for_each_entry(child, &clk->children, child_node)
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300318 clk_debug_create_subtree(child, pdentry);
Mike Turquetteb24764902012-03-15 23:11:19 -0700319
320 ret = 0;
321out:
322 return ret;
323}
324
325/**
326 * clk_debug_register - add a clk node to the debugfs clk tree
327 * @clk: the clk being added to the debugfs clk tree
328 *
329 * Dynamically adds a clk to the debugfs clk tree if debugfs has been
330 * initialized. Otherwise it bails out early since the debugfs clk tree
331 * will be created lazily by clk_debug_init as part of a late_initcall.
332 *
333 * Caller must hold prepare_lock. Only clk_init calls this function (so
334 * far) so this is taken care.
335 */
336static int clk_debug_register(struct clk *clk)
337{
Mike Turquetteb24764902012-03-15 23:11:19 -0700338 int ret = 0;
339
340 if (!inited)
341 goto out;
342
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300343 ret = clk_debug_create_subtree(clk, rootdir);
Mike Turquetteb24764902012-03-15 23:11:19 -0700344
345out:
346 return ret;
347}
348
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +0200349 /**
350 * clk_debug_unregister - remove a clk node from the debugfs clk tree
351 * @clk: the clk being removed from the debugfs clk tree
352 *
353 * Dynamically removes a clk and all it's children clk nodes from the
354 * debugfs clk tree if clk->dentry points to debugfs created by
355 * clk_debug_register in __clk_init.
356 *
357 * Caller must hold prepare_lock.
358 */
359static void clk_debug_unregister(struct clk *clk)
360{
361 debugfs_remove_recursive(clk->dentry);
362}
363
Peter De Schrijverfb2b3c92014-06-26 18:00:53 +0300364struct dentry *clk_debugfs_add_file(struct clk *clk, char *name, umode_t mode,
365 void *data, const struct file_operations *fops)
366{
367 struct dentry *d = NULL;
368
369 if (clk->dentry)
370 d = debugfs_create_file(name, mode, clk->dentry, data, fops);
371
372 return d;
373}
374EXPORT_SYMBOL_GPL(clk_debugfs_add_file);
375
Mike Turquetteb24764902012-03-15 23:11:19 -0700376/**
377 * clk_debug_init - lazily create the debugfs clk tree visualization
378 *
379 * clks are often initialized very early during boot before memory can
380 * be dynamically allocated and well before debugfs is setup.
381 * clk_debug_init walks the clk tree hierarchy while holding
382 * prepare_lock and creates the topology as part of a late_initcall,
383 * thus insuring that clks initialized very early will still be
384 * represented in the debugfs clk tree. This function should only be
385 * called once at boot-time, and all other clks added dynamically will
386 * be done so with clk_debug_register.
387 */
388static int __init clk_debug_init(void)
389{
390 struct clk *clk;
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530391 struct dentry *d;
Mike Turquetteb24764902012-03-15 23:11:19 -0700392
393 rootdir = debugfs_create_dir("clk", NULL);
394
395 if (!rootdir)
396 return -ENOMEM;
397
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300398 d = debugfs_create_file("clk_summary", S_IRUGO, rootdir, &all_lists,
Prashant Gaikwad1af599d2012-12-26 19:16:22 +0530399 &clk_summary_fops);
400 if (!d)
401 return -ENOMEM;
402
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300403 d = debugfs_create_file("clk_dump", S_IRUGO, rootdir, &all_lists,
Prashant Gaikwadbddca892012-12-26 19:16:23 +0530404 &clk_dump_fops);
405 if (!d)
406 return -ENOMEM;
407
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300408 d = debugfs_create_file("clk_orphan_summary", S_IRUGO, rootdir,
409 &orphan_list, &clk_summary_fops);
410 if (!d)
411 return -ENOMEM;
Mike Turquetteb24764902012-03-15 23:11:19 -0700412
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300413 d = debugfs_create_file("clk_orphan_dump", S_IRUGO, rootdir,
414 &orphan_list, &clk_dump_fops);
415 if (!d)
Mike Turquetteb24764902012-03-15 23:11:19 -0700416 return -ENOMEM;
417
Mike Turquetteeab89f62013-03-28 13:59:01 -0700418 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700419
Sasha Levinb67bfe02013-02-27 17:06:00 -0800420 hlist_for_each_entry(clk, &clk_root_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700421 clk_debug_create_subtree(clk, rootdir);
422
Sasha Levinb67bfe02013-02-27 17:06:00 -0800423 hlist_for_each_entry(clk, &clk_orphan_list, child_node)
Peter De Schrijver27b8d5f2014-05-30 18:03:57 +0300424 clk_debug_create_subtree(clk, rootdir);
Mike Turquetteb24764902012-03-15 23:11:19 -0700425
426 inited = 1;
427
Mike Turquetteeab89f62013-03-28 13:59:01 -0700428 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700429
430 return 0;
431}
432late_initcall(clk_debug_init);
433#else
434static inline int clk_debug_register(struct clk *clk) { return 0; }
Ulf Hanssonb33d2122013-04-02 23:09:37 +0200435static inline void clk_debug_reparent(struct clk *clk, struct clk *new_parent)
436{
437}
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +0200438static inline void clk_debug_unregister(struct clk *clk)
439{
440}
Mike Turquette70d347e2012-03-26 11:53:47 -0700441#endif
Mike Turquetteb24764902012-03-15 23:11:19 -0700442
Mike Turquetteb24764902012-03-15 23:11:19 -0700443/* caller must hold prepare_lock */
Ulf Hansson1c155b32013-03-12 20:26:03 +0100444static void clk_unprepare_unused_subtree(struct clk *clk)
445{
446 struct clk *child;
447
448 if (!clk)
449 return;
450
451 hlist_for_each_entry(child, &clk->children, child_node)
452 clk_unprepare_unused_subtree(child);
453
454 if (clk->prepare_count)
455 return;
456
457 if (clk->flags & CLK_IGNORE_UNUSED)
458 return;
459
Ulf Hansson3cc82472013-03-12 20:26:04 +0100460 if (__clk_is_prepared(clk)) {
461 if (clk->ops->unprepare_unused)
462 clk->ops->unprepare_unused(clk->hw);
463 else if (clk->ops->unprepare)
Ulf Hansson1c155b32013-03-12 20:26:03 +0100464 clk->ops->unprepare(clk->hw);
Ulf Hansson3cc82472013-03-12 20:26:04 +0100465 }
Ulf Hansson1c155b32013-03-12 20:26:03 +0100466}
467
468/* caller must hold prepare_lock */
Mike Turquetteb24764902012-03-15 23:11:19 -0700469static void clk_disable_unused_subtree(struct clk *clk)
470{
471 struct clk *child;
Mike Turquetteb24764902012-03-15 23:11:19 -0700472 unsigned long flags;
473
474 if (!clk)
475 goto out;
476
Sasha Levinb67bfe02013-02-27 17:06:00 -0800477 hlist_for_each_entry(child, &clk->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700478 clk_disable_unused_subtree(child);
479
Mike Turquetteeab89f62013-03-28 13:59:01 -0700480 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700481
482 if (clk->enable_count)
483 goto unlock_out;
484
485 if (clk->flags & CLK_IGNORE_UNUSED)
486 goto unlock_out;
487
Mike Turquette7c045a52012-12-04 11:00:35 -0800488 /*
489 * some gate clocks have special needs during the disable-unused
490 * sequence. call .disable_unused if available, otherwise fall
491 * back to .disable
492 */
493 if (__clk_is_enabled(clk)) {
494 if (clk->ops->disable_unused)
495 clk->ops->disable_unused(clk->hw);
496 else if (clk->ops->disable)
497 clk->ops->disable(clk->hw);
498 }
Mike Turquetteb24764902012-03-15 23:11:19 -0700499
500unlock_out:
Mike Turquetteeab89f62013-03-28 13:59:01 -0700501 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700502
503out:
504 return;
505}
506
Olof Johansson1e435252013-04-27 14:10:18 -0700507static bool clk_ignore_unused;
508static int __init clk_ignore_unused_setup(char *__unused)
509{
510 clk_ignore_unused = true;
511 return 1;
512}
513__setup("clk_ignore_unused", clk_ignore_unused_setup);
514
Mike Turquetteb24764902012-03-15 23:11:19 -0700515static int clk_disable_unused(void)
516{
517 struct clk *clk;
Mike Turquetteb24764902012-03-15 23:11:19 -0700518
Olof Johansson1e435252013-04-27 14:10:18 -0700519 if (clk_ignore_unused) {
520 pr_warn("clk: Not disabling unused clocks\n");
521 return 0;
522 }
523
Mike Turquetteeab89f62013-03-28 13:59:01 -0700524 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700525
Sasha Levinb67bfe02013-02-27 17:06:00 -0800526 hlist_for_each_entry(clk, &clk_root_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700527 clk_disable_unused_subtree(clk);
528
Sasha Levinb67bfe02013-02-27 17:06:00 -0800529 hlist_for_each_entry(clk, &clk_orphan_list, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -0700530 clk_disable_unused_subtree(clk);
531
Ulf Hansson1c155b32013-03-12 20:26:03 +0100532 hlist_for_each_entry(clk, &clk_root_list, child_node)
533 clk_unprepare_unused_subtree(clk);
534
535 hlist_for_each_entry(clk, &clk_orphan_list, child_node)
536 clk_unprepare_unused_subtree(clk);
537
Mike Turquetteeab89f62013-03-28 13:59:01 -0700538 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700539
540 return 0;
541}
Saravana Kannand41d5802013-05-09 11:35:01 -0700542late_initcall_sync(clk_disable_unused);
Mike Turquetteb24764902012-03-15 23:11:19 -0700543
544/*** helper functions ***/
545
Russ Dill65800b22012-11-26 11:20:09 -0800546const char *__clk_get_name(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700547{
548 return !clk ? NULL : clk->name;
549}
Niels de Vos48950842012-12-13 13:12:25 +0100550EXPORT_SYMBOL_GPL(__clk_get_name);
Mike Turquetteb24764902012-03-15 23:11:19 -0700551
Russ Dill65800b22012-11-26 11:20:09 -0800552struct clk_hw *__clk_get_hw(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700553{
554 return !clk ? NULL : clk->hw;
555}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800556EXPORT_SYMBOL_GPL(__clk_get_hw);
Mike Turquetteb24764902012-03-15 23:11:19 -0700557
Russ Dill65800b22012-11-26 11:20:09 -0800558u8 __clk_get_num_parents(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700559{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700560 return !clk ? 0 : clk->num_parents;
Mike Turquetteb24764902012-03-15 23:11:19 -0700561}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800562EXPORT_SYMBOL_GPL(__clk_get_num_parents);
Mike Turquetteb24764902012-03-15 23:11:19 -0700563
Russ Dill65800b22012-11-26 11:20:09 -0800564struct clk *__clk_get_parent(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700565{
566 return !clk ? NULL : clk->parent;
567}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800568EXPORT_SYMBOL_GPL(__clk_get_parent);
Mike Turquetteb24764902012-03-15 23:11:19 -0700569
James Hogan7ef3dcc2013-07-29 12:24:58 +0100570struct clk *clk_get_parent_by_index(struct clk *clk, u8 index)
571{
572 if (!clk || index >= clk->num_parents)
573 return NULL;
574 else if (!clk->parents)
575 return __clk_lookup(clk->parent_names[index]);
576 else if (!clk->parents[index])
577 return clk->parents[index] =
578 __clk_lookup(clk->parent_names[index]);
579 else
580 return clk->parents[index];
581}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800582EXPORT_SYMBOL_GPL(clk_get_parent_by_index);
James Hogan7ef3dcc2013-07-29 12:24:58 +0100583
Russ Dill65800b22012-11-26 11:20:09 -0800584unsigned int __clk_get_enable_count(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700585{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700586 return !clk ? 0 : clk->enable_count;
Mike Turquetteb24764902012-03-15 23:11:19 -0700587}
588
Russ Dill65800b22012-11-26 11:20:09 -0800589unsigned int __clk_get_prepare_count(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700590{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700591 return !clk ? 0 : clk->prepare_count;
Mike Turquetteb24764902012-03-15 23:11:19 -0700592}
593
594unsigned long __clk_get_rate(struct clk *clk)
595{
596 unsigned long ret;
597
598 if (!clk) {
Rajendra Nayak34e44fe2012-03-26 19:01:48 +0530599 ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700600 goto out;
601 }
602
603 ret = clk->rate;
604
605 if (clk->flags & CLK_IS_ROOT)
606 goto out;
607
608 if (!clk->parent)
Rajendra Nayak34e44fe2012-03-26 19:01:48 +0530609 ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700610
611out:
612 return ret;
613}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800614EXPORT_SYMBOL_GPL(__clk_get_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -0700615
Boris BREZILLON5279fc42013-12-21 10:34:47 +0100616unsigned long __clk_get_accuracy(struct clk *clk)
617{
618 if (!clk)
619 return 0;
620
621 return clk->accuracy;
622}
623
Russ Dill65800b22012-11-26 11:20:09 -0800624unsigned long __clk_get_flags(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700625{
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700626 return !clk ? 0 : clk->flags;
Mike Turquetteb24764902012-03-15 23:11:19 -0700627}
Thierry Redingb05c6832013-09-03 09:43:51 +0200628EXPORT_SYMBOL_GPL(__clk_get_flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700629
Ulf Hansson3d6ee282013-03-12 20:26:02 +0100630bool __clk_is_prepared(struct clk *clk)
631{
632 int ret;
633
634 if (!clk)
635 return false;
636
637 /*
638 * .is_prepared is optional for clocks that can prepare
639 * fall back to software usage counter if it is missing
640 */
641 if (!clk->ops->is_prepared) {
642 ret = clk->prepare_count ? 1 : 0;
643 goto out;
644 }
645
646 ret = clk->ops->is_prepared(clk->hw);
647out:
648 return !!ret;
649}
650
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700651bool __clk_is_enabled(struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -0700652{
653 int ret;
654
655 if (!clk)
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700656 return false;
Mike Turquetteb24764902012-03-15 23:11:19 -0700657
658 /*
659 * .is_enabled is only mandatory for clocks that gate
660 * fall back to software usage counter if .is_enabled is missing
661 */
662 if (!clk->ops->is_enabled) {
663 ret = clk->enable_count ? 1 : 0;
664 goto out;
665 }
666
667 ret = clk->ops->is_enabled(clk->hw);
668out:
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700669 return !!ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700670}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800671EXPORT_SYMBOL_GPL(__clk_is_enabled);
Mike Turquetteb24764902012-03-15 23:11:19 -0700672
673static struct clk *__clk_lookup_subtree(const char *name, struct clk *clk)
674{
675 struct clk *child;
676 struct clk *ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700677
678 if (!strcmp(clk->name, name))
679 return clk;
680
Sasha Levinb67bfe02013-02-27 17:06:00 -0800681 hlist_for_each_entry(child, &clk->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -0700682 ret = __clk_lookup_subtree(name, child);
683 if (ret)
684 return ret;
685 }
686
687 return NULL;
688}
689
690struct clk *__clk_lookup(const char *name)
691{
692 struct clk *root_clk;
693 struct clk *ret;
Mike Turquetteb24764902012-03-15 23:11:19 -0700694
695 if (!name)
696 return NULL;
697
698 /* search the 'proper' clk tree first */
Sasha Levinb67bfe02013-02-27 17:06:00 -0800699 hlist_for_each_entry(root_clk, &clk_root_list, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -0700700 ret = __clk_lookup_subtree(name, root_clk);
701 if (ret)
702 return ret;
703 }
704
705 /* if not found, then search the orphan tree */
Sasha Levinb67bfe02013-02-27 17:06:00 -0800706 hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -0700707 ret = __clk_lookup_subtree(name, root_clk);
708 if (ret)
709 return ret;
710 }
711
712 return NULL;
713}
714
James Hogane366fdd2013-07-29 12:25:02 +0100715/*
716 * Helper for finding best parent to provide a given frequency. This can be used
717 * directly as a determine_rate callback (e.g. for a mux), or from a more
718 * complex clock that may combine a mux with other operations.
719 */
720long __clk_mux_determine_rate(struct clk_hw *hw, unsigned long rate,
721 unsigned long *best_parent_rate,
722 struct clk **best_parent_p)
723{
724 struct clk *clk = hw->clk, *parent, *best_parent = NULL;
725 int i, num_parents;
726 unsigned long parent_rate, best = 0;
727
728 /* if NO_REPARENT flag set, pass through to current parent */
729 if (clk->flags & CLK_SET_RATE_NO_REPARENT) {
730 parent = clk->parent;
731 if (clk->flags & CLK_SET_RATE_PARENT)
732 best = __clk_round_rate(parent, rate);
733 else if (parent)
734 best = __clk_get_rate(parent);
735 else
736 best = __clk_get_rate(clk);
737 goto out;
738 }
739
740 /* find the parent that can provide the fastest rate <= rate */
741 num_parents = clk->num_parents;
742 for (i = 0; i < num_parents; i++) {
743 parent = clk_get_parent_by_index(clk, i);
744 if (!parent)
745 continue;
746 if (clk->flags & CLK_SET_RATE_PARENT)
747 parent_rate = __clk_round_rate(parent, rate);
748 else
749 parent_rate = __clk_get_rate(parent);
750 if (parent_rate <= rate && parent_rate > best) {
751 best_parent = parent;
752 best = parent_rate;
753 }
754 }
755
756out:
757 if (best_parent)
758 *best_parent_p = best_parent;
759 *best_parent_rate = best;
760
761 return best;
762}
Stephen Boyd0b7f04b2014-01-17 19:47:17 -0800763EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);
James Hogane366fdd2013-07-29 12:25:02 +0100764
Mike Turquetteb24764902012-03-15 23:11:19 -0700765/*** clk api ***/
766
767void __clk_unprepare(struct clk *clk)
768{
769 if (!clk)
770 return;
771
772 if (WARN_ON(clk->prepare_count == 0))
773 return;
774
775 if (--clk->prepare_count > 0)
776 return;
777
778 WARN_ON(clk->enable_count > 0);
779
780 if (clk->ops->unprepare)
781 clk->ops->unprepare(clk->hw);
782
783 __clk_unprepare(clk->parent);
784}
785
786/**
787 * clk_unprepare - undo preparation of a clock source
Peter Meerwald24ee1a02013-06-29 15:14:19 +0200788 * @clk: the clk being unprepared
Mike Turquetteb24764902012-03-15 23:11:19 -0700789 *
790 * clk_unprepare may sleep, which differentiates it from clk_disable. In a
791 * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
792 * if the operation may sleep. One example is a clk which is accessed over
793 * I2c. In the complex case a clk gate operation may require a fast and a slow
794 * part. It is this reason that clk_unprepare and clk_disable are not mutually
795 * exclusive. In fact clk_disable must be called before clk_unprepare.
796 */
797void clk_unprepare(struct clk *clk)
798{
Stephen Boyd63589e92014-03-26 16:06:37 -0700799 if (IS_ERR_OR_NULL(clk))
800 return;
801
Mike Turquetteeab89f62013-03-28 13:59:01 -0700802 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700803 __clk_unprepare(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700804 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700805}
806EXPORT_SYMBOL_GPL(clk_unprepare);
807
808int __clk_prepare(struct clk *clk)
809{
810 int ret = 0;
811
812 if (!clk)
813 return 0;
814
815 if (clk->prepare_count == 0) {
816 ret = __clk_prepare(clk->parent);
817 if (ret)
818 return ret;
819
820 if (clk->ops->prepare) {
821 ret = clk->ops->prepare(clk->hw);
822 if (ret) {
823 __clk_unprepare(clk->parent);
824 return ret;
825 }
826 }
827 }
828
829 clk->prepare_count++;
830
831 return 0;
832}
833
834/**
835 * clk_prepare - prepare a clock source
836 * @clk: the clk being prepared
837 *
838 * clk_prepare may sleep, which differentiates it from clk_enable. In a simple
839 * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
840 * operation may sleep. One example is a clk which is accessed over I2c. In
841 * the complex case a clk ungate operation may require a fast and a slow part.
842 * It is this reason that clk_prepare and clk_enable are not mutually
843 * exclusive. In fact clk_prepare must be called before clk_enable.
844 * Returns 0 on success, -EERROR otherwise.
845 */
846int clk_prepare(struct clk *clk)
847{
848 int ret;
849
Mike Turquetteeab89f62013-03-28 13:59:01 -0700850 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700851 ret = __clk_prepare(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700852 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700853
854 return ret;
855}
856EXPORT_SYMBOL_GPL(clk_prepare);
857
858static void __clk_disable(struct clk *clk)
859{
860 if (!clk)
861 return;
862
863 if (WARN_ON(clk->enable_count == 0))
864 return;
865
866 if (--clk->enable_count > 0)
867 return;
868
869 if (clk->ops->disable)
870 clk->ops->disable(clk->hw);
871
872 __clk_disable(clk->parent);
873}
874
875/**
876 * clk_disable - gate a clock
877 * @clk: the clk being gated
878 *
879 * clk_disable must not sleep, which differentiates it from clk_unprepare. In
880 * a simple case, clk_disable can be used instead of clk_unprepare to gate a
881 * clk if the operation is fast and will never sleep. One example is a
882 * SoC-internal clk which is controlled via simple register writes. In the
883 * complex case a clk gate operation may require a fast and a slow part. It is
884 * this reason that clk_unprepare and clk_disable are not mutually exclusive.
885 * In fact clk_disable must be called before clk_unprepare.
886 */
887void clk_disable(struct clk *clk)
888{
889 unsigned long flags;
890
Stephen Boyd63589e92014-03-26 16:06:37 -0700891 if (IS_ERR_OR_NULL(clk))
892 return;
893
Mike Turquetteeab89f62013-03-28 13:59:01 -0700894 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700895 __clk_disable(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700896 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700897}
898EXPORT_SYMBOL_GPL(clk_disable);
899
900static int __clk_enable(struct clk *clk)
901{
902 int ret = 0;
903
904 if (!clk)
905 return 0;
906
907 if (WARN_ON(clk->prepare_count == 0))
908 return -ESHUTDOWN;
909
910 if (clk->enable_count == 0) {
911 ret = __clk_enable(clk->parent);
912
913 if (ret)
914 return ret;
915
916 if (clk->ops->enable) {
917 ret = clk->ops->enable(clk->hw);
918 if (ret) {
919 __clk_disable(clk->parent);
920 return ret;
921 }
922 }
923 }
924
925 clk->enable_count++;
926 return 0;
927}
928
929/**
930 * clk_enable - ungate a clock
931 * @clk: the clk being ungated
932 *
933 * clk_enable must not sleep, which differentiates it from clk_prepare. In a
934 * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
935 * if the operation will never sleep. One example is a SoC-internal clk which
936 * is controlled via simple register writes. In the complex case a clk ungate
937 * operation may require a fast and a slow part. It is this reason that
938 * clk_enable and clk_prepare are not mutually exclusive. In fact clk_prepare
939 * must be called before clk_enable. Returns 0 on success, -EERROR
940 * otherwise.
941 */
942int clk_enable(struct clk *clk)
943{
944 unsigned long flags;
945 int ret;
946
Mike Turquetteeab89f62013-03-28 13:59:01 -0700947 flags = clk_enable_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -0700948 ret = __clk_enable(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -0700949 clk_enable_unlock(flags);
Mike Turquetteb24764902012-03-15 23:11:19 -0700950
951 return ret;
952}
953EXPORT_SYMBOL_GPL(clk_enable);
954
955/**
Mike Turquetteb24764902012-03-15 23:11:19 -0700956 * __clk_round_rate - round the given rate for a clk
957 * @clk: round the rate of this clock
Peter Meerwald24ee1a02013-06-29 15:14:19 +0200958 * @rate: the rate which is to be rounded
Mike Turquetteb24764902012-03-15 23:11:19 -0700959 *
960 * Caller must hold prepare_lock. Useful for clk_ops such as .set_rate
961 */
962unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)
963{
Shawn Guo81536e02012-04-12 20:50:17 +0800964 unsigned long parent_rate = 0;
James Hogan71472c02013-07-29 12:25:00 +0100965 struct clk *parent;
Mike Turquetteb24764902012-03-15 23:11:19 -0700966
967 if (!clk)
Stephen Boyd2ac6b1f2012-10-03 23:38:55 -0700968 return 0;
Mike Turquetteb24764902012-03-15 23:11:19 -0700969
James Hogan71472c02013-07-29 12:25:00 +0100970 parent = clk->parent;
971 if (parent)
972 parent_rate = parent->rate;
Mike Turquetteb24764902012-03-15 23:11:19 -0700973
James Hogan71472c02013-07-29 12:25:00 +0100974 if (clk->ops->determine_rate)
975 return clk->ops->determine_rate(clk->hw, rate, &parent_rate,
976 &parent);
977 else if (clk->ops->round_rate)
978 return clk->ops->round_rate(clk->hw, rate, &parent_rate);
979 else if (clk->flags & CLK_SET_RATE_PARENT)
980 return __clk_round_rate(clk->parent, rate);
981 else
982 return clk->rate;
Mike Turquetteb24764902012-03-15 23:11:19 -0700983}
Arnd Bergmann1cdf8ee2014-06-03 11:40:14 +0200984EXPORT_SYMBOL_GPL(__clk_round_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -0700985
986/**
987 * clk_round_rate - round the given rate for a clk
988 * @clk: the clk for which we are rounding a rate
989 * @rate: the rate which is to be rounded
990 *
991 * Takes in a rate as input and rounds it to a rate that the clk can actually
992 * use which is then returned. If clk doesn't support round_rate operation
993 * then the parent rate is returned.
994 */
995long clk_round_rate(struct clk *clk, unsigned long rate)
996{
997 unsigned long ret;
998
Mike Turquetteeab89f62013-03-28 13:59:01 -0700999 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001000 ret = __clk_round_rate(clk, rate);
Mike Turquetteeab89f62013-03-28 13:59:01 -07001001 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001002
1003 return ret;
1004}
1005EXPORT_SYMBOL_GPL(clk_round_rate);
1006
1007/**
1008 * __clk_notify - call clk notifier chain
1009 * @clk: struct clk * that is changing rate
1010 * @msg: clk notifier type (see include/linux/clk.h)
1011 * @old_rate: old clk rate
1012 * @new_rate: new clk rate
1013 *
1014 * Triggers a notifier call chain on the clk rate-change notification
1015 * for 'clk'. Passes a pointer to the struct clk and the previous
1016 * and current rates to the notifier callback. Intended to be called by
1017 * internal clock code only. Returns NOTIFY_DONE from the last driver
1018 * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
1019 * a driver returns that.
1020 */
1021static int __clk_notify(struct clk *clk, unsigned long msg,
1022 unsigned long old_rate, unsigned long new_rate)
1023{
1024 struct clk_notifier *cn;
1025 struct clk_notifier_data cnd;
1026 int ret = NOTIFY_DONE;
1027
1028 cnd.clk = clk;
1029 cnd.old_rate = old_rate;
1030 cnd.new_rate = new_rate;
1031
1032 list_for_each_entry(cn, &clk_notifier_list, node) {
1033 if (cn->clk == clk) {
1034 ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
1035 &cnd);
1036 break;
1037 }
1038 }
1039
1040 return ret;
1041}
1042
1043/**
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001044 * __clk_recalc_accuracies
1045 * @clk: first clk in the subtree
1046 *
1047 * Walks the subtree of clks starting with clk and recalculates accuracies as
1048 * it goes. Note that if a clk does not implement the .recalc_accuracy
1049 * callback then it is assumed that the clock will take on the accuracy of it's
1050 * parent.
1051 *
1052 * Caller must hold prepare_lock.
1053 */
1054static void __clk_recalc_accuracies(struct clk *clk)
1055{
1056 unsigned long parent_accuracy = 0;
1057 struct clk *child;
1058
1059 if (clk->parent)
1060 parent_accuracy = clk->parent->accuracy;
1061
1062 if (clk->ops->recalc_accuracy)
1063 clk->accuracy = clk->ops->recalc_accuracy(clk->hw,
1064 parent_accuracy);
1065 else
1066 clk->accuracy = parent_accuracy;
1067
1068 hlist_for_each_entry(child, &clk->children, child_node)
1069 __clk_recalc_accuracies(child);
1070}
1071
1072/**
1073 * clk_get_accuracy - return the accuracy of clk
1074 * @clk: the clk whose accuracy is being returned
1075 *
1076 * Simply returns the cached accuracy of the clk, unless
1077 * CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
1078 * issued.
1079 * If clk is NULL then returns 0.
1080 */
1081long clk_get_accuracy(struct clk *clk)
1082{
1083 unsigned long accuracy;
1084
1085 clk_prepare_lock();
1086 if (clk && (clk->flags & CLK_GET_ACCURACY_NOCACHE))
1087 __clk_recalc_accuracies(clk);
1088
1089 accuracy = __clk_get_accuracy(clk);
1090 clk_prepare_unlock();
1091
1092 return accuracy;
1093}
1094EXPORT_SYMBOL_GPL(clk_get_accuracy);
1095
Stephen Boyd8f2c2db2014-03-26 16:06:36 -07001096static unsigned long clk_recalc(struct clk *clk, unsigned long parent_rate)
1097{
1098 if (clk->ops->recalc_rate)
1099 return clk->ops->recalc_rate(clk->hw, parent_rate);
1100 return parent_rate;
1101}
1102
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001103/**
Mike Turquetteb24764902012-03-15 23:11:19 -07001104 * __clk_recalc_rates
1105 * @clk: first clk in the subtree
1106 * @msg: notification type (see include/linux/clk.h)
1107 *
1108 * Walks the subtree of clks starting with clk and recalculates rates as it
1109 * goes. Note that if a clk does not implement the .recalc_rate callback then
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001110 * it is assumed that the clock will take on the rate of its parent.
Mike Turquetteb24764902012-03-15 23:11:19 -07001111 *
1112 * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
1113 * if necessary.
1114 *
1115 * Caller must hold prepare_lock.
1116 */
1117static void __clk_recalc_rates(struct clk *clk, unsigned long msg)
1118{
1119 unsigned long old_rate;
1120 unsigned long parent_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001121 struct clk *child;
1122
1123 old_rate = clk->rate;
1124
1125 if (clk->parent)
1126 parent_rate = clk->parent->rate;
1127
Stephen Boyd8f2c2db2014-03-26 16:06:36 -07001128 clk->rate = clk_recalc(clk, parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001129
1130 /*
1131 * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
1132 * & ABORT_RATE_CHANGE notifiers
1133 */
1134 if (clk->notifier_count && msg)
1135 __clk_notify(clk, msg, old_rate, clk->rate);
1136
Sasha Levinb67bfe02013-02-27 17:06:00 -08001137 hlist_for_each_entry(child, &clk->children, child_node)
Mike Turquetteb24764902012-03-15 23:11:19 -07001138 __clk_recalc_rates(child, msg);
1139}
1140
1141/**
Ulf Hanssona093bde2012-08-31 14:21:28 +02001142 * clk_get_rate - return the rate of clk
1143 * @clk: the clk whose rate is being returned
1144 *
1145 * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
1146 * is set, which means a recalc_rate will be issued.
1147 * If clk is NULL then returns 0.
1148 */
1149unsigned long clk_get_rate(struct clk *clk)
1150{
1151 unsigned long rate;
1152
Mike Turquetteeab89f62013-03-28 13:59:01 -07001153 clk_prepare_lock();
Ulf Hanssona093bde2012-08-31 14:21:28 +02001154
1155 if (clk && (clk->flags & CLK_GET_RATE_NOCACHE))
1156 __clk_recalc_rates(clk, 0);
1157
1158 rate = __clk_get_rate(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -07001159 clk_prepare_unlock();
Ulf Hanssona093bde2012-08-31 14:21:28 +02001160
1161 return rate;
1162}
1163EXPORT_SYMBOL_GPL(clk_get_rate);
1164
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001165static int clk_fetch_parent_index(struct clk *clk, struct clk *parent)
James Hogan4935b222013-07-29 12:24:59 +01001166{
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001167 int i;
James Hogan4935b222013-07-29 12:24:59 +01001168
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001169 if (!clk->parents) {
Tomasz Figa96a7ed92013-09-29 02:37:15 +02001170 clk->parents = kcalloc(clk->num_parents,
1171 sizeof(struct clk *), GFP_KERNEL);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001172 if (!clk->parents)
1173 return -ENOMEM;
1174 }
James Hogan4935b222013-07-29 12:24:59 +01001175
1176 /*
1177 * find index of new parent clock using cached parent ptrs,
1178 * or if not yet cached, use string name comparison and cache
1179 * them now to avoid future calls to __clk_lookup.
1180 */
1181 for (i = 0; i < clk->num_parents; i++) {
Tomasz Figada0f0b22013-09-29 02:37:16 +02001182 if (clk->parents[i] == parent)
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001183 return i;
Tomasz Figada0f0b22013-09-29 02:37:16 +02001184
1185 if (clk->parents[i])
1186 continue;
1187
1188 if (!strcmp(clk->parent_names[i], parent->name)) {
1189 clk->parents[i] = __clk_lookup(parent->name);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001190 return i;
James Hogan4935b222013-07-29 12:24:59 +01001191 }
1192 }
1193
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001194 return -EINVAL;
James Hogan4935b222013-07-29 12:24:59 +01001195}
1196
1197static void clk_reparent(struct clk *clk, struct clk *new_parent)
1198{
1199 hlist_del(&clk->child_node);
1200
James Hogan903efc52013-08-29 12:10:51 +01001201 if (new_parent) {
1202 /* avoid duplicate POST_RATE_CHANGE notifications */
1203 if (new_parent->new_child == clk)
1204 new_parent->new_child = NULL;
1205
James Hogan4935b222013-07-29 12:24:59 +01001206 hlist_add_head(&clk->child_node, &new_parent->children);
James Hogan903efc52013-08-29 12:10:51 +01001207 } else {
James Hogan4935b222013-07-29 12:24:59 +01001208 hlist_add_head(&clk->child_node, &clk_orphan_list);
James Hogan903efc52013-08-29 12:10:51 +01001209 }
James Hogan4935b222013-07-29 12:24:59 +01001210
1211 clk->parent = new_parent;
1212}
1213
Stephen Boyd3fa22522014-01-15 10:47:22 -08001214static struct clk *__clk_set_parent_before(struct clk *clk, struct clk *parent)
James Hogan4935b222013-07-29 12:24:59 +01001215{
1216 unsigned long flags;
James Hogan4935b222013-07-29 12:24:59 +01001217 struct clk *old_parent = clk->parent;
1218
1219 /*
1220 * Migrate prepare state between parents and prevent race with
1221 * clk_enable().
1222 *
1223 * If the clock is not prepared, then a race with
1224 * clk_enable/disable() is impossible since we already have the
1225 * prepare lock (future calls to clk_enable() need to be preceded by
1226 * a clk_prepare()).
1227 *
1228 * If the clock is prepared, migrate the prepared state to the new
1229 * parent and also protect against a race with clk_enable() by
1230 * forcing the clock and the new parent on. This ensures that all
1231 * future calls to clk_enable() are practically NOPs with respect to
1232 * hardware and software states.
1233 *
1234 * See also: Comment for clk_set_parent() below.
1235 */
1236 if (clk->prepare_count) {
1237 __clk_prepare(parent);
1238 clk_enable(parent);
1239 clk_enable(clk);
1240 }
1241
1242 /* update the clk tree topology */
1243 flags = clk_enable_lock();
1244 clk_reparent(clk, parent);
1245 clk_enable_unlock(flags);
1246
Stephen Boyd3fa22522014-01-15 10:47:22 -08001247 return old_parent;
1248}
1249
1250static void __clk_set_parent_after(struct clk *clk, struct clk *parent,
1251 struct clk *old_parent)
1252{
1253 /*
1254 * Finish the migration of prepare state and undo the changes done
1255 * for preventing a race with clk_enable().
1256 */
1257 if (clk->prepare_count) {
1258 clk_disable(clk);
1259 clk_disable(old_parent);
1260 __clk_unprepare(old_parent);
1261 }
Stephen Boyd3fa22522014-01-15 10:47:22 -08001262}
1263
1264static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
1265{
1266 unsigned long flags;
1267 int ret = 0;
1268 struct clk *old_parent;
1269
1270 old_parent = __clk_set_parent_before(clk, parent);
1271
James Hogan4935b222013-07-29 12:24:59 +01001272 /* change clock input source */
1273 if (parent && clk->ops->set_parent)
1274 ret = clk->ops->set_parent(clk->hw, p_index);
1275
1276 if (ret) {
1277 flags = clk_enable_lock();
1278 clk_reparent(clk, old_parent);
1279 clk_enable_unlock(flags);
1280
1281 if (clk->prepare_count) {
1282 clk_disable(clk);
1283 clk_disable(parent);
1284 __clk_unprepare(parent);
1285 }
1286 return ret;
1287 }
1288
Stephen Boyd3fa22522014-01-15 10:47:22 -08001289 __clk_set_parent_after(clk, parent, old_parent);
James Hogan4935b222013-07-29 12:24:59 +01001290
James Hogan4935b222013-07-29 12:24:59 +01001291 return 0;
1292}
1293
Ulf Hanssona093bde2012-08-31 14:21:28 +02001294/**
Mike Turquetteb24764902012-03-15 23:11:19 -07001295 * __clk_speculate_rates
1296 * @clk: first clk in the subtree
1297 * @parent_rate: the "future" rate of clk's parent
1298 *
1299 * Walks the subtree of clks starting with clk, speculating rates as it
1300 * goes and firing off PRE_RATE_CHANGE notifications as necessary.
1301 *
1302 * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
1303 * pre-rate change notifications and returns early if no clks in the
1304 * subtree have subscribed to the notifications. Note that if a clk does not
1305 * implement the .recalc_rate callback then it is assumed that the clock will
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001306 * take on the rate of its parent.
Mike Turquetteb24764902012-03-15 23:11:19 -07001307 *
1308 * Caller must hold prepare_lock.
1309 */
1310static int __clk_speculate_rates(struct clk *clk, unsigned long parent_rate)
1311{
Mike Turquetteb24764902012-03-15 23:11:19 -07001312 struct clk *child;
1313 unsigned long new_rate;
1314 int ret = NOTIFY_DONE;
1315
Stephen Boyd8f2c2db2014-03-26 16:06:36 -07001316 new_rate = clk_recalc(clk, parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001317
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001318 /* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
Mike Turquetteb24764902012-03-15 23:11:19 -07001319 if (clk->notifier_count)
1320 ret = __clk_notify(clk, PRE_RATE_CHANGE, clk->rate, new_rate);
1321
Mike Turquette86bcfa22014-02-24 16:08:41 -08001322 if (ret & NOTIFY_STOP_MASK) {
1323 pr_debug("%s: clk notifier callback for clock %s aborted with error %d\n",
1324 __func__, clk->name, ret);
Mike Turquetteb24764902012-03-15 23:11:19 -07001325 goto out;
Mike Turquette86bcfa22014-02-24 16:08:41 -08001326 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001327
Sasha Levinb67bfe02013-02-27 17:06:00 -08001328 hlist_for_each_entry(child, &clk->children, child_node) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001329 ret = __clk_speculate_rates(child, new_rate);
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001330 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001331 break;
1332 }
1333
1334out:
1335 return ret;
1336}
1337
James Hogan71472c02013-07-29 12:25:00 +01001338static void clk_calc_subtree(struct clk *clk, unsigned long new_rate,
1339 struct clk *new_parent, u8 p_index)
Mike Turquetteb24764902012-03-15 23:11:19 -07001340{
1341 struct clk *child;
Mike Turquetteb24764902012-03-15 23:11:19 -07001342
1343 clk->new_rate = new_rate;
James Hogan71472c02013-07-29 12:25:00 +01001344 clk->new_parent = new_parent;
1345 clk->new_parent_index = p_index;
1346 /* include clk in new parent's PRE_RATE_CHANGE notifications */
1347 clk->new_child = NULL;
1348 if (new_parent && new_parent != clk->parent)
1349 new_parent->new_child = clk;
Mike Turquetteb24764902012-03-15 23:11:19 -07001350
Sasha Levinb67bfe02013-02-27 17:06:00 -08001351 hlist_for_each_entry(child, &clk->children, child_node) {
Stephen Boyd8f2c2db2014-03-26 16:06:36 -07001352 child->new_rate = clk_recalc(child, new_rate);
James Hogan71472c02013-07-29 12:25:00 +01001353 clk_calc_subtree(child, child->new_rate, NULL, 0);
Mike Turquetteb24764902012-03-15 23:11:19 -07001354 }
1355}
1356
1357/*
1358 * calculate the new rates returning the topmost clock that has to be
1359 * changed.
1360 */
1361static struct clk *clk_calc_new_rates(struct clk *clk, unsigned long rate)
1362{
1363 struct clk *top = clk;
James Hogan71472c02013-07-29 12:25:00 +01001364 struct clk *old_parent, *parent;
Shawn Guo81536e02012-04-12 20:50:17 +08001365 unsigned long best_parent_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001366 unsigned long new_rate;
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001367 int p_index = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001368
Mike Turquette7452b212012-03-26 14:45:36 -07001369 /* sanity */
1370 if (IS_ERR_OR_NULL(clk))
1371 return NULL;
1372
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001373 /* save parent rate, if it exists */
James Hogan71472c02013-07-29 12:25:00 +01001374 parent = old_parent = clk->parent;
1375 if (parent)
1376 best_parent_rate = parent->rate;
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001377
James Hogan71472c02013-07-29 12:25:00 +01001378 /* find the closest rate and parent clk/rate */
1379 if (clk->ops->determine_rate) {
1380 new_rate = clk->ops->determine_rate(clk->hw, rate,
1381 &best_parent_rate,
1382 &parent);
1383 } else if (clk->ops->round_rate) {
1384 new_rate = clk->ops->round_rate(clk->hw, rate,
1385 &best_parent_rate);
1386 } else if (!parent || !(clk->flags & CLK_SET_RATE_PARENT)) {
1387 /* pass-through clock without adjustable parent */
1388 clk->new_rate = clk->rate;
1389 return NULL;
1390 } else {
1391 /* pass-through clock with adjustable parent */
1392 top = clk_calc_new_rates(parent, rate);
1393 new_rate = parent->new_rate;
Mike Turquette63f5c3b2012-05-02 16:23:43 -07001394 goto out;
Mike Turquette7452b212012-03-26 14:45:36 -07001395 }
1396
James Hogan71472c02013-07-29 12:25:00 +01001397 /* some clocks must be gated to change parent */
1398 if (parent != old_parent &&
1399 (clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) {
1400 pr_debug("%s: %s not gated but wants to reparent\n",
1401 __func__, clk->name);
Mike Turquetteb24764902012-03-15 23:11:19 -07001402 return NULL;
1403 }
1404
James Hogan71472c02013-07-29 12:25:00 +01001405 /* try finding the new parent index */
1406 if (parent) {
1407 p_index = clk_fetch_parent_index(clk, parent);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001408 if (p_index < 0) {
James Hogan71472c02013-07-29 12:25:00 +01001409 pr_debug("%s: clk %s can not be parent of clk %s\n",
1410 __func__, parent->name, clk->name);
1411 return NULL;
1412 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001413 }
1414
James Hogan71472c02013-07-29 12:25:00 +01001415 if ((clk->flags & CLK_SET_RATE_PARENT) && parent &&
1416 best_parent_rate != parent->rate)
1417 top = clk_calc_new_rates(parent, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001418
1419out:
James Hogan71472c02013-07-29 12:25:00 +01001420 clk_calc_subtree(clk, new_rate, parent, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001421
1422 return top;
1423}
1424
1425/*
1426 * Notify about rate changes in a subtree. Always walk down the whole tree
1427 * so that in case of an error we can walk down the whole tree again and
1428 * abort the change.
1429 */
1430static struct clk *clk_propagate_rate_change(struct clk *clk, unsigned long event)
1431{
James Hogan71472c02013-07-29 12:25:00 +01001432 struct clk *child, *tmp_clk, *fail_clk = NULL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001433 int ret = NOTIFY_DONE;
1434
1435 if (clk->rate == clk->new_rate)
Sachin Kamat5fda6852013-03-13 15:17:49 +05301436 return NULL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001437
1438 if (clk->notifier_count) {
1439 ret = __clk_notify(clk, event, clk->rate, clk->new_rate);
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001440 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001441 fail_clk = clk;
1442 }
1443
Sasha Levinb67bfe02013-02-27 17:06:00 -08001444 hlist_for_each_entry(child, &clk->children, child_node) {
James Hogan71472c02013-07-29 12:25:00 +01001445 /* Skip children who will be reparented to another clock */
1446 if (child->new_parent && child->new_parent != clk)
1447 continue;
1448 tmp_clk = clk_propagate_rate_change(child, event);
1449 if (tmp_clk)
1450 fail_clk = tmp_clk;
1451 }
1452
1453 /* handle the new child who might not be in clk->children yet */
1454 if (clk->new_child) {
1455 tmp_clk = clk_propagate_rate_change(clk->new_child, event);
1456 if (tmp_clk)
1457 fail_clk = tmp_clk;
Mike Turquetteb24764902012-03-15 23:11:19 -07001458 }
1459
1460 return fail_clk;
1461}
1462
1463/*
1464 * walk down a subtree and set the new rates notifying the rate
1465 * change on the way
1466 */
1467static void clk_change_rate(struct clk *clk)
1468{
1469 struct clk *child;
Tero Kristo067bb172014-08-21 16:47:45 +03001470 struct hlist_node *tmp;
Mike Turquetteb24764902012-03-15 23:11:19 -07001471 unsigned long old_rate;
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001472 unsigned long best_parent_rate = 0;
Stephen Boyd3fa22522014-01-15 10:47:22 -08001473 bool skip_set_rate = false;
1474 struct clk *old_parent;
Mike Turquetteb24764902012-03-15 23:11:19 -07001475
1476 old_rate = clk->rate;
1477
Stephen Boyd3fa22522014-01-15 10:47:22 -08001478 if (clk->new_parent)
1479 best_parent_rate = clk->new_parent->rate;
1480 else if (clk->parent)
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001481 best_parent_rate = clk->parent->rate;
1482
Stephen Boyd3fa22522014-01-15 10:47:22 -08001483 if (clk->new_parent && clk->new_parent != clk->parent) {
1484 old_parent = __clk_set_parent_before(clk, clk->new_parent);
1485
1486 if (clk->ops->set_rate_and_parent) {
1487 skip_set_rate = true;
1488 clk->ops->set_rate_and_parent(clk->hw, clk->new_rate,
1489 best_parent_rate,
1490 clk->new_parent_index);
1491 } else if (clk->ops->set_parent) {
1492 clk->ops->set_parent(clk->hw, clk->new_parent_index);
1493 }
1494
1495 __clk_set_parent_after(clk, clk->new_parent, old_parent);
1496 }
1497
1498 if (!skip_set_rate && clk->ops->set_rate)
Pawel Mollbf47b4f2012-06-08 14:04:06 +01001499 clk->ops->set_rate(clk->hw, clk->new_rate, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001500
Stephen Boyd8f2c2db2014-03-26 16:06:36 -07001501 clk->rate = clk_recalc(clk, best_parent_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001502
1503 if (clk->notifier_count && old_rate != clk->rate)
1504 __clk_notify(clk, POST_RATE_CHANGE, old_rate, clk->rate);
1505
Tero Kristo067bb172014-08-21 16:47:45 +03001506 /*
1507 * Use safe iteration, as change_rate can actually swap parents
1508 * for certain clock types.
1509 */
1510 hlist_for_each_entry_safe(child, tmp, &clk->children, child_node) {
James Hogan71472c02013-07-29 12:25:00 +01001511 /* Skip children who will be reparented to another clock */
1512 if (child->new_parent && child->new_parent != clk)
1513 continue;
Mike Turquetteb24764902012-03-15 23:11:19 -07001514 clk_change_rate(child);
James Hogan71472c02013-07-29 12:25:00 +01001515 }
1516
1517 /* handle the new child who might not be in clk->children yet */
1518 if (clk->new_child)
1519 clk_change_rate(clk->new_child);
Mike Turquetteb24764902012-03-15 23:11:19 -07001520}
1521
1522/**
1523 * clk_set_rate - specify a new rate for clk
1524 * @clk: the clk whose rate is being changed
1525 * @rate: the new rate for clk
1526 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001527 * In the simplest case clk_set_rate will only adjust the rate of clk.
Mike Turquetteb24764902012-03-15 23:11:19 -07001528 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001529 * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
1530 * propagate up to clk's parent; whether or not this happens depends on the
1531 * outcome of clk's .round_rate implementation. If *parent_rate is unchanged
1532 * after calling .round_rate then upstream parent propagation is ignored. If
1533 * *parent_rate comes back with a new rate for clk's parent then we propagate
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001534 * up to clk's parent and set its rate. Upward propagation will continue
Mike Turquette5654dc92012-03-26 11:51:34 -07001535 * until either a clk does not support the CLK_SET_RATE_PARENT flag or
1536 * .round_rate stops requesting changes to clk's parent_rate.
Mike Turquetteb24764902012-03-15 23:11:19 -07001537 *
Mike Turquette5654dc92012-03-26 11:51:34 -07001538 * Rate changes are accomplished via tree traversal that also recalculates the
1539 * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
Mike Turquetteb24764902012-03-15 23:11:19 -07001540 *
1541 * Returns 0 on success, -EERROR otherwise.
1542 */
1543int clk_set_rate(struct clk *clk, unsigned long rate)
1544{
1545 struct clk *top, *fail_clk;
1546 int ret = 0;
1547
Mike Turquette89ac8d72013-08-21 23:58:09 -07001548 if (!clk)
1549 return 0;
1550
Mike Turquetteb24764902012-03-15 23:11:19 -07001551 /* prevent racing with updates to the clock topology */
Mike Turquetteeab89f62013-03-28 13:59:01 -07001552 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001553
1554 /* bail early if nothing to do */
Peter De Schrijver34e452a2013-06-05 18:06:36 +03001555 if (rate == clk_get_rate(clk))
Mike Turquetteb24764902012-03-15 23:11:19 -07001556 goto out;
1557
Saravana Kannan7e0fa1b2012-05-15 13:43:42 -07001558 if ((clk->flags & CLK_SET_RATE_GATE) && clk->prepare_count) {
Viresh Kumar0e1c0302012-04-11 16:03:42 +05301559 ret = -EBUSY;
1560 goto out;
1561 }
1562
Mike Turquetteb24764902012-03-15 23:11:19 -07001563 /* calculate new rates and get the topmost changed clock */
1564 top = clk_calc_new_rates(clk, rate);
1565 if (!top) {
1566 ret = -EINVAL;
1567 goto out;
1568 }
1569
1570 /* notify that we are about to change rates */
1571 fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
1572 if (fail_clk) {
Sascha Hauerf7363862014-01-16 16:12:55 +01001573 pr_debug("%s: failed to set %s rate\n", __func__,
Mike Turquetteb24764902012-03-15 23:11:19 -07001574 fail_clk->name);
1575 clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
1576 ret = -EBUSY;
1577 goto out;
1578 }
1579
1580 /* change the rates */
1581 clk_change_rate(top);
1582
Mike Turquetteb24764902012-03-15 23:11:19 -07001583out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001584 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001585
1586 return ret;
1587}
1588EXPORT_SYMBOL_GPL(clk_set_rate);
1589
1590/**
1591 * clk_get_parent - return the parent of a clk
1592 * @clk: the clk whose parent gets returned
1593 *
1594 * Simply returns clk->parent. Returns NULL if clk is NULL.
1595 */
1596struct clk *clk_get_parent(struct clk *clk)
1597{
1598 struct clk *parent;
1599
Mike Turquetteeab89f62013-03-28 13:59:01 -07001600 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001601 parent = __clk_get_parent(clk);
Mike Turquetteeab89f62013-03-28 13:59:01 -07001602 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001603
1604 return parent;
1605}
1606EXPORT_SYMBOL_GPL(clk_get_parent);
1607
1608/*
1609 * .get_parent is mandatory for clocks with multiple possible parents. It is
1610 * optional for single-parent clocks. Always call .get_parent if it is
1611 * available and WARN if it is missing for multi-parent clocks.
1612 *
1613 * For single-parent clocks without .get_parent, first check to see if the
1614 * .parents array exists, and if so use it to avoid an expensive tree
1615 * traversal. If .parents does not exist then walk the tree with __clk_lookup.
1616 */
1617static struct clk *__clk_init_parent(struct clk *clk)
1618{
1619 struct clk *ret = NULL;
1620 u8 index;
1621
1622 /* handle the trivial cases */
1623
1624 if (!clk->num_parents)
1625 goto out;
1626
1627 if (clk->num_parents == 1) {
1628 if (IS_ERR_OR_NULL(clk->parent))
1629 ret = clk->parent = __clk_lookup(clk->parent_names[0]);
1630 ret = clk->parent;
1631 goto out;
1632 }
1633
1634 if (!clk->ops->get_parent) {
1635 WARN(!clk->ops->get_parent,
1636 "%s: multi-parent clocks must implement .get_parent\n",
1637 __func__);
1638 goto out;
1639 };
1640
1641 /*
1642 * Do our best to cache parent clocks in clk->parents. This prevents
1643 * unnecessary and expensive calls to __clk_lookup. We don't set
1644 * clk->parent here; that is done by the calling function
1645 */
1646
1647 index = clk->ops->get_parent(clk->hw);
1648
1649 if (!clk->parents)
1650 clk->parents =
Tomasz Figa96a7ed92013-09-29 02:37:15 +02001651 kcalloc(clk->num_parents, sizeof(struct clk *),
Mike Turquetteb24764902012-03-15 23:11:19 -07001652 GFP_KERNEL);
1653
James Hogan7ef3dcc2013-07-29 12:24:58 +01001654 ret = clk_get_parent_by_index(clk, index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001655
1656out:
1657 return ret;
1658}
1659
Ulf Hanssonb33d2122013-04-02 23:09:37 +02001660void __clk_reparent(struct clk *clk, struct clk *new_parent)
1661{
1662 clk_reparent(clk, new_parent);
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001663 __clk_recalc_accuracies(clk);
Mike Turquetteb24764902012-03-15 23:11:19 -07001664 __clk_recalc_rates(clk, POST_RATE_CHANGE);
1665}
1666
Mike Turquetteb24764902012-03-15 23:11:19 -07001667/**
1668 * clk_set_parent - switch the parent of a mux clk
1669 * @clk: the mux clk whose input we are switching
1670 * @parent: the new input to clk
1671 *
Saravana Kannanf8aa0bd2013-05-15 21:07:24 -07001672 * Re-parent clk to use parent as its new input source. If clk is in
1673 * prepared state, the clk will get enabled for the duration of this call. If
1674 * that's not acceptable for a specific clk (Eg: the consumer can't handle
1675 * that, the reparenting is glitchy in hardware, etc), use the
1676 * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
1677 *
1678 * After successfully changing clk's parent clk_set_parent will update the
1679 * clk topology, sysfs topology and propagate rate recalculation via
1680 * __clk_recalc_rates.
1681 *
1682 * Returns 0 on success, -EERROR otherwise.
Mike Turquetteb24764902012-03-15 23:11:19 -07001683 */
1684int clk_set_parent(struct clk *clk, struct clk *parent)
1685{
1686 int ret = 0;
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001687 int p_index = 0;
Ulf Hansson031dcc92013-04-02 23:09:38 +02001688 unsigned long p_rate = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001689
Mike Turquette89ac8d72013-08-21 23:58:09 -07001690 if (!clk)
1691 return 0;
1692
Ulf Hansson031dcc92013-04-02 23:09:38 +02001693 /* verify ops for for multi-parent clks */
1694 if ((clk->num_parents > 1) && (!clk->ops->set_parent))
Mike Turquetteb24764902012-03-15 23:11:19 -07001695 return -ENOSYS;
1696
1697 /* prevent racing with updates to the clock topology */
Mike Turquetteeab89f62013-03-28 13:59:01 -07001698 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001699
1700 if (clk->parent == parent)
1701 goto out;
1702
Ulf Hansson031dcc92013-04-02 23:09:38 +02001703 /* check that we are allowed to re-parent if the clock is in use */
1704 if ((clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) {
1705 ret = -EBUSY;
1706 goto out;
1707 }
1708
1709 /* try finding the new parent index */
1710 if (parent) {
1711 p_index = clk_fetch_parent_index(clk, parent);
1712 p_rate = parent->rate;
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001713 if (p_index < 0) {
Ulf Hansson031dcc92013-04-02 23:09:38 +02001714 pr_debug("%s: clk %s can not be parent of clk %s\n",
1715 __func__, parent->name, clk->name);
Tomasz Figaf1c8b2e2013-09-29 02:37:14 +02001716 ret = p_index;
Ulf Hansson031dcc92013-04-02 23:09:38 +02001717 goto out;
1718 }
1719 }
1720
Mike Turquetteb24764902012-03-15 23:11:19 -07001721 /* propagate PRE_RATE_CHANGE notifications */
Soren Brinkmannf3aab5d2013-04-16 10:06:50 -07001722 ret = __clk_speculate_rates(clk, p_rate);
Mike Turquetteb24764902012-03-15 23:11:19 -07001723
1724 /* abort if a driver objects */
Soren Brinkmannfb72a052013-04-03 12:17:12 -07001725 if (ret & NOTIFY_STOP_MASK)
Mike Turquetteb24764902012-03-15 23:11:19 -07001726 goto out;
1727
Ulf Hansson031dcc92013-04-02 23:09:38 +02001728 /* do the re-parent */
1729 ret = __clk_set_parent(clk, parent, p_index);
Mike Turquetteb24764902012-03-15 23:11:19 -07001730
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001731 /* propagate rate an accuracy recalculation accordingly */
1732 if (ret) {
Mike Turquetteb24764902012-03-15 23:11:19 -07001733 __clk_recalc_rates(clk, ABORT_RATE_CHANGE);
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001734 } else {
Ulf Hanssona68de8e2013-04-02 23:09:39 +02001735 __clk_recalc_rates(clk, POST_RATE_CHANGE);
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001736 __clk_recalc_accuracies(clk);
1737 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001738
1739out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001740 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001741
1742 return ret;
1743}
1744EXPORT_SYMBOL_GPL(clk_set_parent);
1745
1746/**
1747 * __clk_init - initialize the data structures in a struct clk
1748 * @dev: device initializing this clk, placeholder for now
1749 * @clk: clk being initialized
1750 *
1751 * Initializes the lists in struct clk, queries the hardware for the
1752 * parent and rate and sets them both.
Mike Turquetteb24764902012-03-15 23:11:19 -07001753 */
Mike Turquetted1302a32012-03-29 14:30:40 -07001754int __clk_init(struct device *dev, struct clk *clk)
Mike Turquetteb24764902012-03-15 23:11:19 -07001755{
Mike Turquetted1302a32012-03-29 14:30:40 -07001756 int i, ret = 0;
Mike Turquetteb24764902012-03-15 23:11:19 -07001757 struct clk *orphan;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001758 struct hlist_node *tmp2;
Mike Turquetteb24764902012-03-15 23:11:19 -07001759
1760 if (!clk)
Mike Turquetted1302a32012-03-29 14:30:40 -07001761 return -EINVAL;
Mike Turquetteb24764902012-03-15 23:11:19 -07001762
Mike Turquetteeab89f62013-03-28 13:59:01 -07001763 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001764
1765 /* check to see if a clock with this name is already registered */
Mike Turquetted1302a32012-03-29 14:30:40 -07001766 if (__clk_lookup(clk->name)) {
1767 pr_debug("%s: clk %s already initialized\n",
1768 __func__, clk->name);
1769 ret = -EEXIST;
Mike Turquetteb24764902012-03-15 23:11:19 -07001770 goto out;
Mike Turquetted1302a32012-03-29 14:30:40 -07001771 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001772
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001773 /* check that clk_ops are sane. See Documentation/clk.txt */
1774 if (clk->ops->set_rate &&
James Hogan71472c02013-07-29 12:25:00 +01001775 !((clk->ops->round_rate || clk->ops->determine_rate) &&
1776 clk->ops->recalc_rate)) {
1777 pr_warning("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n",
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001778 __func__, clk->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07001779 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001780 goto out;
1781 }
1782
1783 if (clk->ops->set_parent && !clk->ops->get_parent) {
1784 pr_warning("%s: %s must implement .get_parent & .set_parent\n",
1785 __func__, clk->name);
Mike Turquetted1302a32012-03-29 14:30:40 -07001786 ret = -EINVAL;
Mike Turquetted4d7e3d2012-03-26 16:15:52 -07001787 goto out;
1788 }
1789
Stephen Boyd3fa22522014-01-15 10:47:22 -08001790 if (clk->ops->set_rate_and_parent &&
1791 !(clk->ops->set_parent && clk->ops->set_rate)) {
1792 pr_warn("%s: %s must implement .set_parent & .set_rate\n",
1793 __func__, clk->name);
1794 ret = -EINVAL;
1795 goto out;
1796 }
1797
Mike Turquetteb24764902012-03-15 23:11:19 -07001798 /* throw a WARN if any entries in parent_names are NULL */
1799 for (i = 0; i < clk->num_parents; i++)
1800 WARN(!clk->parent_names[i],
1801 "%s: invalid NULL in %s's .parent_names\n",
1802 __func__, clk->name);
1803
1804 /*
1805 * Allocate an array of struct clk *'s to avoid unnecessary string
1806 * look-ups of clk's possible parents. This can fail for clocks passed
1807 * in to clk_init during early boot; thus any access to clk->parents[]
1808 * must always check for a NULL pointer and try to populate it if
1809 * necessary.
1810 *
1811 * If clk->parents is not NULL we skip this entire block. This allows
1812 * for clock drivers to statically initialize clk->parents.
1813 */
Rajendra Nayak9ca1c5a2012-06-06 14:41:30 +05301814 if (clk->num_parents > 1 && !clk->parents) {
Tomasz Figa96a7ed92013-09-29 02:37:15 +02001815 clk->parents = kcalloc(clk->num_parents, sizeof(struct clk *),
1816 GFP_KERNEL);
Mike Turquetteb24764902012-03-15 23:11:19 -07001817 /*
1818 * __clk_lookup returns NULL for parents that have not been
1819 * clk_init'd; thus any access to clk->parents[] must check
1820 * for a NULL pointer. We can always perform lazy lookups for
1821 * missing parents later on.
1822 */
1823 if (clk->parents)
1824 for (i = 0; i < clk->num_parents; i++)
1825 clk->parents[i] =
1826 __clk_lookup(clk->parent_names[i]);
1827 }
1828
1829 clk->parent = __clk_init_parent(clk);
1830
1831 /*
1832 * Populate clk->parent if parent has already been __clk_init'd. If
1833 * parent has not yet been __clk_init'd then place clk in the orphan
1834 * list. If clk has set the CLK_IS_ROOT flag then place it in the root
1835 * clk list.
1836 *
1837 * Every time a new clk is clk_init'd then we walk the list of orphan
1838 * clocks and re-parent any that are children of the clock currently
1839 * being clk_init'd.
1840 */
1841 if (clk->parent)
1842 hlist_add_head(&clk->child_node,
1843 &clk->parent->children);
1844 else if (clk->flags & CLK_IS_ROOT)
1845 hlist_add_head(&clk->child_node, &clk_root_list);
1846 else
1847 hlist_add_head(&clk->child_node, &clk_orphan_list);
1848
1849 /*
Boris BREZILLON5279fc42013-12-21 10:34:47 +01001850 * Set clk's accuracy. The preferred method is to use
1851 * .recalc_accuracy. For simple clocks and lazy developers the default
1852 * fallback is to use the parent's accuracy. If a clock doesn't have a
1853 * parent (or is orphaned) then accuracy is set to zero (perfect
1854 * clock).
1855 */
1856 if (clk->ops->recalc_accuracy)
1857 clk->accuracy = clk->ops->recalc_accuracy(clk->hw,
1858 __clk_get_accuracy(clk->parent));
1859 else if (clk->parent)
1860 clk->accuracy = clk->parent->accuracy;
1861 else
1862 clk->accuracy = 0;
1863
1864 /*
Mike Turquetteb24764902012-03-15 23:11:19 -07001865 * Set clk's rate. The preferred method is to use .recalc_rate. For
1866 * simple clocks and lazy developers the default fallback is to use the
1867 * parent's rate. If a clock doesn't have a parent (or is orphaned)
1868 * then rate is set to zero.
1869 */
1870 if (clk->ops->recalc_rate)
1871 clk->rate = clk->ops->recalc_rate(clk->hw,
1872 __clk_get_rate(clk->parent));
1873 else if (clk->parent)
1874 clk->rate = clk->parent->rate;
1875 else
1876 clk->rate = 0;
1877
Stephen Boyd3a5aec22013-10-16 00:40:03 -07001878 clk_debug_register(clk);
Mike Turquetteb24764902012-03-15 23:11:19 -07001879 /*
1880 * walk the list of orphan clocks and reparent any that are children of
1881 * this clock
1882 */
Sasha Levinb67bfe02013-02-27 17:06:00 -08001883 hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
Alex Elder12d298862013-09-05 08:33:24 -05001884 if (orphan->num_parents && orphan->ops->get_parent) {
Martin Fuzzey1f61e5f2012-11-22 20:15:05 +01001885 i = orphan->ops->get_parent(orphan->hw);
1886 if (!strcmp(clk->name, orphan->parent_names[i]))
1887 __clk_reparent(orphan, clk);
1888 continue;
1889 }
1890
Mike Turquetteb24764902012-03-15 23:11:19 -07001891 for (i = 0; i < orphan->num_parents; i++)
1892 if (!strcmp(clk->name, orphan->parent_names[i])) {
1893 __clk_reparent(orphan, clk);
1894 break;
1895 }
Martin Fuzzey1f61e5f2012-11-22 20:15:05 +01001896 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001897
1898 /*
1899 * optional platform-specific magic
1900 *
1901 * The .init callback is not used by any of the basic clock types, but
1902 * exists for weird hardware that must perform initialization magic.
1903 * Please consider other ways of solving initialization problems before
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001904 * using this callback, as its use is discouraged.
Mike Turquetteb24764902012-03-15 23:11:19 -07001905 */
1906 if (clk->ops->init)
1907 clk->ops->init(clk->hw);
1908
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02001909 kref_init(&clk->ref);
Mike Turquetteb24764902012-03-15 23:11:19 -07001910out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07001911 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07001912
Mike Turquetted1302a32012-03-29 14:30:40 -07001913 return ret;
Mike Turquetteb24764902012-03-15 23:11:19 -07001914}
1915
1916/**
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001917 * __clk_register - register a clock and return a cookie.
1918 *
1919 * Same as clk_register, except that the .clk field inside hw shall point to a
1920 * preallocated (generally statically allocated) struct clk. None of the fields
1921 * of the struct clk need to be initialized.
1922 *
1923 * The data pointed to by .init and .clk field shall NOT be marked as init
1924 * data.
1925 *
1926 * __clk_register is only exposed via clk-private.h and is intended for use with
1927 * very large numbers of clocks that need to be statically initialized. It is
1928 * a layering violation to include clk-private.h from any code which implements
1929 * a clock's .ops; as such any statically initialized clock data MUST be in a
Peter Meerwald24ee1a02013-06-29 15:14:19 +02001930 * separate C file from the logic that implements its operations. Returns 0
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001931 * on success, otherwise an error code.
1932 */
1933struct clk *__clk_register(struct device *dev, struct clk_hw *hw)
1934{
1935 int ret;
1936 struct clk *clk;
1937
1938 clk = hw->clk;
1939 clk->name = hw->init->name;
1940 clk->ops = hw->init->ops;
1941 clk->hw = hw;
1942 clk->flags = hw->init->flags;
1943 clk->parent_names = hw->init->parent_names;
1944 clk->num_parents = hw->init->num_parents;
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02001945 if (dev && dev->driver)
1946 clk->owner = dev->driver->owner;
1947 else
1948 clk->owner = NULL;
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001949
1950 ret = __clk_init(dev, clk);
1951 if (ret)
1952 return ERR_PTR(ret);
1953
1954 return clk;
1955}
1956EXPORT_SYMBOL_GPL(__clk_register);
1957
Stephen Boyd293ba3b2014-04-18 16:29:42 -07001958/**
1959 * clk_register - allocate a new clock, register it and return an opaque cookie
1960 * @dev: device that is registering this clock
1961 * @hw: link to hardware-specific clock data
1962 *
1963 * clk_register is the primary interface for populating the clock tree with new
1964 * clock nodes. It returns a pointer to the newly allocated struct clk which
1965 * cannot be dereferenced by driver code but may be used in conjuction with the
1966 * rest of the clock API. In the event of an error clk_register will return an
1967 * error code; drivers must test for an error code after calling clk_register.
1968 */
1969struct clk *clk_register(struct device *dev, struct clk_hw *hw)
Mike Turquetteb24764902012-03-15 23:11:19 -07001970{
Mike Turquetted1302a32012-03-29 14:30:40 -07001971 int i, ret;
Stephen Boyd293ba3b2014-04-18 16:29:42 -07001972 struct clk *clk;
1973
1974 clk = kzalloc(sizeof(*clk), GFP_KERNEL);
1975 if (!clk) {
1976 pr_err("%s: could not allocate clk\n", __func__);
1977 ret = -ENOMEM;
1978 goto fail_out;
1979 }
Mike Turquetteb24764902012-03-15 23:11:19 -07001980
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001981 clk->name = kstrdup(hw->init->name, GFP_KERNEL);
1982 if (!clk->name) {
1983 pr_err("%s: could not allocate clk->name\n", __func__);
1984 ret = -ENOMEM;
1985 goto fail_name;
1986 }
1987 clk->ops = hw->init->ops;
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02001988 if (dev && dev->driver)
1989 clk->owner = dev->driver->owner;
Mike Turquetteb24764902012-03-15 23:11:19 -07001990 clk->hw = hw;
Saravana Kannan0197b3e2012-04-25 22:58:56 -07001991 clk->flags = hw->init->flags;
1992 clk->num_parents = hw->init->num_parents;
Mike Turquetteb24764902012-03-15 23:11:19 -07001993 hw->clk = clk;
1994
Mike Turquetted1302a32012-03-29 14:30:40 -07001995 /* allocate local copy in case parent_names is __initdata */
Tomasz Figa96a7ed92013-09-29 02:37:15 +02001996 clk->parent_names = kcalloc(clk->num_parents, sizeof(char *),
1997 GFP_KERNEL);
Mike Turquetteb24764902012-03-15 23:11:19 -07001998
Mike Turquetted1302a32012-03-29 14:30:40 -07001999 if (!clk->parent_names) {
2000 pr_err("%s: could not allocate clk->parent_names\n", __func__);
2001 ret = -ENOMEM;
2002 goto fail_parent_names;
2003 }
2004
2005
2006 /* copy each string name in case parent_names is __initdata */
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002007 for (i = 0; i < clk->num_parents; i++) {
2008 clk->parent_names[i] = kstrdup(hw->init->parent_names[i],
2009 GFP_KERNEL);
Mike Turquetted1302a32012-03-29 14:30:40 -07002010 if (!clk->parent_names[i]) {
2011 pr_err("%s: could not copy parent_names\n", __func__);
2012 ret = -ENOMEM;
2013 goto fail_parent_names_copy;
2014 }
2015 }
2016
2017 ret = __clk_init(dev, clk);
2018 if (!ret)
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002019 return clk;
Mike Turquetted1302a32012-03-29 14:30:40 -07002020
2021fail_parent_names_copy:
2022 while (--i >= 0)
2023 kfree(clk->parent_names[i]);
2024 kfree(clk->parent_names);
2025fail_parent_names:
Saravana Kannan0197b3e2012-04-25 22:58:56 -07002026 kfree(clk->name);
2027fail_name:
Mike Turquetted1302a32012-03-29 14:30:40 -07002028 kfree(clk);
2029fail_out:
2030 return ERR_PTR(ret);
Mike Turquetteb24764902012-03-15 23:11:19 -07002031}
2032EXPORT_SYMBOL_GPL(clk_register);
2033
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002034/*
2035 * Free memory allocated for a clock.
2036 * Caller must hold prepare_lock.
2037 */
2038static void __clk_release(struct kref *ref)
2039{
2040 struct clk *clk = container_of(ref, struct clk, ref);
2041 int i = clk->num_parents;
2042
2043 kfree(clk->parents);
2044 while (--i >= 0)
2045 kfree(clk->parent_names[i]);
2046
2047 kfree(clk->parent_names);
2048 kfree(clk->name);
2049 kfree(clk);
2050}
2051
2052/*
2053 * Empty clk_ops for unregistered clocks. These are used temporarily
2054 * after clk_unregister() was called on a clock and until last clock
2055 * consumer calls clk_put() and the struct clk object is freed.
2056 */
2057static int clk_nodrv_prepare_enable(struct clk_hw *hw)
2058{
2059 return -ENXIO;
2060}
2061
2062static void clk_nodrv_disable_unprepare(struct clk_hw *hw)
2063{
2064 WARN_ON_ONCE(1);
2065}
2066
2067static int clk_nodrv_set_rate(struct clk_hw *hw, unsigned long rate,
2068 unsigned long parent_rate)
2069{
2070 return -ENXIO;
2071}
2072
2073static int clk_nodrv_set_parent(struct clk_hw *hw, u8 index)
2074{
2075 return -ENXIO;
2076}
2077
2078static const struct clk_ops clk_nodrv_ops = {
2079 .enable = clk_nodrv_prepare_enable,
2080 .disable = clk_nodrv_disable_unprepare,
2081 .prepare = clk_nodrv_prepare_enable,
2082 .unprepare = clk_nodrv_disable_unprepare,
2083 .set_rate = clk_nodrv_set_rate,
2084 .set_parent = clk_nodrv_set_parent,
2085};
2086
Mark Brown1df5c932012-04-18 09:07:12 +01002087/**
2088 * clk_unregister - unregister a currently registered clock
2089 * @clk: clock to unregister
Mark Brown1df5c932012-04-18 09:07:12 +01002090 */
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002091void clk_unregister(struct clk *clk)
2092{
2093 unsigned long flags;
2094
2095 if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
2096 return;
2097
2098 clk_prepare_lock();
2099
2100 if (clk->ops == &clk_nodrv_ops) {
2101 pr_err("%s: unregistered clock: %s\n", __func__, clk->name);
2102 goto out;
2103 }
2104 /*
2105 * Assign empty clock ops for consumers that might still hold
2106 * a reference to this clock.
2107 */
2108 flags = clk_enable_lock();
2109 clk->ops = &clk_nodrv_ops;
2110 clk_enable_unlock(flags);
2111
2112 if (!hlist_empty(&clk->children)) {
2113 struct clk *child;
Stephen Boyd874f2242014-04-18 16:29:43 -07002114 struct hlist_node *t;
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002115
2116 /* Reparent all children to the orphan list. */
Stephen Boyd874f2242014-04-18 16:29:43 -07002117 hlist_for_each_entry_safe(child, t, &clk->children, child_node)
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002118 clk_set_parent(child, NULL);
2119 }
2120
2121 clk_debug_unregister(clk);
2122
2123 hlist_del_init(&clk->child_node);
2124
2125 if (clk->prepare_count)
2126 pr_warn("%s: unregistering prepared clock: %s\n",
2127 __func__, clk->name);
2128
2129 kref_put(&clk->ref, __clk_release);
2130out:
2131 clk_prepare_unlock();
2132}
Mark Brown1df5c932012-04-18 09:07:12 +01002133EXPORT_SYMBOL_GPL(clk_unregister);
2134
Stephen Boyd46c87732012-09-24 13:38:04 -07002135static void devm_clk_release(struct device *dev, void *res)
2136{
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002137 clk_unregister(*(struct clk **)res);
Stephen Boyd46c87732012-09-24 13:38:04 -07002138}
2139
2140/**
2141 * devm_clk_register - resource managed clk_register()
2142 * @dev: device that is registering this clock
2143 * @hw: link to hardware-specific clock data
2144 *
2145 * Managed clk_register(). Clocks returned from this function are
2146 * automatically clk_unregister()ed on driver detach. See clk_register() for
2147 * more information.
2148 */
2149struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw)
2150{
2151 struct clk *clk;
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002152 struct clk **clkp;
Stephen Boyd46c87732012-09-24 13:38:04 -07002153
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002154 clkp = devres_alloc(devm_clk_release, sizeof(*clkp), GFP_KERNEL);
2155 if (!clkp)
Stephen Boyd46c87732012-09-24 13:38:04 -07002156 return ERR_PTR(-ENOMEM);
2157
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002158 clk = clk_register(dev, hw);
2159 if (!IS_ERR(clk)) {
2160 *clkp = clk;
2161 devres_add(dev, clkp);
Stephen Boyd46c87732012-09-24 13:38:04 -07002162 } else {
Stephen Boyd293ba3b2014-04-18 16:29:42 -07002163 devres_free(clkp);
Stephen Boyd46c87732012-09-24 13:38:04 -07002164 }
2165
2166 return clk;
2167}
2168EXPORT_SYMBOL_GPL(devm_clk_register);
2169
2170static int devm_clk_match(struct device *dev, void *res, void *data)
2171{
2172 struct clk *c = res;
2173 if (WARN_ON(!c))
2174 return 0;
2175 return c == data;
2176}
2177
2178/**
2179 * devm_clk_unregister - resource managed clk_unregister()
2180 * @clk: clock to unregister
2181 *
2182 * Deallocate a clock allocated with devm_clk_register(). Normally
2183 * this function will not need to be called and the resource management
2184 * code will ensure that the resource is freed.
2185 */
2186void devm_clk_unregister(struct device *dev, struct clk *clk)
2187{
2188 WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk));
2189}
2190EXPORT_SYMBOL_GPL(devm_clk_unregister);
2191
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002192/*
2193 * clkdev helpers
2194 */
2195int __clk_get(struct clk *clk)
2196{
Sylwester Nawrocki00efcb12014-01-07 13:03:43 +01002197 if (clk) {
2198 if (!try_module_get(clk->owner))
2199 return 0;
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002200
Sylwester Nawrocki00efcb12014-01-07 13:03:43 +01002201 kref_get(&clk->ref);
2202 }
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002203 return 1;
2204}
2205
2206void __clk_put(struct clk *clk)
2207{
Sylwester Nawrocki00efcb12014-01-07 13:03:43 +01002208 if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002209 return;
2210
Sylwester Nawrockifcb0ee62013-08-24 15:00:10 +02002211 clk_prepare_lock();
2212 kref_put(&clk->ref, __clk_release);
2213 clk_prepare_unlock();
2214
Sylwester Nawrocki00efcb12014-01-07 13:03:43 +01002215 module_put(clk->owner);
Sylwester Nawrockiac2df522013-08-24 20:10:41 +02002216}
2217
Mike Turquetteb24764902012-03-15 23:11:19 -07002218/*** clk rate change notifiers ***/
2219
2220/**
2221 * clk_notifier_register - add a clk rate change notifier
2222 * @clk: struct clk * to watch
2223 * @nb: struct notifier_block * with callback info
2224 *
2225 * Request notification when clk's rate changes. This uses an SRCU
2226 * notifier because we want it to block and notifier unregistrations are
2227 * uncommon. The callbacks associated with the notifier must not
2228 * re-enter into the clk framework by calling any top-level clk APIs;
2229 * this will cause a nested prepare_lock mutex.
2230 *
Soren Brinkmann5324fda2014-01-22 11:48:37 -08002231 * In all notification cases cases (pre, post and abort rate change) the
2232 * original clock rate is passed to the callback via struct
2233 * clk_notifier_data.old_rate and the new frequency is passed via struct
Mike Turquetteb24764902012-03-15 23:11:19 -07002234 * clk_notifier_data.new_rate.
2235 *
Mike Turquetteb24764902012-03-15 23:11:19 -07002236 * clk_notifier_register() must be called from non-atomic context.
2237 * Returns -EINVAL if called with null arguments, -ENOMEM upon
2238 * allocation failure; otherwise, passes along the return value of
2239 * srcu_notifier_chain_register().
2240 */
2241int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
2242{
2243 struct clk_notifier *cn;
2244 int ret = -ENOMEM;
2245
2246 if (!clk || !nb)
2247 return -EINVAL;
2248
Mike Turquetteeab89f62013-03-28 13:59:01 -07002249 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002250
2251 /* search the list of notifiers for this clk */
2252 list_for_each_entry(cn, &clk_notifier_list, node)
2253 if (cn->clk == clk)
2254 break;
2255
2256 /* if clk wasn't in the notifier list, allocate new clk_notifier */
2257 if (cn->clk != clk) {
2258 cn = kzalloc(sizeof(struct clk_notifier), GFP_KERNEL);
2259 if (!cn)
2260 goto out;
2261
2262 cn->clk = clk;
2263 srcu_init_notifier_head(&cn->notifier_head);
2264
2265 list_add(&cn->node, &clk_notifier_list);
2266 }
2267
2268 ret = srcu_notifier_chain_register(&cn->notifier_head, nb);
2269
2270 clk->notifier_count++;
2271
2272out:
Mike Turquetteeab89f62013-03-28 13:59:01 -07002273 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002274
2275 return ret;
2276}
2277EXPORT_SYMBOL_GPL(clk_notifier_register);
2278
2279/**
2280 * clk_notifier_unregister - remove a clk rate change notifier
2281 * @clk: struct clk *
2282 * @nb: struct notifier_block * with callback info
2283 *
2284 * Request no further notification for changes to 'clk' and frees memory
2285 * allocated in clk_notifier_register.
2286 *
2287 * Returns -EINVAL if called with null arguments; otherwise, passes
2288 * along the return value of srcu_notifier_chain_unregister().
2289 */
2290int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
2291{
2292 struct clk_notifier *cn = NULL;
2293 int ret = -EINVAL;
2294
2295 if (!clk || !nb)
2296 return -EINVAL;
2297
Mike Turquetteeab89f62013-03-28 13:59:01 -07002298 clk_prepare_lock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002299
2300 list_for_each_entry(cn, &clk_notifier_list, node)
2301 if (cn->clk == clk)
2302 break;
2303
2304 if (cn->clk == clk) {
2305 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb);
2306
2307 clk->notifier_count--;
2308
2309 /* XXX the notifier code should handle this better */
2310 if (!cn->notifier_head.head) {
2311 srcu_cleanup_notifier_head(&cn->notifier_head);
Lai Jiangshan72b53222013-06-03 17:17:15 +08002312 list_del(&cn->node);
Mike Turquetteb24764902012-03-15 23:11:19 -07002313 kfree(cn);
2314 }
2315
2316 } else {
2317 ret = -ENOENT;
2318 }
2319
Mike Turquetteeab89f62013-03-28 13:59:01 -07002320 clk_prepare_unlock();
Mike Turquetteb24764902012-03-15 23:11:19 -07002321
2322 return ret;
2323}
2324EXPORT_SYMBOL_GPL(clk_notifier_unregister);
Grant Likely766e6a42012-04-09 14:50:06 -05002325
2326#ifdef CONFIG_OF
2327/**
2328 * struct of_clk_provider - Clock provider registration structure
2329 * @link: Entry in global list of clock providers
2330 * @node: Pointer to device tree node of clock provider
2331 * @get: Get clock callback. Returns NULL or a struct clk for the
2332 * given clock specifier
2333 * @data: context pointer to be passed into @get callback
2334 */
2335struct of_clk_provider {
2336 struct list_head link;
2337
2338 struct device_node *node;
2339 struct clk *(*get)(struct of_phandle_args *clkspec, void *data);
2340 void *data;
2341};
2342
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05302343static const struct of_device_id __clk_of_table_sentinel
2344 __used __section(__clk_of_table_end);
2345
Grant Likely766e6a42012-04-09 14:50:06 -05002346static LIST_HEAD(of_clk_providers);
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002347static DEFINE_MUTEX(of_clk_mutex);
2348
2349/* of_clk_provider list locking helpers */
2350void of_clk_lock(void)
2351{
2352 mutex_lock(&of_clk_mutex);
2353}
2354
2355void of_clk_unlock(void)
2356{
2357 mutex_unlock(&of_clk_mutex);
2358}
Grant Likely766e6a42012-04-09 14:50:06 -05002359
2360struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
2361 void *data)
2362{
2363 return data;
2364}
2365EXPORT_SYMBOL_GPL(of_clk_src_simple_get);
2366
Shawn Guo494bfec2012-08-22 21:36:27 +08002367struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data)
2368{
2369 struct clk_onecell_data *clk_data = data;
2370 unsigned int idx = clkspec->args[0];
2371
2372 if (idx >= clk_data->clk_num) {
2373 pr_err("%s: invalid clock index %d\n", __func__, idx);
2374 return ERR_PTR(-EINVAL);
2375 }
2376
2377 return clk_data->clks[idx];
2378}
2379EXPORT_SYMBOL_GPL(of_clk_src_onecell_get);
2380
Grant Likely766e6a42012-04-09 14:50:06 -05002381/**
2382 * of_clk_add_provider() - Register a clock provider for a node
2383 * @np: Device node pointer associated with clock provider
2384 * @clk_src_get: callback for decoding clock
2385 * @data: context pointer for @clk_src_get callback.
2386 */
2387int of_clk_add_provider(struct device_node *np,
2388 struct clk *(*clk_src_get)(struct of_phandle_args *clkspec,
2389 void *data),
2390 void *data)
2391{
2392 struct of_clk_provider *cp;
Sylwester Nawrocki86be4082014-06-18 17:29:32 +02002393 int ret;
Grant Likely766e6a42012-04-09 14:50:06 -05002394
2395 cp = kzalloc(sizeof(struct of_clk_provider), GFP_KERNEL);
2396 if (!cp)
2397 return -ENOMEM;
2398
2399 cp->node = of_node_get(np);
2400 cp->data = data;
2401 cp->get = clk_src_get;
2402
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002403 mutex_lock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002404 list_add(&cp->link, &of_clk_providers);
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002405 mutex_unlock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002406 pr_debug("Added clock from %s\n", np->full_name);
2407
Sylwester Nawrocki86be4082014-06-18 17:29:32 +02002408 ret = of_clk_set_defaults(np, true);
2409 if (ret < 0)
2410 of_clk_del_provider(np);
2411
2412 return ret;
Grant Likely766e6a42012-04-09 14:50:06 -05002413}
2414EXPORT_SYMBOL_GPL(of_clk_add_provider);
2415
2416/**
2417 * of_clk_del_provider() - Remove a previously registered clock provider
2418 * @np: Device node pointer associated with clock provider
2419 */
2420void of_clk_del_provider(struct device_node *np)
2421{
2422 struct of_clk_provider *cp;
2423
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002424 mutex_lock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002425 list_for_each_entry(cp, &of_clk_providers, link) {
2426 if (cp->node == np) {
2427 list_del(&cp->link);
2428 of_node_put(cp->node);
2429 kfree(cp);
2430 break;
2431 }
2432 }
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002433 mutex_unlock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002434}
2435EXPORT_SYMBOL_GPL(of_clk_del_provider);
2436
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002437struct clk *__of_clk_get_from_provider(struct of_phandle_args *clkspec)
Grant Likely766e6a42012-04-09 14:50:06 -05002438{
2439 struct of_clk_provider *provider;
Jean-Francois Moinea34cd462013-11-25 19:47:04 +01002440 struct clk *clk = ERR_PTR(-EPROBE_DEFER);
Grant Likely766e6a42012-04-09 14:50:06 -05002441
2442 /* Check if we have such a provider in our array */
Grant Likely766e6a42012-04-09 14:50:06 -05002443 list_for_each_entry(provider, &of_clk_providers, link) {
2444 if (provider->node == clkspec->np)
2445 clk = provider->get(clkspec, provider->data);
2446 if (!IS_ERR(clk))
2447 break;
2448 }
Sylwester Nawrockid6782c22013-08-23 17:03:43 +02002449
2450 return clk;
2451}
2452
2453struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
2454{
2455 struct clk *clk;
2456
2457 mutex_lock(&of_clk_mutex);
2458 clk = __of_clk_get_from_provider(clkspec);
2459 mutex_unlock(&of_clk_mutex);
Grant Likely766e6a42012-04-09 14:50:06 -05002460
2461 return clk;
2462}
2463
Mike Turquettef6102742013-10-07 23:12:13 -07002464int of_clk_get_parent_count(struct device_node *np)
2465{
2466 return of_count_phandle_with_args(np, "clocks", "#clock-cells");
2467}
2468EXPORT_SYMBOL_GPL(of_clk_get_parent_count);
2469
Grant Likely766e6a42012-04-09 14:50:06 -05002470const char *of_clk_get_parent_name(struct device_node *np, int index)
2471{
2472 struct of_phandle_args clkspec;
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00002473 struct property *prop;
Grant Likely766e6a42012-04-09 14:50:06 -05002474 const char *clk_name;
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00002475 const __be32 *vp;
2476 u32 pv;
Grant Likely766e6a42012-04-09 14:50:06 -05002477 int rc;
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00002478 int count;
Grant Likely766e6a42012-04-09 14:50:06 -05002479
2480 if (index < 0)
2481 return NULL;
2482
2483 rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
2484 &clkspec);
2485 if (rc)
2486 return NULL;
2487
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00002488 index = clkspec.args_count ? clkspec.args[0] : 0;
2489 count = 0;
2490
2491 /* if there is an indices property, use it to transfer the index
2492 * specified into an array offset for the clock-output-names property.
2493 */
2494 of_property_for_each_u32(clkspec.np, "clock-indices", prop, vp, pv) {
2495 if (index == pv) {
2496 index = count;
2497 break;
2498 }
2499 count++;
2500 }
2501
Grant Likely766e6a42012-04-09 14:50:06 -05002502 if (of_property_read_string_index(clkspec.np, "clock-output-names",
Ben Dooks7a0fc1a2014-02-13 18:02:49 +00002503 index,
Grant Likely766e6a42012-04-09 14:50:06 -05002504 &clk_name) < 0)
2505 clk_name = clkspec.np->name;
2506
2507 of_node_put(clkspec.np);
2508 return clk_name;
2509}
2510EXPORT_SYMBOL_GPL(of_clk_get_parent_name);
2511
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002512struct clock_provider {
2513 of_clk_init_cb_t clk_init_cb;
2514 struct device_node *np;
2515 struct list_head node;
2516};
2517
2518static LIST_HEAD(clk_provider_list);
2519
2520/*
2521 * This function looks for a parent clock. If there is one, then it
2522 * checks that the provider for this parent clock was initialized, in
2523 * this case the parent clock will be ready.
2524 */
2525static int parent_ready(struct device_node *np)
2526{
2527 int i = 0;
2528
2529 while (true) {
2530 struct clk *clk = of_clk_get(np, i);
2531
2532 /* this parent is ready we can check the next one */
2533 if (!IS_ERR(clk)) {
2534 clk_put(clk);
2535 i++;
2536 continue;
2537 }
2538
2539 /* at least one parent is not ready, we exit now */
2540 if (PTR_ERR(clk) == -EPROBE_DEFER)
2541 return 0;
2542
2543 /*
2544 * Here we make assumption that the device tree is
2545 * written correctly. So an error means that there is
2546 * no more parent. As we didn't exit yet, then the
2547 * previous parent are ready. If there is no clock
2548 * parent, no need to wait for them, then we can
2549 * consider their absence as being ready
2550 */
2551 return 1;
2552 }
2553}
2554
Grant Likely766e6a42012-04-09 14:50:06 -05002555/**
2556 * of_clk_init() - Scan and init clock providers from the DT
2557 * @matches: array of compatible values and init functions for providers.
2558 *
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002559 * This function scans the device tree for matching clock providers
Sylwester Nawrockie5ca8fb2014-03-27 12:08:36 +01002560 * and calls their initialization functions. It also does it by trying
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002561 * to follow the dependencies.
Grant Likely766e6a42012-04-09 14:50:06 -05002562 */
2563void __init of_clk_init(const struct of_device_id *matches)
2564{
Alex Elder7f7ed582013-08-22 11:31:31 -05002565 const struct of_device_id *match;
Grant Likely766e6a42012-04-09 14:50:06 -05002566 struct device_node *np;
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002567 struct clock_provider *clk_provider, *next;
2568 bool is_init_done;
2569 bool force = false;
Grant Likely766e6a42012-04-09 14:50:06 -05002570
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05302571 if (!matches)
Tero Kristo819b4862013-10-22 11:39:36 +03002572 matches = &__clk_of_table;
Prashant Gaikwadf2f6c252013-01-04 12:30:52 +05302573
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002574 /* First prepare the list of the clocks providers */
Alex Elder7f7ed582013-08-22 11:31:31 -05002575 for_each_matching_node_and_match(np, matches, &match) {
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002576 struct clock_provider *parent =
2577 kzalloc(sizeof(struct clock_provider), GFP_KERNEL);
2578
2579 parent->clk_init_cb = match->data;
2580 parent->np = np;
Sylwester Nawrocki3f6d4392014-03-27 11:43:32 +01002581 list_add_tail(&parent->node, &clk_provider_list);
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002582 }
2583
2584 while (!list_empty(&clk_provider_list)) {
2585 is_init_done = false;
2586 list_for_each_entry_safe(clk_provider, next,
2587 &clk_provider_list, node) {
2588 if (force || parent_ready(clk_provider->np)) {
Sylwester Nawrocki86be4082014-06-18 17:29:32 +02002589
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002590 clk_provider->clk_init_cb(clk_provider->np);
Sylwester Nawrocki86be4082014-06-18 17:29:32 +02002591 of_clk_set_defaults(clk_provider->np, true);
2592
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002593 list_del(&clk_provider->node);
2594 kfree(clk_provider);
2595 is_init_done = true;
2596 }
2597 }
2598
2599 /*
Sylwester Nawrockie5ca8fb2014-03-27 12:08:36 +01002600 * We didn't manage to initialize any of the
Gregory CLEMENT1771b102014-02-24 19:10:13 +01002601 * remaining providers during the last loop, so now we
2602 * initialize all the remaining ones unconditionally
2603 * in case the clock parent was not mandatory
2604 */
2605 if (!is_init_done)
2606 force = true;
Grant Likely766e6a42012-04-09 14:50:06 -05002607 }
2608}
2609#endif