2 * Copyright (C) 2010 Samsung Electronics
3 * Minkyu Kang <mk7.kang@samsung.com>
5 * See file CREDITS for list of people who contributed to this
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
26 #include <asm/arch/clock.h>
27 #include <asm/arch/clk.h>
28 #include <asm/arch/periph.h>
30 /* Epll Clock division values to achive different frequency output */
31 static struct set_epll_con_val exynos5_epll_div[] = {
32 { 192000000, 0, 48, 3, 1, 0 },
33 { 180000000, 0, 45, 3, 1, 0 },
34 { 73728000, 1, 73, 3, 3, 47710 },
35 { 67737600, 1, 90, 4, 3, 20762 },
36 { 49152000, 0, 49, 3, 3, 9961 },
37 { 45158400, 0, 45, 3, 3, 10381 },
38 { 180633600, 0, 45, 3, 1, 10381 }
41 /* exynos: return pll clock frequency */
42 static int exynos_get_pll_clk(int pllreg, unsigned int r, unsigned int k)
44 unsigned long m, p, s = 0, mask, fout;
47 * APLL_CON: MIDV [25:16]
48 * MPLL_CON: MIDV [25:16]
49 * EPLL_CON: MIDV [24:16]
50 * VPLL_CON: MIDV [24:16]
51 * BPLL_CON: MIDV [25:16]: Exynos5
53 if (pllreg == APLL || pllreg == MPLL || pllreg == BPLL)
65 freq = CONFIG_SYS_CLK_FREQ;
69 /* FOUT = (MDIV + K / 65536) * FIN / (PDIV * 2^SDIV) */
70 fout = (m + k / 65536) * (freq / (p * (1 << s)));
71 } else if (pllreg == VPLL) {
73 /* FOUT = (MDIV + K / 1024) * FIN / (PDIV * 2^SDIV) */
74 fout = (m + k / 1024) * (freq / (p * (1 << s)));
78 /* FOUT = MDIV * FIN / (PDIV * 2^(SDIV - 1)) */
79 fout = m * (freq / (p * (1 << (s - 1))));
85 /* exynos4: return pll clock frequency */
86 static unsigned long exynos4_get_pll_clk(int pllreg)
88 struct exynos4_clock *clk =
89 (struct exynos4_clock *)samsung_get_base_clock();
90 unsigned long r, k = 0;
94 r = readl(&clk->apll_con0);
97 r = readl(&clk->mpll_con0);
100 r = readl(&clk->epll_con0);
101 k = readl(&clk->epll_con1);
104 r = readl(&clk->vpll_con0);
105 k = readl(&clk->vpll_con1);
108 printf("Unsupported PLL (%d)\n", pllreg);
112 return exynos_get_pll_clk(pllreg, r, k);
115 /* exynos4x12: return pll clock frequency */
116 static unsigned long exynos4x12_get_pll_clk(int pllreg)
118 struct exynos4x12_clock *clk =
119 (struct exynos4x12_clock *)samsung_get_base_clock();
120 unsigned long r, k = 0;
124 r = readl(&clk->apll_con0);
127 r = readl(&clk->mpll_con0);
130 r = readl(&clk->epll_con0);
131 k = readl(&clk->epll_con1);
134 r = readl(&clk->vpll_con0);
135 k = readl(&clk->vpll_con1);
138 printf("Unsupported PLL (%d)\n", pllreg);
142 return exynos_get_pll_clk(pllreg, r, k);
145 /* exynos5: return pll clock frequency */
146 static unsigned long exynos5_get_pll_clk(int pllreg)
148 struct exynos5_clock *clk =
149 (struct exynos5_clock *)samsung_get_base_clock();
150 unsigned long r, k = 0, fout;
151 unsigned int pll_div2_sel, fout_sel;
155 r = readl(&clk->apll_con0);
158 r = readl(&clk->mpll_con0);
161 r = readl(&clk->epll_con0);
162 k = readl(&clk->epll_con1);
165 r = readl(&clk->vpll_con0);
166 k = readl(&clk->vpll_con1);
169 r = readl(&clk->bpll_con0);
172 printf("Unsupported PLL (%d)\n", pllreg);
176 fout = exynos_get_pll_clk(pllreg, r, k);
178 /* According to the user manual, in EVT1 MPLL and BPLL always gives
179 * 1.6GHz clock, so divide by 2 to get 800MHz MPLL clock.*/
180 if (pllreg == MPLL || pllreg == BPLL) {
181 pll_div2_sel = readl(&clk->pll_div2_sel);
185 fout_sel = (pll_div2_sel >> MPLL_FOUT_SEL_SHIFT)
186 & MPLL_FOUT_SEL_MASK;
189 fout_sel = (pll_div2_sel >> BPLL_FOUT_SEL_SHIFT)
190 & BPLL_FOUT_SEL_MASK;
204 /* exynos4: return ARM clock frequency */
205 static unsigned long exynos4_get_arm_clk(void)
207 struct exynos4_clock *clk =
208 (struct exynos4_clock *)samsung_get_base_clock();
210 unsigned long armclk;
211 unsigned int core_ratio;
212 unsigned int core2_ratio;
214 div = readl(&clk->div_cpu0);
216 /* CORE_RATIO: [2:0], CORE2_RATIO: [30:28] */
217 core_ratio = (div >> 0) & 0x7;
218 core2_ratio = (div >> 28) & 0x7;
220 armclk = get_pll_clk(APLL) / (core_ratio + 1);
221 armclk /= (core2_ratio + 1);
226 /* exynos4x12: return ARM clock frequency */
227 static unsigned long exynos4x12_get_arm_clk(void)
229 struct exynos4x12_clock *clk =
230 (struct exynos4x12_clock *)samsung_get_base_clock();
232 unsigned long armclk;
233 unsigned int core_ratio;
234 unsigned int core2_ratio;
236 div = readl(&clk->div_cpu0);
238 /* CORE_RATIO: [2:0], CORE2_RATIO: [30:28] */
239 core_ratio = (div >> 0) & 0x7;
240 core2_ratio = (div >> 28) & 0x7;
242 armclk = get_pll_clk(APLL) / (core_ratio + 1);
243 armclk /= (core2_ratio + 1);
248 /* exynos5: return ARM clock frequency */
249 static unsigned long exynos5_get_arm_clk(void)
251 struct exynos5_clock *clk =
252 (struct exynos5_clock *)samsung_get_base_clock();
254 unsigned long armclk;
255 unsigned int arm_ratio;
256 unsigned int arm2_ratio;
258 div = readl(&clk->div_cpu0);
260 /* ARM_RATIO: [2:0], ARM2_RATIO: [30:28] */
261 arm_ratio = (div >> 0) & 0x7;
262 arm2_ratio = (div >> 28) & 0x7;
264 armclk = get_pll_clk(APLL) / (arm_ratio + 1);
265 armclk /= (arm2_ratio + 1);
270 /* exynos4: return pwm clock frequency */
271 static unsigned long exynos4_get_pwm_clk(void)
273 struct exynos4_clock *clk =
274 (struct exynos4_clock *)samsung_get_base_clock();
275 unsigned long pclk, sclk;
279 if (s5p_get_cpu_rev() == 0) {
284 sel = readl(&clk->src_peril0);
285 sel = (sel >> 24) & 0xf;
288 sclk = get_pll_clk(MPLL);
290 sclk = get_pll_clk(EPLL);
292 sclk = get_pll_clk(VPLL);
300 ratio = readl(&clk->div_peril3);
302 } else if (s5p_get_cpu_rev() == 1) {
303 sclk = get_pll_clk(MPLL);
308 pclk = sclk / (ratio + 1);
313 /* exynos4x12: return pwm clock frequency */
314 static unsigned long exynos4x12_get_pwm_clk(void)
316 unsigned long pclk, sclk;
319 sclk = get_pll_clk(MPLL);
322 pclk = sclk / (ratio + 1);
327 /* exynos5: return pwm clock frequency */
328 static unsigned long exynos5_get_pwm_clk(void)
330 struct exynos5_clock *clk =
331 (struct exynos5_clock *)samsung_get_base_clock();
332 unsigned long pclk, sclk;
339 ratio = readl(&clk->div_peric3);
341 sclk = get_pll_clk(MPLL);
343 pclk = sclk / (ratio + 1);
348 /* exynos4: return uart clock frequency */
349 static unsigned long exynos4_get_uart_clk(int dev_index)
351 struct exynos4_clock *clk =
352 (struct exynos4_clock *)samsung_get_base_clock();
353 unsigned long uclk, sclk;
366 sel = readl(&clk->src_peril0);
367 sel = (sel >> (dev_index << 2)) & 0xf;
370 sclk = get_pll_clk(MPLL);
372 sclk = get_pll_clk(EPLL);
374 sclk = get_pll_clk(VPLL);
383 * UART3_RATIO [12:15]
384 * UART4_RATIO [16:19]
385 * UART5_RATIO [23:20]
387 ratio = readl(&clk->div_peril0);
388 ratio = (ratio >> (dev_index << 2)) & 0xf;
390 uclk = sclk / (ratio + 1);
395 /* exynos4x12: return uart clock frequency */
396 static unsigned long exynos4x12_get_uart_clk(int dev_index)
398 struct exynos4x12_clock *clk =
399 (struct exynos4x12_clock *)samsung_get_base_clock();
400 unsigned long uclk, sclk;
412 sel = readl(&clk->src_peril0);
413 sel = (sel >> (dev_index << 2)) & 0xf;
416 sclk = get_pll_clk(MPLL);
418 sclk = get_pll_clk(EPLL);
420 sclk = get_pll_clk(VPLL);
429 * UART3_RATIO [12:15]
430 * UART4_RATIO [16:19]
432 ratio = readl(&clk->div_peril0);
433 ratio = (ratio >> (dev_index << 2)) & 0xf;
435 uclk = sclk / (ratio + 1);
440 /* exynos5: return uart clock frequency */
441 static unsigned long exynos5_get_uart_clk(int dev_index)
443 struct exynos5_clock *clk =
444 (struct exynos5_clock *)samsung_get_base_clock();
445 unsigned long uclk, sclk;
458 sel = readl(&clk->src_peric0);
459 sel = (sel >> (dev_index << 2)) & 0xf;
462 sclk = get_pll_clk(MPLL);
464 sclk = get_pll_clk(EPLL);
466 sclk = get_pll_clk(VPLL);
475 * UART3_RATIO [12:15]
476 * UART4_RATIO [16:19]
477 * UART5_RATIO [23:20]
479 ratio = readl(&clk->div_peric0);
480 ratio = (ratio >> (dev_index << 2)) & 0xf;
482 uclk = sclk / (ratio + 1);
487 static unsigned long exynos4_get_mmc_clk(int dev_index)
489 struct exynos4_clock *clk =
490 (struct exynos4_clock *)samsung_get_base_clock();
491 unsigned long uclk, sclk;
492 unsigned int sel, ratio, pre_ratio;
495 sel = readl(&clk->src_fsys);
496 sel = (sel >> (dev_index << 2)) & 0xf;
499 sclk = get_pll_clk(MPLL);
501 sclk = get_pll_clk(EPLL);
503 sclk = get_pll_clk(VPLL);
510 ratio = readl(&clk->div_fsys1);
511 pre_ratio = readl(&clk->div_fsys1);
515 ratio = readl(&clk->div_fsys2);
516 pre_ratio = readl(&clk->div_fsys2);
519 ratio = readl(&clk->div_fsys3);
520 pre_ratio = readl(&clk->div_fsys3);
526 if (dev_index == 1 || dev_index == 3)
529 ratio = (ratio >> shift) & 0xf;
530 pre_ratio = (pre_ratio >> (shift + 8)) & 0xff;
531 uclk = (sclk / (ratio + 1)) / (pre_ratio + 1);
536 static unsigned long exynos5_get_mmc_clk(int dev_index)
538 struct exynos5_clock *clk =
539 (struct exynos5_clock *)samsung_get_base_clock();
540 unsigned long uclk, sclk;
541 unsigned int sel, ratio, pre_ratio;
544 sel = readl(&clk->src_fsys);
545 sel = (sel >> (dev_index << 2)) & 0xf;
548 sclk = get_pll_clk(MPLL);
550 sclk = get_pll_clk(EPLL);
552 sclk = get_pll_clk(VPLL);
559 ratio = readl(&clk->div_fsys1);
560 pre_ratio = readl(&clk->div_fsys1);
564 ratio = readl(&clk->div_fsys2);
565 pre_ratio = readl(&clk->div_fsys2);
571 if (dev_index == 1 || dev_index == 3)
574 ratio = (ratio >> shift) & 0xf;
575 pre_ratio = (pre_ratio >> (shift + 8)) & 0xff;
576 uclk = (sclk / (ratio + 1)) / (pre_ratio + 1);
581 /* exynos4: set the mmc clock */
582 static void exynos4_set_mmc_clk(int dev_index, unsigned int div)
584 struct exynos4_clock *clk =
585 (struct exynos4_clock *)samsung_get_base_clock();
591 * MMC0_PRE_RATIO [15:8], MMC1_PRE_RATIO [31:24]
593 * MMC2_PRE_RATIO [15:8], MMC3_PRE_RATIO [31:24]
595 * MMC4_PRE_RATIO [15:8]
598 addr = (unsigned int)&clk->div_fsys1;
599 } else if (dev_index == 4) {
600 addr = (unsigned int)&clk->div_fsys3;
603 addr = (unsigned int)&clk->div_fsys2;
608 val &= ~(0xff << ((dev_index << 4) + 8));
609 val |= (div & 0xff) << ((dev_index << 4) + 8);
613 /* exynos4x12: set the mmc clock */
614 static void exynos4x12_set_mmc_clk(int dev_index, unsigned int div)
616 struct exynos4x12_clock *clk =
617 (struct exynos4x12_clock *)samsung_get_base_clock();
623 * MMC0_PRE_RATIO [15:8], MMC1_PRE_RATIO [31:24]
625 * MMC2_PRE_RATIO [15:8], MMC3_PRE_RATIO [31:24]
628 addr = (unsigned int)&clk->div_fsys1;
630 addr = (unsigned int)&clk->div_fsys2;
635 val &= ~(0xff << ((dev_index << 4) + 8));
636 val |= (div & 0xff) << ((dev_index << 4) + 8);
640 /* exynos5: set the mmc clock */
641 static void exynos5_set_mmc_clk(int dev_index, unsigned int div)
643 struct exynos5_clock *clk =
644 (struct exynos5_clock *)samsung_get_base_clock();
650 * MMC0_PRE_RATIO [15:8], MMC1_PRE_RATIO [31:24]
652 * MMC2_PRE_RATIO [15:8], MMC3_PRE_RATIO [31:24]
655 addr = (unsigned int)&clk->div_fsys1;
657 addr = (unsigned int)&clk->div_fsys2;
662 val &= ~(0xff << ((dev_index << 4) + 8));
663 val |= (div & 0xff) << ((dev_index << 4) + 8);
667 /* get_lcd_clk: return lcd clock frequency */
668 static unsigned long exynos4_get_lcd_clk(void)
670 struct exynos4_clock *clk =
671 (struct exynos4_clock *)samsung_get_base_clock();
672 unsigned long pclk, sclk;
680 sel = readl(&clk->src_lcd0);
689 sclk = get_pll_clk(MPLL);
691 sclk = get_pll_clk(EPLL);
693 sclk = get_pll_clk(VPLL);
701 ratio = readl(&clk->div_lcd0);
704 pclk = sclk / (ratio + 1);
709 /* get_lcd_clk: return lcd clock frequency */
710 static unsigned long exynos5_get_lcd_clk(void)
712 struct exynos5_clock *clk =
713 (struct exynos5_clock *)samsung_get_base_clock();
714 unsigned long pclk, sclk;
722 sel = readl(&clk->src_disp1_0);
731 sclk = get_pll_clk(MPLL);
733 sclk = get_pll_clk(EPLL);
735 sclk = get_pll_clk(VPLL);
743 ratio = readl(&clk->div_disp1_0);
746 pclk = sclk / (ratio + 1);
751 void exynos4_set_lcd_clk(void)
753 struct exynos4_clock *clk =
754 (struct exynos4_clock *)samsung_get_base_clock();
755 unsigned int cfg = 0;
767 cfg = readl(&clk->gate_block);
769 writel(cfg, &clk->gate_block);
775 * MDNIE_PWM0_SEL [8:11]
777 * set lcd0 src clock 0x6: SCLK_MPLL
779 cfg = readl(&clk->src_lcd0);
782 writel(cfg, &clk->src_lcd0);
792 * Gating all clocks for FIMD0
794 cfg = readl(&clk->gate_ip_lcd0);
796 writel(cfg, &clk->gate_ip_lcd0);
802 * MDNIE_PWM0_RATIO [11:8]
803 * MDNIE_PWM_PRE_RATIO [15:12]
804 * MIPI0_RATIO [19:16]
805 * MIPI0_PRE_RATIO [23:20]
810 writel(cfg, &clk->div_lcd0);
813 void exynos5_set_lcd_clk(void)
815 struct exynos5_clock *clk =
816 (struct exynos5_clock *)samsung_get_base_clock();
817 unsigned int cfg = 0;
829 cfg = readl(&clk->gate_block);
831 writel(cfg, &clk->gate_block);
837 * MDNIE_PWM0_SEL [8:11]
839 * set lcd0 src clock 0x6: SCLK_MPLL
841 cfg = readl(&clk->src_disp1_0);
844 writel(cfg, &clk->src_disp1_0);
854 * Gating all clocks for FIMD0
856 cfg = readl(&clk->gate_ip_disp1);
858 writel(cfg, &clk->gate_ip_disp1);
864 * MDNIE_PWM0_RATIO [11:8]
865 * MDNIE_PWM_PRE_RATIO [15:12]
866 * MIPI0_RATIO [19:16]
867 * MIPI0_PRE_RATIO [23:20]
872 writel(cfg, &clk->div_disp1_0);
875 void exynos4_set_mipi_clk(void)
877 struct exynos4_clock *clk =
878 (struct exynos4_clock *)samsung_get_base_clock();
879 unsigned int cfg = 0;
885 * MDNIE_PWM0_SEL [8:11]
887 * set mipi0 src clock 0x6: SCLK_MPLL
889 cfg = readl(&clk->src_lcd0);
892 writel(cfg, &clk->src_lcd0);
898 * MDNIE_PWM0_MASK [8]
900 * set src mask mipi0 0x1: Unmask
902 cfg = readl(&clk->src_mask_lcd0);
904 writel(cfg, &clk->src_mask_lcd0);
914 * Gating all clocks for MIPI0
916 cfg = readl(&clk->gate_ip_lcd0);
918 writel(cfg, &clk->gate_ip_lcd0);
924 * MDNIE_PWM0_RATIO [11:8]
925 * MDNIE_PWM_PRE_RATIO [15:12]
926 * MIPI0_RATIO [19:16]
927 * MIPI0_PRE_RATIO [23:20]
932 writel(cfg, &clk->div_lcd0);
938 * exynos5: obtaining the I2C clock
940 static unsigned long exynos5_get_i2c_clk(void)
942 struct exynos5_clock *clk =
943 (struct exynos5_clock *)samsung_get_base_clock();
944 unsigned long aclk_66, aclk_66_pre, sclk;
947 sclk = get_pll_clk(MPLL);
949 ratio = (readl(&clk->div_top1)) >> 24;
951 aclk_66_pre = sclk / (ratio + 1);
952 ratio = readl(&clk->div_top0);
954 aclk_66 = aclk_66_pre / (ratio + 1);
958 int exynos5_set_epll_clk(unsigned long rate)
960 unsigned int epll_con, epll_con_k;
962 unsigned int lockcnt;
964 struct exynos5_clock *clk =
965 (struct exynos5_clock *)samsung_get_base_clock();
967 epll_con = readl(&clk->epll_con0);
968 epll_con &= ~((EPLL_CON0_LOCK_DET_EN_MASK <<
969 EPLL_CON0_LOCK_DET_EN_SHIFT) |
970 EPLL_CON0_MDIV_MASK << EPLL_CON0_MDIV_SHIFT |
971 EPLL_CON0_PDIV_MASK << EPLL_CON0_PDIV_SHIFT |
972 EPLL_CON0_SDIV_MASK << EPLL_CON0_SDIV_SHIFT);
974 for (i = 0; i < ARRAY_SIZE(exynos5_epll_div); i++) {
975 if (exynos5_epll_div[i].freq_out == rate)
979 if (i == ARRAY_SIZE(exynos5_epll_div))
982 epll_con_k = exynos5_epll_div[i].k_dsm << 0;
983 epll_con |= exynos5_epll_div[i].en_lock_det <<
984 EPLL_CON0_LOCK_DET_EN_SHIFT;
985 epll_con |= exynos5_epll_div[i].m_div << EPLL_CON0_MDIV_SHIFT;
986 epll_con |= exynos5_epll_div[i].p_div << EPLL_CON0_PDIV_SHIFT;
987 epll_con |= exynos5_epll_div[i].s_div << EPLL_CON0_SDIV_SHIFT;
990 * Required period ( in cycles) to genarate a stable clock output.
991 * The maximum clock time can be up to 3000 * PDIV cycles of PLLs
992 * frequency input (as per spec)
994 lockcnt = 3000 * exynos5_epll_div[i].p_div;
996 writel(lockcnt, &clk->epll_lock);
997 writel(epll_con, &clk->epll_con0);
998 writel(epll_con_k, &clk->epll_con1);
1000 start = get_timer(0);
1002 while (!(readl(&clk->epll_con0) &
1003 (0x1 << EXYNOS5_EPLLCON0_LOCKED_SHIFT))) {
1004 if (get_timer(start) > TIMEOUT_EPLL_LOCK) {
1005 debug("%s: Timeout waiting for EPLL lock\n", __func__);
1012 void exynos5_set_i2s_clk_source(void)
1014 struct exynos5_clock *clk =
1015 (struct exynos5_clock *)samsung_get_base_clock();
1017 clrsetbits_le32(&clk->src_peric1, AUDIO1_SEL_MASK,
1018 (CLK_SRC_SCLK_EPLL));
1021 int exynos5_set_i2s_clk_prescaler(unsigned int src_frq,
1022 unsigned int dst_frq)
1024 struct exynos5_clock *clk =
1025 (struct exynos5_clock *)samsung_get_base_clock();
1028 if ((dst_frq == 0) || (src_frq == 0)) {
1029 debug("%s: Invalid requency input for prescaler\n", __func__);
1030 debug("src frq = %d des frq = %d ", src_frq, dst_frq);
1034 div = (src_frq / dst_frq);
1035 if (div > AUDIO_1_RATIO_MASK) {
1036 debug("%s: Frequency ratio is out of range\n", __func__);
1037 debug("src frq = %d des frq = %d ", src_frq, dst_frq);
1040 clrsetbits_le32(&clk->div_peric4, AUDIO_1_RATIO_MASK,
1041 (div & AUDIO_1_RATIO_MASK));
1046 * Linearly searches for the most accurate main and fine stage clock scalars
1047 * (divisors) for a specified target frequency and scalar bit sizes by checking
1048 * all multiples of main_scalar_bits values. Will always return scalars up to or
1049 * slower than target.
1051 * @param main_scalar_bits Number of main scalar bits, must be > 0 and < 32
1052 * @param fine_scalar_bits Number of fine scalar bits, must be > 0 and < 32
1053 * @param input_freq Clock frequency to be scaled in Hz
1054 * @param target_freq Desired clock frequency in Hz
1055 * @param best_fine_scalar Pointer to store the fine stage divisor
1057 * @return best_main_scalar Main scalar for desired frequency or -1 if none
1060 static int clock_calc_best_scalar(unsigned int main_scaler_bits,
1061 unsigned int fine_scalar_bits, unsigned int input_rate,
1062 unsigned int target_rate, unsigned int *best_fine_scalar)
1065 int best_main_scalar = -1;
1066 unsigned int best_error = target_rate;
1067 const unsigned int cap = (1 << fine_scalar_bits) - 1;
1068 const unsigned int loops = 1 << main_scaler_bits;
1070 debug("Input Rate is %u, Target is %u, Cap is %u\n", input_rate,
1073 assert(best_fine_scalar != NULL);
1074 assert(main_scaler_bits <= fine_scalar_bits);
1076 *best_fine_scalar = 1;
1078 if (input_rate == 0 || target_rate == 0)
1081 if (target_rate >= input_rate)
1084 for (i = 1; i <= loops; i++) {
1085 const unsigned int effective_div = max(min(input_rate / i /
1086 target_rate, cap), 1);
1087 const unsigned int effective_rate = input_rate / i /
1089 const int error = target_rate - effective_rate;
1091 debug("%d|effdiv:%u, effrate:%u, error:%d\n", i, effective_div,
1092 effective_rate, error);
1094 if (error >= 0 && error <= best_error) {
1096 best_main_scalar = i;
1097 *best_fine_scalar = effective_div;
1101 return best_main_scalar;
1104 static int exynos5_set_spi_clk(enum periph_id periph_id,
1107 struct exynos5_clock *clk =
1108 (struct exynos5_clock *)samsung_get_base_clock();
1111 unsigned shift, pre_shift;
1112 unsigned mask = 0xff;
1115 main = clock_calc_best_scalar(4, 8, 400000000, rate, &fine);
1117 debug("%s: Cannot set clock rate for periph %d",
1118 __func__, periph_id);
1124 switch (periph_id) {
1125 case PERIPH_ID_SPI0:
1126 reg = &clk->div_peric1;
1130 case PERIPH_ID_SPI1:
1131 reg = &clk->div_peric1;
1135 case PERIPH_ID_SPI2:
1136 reg = &clk->div_peric2;
1140 case PERIPH_ID_SPI3:
1141 reg = &clk->sclk_div_isp;
1145 case PERIPH_ID_SPI4:
1146 reg = &clk->sclk_div_isp;
1151 debug("%s: Unsupported peripheral ID %d\n", __func__,
1155 clrsetbits_le32(reg, mask << shift, (main & mask) << shift);
1156 clrsetbits_le32(reg, mask << pre_shift, (fine & mask) << pre_shift);
1161 static unsigned long exynos4_get_i2c_clk(void)
1163 struct exynos4_clock *clk =
1164 (struct exynos4_clock *)samsung_get_base_clock();
1165 unsigned long sclk, aclk_100;
1168 sclk = get_pll_clk(APLL);
1170 ratio = (readl(&clk->div_top)) >> 4;
1172 aclk_100 = sclk / (ratio + 1);
1176 unsigned long get_pll_clk(int pllreg)
1178 if (cpu_is_exynos5())
1179 return exynos5_get_pll_clk(pllreg);
1181 if (proid_is_exynos4412())
1182 return exynos4x12_get_pll_clk(pllreg);
1183 return exynos4_get_pll_clk(pllreg);
1187 unsigned long get_arm_clk(void)
1189 if (cpu_is_exynos5())
1190 return exynos5_get_arm_clk();
1192 if (proid_is_exynos4412())
1193 return exynos4x12_get_arm_clk();
1194 return exynos4_get_arm_clk();
1198 unsigned long get_i2c_clk(void)
1200 if (cpu_is_exynos5()) {
1201 return exynos5_get_i2c_clk();
1202 } else if (cpu_is_exynos4()) {
1203 return exynos4_get_i2c_clk();
1205 debug("I2C clock is not set for this CPU\n");
1210 unsigned long get_pwm_clk(void)
1212 if (cpu_is_exynos5())
1213 return exynos5_get_pwm_clk();
1215 if (proid_is_exynos4412())
1216 return exynos4x12_get_pwm_clk();
1217 return exynos4_get_pwm_clk();
1221 unsigned long get_uart_clk(int dev_index)
1223 if (cpu_is_exynos5())
1224 return exynos5_get_uart_clk(dev_index);
1226 if (proid_is_exynos4412())
1227 return exynos4x12_get_uart_clk(dev_index);
1228 return exynos4_get_uart_clk(dev_index);
1232 unsigned long get_mmc_clk(int dev_index)
1234 if (cpu_is_exynos5())
1235 return exynos5_get_mmc_clk(dev_index);
1237 return exynos4_get_mmc_clk(dev_index);
1240 void set_mmc_clk(int dev_index, unsigned int div)
1242 if (cpu_is_exynos5())
1243 exynos5_set_mmc_clk(dev_index, div);
1245 if (proid_is_exynos4412())
1246 exynos4x12_set_mmc_clk(dev_index, div);
1247 exynos4_set_mmc_clk(dev_index, div);
1251 unsigned long get_lcd_clk(void)
1253 if (cpu_is_exynos4())
1254 return exynos4_get_lcd_clk();
1256 return exynos5_get_lcd_clk();
1259 void set_lcd_clk(void)
1261 if (cpu_is_exynos4())
1262 exynos4_set_lcd_clk();
1264 exynos5_set_lcd_clk();
1267 void set_mipi_clk(void)
1269 if (cpu_is_exynos4())
1270 exynos4_set_mipi_clk();
1273 int set_spi_clk(int periph_id, unsigned int rate)
1275 if (cpu_is_exynos5())
1276 return exynos5_set_spi_clk(periph_id, rate);
1281 int set_i2s_clk_prescaler(unsigned int src_frq, unsigned int dst_frq)
1284 if (cpu_is_exynos5())
1285 return exynos5_set_i2s_clk_prescaler(src_frq, dst_frq);
1290 void set_i2s_clk_source(void)
1292 if (cpu_is_exynos5())
1293 exynos5_set_i2s_clk_source();
1296 int set_epll_clk(unsigned long rate)
1298 if (cpu_is_exynos5())
1299 return exynos5_set_epll_clk(rate);