2 * (C) Copyright 2000-2004
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
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/processor.h>
28 DECLARE_GLOBAL_DATA_PTR
;
30 #if !defined(CONFIG_8xx_CPUCLK_DEFAULT) || defined(CFG_MEASURE_CPUCLK) || defined(DEBUG)
34 /* pitc values to time for 58/8192 seconds (about 70.8 milliseconds) */
35 #define SPEED_PIT_COUNTS 58
36 #define SPEED_PITC ((SPEED_PIT_COUNTS - 1) << PITC_SHIFT)
37 #define SPEED_PITC_INIT ((SPEED_PIT_COUNTS + 1) << PITC_SHIFT)
39 /* Access functions for the Machine State Register */
40 static __inline__
unsigned long get_msr(void)
44 asm volatile("mfmsr %0" : "=r" (msr
) :);
48 static __inline__
void set_msr(unsigned long msr
)
50 asm volatile("mtmsr %0" : : "r" (msr
));
53 /* ------------------------------------------------------------------------- */
56 * Measure CPU clock speed (core clock GCLK1, GCLK2),
57 * also determine bus clock speed (checking bus divider factor)
59 * (Approx. GCLK frequency in Hz)
61 * Initializes timer 2 and PIT, but disables them before return.
62 * [Use timer 2, because MPC823 CPUs mask 0.x do not have timers 3 and 4]
64 * When measuring the CPU clock against the PIT, we count cpu clocks
65 * for 58/8192 seconds with a prescale divide by 177 for the cpu clock.
66 * These strange values for the timing interval and prescaling are used
67 * because the formula for the CPU clock is:
69 * CPU clock = count * (177 * (8192 / 58))
71 * = count * 24999.7241
73 * which is very close to
77 * Since the count gives the CPU clock divided by 25000, we can get
78 * the CPU clock rounded to the nearest 0.1 MHz by
80 * CPU clock = ((count + 2) / 4) * 100000;
82 * The rounding is important since the measurement is sometimes going
83 * to be high or low by 0.025 MHz, depending on exactly how the clocks
84 * and counters interact. By rounding we get the exact answer for any
85 * CPU clock that is an even multiple of 0.1 MHz.
88 unsigned long measure_gclk(void)
90 volatile immap_t
*immr
= (immap_t
*) CFG_IMMR
;
91 volatile cpmtimer8xx_t
*timerp
= &immr
->im_cpmtimer
;
96 /* dont use OSCM, only use EXTCLK/512 */
97 immr
->im_clkrst
.car_sccr
|= SCCR_RTSEL
| SCCR_RTDIV
;
99 immr
->im_clkrst
.car_sccr
&= ~(SCCR_RTSEL
| SCCR_RTDIV
);
102 /* Reset + Stop Timer 2, no cascading
104 timerp
->cpmt_tgcr
&= ~(TGCR_CAS2
| TGCR_RST2
);
106 /* Keep stopped, halt in debug mode
108 timerp
->cpmt_tgcr
|= (TGCR_FRZ2
| TGCR_STP2
);
111 * Output ref. interrupt disable, int. clock
112 * Prescale by 177. Note that prescaler divides by value + 1
113 * so we must subtract 1 here.
115 timerp
->cpmt_tmr2
= ((177 - 1) << TMR_PS_SHIFT
) | TMR_ICLK_IN_GEN
;
117 timerp
->cpmt_tcn2
= 0; /* reset state */
118 timerp
->cpmt_tgcr
|= TGCR_RST2
; /* enable timer 2 */
123 * We want to time for SPEED_PITC_COUNTS counts (of 8192 Hz),
124 * so the count value would be SPEED_PITC_COUNTS - 1.
125 * But there would be an uncertainty in the start time of 1/4
126 * count since when we enable the PIT the count is not
127 * synchronized to the 32768 Hz oscillator. The trick here is
128 * to start the count higher and wait until the PIT count
129 * changes to the required value before starting timer 2.
131 * One count high should be enough, but occasionally the start
132 * is off by 1 or 2 counts of 32768 Hz. With the start value
133 * set two counts high it seems very reliable.
136 immr
->im_sitk
.sitk_pitck
= KAPWR_KEY
; /* PIT initialization */
137 immr
->im_sit
.sit_pitc
= SPEED_PITC_INIT
;
139 immr
->im_sitk
.sitk_piscrk
= KAPWR_KEY
;
140 immr
->im_sit
.sit_piscr
= CFG_PISCR
;
143 * Start measurement - disable interrupts, just in case
145 msr_val
= get_msr ();
146 set_msr (msr_val
& ~MSR_EE
);
148 immr
->im_sit
.sit_piscr
|= PISCR_PTE
;
150 /* spin until get exact count when we want to start */
151 while (immr
->im_sit
.sit_pitr
> SPEED_PITC
);
153 timerp
->cpmt_tgcr
&= ~TGCR_STP2
; /* Start Timer 2 */
154 while ((immr
->im_sit
.sit_piscr
& PISCR_PS
) == 0);
155 timerp
->cpmt_tgcr
|= TGCR_STP2
; /* Stop Timer 2 */
157 /* re-enable external interrupts if they were on */
160 /* Disable timer and PIT
162 timer2_val
= timerp
->cpmt_tcn2
; /* save before reset timer */
164 timerp
->cpmt_tgcr
&= ~(TGCR_RST2
| TGCR_FRZ2
| TGCR_STP2
);
165 immr
->im_sit
.sit_piscr
&= ~PISCR_PTE
;
167 #if defined(CFG_8XX_XIN)
168 /* not using OSCM, using XIN, so scale appropriately */
169 return (((timer2_val
+ 2) / 4) * (CFG_8XX_XIN
/512))/8192 * 100000L;
171 return ((timer2_val
+ 2) / 4) * 100000L; /* convert to Hz */
177 #if !defined(CONFIG_8xx_CPUCLK_DEFAULT)
180 * get_clocks() fills in gd->cpu_clock depending on CONFIG_8xx_GCLK_FREQ
181 * or (if it is not defined) measure_gclk() (which uses the ref clock)
184 int get_clocks (void)
186 uint immr
= get_immr (0); /* Return full IMMR contents */
187 volatile immap_t
*immap
= (immap_t
*) (immr
& 0xFFFF0000);
188 uint sccr
= immap
->im_clkrst
.car_sccr
;
190 * If for some reason measuring the gclk frequency won't
191 * work, we return the hardwired value.
192 * (For example, the cogent CMA286-60 CPU module has no
193 * separate oscillator for PITRTCLK)
195 #if defined(CONFIG_8xx_GCLK_FREQ)
196 gd
->cpu_clk
= CONFIG_8xx_GCLK_FREQ
;
197 #elif defined(CONFIG_8xx_OSCLK)
198 #define PLPRCR_val(a) ((pll & PLPRCR_ ## a ## _MSK) >> PLPRCR_ ## a ## _SHIFT)
199 uint pll
= immap
->im_clkrst
.car_plprcr
;
202 if ((immr
& 0x0FFF) >= MPC8xx_NEW_CLK
) { /* MPC866/87x/88x series */
203 clk
= ((CONFIG_8xx_OSCLK
/ (PLPRCR_val(PDF
)+1)) *
204 (PLPRCR_val(MFI
) + PLPRCR_val(MFN
) / (PLPRCR_val(MFD
)+1))) /
207 clk
= CONFIG_8xx_OSCLK
* (PLPRCR_val(MF
)+1);
209 if (pll
& PLPRCR_CSRC
) { /* Low frequency division factor is used */
210 gd
->cpu_clk
= clk
/ (2 << ((sccr
>> 8) & 7));
211 } else { /* High frequency division factor is used */
212 gd
->cpu_clk
= clk
/ (1 << ((sccr
>> 5) & 7));
215 gd
->cpu_clk
= measure_gclk();
216 #endif /* CONFIG_8xx_GCLK_FREQ */
218 if ((sccr
& SCCR_EBDF11
) == 0) {
219 /* No Bus Divider active */
220 gd
->bus_clk
= gd
->cpu_clk
;
222 /* The MPC8xx has only one BDF: half clock speed */
223 gd
->bus_clk
= gd
->cpu_clk
/ 2;
229 #else /* CONFIG_8xx_CPUCLK_DEFAULT defined, use dynamic clock setting */
231 static long init_pll_866 (long clk
);
233 /* This function sets up PLL (init_pll_866() is called) and
234 * fills gd->cpu_clk and gd->bus_clk according to the environment
235 * variable 'cpuclk' or to CONFIG_8xx_CPUCLK_DEFAULT (if 'cpuclk'
236 * contains invalid value).
237 * This functions requires an MPC866 or newer series CPU.
239 int get_clocks_866 (void)
241 volatile immap_t
*immr
= (immap_t
*) CFG_IMMR
;
246 if (getenv_r ("cpuclk", tmp
, sizeof (tmp
)) > 0)
247 cpuclk
= simple_strtoul (tmp
, NULL
, 10) * 1000000;
249 if ((CFG_8xx_CPUCLK_MIN
> cpuclk
) || (CFG_8xx_CPUCLK_MAX
< cpuclk
))
250 cpuclk
= CONFIG_8xx_CPUCLK_DEFAULT
;
252 gd
->cpu_clk
= init_pll_866 (cpuclk
);
253 #if defined(CFG_MEASURE_CPUCLK)
254 gd
->cpu_clk
= measure_gclk ();
257 /* if cpu clock <= 66 MHz then set bus division factor to 1,
258 * otherwise set it to 2
260 sccr_reg
= immr
->im_clkrst
.car_sccr
;
261 sccr_reg
&= ~SCCR_EBDF11
;
263 if (gd
->cpu_clk
<= 66000000) {
264 sccr_reg
|= SCCR_EBDF00
; /* bus division factor = 1 */
265 gd
->bus_clk
= gd
->cpu_clk
;
267 sccr_reg
|= SCCR_EBDF01
; /* bus division factor = 2 */
268 gd
->bus_clk
= gd
->cpu_clk
/ 2;
270 immr
->im_clkrst
.car_sccr
= sccr_reg
;
275 /* Adjust sdram refresh rate to actual CPU clock.
277 int sdram_adjust_866 (void)
279 volatile immap_t
*immr
= (immap_t
*) CFG_IMMR
;
282 mamr
= immr
->im_memctl
.memc_mamr
;
283 mamr
&= ~MAMR_PTA_MSK
;
284 mamr
|= ((gd
->cpu_clk
/ CFG_PTA_PER_CLK
) << MAMR_PTA_SHIFT
);
285 immr
->im_memctl
.memc_mamr
= mamr
;
290 /* Configure PLL for MPC866/859/885 CPU series
291 * PLL multiplication factor is set to the value nearest to the desired clk,
292 * assuming a oscclk of 10 MHz.
294 static long init_pll_866 (long clk
)
296 extern void plprcr_write_866 (long);
298 volatile immap_t
*immr
= (immap_t
*) CFG_IMMR
;
300 char mfi
, mfn
, mfd
, s
, pdf
;
301 long step_mfi
, step_mfn
;
303 if (clk
< 20000000) {
310 if (clk
< 40000000) {
312 step_mfi
= CONFIG_8xx_OSCLK
/ 4;
314 step_mfn
= CONFIG_8xx_OSCLK
/ 30;
315 } else if (clk
< 80000000) {
317 step_mfi
= CONFIG_8xx_OSCLK
/ 2;
319 step_mfn
= CONFIG_8xx_OSCLK
/ 30;
322 step_mfi
= CONFIG_8xx_OSCLK
;
324 step_mfn
= CONFIG_8xx_OSCLK
/ 30;
327 /* Calculate integer part of multiplication factor
332 /* Calculate numerator of fractional part of multiplication factor
334 n
= clk
- (n
* step_mfi
);
335 mfn
= (char)(n
/ step_mfn
);
337 /* Calculate effective clk
339 n
= ((mfi
* step_mfi
) + (mfn
* step_mfn
)) / (pdf
+ 1);
341 immr
->im_clkrstk
.cark_plprcrk
= KAPWR_KEY
;
343 plprcr
= (immr
->im_clkrst
.car_plprcr
& ~(PLPRCR_MFN_MSK
344 | PLPRCR_MFD_MSK
| PLPRCR_S_MSK
345 | PLPRCR_MFI_MSK
| PLPRCR_DBRMO
347 | (mfn
<< PLPRCR_MFN_SHIFT
)
348 | (mfd
<< PLPRCR_MFD_SHIFT
)
349 | (s
<< PLPRCR_S_SHIFT
)
350 | (mfi
<< PLPRCR_MFI_SHIFT
)
351 | (pdf
<< PLPRCR_PDF_SHIFT
);
353 if( (mfn
> 0) && ((mfd
/ mfn
) > 10) )
354 plprcr
|= PLPRCR_DBRMO
;
356 plprcr_write_866 (plprcr
); /* set value using SIU4/9 workaround */
357 immr
->im_clkrstk
.cark_plprcrk
= 0x00000000;
362 #endif /* CONFIG_8xx_CPUCLK_DEFAULT */
364 #if defined(CONFIG_TQM8xxL) && !defined(CONFIG_TQM866M) \
365 && !defined(CONFIG_TQM885D)
367 * Adjust sdram refresh rate to actual CPU clock
368 * and set timebase source according to actual CPU clock
370 int adjust_sdram_tbs_8xx (void)
372 volatile immap_t
*immr
= (immap_t
*) CFG_IMMR
;
376 mamr
= immr
->im_memctl
.memc_mamr
;
377 mamr
&= ~MAMR_PTA_MSK
;
378 mamr
|= ((gd
->cpu_clk
/ CFG_PTA_PER_CLK
) << MAMR_PTA_SHIFT
);
379 immr
->im_memctl
.memc_mamr
= mamr
;
381 if (gd
->cpu_clk
< 67000000) {
382 sccr
= immr
->im_clkrst
.car_sccr
;
384 immr
->im_clkrst
.car_sccr
= sccr
;
389 #endif /* CONFIG_TQM8xxL/M, !TQM866M, !TQM885D */
391 /* ------------------------------------------------------------------------- */