Commit dd322f04 authored by Rhyland Klein's avatar Rhyland Klein Committed by Thierry Reding
Browse files

clk: tegra: pll: Add specialized logic for Tegra210 



On Tegra210 SoC's, the logic to enable several of the plls is different
from previous generations. Therefore, add registration functions specific
to Tegra210 which will handle them appropriately.

Reviewed-by: default avatarBenson Leung <bleung@chromium.org>
Signed-off-by: default avatarRhyland Klein <rklein@nvidia.com>
Signed-off-by: default avatarThierry Reding <treding@nvidia.com>
parent 267b62a9

drivers/clk/tegra/clk-pll.c

+322 −2
Original line number Diff line number Diff line
@@ -65,6 +65,7 @@ 
#define PLLE_BASE_DIVN_WIDTH 8

#define PLLE_BASE_DIVM_SHIFT 0

#define PLLE_BASE_DIVM_WIDTH 8

#define PLLE_BASE_ENABLE BIT(31)



#define PLLE_MISC_SETUP_BASE_SHIFT 16

#define PLLE_MISC_SETUP_BASE_MASK (0xffff << PLLE_MISC_SETUP_BASE_SHIFT)
@@ -102,6 +103,7 @@ 
#define PLLE_AUX_SEQ_ENABLE	BIT(24)

#define PLLE_AUX_SEQ_START_STATE BIT(25)

#define PLLE_AUX_PLLRE_SEL	BIT(28)

#define PLLE_AUX_SS_SEQ_INCLUDE	BIT(31)



#define XUSBIO_PLL_CFG0		0x51c

