?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / arch / m68k / coldfire / m53xx.c
blob075722c0c4f00fa6a208a84e187b25452b76bb78
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /***************************************************************************/
3
4 /*
5 * m53xx.c -- platform support for ColdFire 53xx based boards
6 *
7 * Copyright (C) 1999-2002, Greg Ungerer (gerg@snapgear.com)
8 * Copyright (C) 2000, Lineo (www.lineo.com)
9 * Yaroslav Vinogradov yaroslav.vinogradov@freescale.com
10 * Copyright Freescale Semiconductor, Inc 2006
11 * Copyright (c) 2006, emlix, Sebastian Hess <shess@hessware.de>
12 */
13
14 /***************************************************************************/
15
16 #include <linux/kernel.h>
17 #include <linux/param.h>
18 #include <linux/init.h>
19 #include <linux/io.h>
20 #include <asm/machdep.h>
21 #include <asm/coldfire.h>
22 #include <asm/mcfsim.h>
23 #include <asm/mcfuart.h>
24 #include <asm/mcfdma.h>
25 #include <asm/mcfwdebug.h>
26 #include <asm/mcfclk.h>
27
28 /***************************************************************************/
29
30 DEFINE_CLK(0, "flexbus", 2, MCF_CLK);
31 DEFINE_CLK(0, "mcfcan.0", 8, MCF_CLK);
32 DEFINE_CLK(0, "fec.0", 12, MCF_CLK);
33 DEFINE_CLK(0, "edma", 17, MCF_CLK);
34 DEFINE_CLK(0, "intc.0", 18, MCF_CLK);
35 DEFINE_CLK(0, "intc.1", 19, MCF_CLK);
36 DEFINE_CLK(0, "iack.0", 21, MCF_CLK);
37 DEFINE_CLK(0, "imx1-i2c.0", 22, MCF_CLK);
38 DEFINE_CLK(0, "mcfqspi.0", 23, MCF_CLK);
39 DEFINE_CLK(0, "mcfuart.0", 24, MCF_BUSCLK);
40 DEFINE_CLK(0, "mcfuart.1", 25, MCF_BUSCLK);
41 DEFINE_CLK(0, "mcfuart.2", 26, MCF_BUSCLK);
42 DEFINE_CLK(0, "mcftmr.0", 28, MCF_CLK);
43 DEFINE_CLK(0, "mcftmr.1", 29, MCF_CLK);
44 DEFINE_CLK(0, "mcftmr.2", 30, MCF_CLK);
45 DEFINE_CLK(0, "mcftmr.3", 31, MCF_CLK);
46
47 DEFINE_CLK(0, "mcfpit.0", 32, MCF_CLK);
48 DEFINE_CLK(0, "mcfpit.1", 33, MCF_CLK);
49 DEFINE_CLK(0, "mcfpit.2", 34, MCF_CLK);
50 DEFINE_CLK(0, "mcfpit.3", 35, MCF_CLK);
51 DEFINE_CLK(0, "mcfpwm.0", 36, MCF_CLK);
52 DEFINE_CLK(0, "mcfeport.0", 37, MCF_CLK);
53 DEFINE_CLK(0, "mcfwdt.0", 38, MCF_CLK);
54 DEFINE_CLK(0, "sys.0", 40, MCF_BUSCLK);
55 DEFINE_CLK(0, "gpio.0", 41, MCF_BUSCLK);
56 DEFINE_CLK(0, "mcfrtc.0", 42, MCF_CLK);
57 DEFINE_CLK(0, "mcflcd.0", 43, MCF_CLK);
58 DEFINE_CLK(0, "mcfusb-otg.0", 44, MCF_CLK);
59 DEFINE_CLK(0, "mcfusb-host.0", 45, MCF_CLK);
60 DEFINE_CLK(0, "sdram.0", 46, MCF_CLK);
61 DEFINE_CLK(0, "ssi.0", 47, MCF_CLK);
62 DEFINE_CLK(0, "pll.0", 48, MCF_CLK);
63
64 DEFINE_CLK(1, "mdha.0", 32, MCF_CLK);
65 DEFINE_CLK(1, "skha.0", 33, MCF_CLK);
66 DEFINE_CLK(1, "rng.0", 34, MCF_CLK);
67
68 struct clk *mcf_clks[] = {
69 &__clk_0_2, /* flexbus */
70 &__clk_0_8, /* mcfcan.0 */
71 &__clk_0_12, /* fec.0 */
72 &__clk_0_17, /* edma */
73 &__clk_0_18, /* intc.0 */
74 &__clk_0_19, /* intc.1 */
75 &__clk_0_21, /* iack.0 */
76 &__clk_0_22, /* imx1-i2c.0 */
77 &__clk_0_23, /* mcfqspi.0 */
78 &__clk_0_24, /* mcfuart.0 */
79 &__clk_0_25, /* mcfuart.1 */
80 &__clk_0_26, /* mcfuart.2 */
81 &__clk_0_28, /* mcftmr.0 */
82 &__clk_0_29, /* mcftmr.1 */
83 &__clk_0_30, /* mcftmr.2 */
84 &__clk_0_31, /* mcftmr.3 */
85
86 &__clk_0_32, /* mcfpit.0 */
87 &__clk_0_33, /* mcfpit.1 */
88 &__clk_0_34, /* mcfpit.2 */
89 &__clk_0_35, /* mcfpit.3 */
90 &__clk_0_36, /* mcfpwm.0 */
91 &__clk_0_37, /* mcfeport.0 */
92 &__clk_0_38, /* mcfwdt.0 */
93 &__clk_0_40, /* sys.0 */
94 &__clk_0_41, /* gpio.0 */
95 &__clk_0_42, /* mcfrtc.0 */
96 &__clk_0_43, /* mcflcd.0 */
97 &__clk_0_44, /* mcfusb-otg.0 */
98 &__clk_0_45, /* mcfusb-host.0 */
99 &__clk_0_46, /* sdram.0 */
100 &__clk_0_47, /* ssi.0 */
101 &__clk_0_48, /* pll.0 */
102
103 &__clk_1_32, /* mdha.0 */
104 &__clk_1_33, /* skha.0 */
105 &__clk_1_34, /* rng.0 */
106 NULL,
107 };
108
109 static struct clk * const enable_clks[] __initconst = {
110 &__clk_0_2, /* flexbus */
111 &__clk_0_18, /* intc.0 */
112 &__clk_0_19, /* intc.1 */
113 &__clk_0_21, /* iack.0 */
114 &__clk_0_24, /* mcfuart.0 */
115 &__clk_0_25, /* mcfuart.1 */
116 &__clk_0_26, /* mcfuart.2 */
117 &__clk_0_28, /* mcftmr.0 */
118 &__clk_0_29, /* mcftmr.1 */
119 &__clk_0_32, /* mcfpit.0 */
120 &__clk_0_33, /* mcfpit.1 */
121 &__clk_0_37, /* mcfeport.0 */
122 &__clk_0_40, /* sys.0 */
123 &__clk_0_41, /* gpio.0 */
124 &__clk_0_46, /* sdram.0 */
125 &__clk_0_48, /* pll.0 */
126 };
127
128 static struct clk * const disable_clks[] __initconst = {
129 &__clk_0_8, /* mcfcan.0 */
130 &__clk_0_12, /* fec.0 */
131 &__clk_0_17, /* edma */
132 &__clk_0_22, /* imx1-i2c.0 */
133 &__clk_0_23, /* mcfqspi.0 */
134 &__clk_0_30, /* mcftmr.2 */
135 &__clk_0_31, /* mcftmr.3 */
136 &__clk_0_34, /* mcfpit.2 */
137 &__clk_0_35, /* mcfpit.3 */
138 &__clk_0_36, /* mcfpwm.0 */
139 &__clk_0_38, /* mcfwdt.0 */
140 &__clk_0_42, /* mcfrtc.0 */
141 &__clk_0_43, /* mcflcd.0 */
142 &__clk_0_44, /* mcfusb-otg.0 */
143 &__clk_0_45, /* mcfusb-host.0 */
144 &__clk_0_47, /* ssi.0 */
145 &__clk_1_32, /* mdha.0 */
146 &__clk_1_33, /* skha.0 */
147 &__clk_1_34, /* rng.0 */
148 };
149
150
151 static void __init m53xx_clk_init(void)
152 {
153 unsigned i;
154
155 /* make sure these clocks are enabled */
156 for (i = 0; i < ARRAY_SIZE(enable_clks); ++i)
157 __clk_init_enabled(enable_clks[i]);
158 /* make sure these clocks are disabled */
159 for (i = 0; i < ARRAY_SIZE(disable_clks); ++i)
160 __clk_init_disabled(disable_clks[i]);
161 }
162
163 /***************************************************************************/
164
165 static void __init m53xx_qspi_init(void)
166 {
167 #if IS_ENABLED(CONFIG_SPI_COLDFIRE_QSPI)
168 /* setup QSPS pins for QSPI with gpio CS control */
169 writew(0x01f0, MCFGPIO_PAR_QSPI);
170 #endif /* IS_ENABLED(CONFIG_SPI_COLDFIRE_QSPI) */
171 }
172
173 /***************************************************************************/
174
175 static void __init m53xx_i2c_init(void)
176 {
177 #if IS_ENABLED(CONFIG_I2C_IMX)
178 /* setup Port AS Pin Assignment Register for I2C */
179 /* set PASPA0 to SCL and PASPA1 to SDA */
180 u8 r = readb(MCFGPIO_PAR_FECI2C);
181 r |= 0x0f;
182 writeb(r, MCFGPIO_PAR_FECI2C);
183 #endif /* IS_ENABLED(CONFIG_I2C_IMX) */
184 }
185
186 /***************************************************************************/
187
188 static void __init m53xx_uarts_init(void)
189 {
190 /* UART GPIO initialization */
191 writew(readw(MCFGPIO_PAR_UART) | 0x0FFF, MCFGPIO_PAR_UART);
192 }
193
194 /***************************************************************************/
195
196 static void __init m53xx_fec_init(void)
197 {
198 u8 v;
199
200 /* Set multi-function pins to ethernet mode for fec0 */
201 v = readb(MCFGPIO_PAR_FECI2C);
202 v |= MCF_GPIO_PAR_FECI2C_PAR_MDC_EMDC |
203 MCF_GPIO_PAR_FECI2C_PAR_MDIO_EMDIO;
204 writeb(v, MCFGPIO_PAR_FECI2C);
205
206 v = readb(MCFGPIO_PAR_FEC);
207 v = MCF_GPIO_PAR_FEC_PAR_FEC_7W_FEC | MCF_GPIO_PAR_FEC_PAR_FEC_MII_FEC;
208 writeb(v, MCFGPIO_PAR_FEC);
209 }
210
211 /***************************************************************************/
212
213 void __init config_BSP(char *commandp, int size)
214 {
215 #if !defined(CONFIG_BOOTPARAM)
216 /* Copy command line from FLASH to local buffer... */
217 memcpy(commandp, (char *) 0x4000, 4);
218 if(strncmp(commandp, "kcl ", 4) == 0){
219 memcpy(commandp, (char *) 0x4004, size);
220 commandp[size-1] = 0;
221 } else {
222 memset(commandp, 0, size);
223 }
224 #endif
225 mach_sched_init = hw_timer_init;
226 m53xx_clk_init();
227 m53xx_uarts_init();
228 m53xx_fec_init();
229 m53xx_qspi_init();
230 m53xx_i2c_init();
231
232 #ifdef CONFIG_BDM_DISABLE
233 /*
234 * Disable the BDM clocking. This also turns off most of the rest of
235 * the BDM device. This is good for EMC reasons. This option is not
236 * incompatible with the memory protection option.
237 */
238 wdebug(MCFDEBUG_CSR, MCFDEBUG_CSR_PSTCLK);
239 #endif
240 }
241
242 /***************************************************************************/
243 /* Board initialization */
244 /***************************************************************************/
245 /*
246 * PLL min/max specifications
247 */
248 #define MAX_FVCO 500000 /* KHz */
249 #define MAX_FSYS 80000 /* KHz */
250 #define MIN_FSYS 58333 /* KHz */
251 #define FREF 16000 /* KHz */
252
253
254 #define MAX_MFD 135 /* Multiplier */
255 #define MIN_MFD 88 /* Multiplier */
256 #define BUSDIV 6 /* Divider */
257
258 /*
259 * Low Power Divider specifications
260 */
261 #define MIN_LPD (1 << 0) /* Divider (not encoded) */
262 #define MAX_LPD (1 << 15) /* Divider (not encoded) */
263 #define DEFAULT_LPD (1 << 1) /* Divider (not encoded) */
264
265 #define SYS_CLK_KHZ 80000
266 #define SYSTEM_PERIOD 12.5
267 /*
268 * SDRAM Timing Parameters
269 */
270 #define SDRAM_BL 8 /* # of beats in a burst */
271 #define SDRAM_TWR 2 /* in clocks */
272 #define SDRAM_CASL 2.5 /* CASL in clocks */
273 #define SDRAM_TRCD 2 /* in clocks */
274 #define SDRAM_TRP 2 /* in clocks */
275 #define SDRAM_TRFC 7 /* in clocks */
276 #define SDRAM_TREFI 7800 /* in ns */
277
278 #define EXT_SRAM_ADDRESS (0xC0000000)
279 #define FLASH_ADDRESS (0x00000000)
280 #define SDRAM_ADDRESS (0x40000000)
281
282 #define NAND_FLASH_ADDRESS (0xD0000000)
283
284 void wtm_init(void);
285 void scm_init(void);
286 void gpio_init(void);
287 void fbcs_init(void);
288 void sdramc_init(void);
289 int clock_pll (int fsys, int flags);
290 int clock_limp (int);
291 int clock_exit_limp (void);
292 int get_sys_clock (void);
293
294 asmlinkage void __init sysinit(void)
295 {
296 clock_pll(0, 0);
297
298 wtm_init();
299 scm_init();
300 gpio_init();
301 fbcs_init();
302 sdramc_init();
303 }
304
305 void wtm_init(void)
306 {
307 /* Disable watchdog timer */
308 writew(0, MCF_WTM_WCR);
309 }
310
311 #define MCF_SCM_BCR_GBW (0x00000100)
312 #define MCF_SCM_BCR_GBR (0x00000200)
313
314 void scm_init(void)
315 {
316 /* All masters are trusted */
317 writel(0x77777777, MCF_SCM_MPR);
318
319 /* Allow supervisor/user, read/write, and trusted/untrusted
320 access to all slaves */
321 writel(0, MCF_SCM_PACRA);
322 writel(0, MCF_SCM_PACRB);
323 writel(0, MCF_SCM_PACRC);
324 writel(0, MCF_SCM_PACRD);
325 writel(0, MCF_SCM_PACRE);
326 writel(0, MCF_SCM_PACRF);
327
328 /* Enable bursts */
329 writel(MCF_SCM_BCR_GBR | MCF_SCM_BCR_GBW, MCF_SCM_BCR);
330 }
331
332
333 void fbcs_init(void)
334 {
335 writeb(0x3E, MCFGPIO_PAR_CS);
336
337 /* Latch chip select */
338 writel(0x10080000, MCF_FBCS1_CSAR);
339
340 writel(0x002A3780, MCF_FBCS1_CSCR);
341 writel(MCF_FBCS_CSMR_BAM_2M | MCF_FBCS_CSMR_V, MCF_FBCS1_CSMR);
342
343 /* Initialize latch to drive signals to inactive states */
344 writew(0xffff, 0x10080000);
345
346 /* External SRAM */
347 writel(EXT_SRAM_ADDRESS, MCF_FBCS1_CSAR);
348 writel(MCF_FBCS_CSCR_PS_16 |
349 MCF_FBCS_CSCR_AA |
350 MCF_FBCS_CSCR_SBM |
351 MCF_FBCS_CSCR_WS(1),
352 MCF_FBCS1_CSCR);
353 writel(MCF_FBCS_CSMR_BAM_512K | MCF_FBCS_CSMR_V, MCF_FBCS1_CSMR);
354
355 /* Boot Flash connected to FBCS0 */
356 writel(FLASH_ADDRESS, MCF_FBCS0_CSAR);
357 writel(MCF_FBCS_CSCR_PS_16 |
358 MCF_FBCS_CSCR_BEM |
359 MCF_FBCS_CSCR_AA |
360 MCF_FBCS_CSCR_SBM |
361 MCF_FBCS_CSCR_WS(7),
362 MCF_FBCS0_CSCR);
363 writel(MCF_FBCS_CSMR_BAM_32M | MCF_FBCS_CSMR_V, MCF_FBCS0_CSMR);
364 }
365
366 void sdramc_init(void)
367 {
368 /*
369 * Check to see if the SDRAM has already been initialized
370 * by a run control tool
371 */
372 if (!(readl(MCF_SDRAMC_SDCR) & MCF_SDRAMC_SDCR_REF)) {
373 /* SDRAM chip select initialization */
374
375 /* Initialize SDRAM chip select */
376 writel(MCF_SDRAMC_SDCS_BA(SDRAM_ADDRESS) |
377 MCF_SDRAMC_SDCS_CSSZ(MCF_SDRAMC_SDCS_CSSZ_32MBYTE),
378 MCF_SDRAMC_SDCS0);
379
380 /*
381 * Basic configuration and initialization
382 */
383 writel(MCF_SDRAMC_SDCFG1_SRD2RW((int)((SDRAM_CASL + 2) + 0.5)) |
384 MCF_SDRAMC_SDCFG1_SWT2RD(SDRAM_TWR + 1) |
385 MCF_SDRAMC_SDCFG1_RDLAT((int)((SDRAM_CASL * 2) + 2)) |
386 MCF_SDRAMC_SDCFG1_ACT2RW((int)(SDRAM_TRCD + 0.5)) |
387 MCF_SDRAMC_SDCFG1_PRE2ACT((int)(SDRAM_TRP + 0.5)) |
388 MCF_SDRAMC_SDCFG1_REF2ACT((int)(SDRAM_TRFC + 0.5)) |
389 MCF_SDRAMC_SDCFG1_WTLAT(3),
390 MCF_SDRAMC_SDCFG1);
391 writel(MCF_SDRAMC_SDCFG2_BRD2PRE(SDRAM_BL / 2 + 1) |
392 MCF_SDRAMC_SDCFG2_BWT2RW(SDRAM_BL / 2 + SDRAM_TWR) |
393 MCF_SDRAMC_SDCFG2_BRD2WT((int)((SDRAM_CASL + SDRAM_BL / 2 - 1.0) + 0.5)) |
394 MCF_SDRAMC_SDCFG2_BL(SDRAM_BL - 1),
395 MCF_SDRAMC_SDCFG2);
396
397
398 /*
399 * Precharge and enable write to SDMR
400 */
401 writel(MCF_SDRAMC_SDCR_MODE_EN |
402 MCF_SDRAMC_SDCR_CKE |
403 MCF_SDRAMC_SDCR_DDR |
404 MCF_SDRAMC_SDCR_MUX(1) |
405 MCF_SDRAMC_SDCR_RCNT((int)(((SDRAM_TREFI / (SYSTEM_PERIOD * 64)) - 1) + 0.5)) |
406 MCF_SDRAMC_SDCR_PS_16 |
407 MCF_SDRAMC_SDCR_IPALL,
408 MCF_SDRAMC_SDCR);
409
410 /*
411 * Write extended mode register
412 */
413 writel(MCF_SDRAMC_SDMR_BNKAD_LEMR |
414 MCF_SDRAMC_SDMR_AD(0x0) |
415 MCF_SDRAMC_SDMR_CMD,
416 MCF_SDRAMC_SDMR);
417
418 /*
419 * Write mode register and reset DLL
420 */
421 writel(MCF_SDRAMC_SDMR_BNKAD_LMR |
422 MCF_SDRAMC_SDMR_AD(0x163) |
423 MCF_SDRAMC_SDMR_CMD,
424 MCF_SDRAMC_SDMR);
425
426 /*
427 * Execute a PALL command
428 */
429 writel(readl(MCF_SDRAMC_SDCR) | MCF_SDRAMC_SDCR_IPALL, MCF_SDRAMC_SDCR);
430
431 /*
432 * Perform two REF cycles
433 */
434 writel(readl(MCF_SDRAMC_SDCR) | MCF_SDRAMC_SDCR_IREF, MCF_SDRAMC_SDCR);
435 writel(readl(MCF_SDRAMC_SDCR) | MCF_SDRAMC_SDCR_IREF, MCF_SDRAMC_SDCR);
436
437 /*
438 * Write mode register and clear reset DLL
439 */
440 writel(MCF_SDRAMC_SDMR_BNKAD_LMR |
441 MCF_SDRAMC_SDMR_AD(0x063) |
442 MCF_SDRAMC_SDMR_CMD,
443 MCF_SDRAMC_SDMR);
444
445 /*
446 * Enable auto refresh and lock SDMR
447 */
448 writel(readl(MCF_SDRAMC_SDCR) & ~MCF_SDRAMC_SDCR_MODE_EN,
449 MCF_SDRAMC_SDCR);
450 writel(MCF_SDRAMC_SDCR_REF | MCF_SDRAMC_SDCR_DQS_OE(0xC),
451 MCF_SDRAMC_SDCR);
452 }
453 }
454
455 void gpio_init(void)
456 {
457 /* Enable UART0 pins */
458 writew(MCF_GPIO_PAR_UART_PAR_URXD0 | MCF_GPIO_PAR_UART_PAR_UTXD0,
459 MCFGPIO_PAR_UART);
460
461 /*
462 * Initialize TIN3 as a GPIO output to enable the write
463 * half of the latch.
464 */
465 writeb(0x00, MCFGPIO_PAR_TIMER);
466 writeb(0x08, MCFGPIO_PDDR_TIMER);
467 writeb(0x00, MCFGPIO_PCLRR_TIMER);
468 }
469
470 int clock_pll(int fsys, int flags)
471 {
472 int fref, temp, fout, mfd;
473 u32 i;
474
475 fref = FREF;
476
477 if (fsys == 0) {
478 /* Return current PLL output */
479 mfd = readb(MCF_PLL_PFDR);
480
481 return (fref * mfd / (BUSDIV * 4));
482 }
483
484 /* Check bounds of requested system clock */
485 if (fsys > MAX_FSYS)
486 fsys = MAX_FSYS;
487 if (fsys < MIN_FSYS)
488 fsys = MIN_FSYS;
489
490 /* Multiplying by 100 when calculating the temp value,
491 and then dividing by 100 to calculate the mfd allows
492 for exact values without needing to include floating
493 point libraries. */
494 temp = 100 * fsys / fref;
495 mfd = 4 * BUSDIV * temp / 100;
496
497 /* Determine the output frequency for selected values */
498 fout = (fref * mfd / (BUSDIV * 4));
499
500 /*
501 * Check to see if the SDRAM has already been initialized.
502 * If it has then the SDRAM needs to be put into self refresh
503 * mode before reprogramming the PLL.
504 */
505 if (readl(MCF_SDRAMC_SDCR) & MCF_SDRAMC_SDCR_REF)
506 /* Put SDRAM into self refresh mode */
507 writel(readl(MCF_SDRAMC_SDCR) & ~MCF_SDRAMC_SDCR_CKE,
508 MCF_SDRAMC_SDCR);
509
510 /*
511 * Initialize the PLL to generate the new system clock frequency.
512 * The device must be put into LIMP mode to reprogram the PLL.
513 */
514
515 /* Enter LIMP mode */
516 clock_limp(DEFAULT_LPD);
517
518 /* Reprogram PLL for desired fsys */
519 writeb(MCF_PLL_PODR_CPUDIV(BUSDIV/3) | MCF_PLL_PODR_BUSDIV(BUSDIV),
520 MCF_PLL_PODR);
521
522 writeb(mfd, MCF_PLL_PFDR);
523
524 /* Exit LIMP mode */
525 clock_exit_limp();
526
527 /*
528 * Return the SDRAM to normal operation if it is in use.
529 */
530 if (readl(MCF_SDRAMC_SDCR) & MCF_SDRAMC_SDCR_REF)
531 /* Exit self refresh mode */
532 writel(readl(MCF_SDRAMC_SDCR) | MCF_SDRAMC_SDCR_CKE,
533 MCF_SDRAMC_SDCR);
534
535 /* Errata - workaround for SDRAM opeartion after exiting LIMP mode */
536 writel(MCF_SDRAMC_REFRESH, MCF_SDRAMC_LIMP_FIX);
537
538 /* wait for DQS logic to relock */
539 for (i = 0; i < 0x200; i++)
540 ;
541
542 return fout;
543 }
544
545 int clock_limp(int div)
546 {
547 u32 temp;
548
549 /* Check bounds of divider */
550 if (div < MIN_LPD)
551 div = MIN_LPD;
552 if (div > MAX_LPD)
553 div = MAX_LPD;
554
555 /* Save of the current value of the SSIDIV so we don't
556 overwrite the value*/
557 temp = readw(MCF_CCM_CDR) & MCF_CCM_CDR_SSIDIV(0xF);
558
559 /* Apply the divider to the system clock */
560 writew(MCF_CCM_CDR_LPDIV(div) | MCF_CCM_CDR_SSIDIV(temp), MCF_CCM_CDR);
561
562 writew(readw(MCF_CCM_MISCCR) | MCF_CCM_MISCCR_LIMP, MCF_CCM_MISCCR);
563
564 return (FREF/(3*(1 << div)));
565 }
566
567 int clock_exit_limp(void)
568 {
569 int fout;
570
571 /* Exit LIMP mode */
572 writew(readw(MCF_CCM_MISCCR) & ~MCF_CCM_MISCCR_LIMP, MCF_CCM_MISCCR);
573
574 /* Wait for PLL to lock */
575 while (!(readw(MCF_CCM_MISCCR) & MCF_CCM_MISCCR_PLL_LOCK))
576 ;
577
578 fout = get_sys_clock();
579
580 return fout;
581 }
582
583 int get_sys_clock(void)
584 {
585 int divider;
586
587 /* Test to see if device is in LIMP mode */
588 if (readw(MCF_CCM_MISCCR) & MCF_CCM_MISCCR_LIMP) {
589 divider = readw(MCF_CCM_CDR) & MCF_CCM_CDR_LPDIV(0xF);
590 return (FREF/(2 << divider));
591 }
592 else
593 return (FREF * readb(MCF_PLL_PFDR)) / (BUSDIV * 4);
594 }
Linux with added FPC-III support