| /* 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, |
| }; |