#define XUSBIO_PLL_CFG0_PADPLL_RESET_SWCTL	BIT(0)
@@ -967,7 +969,8 @@ static int _calc_dynamic_ramp_rate(struct clk_hw *hw, 


#if defined(CONFIG_ARCH_TEGRA_114_SOC) || \

	defined(CONFIG_ARCH_TEGRA_124_SOC) || \

	defined(CONFIG_ARCH_TEGRA_132_SOC)

	defined(CONFIG_ARCH_TEGRA_132_SOC) || \

	defined(CONFIG_ARCH_TEGRA_210_SOC)



u16 tegra_pll_get_fixed_mdiv(struct clk_hw *hw, unsigned long input_rate)

{
@@ -1555,7 +1558,8 @@ struct clk *tegra_clk_register_plle(const char *name, const char *parent_name, 


#if defined(CONFIG_ARCH_TEGRA_114_SOC) || \

	defined(CONFIG_ARCH_TEGRA_124_SOC) || \

	defined(CONFIG_ARCH_TEGRA_132_SOC)

	defined(CONFIG_ARCH_TEGRA_132_SOC) || \

	defined(CONFIG_ARCH_TEGRA_210_SOC)

static const struct clk_ops tegra_clk_pllxc_ops = {

	.is_enabled = clk_pll_is_enabled,

	.enable = clk_pll_enable,
@@ -1925,3 +1929,319 @@ struct clk *tegra_clk_register_pllss(const char *name, const char *parent_name, 
	return clk;

}

#endif



#if defined(CONFIG_ARCH_TEGRA_210_SOC)

static int clk_plle_tegra210_enable(struct clk_hw *hw)

{

	struct tegra_clk_pll *pll = to_clk_pll(hw);

	struct tegra_clk_pll_freq_table sel;

	u32 val;

	int ret;

	unsigned long flags = 0;

	unsigned long input_rate = clk_get_rate(clk_get_parent(hw->clk));



	if (_get_table_rate(hw, &sel, pll->params->fixed_rate, input_rate))

		return -EINVAL;



	if (pll->lock)

		spin_lock_irqsave(pll->lock, flags);



	val = pll_readl_base(pll);

	val &= ~BIT(30); /* Disable lock override */

	pll_writel_base(val, pll);



	val = pll_readl(pll->params->aux_reg, pll);

	val |= PLLE_AUX_ENABLE_SWCTL;

	val &= ~PLLE_AUX_SEQ_ENABLE;

	pll_writel(val, pll->params->aux_reg, pll);

	udelay(1);



	val = pll_readl_misc(pll);

	val |= PLLE_MISC_LOCK_ENABLE;

	val |= PLLE_MISC_IDDQ_SW_CTRL;

	val &= ~PLLE_MISC_IDDQ_SW_VALUE;

	val |= PLLE_MISC_PLLE_PTS;

	val |= PLLE_MISC_VREG_BG_CTRL_MASK | PLLE_MISC_VREG_CTRL_MASK;

	pll_writel_misc(val, pll);

	udelay(5);



	val = pll_readl(PLLE_SS_CTRL, pll);

	val |= PLLE_SS_DISABLE;

	pll_writel(val, PLLE_SS_CTRL, pll);



	val = pll_readl_base(pll);

	val &= ~(divp_mask_shifted(pll) | divn_mask_shifted(pll) |

		 divm_mask_shifted(pll));

	val &= ~(PLLE_BASE_DIVCML_MASK << PLLE_BASE_DIVCML_SHIFT);

	val |= sel.m << divm_shift(pll);

	val |= sel.n << divn_shift(pll);

	val |= sel.cpcon << PLLE_BASE_DIVCML_SHIFT;

	pll_writel_base(val, pll);

	udelay(1);



	val = pll_readl_base(pll);

	val |= PLLE_BASE_ENABLE;

	pll_writel_base(val, pll);



	ret = clk_pll_wait_for_lock(pll);



	if (ret < 0)

		goto out;



	val = pll_readl(PLLE_SS_CTRL, pll);

	val &= ~(PLLE_SS_CNTL_CENTER | PLLE_SS_CNTL_INVERT);

	val &= ~PLLE_SS_COEFFICIENTS_MASK;

	val |= PLLE_SS_COEFFICIENTS_VAL;

	pll_writel(val, PLLE_SS_CTRL, pll);

	val &= ~(PLLE_SS_CNTL_SSC_BYP | PLLE_SS_CNTL_BYPASS_SS);

	pll_writel(val, PLLE_SS_CTRL, pll);

	udelay(1);

	val &= ~PLLE_SS_CNTL_INTERP_RESET;

	pll_writel(val, PLLE_SS_CTRL, pll);

	udelay(1);



	val = pll_readl_misc(pll);

	val &= ~PLLE_MISC_IDDQ_SW_CTRL;

	pll_writel_misc(val, pll);



	val = pll_readl(pll->params->aux_reg, pll);

	val |= (PLLE_AUX_USE_LOCKDET | PLLE_AUX_SS_SEQ_INCLUDE);

	val &= ~(PLLE_AUX_ENABLE_SWCTL | PLLE_AUX_SS_SWCTL);

	pll_writel(val, pll->params->aux_reg, pll);

	udelay(1);

	val |= PLLE_AUX_SEQ_ENABLE;

	pll_writel(val, pll->params->aux_reg, pll);



out:

	if (pll->lock)

		spin_unlock_irqrestore(pll->lock, flags);



	return ret;

}



static void clk_plle_tegra210_disable(struct clk_hw *hw)

{

	struct tegra_clk_pll *pll = to_clk_pll(hw);

	unsigned long flags = 0;

	u32 val;



	if (pll->lock)

		spin_lock_irqsave(pll->lock, flags);



	val = pll_readl_base(pll);

	val &= ~PLLE_BASE_ENABLE;

	pll_writel_base(val, pll);



	val = pll_readl_misc(pll);

	val |= PLLE_MISC_IDDQ_SW_CTRL | PLLE_MISC_IDDQ_SW_VALUE;

	pll_writel_misc(val, pll);

	udelay(1);



	if (pll->lock)

		spin_unlock_irqrestore(pll->lock, flags);

}



static int clk_plle_tegra210_is_enabled(struct clk_hw *hw)

{

	struct tegra_clk_pll *pll = to_clk_pll(hw);

	u32 val;



	val = pll_readl_base(pll);



	return val & PLLE_BASE_ENABLE ? 1 : 0;

}



static const struct clk_ops tegra_clk_plle_tegra210_ops = {

	.is_enabled =  clk_plle_tegra210_is_enabled,

	.enable = clk_plle_tegra210_enable,

	.disable = clk_plle_tegra210_disable,

	.recalc_rate = clk_pll_recalc_rate,

};



struct clk *tegra_clk_register_plle_tegra210(const char *name,

				const char *parent_name,

				void __iomem *clk_base, unsigned long flags,

				struct tegra_clk_pll_params *pll_params,

				spinlock_t *lock)

{

	struct tegra_clk_pll *pll;

	struct clk *clk;

	u32 val, val_aux;



	pll = _tegra_init_pll(clk_base, NULL, pll_params, lock);

	if (IS_ERR(pll))

		return ERR_CAST(pll);



	/* ensure parent is set to pll_re_vco */



	val = pll_readl_base(pll);

	val_aux = pll_readl(pll_params->aux_reg, pll);



	if (val & PLLE_BASE_ENABLE) {

		if ((val_aux & PLLE_AUX_PLLRE_SEL) ||

			(val_aux & PLLE_AUX_PLLP_SEL))

			WARN(1, "pll_e enabled with unsupported parent %s\n",

			  (val_aux & PLLE_AUX_PLLP_SEL) ? "pllp_out0" :

					"pll_re_vco");

	} else {

		val_aux &= ~(PLLE_AUX_PLLRE_SEL | PLLE_AUX_PLLP_SEL);

		pll_writel(val_aux, pll_params->aux_reg, pll);

	}



	clk = _tegra_clk_register_pll(pll, name, parent_name, flags,

				      &tegra_clk_plle_tegra210_ops);

	if (IS_ERR(clk))

		kfree(pll);



	return clk;

}



struct clk *tegra_clk_register_pllc_tegra210(const char *name,

			const char *parent_name, void __iomem *clk_base,

			void __iomem *pmc, unsigned long flags,

			struct tegra_clk_pll_params *pll_params,

			spinlock_t *lock)

{

	struct clk *parent, *clk;

	const struct pdiv_map *p_tohw = pll_params->pdiv_tohw;

	struct tegra_clk_pll *pll;

	unsigned long parent_rate;



	if (!p_tohw)

		return ERR_PTR(-EINVAL);



	parent = __clk_lookup(parent_name);

	if (!parent) {

		WARN(1, "parent clk %s of %s must be registered first\n",

			name, parent_name);

		return ERR_PTR(-EINVAL);

	}



	parent_rate = clk_get_rate(parent);



	pll_params->vco_min = _clip_vco_min(pll_params->vco_min, parent_rate);



	pll_params->flags |= TEGRA_PLL_BYPASS;

	pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

	if (IS_ERR(pll))

		return ERR_CAST(pll);



	clk = _tegra_clk_register_pll(pll, name, parent_name, flags,

				      &tegra_clk_pll_ops);

	if (IS_ERR(clk))

		kfree(pll);



	return clk;

}



struct clk *tegra_clk_register_pllxc_tegra210(const char *name,

			const char *parent_name, void __iomem *clk_base,

			void __iomem *pmc, unsigned long flags,

			struct tegra_clk_pll_params *pll_params,

			spinlock_t *lock)

{

	struct tegra_clk_pll *pll;

	struct clk *clk, *parent;

	unsigned long parent_rate;



	parent = __clk_lookup(parent_name);

	if (!parent) {

		WARN(1, "parent clk %s of %s must be registered first\n",

			name, parent_name);

		return ERR_PTR(-EINVAL);

	}



	if (!pll_params->pdiv_tohw)

		return ERR_PTR(-EINVAL);



	parent_rate = clk_get_rate(parent);



	pll_params->vco_min = _clip_vco_min(pll_params->vco_min, parent_rate);



	pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

	if (IS_ERR(pll))

		return ERR_CAST(pll);



	clk = _tegra_clk_register_pll(pll, name, parent_name, flags,

				      &tegra_clk_pll_ops);

	if (IS_ERR(clk))

		kfree(pll);



	return clk;

}



struct clk *tegra_clk_register_pllss_tegra210(const char *name,

				const char *parent_name, void __iomem *clk_base,

				unsigned long flags,

				struct tegra_clk_pll_params *pll_params,

				spinlock_t *lock)

{

	struct tegra_clk_pll *pll;

	struct clk *clk, *parent;

	struct tegra_clk_pll_freq_table cfg;

	unsigned long parent_rate;

	u32 val;

	int i;



	if (!pll_params->div_nmp)

		return ERR_PTR(-EINVAL);



	parent = __clk_lookup(parent_name);

	if (!parent) {

		WARN(1, "parent clk %s of %s must be registered first\n",

			name, parent_name);

		return ERR_PTR(-EINVAL);

	}



	pll = _tegra_init_pll(clk_base, NULL, pll_params, lock);

	if (IS_ERR(pll))

		return ERR_CAST(pll);



	val = pll_readl_base(pll);

	val &= ~PLLSS_REF_SRC_SEL_MASK;

	pll_writel_base(val, pll);



	parent_rate = clk_get_rate(parent);



	pll_params->vco_min = _clip_vco_min(pll_params->vco_min, parent_rate);



	/* initialize PLL to minimum rate */



	cfg.m = _pll_fixed_mdiv(pll_params, parent_rate);

	cfg.n = cfg.m * pll_params->vco_min / parent_rate;



	for (i = 0; pll_params->pdiv_tohw[i].pdiv; i++)

		;

	if (!i) {

		kfree(pll);

		return ERR_PTR(-EINVAL);

	}



	cfg.p = pll_params->pdiv_tohw[i-1].hw_val;



	_update_pll_mnp(pll, &cfg);



	pll_writel_misc(PLLSS_MISC_DEFAULT, pll);



	val = pll_readl_base(pll);

	if (val & PLL_BASE_ENABLE) {

		if (val & BIT(pll_params->iddq_bit_idx)) {

			WARN(1, "%s is on but IDDQ set\n", name);

			kfree(pll);

			return ERR_PTR(-EINVAL);

		}

	} else

		val |= BIT(pll_params->iddq_bit_idx);



	val &= ~PLLSS_LOCK_OVERRIDE;

	pll_writel_base(val, pll);



	clk = _tegra_clk_register_pll(pll, name, parent_name, flags,

					&tegra_clk_pll_ops);



	if (IS_ERR(clk))

		kfree(pll);



	return clk;

}

#endif

drivers/clk/tegra/clk.h

+24 −0
Original line number Diff line number Diff line
@@ -334,6 +334,12 @@ struct clk *tegra_clk_register_pllxc(const char *name, const char *parent_name, 
			    struct tegra_clk_pll_params *pll_params,

			    spinlock_t *lock);



struct clk *tegra_clk_register_pllxc_tegra210(const char *name,

			const char *parent_name, void __iomem *clk_base,

			void __iomem *pmc, unsigned long flags,

			struct tegra_clk_pll_params *pll_params,

			spinlock_t *lock);



struct clk *tegra_clk_register_pllm(const char *name, const char *parent_name,

			   void __iomem *clk_base, void __iomem *pmc,

			   unsigned long flags,
@@ -358,6 +364,24 @@ struct clk *tegra_clk_register_plle_tegra114(const char *name, 
				struct tegra_clk_pll_params *pll_params,

				spinlock_t *lock);



struct clk *tegra_clk_register_plle_tegra210(const char *name,

				const char *parent_name,

				void __iomem *clk_base, unsigned long flags,

				struct tegra_clk_pll_params *pll_params,

				spinlock_t *lock);



struct clk *tegra_clk_register_pllc_tegra210(const char *name,

				const char *parent_name, void __iomem *clk_base,

				void __iomem *pmc, unsigned long flags,

				struct tegra_clk_pll_params *pll_params,

				spinlock_t *lock);



struct clk *tegra_clk_register_pllss_tegra210(const char *name,

				const char *parent_name, void __iomem *clk_base,

				unsigned long flags,

				struct tegra_clk_pll_params *pll_params,

				spinlock_t *lock);



struct clk *tegra_clk_register_pllss(const char *name, const char *parent_name,

			   void __iomem *clk_base, unsigned long flags,

			   struct tegra_clk_pll_params *pll_params,