![Rajendra Nayak](/assets/img/avatar_default.png)
Moving to Common clk framework for OMAP would mean we no longer use internal lookup mechanism like omap_clk_get_by_name(). get rid of all its usage mostly from hwmod and omap_device code. Moving to clk_get() also means the respective platforms need the clkdev tables updated with an entry for all clocks used by hwmod to have clock name same as the alias. Based on original changes from Mike Turquette. Signed-off-by: Rajendra Nayak <rnayak@ti.com> Cc: Russell King - ARM Linux <linux@arm.linux.org.uk> [paul@pwsan.com: removed IS_ERR_OR_NULL() conversion (rmk comment); restricted omap_96m_alwon_fck_3630 to OMAP36xx; added missing AM35xx clock aliases for emac_fck, emac_ick, vpfe_ick, vpfe_fck; added aliases rng_ick and several emulation clocks] Signed-off-by: Paul Walmsley <paul@pwsan.com>
545 lines
10 KiB
C
545 lines
10 KiB
C
/*
|
|
* linux/arch/arm/plat-omap/clock.c
|
|
*
|
|
* 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 program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/list.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/export.h>
|
|
#include <linux/err.h>
|
|
#include <linux/string.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/cpufreq.h>
|
|
#include <linux/io.h>
|
|
|
|
#include <plat/clock.h>
|
|
|
|
static LIST_HEAD(clocks);
|
|
static DEFINE_MUTEX(clocks_mutex);
|
|
static DEFINE_SPINLOCK(clockfw_lock);
|
|
|
|
static struct clk_functions *arch_clock;
|
|
|
|
/*
|
|
* Standard clock functions defined in include/linux/clk.h
|
|
*/
|
|
|
|
int clk_enable(struct clk *clk)
|
|
{
|
|
unsigned long flags;
|
|
int ret;
|
|
|
|
if (clk == NULL || IS_ERR(clk))
|
|
return -EINVAL;
|
|
|
|
if (!arch_clock || !arch_clock->clk_enable)
|
|
return -EINVAL;
|
|
|
|
spin_lock_irqsave(&clockfw_lock, flags);
|
|
ret = arch_clock->clk_enable(clk);
|
|
spin_unlock_irqrestore(&clockfw_lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(clk_enable);
|
|
|
|
void clk_disable(struct clk *clk)
|
|
{
|
|
unsigned long flags;
|
|
|
|
if (clk == NULL || IS_ERR(clk))
|
|
return;
|
|
|
|
if (!arch_clock || !arch_clock->clk_disable)
|
|
return;
|
|
|
|
spin_lock_irqsave(&clockfw_lock, flags);
|
|
if (clk->usecount == 0) {
|
|
pr_err("Trying disable clock %s with 0 usecount\n",
|
|
clk->name);
|
|
WARN_ON(1);
|
|
goto out;
|
|
}
|
|
|
|
arch_clock->clk_disable(clk);
|
|
|
|
out:
|
|
spin_unlock_irqrestore(&clockfw_lock, flags);
|
|
}
|
|
EXPORT_SYMBOL(clk_disable);
|
|
|
|
unsigned long clk_get_rate(struct clk *clk)
|
|
{
|
|
unsigned long flags;
|
|
unsigned long ret;
|
|
|
|
if (clk == NULL || IS_ERR(clk))
|
|
return 0;
|
|
|
|
spin_lock_irqsave(&clockfw_lock, flags);
|
|
ret = clk->rate;
|
|
spin_unlock_irqrestore(&clockfw_lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(clk_get_rate);
|
|
|
|
/*
|
|
* Optional clock functions defined in include/linux/clk.h
|
|
*/
|
|
|
|
long clk_round_rate(struct clk *clk, unsigned long rate)
|
|
{
|
|
unsigned long flags;
|
|
long ret;
|
|
|
|
if (clk == NULL || IS_ERR(clk))
|
|
return 0;
|
|
|
|
if (!arch_clock || !arch_clock->clk_round_rate)
|
|
return 0;
|
|
|
|
spin_lock_irqsave(&clockfw_lock, flags);
|
|
ret = arch_clock->clk_round_rate(clk, rate);
|
|
spin_unlock_irqrestore(&clockfw_lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(clk_round_rate);
|
|
|
|
int clk_set_rate(struct clk *clk, unsigned long rate)
|
|
{
|
|
unsigned long flags;
|
|
int ret = -EINVAL;
|
|
|
|
if (clk == NULL || IS_ERR(clk))
|
|
return ret;
|
|
|
|
if (!arch_clock || !arch_clock->clk_set_rate)
|
|
return ret;
|
|
|
|
spin_lock_irqsave(&clockfw_lock, flags);
|
|
ret = arch_clock->clk_set_rate(clk, rate);
|
|
if (ret == 0)
|
|
propagate_rate(clk);
|
|
spin_unlock_irqrestore(&clockfw_lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(clk_set_rate);
|
|
|
|
int clk_set_parent(struct clk *clk, struct clk *parent)
|
|
{
|
|
unsigned long flags;
|
|
int ret = -EINVAL;
|
|
|
|
if (clk == NULL || IS_ERR(clk) || parent == NULL || IS_ERR(parent))
|
|
return ret;
|
|
|
|
if (!arch_clock || !arch_clock->clk_set_parent)
|
|
return ret;
|
|
|
|
spin_lock_irqsave(&clockfw_lock, flags);
|
|
if (clk->usecount == 0) {
|
|
ret = arch_clock->clk_set_parent(clk, parent);
|
|
if (ret == 0)
|
|
propagate_rate(clk);
|
|
} else
|
|
ret = -EBUSY;
|
|
spin_unlock_irqrestore(&clockfw_lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(clk_set_parent);
|
|
|
|
struct clk *clk_get_parent(struct clk *clk)
|
|
{
|
|
return clk->parent;
|
|
}
|
|
EXPORT_SYMBOL(clk_get_parent);
|
|
|
|
/*
|
|
* OMAP specific clock functions shared between omap1 and omap2
|
|
*/
|
|
|
|
int __initdata mpurate;
|
|
|
|
/*
|
|
* By default we use the rate set by the bootloader.
|
|
* You can override this with mpurate= cmdline option.
|
|
*/
|
|
static int __init omap_clk_setup(char *str)
|
|
{
|
|
get_option(&str, &mpurate);
|
|
|
|
if (!mpurate)
|
|
return 1;
|
|
|
|
if (mpurate < 1000)
|
|
mpurate *= 1000000;
|
|
|
|
return 1;
|
|
}
|
|
__setup("mpurate=", omap_clk_setup);
|
|
|
|
/* Used for clocks that always have same value as the parent clock */
|
|
unsigned long followparent_recalc(struct clk *clk)
|
|
{
|
|
return clk->parent->rate;
|
|
}
|
|
|
|
/*
|
|
* Used for clocks that have the same value as the parent clock,
|
|
* divided by some factor
|
|
*/
|
|
unsigned long omap_fixed_divisor_recalc(struct clk *clk)
|
|
{
|
|
WARN_ON(!clk->fixed_div);
|
|
|
|
return clk->parent->rate / clk->fixed_div;
|
|
}
|
|
|
|
void 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 */
|
|
}
|
|
|
|
/* Propagate rate to children */
|
|
void propagate_rate(struct clk *tclk)
|
|
{
|
|
struct clk *clkp;
|
|
|
|
list_for_each_entry(clkp, &tclk->children, sibling) {
|
|
if (clkp->recalc)
|
|
clkp->rate = clkp->recalc(clkp);
|
|
propagate_rate(clkp);
|
|
}
|
|
}
|
|
|
|
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->recalc)
|
|
clkp->rate = clkp->recalc(clkp);
|
|
propagate_rate(clkp);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* clk_preinit - initialize any fields in the struct clk before clk init
|
|
* @clk: struct clk * to initialize
|
|
*
|
|
* Initialize any struct clk fields needed before normal clk initialization
|
|
* can run. No return value.
|
|
*/
|
|
void clk_preinit(struct clk *clk)
|
|
{
|
|
INIT_LIST_HEAD(&clk->children);
|
|
}
|
|
|
|
int clk_register(struct clk *clk)
|
|
{
|
|
if (clk == NULL || IS_ERR(clk))
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* trap out already registered clocks
|
|
*/
|
|
if (clk->node.next || clk->node.prev)
|
|
return 0;
|
|
|
|
mutex_lock(&clocks_mutex);
|
|
if (clk->parent)
|
|
list_add(&clk->sibling, &clk->parent->children);
|
|
else
|
|
list_add(&clk->sibling, &root_clks);
|
|
|
|
list_add(&clk->node, &clocks);
|
|
if (clk->init)
|
|
clk->init(clk);
|
|
mutex_unlock(&clocks_mutex);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(clk_register);
|
|
|
|
void clk_unregister(struct clk *clk)
|
|
{
|
|
if (clk == NULL || IS_ERR(clk))
|
|
return;
|
|
|
|
mutex_lock(&clocks_mutex);
|
|
list_del(&clk->sibling);
|
|
list_del(&clk->node);
|
|
mutex_unlock(&clocks_mutex);
|
|
}
|
|
EXPORT_SYMBOL(clk_unregister);
|
|
|
|
void clk_enable_init_clocks(void)
|
|
{
|
|
struct clk *clkp;
|
|
|
|
list_for_each_entry(clkp, &clocks, node) {
|
|
if (clkp->flags & ENABLE_ON_INIT)
|
|
clk_enable(clkp);
|
|
}
|
|
}
|
|
|
|
int omap_clk_enable_autoidle_all(void)
|
|
{
|
|
struct clk *c;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&clockfw_lock, flags);
|
|
|
|
list_for_each_entry(c, &clocks, node)
|
|
if (c->ops->allow_idle)
|
|
c->ops->allow_idle(c);
|
|
|
|
spin_unlock_irqrestore(&clockfw_lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int omap_clk_disable_autoidle_all(void)
|
|
{
|
|
struct clk *c;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&clockfw_lock, flags);
|
|
|
|
list_for_each_entry(c, &clocks, node)
|
|
if (c->ops->deny_idle)
|
|
c->ops->deny_idle(c);
|
|
|
|
spin_unlock_irqrestore(&clockfw_lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Low level helpers
|
|
*/
|
|
static int clkll_enable_null(struct clk *clk)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void clkll_disable_null(struct clk *clk)
|
|
{
|
|
}
|
|
|
|
const struct clkops clkops_null = {
|
|
.enable = clkll_enable_null,
|
|
.disable = clkll_disable_null,
|
|
};
|
|
|
|
/*
|
|
* Dummy clock
|
|
*
|
|
* Used for clock aliases that are needed on some OMAPs, but not others
|
|
*/
|
|
struct clk dummy_ck = {
|
|
.name = "dummy",
|
|
.ops = &clkops_null,
|
|
};
|
|
|
|
/*
|
|
*
|
|
*/
|
|
|
|
#ifdef CONFIG_OMAP_RESET_CLOCKS
|
|
/*
|
|
* Disable any unused clocks left on by the bootloader
|
|
*/
|
|
static int __init clk_disable_unused(void)
|
|
{
|
|
struct clk *ck;
|
|
unsigned long flags;
|
|
|
|
if (!arch_clock || !arch_clock->clk_disable_unused)
|
|
return 0;
|
|
|
|
pr_info("clock: disabling unused clocks to save power\n");
|
|
|
|
spin_lock_irqsave(&clockfw_lock, flags);
|
|
list_for_each_entry(ck, &clocks, node) {
|
|
if (ck->ops == &clkops_null)
|
|
continue;
|
|
|
|
if (ck->usecount > 0 || !ck->enable_reg)
|
|
continue;
|
|
|
|
arch_clock->clk_disable_unused(ck);
|
|
}
|
|
spin_unlock_irqrestore(&clockfw_lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
late_initcall(clk_disable_unused);
|
|
late_initcall(omap_clk_enable_autoidle_all);
|
|
#endif
|
|
|
|
int __init clk_init(struct clk_functions * custom_clocks)
|
|
{
|
|
if (!custom_clocks) {
|
|
pr_err("No custom clock functions registered\n");
|
|
BUG();
|
|
}
|
|
|
|
arch_clock = custom_clocks;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS)
|
|
/*
|
|
* debugfs support to trace clock tree hierarchy and attributes
|
|
*/
|
|
|
|
#include <linux/debugfs.h>
|
|
#include <linux/seq_file.h>
|
|
|
|
static struct dentry *clk_debugfs_root;
|
|
|
|
static int clk_dbg_show_summary(struct seq_file *s, void *unused)
|
|
{
|
|
struct clk *c;
|
|
struct clk *pa;
|
|
|
|
mutex_lock(&clocks_mutex);
|
|
seq_printf(s, "%-30s %-30s %-10s %s\n",
|
|
"clock-name", "parent-name", "rate", "use-count");
|
|
|
|
list_for_each_entry(c, &clocks, node) {
|
|
pa = c->parent;
|
|
seq_printf(s, "%-30s %-30s %-10lu %d\n",
|
|
c->name, pa ? pa->name : "none", c->rate, c->usecount);
|
|
}
|
|
mutex_unlock(&clocks_mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int clk_dbg_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, clk_dbg_show_summary, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations debug_clock_fops = {
|
|
.open = clk_dbg_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int clk_debugfs_register_one(struct clk *c)
|
|
{
|
|
int err;
|
|
struct dentry *d;
|
|
struct clk *pa = c->parent;
|
|
|
|
d = debugfs_create_dir(c->name, pa ? pa->dent : clk_debugfs_root);
|
|
if (!d)
|
|
return -ENOMEM;
|
|
c->dent = d;
|
|
|
|
d = debugfs_create_u8("usecount", S_IRUGO, c->dent, (u8 *)&c->usecount);
|
|
if (!d) {
|
|
err = -ENOMEM;
|
|
goto err_out;
|
|
}
|
|
d = debugfs_create_u32("rate", S_IRUGO, c->dent, (u32 *)&c->rate);
|
|
if (!d) {
|
|
err = -ENOMEM;
|
|
goto err_out;
|
|
}
|
|
d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
|
|
if (!d) {
|
|
err = -ENOMEM;
|
|
goto err_out;
|
|
}
|
|
return 0;
|
|
|
|
err_out:
|
|
debugfs_remove_recursive(c->dent);
|
|
return err;
|
|
}
|
|
|
|
static int clk_debugfs_register(struct clk *c)
|
|
{
|
|
int err;
|
|
struct clk *pa = c->parent;
|
|
|
|
if (pa && !pa->dent) {
|
|
err = clk_debugfs_register(pa);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
if (!c->dent) {
|
|
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, &clocks, node) {
|
|
err = clk_debugfs_register(c);
|
|
if (err)
|
|
goto err_out;
|
|
}
|
|
|
|
d = debugfs_create_file("summary", S_IRUGO,
|
|
d, NULL, &debug_clock_fops);
|
|
if (!d)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
err_out:
|
|
debugfs_remove_recursive(clk_debugfs_root);
|
|
return err;
|
|
}
|
|
late_initcall(clk_debugfs_init);
|
|
|
|
#endif /* defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS) */
|