2 * Copyright (C) 2010 Samsung Electronics
3 * Minkyu Kang <mk7.kang@samsung.com>
5 * SPDX-License-Identifier: GPL-2.0+
10 #include <asm/arch/clock.h>
11 #include <asm/arch/clk.h>
12 #include <asm/arch/periph.h>
14 #define PLL_DIV_1024 1024
15 #define PLL_DIV_65535 65535
16 #define PLL_DIV_65536 65536
19 * This structure is to store the src bit, div bit and prediv bit
20 * positions of the peripheral clocks of the src and div registers
29 /* periph_id src_bit div_bit prediv_bit */
30 static struct clk_bit_info exynos5_bit_info[] = {
31 {PERIPH_ID_UART0, 0, 0, -1},
32 {PERIPH_ID_UART1, 4, 4, -1},
33 {PERIPH_ID_UART2, 8, 8, -1},
34 {PERIPH_ID_UART3, 12, 12, -1},
35 {PERIPH_ID_I2C0, -1, 24, 0},
36 {PERIPH_ID_I2C1, -1, 24, 0},
37 {PERIPH_ID_I2C2, -1, 24, 0},
38 {PERIPH_ID_I2C3, -1, 24, 0},
39 {PERIPH_ID_I2C4, -1, 24, 0},
40 {PERIPH_ID_I2C5, -1, 24, 0},
41 {PERIPH_ID_I2C6, -1, 24, 0},
42 {PERIPH_ID_I2C7, -1, 24, 0},
43 {PERIPH_ID_SPI0, 16, 0, 8},
44 {PERIPH_ID_SPI1, 20, 16, 24},
45 {PERIPH_ID_SPI2, 24, 0, 8},
46 {PERIPH_ID_SDMMC0, 0, 0, 8},
47 {PERIPH_ID_SDMMC1, 4, 16, 24},
48 {PERIPH_ID_SDMMC2, 8, 0, 8},
49 {PERIPH_ID_SDMMC3, 12, 16, 24},
50 {PERIPH_ID_I2S0, 0, 0, 4},
51 {PERIPH_ID_I2S1, 4, 12, 16},
52 {PERIPH_ID_SPI3, 0, 0, 4},
53 {PERIPH_ID_SPI4, 4, 12, 16},
54 {PERIPH_ID_SDMMC4, 16, 0, 8},
55 {PERIPH_ID_PWM0, 24, 0, -1},
56 {PERIPH_ID_PWM1, 24, 0, -1},
57 {PERIPH_ID_PWM2, 24, 0, -1},
58 {PERIPH_ID_PWM3, 24, 0, -1},
59 {PERIPH_ID_PWM4, 24, 0, -1},
61 {PERIPH_ID_NONE, -1, -1, -1},
64 static struct clk_bit_info exynos542x_bit_info[] = {
65 {PERIPH_ID_UART0, 4, 8, -1},
66 {PERIPH_ID_UART1, 8, 12, -1},
67 {PERIPH_ID_UART2, 12, 16, -1},
68 {PERIPH_ID_UART3, 16, 20, -1},
69 {PERIPH_ID_I2C0, -1, 8, -1},
70 {PERIPH_ID_I2C1, -1, 8, -1},
71 {PERIPH_ID_I2C2, -1, 8, -1},
72 {PERIPH_ID_I2C3, -1, 8, -1},
73 {PERIPH_ID_I2C4, -1, 8, -1},
74 {PERIPH_ID_I2C5, -1, 8, -1},
75 {PERIPH_ID_I2C6, -1, 8, -1},
76 {PERIPH_ID_I2C7, -1, 8, -1},
77 {PERIPH_ID_SPI0, 20, 20, 8},
78 {PERIPH_ID_SPI1, 24, 24, 16},
79 {PERIPH_ID_SPI2, 28, 28, 24},
80 {PERIPH_ID_SDMMC0, 8, 0, -1},
81 {PERIPH_ID_SDMMC1, 12, 10, -1},
82 {PERIPH_ID_SDMMC2, 16, 20, -1},
83 {PERIPH_ID_I2C8, -1, 8, -1},
84 {PERIPH_ID_I2C9, -1, 8, -1},
85 {PERIPH_ID_I2S0, 0, 0, 4},
86 {PERIPH_ID_I2S1, 4, 12, 16},
87 {PERIPH_ID_SPI3, 12, 16, 0},
88 {PERIPH_ID_SPI4, 16, 20, 8},
89 {PERIPH_ID_PWM0, 24, 28, -1},
90 {PERIPH_ID_PWM1, 24, 28, -1},
91 {PERIPH_ID_PWM2, 24, 28, -1},
92 {PERIPH_ID_PWM3, 24, 28, -1},
93 {PERIPH_ID_PWM4, 24, 28, -1},
94 {PERIPH_ID_I2C10, -1, 8, -1},
96 {PERIPH_ID_NONE, -1, -1, -1},
99 /* Epll Clock division values to achive different frequency output */
100 static struct set_epll_con_val exynos5_epll_div[] = {
101 { 192000000, 0, 48, 3, 1, 0 },
102 { 180000000, 0, 45, 3, 1, 0 },
103 { 73728000, 1, 73, 3, 3, 47710 },
104 { 67737600, 1, 90, 4, 3, 20762 },
105 { 49152000, 0, 49, 3, 3, 9961 },
106 { 45158400, 0, 45, 3, 3, 10381 },
107 { 180633600, 0, 45, 3, 1, 10381 }
110 /* exynos: return pll clock frequency */
111 static int exynos_get_pll_clk(int pllreg, unsigned int r, unsigned int k)
113 unsigned long m, p, s = 0, mask, fout;
117 * APLL_CON: MIDV [25:16]
118 * MPLL_CON: MIDV [25:16]
119 * EPLL_CON: MIDV [24:16]
120 * VPLL_CON: MIDV [24:16]
121 * BPLL_CON: MIDV [25:16]: Exynos5
123 if (pllreg == APLL || pllreg == MPLL || pllreg == BPLL ||
129 m = (r >> 16) & mask;
136 freq = CONFIG_SYS_CLK_FREQ;
138 if (pllreg == EPLL || pllreg == RPLL) {
140 /* FOUT = (MDIV + K / 65536) * FIN / (PDIV * 2^SDIV) */
141 fout = (m + k / PLL_DIV_65536) * (freq / (p * (1 << s)));
142 } else if (pllreg == VPLL) {
147 * FOUT = (MDIV + K / 1024) * FIN / (PDIV * 2^SDIV)
150 * FOUT = (MDIV + K / 65535) * FIN / (PDIV * 2^SDIV)
153 * FOUT = (MDIV + K / 65536) * FIN / (PDIV * 2^SDIV)
155 if (proid_is_exynos4210())
157 else if (proid_is_exynos4412())
159 else if (proid_is_exynos5250() || proid_is_exynos5420()
160 || proid_is_exynos5800())
165 fout = (m + k / div) * (freq / (p * (1 << s)));
168 * Exynos4412 / Exynos5250
169 * FOUT = MDIV * FIN / (PDIV * 2^SDIV)
172 * FOUT = MDIV * FIN / (PDIV * 2^(SDIV-1))
174 if (proid_is_exynos4210())
175 fout = m * (freq / (p * (1 << (s - 1))));
177 fout = m * (freq / (p * (1 << s)));
182 /* exynos4: return pll clock frequency */
183 static unsigned long exynos4_get_pll_clk(int pllreg)
185 struct exynos4_clock *clk =
186 (struct exynos4_clock *)samsung_get_base_clock();
187 unsigned long r, k = 0;
191 r = readl(&clk->apll_con0);
194 r = readl(&clk->mpll_con0);
197 r = readl(&clk->epll_con0);
198 k = readl(&clk->epll_con1);
201 r = readl(&clk->vpll_con0);
202 k = readl(&clk->vpll_con1);
205 printf("Unsupported PLL (%d)\n", pllreg);
209 return exynos_get_pll_clk(pllreg, r, k);
212 /* exynos4x12: return pll clock frequency */
213 static unsigned long exynos4x12_get_pll_clk(int pllreg)
215 struct exynos4x12_clock *clk =
216 (struct exynos4x12_clock *)samsung_get_base_clock();
217 unsigned long r, k = 0;
221 r = readl(&clk->apll_con0);
224 r = readl(&clk->mpll_con0);
227 r = readl(&clk->epll_con0);
228 k = readl(&clk->epll_con1);
231 r = readl(&clk->vpll_con0);
232 k = readl(&clk->vpll_con1);
235 printf("Unsupported PLL (%d)\n", pllreg);
239 return exynos_get_pll_clk(pllreg, r, k);
242 /* exynos5: return pll clock frequency */
243 static unsigned long exynos5_get_pll_clk(int pllreg)
245 struct exynos5_clock *clk =
246 (struct exynos5_clock *)samsung_get_base_clock();
247 unsigned long r, k = 0, fout;
248 unsigned int pll_div2_sel, fout_sel;
252 r = readl(&clk->apll_con0);
255 r = readl(&clk->mpll_con0);
258 r = readl(&clk->epll_con0);
259 k = readl(&clk->epll_con1);
262 r = readl(&clk->vpll_con0);
263 k = readl(&clk->vpll_con1);
266 r = readl(&clk->bpll_con0);
269 printf("Unsupported PLL (%d)\n", pllreg);
273 fout = exynos_get_pll_clk(pllreg, r, k);
275 /* According to the user manual, in EVT1 MPLL and BPLL always gives
276 * 1.6GHz clock, so divide by 2 to get 800MHz MPLL clock.*/
277 if (pllreg == MPLL || pllreg == BPLL) {
278 pll_div2_sel = readl(&clk->pll_div2_sel);
282 fout_sel = (pll_div2_sel >> MPLL_FOUT_SEL_SHIFT)
283 & MPLL_FOUT_SEL_MASK;
286 fout_sel = (pll_div2_sel >> BPLL_FOUT_SEL_SHIFT)
287 & BPLL_FOUT_SEL_MASK;
301 /* exynos542x: return pll clock frequency */
302 static unsigned long exynos542x_get_pll_clk(int pllreg)
304 struct exynos5420_clock *clk =
305 (struct exynos5420_clock *)samsung_get_base_clock();
306 unsigned long r, k = 0;
310 r = readl(&clk->apll_con0);
313 r = readl(&clk->mpll_con0);
316 r = readl(&clk->epll_con0);
317 k = readl(&clk->epll_con1);
320 r = readl(&clk->vpll_con0);
321 k = readl(&clk->vpll_con1);
324 r = readl(&clk->bpll_con0);
327 r = readl(&clk->rpll_con0);
328 k = readl(&clk->rpll_con1);
331 r = readl(&clk->spll_con0);
334 printf("Unsupported PLL (%d)\n", pllreg);
338 return exynos_get_pll_clk(pllreg, r, k);
341 static struct clk_bit_info *get_clk_bit_info(int peripheral)
344 struct clk_bit_info *info;
346 if (proid_is_exynos5420() || proid_is_exynos5800())
347 info = exynos542x_bit_info;
349 info = exynos5_bit_info;
351 for (i = 0; info[i].id != PERIPH_ID_NONE; i++) {
352 if (info[i].id == peripheral)
356 if (info[i].id == PERIPH_ID_NONE)
357 debug("ERROR: Peripheral ID %d not found\n", peripheral);
362 static unsigned long exynos5_get_periph_rate(int peripheral)
364 struct clk_bit_info *bit_info = get_clk_bit_info(peripheral);
365 unsigned long sclk, sub_clk = 0;
366 unsigned int src, div, sub_div = 0;
367 struct exynos5_clock *clk =
368 (struct exynos5_clock *)samsung_get_base_clock();
370 switch (peripheral) {
371 case PERIPH_ID_UART0:
372 case PERIPH_ID_UART1:
373 case PERIPH_ID_UART2:
374 case PERIPH_ID_UART3:
375 src = readl(&clk->src_peric0);
376 div = readl(&clk->div_peric0);
383 src = readl(&clk->src_peric0);
384 div = readl(&clk->div_peric3);
387 src = readl(&clk->src_mau);
388 div = readl(&clk->div_mau);
391 src = readl(&clk->src_peric1);
392 div = readl(&clk->div_peric1);
395 src = readl(&clk->src_peric1);
396 div = readl(&clk->div_peric2);
400 src = readl(&clk->sclk_src_isp);
401 div = readl(&clk->sclk_div_isp);
403 case PERIPH_ID_SDMMC0:
404 case PERIPH_ID_SDMMC1:
405 src = readl(&clk->src_fsys);
406 div = readl(&clk->div_fsys1);
408 case PERIPH_ID_SDMMC2:
409 case PERIPH_ID_SDMMC3:
410 src = readl(&clk->src_fsys);
411 div = readl(&clk->div_fsys2);
421 sclk = exynos5_get_pll_clk(MPLL);
422 sub_div = ((readl(&clk->div_top1) >> bit_info->div_bit)
424 div = ((readl(&clk->div_top0) >> bit_info->prediv_bit)
426 return (sclk / sub_div) / div;
428 debug("%s: invalid peripheral %d", __func__, peripheral);
432 if (bit_info->src_bit >= 0)
433 src = (src >> bit_info->src_bit) & 0xf;
436 case EXYNOS_SRC_MPLL:
437 sclk = exynos5_get_pll_clk(MPLL);
439 case EXYNOS_SRC_EPLL:
440 sclk = exynos5_get_pll_clk(EPLL);
442 case EXYNOS_SRC_VPLL:
443 sclk = exynos5_get_pll_clk(VPLL);
449 /* Ratio clock division for this peripheral */
450 if (bit_info->div_bit >= 0) {
451 sub_div = (div >> bit_info->div_bit) & 0xf;
452 sub_clk = sclk / (sub_div + 1);
455 if (bit_info->prediv_bit >= 0) {
456 div = (div >> bit_info->prediv_bit) & 0xff;
457 return sub_clk / (div + 1);
463 static unsigned long exynos542x_get_periph_rate(int peripheral)
465 struct clk_bit_info *bit_info = get_clk_bit_info(peripheral);
466 unsigned long sclk, sub_clk = 0;
467 unsigned int src, div, sub_div = 0;
468 struct exynos5420_clock *clk =
469 (struct exynos5420_clock *)samsung_get_base_clock();
471 switch (peripheral) {
472 case PERIPH_ID_UART0:
473 case PERIPH_ID_UART1:
474 case PERIPH_ID_UART2:
475 case PERIPH_ID_UART3:
481 src = readl(&clk->src_peric0);
482 div = readl(&clk->div_peric0);
487 src = readl(&clk->src_peric1);
488 div = readl(&clk->div_peric1);
489 sub_div = readl(&clk->div_peric4);
493 src = readl(&clk->src_isp);
494 div = readl(&clk->div_isp1);
495 sub_div = readl(&clk->div_isp1);
497 case PERIPH_ID_SDMMC0:
498 case PERIPH_ID_SDMMC1:
499 case PERIPH_ID_SDMMC2:
500 case PERIPH_ID_SDMMC3:
501 src = readl(&clk->src_fsys);
502 div = readl(&clk->div_fsys1);
514 case PERIPH_ID_I2C10:
515 sclk = exynos542x_get_pll_clk(MPLL);
516 sub_div = ((readl(&clk->div_top1) >> bit_info->div_bit)
518 return sclk / sub_div;
520 debug("%s: invalid peripheral %d", __func__, peripheral);
524 if (bit_info->src_bit >= 0)
525 src = (src >> bit_info->src_bit) & 0xf;
528 case EXYNOS542X_SRC_MPLL:
529 sclk = exynos542x_get_pll_clk(MPLL);
531 case EXYNOS542X_SRC_SPLL:
532 sclk = exynos542x_get_pll_clk(SPLL);
534 case EXYNOS542X_SRC_EPLL:
535 sclk = exynos542x_get_pll_clk(EPLL);
537 case EXYNOS542X_SRC_RPLL:
538 sclk = exynos542x_get_pll_clk(RPLL);
544 /* Ratio clock division for this peripheral */
545 if (bit_info->div_bit >= 0) {
546 div = (div >> bit_info->div_bit) & 0xf;
547 sub_clk = sclk / (div + 1);
550 if (bit_info->prediv_bit >= 0) {
551 sub_div = (sub_div >> bit_info->prediv_bit) & 0xff;
552 return sub_clk / (sub_div + 1);
558 unsigned long clock_get_periph_rate(int peripheral)
560 if (cpu_is_exynos5()) {
561 if (proid_is_exynos5420() || proid_is_exynos5800())
562 return exynos542x_get_periph_rate(peripheral);
563 return exynos5_get_periph_rate(peripheral);
569 /* exynos4: return ARM clock frequency */
570 static unsigned long exynos4_get_arm_clk(void)
572 struct exynos4_clock *clk =
573 (struct exynos4_clock *)samsung_get_base_clock();
575 unsigned long armclk;
576 unsigned int core_ratio;
577 unsigned int core2_ratio;
579 div = readl(&clk->div_cpu0);
581 /* CORE_RATIO: [2:0], CORE2_RATIO: [30:28] */
582 core_ratio = (div >> 0) & 0x7;
583 core2_ratio = (div >> 28) & 0x7;
585 armclk = get_pll_clk(APLL) / (core_ratio + 1);
586 armclk /= (core2_ratio + 1);
591 /* exynos4x12: return ARM clock frequency */
592 static unsigned long exynos4x12_get_arm_clk(void)
594 struct exynos4x12_clock *clk =
595 (struct exynos4x12_clock *)samsung_get_base_clock();
597 unsigned long armclk;
598 unsigned int core_ratio;
599 unsigned int core2_ratio;
601 div = readl(&clk->div_cpu0);
603 /* CORE_RATIO: [2:0], CORE2_RATIO: [30:28] */
604 core_ratio = (div >> 0) & 0x7;
605 core2_ratio = (div >> 28) & 0x7;
607 armclk = get_pll_clk(APLL) / (core_ratio + 1);
608 armclk /= (core2_ratio + 1);
613 /* exynos5: return ARM clock frequency */
614 static unsigned long exynos5_get_arm_clk(void)
616 struct exynos5_clock *clk =
617 (struct exynos5_clock *)samsung_get_base_clock();
619 unsigned long armclk;
620 unsigned int arm_ratio;
621 unsigned int arm2_ratio;
623 div = readl(&clk->div_cpu0);
625 /* ARM_RATIO: [2:0], ARM2_RATIO: [30:28] */
626 arm_ratio = (div >> 0) & 0x7;
627 arm2_ratio = (div >> 28) & 0x7;
629 armclk = get_pll_clk(APLL) / (arm_ratio + 1);
630 armclk /= (arm2_ratio + 1);
635 /* exynos4: return pwm clock frequency */
636 static unsigned long exynos4_get_pwm_clk(void)
638 struct exynos4_clock *clk =
639 (struct exynos4_clock *)samsung_get_base_clock();
640 unsigned long pclk, sclk;
644 if (s5p_get_cpu_rev() == 0) {
649 sel = readl(&clk->src_peril0);
650 sel = (sel >> 24) & 0xf;
653 sclk = get_pll_clk(MPLL);
655 sclk = get_pll_clk(EPLL);
657 sclk = get_pll_clk(VPLL);
665 ratio = readl(&clk->div_peril3);
667 } else if (s5p_get_cpu_rev() == 1) {
668 sclk = get_pll_clk(MPLL);
673 pclk = sclk / (ratio + 1);
678 /* exynos4x12: return pwm clock frequency */
679 static unsigned long exynos4x12_get_pwm_clk(void)
681 unsigned long pclk, sclk;
684 sclk = get_pll_clk(MPLL);
687 pclk = sclk / (ratio + 1);
692 /* exynos4: return uart clock frequency */
693 static unsigned long exynos4_get_uart_clk(int dev_index)
695 struct exynos4_clock *clk =
696 (struct exynos4_clock *)samsung_get_base_clock();
697 unsigned long uclk, sclk;
710 sel = readl(&clk->src_peril0);
711 sel = (sel >> (dev_index << 2)) & 0xf;
714 sclk = get_pll_clk(MPLL);
716 sclk = get_pll_clk(EPLL);
718 sclk = get_pll_clk(VPLL);
727 * UART3_RATIO [12:15]
728 * UART4_RATIO [16:19]
729 * UART5_RATIO [23:20]
731 ratio = readl(&clk->div_peril0);
732 ratio = (ratio >> (dev_index << 2)) & 0xf;
734 uclk = sclk / (ratio + 1);
739 /* exynos4x12: return uart clock frequency */
740 static unsigned long exynos4x12_get_uart_clk(int dev_index)
742 struct exynos4x12_clock *clk =
743 (struct exynos4x12_clock *)samsung_get_base_clock();
744 unsigned long uclk, sclk;
756 sel = readl(&clk->src_peril0);
757 sel = (sel >> (dev_index << 2)) & 0xf;
760 sclk = get_pll_clk(MPLL);
762 sclk = get_pll_clk(EPLL);
764 sclk = get_pll_clk(VPLL);
773 * UART3_RATIO [12:15]
774 * UART4_RATIO [16:19]
776 ratio = readl(&clk->div_peril0);
777 ratio = (ratio >> (dev_index << 2)) & 0xf;
779 uclk = sclk / (ratio + 1);
784 static unsigned long exynos4_get_mmc_clk(int dev_index)
786 struct exynos4_clock *clk =
787 (struct exynos4_clock *)samsung_get_base_clock();
788 unsigned long uclk, sclk;
789 unsigned int sel, ratio, pre_ratio;
792 sel = readl(&clk->src_fsys);
793 sel = (sel >> (dev_index << 2)) & 0xf;
796 sclk = get_pll_clk(MPLL);
798 sclk = get_pll_clk(EPLL);
800 sclk = get_pll_clk(VPLL);
807 ratio = readl(&clk->div_fsys1);
808 pre_ratio = readl(&clk->div_fsys1);
812 ratio = readl(&clk->div_fsys2);
813 pre_ratio = readl(&clk->div_fsys2);
816 ratio = readl(&clk->div_fsys3);
817 pre_ratio = readl(&clk->div_fsys3);
823 if (dev_index == 1 || dev_index == 3)
826 ratio = (ratio >> shift) & 0xf;
827 pre_ratio = (pre_ratio >> (shift + 8)) & 0xff;
828 uclk = (sclk / (ratio + 1)) / (pre_ratio + 1);
833 /* exynos4: set the mmc clock */
834 static void exynos4_set_mmc_clk(int dev_index, unsigned int div)
836 struct exynos4_clock *clk =
837 (struct exynos4_clock *)samsung_get_base_clock();
838 unsigned int addr, clear_bit, set_bit;
842 * MMC0_PRE_RATIO [15:8], MMC1_PRE_RATIO [31:24]
844 * MMC2_PRE_RATIO [15:8], MMC3_PRE_RATIO [31:24]
849 addr = (unsigned int)&clk->div_fsys1;
850 clear_bit = MASK_PRE_RATIO(dev_index);
851 set_bit = SET_PRE_RATIO(dev_index, div);
852 } else if (dev_index == 4) {
853 addr = (unsigned int)&clk->div_fsys3;
855 /* MMC4 is controlled with the MMC4_RATIO value */
856 clear_bit = MASK_RATIO(dev_index);
857 set_bit = SET_RATIO(dev_index, div);
859 addr = (unsigned int)&clk->div_fsys2;
861 clear_bit = MASK_PRE_RATIO(dev_index);
862 set_bit = SET_PRE_RATIO(dev_index, div);
865 clrsetbits_le32(addr, clear_bit, set_bit);
868 /* exynos5: set the mmc clock */
869 static void exynos5_set_mmc_clk(int dev_index, unsigned int div)
871 struct exynos5_clock *clk =
872 (struct exynos5_clock *)samsung_get_base_clock();
877 * MMC0_PRE_RATIO [15:8], MMC1_PRE_RATIO [31:24]
879 * MMC2_PRE_RATIO [15:8], MMC3_PRE_RATIO [31:24]
882 addr = (unsigned int)&clk->div_fsys1;
884 addr = (unsigned int)&clk->div_fsys2;
888 clrsetbits_le32(addr, 0xff << ((dev_index << 4) + 8),
889 (div & 0xff) << ((dev_index << 4) + 8));
892 /* exynos5: set the mmc clock */
893 static void exynos5420_set_mmc_clk(int dev_index, unsigned int div)
895 struct exynos5420_clock *clk =
896 (struct exynos5420_clock *)samsung_get_base_clock();
906 addr = (unsigned int)&clk->div_fsys1;
907 shift = dev_index * 10;
909 clrsetbits_le32(addr, 0x3ff << shift, (div & 0x3ff) << shift);
912 /* get_lcd_clk: return lcd clock frequency */
913 static unsigned long exynos4_get_lcd_clk(void)
915 struct exynos4_clock *clk =
916 (struct exynos4_clock *)samsung_get_base_clock();
917 unsigned long pclk, sclk;
925 sel = readl(&clk->src_lcd0);
934 sclk = get_pll_clk(MPLL);
936 sclk = get_pll_clk(EPLL);
938 sclk = get_pll_clk(VPLL);
946 ratio = readl(&clk->div_lcd0);
949 pclk = sclk / (ratio + 1);
954 /* get_lcd_clk: return lcd clock frequency */
955 static unsigned long exynos5_get_lcd_clk(void)
957 struct exynos5_clock *clk =
958 (struct exynos5_clock *)samsung_get_base_clock();
959 unsigned long pclk, sclk;
967 sel = readl(&clk->src_disp1_0);
976 sclk = get_pll_clk(MPLL);
978 sclk = get_pll_clk(EPLL);
980 sclk = get_pll_clk(VPLL);
988 ratio = readl(&clk->div_disp1_0);
991 pclk = sclk / (ratio + 1);
996 static unsigned long exynos5420_get_lcd_clk(void)
998 struct exynos5420_clock *clk =
999 (struct exynos5420_clock *)samsung_get_base_clock();
1000 unsigned long pclk, sclk;
1010 sel = readl(&clk->src_disp10);
1014 sclk = get_pll_clk(SPLL);
1016 sclk = get_pll_clk(RPLL);
1022 ratio = readl(&clk->div_disp10);
1023 ratio = ratio & 0xf;
1025 pclk = sclk / (ratio + 1);
1030 void exynos4_set_lcd_clk(void)
1032 struct exynos4_clock *clk =
1033 (struct exynos4_clock *)samsung_get_base_clock();
1045 setbits_le32(&clk->gate_block, 1 << 4);
1051 * MDNIE_PWM0_SEL [8:11]
1053 * set lcd0 src clock 0x6: SCLK_MPLL
1055 clrsetbits_le32(&clk->src_lcd0, 0xf, 0x6);
1065 * Gating all clocks for FIMD0
1067 setbits_le32(&clk->gate_ip_lcd0, 1 << 0);
1072 * MDNIE0_RATIO [7:4]
1073 * MDNIE_PWM0_RATIO [11:8]
1074 * MDNIE_PWM_PRE_RATIO [15:12]
1075 * MIPI0_RATIO [19:16]
1076 * MIPI0_PRE_RATIO [23:20]
1079 clrsetbits_le32(&clk->div_lcd0, 0xf, 0x1);
1082 void exynos5_set_lcd_clk(void)
1084 struct exynos5_clock *clk =
1085 (struct exynos5_clock *)samsung_get_base_clock();
1097 setbits_le32(&clk->gate_block, 1 << 4);
1103 * MDNIE_PWM0_SEL [8:11]
1105 * set lcd0 src clock 0x6: SCLK_MPLL
1107 clrsetbits_le32(&clk->src_disp1_0, 0xf, 0x6);
1117 * Gating all clocks for FIMD0
1119 setbits_le32(&clk->gate_ip_disp1, 1 << 0);
1124 * MDNIE0_RATIO [7:4]
1125 * MDNIE_PWM0_RATIO [11:8]
1126 * MDNIE_PWM_PRE_RATIO [15:12]
1127 * MIPI0_RATIO [19:16]
1128 * MIPI0_PRE_RATIO [23:20]
1131 clrsetbits_le32(&clk->div_disp1_0, 0xf, 0x0);
1134 void exynos5420_set_lcd_clk(void)
1136 struct exynos5420_clock *clk =
1137 (struct exynos5420_clock *)samsung_get_base_clock();
1146 cfg = readl(&clk->src_disp10);
1149 writel(cfg, &clk->src_disp10);
1155 cfg = readl(&clk->div_disp10);
1158 writel(cfg, &clk->div_disp10);
1161 void exynos4_set_mipi_clk(void)
1163 struct exynos4_clock *clk =
1164 (struct exynos4_clock *)samsung_get_base_clock();
1170 * MDNIE_PWM0_SEL [8:11]
1172 * set mipi0 src clock 0x6: SCLK_MPLL
1174 clrsetbits_le32(&clk->src_lcd0, 0xf << 12, 0x6 << 12);
1180 * MDNIE_PWM0_MASK [8]
1182 * set src mask mipi0 0x1: Unmask
1184 setbits_le32(&clk->src_mask_lcd0, 0x1 << 12);
1194 * Gating all clocks for MIPI0
1196 setbits_le32(&clk->gate_ip_lcd0, 1 << 3);
1201 * MDNIE0_RATIO [7:4]
1202 * MDNIE_PWM0_RATIO [11:8]
1203 * MDNIE_PWM_PRE_RATIO [15:12]
1204 * MIPI0_RATIO [19:16]
1205 * MIPI0_PRE_RATIO [23:20]
1208 clrsetbits_le32(&clk->div_lcd0, 0xf << 16, 0x1 << 16);
1211 int exynos5_set_epll_clk(unsigned long rate)
1213 unsigned int epll_con, epll_con_k;
1215 unsigned int lockcnt;
1217 struct exynos5_clock *clk =
1218 (struct exynos5_clock *)samsung_get_base_clock();
1220 epll_con = readl(&clk->epll_con0);
1221 epll_con &= ~((EPLL_CON0_LOCK_DET_EN_MASK <<
1222 EPLL_CON0_LOCK_DET_EN_SHIFT) |
1223 EPLL_CON0_MDIV_MASK << EPLL_CON0_MDIV_SHIFT |
1224 EPLL_CON0_PDIV_MASK << EPLL_CON0_PDIV_SHIFT |
1225 EPLL_CON0_SDIV_MASK << EPLL_CON0_SDIV_SHIFT);
1227 for (i = 0; i < ARRAY_SIZE(exynos5_epll_div); i++) {
1228 if (exynos5_epll_div[i].freq_out == rate)
1232 if (i == ARRAY_SIZE(exynos5_epll_div))
1235 epll_con_k = exynos5_epll_div[i].k_dsm << 0;
1236 epll_con |= exynos5_epll_div[i].en_lock_det <<
1237 EPLL_CON0_LOCK_DET_EN_SHIFT;
1238 epll_con |= exynos5_epll_div[i].m_div << EPLL_CON0_MDIV_SHIFT;
1239 epll_con |= exynos5_epll_div[i].p_div << EPLL_CON0_PDIV_SHIFT;
1240 epll_con |= exynos5_epll_div[i].s_div << EPLL_CON0_SDIV_SHIFT;
1243 * Required period ( in cycles) to genarate a stable clock output.
1244 * The maximum clock time can be up to 3000 * PDIV cycles of PLLs
1245 * frequency input (as per spec)
1247 lockcnt = 3000 * exynos5_epll_div[i].p_div;
1249 writel(lockcnt, &clk->epll_lock);
1250 writel(epll_con, &clk->epll_con0);
1251 writel(epll_con_k, &clk->epll_con1);
1253 start = get_timer(0);
1255 while (!(readl(&clk->epll_con0) &
1256 (0x1 << EXYNOS5_EPLLCON0_LOCKED_SHIFT))) {
1257 if (get_timer(start) > TIMEOUT_EPLL_LOCK) {
1258 debug("%s: Timeout waiting for EPLL lock\n", __func__);
1265 int exynos5_set_i2s_clk_source(unsigned int i2s_id)
1267 struct exynos5_clock *clk =
1268 (struct exynos5_clock *)samsung_get_base_clock();
1269 unsigned int *audio_ass = (unsigned int *)samsung_get_base_audio_ass();
1272 setbits_le32(&clk->src_top2, CLK_SRC_MOUT_EPLL);
1273 clrsetbits_le32(&clk->src_mau, AUDIO0_SEL_MASK,
1274 (CLK_SRC_SCLK_EPLL));
1275 setbits_le32(audio_ass, AUDIO_CLKMUX_ASS);
1276 } else if (i2s_id == 1) {
1277 clrsetbits_le32(&clk->src_peric1, AUDIO1_SEL_MASK,
1278 (CLK_SRC_SCLK_EPLL));
1285 int exynos5_set_i2s_clk_prescaler(unsigned int src_frq,
1286 unsigned int dst_frq,
1287 unsigned int i2s_id)
1289 struct exynos5_clock *clk =
1290 (struct exynos5_clock *)samsung_get_base_clock();
1293 if ((dst_frq == 0) || (src_frq == 0)) {
1294 debug("%s: Invalid requency input for prescaler\n", __func__);
1295 debug("src frq = %d des frq = %d ", src_frq, dst_frq);
1299 div = (src_frq / dst_frq);
1301 if (div > AUDIO_0_RATIO_MASK) {
1302 debug("%s: Frequency ratio is out of range\n",
1304 debug("src frq = %d des frq = %d ", src_frq, dst_frq);
1307 clrsetbits_le32(&clk->div_mau, AUDIO_0_RATIO_MASK,
1308 (div & AUDIO_0_RATIO_MASK));
1309 } else if(i2s_id == 1) {
1310 if (div > AUDIO_1_RATIO_MASK) {
1311 debug("%s: Frequency ratio is out of range\n",
1313 debug("src frq = %d des frq = %d ", src_frq, dst_frq);
1316 clrsetbits_le32(&clk->div_peric4, AUDIO_1_RATIO_MASK,
1317 (div & AUDIO_1_RATIO_MASK));
1325 * Linearly searches for the most accurate main and fine stage clock scalars
1326 * (divisors) for a specified target frequency and scalar bit sizes by checking
1327 * all multiples of main_scalar_bits values. Will always return scalars up to or
1328 * slower than target.
1330 * @param main_scalar_bits Number of main scalar bits, must be > 0 and < 32
1331 * @param fine_scalar_bits Number of fine scalar bits, must be > 0 and < 32
1332 * @param input_freq Clock frequency to be scaled in Hz
1333 * @param target_freq Desired clock frequency in Hz
1334 * @param best_fine_scalar Pointer to store the fine stage divisor
1336 * @return best_main_scalar Main scalar for desired frequency or -1 if none
1339 static int clock_calc_best_scalar(unsigned int main_scaler_bits,
1340 unsigned int fine_scalar_bits, unsigned int input_rate,
1341 unsigned int target_rate, unsigned int *best_fine_scalar)
1344 int best_main_scalar = -1;
1345 unsigned int best_error = target_rate;
1346 const unsigned int cap = (1 << fine_scalar_bits) - 1;
1347 const unsigned int loops = 1 << main_scaler_bits;
1349 debug("Input Rate is %u, Target is %u, Cap is %u\n", input_rate,
1352 assert(best_fine_scalar != NULL);
1353 assert(main_scaler_bits <= fine_scalar_bits);
1355 *best_fine_scalar = 1;
1357 if (input_rate == 0 || target_rate == 0)
1360 if (target_rate >= input_rate)
1363 for (i = 1; i <= loops; i++) {
1364 const unsigned int effective_div =
1365 max(min(input_rate / i / target_rate, cap), 1U);
1366 const unsigned int effective_rate = input_rate / i /
1368 const int error = target_rate - effective_rate;
1370 debug("%d|effdiv:%u, effrate:%u, error:%d\n", i, effective_div,
1371 effective_rate, error);
1373 if (error >= 0 && error <= best_error) {
1375 best_main_scalar = i;
1376 *best_fine_scalar = effective_div;
1380 return best_main_scalar;
1383 static int exynos5_set_spi_clk(enum periph_id periph_id,
1386 struct exynos5_clock *clk =
1387 (struct exynos5_clock *)samsung_get_base_clock();
1390 unsigned shift, pre_shift;
1391 unsigned mask = 0xff;
1394 main = clock_calc_best_scalar(4, 8, 400000000, rate, &fine);
1396 debug("%s: Cannot set clock rate for periph %d",
1397 __func__, periph_id);
1403 switch (periph_id) {
1404 case PERIPH_ID_SPI0:
1405 reg = &clk->div_peric1;
1409 case PERIPH_ID_SPI1:
1410 reg = &clk->div_peric1;
1414 case PERIPH_ID_SPI2:
1415 reg = &clk->div_peric2;
1419 case PERIPH_ID_SPI3:
1420 reg = &clk->sclk_div_isp;
1424 case PERIPH_ID_SPI4:
1425 reg = &clk->sclk_div_isp;
1430 debug("%s: Unsupported peripheral ID %d\n", __func__,
1434 clrsetbits_le32(reg, mask << shift, (main & mask) << shift);
1435 clrsetbits_le32(reg, mask << pre_shift, (fine & mask) << pre_shift);
1440 static int exynos5420_set_spi_clk(enum periph_id periph_id,
1443 struct exynos5420_clock *clk =
1444 (struct exynos5420_clock *)samsung_get_base_clock();
1447 unsigned shift, pre_shift;
1448 unsigned div_mask = 0xf, pre_div_mask = 0xff;
1452 main = clock_calc_best_scalar(4, 8, 400000000, rate, &fine);
1454 debug("%s: Cannot set clock rate for periph %d",
1455 __func__, periph_id);
1461 switch (periph_id) {
1462 case PERIPH_ID_SPI0:
1463 reg = &clk->div_peric1;
1465 pre_reg = &clk->div_peric4;
1468 case PERIPH_ID_SPI1:
1469 reg = &clk->div_peric1;
1471 pre_reg = &clk->div_peric4;
1474 case PERIPH_ID_SPI2:
1475 reg = &clk->div_peric1;
1477 pre_reg = &clk->div_peric4;
1480 case PERIPH_ID_SPI3:
1481 reg = &clk->div_isp1;
1483 pre_reg = &clk->div_isp1;
1486 case PERIPH_ID_SPI4:
1487 reg = &clk->div_isp1;
1489 pre_reg = &clk->div_isp1;
1493 debug("%s: Unsupported peripheral ID %d\n", __func__,
1498 clrsetbits_le32(reg, div_mask << shift, (main & div_mask) << shift);
1499 clrsetbits_le32(pre_reg, pre_div_mask << pre_shift,
1500 (fine & pre_div_mask) << pre_shift);
1505 static unsigned long exynos4_get_i2c_clk(void)
1507 struct exynos4_clock *clk =
1508 (struct exynos4_clock *)samsung_get_base_clock();
1509 unsigned long sclk, aclk_100;
1512 sclk = get_pll_clk(APLL);
1514 ratio = (readl(&clk->div_top)) >> 4;
1516 aclk_100 = sclk / (ratio + 1);
1520 unsigned long get_pll_clk(int pllreg)
1522 if (cpu_is_exynos5()) {
1523 if (proid_is_exynos5420() || proid_is_exynos5800())
1524 return exynos542x_get_pll_clk(pllreg);
1525 return exynos5_get_pll_clk(pllreg);
1527 if (proid_is_exynos4412())
1528 return exynos4x12_get_pll_clk(pllreg);
1529 return exynos4_get_pll_clk(pllreg);
1533 unsigned long get_arm_clk(void)
1535 if (cpu_is_exynos5())
1536 return exynos5_get_arm_clk();
1538 if (proid_is_exynos4412())
1539 return exynos4x12_get_arm_clk();
1540 return exynos4_get_arm_clk();
1544 unsigned long get_i2c_clk(void)
1546 if (cpu_is_exynos5()) {
1547 return clock_get_periph_rate(PERIPH_ID_I2C0);
1548 } else if (cpu_is_exynos4()) {
1549 return exynos4_get_i2c_clk();
1551 debug("I2C clock is not set for this CPU\n");
1556 unsigned long get_pwm_clk(void)
1558 if (cpu_is_exynos5()) {
1559 return clock_get_periph_rate(PERIPH_ID_PWM0);
1561 if (proid_is_exynos4412())
1562 return exynos4x12_get_pwm_clk();
1563 return exynos4_get_pwm_clk();
1567 unsigned long get_uart_clk(int dev_index)
1571 switch (dev_index) {
1573 id = PERIPH_ID_UART0;
1576 id = PERIPH_ID_UART1;
1579 id = PERIPH_ID_UART2;
1582 id = PERIPH_ID_UART3;
1585 debug("%s: invalid UART index %d", __func__, dev_index);
1589 if (cpu_is_exynos5()) {
1590 return clock_get_periph_rate(id);
1592 if (proid_is_exynos4412())
1593 return exynos4x12_get_uart_clk(dev_index);
1594 return exynos4_get_uart_clk(dev_index);
1598 unsigned long get_mmc_clk(int dev_index)
1602 switch (dev_index) {
1604 id = PERIPH_ID_SDMMC0;
1607 id = PERIPH_ID_SDMMC1;
1610 id = PERIPH_ID_SDMMC2;
1613 id = PERIPH_ID_SDMMC3;
1616 debug("%s: invalid MMC index %d", __func__, dev_index);
1620 if (cpu_is_exynos5()) {
1621 return clock_get_periph_rate(id);
1623 return exynos4_get_mmc_clk(dev_index);
1627 void set_mmc_clk(int dev_index, unsigned int div)
1629 /* If want to set correct value, it needs to substract one from div.*/
1633 if (cpu_is_exynos5()) {
1634 if (proid_is_exynos5420() || proid_is_exynos5800())
1635 exynos5420_set_mmc_clk(dev_index, div);
1637 exynos5_set_mmc_clk(dev_index, div);
1639 exynos4_set_mmc_clk(dev_index, div);
1643 unsigned long get_lcd_clk(void)
1645 if (cpu_is_exynos4())
1646 return exynos4_get_lcd_clk();
1648 if (proid_is_exynos5420() || proid_is_exynos5800())
1649 return exynos5420_get_lcd_clk();
1651 return exynos5_get_lcd_clk();
1655 void set_lcd_clk(void)
1657 if (cpu_is_exynos4())
1658 exynos4_set_lcd_clk();
1660 if (proid_is_exynos5250())
1661 exynos5_set_lcd_clk();
1662 else if (proid_is_exynos5420() || proid_is_exynos5800())
1663 exynos5420_set_lcd_clk();
1667 void set_mipi_clk(void)
1669 if (cpu_is_exynos4())
1670 exynos4_set_mipi_clk();
1673 int set_spi_clk(int periph_id, unsigned int rate)
1675 if (cpu_is_exynos5()) {
1676 if (proid_is_exynos5420() || proid_is_exynos5800())
1677 return exynos5420_set_spi_clk(periph_id, rate);
1678 return exynos5_set_spi_clk(periph_id, rate);
1684 int set_i2s_clk_prescaler(unsigned int src_frq, unsigned int dst_frq,
1685 unsigned int i2s_id)
1687 if (cpu_is_exynos5())
1688 return exynos5_set_i2s_clk_prescaler(src_frq, dst_frq, i2s_id);
1693 int set_i2s_clk_source(unsigned int i2s_id)
1695 if (cpu_is_exynos5())
1696 return exynos5_set_i2s_clk_source(i2s_id);
1701 int set_epll_clk(unsigned long rate)
1703 if (cpu_is_exynos5())
1704 return exynos5_set_epll_clk(rate);