xref: /linux/arch/sh/kernel/cpu/clock.c (revision 5306293c9cd2caf41849cc909281bda628bb989e) 
1 /*
2  * arch/sh/kernel/cpu/clock.c - SuperH clock framework
3  *
4  *  Copyright (C) 2005 - 2009  Paul Mundt
5  *
6  * This clock framework is derived from the OMAP version by:
7  *
8  *	Copyright (C) 2004 - 2008 Nokia Corporation
9  *	Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
10  *
11  *  Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com>
12  *
13  *  With clkdev bits:
14  *
15  *	Copyright (C) 2008 Russell King.
16  *
17  * This file is subject to the terms and conditions of the GNU General Public
18  * License.  See the file "COPYING" in the main directory of this archive
19  * for more details.
20  */
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/mutex.h>
25 #include <linux/list.h>
26 #include <linux/kobject.h>
27 #include <linux/sysdev.h>
28 #include <linux/seq_file.h>
29 #include <linux/err.h>
30 #include <linux/platform_device.h>
31 #include <linux/debugfs.h>
32 #include <linux/cpufreq.h>
33 #include <asm/clock.h>
34 #include <asm/machvec.h>
35 
36 static LIST_HEAD(clock_list);
37 static DEFINE_SPINLOCK(clock_lock);
38 static DEFINE_MUTEX(clock_list_sem);
39 
40 void clk_rate_table_build(struct clk *clk,
41 			  struct cpufreq_frequency_table *freq_table,
42 			  int nr_freqs,
43 			  struct clk_div_mult_table *src_table,
44 			  unsigned long *bitmap)
45 {
46 	unsigned long mult, div;
47 	unsigned long freq;
48 	int i;
49 
50 	for (i = 0; i < nr_freqs; i++) {
51 		div = 1;
52 		mult = 1;
53 
54 		if (src_table->divisors && i < src_table->nr_divisors)
55 			div = src_table->divisors[i];
56 
57 		if (src_table->multipliers && i < src_table->nr_multipliers)
58 			mult = src_table->multipliers[i];
59 
60 		if (!div || !mult || (bitmap && !test_bit(i, bitmap)))
61 			freq = CPUFREQ_ENTRY_INVALID;
62 		else
63 			freq = clk->parent->rate * mult / div;
64 
65 		freq_table[i].index = i;
66 		freq_table[i].frequency = freq;
67 	}
68 
69 	/* Termination entry */
70 	freq_table[i].index = i;
71 	freq_table[i].frequency = CPUFREQ_TABLE_END;
72 }
73 
74 long clk_rate_table_round(struct clk *clk,
75 			  struct cpufreq_frequency_table *freq_table,
76 			  unsigned long rate)
77 {
78 	unsigned long rate_error, rate_error_prev = ~0UL;
79 	unsigned long rate_best_fit = rate;
80 	unsigned long highest, lowest;
81 	int i;
82 
83 	highest = lowest = 0;
84 
85 	for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
86 		unsigned long freq = freq_table[i].frequency;
87 
88 		if (freq == CPUFREQ_ENTRY_INVALID)
89 			continue;
90 
91 		if (freq > highest)
92 			highest = freq;
93 		if (freq < lowest)
94 			lowest = freq;
95 
96 		rate_error = abs(freq - rate);
97 		if (rate_error < rate_error_prev) {
98 			rate_best_fit = freq;
99 			rate_error_prev = rate_error;
100 		}
101 
102 		if (rate_error == 0)
103 			break;
104 	}
105 
106 	if (rate >= highest)
107 		rate_best_fit = highest;
108 	if (rate <= lowest)
109 		rate_best_fit = lowest;
110 
111 	return rate_best_fit;
112 }
113 
114 int clk_rate_table_find(struct clk *clk,
115 			struct cpufreq_frequency_table *freq_table,
116 			unsigned long rate)
117 {
118 	int i;
119 
120 	for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
121 		unsigned long freq = freq_table[i].frequency;
122 
123 		if (freq == CPUFREQ_ENTRY_INVALID)
124 			continue;
125 
126 		if (freq == rate)
127 			return i;
128 	}
129 
130 	return -ENOENT;
131 }
132 
133 /* Used for clocks that always have same value as the parent clock */
134 unsigned long followparent_recalc(struct clk *clk)
135 {
136 	return clk->parent ? clk->parent->rate : 0;
137 }
138 
139 int clk_reparent(struct clk *child, struct clk *parent)
140 {
141 	list_del_init(&child->sibling);
142 	if (parent)
143 		list_add(&child->sibling, &parent->children);
144 	child->parent = parent;
145 
146 	/* now do the debugfs renaming to reattach the child
147 	   to the proper parent */
148 
149 	return 0;
150 }
151 
152 /* Propagate rate to children */
153 void propagate_rate(struct clk *tclk)
154 {
155 	struct clk *clkp;
156 
157 	list_for_each_entry(clkp, &tclk->children, sibling) {
158 		if (clkp->ops && clkp->ops->recalc)
159 			clkp->rate = clkp->ops->recalc(clkp);
160 
161 		propagate_rate(clkp);
162 	}
163 }
164 
165 static void __clk_disable(struct clk *clk)
166 {
167 	if (clk->usecount == 0) {
168 		printk(KERN_ERR "Trying disable clock %s with 0 usecount\n",
169 		       clk->name);
170 		WARN_ON(1);
171 		return;
172 	}
173 
174 	if (!(--clk->usecount)) {
175 		if (likely(clk->ops && clk->ops->disable))
176 			clk->ops->disable(clk);
177 		if (likely(clk->parent))
178 			__clk_disable(clk->parent);
179 	}
180 }
181 
182 void clk_disable(struct clk *clk)
183 {
184 	unsigned long flags;
185 
186 	if (!clk)
187 		return;
188 
189 	spin_lock_irqsave(&clock_lock, flags);
190 	__clk_disable(clk);
191 	spin_unlock_irqrestore(&clock_lock, flags);
192 }
193 EXPORT_SYMBOL_GPL(clk_disable);
194 
195 static int __clk_enable(struct clk *clk)
196 {
197 	int ret = 0;
198 
199 	if (clk->usecount++ == 0) {
200 		if (clk->parent) {
201 			ret = __clk_enable(clk->parent);
202 			if (unlikely(ret))
203 				goto err;
204 		}
205 
206 		if (clk->ops && clk->ops->enable) {
207 			ret = clk->ops->enable(clk);
208 			if (ret) {
209 				if (clk->parent)
210 					__clk_disable(clk->parent);
211 				goto err;
212 			}
213 		}
214 	}
215 
216 	return ret;
217 err:
218 	clk->usecount--;
219 	return ret;
220 }
221 
222 int clk_enable(struct clk *clk)
223 {
224 	unsigned long flags;
225 	int ret;
226 
227 	if (!clk)
228 		return -EINVAL;
229 
230 	spin_lock_irqsave(&clock_lock, flags);
231 	ret = __clk_enable(clk);
232 	spin_unlock_irqrestore(&clock_lock, flags);
233 
234 	return ret;
235 }
236 EXPORT_SYMBOL_GPL(clk_enable);
237 
238 static LIST_HEAD(root_clks);
239 
240 /**
241  * recalculate_root_clocks - recalculate and propagate all root clocks
242  *
243  * Recalculates all root clocks (clocks with no parent), which if the
244  * clock's .recalc is set correctly, should also propagate their rates.
245  * Called at init.
246  */
247 void recalculate_root_clocks(void)
248 {
249 	struct clk *clkp;
250 
251 	list_for_each_entry(clkp, &root_clks, sibling) {
252 		if (clkp->ops && clkp->ops->recalc)
253 			clkp->rate = clkp->ops->recalc(clkp);
254 		propagate_rate(clkp);
255 	}
256 }
257 
258 int clk_register(struct clk *clk)
259 {
260 	if (clk == NULL || IS_ERR(clk))
261 		return -EINVAL;
262 
263 	/*
264 	 * trap out already registered clocks
265 	 */
266 	if (clk->node.next || clk->node.prev)
267 		return 0;
268 
269 	mutex_lock(&clock_list_sem);
270 
271 	INIT_LIST_HEAD(&clk->children);
272 	clk->usecount = 0;
273 
274 	if (clk->parent)
275 		list_add(&clk->sibling, &clk->parent->children);
276 	else
277 		list_add(&clk->sibling, &root_clks);
278 
279 	list_add(&clk->node, &clock_list);
280 	if (clk->ops && clk->ops->init)
281 		clk->ops->init(clk);
282 	mutex_unlock(&clock_list_sem);
283 
284 	return 0;
285 }
286 EXPORT_SYMBOL_GPL(clk_register);
287 
288 void clk_unregister(struct clk *clk)
289 {
290 	mutex_lock(&clock_list_sem);
291 	list_del(&clk->sibling);
292 	list_del(&clk->node);
293 	mutex_unlock(&clock_list_sem);
294 }
295 EXPORT_SYMBOL_GPL(clk_unregister);
296 
297 static void clk_enable_init_clocks(void)
298 {
299 	struct clk *clkp;
300 
301 	list_for_each_entry(clkp, &clock_list, node)
302 		if (clkp->flags & CLK_ENABLE_ON_INIT)
303 			clk_enable(clkp);
304 }
305 
306 unsigned long clk_get_rate(struct clk *clk)
307 {
308 	return clk->rate;
309 }
310 EXPORT_SYMBOL_GPL(clk_get_rate);
311 
312 int clk_set_rate(struct clk *clk, unsigned long rate)
313 {
314 	return clk_set_rate_ex(clk, rate, 0);
315 }
316 EXPORT_SYMBOL_GPL(clk_set_rate);
317 
318 int clk_set_rate_ex(struct clk *clk, unsigned long rate, int algo_id)
319 {
320 	int ret = -EOPNOTSUPP;
321 	unsigned long flags;
322 
323 	spin_lock_irqsave(&clock_lock, flags);
324 
325 	if (likely(clk->ops && clk->ops->set_rate)) {
326 		ret = clk->ops->set_rate(clk, rate, algo_id);
327 		if (ret != 0)
328 			goto out_unlock;
329 	} else {
330 		clk->rate = rate;
331 		ret = 0;
332 	}
333 
334 	if (clk->ops && clk->ops->recalc)
335 		clk->rate = clk->ops->recalc(clk);
336 
337 	propagate_rate(clk);
338 
339 out_unlock:
340 	spin_unlock_irqrestore(&clock_lock, flags);
341 
342 	return ret;
343 }
344 EXPORT_SYMBOL_GPL(clk_set_rate_ex);
345 
346 int clk_set_parent(struct clk *clk, struct clk *parent)
347 {
348 	unsigned long flags;
349 	int ret = -EINVAL;
350 
351 	if (!parent || !clk)
352 		return ret;
353 	if (clk->parent == parent)
354 		return 0;
355 
356 	spin_lock_irqsave(&clock_lock, flags);
357 	if (clk->usecount == 0) {
358 		if (clk->ops->set_parent)
359 			ret = clk->ops->set_parent(clk, parent);
360 		else
361 			ret = clk_reparent(clk, parent);
362 
363 		if (ret == 0) {
364 			pr_debug("clock: set parent of %s to %s (new rate %ld)\n",
365 				 clk->name, clk->parent->name, clk->rate);
366 			if (clk->ops->recalc)
367 				clk->rate = clk->ops->recalc(clk);
368 			propagate_rate(clk);
369 		}
370 	} else
371 		ret = -EBUSY;
372 	spin_unlock_irqrestore(&clock_lock, flags);
373 
374 	return ret;
375 }
376 EXPORT_SYMBOL_GPL(clk_set_parent);
377 
378 struct clk *clk_get_parent(struct clk *clk)
379 {
380 	return clk->parent;
381 }
382 EXPORT_SYMBOL_GPL(clk_get_parent);
383 
384 long clk_round_rate(struct clk *clk, unsigned long rate)
385 {
386 	if (likely(clk->ops && clk->ops->round_rate)) {
387 		unsigned long flags, rounded;
388 
389 		spin_lock_irqsave(&clock_lock, flags);
390 		rounded = clk->ops->round_rate(clk, rate);
391 		spin_unlock_irqrestore(&clock_lock, flags);
392 
393 		return rounded;
394 	}
395 
396 	return clk_get_rate(clk);
397 }
398 EXPORT_SYMBOL_GPL(clk_round_rate);
399 
400 /*
401  * Find the correct struct clk for the device and connection ID.
402  * We do slightly fuzzy matching here:
403  *  An entry with a NULL ID is assumed to be a wildcard.
404  *  If an entry has a device ID, it must match
405  *  If an entry has a connection ID, it must match
406  * Then we take the most specific entry - with the following
407  * order of precedence: dev+con > dev only > con only.
408  */
409 static struct clk *clk_find(const char *dev_id, const char *con_id)
410 {
411 	struct clk_lookup *p;
412 	struct clk *clk = NULL;
413 	int match, best = 0;
414 
415 	list_for_each_entry(p, &clock_list, node) {
416 		match = 0;
417 		if (p->dev_id) {
418 			if (!dev_id || strcmp(p->dev_id, dev_id))
419 				continue;
420 			match += 2;
421 		}
422 		if (p->con_id) {
423 			if (!con_id || strcmp(p->con_id, con_id))
424 				continue;
425 			match += 1;
426 		}
427 		if (match == 0)
428 			continue;
429 
430 		if (match > best) {
431 			clk = p->clk;
432 			best = match;
433 		}
434 	}
435 	return clk;
436 }
437 
438 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
439 {
440 	struct clk *clk;
441 
442 	mutex_lock(&clock_list_sem);
443 	clk = clk_find(dev_id, con_id);
444 	mutex_unlock(&clock_list_sem);
445 
446 	return clk ? clk : ERR_PTR(-ENOENT);
447 }
448 EXPORT_SYMBOL_GPL(clk_get_sys);
449 
450 /*
451  * Returns a clock. Note that we first try to use device id on the bus
452  * and clock name. If this fails, we try to use clock name only.
453  */
454 struct clk *clk_get(struct device *dev, const char *id)
455 {
456 	const char *dev_id = dev ? dev_name(dev) : NULL;
457 	struct clk *p, *clk = ERR_PTR(-ENOENT);
458 	int idno;
459 
460 	clk = clk_get_sys(dev_id, id);
461 	if (clk && !IS_ERR(clk))
462 		return clk;
463 
464 	if (dev == NULL || dev->bus != &platform_bus_type)
465 		idno = -1;
466 	else
467 		idno = to_platform_device(dev)->id;
468 
469 	mutex_lock(&clock_list_sem);
470 	list_for_each_entry(p, &clock_list, node) {
471 		if (p->id == idno &&
472 		    strcmp(id, p->name) == 0 && try_module_get(p->owner)) {
473 			clk = p;
474 			goto found;
475 		}
476 	}
477 
478 	list_for_each_entry(p, &clock_list, node) {
479 		if (strcmp(id, p->name) == 0 && try_module_get(p->owner)) {
480 			clk = p;
481 			break;
482 		}
483 	}
484 
485 found:
486 	mutex_unlock(&clock_list_sem);
487 
488 	return clk;
489 }
490 EXPORT_SYMBOL_GPL(clk_get);
491 
492 void clk_put(struct clk *clk)
493 {
494 	if (clk && !IS_ERR(clk))
495 		module_put(clk->owner);
496 }
497 EXPORT_SYMBOL_GPL(clk_put);
498 
499 #ifdef CONFIG_PM
500 static int clks_sysdev_suspend(struct sys_device *dev, pm_message_t state)
501 {
502 	static pm_message_t prev_state;
503 	struct clk *clkp;
504 
505 	switch (state.event) {
506 	case PM_EVENT_ON:
507 		/* Resumeing from hibernation */
508 		if (prev_state.event != PM_EVENT_FREEZE)
509 			break;
510 
511 		list_for_each_entry(clkp, &clock_list, node) {
512 			if (likely(clkp->ops)) {
513 				unsigned long rate = clkp->rate;
514 
515 				if (likely(clkp->ops->set_parent))
516 					clkp->ops->set_parent(clkp,
517 						clkp->parent);
518 				if (likely(clkp->ops->set_rate))
519 					clkp->ops->set_rate(clkp,
520 						rate, NO_CHANGE);
521 				else if (likely(clkp->ops->recalc))
522 					clkp->rate = clkp->ops->recalc(clkp);
523 			}
524 		}
525 		break;
526 	case PM_EVENT_FREEZE:
527 		break;
528 	case PM_EVENT_SUSPEND:
529 		break;
530 	}
531 
532 	prev_state = state;
533 	return 0;
534 }
535 
536 static int clks_sysdev_resume(struct sys_device *dev)
537 {
538 	return clks_sysdev_suspend(dev, PMSG_ON);
539 }
540 
541 static struct sysdev_class clks_sysdev_class = {
542 	.name = "clks",
543 };
544 
545 static struct sysdev_driver clks_sysdev_driver = {
546 	.suspend = clks_sysdev_suspend,
547 	.resume = clks_sysdev_resume,
548 };
549 
550 static struct sys_device clks_sysdev_dev = {
551 	.cls = &clks_sysdev_class,
552 };
553 
554 static int __init clk_sysdev_init(void)
555 {
556 	sysdev_class_register(&clks_sysdev_class);
557 	sysdev_driver_register(&clks_sysdev_class, &clks_sysdev_driver);
558 	sysdev_register(&clks_sysdev_dev);
559 
560 	return 0;
561 }
562 subsys_initcall(clk_sysdev_init);
563 #endif
564 
565 int __init clk_init(void)
566 {
567 	int ret;
568 
569 	ret = arch_clk_init();
570 	if (unlikely(ret)) {
571 		pr_err("%s: CPU clock registration failed.\n", __func__);
572 		return ret;
573 	}
574 
575 	if (sh_mv.mv_clk_init) {
576 		ret = sh_mv.mv_clk_init();
577 		if (unlikely(ret)) {
578 			pr_err("%s: machvec clock initialization failed.\n",
579 			       __func__);
580 			return ret;
581 		}
582 	}
583 
584 	/* Kick the child clocks.. */
585 	recalculate_root_clocks();
586 
587 	/* Enable the necessary init clocks */
588 	clk_enable_init_clocks();
589 
590 	return ret;
591 }
592 
593 /*
594  *	debugfs support to trace clock tree hierarchy and attributes
595  */
596 static struct dentry *clk_debugfs_root;
597 
598 static int clk_debugfs_register_one(struct clk *c)
599 {
600 	int err;
601 	struct dentry *d, *child, *child_tmp;
602 	struct clk *pa = c->parent;
603 	char s[255];
604 	char *p = s;
605 
606 	p += sprintf(p, "%s", c->name);
607 	if (c->id >= 0)
608 		sprintf(p, ":%d", c->id);
609 	d = debugfs_create_dir(s, pa ? pa->dentry : clk_debugfs_root);
610 	if (!d)
611 		return -ENOMEM;
612 	c->dentry = d;
613 
614 	d = debugfs_create_u8("usecount", S_IRUGO, c->dentry, (u8 *)&c->usecount);
615 	if (!d) {
616 		err = -ENOMEM;
617 		goto err_out;
618 	}
619 	d = debugfs_create_u32("rate", S_IRUGO, c->dentry, (u32 *)&c->rate);
620 	if (!d) {
621 		err = -ENOMEM;
622 		goto err_out;
623 	}
624 	d = debugfs_create_x32("flags", S_IRUGO, c->dentry, (u32 *)&c->flags);
625 	if (!d) {
626 		err = -ENOMEM;
627 		goto err_out;
628 	}
629 	return 0;
630 
631 err_out:
632 	d = c->dentry;
633 	list_for_each_entry_safe(child, child_tmp, &d->d_subdirs, d_u.d_child)
634 		debugfs_remove(child);
635 	debugfs_remove(c->dentry);
636 	return err;
637 }
638 
639 static int clk_debugfs_register(struct clk *c)
640 {
641 	int err;
642 	struct clk *pa = c->parent;
643 
644 	if (pa && !pa->dentry) {
645 		err = clk_debugfs_register(pa);
646 		if (err)
647 			return err;
648 	}
649 
650 	if (!c->dentry) {
651 		err = clk_debugfs_register_one(c);
652 		if (err)
653 			return err;
654 	}
655 	return 0;
656 }
657 
658 static int __init clk_debugfs_init(void)
659 {
660 	struct clk *c;
661 	struct dentry *d;
662 	int err;
663 
664 	d = debugfs_create_dir("clock", NULL);
665 	if (!d)
666 		return -ENOMEM;
667 	clk_debugfs_root = d;
668 
669 	list_for_each_entry(c, &clock_list, node) {
670 		err = clk_debugfs_register(c);
671 		if (err)
672 			goto err_out;
673 	}
674 	return 0;
675 err_out:
676 	debugfs_remove(clk_debugfs_root); /* REVISIT: Cleanup correctly */
677 	return err;
678 }
679 late_initcall(clk_debugfs_init);
680