1 // SPDX-License-Identifier: GPL-2.0
3 * (C) Copyright 2017-2019 Rockchip Electronics Co., Ltd
7 #include <clk-uclass.h>
14 #include <asm/arch/cru_rk3308.h>
15 #include <asm/arch-rockchip/clock.h>
16 #include <asm/arch-rockchip/hardware.h>
18 #include <dt-bindings/clock/rk3308-cru.h>
20 DECLARE_GLOBAL_DATA_PTR;
23 VCO_MAX_HZ = 3200U * 1000000,
24 VCO_MIN_HZ = 800 * 1000000,
25 OUTPUT_MAX_HZ = 3200U * 1000000,
26 OUTPUT_MIN_HZ = 24 * 1000000,
29 #define DIV_TO_RATE(input_rate, div) ((input_rate) / ((div) + 1))
31 #define RK3308_CPUCLK_RATE(_rate, _aclk_div, _pclk_div) \
34 .aclk_div = _aclk_div, \
35 .pclk_div = _pclk_div, \
38 static struct rockchip_pll_rate_table rk3308_pll_rates[] = {
39 /* _mhz, _refdiv, _fbdiv, _postdiv1, _postdiv2, _dsmpd, _frac */
40 RK3036_PLL_RATE(1300000000, 6, 325, 1, 1, 1, 0),
41 RK3036_PLL_RATE(1200000000, 1, 50, 1, 1, 1, 0),
42 RK3036_PLL_RATE(816000000, 1, 68, 2, 1, 1, 0),
43 RK3036_PLL_RATE(748000000, 2, 187, 3, 1, 1, 0),
46 static struct rockchip_cpu_rate_table rk3308_cpu_rates[] = {
47 RK3308_CPUCLK_RATE(1200000000, 1, 5),
48 RK3308_CPUCLK_RATE(1008000000, 1, 5),
49 RK3308_CPUCLK_RATE(816000000, 1, 3),
50 RK3308_CPUCLK_RATE(600000000, 1, 3),
51 RK3308_CPUCLK_RATE(408000000, 1, 1),
54 static struct rockchip_pll_clock rk3308_pll_clks[] = {
55 [APLL] = PLL(pll_rk3328, PLL_APLL, RK3308_PLL_CON(0),
56 RK3308_MODE_CON, 0, 10, 0, rk3308_pll_rates),
57 [DPLL] = PLL(pll_rk3328, PLL_DPLL, RK3308_PLL_CON(8),
58 RK3308_MODE_CON, 2, 10, 0, NULL),
59 [VPLL0] = PLL(pll_rk3328, PLL_VPLL0, RK3308_PLL_CON(16),
60 RK3308_MODE_CON, 4, 10, 0, NULL),
61 [VPLL1] = PLL(pll_rk3328, PLL_VPLL1, RK3308_PLL_CON(24),
62 RK3308_MODE_CON, 6, 10, 0, NULL),
65 static ulong rk3308_armclk_set_clk(struct rk3308_clk_priv *priv, ulong hz)
67 struct rk3308_cru *cru = priv->cru;
68 const struct rockchip_cpu_rate_table *rate;
71 rate = rockchip_get_cpu_settings(rk3308_cpu_rates, hz);
73 printf("%s unsupport rate\n", __func__);
78 * select apll as cpu/core clock pll source and
79 * set up dependent divisors for PERI and ACLK clocks.
80 * core hz : apll = 1:1
82 old_rate = rockchip_pll_get_rate(&rk3308_pll_clks[APLL],
85 if (rockchip_pll_set_rate(&rk3308_pll_clks[APLL],
88 rk_clrsetreg(&cru->clksel_con[0],
89 CORE_CLK_PLL_SEL_MASK | CORE_DIV_CON_MASK |
90 CORE_ACLK_DIV_MASK | CORE_DBG_DIV_MASK,
91 rate->aclk_div << CORE_ACLK_DIV_SHIFT |
92 rate->pclk_div << CORE_DBG_DIV_SHIFT |
93 CORE_CLK_PLL_SEL_APLL << CORE_CLK_PLL_SEL_SHIFT |
94 0 << CORE_DIV_CON_SHIFT);
95 } else if (old_rate < hz) {
96 rk_clrsetreg(&cru->clksel_con[0],
97 CORE_CLK_PLL_SEL_MASK | CORE_DIV_CON_MASK |
98 CORE_ACLK_DIV_MASK | CORE_DBG_DIV_MASK,
99 rate->aclk_div << CORE_ACLK_DIV_SHIFT |
100 rate->pclk_div << CORE_DBG_DIV_SHIFT |
101 CORE_CLK_PLL_SEL_APLL << CORE_CLK_PLL_SEL_SHIFT |
102 0 << CORE_DIV_CON_SHIFT);
103 if (rockchip_pll_set_rate(&rk3308_pll_clks[APLL],
104 priv->cru, APLL, hz))
108 return rockchip_pll_get_rate(&rk3308_pll_clks[APLL], priv->cru, APLL);
111 static void rk3308_clk_get_pll_rate(struct rk3308_clk_priv *priv)
114 priv->dpll_hz = rockchip_pll_get_rate(&rk3308_pll_clks[DPLL],
117 priv->vpll0_hz = rockchip_pll_get_rate(&rk3308_pll_clks[VPLL0],
120 priv->vpll1_hz = rockchip_pll_get_rate(&rk3308_pll_clks[VPLL1],
124 static ulong rk3308_i2c_get_clk(struct clk *clk)
126 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
127 struct rk3308_cru *cru = priv->cru;
128 u32 div, con, con_id;
144 printf("do not support this i2c bus\n");
148 con = readl(&cru->clksel_con[con_id]);
149 div = con >> CLK_I2C_DIV_CON_SHIFT & CLK_I2C_DIV_CON_MASK;
151 return DIV_TO_RATE(priv->dpll_hz, div);
154 static ulong rk3308_i2c_set_clk(struct clk *clk, uint hz)
156 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
157 struct rk3308_cru *cru = priv->cru;
158 u32 src_clk_div, con_id;
160 src_clk_div = DIV_ROUND_UP(priv->dpll_hz, hz);
161 assert(src_clk_div - 1 <= 127);
177 printf("do not support this i2c bus\n");
180 rk_clrsetreg(&cru->clksel_con[con_id],
181 CLK_I2C_PLL_SEL_MASK | CLK_I2C_DIV_CON_MASK,
182 CLK_I2C_PLL_SEL_DPLL << CLK_I2C_PLL_SEL_SHIFT |
183 (src_clk_div - 1) << CLK_I2C_DIV_CON_SHIFT);
185 return rk3308_i2c_get_clk(clk);
188 static ulong rk3308_mac_set_clk(struct clk *clk, uint hz)
190 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
191 struct rk3308_cru *cru = priv->cru;
192 u32 con = readl(&cru->clksel_con[43]);
196 if ((con >> MAC_PLL_SHIFT) & MAC_SEL_VPLL0)
197 pll_rate = rockchip_pll_get_rate(&rk3308_pll_clks[VPLL0],
199 else if ((con >> MAC_PLL_SHIFT) & MAC_SEL_VPLL1)
200 pll_rate = rockchip_pll_get_rate(&rk3308_pll_clks[VPLL1],
203 pll_rate = rockchip_pll_get_rate(&rk3308_pll_clks[DPLL],
206 /*default set 50MHZ for gmac*/
210 div = DIV_ROUND_UP(pll_rate, hz) - 1;
212 rk_clrsetreg(&cru->clksel_con[43], MAC_DIV_MASK,
213 div << MAC_DIV_SHIFT);
215 return DIV_TO_RATE(pll_rate, div);
218 static int rk3308_mac_set_speed_clk(struct clk *clk, uint hz)
220 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
221 struct rk3308_cru *cru = priv->cru;
223 if (hz != 2500000 && hz != 25000000) {
224 debug("Unsupported mac speed:%d\n", hz);
228 rk_clrsetreg(&cru->clksel_con[43], MAC_CLK_SPEED_SEL_MASK,
229 ((hz == 2500000) ? 0 : 1) << MAC_CLK_SPEED_SEL_SHIFT);
234 static ulong rk3308_mmc_get_clk(struct clk *clk)
236 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
237 struct rk3308_cru *cru = priv->cru;
238 u32 div, con, con_id;
247 case SCLK_EMMC_SAMPLE:
254 con = readl(&cru->clksel_con[con_id]);
255 div = (con & EMMC_DIV_MASK) >> EMMC_DIV_SHIFT;
257 if ((con & EMMC_PLL_MASK) >> EMMC_PLL_SHIFT
259 return DIV_TO_RATE(OSC_HZ, div) / 2;
261 return DIV_TO_RATE(priv->vpll0_hz, div) / 2;
264 static ulong rk3308_mmc_set_clk(struct clk *clk, ulong set_rate)
266 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
267 struct rk3308_cru *cru = priv->cru;
283 /* Select clk_sdmmc/emmc source from VPLL0 by default */
284 /* mmc clock defaulg div 2 internal, need provide double in cru */
285 src_clk_div = DIV_ROUND_UP(priv->vpll0_hz / 2, set_rate);
287 if (src_clk_div > 127) {
288 /* use 24MHz source for 400KHz clock */
289 src_clk_div = DIV_ROUND_UP(OSC_HZ / 2, set_rate);
290 rk_clrsetreg(&cru->clksel_con[con_id],
291 EMMC_PLL_MASK | EMMC_DIV_MASK | EMMC_CLK_SEL_MASK,
292 EMMC_CLK_SEL_EMMC << EMMC_CLK_SEL_SHIFT |
293 EMMC_SEL_24M << EMMC_PLL_SHIFT |
294 (src_clk_div - 1) << EMMC_DIV_SHIFT);
296 rk_clrsetreg(&cru->clksel_con[con_id],
297 EMMC_PLL_MASK | EMMC_DIV_MASK | EMMC_CLK_SEL_MASK,
298 EMMC_CLK_SEL_EMMC << EMMC_CLK_SEL_SHIFT |
299 EMMC_SEL_VPLL0 << EMMC_PLL_SHIFT |
300 (src_clk_div - 1) << EMMC_DIV_SHIFT);
303 return rk3308_mmc_get_clk(clk);
306 static ulong rk3308_saradc_get_clk(struct clk *clk)
308 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
309 struct rk3308_cru *cru = priv->cru;
312 con = readl(&cru->clksel_con[34]);
313 div = con >> CLK_SARADC_DIV_CON_SHIFT & CLK_SARADC_DIV_CON_MASK;
315 return DIV_TO_RATE(OSC_HZ, div);
318 static ulong rk3308_saradc_set_clk(struct clk *clk, uint hz)
320 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
321 struct rk3308_cru *cru = priv->cru;
324 src_clk_div = DIV_ROUND_UP(OSC_HZ, hz);
325 assert(src_clk_div - 1 <= 2047);
327 rk_clrsetreg(&cru->clksel_con[34],
328 CLK_SARADC_DIV_CON_MASK,
329 (src_clk_div - 1) << CLK_SARADC_DIV_CON_SHIFT);
331 return rk3308_saradc_get_clk(clk);
334 static ulong rk3308_tsadc_get_clk(struct clk *clk)
336 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
337 struct rk3308_cru *cru = priv->cru;
340 con = readl(&cru->clksel_con[33]);
341 div = con >> CLK_SARADC_DIV_CON_SHIFT & CLK_SARADC_DIV_CON_MASK;
343 return DIV_TO_RATE(OSC_HZ, div);
346 static ulong rk3308_tsadc_set_clk(struct clk *clk, uint hz)
348 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
349 struct rk3308_cru *cru = priv->cru;
352 src_clk_div = DIV_ROUND_UP(OSC_HZ, hz);
353 assert(src_clk_div - 1 <= 2047);
355 rk_clrsetreg(&cru->clksel_con[33],
356 CLK_SARADC_DIV_CON_MASK,
357 (src_clk_div - 1) << CLK_SARADC_DIV_CON_SHIFT);
359 return rk3308_tsadc_get_clk(clk);
362 static ulong rk3308_spi_get_clk(struct clk *clk)
364 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
365 struct rk3308_cru *cru = priv->cru;
366 u32 div, con, con_id;
379 printf("do not support this spi bus\n");
383 con = readl(&cru->clksel_con[con_id]);
384 div = con >> CLK_SPI_DIV_CON_SHIFT & CLK_SPI_DIV_CON_MASK;
386 return DIV_TO_RATE(priv->dpll_hz, div);
389 static ulong rk3308_spi_set_clk(struct clk *clk, uint hz)
391 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
392 struct rk3308_cru *cru = priv->cru;
393 u32 src_clk_div, con_id;
395 src_clk_div = DIV_ROUND_UP(priv->dpll_hz, hz);
396 assert(src_clk_div - 1 <= 127);
409 printf("do not support this spi bus\n");
413 rk_clrsetreg(&cru->clksel_con[con_id],
414 CLK_SPI_PLL_SEL_MASK | CLK_SPI_DIV_CON_MASK,
415 CLK_SPI_PLL_SEL_DPLL << CLK_SPI_PLL_SEL_SHIFT |
416 (src_clk_div - 1) << CLK_SPI_DIV_CON_SHIFT);
418 return rk3308_spi_get_clk(clk);
421 static ulong rk3308_pwm_get_clk(struct clk *clk)
423 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
424 struct rk3308_cru *cru = priv->cru;
427 con = readl(&cru->clksel_con[29]);
428 div = con >> CLK_PWM_DIV_CON_SHIFT & CLK_PWM_DIV_CON_MASK;
430 return DIV_TO_RATE(priv->dpll_hz, div);
433 static ulong rk3308_pwm_set_clk(struct clk *clk, uint hz)
435 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
436 struct rk3308_cru *cru = priv->cru;
439 src_clk_div = DIV_ROUND_UP(priv->dpll_hz, hz);
440 assert(src_clk_div - 1 <= 127);
442 rk_clrsetreg(&cru->clksel_con[29],
443 CLK_PWM_PLL_SEL_MASK | CLK_PWM_DIV_CON_MASK,
444 CLK_PWM_PLL_SEL_DPLL << CLK_PWM_PLL_SEL_SHIFT |
445 (src_clk_div - 1) << CLK_PWM_DIV_CON_SHIFT);
447 return rk3308_pwm_get_clk(clk);
450 static ulong rk3308_vop_get_clk(struct clk *clk)
452 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
453 struct rk3308_cru *cru = priv->cru;
454 u32 div, pll_sel, vol_sel, con, parent;
456 con = readl(&cru->clksel_con[8]);
457 vol_sel = (con & DCLK_VOP_SEL_MASK) >> DCLK_VOP_SEL_SHIFT;
458 pll_sel = (con & DCLK_VOP_PLL_SEL_MASK) >> DCLK_VOP_PLL_SEL_SHIFT;
459 div = con & DCLK_VOP_DIV_MASK;
461 if (vol_sel == DCLK_VOP_SEL_24M) {
463 } else if (vol_sel == DCLK_VOP_SEL_DIVOUT) {
465 case DCLK_VOP_PLL_SEL_DPLL:
466 parent = priv->dpll_hz;
468 case DCLK_VOP_PLL_SEL_VPLL0:
469 parent = priv->vpll0_hz;
471 case DCLK_VOP_PLL_SEL_VPLL1:
472 parent = priv->vpll0_hz;
475 printf("do not support this vop pll sel\n");
479 printf("do not support this vop sel\n");
483 return DIV_TO_RATE(parent, div);
486 static ulong rk3308_vop_set_clk(struct clk *clk, ulong hz)
488 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
489 struct rk3308_cru *cru = priv->cru;
490 ulong pll_rate, now, best_rate = 0;
491 u32 i, div, best_div = 0, best_sel = 0;
493 for (i = 0; i <= DCLK_VOP_PLL_SEL_VPLL1; i++) {
495 case DCLK_VOP_PLL_SEL_DPLL:
496 pll_rate = priv->dpll_hz;
498 case DCLK_VOP_PLL_SEL_VPLL0:
499 pll_rate = priv->vpll0_hz;
501 case DCLK_VOP_PLL_SEL_VPLL1:
502 pll_rate = priv->vpll1_hz;
505 printf("do not support this vop pll sel\n");
509 div = DIV_ROUND_UP(pll_rate, hz);
512 now = pll_rate / div;
513 if (abs(hz - now) < abs(hz - best_rate)) {
518 debug("pll_rate=%lu, best_rate=%lu, best_div=%u, best_sel=%u\n",
519 pll_rate, best_rate, best_div, best_sel);
522 if (best_rate != hz && hz == OSC_HZ) {
523 rk_clrsetreg(&cru->clksel_con[8],
525 DCLK_VOP_SEL_24M << DCLK_VOP_SEL_SHIFT);
526 } else if (best_rate) {
527 rk_clrsetreg(&cru->clksel_con[8],
528 DCLK_VOP_SEL_MASK | DCLK_VOP_PLL_SEL_MASK |
530 DCLK_VOP_SEL_DIVOUT << DCLK_VOP_SEL_SHIFT |
531 best_sel << DCLK_VOP_PLL_SEL_SHIFT |
532 (best_div - 1) << DCLK_VOP_DIV_SHIFT);
534 printf("do not support this vop freq\n");
538 return rk3308_vop_get_clk(clk);
541 static ulong rk3308_bus_get_clk(struct rk3308_clk_priv *priv, ulong clk_id)
543 struct rk3308_cru *cru = priv->cru;
544 u32 div, con, parent = priv->dpll_hz;
548 con = readl(&cru->clksel_con[5]);
549 div = (con & BUS_ACLK_DIV_MASK) >> BUS_ACLK_DIV_SHIFT;
552 con = readl(&cru->clksel_con[6]);
553 div = (con & BUS_HCLK_DIV_MASK) >> BUS_HCLK_DIV_SHIFT;
557 con = readl(&cru->clksel_con[6]);
558 div = (con & BUS_PCLK_DIV_MASK) >> BUS_PCLK_DIV_SHIFT;
564 return DIV_TO_RATE(parent, div);
567 static ulong rk3308_bus_set_clk(struct rk3308_clk_priv *priv, ulong clk_id,
570 struct rk3308_cru *cru = priv->cru;
573 src_clk_div = DIV_ROUND_UP(priv->dpll_hz, hz);
574 assert(src_clk_div - 1 <= 31);
577 * select dpll as pd_bus bus clock source and
578 * set up dependent divisors for PCLK/HCLK and ACLK clocks.
582 rk_clrsetreg(&cru->clksel_con[5],
583 BUS_PLL_SEL_MASK | BUS_ACLK_DIV_MASK,
584 BUS_PLL_SEL_DPLL << BUS_PLL_SEL_SHIFT |
585 (src_clk_div - 1) << BUS_ACLK_DIV_SHIFT);
588 rk_clrsetreg(&cru->clksel_con[6],
590 (src_clk_div - 1) << BUS_HCLK_DIV_SHIFT);
593 rk_clrsetreg(&cru->clksel_con[6],
595 (src_clk_div - 1) << BUS_PCLK_DIV_SHIFT);
598 printf("do not support this bus freq\n");
602 return rk3308_bus_get_clk(priv, clk_id);
605 static ulong rk3308_peri_get_clk(struct rk3308_clk_priv *priv, ulong clk_id)
607 struct rk3308_cru *cru = priv->cru;
608 u32 div, con, parent = priv->dpll_hz;
612 con = readl(&cru->clksel_con[36]);
613 div = (con & PERI_ACLK_DIV_MASK) >> PERI_ACLK_DIV_SHIFT;
616 con = readl(&cru->clksel_con[37]);
617 div = (con & PERI_HCLK_DIV_MASK) >> PERI_HCLK_DIV_SHIFT;
620 con = readl(&cru->clksel_con[37]);
621 div = (con & PERI_PCLK_DIV_MASK) >> PERI_PCLK_DIV_SHIFT;
627 return DIV_TO_RATE(parent, div);
630 static ulong rk3308_peri_set_clk(struct rk3308_clk_priv *priv, ulong clk_id,
633 struct rk3308_cru *cru = priv->cru;
636 src_clk_div = DIV_ROUND_UP(priv->dpll_hz, hz);
637 assert(src_clk_div - 1 <= 31);
640 * select dpll as pd_peri bus clock source and
641 * set up dependent divisors for PCLK/HCLK and ACLK clocks.
645 rk_clrsetreg(&cru->clksel_con[36],
646 PERI_PLL_SEL_MASK | PERI_ACLK_DIV_MASK,
647 PERI_PLL_DPLL << PERI_PLL_SEL_SHIFT |
648 (src_clk_div - 1) << PERI_ACLK_DIV_SHIFT);
651 rk_clrsetreg(&cru->clksel_con[37],
653 (src_clk_div - 1) << PERI_HCLK_DIV_SHIFT);
656 rk_clrsetreg(&cru->clksel_con[37],
658 (src_clk_div - 1) << PERI_PCLK_DIV_SHIFT);
661 printf("do not support this peri freq\n");
665 return rk3308_peri_get_clk(priv, clk_id);
668 static ulong rk3308_audio_get_clk(struct rk3308_clk_priv *priv, ulong clk_id)
670 struct rk3308_cru *cru = priv->cru;
671 u32 div, con, parent = priv->vpll0_hz;
675 con = readl(&cru->clksel_con[45]);
676 div = (con & AUDIO_HCLK_DIV_MASK) >> AUDIO_HCLK_DIV_SHIFT;
679 con = readl(&cru->clksel_con[45]);
680 div = (con & AUDIO_PCLK_DIV_MASK) >> AUDIO_PCLK_DIV_SHIFT;
686 return DIV_TO_RATE(parent, div);
689 static ulong rk3308_audio_set_clk(struct rk3308_clk_priv *priv, ulong clk_id,
692 struct rk3308_cru *cru = priv->cru;
695 src_clk_div = DIV_ROUND_UP(priv->vpll0_hz, hz);
696 assert(src_clk_div - 1 <= 31);
699 * select vpll0 as audio bus clock source and
700 * set up dependent divisors for HCLK and PCLK clocks.
704 rk_clrsetreg(&cru->clksel_con[45],
705 AUDIO_PLL_SEL_MASK | AUDIO_HCLK_DIV_MASK,
706 AUDIO_PLL_VPLL0 << AUDIO_PLL_SEL_SHIFT |
707 (src_clk_div - 1) << AUDIO_HCLK_DIV_SHIFT);
710 rk_clrsetreg(&cru->clksel_con[45],
711 AUDIO_PLL_SEL_MASK | AUDIO_PCLK_DIV_MASK,
712 AUDIO_PLL_VPLL0 << AUDIO_PLL_SEL_SHIFT |
713 (src_clk_div - 1) << AUDIO_PCLK_DIV_SHIFT);
716 printf("do not support this audio freq\n");
720 return rk3308_peri_get_clk(priv, clk_id);
723 static ulong rk3308_crypto_get_clk(struct rk3308_clk_priv *priv, ulong clk_id)
725 struct rk3308_cru *cru = priv->cru;
726 u32 div, con, parent;
730 con = readl(&cru->clksel_con[7]);
731 div = (con & CRYPTO_DIV_MASK) >> CRYPTO_DIV_SHIFT;
732 parent = priv->vpll0_hz;
734 case SCLK_CRYPTO_APK:
735 con = readl(&cru->clksel_con[7]);
736 div = (con & CRYPTO_APK_DIV_MASK) >> CRYPTO_APK_DIV_SHIFT;
737 parent = priv->vpll0_hz;
743 return DIV_TO_RATE(parent, div);
746 static ulong rk3308_crypto_set_clk(struct rk3308_clk_priv *priv, ulong clk_id,
749 struct rk3308_cru *cru = priv->cru;
752 src_clk_div = DIV_ROUND_UP(priv->vpll0_hz, hz);
753 assert(src_clk_div - 1 <= 31);
756 * select gpll as crypto clock source and
757 * set up dependent divisors for crypto clocks.
761 rk_clrsetreg(&cru->clksel_con[7],
762 CRYPTO_PLL_SEL_MASK | CRYPTO_DIV_MASK,
763 CRYPTO_PLL_SEL_VPLL0 << CRYPTO_PLL_SEL_SHIFT |
764 (src_clk_div - 1) << CRYPTO_DIV_SHIFT);
766 case SCLK_CRYPTO_APK:
767 rk_clrsetreg(&cru->clksel_con[7],
768 CRYPTO_APK_PLL_SEL_MASK | CRYPTO_APK_DIV_MASK,
769 CRYPTO_PLL_SEL_VPLL0 << CRYPTO_APK_SEL_SHIFT |
770 (src_clk_div - 1) << CRYPTO_APK_DIV_SHIFT);
773 printf("do not support this peri freq\n");
777 return rk3308_crypto_get_clk(priv, clk_id);
780 static ulong rk3308_clk_get_rate(struct clk *clk)
782 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
785 debug("%s id:%ld\n", __func__, clk->id);
790 rate = rockchip_pll_get_rate(&rk3308_pll_clks[APLL],
794 rate = rockchip_pll_get_rate(&rk3308_pll_clks[DPLL],
798 rate = rockchip_pll_get_rate(&rk3308_pll_clks[VPLL0],
802 rate = rockchip_pll_get_rate(&rk3308_pll_clks[VPLL1],
809 case SCLK_EMMC_SAMPLE:
810 rate = rk3308_mmc_get_clk(clk);
816 rate = rk3308_i2c_get_clk(clk);
819 rate = rk3308_saradc_get_clk(clk);
822 rate = rk3308_tsadc_get_clk(clk);
826 rate = rk3308_spi_get_clk(clk);
829 rate = rk3308_pwm_get_clk(clk);
832 rate = rk3308_vop_get_clk(clk);
838 rate = rk3308_bus_get_clk(priv, clk->id);
843 rate = rk3308_peri_get_clk(priv, clk->id);
847 rate = rk3308_audio_get_clk(priv, clk->id);
850 case SCLK_CRYPTO_APK:
851 rate = rk3308_crypto_get_clk(priv, clk->id);
860 static ulong rk3308_clk_set_rate(struct clk *clk, ulong rate)
862 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
865 debug("%s %ld %ld\n", __func__, clk->id, rate);
869 ret = rockchip_pll_set_rate(&rk3308_pll_clks[DPLL], priv->cru,
871 priv->dpll_hz = rockchip_pll_get_rate(&rk3308_pll_clks[DPLL],
876 rk3308_armclk_set_clk(priv, rate);
877 priv->armclk_hz = rate;
883 ret = rk3308_mmc_set_clk(clk, rate);
889 ret = rk3308_i2c_set_clk(clk, rate);
892 ret = rk3308_mac_set_clk(clk, rate);
895 ret = rk3308_mac_set_speed_clk(clk, rate);
898 ret = rk3308_saradc_set_clk(clk, rate);
901 ret = rk3308_tsadc_set_clk(clk, rate);
905 ret = rk3308_spi_set_clk(clk, rate);
908 ret = rk3308_pwm_set_clk(clk, rate);
911 ret = rk3308_vop_set_clk(clk, rate);
916 rate = rk3308_bus_set_clk(priv, clk->id, rate);
921 rate = rk3308_peri_set_clk(priv, clk->id, rate);
925 rate = rk3308_audio_set_clk(priv, clk->id, rate);
928 case SCLK_CRYPTO_APK:
929 ret = rk3308_crypto_set_clk(priv, clk->id, rate);
938 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
939 static int __maybe_unused rk3308_mac_set_parent(struct clk *clk, struct clk *parent)
941 struct rk3308_clk_priv *priv = dev_get_priv(clk->dev);
944 * If the requested parent is in the same clock-controller and
945 * the id is SCLK_MAC_SRC, switch to the internal clock.
947 if (parent->id == SCLK_MAC_SRC) {
948 debug("%s: switching RMII to SCLK_MAC\n", __func__);
949 rk_clrreg(&priv->cru->clksel_con[43], BIT(14));
951 debug("%s: switching RMII to CLKIN\n", __func__);
952 rk_setreg(&priv->cru->clksel_con[43], BIT(14));
958 static int __maybe_unused rk3308_clk_set_parent(struct clk *clk, struct clk *parent)
962 return rk3308_mac_set_parent(clk, parent);
967 debug("%s: unsupported clk %ld\n", __func__, clk->id);
972 static struct clk_ops rk3308_clk_ops = {
973 .get_rate = rk3308_clk_get_rate,
974 .set_rate = rk3308_clk_set_rate,
975 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
976 .set_parent = rk3308_clk_set_parent,
980 static void rk3308_clk_init(struct udevice *dev)
982 struct rk3308_clk_priv *priv = dev_get_priv(dev);
985 if (rockchip_pll_get_rate(&rk3308_pll_clks[APLL],
986 priv->cru, APLL) != APLL_HZ) {
987 ret = rk3308_armclk_set_clk(priv, APLL_HZ);
989 printf("%s failed to set armclk rate\n", __func__);
992 rk3308_clk_get_pll_rate(priv);
994 rk3308_bus_set_clk(priv, ACLK_BUS, BUS_ACLK_HZ);
995 rk3308_bus_set_clk(priv, HCLK_BUS, BUS_HCLK_HZ);
996 rk3308_bus_set_clk(priv, PCLK_BUS, BUS_PCLK_HZ);
998 rk3308_peri_set_clk(priv, ACLK_PERI, PERI_ACLK_HZ);
999 rk3308_peri_set_clk(priv, HCLK_PERI, PERI_HCLK_HZ);
1000 rk3308_peri_set_clk(priv, PCLK_PERI, PERI_PCLK_HZ);
1002 rk3308_audio_set_clk(priv, HCLK_AUDIO, AUDIO_HCLK_HZ);
1003 rk3308_audio_set_clk(priv, PCLK_AUDIO, AUDIO_PCLK_HZ);
1006 static int rk3308_clk_probe(struct udevice *dev)
1010 rk3308_clk_init(dev);
1012 /* Process 'assigned-{clocks/clock-parents/clock-rates}' properties */
1013 ret = clk_set_defaults(dev, 1);
1015 debug("%s clk_set_defaults failed %d\n", __func__, ret);
1020 static int rk3308_clk_ofdata_to_platdata(struct udevice *dev)
1022 struct rk3308_clk_priv *priv = dev_get_priv(dev);
1024 priv->cru = dev_read_addr_ptr(dev);
1029 static int rk3308_clk_bind(struct udevice *dev)
1032 struct udevice *sys_child;
1033 struct sysreset_reg *priv;
1035 /* The reset driver does not have a device node, so bind it here */
1036 ret = device_bind_driver(dev, "rockchip_sysreset", "sysreset",
1039 debug("Warning: No sysreset driver: ret=%d\n", ret);
1041 priv = malloc(sizeof(struct sysreset_reg));
1042 priv->glb_srst_fst_value = offsetof(struct rk3308_cru,
1044 priv->glb_srst_snd_value = offsetof(struct rk3308_cru,
1046 sys_child->priv = priv;
1049 #if CONFIG_IS_ENABLED(RESET_ROCKCHIP)
1050 ret = offsetof(struct rk3308_cru, softrst_con[0]);
1051 ret = rockchip_reset_bind(dev, ret, 12);
1053 debug("Warning: software reset driver bind faile\n");
1059 static const struct udevice_id rk3308_clk_ids[] = {
1060 { .compatible = "rockchip,rk3308-cru" },
1064 U_BOOT_DRIVER(rockchip_rk3308_cru) = {
1065 .name = "rockchip_rk3308_cru",
1067 .of_match = rk3308_clk_ids,
1068 .priv_auto_alloc_size = sizeof(struct rk3308_clk_priv),
1069 .ofdata_to_platdata = rk3308_clk_ofdata_to_platdata,
1070 .ops = &rk3308_clk_ops,
1071 .bind = rk3308_clk_bind,
1072 .probe = rk3308_clk_probe,