blob: 3f19b2a5650c577cb871189843a04c2990149203 [file] [log] [blame]
/* Copyright (c) 2012, Code Aurora Forum. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#define pr_fmt(fmt) "%s: " fmt, __func__
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/ctype.h>
#include <linux/bitops.h>
#include <linux/io.h>
#include <linux/spinlock.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <mach/clk.h>
#include "clock.h"
#include "clock-local2.h"
/*
* When enabling/disabling a clock, check the halt bit up to this number
* number of times (with a 1 us delay in between) before continuing.
*/
#define HALT_CHECK_MAX_LOOPS 200
/* For clock without halt checking, wait this long after enables/disables. */
#define HALT_CHECK_DELAY_US 10
/*
* When updating an RCG configuration, check the update bit up to this number
* number of times (with a 1 us delay in between) before continuing.
*/
#define UPDATE_CHECK_MAX_LOOPS 200
DEFINE_SPINLOCK(local_clock_reg_lock);
struct clk_freq_tbl rcg_dummy_freq = F_END;
#define CMD_RCGR_REG(x) (*(x)->base + (x)->cmd_rcgr_reg)
#define CFG_RCGR_REG(x) (*(x)->base + (x)->cmd_rcgr_reg + 0x4)
#define M_REG(x) (*(x)->base + (x)->cmd_rcgr_reg + 0x8)
#define N_REG(x) (*(x)->base + (x)->cmd_rcgr_reg + 0xC)
#define D_REG(x) (*(x)->base + (x)->cmd_rcgr_reg + 0x10)
#define CBCR_REG(x) (*(x)->base + (x)->cbcr_reg)
#define BCR_REG(x) (*(x)->base + (x)->bcr_reg)
#define VOTE_REG(x) (*(x)->base + (x)->vote_reg)
/*
* Important clock bit positions and masks
*/
#define CMD_RCGR_ROOT_ENABLE_BIT BIT(1)
#define CBCR_BRANCH_ENABLE_BIT BIT(0)
#define CBCR_BRANCH_OFF_BIT BIT(31)
#define CMD_RCGR_CONFIG_UPDATE_BIT BIT(0)
#define CMD_RCGR_ROOT_STATUS_BIT BIT(31)
#define BCR_BLK_ARES_BIT BIT(0)
#define CBCR_HW_CTL_BIT BIT(1)
#define CFG_RCGR_DIV_MASK BM(4, 0)
#define CFG_RCGR_SRC_SEL_MASK BM(10, 8)
#define MND_MODE_MASK BM(13, 12)
#define MND_DUAL_EDGE_MODE_BVAL BVAL(13, 12, 0x2)
#define CMD_RCGR_CONFIG_DIRTY_MASK BM(7, 4)
#define CBCR_BRANCH_CDIV_MASK BM(24, 16)
#define CBCR_BRANCH_CDIV_MASKED(val) BVAL(24, 16, (val));
enum branch_state {
BRANCH_ON,
BRANCH_OFF,
};
/*
* RCG functions
*/
/*
* Update an RCG with a new configuration. This may include a new M, N, or D
* value, source selection or pre-divider value.
*
*/
static void rcg_update_config(struct rcg_clk *rcg)
{
u32 cmd_rcgr_regval, count;
cmd_rcgr_regval = readl_relaxed(CMD_RCGR_REG(rcg));
cmd_rcgr_regval |= CMD_RCGR_CONFIG_UPDATE_BIT;
writel_relaxed(cmd_rcgr_regval, CMD_RCGR_REG(rcg));
/* Wait for update to take effect */
for (count = UPDATE_CHECK_MAX_LOOPS; count > 0; count--) {
if (!(readl_relaxed(CMD_RCGR_REG(rcg)) &
CMD_RCGR_CONFIG_UPDATE_BIT))
return;
udelay(1);
}
WARN(count == 0, "%s: rcg didn't update its configuration.",
rcg->c.dbg_name);
}
/* RCG set rate function for clocks with Half Integer Dividers. */
void set_rate_hid(struct rcg_clk *rcg, struct clk_freq_tbl *nf)
{
u32 cfg_regval;
unsigned long flags;
spin_lock_irqsave(&local_clock_reg_lock, flags);
cfg_regval = readl_relaxed(CFG_RCGR_REG(rcg));
cfg_regval &= ~(CFG_RCGR_DIV_MASK | CFG_RCGR_SRC_SEL_MASK);
cfg_regval |= nf->div_src_val;
writel_relaxed(cfg_regval, CFG_RCGR_REG(rcg));
rcg_update_config(rcg);
spin_unlock_irqrestore(&local_clock_reg_lock, flags);
}
/* RCG set rate function for clocks with MND & Half Integer Dividers. */
void set_rate_mnd(struct rcg_clk *rcg, struct clk_freq_tbl *nf)
{
u32 cfg_regval;
unsigned long flags;
spin_lock_irqsave(&local_clock_reg_lock, flags);
cfg_regval = readl_relaxed(CFG_RCGR_REG(rcg));
writel_relaxed(nf->m_val, M_REG(rcg));
writel_relaxed(nf->n_val, N_REG(rcg));
writel_relaxed(nf->d_val, D_REG(rcg));
cfg_regval = readl_relaxed(CFG_RCGR_REG(rcg));
cfg_regval &= ~(CFG_RCGR_DIV_MASK | CFG_RCGR_SRC_SEL_MASK);
cfg_regval |= nf->div_src_val;
/* Activate or disable the M/N:D divider as necessary */
cfg_regval &= ~MND_MODE_MASK;
if (nf->n_val != 0)
cfg_regval |= MND_DUAL_EDGE_MODE_BVAL;
writel_relaxed(cfg_regval, CFG_RCGR_REG(rcg));
rcg_update_config(rcg);
spin_unlock_irqrestore(&local_clock_reg_lock, flags);
}
static int rcg_clk_prepare(struct clk *c)
{
struct rcg_clk *rcg = to_rcg_clk(c);
WARN(rcg->current_freq == &rcg_dummy_freq,
"Attempting to prepare %s before setting its rate. "
"Set the rate first!\n", rcg->c.dbg_name);
return 0;
}
static int rcg_clk_set_rate(struct clk *c, unsigned long rate)
{
struct clk_freq_tbl *cf, *nf;
struct rcg_clk *rcg = to_rcg_clk(c);
int rc;
unsigned long flags;
for (nf = rcg->freq_tbl; nf->freq_hz != FREQ_END
&& nf->freq_hz != rate; nf++)
;
if (nf->freq_hz == FREQ_END)
return -EINVAL;
cf = rcg->current_freq;
/* Enable source clock dependency for the new freq. */
if (c->prepare_count) {
rc = clk_prepare(nf->src_clk);
if (rc)
return rc;
}
spin_lock_irqsave(&c->lock, flags);
if (c->count) {
rc = clk_enable(nf->src_clk);
if (rc) {
spin_unlock_irqrestore(&c->lock, flags);
clk_unprepare(nf->src_clk);
return rc;
}
}
BUG_ON(!rcg->set_rate);
/* Perform clock-specific frequency switch operations. */
rcg->set_rate(rcg, nf);
/* Release source requirements of the old freq. */
if (c->count)
clk_disable(cf->src_clk);
spin_unlock_irqrestore(&c->lock, flags);
if (c->prepare_count)
clk_unprepare(cf->src_clk);
rcg->current_freq = nf;
return 0;
}
/* Return a supported rate that's at least the specified rate. */
static long rcg_clk_round_rate(struct clk *c, unsigned long rate)
{
struct rcg_clk *rcg = to_rcg_clk(c);
struct clk_freq_tbl *f;
for (f = rcg->freq_tbl; f->freq_hz != FREQ_END; f++)
if (f->freq_hz >= rate)
return f->freq_hz;
return -EPERM;
}
/* Return the nth supported frequency for a given clock. */
static int rcg_clk_list_rate(struct clk *c, unsigned n)
{
struct rcg_clk *rcg = to_rcg_clk(c);
if (!rcg->freq_tbl || rcg->freq_tbl->freq_hz == FREQ_END)
return -ENXIO;
return (rcg->freq_tbl + n)->freq_hz;
}
static struct clk *rcg_clk_get_parent(struct clk *c)
{
return to_rcg_clk(c)->current_freq->src_clk;
}
static enum handoff _rcg_clk_handoff(struct rcg_clk *rcg, int has_mnd)
{
u32 n_regval = 0, m_regval = 0, d_regval = 0;
u32 cfg_regval;
struct clk_freq_tbl *freq;
u32 cmd_rcgr_regval;
/* Is the root enabled? */
cmd_rcgr_regval = readl_relaxed(CMD_RCGR_REG(rcg));
if ((cmd_rcgr_regval & CMD_RCGR_ROOT_STATUS_BIT))
return HANDOFF_DISABLED_CLK;
/* Is there a pending configuration? */
if (cmd_rcgr_regval & CMD_RCGR_CONFIG_DIRTY_MASK)
return HANDOFF_UNKNOWN_RATE;
/* Get values of m, n, d, div and src_sel registers. */
if (has_mnd) {
m_regval = readl_relaxed(M_REG(rcg));
n_regval = readl_relaxed(N_REG(rcg));
d_regval = readl_relaxed(D_REG(rcg));
/*
* The n and d values stored in the frequency tables are sign
* extended to 32 bits. The n and d values in the registers are
* sign extended to 8 or 16 bits. Sign extend the values read
* from the registers so that they can be compared to the
* values in the frequency tables.
*/
n_regval |= (n_regval >> 8) ? BM(31, 16) : BM(31, 8);
d_regval |= (d_regval >> 8) ? BM(31, 16) : BM(31, 8);
}
cfg_regval = readl_relaxed(CFG_RCGR_REG(rcg));
cfg_regval &= CFG_RCGR_SRC_SEL_MASK | CFG_RCGR_DIV_MASK
| MND_MODE_MASK;
/* If mnd counter is present, check if it's in use. */
has_mnd = (has_mnd) &&
((cfg_regval & MND_MODE_MASK) == MND_DUAL_EDGE_MODE_BVAL);
/*
* Clear out the mn counter mode bits since we now want to compare only
* the source mux selection and pre-divider values in the registers.
*/
cfg_regval &= ~MND_MODE_MASK;
/* Figure out what rate the rcg is running at */
for (freq = rcg->freq_tbl; freq->freq_hz != FREQ_END; freq++) {
if (freq->div_src_val != cfg_regval)
continue;
if (has_mnd) {
if (freq->m_val != m_regval)
continue;
if (freq->n_val != n_regval)
continue;
if (freq->d_val != d_regval)
continue;
}
break;
}
/* No known frequency found */
if (freq->freq_hz == FREQ_END)
return HANDOFF_UNKNOWN_RATE;
rcg->current_freq = freq;
rcg->c.rate = freq->freq_hz;
return HANDOFF_ENABLED_CLK;
}
static enum handoff rcg_mnd_clk_handoff(struct clk *c)
{
return _rcg_clk_handoff(to_rcg_clk(c), 1);
}
static enum handoff rcg_clk_handoff(struct clk *c)
{
return _rcg_clk_handoff(to_rcg_clk(c), 0);
}
#define BRANCH_CHECK_MASK BM(31, 28)
#define BRANCH_ON_VAL BVAL(31, 28, 0x0)
#define BRANCH_OFF_VAL BVAL(31, 28, 0x8)
#define BRANCH_NOC_FSM_ON_VAL BVAL(31, 28, 0x2)
/*
* Branch clock functions
*/
static void branch_clk_halt_check(u32 halt_check, const char *clk_name,
void __iomem *cbcr_reg,
enum branch_state br_status)
{
char *status_str = (br_status == BRANCH_ON) ? "off" : "on";
/*
* Use a memory barrier since some halt status registers are
* not within the same 1K segment as the branch/root enable
* registers. It's also needed in the udelay() case to ensure
* the delay starts after the branch disable.
*/
mb();
if (halt_check == DELAY || halt_check == HALT_VOTED) {
udelay(HALT_CHECK_DELAY_US);
} else if (halt_check == HALT) {
int count;
u32 val;
for (count = HALT_CHECK_MAX_LOOPS; count > 0; count--) {
val = readl_relaxed(cbcr_reg);
val &= BRANCH_CHECK_MASK;
switch (br_status) {
case BRANCH_ON:
if (val == BRANCH_ON_VAL
|| val == BRANCH_NOC_FSM_ON_VAL)
return;
break;
case BRANCH_OFF:
if (val == BRANCH_OFF_VAL)
return;
break;
};
udelay(1);
}
WARN(count == 0, "%s status stuck %s", clk_name, status_str);
}
}
static int branch_clk_enable(struct clk *c)
{
unsigned long flags;
u32 cbcr_val;
struct branch_clk *branch = to_branch_clk(c);
spin_lock_irqsave(&local_clock_reg_lock, flags);
cbcr_val = readl_relaxed(CBCR_REG(branch));
cbcr_val |= CBCR_BRANCH_ENABLE_BIT;
writel_relaxed(cbcr_val, CBCR_REG(branch));
spin_unlock_irqrestore(&local_clock_reg_lock, flags);
/* Wait for clock to enable before continuing. */
branch_clk_halt_check(branch->halt_check, branch->c.dbg_name,
CBCR_REG(branch), BRANCH_ON);
return 0;
}
static void branch_clk_disable(struct clk *c)
{
unsigned long flags;
struct branch_clk *branch = to_branch_clk(c);
u32 reg_val;
spin_lock_irqsave(&local_clock_reg_lock, flags);
reg_val = readl_relaxed(CBCR_REG(branch));
reg_val &= ~CBCR_BRANCH_ENABLE_BIT;
writel_relaxed(reg_val, CBCR_REG(branch));
spin_unlock_irqrestore(&local_clock_reg_lock, flags);
/* Wait for clock to disable before continuing. */
branch_clk_halt_check(branch->halt_check, branch->c.dbg_name,
CBCR_REG(branch), BRANCH_OFF);
}
static int branch_cdiv_set_rate(struct branch_clk *branch, unsigned long rate)
{
unsigned long flags;
u32 regval;
if (rate > branch->max_div)
return -EINVAL;
spin_lock_irqsave(&local_clock_reg_lock, flags);
regval = readl_relaxed(CBCR_REG(branch));
regval &= ~CBCR_BRANCH_CDIV_MASK;
regval |= CBCR_BRANCH_CDIV_MASKED(rate);
writel_relaxed(regval, CBCR_REG(branch));
spin_unlock_irqrestore(&local_clock_reg_lock, flags);
return 0;
}
static int branch_clk_set_rate(struct clk *c, unsigned long rate)
{
struct branch_clk *branch = to_branch_clk(c);
if (branch->max_div)
return branch_cdiv_set_rate(branch, rate);
if (!branch->has_sibling)
return clk_set_rate(branch->parent, rate);
return -EPERM;
}
static long branch_clk_round_rate(struct clk *c, unsigned long rate)
{
struct branch_clk *branch = to_branch_clk(c);
if (branch->max_div)
return rate <= (branch->max_div) ? rate : -EPERM;
if (!branch->has_sibling)
return clk_round_rate(branch->parent, rate);
return -EPERM;
}
static unsigned long branch_clk_get_rate(struct clk *c)
{
struct branch_clk *branch = to_branch_clk(c);
if (branch->max_div)
return branch->c.rate;
if (!branch->has_sibling)
return clk_get_rate(branch->parent);
return 0;
}
static struct clk *branch_clk_get_parent(struct clk *c)
{
return to_branch_clk(c)->parent;
}
static int branch_clk_list_rate(struct clk *c, unsigned n)
{
struct branch_clk *branch = to_branch_clk(c);
if (branch->has_sibling == 1)
return -ENXIO;
if (branch->parent)
return rcg_clk_list_rate(branch->parent, n);
else
return 0;
}
static enum handoff branch_clk_handoff(struct clk *c)
{
struct branch_clk *branch = to_branch_clk(c);
u32 cbcr_regval;
cbcr_regval = readl_relaxed(CBCR_REG(branch));
if ((cbcr_regval & CBCR_BRANCH_OFF_BIT))
return HANDOFF_DISABLED_CLK;
if (branch->parent) {
if (branch->parent->ops->handoff)
return branch->parent->ops->handoff(branch->parent);
}
return HANDOFF_ENABLED_CLK;
}
static int __branch_clk_reset(void __iomem *bcr_reg,
enum clk_reset_action action)
{
int ret = 0;
unsigned long flags;
u32 reg_val;
spin_lock_irqsave(&local_clock_reg_lock, flags);
reg_val = readl_relaxed(bcr_reg);
switch (action) {
case CLK_RESET_ASSERT:
reg_val |= BCR_BLK_ARES_BIT;
break;
case CLK_RESET_DEASSERT:
reg_val &= ~BCR_BLK_ARES_BIT;
break;
default:
ret = -EINVAL;
}
writel_relaxed(reg_val, bcr_reg);
spin_unlock_irqrestore(&local_clock_reg_lock, flags);
/* Make sure write is issued before returning. */
mb();
return ret;
}
static int branch_clk_reset(struct clk *c, enum clk_reset_action action)
{
struct branch_clk *branch = to_branch_clk(c);
if (!branch->bcr_reg) {
WARN("clk_reset called on an unsupported clock (%s)\n",
c->dbg_name);
return -EPERM;
}
return __branch_clk_reset(BCR_REG(branch), action);
}
/*
* Voteable clock functions
*/
static int local_vote_clk_reset(struct clk *c, enum clk_reset_action action)
{
struct local_vote_clk *vclk = to_local_vote_clk(c);
if (!vclk->bcr_reg) {
WARN("clk_reset called on an unsupported clock (%s)\n",
c->dbg_name);
return -EPERM;
}
return __branch_clk_reset(BCR_REG(vclk), action);
}
static int local_vote_clk_enable(struct clk *c)
{
unsigned long flags;
u32 ena;
struct local_vote_clk *vclk = to_local_vote_clk(c);
spin_lock_irqsave(&local_clock_reg_lock, flags);
ena = readl_relaxed(VOTE_REG(vclk));
ena |= vclk->en_mask;
writel_relaxed(ena, VOTE_REG(vclk));
spin_unlock_irqrestore(&local_clock_reg_lock, flags);
branch_clk_halt_check(vclk->halt_check, c->dbg_name, CBCR_REG(vclk),
BRANCH_ON);
return 0;
}
static void local_vote_clk_disable(struct clk *c)
{
unsigned long flags;
u32 ena;
struct local_vote_clk *vclk = to_local_vote_clk(c);
spin_lock_irqsave(&local_clock_reg_lock, flags);
ena = readl_relaxed(VOTE_REG(vclk));
ena &= ~vclk->en_mask;
writel_relaxed(ena, VOTE_REG(vclk));
spin_unlock_irqrestore(&local_clock_reg_lock, flags);
}
static enum handoff local_vote_clk_handoff(struct clk *c)
{
struct local_vote_clk *vclk = to_local_vote_clk(c);
u32 vote_regval;
/* Is the branch voted on by apps? */
vote_regval = readl_relaxed(VOTE_REG(vclk));
if (!(vote_regval & vclk->en_mask))
return HANDOFF_DISABLED_CLK;
return HANDOFF_ENABLED_CLK;
}
struct clk_ops clk_ops_empty;
struct clk_ops clk_ops_rcg = {
.enable = rcg_clk_prepare,
.set_rate = rcg_clk_set_rate,
.list_rate = rcg_clk_list_rate,
.round_rate = rcg_clk_round_rate,
.get_parent = rcg_clk_get_parent,
.handoff = rcg_clk_handoff,
};
struct clk_ops clk_ops_rcg_mnd = {
.enable = rcg_clk_prepare,
.set_rate = rcg_clk_set_rate,
.list_rate = rcg_clk_list_rate,
.round_rate = rcg_clk_round_rate,
.get_parent = rcg_clk_get_parent,
.handoff = rcg_mnd_clk_handoff,
};
struct clk_ops clk_ops_branch = {
.enable = branch_clk_enable,
.disable = branch_clk_disable,
.set_rate = branch_clk_set_rate,
.get_rate = branch_clk_get_rate,
.list_rate = branch_clk_list_rate,
.round_rate = branch_clk_round_rate,
.reset = branch_clk_reset,
.get_parent = branch_clk_get_parent,
.handoff = branch_clk_handoff,
};
struct clk_ops clk_ops_vote = {
.enable = local_vote_clk_enable,
.disable = local_vote_clk_disable,
.reset = local_vote_clk_reset,
.handoff = local_vote_clk_handoff,
};