2 * Freescale i.MX28 clock setup code
4 * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
5 * on behalf of DENX Software Engineering GmbH
7 * Based on code from LTIB:
8 * Copyright (C) 2010 Freescale Semiconductor, Inc.
10 * See file CREDITS for list of people who contributed to this
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License as
15 * published by the Free Software Foundation; either version 2 of
16 * the License, or (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
30 #include <asm/errno.h>
32 #include <asm/arch/clock.h>
33 #include <asm/arch/imx-regs.h>
35 /* The PLL frequency is always 480MHz, see section 10.2 in iMX28 datasheet. */
36 #define PLL_FREQ_KHZ 480000
37 #define PLL_FREQ_COEF 18
38 /* The XTAL frequency is always 24MHz, see section 10.2 in iMX28 datasheet. */
39 #define XTAL_FREQ_KHZ 24000
41 #define PLL_FREQ_MHZ (PLL_FREQ_KHZ / 1000)
42 #define XTAL_FREQ_MHZ (XTAL_FREQ_KHZ / 1000)
44 static struct mxs_clkctrl_regs *clkctrl_regs = (void *)MXS_CLKCTRL_BASE;
46 static uint32_t mx28_get_pclk(void)
48 uint32_t clkctrl, clkseq, div;
49 uint8_t clkfrac, frac;
51 clkctrl = readl(&clkctrl_regs->hw_clkctrl_cpu);
53 /* No support of fractional divider calculation */
55 (CLKCTRL_CPU_DIV_XTAL_FRAC_EN | CLKCTRL_CPU_DIV_CPU_FRAC_EN)) {
59 clkseq = readl(&clkctrl_regs->hw_clkctrl_clkseq);
62 if (clkseq & CLKCTRL_CLKSEQ_BYPASS_CPU) {
63 div = (clkctrl & CLKCTRL_CPU_DIV_XTAL_MASK) >>
64 CLKCTRL_CPU_DIV_XTAL_OFFSET;
65 return XTAL_FREQ_MHZ / div;
69 clkfrac = readb(&clkctrl_regs->hw_clkctrl_frac0[CLKCTRL_FRAC0_CPU]);
70 frac = clkfrac & CLKCTRL_FRAC_FRAC_MASK;
71 div = clkctrl & CLKCTRL_CPU_DIV_CPU_MASK;
72 return (PLL_FREQ_MHZ * PLL_FREQ_COEF / frac) / div;
75 static uint32_t mx28_get_hclk(void)
80 clkctrl = readl(&clkctrl_regs->hw_clkctrl_hbus);
82 /* No support of fractional divider calculation */
83 if (clkctrl & CLKCTRL_HBUS_DIV_FRAC_EN)
86 div = clkctrl & CLKCTRL_HBUS_DIV_MASK;
87 return mx28_get_pclk() / div;
90 static uint32_t mx28_get_emiclk(void)
92 uint32_t clkctrl, clkseq, div;
93 uint8_t clkfrac, frac;
95 clkseq = readl(&clkctrl_regs->hw_clkctrl_clkseq);
96 clkctrl = readl(&clkctrl_regs->hw_clkctrl_emi);
99 if (clkseq & CLKCTRL_CLKSEQ_BYPASS_EMI) {
100 div = (clkctrl & CLKCTRL_EMI_DIV_XTAL_MASK) >>
101 CLKCTRL_EMI_DIV_XTAL_OFFSET;
102 return XTAL_FREQ_MHZ / div;
106 clkfrac = readb(&clkctrl_regs->hw_clkctrl_frac0[CLKCTRL_FRAC0_EMI]);
107 frac = clkfrac & CLKCTRL_FRAC_FRAC_MASK;
108 div = clkctrl & CLKCTRL_EMI_DIV_EMI_MASK;
109 return (PLL_FREQ_MHZ * PLL_FREQ_COEF / frac) / div;
112 static uint32_t mx28_get_gpmiclk(void)
114 uint32_t clkctrl, clkseq, div;
115 uint8_t clkfrac, frac;
117 clkseq = readl(&clkctrl_regs->hw_clkctrl_clkseq);
118 clkctrl = readl(&clkctrl_regs->hw_clkctrl_gpmi);
121 if (clkseq & CLKCTRL_CLKSEQ_BYPASS_GPMI) {
122 div = clkctrl & CLKCTRL_GPMI_DIV_MASK;
123 return XTAL_FREQ_MHZ / div;
127 clkfrac = readb(&clkctrl_regs->hw_clkctrl_frac1[CLKCTRL_FRAC1_GPMI]);
128 frac = clkfrac & CLKCTRL_FRAC_FRAC_MASK;
129 div = clkctrl & CLKCTRL_GPMI_DIV_MASK;
130 return (PLL_FREQ_MHZ * PLL_FREQ_COEF / frac) / div;
134 * Set IO clock frequency, in kHz
136 void mx28_set_ioclk(enum mxs_ioclock io, uint32_t freq)
144 if ((io < MXC_IOCLK0) || (io > MXC_IOCLK1))
147 div = (PLL_FREQ_KHZ * PLL_FREQ_COEF) / freq;
155 io_reg = CLKCTRL_FRAC0_IO0 - io; /* Register order is reversed */
156 writeb(CLKCTRL_FRAC_CLKGATE,
157 &clkctrl_regs->hw_clkctrl_frac0_set[io_reg]);
158 writeb(CLKCTRL_FRAC_CLKGATE | (div & CLKCTRL_FRAC_FRAC_MASK),
159 &clkctrl_regs->hw_clkctrl_frac0[io_reg]);
160 writeb(CLKCTRL_FRAC_CLKGATE,
161 &clkctrl_regs->hw_clkctrl_frac0_clr[io_reg]);
165 * Get IO clock, returns IO clock in kHz
167 static uint32_t mx28_get_ioclk(enum mxs_ioclock io)
172 if ((io < MXC_IOCLK0) || (io > MXC_IOCLK1)) {
173 printf("%s: IO clock selector %u out of range %u..%u\n",
174 __func__, io, MXC_IOCLK0, MXC_IOCLK1);
177 io_reg = CLKCTRL_FRAC0_IO0 - io; /* Register order is reversed */
179 ret = readb(&clkctrl_regs->hw_clkctrl_frac0[io_reg]) &
180 CLKCTRL_FRAC_FRAC_MASK;
182 return (PLL_FREQ_KHZ * PLL_FREQ_COEF) / ret;
186 * Configure SSP clock frequency, in kHz
188 void mx28_set_sspclk(enum mxs_sspclock ssp, uint32_t freq, int xtal)
190 uint32_t clk, clkreg;
192 if (ssp > MXC_SSPCLK3)
195 clkreg = (uint32_t)(&clkctrl_regs->hw_clkctrl_ssp0) +
196 (ssp * sizeof(struct mxs_register_32));
198 clrbits_le32(clkreg, CLKCTRL_SSP_CLKGATE);
199 while (readl(clkreg) & CLKCTRL_SSP_CLKGATE)
205 clk = mx28_get_ioclk(ssp >> 1);
210 /* Calculate the divider and cap it if necessary */
212 if (clk > CLKCTRL_SSP_DIV_MASK)
213 clk = CLKCTRL_SSP_DIV_MASK;
215 clrsetbits_le32(clkreg, CLKCTRL_SSP_DIV_MASK, clk);
216 while (readl(clkreg) & CLKCTRL_SSP_BUSY)
220 writel(CLKCTRL_CLKSEQ_BYPASS_SSP0 << ssp,
221 &clkctrl_regs->hw_clkctrl_clkseq_set);
223 writel(CLKCTRL_CLKSEQ_BYPASS_SSP0 << ssp,
224 &clkctrl_regs->hw_clkctrl_clkseq_clr);
228 * Return SSP frequency, in kHz
230 static uint32_t mx28_get_sspclk(enum mxs_sspclock ssp)
235 if (ssp > MXC_SSPCLK3)
238 tmp = readl(&clkctrl_regs->hw_clkctrl_clkseq);
239 if (tmp & (CLKCTRL_CLKSEQ_BYPASS_SSP0 << ssp))
240 return XTAL_FREQ_KHZ;
242 clkreg = &clkctrl_regs->hw_clkctrl_ssp0 +
243 ssp * sizeof(struct mxs_register_32);
245 tmp = readl(clkreg) & CLKCTRL_SSP_DIV_MASK;
249 clk = mx28_get_ioclk(ssp >> 1);
254 * Set SSP/MMC bus frequency, in kHz)
256 void mx28_set_ssp_busclock(unsigned int bus, uint32_t freq)
258 struct mxs_ssp_regs *ssp_regs;
259 const uint32_t sspclk = mx28_get_sspclk(bus);
261 uint32_t divide, rate, tgtclk;
263 ssp_regs = (struct mxs_ssp_regs *)(MXS_SSP0_BASE + (bus * 0x2000));
266 * SSP bit rate = SSPCLK / (CLOCK_DIVIDE * (1 + CLOCK_RATE)),
267 * CLOCK_DIVIDE has to be an even value from 2 to 254, and
268 * CLOCK_RATE could be any integer from 0 to 255.
270 for (divide = 2; divide < 254; divide += 2) {
271 rate = sspclk / freq / divide;
276 tgtclk = sspclk / divide / rate;
277 while (tgtclk > freq) {
279 tgtclk = sspclk / divide / rate;
284 /* Always set timeout the maximum */
285 reg = SSP_TIMING_TIMEOUT_MASK |
286 (divide << SSP_TIMING_CLOCK_DIVIDE_OFFSET) |
287 ((rate - 1) << SSP_TIMING_CLOCK_RATE_OFFSET);
288 writel(reg, &ssp_regs->hw_ssp_timing);
290 debug("SPI%d: Set freq rate to %d KHz (requested %d KHz)\n",
294 static uint32_t mx28_get_xbus_clk(void)
296 struct mxs_clkctrl_regs *clkctrl_regs =
297 (struct mxs_clkctrl_regs *)MXS_CLKCTRL_BASE;
300 uint32_t refclk = mx28_get_pclk();
302 clkctrl = readl(&clkctrl_regs->hw_clkctrl_xbus);
303 div = clkctrl & CLKCTRL_XBUS_DIV_MASK;
305 if (clkctrl & CLKCTRL_XBUS_DIV_FRAC_EN)
311 uint32_t mxc_get_clock(enum mxc_clock clk)
315 return mx28_get_pclk() * 1000000;
317 return mx28_get_gpmiclk() * 1000000;
320 return mx28_get_hclk() * 1000000;
322 return mx28_get_emiclk();
324 return mx28_get_ioclk(MXC_IOCLK0);
326 return mx28_get_ioclk(MXC_IOCLK1);
328 return mx28_get_sspclk(MXC_SSPCLK0);
330 return mx28_get_sspclk(MXC_SSPCLK1);
332 return mx28_get_sspclk(MXC_SSPCLK2);
334 return mx28_get_sspclk(MXC_SSPCLK3);
336 return XTAL_FREQ_KHZ * 1000;
338 return mx28_get_xbus_clk() * 1000000;
340 printf("Invalid clock selector %u\n", clk);