/* * SuperH clock framework * * Copyright (C) 2005 - 2010 Paul Mundt * * This clock framework is derived from the OMAP version by: * * Copyright (C) 2004 - 2008 Nokia Corporation * Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com> * * Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com> * * This file is subject to the terms and conditions of the GNU General Public * License. See the file "COPYING" in the main directory of this archive * for more details. */ #define pr_fmt(fmt) "clock: " fmt #include <linux/kernel.h> #include <linux/init.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/list.h> #include <linux/syscore_ops.h> #include <linux/seq_file.h> #include <linux/err.h> #include <linux/io.h> #include <linux/debugfs.h> #include <linux/cpufreq.h> #include <linux/clk.h> #include <linux/sh_clk.h> static LIST_HEAD(clock_list); static DEFINE_SPINLOCK(clock_lock); static DEFINE_MUTEX(clock_list_sem); void clk_rate_table_build(struct clk *clk, struct cpufreq_frequency_table *freq_table, int nr_freqs, struct clk_div_mult_table *src_table, unsigned long *bitmap) { unsigned long mult, div; unsigned long freq; int i; clk->nr_freqs = nr_freqs; for (i = 0; i < nr_freqs; i++) { div = 1; mult = 1; if (src_table->divisors && i < src_table->nr_divisors) div = src_table->divisors[i]; if (src_table->multipliers && i < src_table->nr_multipliers) mult = src_table->multipliers[i]; if (!div || !mult || (bitmap && !test_bit(i, bitmap))) freq = CPUFREQ_ENTRY_INVALID; else freq = clk->parent->rate * mult / div; freq_table[i].index = i; freq_table[i].frequency = freq; } /* Termination entry */ freq_table[i].index = i; freq_table[i].frequency = CPUFREQ_TABLE_END; } struct clk_rate_round_data; struct clk_rate_round_data { unsigned long rate; unsigned int min, max; long (*func)(unsigned int, struct clk_rate_round_data *); void *arg; }; #define for_each_frequency(pos, r, freq) \ for (pos = r->min, freq = r->func(pos, r); \ pos <= r->max; pos++, freq = r->func(pos, r)) \ if (unlikely(freq == 0)) \ ; \ else static long clk_rate_round_helper(struct clk_rate_round_data *rounder) { unsigned long rate_error, rate_error_prev = ~0UL; unsigned long highest, lowest, freq; long rate_best_fit = -ENOENT; int i; highest = 0; lowest = ~0UL; for_each_frequency(i, rounder, freq) { if (freq > highest) highest = freq; if (freq < lowest) lowest = freq; rate_error = abs(freq - rounder->rate); if (rate_error < rate_error_prev) { rate_best_fit = freq; rate_error_prev = rate_error; } if (rate_error == 0) break; } if (rounder->rate >= highest) rate_best_fit = highest; if (rounder->rate <= lowest) rate_best_fit = lowest; return rate_best_fit; } static long clk_rate_table_iter(unsigned int pos, struct clk_rate_round_data *rounder) { struct cpufreq_frequency_table *freq_table = rounder->arg; unsigned long freq = freq_table[pos].frequency; if (freq == CPUFREQ_ENTRY_INVALID) freq = 0; return freq; } long clk_rate_table_round(struct clk *clk, struct cpufreq_frequency_table *freq_table, unsigned long rate) { struct clk_rate_round_data table_round = { .min = 0, .max = clk->nr_freqs - 1, .func = clk_rate_table_iter, .arg = freq_table, .rate = rate, }; if (clk->nr_freqs < 1) return -ENOSYS; return clk_rate_round_helper(&table_round); } static long clk_rate_div_range_iter(unsigned int pos, struct clk_rate_round_data *rounder) { return clk_get_rate(rounder->arg) / pos; } long clk_rate_div_range_round(struct clk *clk, unsigned int div_min, unsigned int div_max, unsigned long rate) { struct clk_rate_round_data div_range_round = { .min = div_min, .max = div_max, .func = clk_rate_div_range_iter, .arg = clk_get_parent(clk), .rate = rate, }; return clk_rate_round_helper(&div_range_round); } int clk_rate_table_find(struct clk *clk, struct cpufreq_frequency_table *freq_table, unsigned long rate) { int i; for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) { unsigned long freq = freq_table[i].frequency; if (freq == CPUFREQ_ENTRY_INVALID) continue; if (freq == rate) return i; } return -ENOENT; } /* Used for clocks that always have same value as the parent clock */ unsigned long followparent_recalc(struct clk *clk) { return clk->parent ? clk->parent->rate : 0; } int clk_reparent(struct clk *child, struct clk *parent) { list_del_init(&child->sibling); if (parent) list_add(&child->sibling, &parent->children); child->parent = parent; /* now do the debugfs renaming to reattach the child to the proper parent */ return 0; } /* Propagate rate to children */ void propagate_rate(struct clk *tclk) { struct clk *clkp; list_for_each_entry(clkp, &tclk->children, sibling) { if (clkp->ops && clkp->ops->recalc) clkp->rate = clkp->ops->recalc(clkp); propagate_rate(clkp); } } static void __clk_disable(struct clk *clk) { if (WARN(!clk->usecount, "Trying to disable clock %p with 0 usecount\n", clk)) return; if (!(--clk->usecount)) { if (likely(clk->ops && clk->ops->disable)) clk->ops->disable(clk); if (likely(clk->parent)) __clk_disable(clk->parent); } } void clk_disable(struct clk *clk) { unsigned long flags; if (!clk) return; spin_lock_irqsave(&clock_lock, flags); __clk_disable(clk); spin_unlock_irqrestore(&clock_lock, flags); } EXPORT_SYMBOL_GPL(clk_disable); static int __clk_enable(struct clk *clk) { int ret = 0; if (clk->usecount++ == 0) { if (clk->parent) { ret = __clk_enable(clk->parent); if (unlikely(ret)) goto err; } if (clk->ops && clk->ops->enable) { ret = clk->ops->enable(clk); if (ret) { if (clk->parent) __clk_disable(clk->parent); goto err; } } } return ret; err: clk->usecount--; return ret; } int clk_enable(struct clk *clk) { unsigned long flags; int ret; if (!clk) return -EINVAL; spin_lock_irqsave(&clock_lock, flags); ret = __clk_enable(clk); spin_unlock_irqrestore(&clock_lock, flags); return ret; } EXPORT_SYMBOL_GPL(clk_enable); static LIST_HEAD(root_clks); /** * recalculate_root_clocks - recalculate and propagate all root clocks * * Recalculates all root clocks (clocks with no parent), which if the * clock's .recalc is set correctly, should also propagate their rates. * Called at init. */ void recalculate_root_clocks(void) { struct clk *clkp; list_for_each_entry(clkp, &root_clks, sibling) { if (clkp->ops && clkp->ops->recalc) clkp->rate = clkp->ops->recalc(clkp); propagate_rate(clkp); } } static struct clk_mapping dummy_mapping; static struct clk *lookup_root_clock(struct clk *clk) { while (clk->parent) clk = clk->parent; return clk; } static int clk_establish_mapping(struct clk *clk) { struct clk_mapping *mapping = clk->mapping; /* * Propagate mappings. */ if (!mapping) { struct clk *clkp; /* * dummy mapping for root clocks with no specified ranges */ if (!clk->parent) { clk->mapping = &dummy_mapping; return 0; } /* * If we're on a child clock and it provides no mapping of its * own, inherit the mapping from its root clock. */ clkp = lookup_root_clock(clk); mapping = clkp->mapping; BUG_ON(!mapping); } /* * Establish initial mapping. */ if (!mapping->base && mapping->phys) { kref_init(&mapping->ref); mapping->base = ioremap_nocache(mapping->phys, mapping->len); if (unlikely(!mapping->base)) return -ENXIO; } else if (mapping->base) { /* * Bump the refcount for an existing mapping */ kref_get(&mapping->ref); } clk->mapping = mapping; return 0; } static void clk_destroy_mapping(struct kref *kref) { struct clk_mapping *mapping; mapping = container_of(kref, struct clk_mapping, ref); iounmap(mapping->base); } static void clk_teardown_mapping(struct clk *clk) { struct clk_mapping *mapping = clk->mapping; /* Nothing to do */ if (mapping == &dummy_mapping) return; kref_put(&mapping->ref, clk_destroy_mapping); clk->mapping = NULL; } int clk_register(struct clk *clk) { int ret; if (clk == NULL || IS_ERR(clk)) return -EINVAL; /* * trap out already registered clocks */ if (clk->node.next || clk->node.prev) return 0; mutex_lock(&clock_list_sem); INIT_LIST_HEAD(&clk->children); clk->usecount = 0; ret = clk_establish_mapping(clk); if (unlikely(ret)) goto out_unlock; if (clk->parent) list_add(&clk->sibling, &clk->parent->children); else list_add(&clk->sibling, &root_clks); list_add(&clk->node, &clock_list); #ifdef CONFIG_SH_CLK_CPG_LEGACY if (clk->ops && clk->ops->init) clk->ops->init(clk); #endif out_unlock: mutex_unlock(&clock_list_sem); return ret; } EXPORT_SYMBOL_GPL(clk_register); void clk_unregister(struct clk *clk) { mutex_lock(&clock_list_sem); list_del(&clk->sibling); list_del(&clk->node); clk_teardown_mapping(clk); mutex_unlock(&clock_list_sem); } EXPORT_SYMBOL_GPL(clk_unregister); void clk_enable_init_clocks(void) { struct clk *clkp; list_for_each_entry(clkp, &clock_list, node) if (clkp->flags & CLK_ENABLE_ON_INIT) clk_enable(clkp); } unsigned long clk_get_rate(struct clk *clk) { return clk->rate; } EXPORT_SYMBOL_GPL(clk_get_rate); int clk_set_rate(struct clk *clk, unsigned long rate) { int ret = -EOPNOTSUPP; unsigned long flags; spin_lock_irqsave(&clock_lock, flags); if (likely(clk->ops && clk->ops->set_rate)) { ret = clk->ops->set_rate(clk, rate); if (ret != 0) goto out_unlock; } else { clk->rate = rate; ret = 0; } if (clk->ops && clk->ops->recalc) clk->rate = clk->ops->recalc(clk); propagate_rate(clk); out_unlock: spin_unlock_irqrestore(&clock_lock, flags); return ret; } EXPORT_SYMBOL_GPL(clk_set_rate); int clk_set_parent(struct clk *clk, struct clk *parent) { unsigned long flags; int ret = -EINVAL; if (!parent || !clk) return ret; if (clk->parent == parent) return 0; spin_lock_irqsave(&clock_lock, flags); if (clk->usecount == 0) { if (clk->ops->set_parent) ret = clk->ops->set_parent(clk, parent); else ret = clk_reparent(clk, parent); if (ret == 0) { if (clk->ops->recalc) clk->rate = clk->ops->recalc(clk); pr_debug("set parent of %p to %p (new rate %ld)\n", clk, clk->parent, clk->rate); propagate_rate(clk); } } else ret = -EBUSY; spin_unlock_irqrestore(&clock_lock, flags); return ret; } EXPORT_SYMBOL_GPL(clk_set_parent); struct clk *clk_get_parent(struct clk *clk) { return clk->parent; } EXPORT_SYMBOL_GPL(clk_get_parent); long clk_round_rate(struct clk *clk, unsigned long rate) { if (likely(clk->ops && clk->ops->round_rate)) { unsigned long flags, rounded; spin_lock_irqsave(&clock_lock, flags); rounded = clk->ops->round_rate(clk, rate); spin_unlock_irqrestore(&clock_lock, flags); return rounded; } return clk_get_rate(clk); } EXPORT_SYMBOL_GPL(clk_round_rate); long clk_round_parent(struct clk *clk, unsigned long target, unsigned long *best_freq, unsigned long *parent_freq, unsigned int div_min, unsigned int div_max) { struct cpufreq_frequency_table *freq, *best = NULL; unsigned long error = ULONG_MAX, freq_high, freq_low, div; struct clk *parent = clk_get_parent(clk); if (!parent) { *parent_freq = 0; *best_freq = clk_round_rate(clk, target); return abs(target - *best_freq); } for (freq = parent->freq_table; freq->frequency != CPUFREQ_TABLE_END; freq++) { if (freq->frequency == CPUFREQ_ENTRY_INVALID) continue; if (unlikely(freq->frequency / target <= div_min - 1)) { unsigned long freq_max; freq_max = (freq->frequency + div_min / 2) / div_min; if (error > target - freq_max) { error = target - freq_max; best = freq; if (best_freq) *best_freq = freq_max; } pr_debug("too low freq %u, error %lu\n", freq->frequency, target - freq_max); if (!error) break; continue; } if (unlikely(freq->frequency / target >= div_max)) { unsigned long freq_min; freq_min = (freq->frequency + div_max / 2) / div_max; if (error > freq_min - target) { error = freq_min - target; best = freq; if (best_freq) *best_freq = freq_min; } pr_debug("too high freq %u, error %lu\n", freq->frequency, freq_min - target); if (!error) break; continue; } div = freq->frequency / target; freq_high = freq->frequency / div; freq_low = freq->frequency / (div + 1); if (freq_high - target < error) { error = freq_high - target; best = freq; if (best_freq) *best_freq = freq_high; } if (target - freq_low < error) { error = target - freq_low; best = freq; if (best_freq) *best_freq = freq_low; } pr_debug("%u / %lu = %lu, / %lu = %lu, best %lu, parent %u\n", freq->frequency, div, freq_high, div + 1, freq_low, *best_freq, best->frequency); if (!error) break; } if (parent_freq) *parent_freq = best->frequency; return error; } EXPORT_SYMBOL_GPL(clk_round_parent); #ifdef CONFIG_PM static void clks_core_resume(void) { struct clk *clkp; list_for_each_entry(clkp, &clock_list, node) { if (likely(clkp->usecount && clkp->ops)) { unsigned long rate = clkp->rate; if (likely(clkp->ops->set_parent)) clkp->ops->set_parent(clkp, clkp->parent); if (likely(clkp->ops->set_rate)) clkp->ops->set_rate(clkp, rate); else if (likely(clkp->ops->recalc)) clkp->rate = clkp->ops->recalc(clkp); } } } static struct syscore_ops clks_syscore_ops = { .resume = clks_core_resume, }; static int __init clk_syscore_init(void) { register_syscore_ops(&clks_syscore_ops); return 0; } subsys_initcall(clk_syscore_init); #endif /* * debugfs support to trace clock tree hierarchy and attributes */ static struct dentry *clk_debugfs_root; static int clk_debugfs_register_one(struct clk *c) { int err; struct dentry *d, *child, *child_tmp; struct clk *pa = c->parent; char s[255]; char *p = s; p += sprintf(p, "%p", c); d = debugfs_create_dir(s, pa ? pa->dentry : clk_debugfs_root); if (!d) return -ENOMEM; c->dentry = d; d = debugfs_create_u8("usecount", S_IRUGO, c->dentry, (u8 *)&c->usecount); if (!d) { err = -ENOMEM; goto err_out; } d = debugfs_create_u32("rate", S_IRUGO, c->dentry, (u32 *)&c->rate); if (!d) { err = -ENOMEM; goto err_out; } d = debugfs_create_x32("flags", S_IRUGO, c->dentry, (u32 *)&c->flags); if (!d) { err = -ENOMEM; goto err_out; } return 0; err_out: d = c->dentry; list_for_each_entry_safe(child, child_tmp, &d->d_subdirs, d_u.d_child) debugfs_remove(child); debugfs_remove(c->dentry); return err; } static int clk_debugfs_register(struct clk *c) { int err; struct clk *pa = c->parent; if (pa && !pa->dentry) { err = clk_debugfs_register(pa); if (err) return err; } if (!c->dentry) { err = clk_debugfs_register_one(c); if (err) return err; } return 0; } static int __init clk_debugfs_init(void) { struct clk *c; struct dentry *d; int err; d = debugfs_create_dir("clock", NULL); if (!d) return -ENOMEM; clk_debugfs_root = d; list_for_each_entry(c, &clock_list, node) { err = clk_debugfs_register(c); if (err) goto err_out; } return 0; err_out: debugfs_remove_recursive(clk_debugfs_root); return err; } late_initcall(clk_debugfs_init);