1 /* 2 * Copyright (c) 2012, 2013, NVIDIA CORPORATION. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms and conditions of the GNU General Public License, 6 * version 2, as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope it will be useful, but WITHOUT 9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 11 * more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. 15 */ 16 17 #include <linux/slab.h> 18 #include <linux/io.h> 19 #include <linux/delay.h> 20 #include <linux/err.h> 21 #include <linux/clk.h> 22 #include <linux/clk-provider.h> 23 24 #include "clk.h" 25 26 #define PLL_BASE_BYPASS BIT(31) 27 #define PLL_BASE_ENABLE BIT(30) 28 #define PLL_BASE_REF_ENABLE BIT(29) 29 #define PLL_BASE_OVERRIDE BIT(28) 30 31 #define PLL_BASE_DIVP_SHIFT 20 32 #define PLL_BASE_DIVP_WIDTH 3 33 #define PLL_BASE_DIVN_SHIFT 8 34 #define PLL_BASE_DIVN_WIDTH 10 35 #define PLL_BASE_DIVM_SHIFT 0 36 #define PLL_BASE_DIVM_WIDTH 5 37 #define PLLU_POST_DIVP_MASK 0x1 38 39 #define PLL_MISC_DCCON_SHIFT 20 40 #define PLL_MISC_CPCON_SHIFT 8 41 #define PLL_MISC_CPCON_WIDTH 4 42 #define PLL_MISC_CPCON_MASK ((1 << PLL_MISC_CPCON_WIDTH) - 1) 43 #define PLL_MISC_LFCON_SHIFT 4 44 #define PLL_MISC_LFCON_WIDTH 4 45 #define PLL_MISC_LFCON_MASK ((1 << PLL_MISC_LFCON_WIDTH) - 1) 46 #define PLL_MISC_VCOCON_SHIFT 0 47 #define PLL_MISC_VCOCON_WIDTH 4 48 #define PLL_MISC_VCOCON_MASK ((1 << PLL_MISC_VCOCON_WIDTH) - 1) 49 50 #define OUT_OF_TABLE_CPCON 8 51 52 #define PMC_PLLP_WB0_OVERRIDE 0xf8 53 #define PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE BIT(12) 54 #define PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE BIT(11) 55 56 #define PLL_POST_LOCK_DELAY 50 57 58 #define PLLDU_LFCON_SET_DIVN 600 59 60 #define PLLE_BASE_DIVCML_SHIFT 24 61 #define PLLE_BASE_DIVCML_MASK 0xf 62 #define PLLE_BASE_DIVP_SHIFT 16 63 #define PLLE_BASE_DIVP_WIDTH 6 64 #define PLLE_BASE_DIVN_SHIFT 8 65 #define PLLE_BASE_DIVN_WIDTH 8 66 #define PLLE_BASE_DIVM_SHIFT 0 67 #define PLLE_BASE_DIVM_WIDTH 8 68 69 #define PLLE_MISC_SETUP_BASE_SHIFT 16 70 #define PLLE_MISC_SETUP_BASE_MASK (0xffff << PLLE_MISC_SETUP_BASE_SHIFT) 71 #define PLLE_MISC_LOCK_ENABLE BIT(9) 72 #define PLLE_MISC_READY BIT(15) 73 #define PLLE_MISC_SETUP_EX_SHIFT 2 74 #define PLLE_MISC_SETUP_EX_MASK (3 << PLLE_MISC_SETUP_EX_SHIFT) 75 #define PLLE_MISC_SETUP_MASK (PLLE_MISC_SETUP_BASE_MASK | \ 76 PLLE_MISC_SETUP_EX_MASK) 77 #define PLLE_MISC_SETUP_VALUE (7 << PLLE_MISC_SETUP_BASE_SHIFT) 78 79 #define PLLE_SS_CTRL 0x68 80 #define PLLE_SS_CNTL_BYPASS_SS BIT(10) 81 #define PLLE_SS_CNTL_INTERP_RESET BIT(11) 82 #define PLLE_SS_CNTL_SSC_BYP BIT(12) 83 #define PLLE_SS_CNTL_CENTER BIT(14) 84 #define PLLE_SS_CNTL_INVERT BIT(15) 85 #define PLLE_SS_DISABLE (PLLE_SS_CNTL_BYPASS_SS | PLLE_SS_CNTL_INTERP_RESET |\ 86 PLLE_SS_CNTL_SSC_BYP) 87 #define PLLE_SS_MAX_MASK 0x1ff 88 #define PLLE_SS_MAX_VAL 0x25 89 #define PLLE_SS_INC_MASK (0xff << 16) 90 #define PLLE_SS_INC_VAL (0x1 << 16) 91 #define PLLE_SS_INCINTRV_MASK (0x3f << 24) 92 #define PLLE_SS_INCINTRV_VAL (0x20 << 24) 93 #define PLLE_SS_COEFFICIENTS_MASK \ 94 (PLLE_SS_MAX_MASK | PLLE_SS_INC_MASK | PLLE_SS_INCINTRV_MASK) 95 #define PLLE_SS_COEFFICIENTS_VAL \ 96 (PLLE_SS_MAX_VAL | PLLE_SS_INC_VAL | PLLE_SS_INCINTRV_VAL) 97 98 #define PLLE_AUX_PLLP_SEL BIT(2) 99 #define PLLE_AUX_USE_LOCKDET BIT(3) 100 #define PLLE_AUX_ENABLE_SWCTL BIT(4) 101 #define PLLE_AUX_SS_SWCTL BIT(6) 102 #define PLLE_AUX_SEQ_ENABLE BIT(24) 103 #define PLLE_AUX_SEQ_START_STATE BIT(25) 104 #define PLLE_AUX_PLLRE_SEL BIT(28) 105 106 #define XUSBIO_PLL_CFG0 0x51c 107 #define XUSBIO_PLL_CFG0_PADPLL_RESET_SWCTL BIT(0) 108 #define XUSBIO_PLL_CFG0_CLK_ENABLE_SWCTL BIT(2) 109 #define XUSBIO_PLL_CFG0_PADPLL_USE_LOCKDET BIT(6) 110 #define XUSBIO_PLL_CFG0_SEQ_ENABLE BIT(24) 111 #define XUSBIO_PLL_CFG0_SEQ_START_STATE BIT(25) 112 113 #define SATA_PLL_CFG0 0x490 114 #define SATA_PLL_CFG0_PADPLL_RESET_SWCTL BIT(0) 115 #define SATA_PLL_CFG0_PADPLL_USE_LOCKDET BIT(2) 116 #define SATA_PLL_CFG0_SEQ_ENABLE BIT(24) 117 #define SATA_PLL_CFG0_SEQ_START_STATE BIT(25) 118 119 #define PLLE_MISC_PLLE_PTS BIT(8) 120 #define PLLE_MISC_IDDQ_SW_VALUE BIT(13) 121 #define PLLE_MISC_IDDQ_SW_CTRL BIT(14) 122 #define PLLE_MISC_VREG_BG_CTRL_SHIFT 4 123 #define PLLE_MISC_VREG_BG_CTRL_MASK (3 << PLLE_MISC_VREG_BG_CTRL_SHIFT) 124 #define PLLE_MISC_VREG_CTRL_SHIFT 2 125 #define PLLE_MISC_VREG_CTRL_MASK (2 << PLLE_MISC_VREG_CTRL_SHIFT) 126 127 #define PLLCX_MISC_STROBE BIT(31) 128 #define PLLCX_MISC_RESET BIT(30) 129 #define PLLCX_MISC_SDM_DIV_SHIFT 28 130 #define PLLCX_MISC_SDM_DIV_MASK (0x3 << PLLCX_MISC_SDM_DIV_SHIFT) 131 #define PLLCX_MISC_FILT_DIV_SHIFT 26 132 #define PLLCX_MISC_FILT_DIV_MASK (0x3 << PLLCX_MISC_FILT_DIV_SHIFT) 133 #define PLLCX_MISC_ALPHA_SHIFT 18 134 #define PLLCX_MISC_DIV_LOW_RANGE \ 135 ((0x1 << PLLCX_MISC_SDM_DIV_SHIFT) | \ 136 (0x1 << PLLCX_MISC_FILT_DIV_SHIFT)) 137 #define PLLCX_MISC_DIV_HIGH_RANGE \ 138 ((0x2 << PLLCX_MISC_SDM_DIV_SHIFT) | \ 139 (0x2 << PLLCX_MISC_FILT_DIV_SHIFT)) 140 #define PLLCX_MISC_COEF_LOW_RANGE \ 141 ((0x14 << PLLCX_MISC_KA_SHIFT) | (0x38 << PLLCX_MISC_KB_SHIFT)) 142 #define PLLCX_MISC_KA_SHIFT 2 143 #define PLLCX_MISC_KB_SHIFT 9 144 #define PLLCX_MISC_DEFAULT (PLLCX_MISC_COEF_LOW_RANGE | \ 145 (0x19 << PLLCX_MISC_ALPHA_SHIFT) | \ 146 PLLCX_MISC_DIV_LOW_RANGE | \ 147 PLLCX_MISC_RESET) 148 #define PLLCX_MISC1_DEFAULT 0x000d2308 149 #define PLLCX_MISC2_DEFAULT 0x30211200 150 #define PLLCX_MISC3_DEFAULT 0x200 151 152 #define PMC_SATA_PWRGT 0x1ac 153 #define PMC_SATA_PWRGT_PLLE_IDDQ_VALUE BIT(5) 154 #define PMC_SATA_PWRGT_PLLE_IDDQ_SWCTL BIT(4) 155 156 #define PLLSS_MISC_KCP 0 157 #define PLLSS_MISC_KVCO 0 158 #define PLLSS_MISC_SETUP 0 159 #define PLLSS_EN_SDM 0 160 #define PLLSS_EN_SSC 0 161 #define PLLSS_EN_DITHER2 0 162 #define PLLSS_EN_DITHER 1 163 #define PLLSS_SDM_RESET 0 164 #define PLLSS_CLAMP 0 165 #define PLLSS_SDM_SSC_MAX 0 166 #define PLLSS_SDM_SSC_MIN 0 167 #define PLLSS_SDM_SSC_STEP 0 168 #define PLLSS_SDM_DIN 0 169 #define PLLSS_MISC_DEFAULT ((PLLSS_MISC_KCP << 25) | \ 170 (PLLSS_MISC_KVCO << 24) | \ 171 PLLSS_MISC_SETUP) 172 #define PLLSS_CFG_DEFAULT ((PLLSS_EN_SDM << 31) | \ 173 (PLLSS_EN_SSC << 30) | \ 174 (PLLSS_EN_DITHER2 << 29) | \ 175 (PLLSS_EN_DITHER << 28) | \ 176 (PLLSS_SDM_RESET) << 27 | \ 177 (PLLSS_CLAMP << 22)) 178 #define PLLSS_CTRL1_DEFAULT \ 179 ((PLLSS_SDM_SSC_MAX << 16) | PLLSS_SDM_SSC_MIN) 180 #define PLLSS_CTRL2_DEFAULT \ 181 ((PLLSS_SDM_SSC_STEP << 16) | PLLSS_SDM_DIN) 182 #define PLLSS_LOCK_OVERRIDE BIT(24) 183 #define PLLSS_REF_SRC_SEL_SHIFT 25 184 #define PLLSS_REF_SRC_SEL_MASK (3 << PLLSS_REF_SRC_SEL_SHIFT) 185 186 #define pll_readl(offset, p) readl_relaxed(p->clk_base + offset) 187 #define pll_readl_base(p) pll_readl(p->params->base_reg, p) 188 #define pll_readl_misc(p) pll_readl(p->params->misc_reg, p) 189 #define pll_override_readl(offset, p) readl_relaxed(p->pmc + offset) 190 #define pll_readl_sdm_din(p) pll_readl(p->params->sdm_din_reg, p) 191 #define pll_readl_sdm_ctrl(p) pll_readl(p->params->sdm_ctrl_reg, p) 192 193 #define pll_writel(val, offset, p) writel_relaxed(val, p->clk_base + offset) 194 #define pll_writel_base(val, p) pll_writel(val, p->params->base_reg, p) 195 #define pll_writel_misc(val, p) pll_writel(val, p->params->misc_reg, p) 196 #define pll_override_writel(val, offset, p) writel(val, p->pmc + offset) 197 #define pll_writel_sdm_din(val, p) pll_writel(val, p->params->sdm_din_reg, p) 198 #define pll_writel_sdm_ctrl(val, p) pll_writel(val, p->params->sdm_ctrl_reg, p) 199 200 #define mask(w) ((1 << (w)) - 1) 201 #define divm_mask(p) mask(p->params->div_nmp->divm_width) 202 #define divn_mask(p) mask(p->params->div_nmp->divn_width) 203 #define divp_mask(p) (p->params->flags & TEGRA_PLLU ? PLLU_POST_DIVP_MASK :\ 204 mask(p->params->div_nmp->divp_width)) 205 #define sdm_din_mask(p) p->params->sdm_din_mask 206 #define sdm_en_mask(p) p->params->sdm_ctrl_en_mask 207 208 #define divm_shift(p) (p)->params->div_nmp->divm_shift 209 #define divn_shift(p) (p)->params->div_nmp->divn_shift 210 #define divp_shift(p) (p)->params->div_nmp->divp_shift 211 212 #define divm_mask_shifted(p) (divm_mask(p) << divm_shift(p)) 213 #define divn_mask_shifted(p) (divn_mask(p) << divn_shift(p)) 214 #define divp_mask_shifted(p) (divp_mask(p) << divp_shift(p)) 215 216 #define divm_max(p) (divm_mask(p)) 217 #define divn_max(p) (divn_mask(p)) 218 #define divp_max(p) (1 << (divp_mask(p))) 219 220 #define sdin_din_to_data(din) ((u16)((din) ? : 0xFFFFU)) 221 #define sdin_data_to_din(dat) (((dat) == 0xFFFFU) ? 0 : (s16)dat) 222 223 static struct div_nmp default_nmp = { 224 .divn_shift = PLL_BASE_DIVN_SHIFT, 225 .divn_width = PLL_BASE_DIVN_WIDTH, 226 .divm_shift = PLL_BASE_DIVM_SHIFT, 227 .divm_width = PLL_BASE_DIVM_WIDTH, 228 .divp_shift = PLL_BASE_DIVP_SHIFT, 229 .divp_width = PLL_BASE_DIVP_WIDTH, 230 }; 231 232 static void clk_pll_enable_lock(struct tegra_clk_pll *pll) 233 { 234 u32 val; 235 236 if (!(pll->params->flags & TEGRA_PLL_USE_LOCK)) 237 return; 238 239 if (!(pll->params->flags & TEGRA_PLL_HAS_LOCK_ENABLE)) 240 return; 241 242 val = pll_readl_misc(pll); 243 val |= BIT(pll->params->lock_enable_bit_idx); 244 pll_writel_misc(val, pll); 245 } 246 247 static int clk_pll_wait_for_lock(struct tegra_clk_pll *pll) 248 { 249 int i; 250 u32 val, lock_mask; 251 void __iomem *lock_addr; 252 253 if (!(pll->params->flags & TEGRA_PLL_USE_LOCK)) { 254 udelay(pll->params->lock_delay); 255 return 0; 256 } 257 258 lock_addr = pll->clk_base; 259 if (pll->params->flags & TEGRA_PLL_LOCK_MISC) 260 lock_addr += pll->params->misc_reg; 261 else 262 lock_addr += pll->params->base_reg; 263 264 lock_mask = pll->params->lock_mask; 265 266 for (i = 0; i < pll->params->lock_delay; i++) { 267 val = readl_relaxed(lock_addr); 268 if ((val & lock_mask) == lock_mask) { 269 udelay(PLL_POST_LOCK_DELAY); 270 return 0; 271 } 272 udelay(2); /* timeout = 2 * lock time */ 273 } 274 275 pr_err("%s: Timed out waiting for pll %s lock\n", __func__, 276 clk_hw_get_name(&pll->hw)); 277 278 return -1; 279 } 280 281 int tegra_pll_wait_for_lock(struct tegra_clk_pll *pll) 282 { 283 return clk_pll_wait_for_lock(pll); 284 } 285 286 static int clk_pll_is_enabled(struct clk_hw *hw) 287 { 288 struct tegra_clk_pll *pll = to_clk_pll(hw); 289 u32 val; 290 291 if (pll->params->flags & TEGRA_PLLM) { 292 val = readl_relaxed(pll->pmc + PMC_PLLP_WB0_OVERRIDE); 293 if (val & PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE) 294 return val & PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE ? 1 : 0; 295 } 296 297 val = pll_readl_base(pll); 298 299 return val & PLL_BASE_ENABLE ? 1 : 0; 300 } 301 302 static void _clk_pll_enable(struct clk_hw *hw) 303 { 304 struct tegra_clk_pll *pll = to_clk_pll(hw); 305 u32 val; 306 307 if (pll->params->iddq_reg) { 308 val = pll_readl(pll->params->iddq_reg, pll); 309 val &= ~BIT(pll->params->iddq_bit_idx); 310 pll_writel(val, pll->params->iddq_reg, pll); 311 udelay(2); 312 } 313 314 clk_pll_enable_lock(pll); 315 316 val = pll_readl_base(pll); 317 if (pll->params->flags & TEGRA_PLL_BYPASS) 318 val &= ~PLL_BASE_BYPASS; 319 val |= PLL_BASE_ENABLE; 320 pll_writel_base(val, pll); 321 322 if (pll->params->flags & TEGRA_PLLM) { 323 val = readl_relaxed(pll->pmc + PMC_PLLP_WB0_OVERRIDE); 324 val |= PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE; 325 writel_relaxed(val, pll->pmc + PMC_PLLP_WB0_OVERRIDE); 326 } 327 } 328 329 static void _clk_pll_disable(struct clk_hw *hw) 330 { 331 struct tegra_clk_pll *pll = to_clk_pll(hw); 332 u32 val; 333 334 val = pll_readl_base(pll); 335 if (pll->params->flags & TEGRA_PLL_BYPASS) 336 val &= ~PLL_BASE_BYPASS; 337 val &= ~PLL_BASE_ENABLE; 338 pll_writel_base(val, pll); 339 340 if (pll->params->flags & TEGRA_PLLM) { 341 val = readl_relaxed(pll->pmc + PMC_PLLP_WB0_OVERRIDE); 342 val &= ~PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE; 343 writel_relaxed(val, pll->pmc + PMC_PLLP_WB0_OVERRIDE); 344 } 345 346 if (pll->params->iddq_reg) { 347 val = pll_readl(pll->params->iddq_reg, pll); 348 val |= BIT(pll->params->iddq_bit_idx); 349 pll_writel(val, pll->params->iddq_reg, pll); 350 udelay(2); 351 } 352 } 353 354 static int clk_pll_enable(struct clk_hw *hw) 355 { 356 struct tegra_clk_pll *pll = to_clk_pll(hw); 357 unsigned long flags = 0; 358 int ret; 359 360 if (pll->lock) 361 spin_lock_irqsave(pll->lock, flags); 362 363 _clk_pll_enable(hw); 364 365 ret = clk_pll_wait_for_lock(pll); 366 367 if (pll->lock) 368 spin_unlock_irqrestore(pll->lock, flags); 369 370 return ret; 371 } 372 373 static void clk_pll_disable(struct clk_hw *hw) 374 { 375 struct tegra_clk_pll *pll = to_clk_pll(hw); 376 unsigned long flags = 0; 377 378 if (pll->lock) 379 spin_lock_irqsave(pll->lock, flags); 380 381 _clk_pll_disable(hw); 382 383 if (pll->lock) 384 spin_unlock_irqrestore(pll->lock, flags); 385 } 386 387 static int _p_div_to_hw(struct clk_hw *hw, u8 p_div) 388 { 389 struct tegra_clk_pll *pll = to_clk_pll(hw); 390 const struct pdiv_map *p_tohw = pll->params->pdiv_tohw; 391 392 if (p_tohw) { 393 while (p_tohw->pdiv) { 394 if (p_div <= p_tohw->pdiv) 395 return p_tohw->hw_val; 396 p_tohw++; 397 } 398 return -EINVAL; 399 } 400 return -EINVAL; 401 } 402 403 static int _hw_to_p_div(struct clk_hw *hw, u8 p_div_hw) 404 { 405 struct tegra_clk_pll *pll = to_clk_pll(hw); 406 const struct pdiv_map *p_tohw = pll->params->pdiv_tohw; 407 408 if (p_tohw) { 409 while (p_tohw->pdiv) { 410 if (p_div_hw == p_tohw->hw_val) 411 return p_tohw->pdiv; 412 p_tohw++; 413 } 414 return -EINVAL; 415 } 416 417 return 1 << p_div_hw; 418 } 419 420 static int _get_table_rate(struct clk_hw *hw, 421 struct tegra_clk_pll_freq_table *cfg, 422 unsigned long rate, unsigned long parent_rate) 423 { 424 struct tegra_clk_pll *pll = to_clk_pll(hw); 425 struct tegra_clk_pll_freq_table *sel; 426 427 for (sel = pll->params->freq_table; sel->input_rate != 0; sel++) 428 if (sel->input_rate == parent_rate && 429 sel->output_rate == rate) 430 break; 431 432 if (sel->input_rate == 0) 433 return -EINVAL; 434 435 cfg->input_rate = sel->input_rate; 436 cfg->output_rate = sel->output_rate; 437 cfg->m = sel->m; 438 cfg->n = sel->n; 439 cfg->p = sel->p; 440 cfg->cpcon = sel->cpcon; 441 cfg->sdm_data = sel->sdm_data; 442 443 return 0; 444 } 445 446 static int _calc_rate(struct clk_hw *hw, struct tegra_clk_pll_freq_table *cfg, 447 unsigned long rate, unsigned long parent_rate) 448 { 449 struct tegra_clk_pll *pll = to_clk_pll(hw); 450 unsigned long cfreq; 451 u32 p_div = 0; 452 int ret; 453 454 switch (parent_rate) { 455 case 12000000: 456 case 26000000: 457 cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2000000; 458 break; 459 case 13000000: 460 cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2600000; 461 break; 462 case 16800000: 463 case 19200000: 464 cfreq = (rate <= 1200000 * 1000) ? 1200000 : 2400000; 465 break; 466 case 9600000: 467 case 28800000: 468 /* 469 * PLL_P_OUT1 rate is not listed in PLLA table 470 */ 471 cfreq = parent_rate / (parent_rate / 1000000); 472 break; 473 default: 474 pr_err("%s Unexpected reference rate %lu\n", 475 __func__, parent_rate); 476 BUG(); 477 } 478 479 /* Raise VCO to guarantee 0.5% accuracy */ 480 for (cfg->output_rate = rate; cfg->output_rate < 200 * cfreq; 481 cfg->output_rate <<= 1) 482 p_div++; 483 484 cfg->m = parent_rate / cfreq; 485 cfg->n = cfg->output_rate / cfreq; 486 cfg->cpcon = OUT_OF_TABLE_CPCON; 487 488 if (cfg->m > divm_max(pll) || cfg->n > divn_max(pll) || 489 (1 << p_div) > divp_max(pll) 490 || cfg->output_rate > pll->params->vco_max) { 491 return -EINVAL; 492 } 493 494 cfg->output_rate >>= p_div; 495 496 if (pll->params->pdiv_tohw) { 497 ret = _p_div_to_hw(hw, 1 << p_div); 498 if (ret < 0) 499 return ret; 500 else 501 cfg->p = ret; 502 } else 503 cfg->p = p_div; 504 505 return 0; 506 } 507 508 /* 509 * SDM (Sigma Delta Modulator) divisor is 16-bit 2's complement signed number 510 * within (-2^12 ... 2^12-1) range. Represented in PLL data structure as 511 * unsigned 16-bit value, with "0" divisor mapped to 0xFFFF. Data "0" is used 512 * to indicate that SDM is disabled. 513 * 514 * Effective ndiv value when SDM is enabled: ndiv + 1/2 + sdm_din/2^13 515 */ 516 static void clk_pll_set_sdm_data(struct clk_hw *hw, 517 struct tegra_clk_pll_freq_table *cfg) 518 { 519 struct tegra_clk_pll *pll = to_clk_pll(hw); 520 u32 val; 521 bool enabled; 522 523 if (!pll->params->sdm_din_reg) 524 return; 525 526 if (cfg->sdm_data) { 527 val = pll_readl_sdm_din(pll) & (~sdm_din_mask(pll)); 528 val |= sdin_data_to_din(cfg->sdm_data) & sdm_din_mask(pll); 529 pll_writel_sdm_din(val, pll); 530 } 531 532 val = pll_readl_sdm_ctrl(pll); 533 enabled = (val & sdm_en_mask(pll)); 534 535 if (cfg->sdm_data == 0 && enabled) 536 val &= ~pll->params->sdm_ctrl_en_mask; 537 538 if (cfg->sdm_data != 0 && !enabled) 539 val |= pll->params->sdm_ctrl_en_mask; 540 541 pll_writel_sdm_ctrl(val, pll); 542 } 543 544 static void _update_pll_mnp(struct tegra_clk_pll *pll, 545 struct tegra_clk_pll_freq_table *cfg) 546 { 547 u32 val; 548 struct tegra_clk_pll_params *params = pll->params; 549 struct div_nmp *div_nmp = params->div_nmp; 550 551 if ((params->flags & TEGRA_PLLM) && 552 (pll_override_readl(PMC_PLLP_WB0_OVERRIDE, pll) & 553 PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE)) { 554 val = pll_override_readl(params->pmc_divp_reg, pll); 555 val &= ~(divp_mask(pll) << div_nmp->override_divp_shift); 556 val |= cfg->p << div_nmp->override_divp_shift; 557 pll_override_writel(val, params->pmc_divp_reg, pll); 558 559 val = pll_override_readl(params->pmc_divnm_reg, pll); 560 val &= ~(divm_mask(pll) << div_nmp->override_divm_shift) | 561 ~(divn_mask(pll) << div_nmp->override_divn_shift); 562 val |= (cfg->m << div_nmp->override_divm_shift) | 563 (cfg->n << div_nmp->override_divn_shift); 564 pll_override_writel(val, params->pmc_divnm_reg, pll); 565 } else { 566 val = pll_readl_base(pll); 567 568 val &= ~(divm_mask_shifted(pll) | divn_mask_shifted(pll) | 569 divp_mask_shifted(pll)); 570 571 val |= (cfg->m << divm_shift(pll)) | 572 (cfg->n << divn_shift(pll)) | 573 (cfg->p << divp_shift(pll)); 574 575 pll_writel_base(val, pll); 576 577 clk_pll_set_sdm_data(&pll->hw, cfg); 578 } 579 } 580 581 static void _get_pll_mnp(struct tegra_clk_pll *pll, 582 struct tegra_clk_pll_freq_table *cfg) 583 { 584 u32 val; 585 struct tegra_clk_pll_params *params = pll->params; 586 struct div_nmp *div_nmp = params->div_nmp; 587 588 if ((params->flags & TEGRA_PLLM) && 589 (pll_override_readl(PMC_PLLP_WB0_OVERRIDE, pll) & 590 PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE)) { 591 val = pll_override_readl(params->pmc_divp_reg, pll); 592 cfg->p = (val >> div_nmp->override_divp_shift) & divp_mask(pll); 593 594 val = pll_override_readl(params->pmc_divnm_reg, pll); 595 cfg->m = (val >> div_nmp->override_divm_shift) & divm_mask(pll); 596 cfg->n = (val >> div_nmp->override_divn_shift) & divn_mask(pll); 597 } else { 598 val = pll_readl_base(pll); 599 600 cfg->m = (val >> div_nmp->divm_shift) & divm_mask(pll); 601 cfg->n = (val >> div_nmp->divn_shift) & divn_mask(pll); 602 cfg->p = (val >> div_nmp->divp_shift) & divp_mask(pll); 603 604 if (pll->params->sdm_din_reg) { 605 if (sdm_en_mask(pll) & pll_readl_sdm_ctrl(pll)) { 606 val = pll_readl_sdm_din(pll); 607 val &= sdm_din_mask(pll); 608 cfg->sdm_data = sdin_din_to_data(val); 609 } 610 } 611 } 612 } 613 614 static void _update_pll_cpcon(struct tegra_clk_pll *pll, 615 struct tegra_clk_pll_freq_table *cfg, 616 unsigned long rate) 617 { 618 u32 val; 619 620 val = pll_readl_misc(pll); 621 622 val &= ~(PLL_MISC_CPCON_MASK << PLL_MISC_CPCON_SHIFT); 623 val |= cfg->cpcon << PLL_MISC_CPCON_SHIFT; 624 625 if (pll->params->flags & TEGRA_PLL_SET_LFCON) { 626 val &= ~(PLL_MISC_LFCON_MASK << PLL_MISC_LFCON_SHIFT); 627 if (cfg->n >= PLLDU_LFCON_SET_DIVN) 628 val |= 1 << PLL_MISC_LFCON_SHIFT; 629 } else if (pll->params->flags & TEGRA_PLL_SET_DCCON) { 630 val &= ~(1 << PLL_MISC_DCCON_SHIFT); 631 if (rate >= (pll->params->vco_max >> 1)) 632 val |= 1 << PLL_MISC_DCCON_SHIFT; 633 } 634 635 pll_writel_misc(val, pll); 636 } 637 638 static int _program_pll(struct clk_hw *hw, struct tegra_clk_pll_freq_table *cfg, 639 unsigned long rate) 640 { 641 struct tegra_clk_pll *pll = to_clk_pll(hw); 642 int state, ret = 0; 643 644 state = clk_pll_is_enabled(hw); 645 646 if (state) 647 _clk_pll_disable(hw); 648 649 _update_pll_mnp(pll, cfg); 650 651 if (pll->params->flags & TEGRA_PLL_HAS_CPCON) 652 _update_pll_cpcon(pll, cfg, rate); 653 654 if (state) { 655 _clk_pll_enable(hw); 656 ret = clk_pll_wait_for_lock(pll); 657 } 658 659 return ret; 660 } 661 662 static int clk_pll_set_rate(struct clk_hw *hw, unsigned long rate, 663 unsigned long parent_rate) 664 { 665 struct tegra_clk_pll *pll = to_clk_pll(hw); 666 struct tegra_clk_pll_freq_table cfg, old_cfg; 667 unsigned long flags = 0; 668 int ret = 0; 669 670 if (pll->params->flags & TEGRA_PLL_FIXED) { 671 if (rate != pll->params->fixed_rate) { 672 pr_err("%s: Can not change %s fixed rate %lu to %lu\n", 673 __func__, clk_hw_get_name(hw), 674 pll->params->fixed_rate, rate); 675 return -EINVAL; 676 } 677 return 0; 678 } 679 680 if (_get_table_rate(hw, &cfg, rate, parent_rate) && 681 pll->params->calc_rate(hw, &cfg, rate, parent_rate)) { 682 pr_err("%s: Failed to set %s rate %lu\n", __func__, 683 clk_hw_get_name(hw), rate); 684 WARN_ON(1); 685 return -EINVAL; 686 } 687 if (pll->lock) 688 spin_lock_irqsave(pll->lock, flags); 689 690 _get_pll_mnp(pll, &old_cfg); 691 692 if (old_cfg.m != cfg.m || old_cfg.n != cfg.n || old_cfg.p != cfg.p || 693 old_cfg.sdm_data != cfg.sdm_data) 694 ret = _program_pll(hw, &cfg, rate); 695 696 if (pll->lock) 697 spin_unlock_irqrestore(pll->lock, flags); 698 699 return ret; 700 } 701 702 static long clk_pll_round_rate(struct clk_hw *hw, unsigned long rate, 703 unsigned long *prate) 704 { 705 struct tegra_clk_pll *pll = to_clk_pll(hw); 706 struct tegra_clk_pll_freq_table cfg; 707 708 if (pll->params->flags & TEGRA_PLL_FIXED) 709 return pll->params->fixed_rate; 710 711 /* PLLM is used for memory; we do not change rate */ 712 if (pll->params->flags & TEGRA_PLLM) 713 return clk_hw_get_rate(hw); 714 715 if (_get_table_rate(hw, &cfg, rate, *prate) && 716 pll->params->calc_rate(hw, &cfg, rate, *prate)) 717 return -EINVAL; 718 719 return cfg.output_rate; 720 } 721 722 static unsigned long clk_pll_recalc_rate(struct clk_hw *hw, 723 unsigned long parent_rate) 724 { 725 struct tegra_clk_pll *pll = to_clk_pll(hw); 726 struct tegra_clk_pll_freq_table cfg; 727 u32 val; 728 u64 rate = parent_rate; 729 int pdiv; 730 731 val = pll_readl_base(pll); 732 733 if ((pll->params->flags & TEGRA_PLL_BYPASS) && (val & PLL_BASE_BYPASS)) 734 return parent_rate; 735 736 if ((pll->params->flags & TEGRA_PLL_FIXED) && 737 !(val & PLL_BASE_OVERRIDE)) { 738 struct tegra_clk_pll_freq_table sel; 739 if (_get_table_rate(hw, &sel, pll->params->fixed_rate, 740 parent_rate)) { 741 pr_err("Clock %s has unknown fixed frequency\n", 742 clk_hw_get_name(hw)); 743 BUG(); 744 } 745 return pll->params->fixed_rate; 746 } 747 748 _get_pll_mnp(pll, &cfg); 749 750 pdiv = _hw_to_p_div(hw, cfg.p); 751 if (pdiv < 0) { 752 WARN(1, "Clock %s has invalid pdiv value : 0x%x\n", 753 __clk_get_name(hw->clk), cfg.p); 754 pdiv = 1; 755 } 756 757 if (pll->params->set_gain) 758 pll->params->set_gain(&cfg); 759 760 cfg.m *= pdiv; 761 762 rate *= cfg.n; 763 do_div(rate, cfg.m); 764 765 return rate; 766 } 767 768 static int clk_plle_training(struct tegra_clk_pll *pll) 769 { 770 u32 val; 771 unsigned long timeout; 772 773 if (!pll->pmc) 774 return -ENOSYS; 775 776 /* 777 * PLLE is already disabled, and setup cleared; 778 * create falling edge on PLLE IDDQ input. 779 */ 780 val = readl(pll->pmc + PMC_SATA_PWRGT); 781 val |= PMC_SATA_PWRGT_PLLE_IDDQ_VALUE; 782 writel(val, pll->pmc + PMC_SATA_PWRGT); 783 784 val = readl(pll->pmc + PMC_SATA_PWRGT); 785 val |= PMC_SATA_PWRGT_PLLE_IDDQ_SWCTL; 786 writel(val, pll->pmc + PMC_SATA_PWRGT); 787 788 val = readl(pll->pmc + PMC_SATA_PWRGT); 789 val &= ~PMC_SATA_PWRGT_PLLE_IDDQ_VALUE; 790 writel(val, pll->pmc + PMC_SATA_PWRGT); 791 792 val = pll_readl_misc(pll); 793 794 timeout = jiffies + msecs_to_jiffies(100); 795 while (1) { 796 val = pll_readl_misc(pll); 797 if (val & PLLE_MISC_READY) 798 break; 799 if (time_after(jiffies, timeout)) { 800 pr_err("%s: timeout waiting for PLLE\n", __func__); 801 return -EBUSY; 802 } 803 udelay(300); 804 } 805 806 return 0; 807 } 808 809 static int clk_plle_enable(struct clk_hw *hw) 810 { 811 struct tegra_clk_pll *pll = to_clk_pll(hw); 812 unsigned long input_rate = clk_get_rate(clk_get_parent(hw->clk)); 813 struct tegra_clk_pll_freq_table sel; 814 u32 val; 815 int err; 816 817 if (_get_table_rate(hw, &sel, pll->params->fixed_rate, input_rate)) 818 return -EINVAL; 819 820 clk_pll_disable(hw); 821 822 val = pll_readl_misc(pll); 823 val &= ~(PLLE_MISC_LOCK_ENABLE | PLLE_MISC_SETUP_MASK); 824 pll_writel_misc(val, pll); 825 826 val = pll_readl_misc(pll); 827 if (!(val & PLLE_MISC_READY)) { 828 err = clk_plle_training(pll); 829 if (err) 830 return err; 831 } 832 833 if (pll->params->flags & TEGRA_PLLE_CONFIGURE) { 834 /* configure dividers */ 835 val = pll_readl_base(pll); 836 val &= ~(divp_mask_shifted(pll) | divn_mask_shifted(pll) | 837 divm_mask_shifted(pll)); 838 val &= ~(PLLE_BASE_DIVCML_MASK << PLLE_BASE_DIVCML_SHIFT); 839 val |= sel.m << divm_shift(pll); 840 val |= sel.n << divn_shift(pll); 841 val |= sel.p << divp_shift(pll); 842 val |= sel.cpcon << PLLE_BASE_DIVCML_SHIFT; 843 pll_writel_base(val, pll); 844 } 845 846 val = pll_readl_misc(pll); 847 val |= PLLE_MISC_SETUP_VALUE; 848 val |= PLLE_MISC_LOCK_ENABLE; 849 pll_writel_misc(val, pll); 850 851 val = readl(pll->clk_base + PLLE_SS_CTRL); 852 val &= ~PLLE_SS_COEFFICIENTS_MASK; 853 val |= PLLE_SS_DISABLE; 854 writel(val, pll->clk_base + PLLE_SS_CTRL); 855 856 val = pll_readl_base(pll); 857 val |= (PLL_BASE_BYPASS | PLL_BASE_ENABLE); 858 pll_writel_base(val, pll); 859 860 clk_pll_wait_for_lock(pll); 861 862 return 0; 863 } 864 865 static unsigned long clk_plle_recalc_rate(struct clk_hw *hw, 866 unsigned long parent_rate) 867 { 868 struct tegra_clk_pll *pll = to_clk_pll(hw); 869 u32 val = pll_readl_base(pll); 870 u32 divn = 0, divm = 0, divp = 0; 871 u64 rate = parent_rate; 872 873 divp = (val >> pll->params->div_nmp->divp_shift) & (divp_mask(pll)); 874 divn = (val >> pll->params->div_nmp->divn_shift) & (divn_mask(pll)); 875 divm = (val >> pll->params->div_nmp->divm_shift) & (divm_mask(pll)); 876 divm *= divp; 877 878 rate *= divn; 879 do_div(rate, divm); 880 return rate; 881 } 882 883 const struct clk_ops tegra_clk_pll_ops = { 884 .is_enabled = clk_pll_is_enabled, 885 .enable = clk_pll_enable, 886 .disable = clk_pll_disable, 887 .recalc_rate = clk_pll_recalc_rate, 888 .round_rate = clk_pll_round_rate, 889 .set_rate = clk_pll_set_rate, 890 }; 891 892 const struct clk_ops tegra_clk_plle_ops = { 893 .recalc_rate = clk_plle_recalc_rate, 894 .is_enabled = clk_pll_is_enabled, 895 .disable = clk_pll_disable, 896 .enable = clk_plle_enable, 897 }; 898 899 #if defined(CONFIG_ARCH_TEGRA_114_SOC) || \ 900 defined(CONFIG_ARCH_TEGRA_124_SOC) || \ 901 defined(CONFIG_ARCH_TEGRA_132_SOC) 902 903 static int _pll_fixed_mdiv(struct tegra_clk_pll_params *pll_params, 904 unsigned long parent_rate) 905 { 906 u16 mdiv = parent_rate / pll_params->cf_min; 907 908 if (pll_params->flags & TEGRA_MDIV_NEW) 909 return (!pll_params->mdiv_default ? mdiv : 910 min(mdiv, pll_params->mdiv_default)); 911 912 if (pll_params->mdiv_default) 913 return pll_params->mdiv_default; 914 915 if (parent_rate > pll_params->cf_max) 916 return 2; 917 else 918 return 1; 919 } 920 921 u16 tegra_pll_get_fixed_mdiv(struct clk_hw *hw, unsigned long input_rate) 922 { 923 struct tegra_clk_pll *pll = to_clk_pll(hw); 924 925 return (u16)_pll_fixed_mdiv(pll->params, input_rate); 926 } 927 928 static unsigned long _clip_vco_min(unsigned long vco_min, 929 unsigned long parent_rate) 930 { 931 return DIV_ROUND_UP(vco_min, parent_rate) * parent_rate; 932 } 933 934 static int _setup_dynamic_ramp(struct tegra_clk_pll_params *pll_params, 935 void __iomem *clk_base, 936 unsigned long parent_rate) 937 { 938 u32 val; 939 u32 step_a, step_b; 940 941 switch (parent_rate) { 942 case 12000000: 943 case 13000000: 944 case 26000000: 945 step_a = 0x2B; 946 step_b = 0x0B; 947 break; 948 case 16800000: 949 step_a = 0x1A; 950 step_b = 0x09; 951 break; 952 case 19200000: 953 step_a = 0x12; 954 step_b = 0x08; 955 break; 956 default: 957 pr_err("%s: Unexpected reference rate %lu\n", 958 __func__, parent_rate); 959 WARN_ON(1); 960 return -EINVAL; 961 } 962 963 val = step_a << pll_params->stepa_shift; 964 val |= step_b << pll_params->stepb_shift; 965 writel_relaxed(val, clk_base + pll_params->dyn_ramp_reg); 966 967 return 0; 968 } 969 970 static int _calc_dynamic_ramp_rate(struct clk_hw *hw, 971 struct tegra_clk_pll_freq_table *cfg, 972 unsigned long rate, unsigned long parent_rate) 973 { 974 struct tegra_clk_pll *pll = to_clk_pll(hw); 975 unsigned int p; 976 int p_div; 977 978 if (!rate) 979 return -EINVAL; 980 981 p = DIV_ROUND_UP(pll->params->vco_min, rate); 982 cfg->m = _pll_fixed_mdiv(pll->params, parent_rate); 983 cfg->output_rate = rate * p; 984 cfg->n = cfg->output_rate * cfg->m / parent_rate; 985 986 p_div = _p_div_to_hw(hw, p); 987 if (p_div < 0) 988 return p_div; 989 990 cfg->p = p_div; 991 992 if (cfg->n > divn_max(pll) || cfg->output_rate > pll->params->vco_max) 993 return -EINVAL; 994 995 return 0; 996 } 997 998 static int _pll_ramp_calc_pll(struct clk_hw *hw, 999 struct tegra_clk_pll_freq_table *cfg, 1000 unsigned long rate, unsigned long parent_rate) 1001 { 1002 struct tegra_clk_pll *pll = to_clk_pll(hw); 1003 int err = 0, p_div; 1004 1005 err = _get_table_rate(hw, cfg, rate, parent_rate); 1006 if (err < 0) 1007 err = _calc_dynamic_ramp_rate(hw, cfg, rate, parent_rate); 1008 else { 1009 if (cfg->m != _pll_fixed_mdiv(pll->params, parent_rate)) { 1010 WARN_ON(1); 1011 err = -EINVAL; 1012 goto out; 1013 } 1014 p_div = _p_div_to_hw(hw, cfg->p); 1015 if (p_div < 0) 1016 return p_div; 1017 else 1018 cfg->p = p_div; 1019 } 1020 1021 if (cfg->p > pll->params->max_p) 1022 err = -EINVAL; 1023 1024 out: 1025 return err; 1026 } 1027 1028 static int clk_pllxc_set_rate(struct clk_hw *hw, unsigned long rate, 1029 unsigned long parent_rate) 1030 { 1031 struct tegra_clk_pll *pll = to_clk_pll(hw); 1032 struct tegra_clk_pll_freq_table cfg, old_cfg; 1033 unsigned long flags = 0; 1034 int ret; 1035 1036 ret = _pll_ramp_calc_pll(hw, &cfg, rate, parent_rate); 1037 if (ret < 0) 1038 return ret; 1039 1040 if (pll->lock) 1041 spin_lock_irqsave(pll->lock, flags); 1042 1043 _get_pll_mnp(pll, &old_cfg); 1044 1045 if (old_cfg.m != cfg.m || old_cfg.n != cfg.n || old_cfg.p != cfg.p) 1046 ret = _program_pll(hw, &cfg, rate); 1047 1048 if (pll->lock) 1049 spin_unlock_irqrestore(pll->lock, flags); 1050 1051 return ret; 1052 } 1053 1054 static long clk_pll_ramp_round_rate(struct clk_hw *hw, unsigned long rate, 1055 unsigned long *prate) 1056 { 1057 struct tegra_clk_pll *pll = to_clk_pll(hw); 1058 struct tegra_clk_pll_freq_table cfg; 1059 int ret, p_div; 1060 u64 output_rate = *prate; 1061 1062 ret = _pll_ramp_calc_pll(hw, &cfg, rate, *prate); 1063 if (ret < 0) 1064 return ret; 1065 1066 p_div = _hw_to_p_div(hw, cfg.p); 1067 if (p_div < 0) 1068 return p_div; 1069 1070 if (pll->params->set_gain) 1071 pll->params->set_gain(&cfg); 1072 1073 output_rate *= cfg.n; 1074 do_div(output_rate, cfg.m * p_div); 1075 1076 return output_rate; 1077 } 1078 1079 static int clk_pllm_set_rate(struct clk_hw *hw, unsigned long rate, 1080 unsigned long parent_rate) 1081 { 1082 struct tegra_clk_pll_freq_table cfg; 1083 struct tegra_clk_pll *pll = to_clk_pll(hw); 1084 unsigned long flags = 0; 1085 int state, ret = 0; 1086 1087 if (pll->lock) 1088 spin_lock_irqsave(pll->lock, flags); 1089 1090 state = clk_pll_is_enabled(hw); 1091 if (state) { 1092 if (rate != clk_get_rate(hw->clk)) { 1093 pr_err("%s: Cannot change active PLLM\n", __func__); 1094 ret = -EINVAL; 1095 goto out; 1096 } 1097 goto out; 1098 } 1099 1100 ret = _pll_ramp_calc_pll(hw, &cfg, rate, parent_rate); 1101 if (ret < 0) 1102 goto out; 1103 1104 _update_pll_mnp(pll, &cfg); 1105 1106 out: 1107 if (pll->lock) 1108 spin_unlock_irqrestore(pll->lock, flags); 1109 1110 return ret; 1111 } 1112 1113 static void _pllcx_strobe(struct tegra_clk_pll *pll) 1114 { 1115 u32 val; 1116 1117 val = pll_readl_misc(pll); 1118 val |= PLLCX_MISC_STROBE; 1119 pll_writel_misc(val, pll); 1120 udelay(2); 1121 1122 val &= ~PLLCX_MISC_STROBE; 1123 pll_writel_misc(val, pll); 1124 } 1125 1126 static int clk_pllc_enable(struct clk_hw *hw) 1127 { 1128 struct tegra_clk_pll *pll = to_clk_pll(hw); 1129 u32 val; 1130 int ret; 1131 unsigned long flags = 0; 1132 1133 if (pll->lock) 1134 spin_lock_irqsave(pll->lock, flags); 1135 1136 _clk_pll_enable(hw); 1137 udelay(2); 1138 1139 val = pll_readl_misc(pll); 1140 val &= ~PLLCX_MISC_RESET; 1141 pll_writel_misc(val, pll); 1142 udelay(2); 1143 1144 _pllcx_strobe(pll); 1145 1146 ret = clk_pll_wait_for_lock(pll); 1147 1148 if (pll->lock) 1149 spin_unlock_irqrestore(pll->lock, flags); 1150 1151 return ret; 1152 } 1153 1154 static void _clk_pllc_disable(struct clk_hw *hw) 1155 { 1156 struct tegra_clk_pll *pll = to_clk_pll(hw); 1157 u32 val; 1158 1159 _clk_pll_disable(hw); 1160 1161 val = pll_readl_misc(pll); 1162 val |= PLLCX_MISC_RESET; 1163 pll_writel_misc(val, pll); 1164 udelay(2); 1165 } 1166 1167 static void clk_pllc_disable(struct clk_hw *hw) 1168 { 1169 struct tegra_clk_pll *pll = to_clk_pll(hw); 1170 unsigned long flags = 0; 1171 1172 if (pll->lock) 1173 spin_lock_irqsave(pll->lock, flags); 1174 1175 _clk_pllc_disable(hw); 1176 1177 if (pll->lock) 1178 spin_unlock_irqrestore(pll->lock, flags); 1179 } 1180 1181 static int _pllcx_update_dynamic_coef(struct tegra_clk_pll *pll, 1182 unsigned long input_rate, u32 n) 1183 { 1184 u32 val, n_threshold; 1185 1186 switch (input_rate) { 1187 case 12000000: 1188 n_threshold = 70; 1189 break; 1190 case 13000000: 1191 case 26000000: 1192 n_threshold = 71; 1193 break; 1194 case 16800000: 1195 n_threshold = 55; 1196 break; 1197 case 19200000: 1198 n_threshold = 48; 1199 break; 1200 default: 1201 pr_err("%s: Unexpected reference rate %lu\n", 1202 __func__, input_rate); 1203 return -EINVAL; 1204 } 1205 1206 val = pll_readl_misc(pll); 1207 val &= ~(PLLCX_MISC_SDM_DIV_MASK | PLLCX_MISC_FILT_DIV_MASK); 1208 val |= n <= n_threshold ? 1209 PLLCX_MISC_DIV_LOW_RANGE : PLLCX_MISC_DIV_HIGH_RANGE; 1210 pll_writel_misc(val, pll); 1211 1212 return 0; 1213 } 1214 1215 static int clk_pllc_set_rate(struct clk_hw *hw, unsigned long rate, 1216 unsigned long parent_rate) 1217 { 1218 struct tegra_clk_pll_freq_table cfg, old_cfg; 1219 struct tegra_clk_pll *pll = to_clk_pll(hw); 1220 unsigned long flags = 0; 1221 int state, ret = 0; 1222 1223 if (pll->lock) 1224 spin_lock_irqsave(pll->lock, flags); 1225 1226 ret = _pll_ramp_calc_pll(hw, &cfg, rate, parent_rate); 1227 if (ret < 0) 1228 goto out; 1229 1230 _get_pll_mnp(pll, &old_cfg); 1231 1232 if (cfg.m != old_cfg.m) { 1233 WARN_ON(1); 1234 goto out; 1235 } 1236 1237 if (old_cfg.n == cfg.n && old_cfg.p == cfg.p) 1238 goto out; 1239 1240 state = clk_pll_is_enabled(hw); 1241 if (state) 1242 _clk_pllc_disable(hw); 1243 1244 ret = _pllcx_update_dynamic_coef(pll, parent_rate, cfg.n); 1245 if (ret < 0) 1246 goto out; 1247 1248 _update_pll_mnp(pll, &cfg); 1249 1250 if (state) 1251 ret = clk_pllc_enable(hw); 1252 1253 out: 1254 if (pll->lock) 1255 spin_unlock_irqrestore(pll->lock, flags); 1256 1257 return ret; 1258 } 1259 1260 static long _pllre_calc_rate(struct tegra_clk_pll *pll, 1261 struct tegra_clk_pll_freq_table *cfg, 1262 unsigned long rate, unsigned long parent_rate) 1263 { 1264 u16 m, n; 1265 u64 output_rate = parent_rate; 1266 1267 m = _pll_fixed_mdiv(pll->params, parent_rate); 1268 n = rate * m / parent_rate; 1269 1270 output_rate *= n; 1271 do_div(output_rate, m); 1272 1273 if (cfg) { 1274 cfg->m = m; 1275 cfg->n = n; 1276 } 1277 1278 return output_rate; 1279 } 1280 1281 static int clk_pllre_set_rate(struct clk_hw *hw, unsigned long rate, 1282 unsigned long parent_rate) 1283 { 1284 struct tegra_clk_pll_freq_table cfg, old_cfg; 1285 struct tegra_clk_pll *pll = to_clk_pll(hw); 1286 unsigned long flags = 0; 1287 int state, ret = 0; 1288 1289 if (pll->lock) 1290 spin_lock_irqsave(pll->lock, flags); 1291 1292 _pllre_calc_rate(pll, &cfg, rate, parent_rate); 1293 _get_pll_mnp(pll, &old_cfg); 1294 cfg.p = old_cfg.p; 1295 1296 if (cfg.m != old_cfg.m || cfg.n != old_cfg.n) { 1297 state = clk_pll_is_enabled(hw); 1298 if (state) 1299 _clk_pll_disable(hw); 1300 1301 _update_pll_mnp(pll, &cfg); 1302 1303 if (state) { 1304 _clk_pll_enable(hw); 1305 ret = clk_pll_wait_for_lock(pll); 1306 } 1307 } 1308 1309 if (pll->lock) 1310 spin_unlock_irqrestore(pll->lock, flags); 1311 1312 return ret; 1313 } 1314 1315 static unsigned long clk_pllre_recalc_rate(struct clk_hw *hw, 1316 unsigned long parent_rate) 1317 { 1318 struct tegra_clk_pll_freq_table cfg; 1319 struct tegra_clk_pll *pll = to_clk_pll(hw); 1320 u64 rate = parent_rate; 1321 1322 _get_pll_mnp(pll, &cfg); 1323 1324 rate *= cfg.n; 1325 do_div(rate, cfg.m); 1326 1327 return rate; 1328 } 1329 1330 static long clk_pllre_round_rate(struct clk_hw *hw, unsigned long rate, 1331 unsigned long *prate) 1332 { 1333 struct tegra_clk_pll *pll = to_clk_pll(hw); 1334 1335 return _pllre_calc_rate(pll, NULL, rate, *prate); 1336 } 1337 1338 static int clk_plle_tegra114_enable(struct clk_hw *hw) 1339 { 1340 struct tegra_clk_pll *pll = to_clk_pll(hw); 1341 struct tegra_clk_pll_freq_table sel; 1342 u32 val; 1343 int ret; 1344 unsigned long flags = 0; 1345 unsigned long input_rate = clk_get_rate(clk_get_parent(hw->clk)); 1346 1347 if (_get_table_rate(hw, &sel, pll->params->fixed_rate, input_rate)) 1348 return -EINVAL; 1349 1350 if (pll->lock) 1351 spin_lock_irqsave(pll->lock, flags); 1352 1353 val = pll_readl_base(pll); 1354 val &= ~BIT(29); /* Disable lock override */ 1355 pll_writel_base(val, pll); 1356 1357 val = pll_readl(pll->params->aux_reg, pll); 1358 val |= PLLE_AUX_ENABLE_SWCTL; 1359 val &= ~PLLE_AUX_SEQ_ENABLE; 1360 pll_writel(val, pll->params->aux_reg, pll); 1361 udelay(1); 1362 1363 val = pll_readl_misc(pll); 1364 val |= PLLE_MISC_LOCK_ENABLE; 1365 val |= PLLE_MISC_IDDQ_SW_CTRL; 1366 val &= ~PLLE_MISC_IDDQ_SW_VALUE; 1367 val |= PLLE_MISC_PLLE_PTS; 1368 val |= PLLE_MISC_VREG_BG_CTRL_MASK | PLLE_MISC_VREG_CTRL_MASK; 1369 pll_writel_misc(val, pll); 1370 udelay(5); 1371 1372 val = pll_readl(PLLE_SS_CTRL, pll); 1373 val |= PLLE_SS_DISABLE; 1374 pll_writel(val, PLLE_SS_CTRL, pll); 1375 1376 val = pll_readl_base(pll); 1377 val &= ~(divp_mask_shifted(pll) | divn_mask_shifted(pll) | 1378 divm_mask_shifted(pll)); 1379 val &= ~(PLLE_BASE_DIVCML_MASK << PLLE_BASE_DIVCML_SHIFT); 1380 val |= sel.m << divm_shift(pll); 1381 val |= sel.n << divn_shift(pll); 1382 val |= sel.cpcon << PLLE_BASE_DIVCML_SHIFT; 1383 pll_writel_base(val, pll); 1384 udelay(1); 1385 1386 _clk_pll_enable(hw); 1387 ret = clk_pll_wait_for_lock(pll); 1388 1389 if (ret < 0) 1390 goto out; 1391 1392 val = pll_readl(PLLE_SS_CTRL, pll); 1393 val &= ~(PLLE_SS_CNTL_CENTER | PLLE_SS_CNTL_INVERT); 1394 val &= ~PLLE_SS_COEFFICIENTS_MASK; 1395 val |= PLLE_SS_COEFFICIENTS_VAL; 1396 pll_writel(val, PLLE_SS_CTRL, pll); 1397 val &= ~(PLLE_SS_CNTL_SSC_BYP | PLLE_SS_CNTL_BYPASS_SS); 1398 pll_writel(val, PLLE_SS_CTRL, pll); 1399 udelay(1); 1400 val &= ~PLLE_SS_CNTL_INTERP_RESET; 1401 pll_writel(val, PLLE_SS_CTRL, pll); 1402 udelay(1); 1403 1404 /* Enable hw control of xusb brick pll */ 1405 val = pll_readl_misc(pll); 1406 val &= ~PLLE_MISC_IDDQ_SW_CTRL; 1407 pll_writel_misc(val, pll); 1408 1409 val = pll_readl(pll->params->aux_reg, pll); 1410 val |= (PLLE_AUX_USE_LOCKDET | PLLE_AUX_SEQ_START_STATE); 1411 val &= ~(PLLE_AUX_ENABLE_SWCTL | PLLE_AUX_SS_SWCTL); 1412 pll_writel(val, pll->params->aux_reg, pll); 1413 udelay(1); 1414 val |= PLLE_AUX_SEQ_ENABLE; 1415 pll_writel(val, pll->params->aux_reg, pll); 1416 1417 val = pll_readl(XUSBIO_PLL_CFG0, pll); 1418 val |= (XUSBIO_PLL_CFG0_PADPLL_USE_LOCKDET | 1419 XUSBIO_PLL_CFG0_SEQ_START_STATE); 1420 val &= ~(XUSBIO_PLL_CFG0_CLK_ENABLE_SWCTL | 1421 XUSBIO_PLL_CFG0_PADPLL_RESET_SWCTL); 1422 pll_writel(val, XUSBIO_PLL_CFG0, pll); 1423 udelay(1); 1424 val |= XUSBIO_PLL_CFG0_SEQ_ENABLE; 1425 pll_writel(val, XUSBIO_PLL_CFG0, pll); 1426 1427 /* Enable hw control of SATA pll */ 1428 val = pll_readl(SATA_PLL_CFG0, pll); 1429 val &= ~SATA_PLL_CFG0_PADPLL_RESET_SWCTL; 1430 val |= SATA_PLL_CFG0_PADPLL_USE_LOCKDET; 1431 val |= SATA_PLL_CFG0_SEQ_START_STATE; 1432 pll_writel(val, SATA_PLL_CFG0, pll); 1433 1434 udelay(1); 1435 1436 val = pll_readl(SATA_PLL_CFG0, pll); 1437 val |= SATA_PLL_CFG0_SEQ_ENABLE; 1438 pll_writel(val, SATA_PLL_CFG0, pll); 1439 1440 out: 1441 if (pll->lock) 1442 spin_unlock_irqrestore(pll->lock, flags); 1443 1444 return ret; 1445 } 1446 1447 static void clk_plle_tegra114_disable(struct clk_hw *hw) 1448 { 1449 struct tegra_clk_pll *pll = to_clk_pll(hw); 1450 unsigned long flags = 0; 1451 u32 val; 1452 1453 if (pll->lock) 1454 spin_lock_irqsave(pll->lock, flags); 1455 1456 _clk_pll_disable(hw); 1457 1458 val = pll_readl_misc(pll); 1459 val |= PLLE_MISC_IDDQ_SW_CTRL | PLLE_MISC_IDDQ_SW_VALUE; 1460 pll_writel_misc(val, pll); 1461 udelay(1); 1462 1463 if (pll->lock) 1464 spin_unlock_irqrestore(pll->lock, flags); 1465 } 1466 #endif 1467 1468 static struct tegra_clk_pll *_tegra_init_pll(void __iomem *clk_base, 1469 void __iomem *pmc, struct tegra_clk_pll_params *pll_params, 1470 spinlock_t *lock) 1471 { 1472 struct tegra_clk_pll *pll; 1473 1474 pll = kzalloc(sizeof(*pll), GFP_KERNEL); 1475 if (!pll) 1476 return ERR_PTR(-ENOMEM); 1477 1478 pll->clk_base = clk_base; 1479 pll->pmc = pmc; 1480 1481 pll->params = pll_params; 1482 pll->lock = lock; 1483 1484 if (!pll_params->div_nmp) 1485 pll_params->div_nmp = &default_nmp; 1486 1487 return pll; 1488 } 1489 1490 static struct clk *_tegra_clk_register_pll(struct tegra_clk_pll *pll, 1491 const char *name, const char *parent_name, unsigned long flags, 1492 const struct clk_ops *ops) 1493 { 1494 struct clk_init_data init; 1495 1496 init.name = name; 1497 init.ops = ops; 1498 init.flags = flags; 1499 init.parent_names = (parent_name ? &parent_name : NULL); 1500 init.num_parents = (parent_name ? 1 : 0); 1501 1502 /* Default to _calc_rate if unspecified */ 1503 if (!pll->params->calc_rate) 1504 pll->params->calc_rate = _calc_rate; 1505 1506 /* Data in .init is copied by clk_register(), so stack variable OK */ 1507 pll->hw.init = &init; 1508 1509 return clk_register(NULL, &pll->hw); 1510 } 1511 1512 struct clk *tegra_clk_register_pll(const char *name, const char *parent_name, 1513 void __iomem *clk_base, void __iomem *pmc, 1514 unsigned long flags, struct tegra_clk_pll_params *pll_params, 1515 spinlock_t *lock) 1516 { 1517 struct tegra_clk_pll *pll; 1518 struct clk *clk; 1519 1520 pll_params->flags |= TEGRA_PLL_BYPASS; 1521 1522 pll = _tegra_init_pll(clk_base, pmc, pll_params, lock); 1523 if (IS_ERR(pll)) 1524 return ERR_CAST(pll); 1525 1526 clk = _tegra_clk_register_pll(pll, name, parent_name, flags, 1527 &tegra_clk_pll_ops); 1528 if (IS_ERR(clk)) 1529 kfree(pll); 1530 1531 return clk; 1532 } 1533 1534 static struct div_nmp pll_e_nmp = { 1535 .divn_shift = PLLE_BASE_DIVN_SHIFT, 1536 .divn_width = PLLE_BASE_DIVN_WIDTH, 1537 .divm_shift = PLLE_BASE_DIVM_SHIFT, 1538 .divm_width = PLLE_BASE_DIVM_WIDTH, 1539 .divp_shift = PLLE_BASE_DIVP_SHIFT, 1540 .divp_width = PLLE_BASE_DIVP_WIDTH, 1541 }; 1542 1543 struct clk *tegra_clk_register_plle(const char *name, const char *parent_name, 1544 void __iomem *clk_base, void __iomem *pmc, 1545 unsigned long flags, struct tegra_clk_pll_params *pll_params, 1546 spinlock_t *lock) 1547 { 1548 struct tegra_clk_pll *pll; 1549 struct clk *clk; 1550 1551 pll_params->flags |= TEGRA_PLL_BYPASS; 1552 1553 if (!pll_params->div_nmp) 1554 pll_params->div_nmp = &pll_e_nmp; 1555 1556 pll = _tegra_init_pll(clk_base, pmc, pll_params, lock); 1557 if (IS_ERR(pll)) 1558 return ERR_CAST(pll); 1559 1560 clk = _tegra_clk_register_pll(pll, name, parent_name, flags, 1561 &tegra_clk_plle_ops); 1562 if (IS_ERR(clk)) 1563 kfree(pll); 1564 1565 return clk; 1566 } 1567 1568 #if defined(CONFIG_ARCH_TEGRA_114_SOC) || \ 1569 defined(CONFIG_ARCH_TEGRA_124_SOC) || \ 1570 defined(CONFIG_ARCH_TEGRA_132_SOC) 1571 static const struct clk_ops tegra_clk_pllxc_ops = { 1572 .is_enabled = clk_pll_is_enabled, 1573 .enable = clk_pll_enable, 1574 .disable = clk_pll_disable, 1575 .recalc_rate = clk_pll_recalc_rate, 1576 .round_rate = clk_pll_ramp_round_rate, 1577 .set_rate = clk_pllxc_set_rate, 1578 }; 1579 1580 static const struct clk_ops tegra_clk_pllm_ops = { 1581 .is_enabled = clk_pll_is_enabled, 1582 .enable = clk_pll_enable, 1583 .disable = clk_pll_disable, 1584 .recalc_rate = clk_pll_recalc_rate, 1585 .round_rate = clk_pll_ramp_round_rate, 1586 .set_rate = clk_pllm_set_rate, 1587 }; 1588 1589 static const struct clk_ops tegra_clk_pllc_ops = { 1590 .is_enabled = clk_pll_is_enabled, 1591 .enable = clk_pllc_enable, 1592 .disable = clk_pllc_disable, 1593 .recalc_rate = clk_pll_recalc_rate, 1594 .round_rate = clk_pll_ramp_round_rate, 1595 .set_rate = clk_pllc_set_rate, 1596 }; 1597 1598 static const struct clk_ops tegra_clk_pllre_ops = { 1599 .is_enabled = clk_pll_is_enabled, 1600 .enable = clk_pll_enable, 1601 .disable = clk_pll_disable, 1602 .recalc_rate = clk_pllre_recalc_rate, 1603 .round_rate = clk_pllre_round_rate, 1604 .set_rate = clk_pllre_set_rate, 1605 }; 1606 1607 static const struct clk_ops tegra_clk_plle_tegra114_ops = { 1608 .is_enabled = clk_pll_is_enabled, 1609 .enable = clk_plle_tegra114_enable, 1610 .disable = clk_plle_tegra114_disable, 1611 .recalc_rate = clk_pll_recalc_rate, 1612 }; 1613 1614 1615 struct clk *tegra_clk_register_pllxc(const char *name, const char *parent_name, 1616 void __iomem *clk_base, void __iomem *pmc, 1617 unsigned long flags, 1618 struct tegra_clk_pll_params *pll_params, 1619 spinlock_t *lock) 1620 { 1621 struct tegra_clk_pll *pll; 1622 struct clk *clk, *parent; 1623 unsigned long parent_rate; 1624 int err; 1625 u32 val, val_iddq; 1626 1627 parent = __clk_lookup(parent_name); 1628 if (!parent) { 1629 WARN(1, "parent clk %s of %s must be registered first\n", 1630 parent_name, name); 1631 return ERR_PTR(-EINVAL); 1632 } 1633 1634 if (!pll_params->pdiv_tohw) 1635 return ERR_PTR(-EINVAL); 1636 1637 parent_rate = clk_get_rate(parent); 1638 1639 pll_params->vco_min = _clip_vco_min(pll_params->vco_min, parent_rate); 1640 1641 err = _setup_dynamic_ramp(pll_params, clk_base, parent_rate); 1642 if (err) 1643 return ERR_PTR(err); 1644 1645 val = readl_relaxed(clk_base + pll_params->base_reg); 1646 val_iddq = readl_relaxed(clk_base + pll_params->iddq_reg); 1647 1648 if (val & PLL_BASE_ENABLE) 1649 WARN_ON(val_iddq & BIT(pll_params->iddq_bit_idx)); 1650 else { 1651 val_iddq |= BIT(pll_params->iddq_bit_idx); 1652 writel_relaxed(val_iddq, clk_base + pll_params->iddq_reg); 1653 } 1654 1655 pll = _tegra_init_pll(clk_base, pmc, pll_params, lock); 1656 if (IS_ERR(pll)) 1657 return ERR_CAST(pll); 1658 1659 clk = _tegra_clk_register_pll(pll, name, parent_name, flags, 1660 &tegra_clk_pllxc_ops); 1661 if (IS_ERR(clk)) 1662 kfree(pll); 1663 1664 return clk; 1665 } 1666 1667 struct clk *tegra_clk_register_pllre(const char *name, const char *parent_name, 1668 void __iomem *clk_base, void __iomem *pmc, 1669 unsigned long flags, 1670 struct tegra_clk_pll_params *pll_params, 1671 spinlock_t *lock, unsigned long parent_rate) 1672 { 1673 u32 val; 1674 struct tegra_clk_pll *pll; 1675 struct clk *clk; 1676 1677 pll_params->vco_min = _clip_vco_min(pll_params->vco_min, parent_rate); 1678 1679 pll = _tegra_init_pll(clk_base, pmc, pll_params, lock); 1680 if (IS_ERR(pll)) 1681 return ERR_CAST(pll); 1682 1683 /* program minimum rate by default */ 1684 1685 val = pll_readl_base(pll); 1686 if (val & PLL_BASE_ENABLE) 1687 WARN_ON(val & pll_params->iddq_bit_idx); 1688 else { 1689 int m; 1690 1691 m = _pll_fixed_mdiv(pll_params, parent_rate); 1692 val = m << divm_shift(pll); 1693 val |= (pll_params->vco_min / parent_rate) << divn_shift(pll); 1694 pll_writel_base(val, pll); 1695 } 1696 1697 /* disable lock override */ 1698 1699 val = pll_readl_misc(pll); 1700 val &= ~BIT(29); 1701 pll_writel_misc(val, pll); 1702 1703 clk = _tegra_clk_register_pll(pll, name, parent_name, flags, 1704 &tegra_clk_pllre_ops); 1705 if (IS_ERR(clk)) 1706 kfree(pll); 1707 1708 return clk; 1709 } 1710 1711 struct clk *tegra_clk_register_pllm(const char *name, const char *parent_name, 1712 void __iomem *clk_base, void __iomem *pmc, 1713 unsigned long flags, 1714 struct tegra_clk_pll_params *pll_params, 1715 spinlock_t *lock) 1716 { 1717 struct tegra_clk_pll *pll; 1718 struct clk *clk, *parent; 1719 unsigned long parent_rate; 1720 1721 if (!pll_params->pdiv_tohw) 1722 return ERR_PTR(-EINVAL); 1723 1724 parent = __clk_lookup(parent_name); 1725 if (!parent) { 1726 WARN(1, "parent clk %s of %s must be registered first\n", 1727 parent_name, name); 1728 return ERR_PTR(-EINVAL); 1729 } 1730 1731 parent_rate = clk_get_rate(parent); 1732 1733 pll_params->vco_min = _clip_vco_min(pll_params->vco_min, parent_rate); 1734 1735 pll_params->flags |= TEGRA_PLL_BYPASS; 1736 pll_params->flags |= TEGRA_PLLM; 1737 pll = _tegra_init_pll(clk_base, pmc, pll_params, lock); 1738 if (IS_ERR(pll)) 1739 return ERR_CAST(pll); 1740 1741 clk = _tegra_clk_register_pll(pll, name, parent_name, flags, 1742 &tegra_clk_pllm_ops); 1743 if (IS_ERR(clk)) 1744 kfree(pll); 1745 1746 return clk; 1747 } 1748 1749 struct clk *tegra_clk_register_pllc(const char *name, const char *parent_name, 1750 void __iomem *clk_base, void __iomem *pmc, 1751 unsigned long flags, 1752 struct tegra_clk_pll_params *pll_params, 1753 spinlock_t *lock) 1754 { 1755 struct clk *parent, *clk; 1756 const struct pdiv_map *p_tohw = pll_params->pdiv_tohw; 1757 struct tegra_clk_pll *pll; 1758 struct tegra_clk_pll_freq_table cfg; 1759 unsigned long parent_rate; 1760 1761 if (!p_tohw) 1762 return ERR_PTR(-EINVAL); 1763 1764 parent = __clk_lookup(parent_name); 1765 if (!parent) { 1766 WARN(1, "parent clk %s of %s must be registered first\n", 1767 parent_name, name); 1768 return ERR_PTR(-EINVAL); 1769 } 1770 1771 parent_rate = clk_get_rate(parent); 1772 1773 pll_params->vco_min = _clip_vco_min(pll_params->vco_min, parent_rate); 1774 1775 pll_params->flags |= TEGRA_PLL_BYPASS; 1776 pll = _tegra_init_pll(clk_base, pmc, pll_params, lock); 1777 if (IS_ERR(pll)) 1778 return ERR_CAST(pll); 1779 1780 /* 1781 * Most of PLLC register fields are shadowed, and can not be read 1782 * directly from PLL h/w. Hence, actual PLLC boot state is unknown. 1783 * Initialize PLL to default state: disabled, reset; shadow registers 1784 * loaded with default parameters; dividers are preset for half of 1785 * minimum VCO rate (the latter assured that shadowed divider settings 1786 * are within supported range). 1787 */ 1788 1789 cfg.m = _pll_fixed_mdiv(pll_params, parent_rate); 1790 cfg.n = cfg.m * pll_params->vco_min / parent_rate; 1791 1792 while (p_tohw->pdiv) { 1793 if (p_tohw->pdiv == 2) { 1794 cfg.p = p_tohw->hw_val; 1795 break; 1796 } 1797 p_tohw++; 1798 } 1799 1800 if (!p_tohw->pdiv) { 1801 WARN_ON(1); 1802 return ERR_PTR(-EINVAL); 1803 } 1804 1805 pll_writel_base(0, pll); 1806 _update_pll_mnp(pll, &cfg); 1807 1808 pll_writel_misc(PLLCX_MISC_DEFAULT, pll); 1809 pll_writel(PLLCX_MISC1_DEFAULT, pll_params->ext_misc_reg[0], pll); 1810 pll_writel(PLLCX_MISC2_DEFAULT, pll_params->ext_misc_reg[1], pll); 1811 pll_writel(PLLCX_MISC3_DEFAULT, pll_params->ext_misc_reg[2], pll); 1812 1813 _pllcx_update_dynamic_coef(pll, parent_rate, cfg.n); 1814 1815 clk = _tegra_clk_register_pll(pll, name, parent_name, flags, 1816 &tegra_clk_pllc_ops); 1817 if (IS_ERR(clk)) 1818 kfree(pll); 1819 1820 return clk; 1821 } 1822 1823 struct clk *tegra_clk_register_plle_tegra114(const char *name, 1824 const char *parent_name, 1825 void __iomem *clk_base, unsigned long flags, 1826 struct tegra_clk_pll_params *pll_params, 1827 spinlock_t *lock) 1828 { 1829 struct tegra_clk_pll *pll; 1830 struct clk *clk; 1831 u32 val, val_aux; 1832 1833 pll = _tegra_init_pll(clk_base, NULL, pll_params, lock); 1834 if (IS_ERR(pll)) 1835 return ERR_CAST(pll); 1836 1837 /* ensure parent is set to pll_re_vco */ 1838 1839 val = pll_readl_base(pll); 1840 val_aux = pll_readl(pll_params->aux_reg, pll); 1841 1842 if (val & PLL_BASE_ENABLE) { 1843 if ((val_aux & PLLE_AUX_PLLRE_SEL) || 1844 (val_aux & PLLE_AUX_PLLP_SEL)) 1845 WARN(1, "pll_e enabled with unsupported parent %s\n", 1846 (val_aux & PLLE_AUX_PLLP_SEL) ? "pllp_out0" : 1847 "pll_re_vco"); 1848 } else { 1849 val_aux &= ~(PLLE_AUX_PLLRE_SEL | PLLE_AUX_PLLP_SEL); 1850 pll_writel(val_aux, pll_params->aux_reg, pll); 1851 } 1852 1853 clk = _tegra_clk_register_pll(pll, name, parent_name, flags, 1854 &tegra_clk_plle_tegra114_ops); 1855 if (IS_ERR(clk)) 1856 kfree(pll); 1857 1858 return clk; 1859 } 1860 #endif 1861 1862 #if defined(CONFIG_ARCH_TEGRA_124_SOC) || defined(CONFIG_ARCH_TEGRA_132_SOC) 1863 static const struct clk_ops tegra_clk_pllss_ops = { 1864 .is_enabled = clk_pll_is_enabled, 1865 .enable = clk_pll_enable, 1866 .disable = clk_pll_disable, 1867 .recalc_rate = clk_pll_recalc_rate, 1868 .round_rate = clk_pll_ramp_round_rate, 1869 .set_rate = clk_pllxc_set_rate, 1870 }; 1871 1872 struct clk *tegra_clk_register_pllss(const char *name, const char *parent_name, 1873 void __iomem *clk_base, unsigned long flags, 1874 struct tegra_clk_pll_params *pll_params, 1875 spinlock_t *lock) 1876 { 1877 struct tegra_clk_pll *pll; 1878 struct clk *clk, *parent; 1879 struct tegra_clk_pll_freq_table cfg; 1880 unsigned long parent_rate; 1881 u32 val; 1882 int i; 1883 1884 if (!pll_params->div_nmp) 1885 return ERR_PTR(-EINVAL); 1886 1887 parent = __clk_lookup(parent_name); 1888 if (!parent) { 1889 WARN(1, "parent clk %s of %s must be registered first\n", 1890 parent_name, name); 1891 return ERR_PTR(-EINVAL); 1892 } 1893 1894 pll = _tegra_init_pll(clk_base, NULL, pll_params, lock); 1895 if (IS_ERR(pll)) 1896 return ERR_CAST(pll); 1897 1898 val = pll_readl_base(pll); 1899 val &= ~PLLSS_REF_SRC_SEL_MASK; 1900 pll_writel_base(val, pll); 1901 1902 parent_rate = clk_get_rate(parent); 1903 1904 pll_params->vco_min = _clip_vco_min(pll_params->vco_min, parent_rate); 1905 1906 /* initialize PLL to minimum rate */ 1907 1908 cfg.m = _pll_fixed_mdiv(pll_params, parent_rate); 1909 cfg.n = cfg.m * pll_params->vco_min / parent_rate; 1910 1911 for (i = 0; pll_params->pdiv_tohw[i].pdiv; i++) 1912 ; 1913 if (!i) { 1914 kfree(pll); 1915 return ERR_PTR(-EINVAL); 1916 } 1917 1918 cfg.p = pll_params->pdiv_tohw[i-1].hw_val; 1919 1920 _update_pll_mnp(pll, &cfg); 1921 1922 pll_writel_misc(PLLSS_MISC_DEFAULT, pll); 1923 pll_writel(PLLSS_CFG_DEFAULT, pll_params->ext_misc_reg[0], pll); 1924 pll_writel(PLLSS_CTRL1_DEFAULT, pll_params->ext_misc_reg[1], pll); 1925 pll_writel(PLLSS_CTRL1_DEFAULT, pll_params->ext_misc_reg[2], pll); 1926 1927 val = pll_readl_base(pll); 1928 if (val & PLL_BASE_ENABLE) { 1929 if (val & BIT(pll_params->iddq_bit_idx)) { 1930 WARN(1, "%s is on but IDDQ set\n", name); 1931 kfree(pll); 1932 return ERR_PTR(-EINVAL); 1933 } 1934 } else 1935 val |= BIT(pll_params->iddq_bit_idx); 1936 1937 val &= ~PLLSS_LOCK_OVERRIDE; 1938 pll_writel_base(val, pll); 1939 1940 clk = _tegra_clk_register_pll(pll, name, parent_name, flags, 1941 &tegra_clk_pllss_ops); 1942 1943 if (IS_ERR(clk)) 1944 kfree(pll); 1945 1946 return clk; 1947 } 1948 #endif 1949