xref: /linux/drivers/clk/clk-nomadik.c (revision 54bf93c4) 
1 /*
2  * Nomadik clock implementation
3  * Copyright (C) 2013 ST-Ericsson AB
4  * License terms: GNU General Public License (GPL) version 2
5  * Author: Linus Walleij <linus.walleij@linaro.org>
6  */
7 
8 #define pr_fmt(fmt) "Nomadik SRC clocks: " fmt
9 
10 #include <linux/bitops.h>
11 #include <linux/clk.h>
12 #include <linux/clkdev.h>
13 #include <linux/err.h>
14 #include <linux/io.h>
15 #include <linux/clk-provider.h>
16 #include <linux/of.h>
17 #include <linux/of_address.h>
18 #include <linux/debugfs.h>
19 #include <linux/seq_file.h>
20 #include <linux/spinlock.h>
21 #include <linux/reboot.h>
22 
23 /*
24  * The Nomadik clock tree is described in the STN8815A12 DB V4.2
25  * reference manual for the chip, page 94 ff.
26  * Clock IDs are in the STn8815 Reference Manual table 3, page 27.
27  */
28 
29 #define SRC_CR			0x00U
30 #define SRC_CR_T0_ENSEL		BIT(15)
31 #define SRC_CR_T1_ENSEL		BIT(17)
32 #define SRC_CR_T2_ENSEL		BIT(19)
33 #define SRC_CR_T3_ENSEL		BIT(21)
34 #define SRC_CR_T4_ENSEL		BIT(23)
35 #define SRC_CR_T5_ENSEL		BIT(25)
36 #define SRC_CR_T6_ENSEL		BIT(27)
37 #define SRC_CR_T7_ENSEL		BIT(29)
38 #define SRC_XTALCR		0x0CU
39 #define SRC_XTALCR_XTALTIMEN	BIT(20)
40 #define SRC_XTALCR_SXTALDIS	BIT(19)
41 #define SRC_XTALCR_MXTALSTAT	BIT(2)
42 #define SRC_XTALCR_MXTALEN	BIT(1)
43 #define SRC_XTALCR_MXTALOVER	BIT(0)
44 #define SRC_PLLCR		0x10U
45 #define SRC_PLLCR_PLLTIMEN	BIT(29)
46 #define SRC_PLLCR_PLL2EN	BIT(28)
47 #define SRC_PLLCR_PLL1STAT	BIT(2)
48 #define SRC_PLLCR_PLL1EN	BIT(1)
49 #define SRC_PLLCR_PLL1OVER	BIT(0)
50 #define SRC_PLLFR		0x14U
51 #define SRC_PCKEN0		0x24U
52 #define SRC_PCKDIS0		0x28U
53 #define SRC_PCKENSR0		0x2CU
54 #define SRC_PCKSR0		0x30U
55 #define SRC_PCKEN1		0x34U
56 #define SRC_PCKDIS1		0x38U
57 #define SRC_PCKENSR1		0x3CU
58 #define SRC_PCKSR1		0x40U
59 
60 /* Lock protecting the SRC_CR register */
61 static DEFINE_SPINLOCK(src_lock);
62 /* Base address of the SRC */
63 static void __iomem *src_base;
64 
65 static int nomadik_clk_reboot_handler(struct notifier_block *this,
66 				unsigned long code,
67 				void *unused)
68 {
69 	u32 val;
70 
71 	/* The main chrystal need to be enabled for reboot to work */
72 	val = readl(src_base + SRC_XTALCR);
73 	val &= ~SRC_XTALCR_MXTALOVER;
74 	val |= SRC_XTALCR_MXTALEN;
75 	pr_crit("force-enabling MXTALO\n");
76 	writel(val, src_base + SRC_XTALCR);
77 	return NOTIFY_OK;
78 }
79 
80 static struct notifier_block nomadik_clk_reboot_notifier = {
81 	.notifier_call = nomadik_clk_reboot_handler,
82 };
83 
84 static const struct of_device_id nomadik_src_match[] __initconst = {
85 	{ .compatible = "stericsson,nomadik-src" },
86 	{ /* sentinel */ }
87 };
88 
89 static void __init nomadik_src_init(void)
90 {
91 	struct device_node *np;
92 	u32 val;
93 
94 	np = of_find_matching_node(NULL, nomadik_src_match);
95 	if (!np) {
96 		pr_crit("no matching node for SRC, aborting clock init\n");
97 		return;
98 	}
99 	src_base = of_iomap(np, 0);
100 	if (!src_base) {
101 		pr_err("%s: must have src parent node with REGS (%s)\n",
102 		       __func__, np->name);
103 		return;
104 	}
105 
106 	/* Set all timers to use the 2.4 MHz TIMCLK */
107 	val = readl(src_base + SRC_CR);
108 	val |= SRC_CR_T0_ENSEL;
109 	val |= SRC_CR_T1_ENSEL;
110 	val |= SRC_CR_T2_ENSEL;
111 	val |= SRC_CR_T3_ENSEL;
112 	val |= SRC_CR_T4_ENSEL;
113 	val |= SRC_CR_T5_ENSEL;
114 	val |= SRC_CR_T6_ENSEL;
115 	val |= SRC_CR_T7_ENSEL;
116 	writel(val, src_base + SRC_CR);
117 
118 	val = readl(src_base + SRC_XTALCR);
119 	pr_info("SXTALO is %s\n",
120 		(val & SRC_XTALCR_SXTALDIS) ? "disabled" : "enabled");
121 	pr_info("MXTAL is %s\n",
122 		(val & SRC_XTALCR_MXTALSTAT) ? "enabled" : "disabled");
123 	if (of_property_read_bool(np, "disable-sxtalo")) {
124 		/* The machine uses an external oscillator circuit */
125 		val |= SRC_XTALCR_SXTALDIS;
126 		pr_info("disabling SXTALO\n");
127 	}
128 	if (of_property_read_bool(np, "disable-mxtalo")) {
129 		/* Disable this too: also run by external oscillator */
130 		val |= SRC_XTALCR_MXTALOVER;
131 		val &= ~SRC_XTALCR_MXTALEN;
132 		pr_info("disabling MXTALO\n");
133 	}
134 	writel(val, src_base + SRC_XTALCR);
135 	register_reboot_notifier(&nomadik_clk_reboot_notifier);
136 }
137 
138 /**
139  * struct clk_pll1 - Nomadik PLL1 clock
140  * @hw: corresponding clock hardware entry
141  * @id: PLL instance: 1 or 2
142  */
143 struct clk_pll {
144 	struct clk_hw hw;
145 	int id;
146 };
147 
148 /**
149  * struct clk_src - Nomadik src clock
150  * @hw: corresponding clock hardware entry
151  * @id: the clock ID
152  * @group1: true if the clock is in group1, else it is in group0
153  * @clkbit: bit 0...31 corresponding to the clock in each clock register
154  */
155 struct clk_src {
156 	struct clk_hw hw;
157 	int id;
158 	bool group1;
159 	u32 clkbit;
160 };
161 
162 #define to_pll(_hw) container_of(_hw, struct clk_pll, hw)
163 #define to_src(_hw) container_of(_hw, struct clk_src, hw)
164 
165 static int pll_clk_enable(struct clk_hw *hw)
166 {
167 	struct clk_pll *pll = to_pll(hw);
168 	u32 val;
169 
170 	spin_lock(&src_lock);
171 	val = readl(src_base + SRC_PLLCR);
172 	if (pll->id == 1) {
173 		if (val & SRC_PLLCR_PLL1OVER) {
174 			val |= SRC_PLLCR_PLL1EN;
175 			writel(val, src_base + SRC_PLLCR);
176 		}
177 	} else if (pll->id == 2) {
178 		val |= SRC_PLLCR_PLL2EN;
179 		writel(val, src_base + SRC_PLLCR);
180 	}
181 	spin_unlock(&src_lock);
182 	return 0;
183 }
184 
185 static void pll_clk_disable(struct clk_hw *hw)
186 {
187 	struct clk_pll *pll = to_pll(hw);
188 	u32 val;
189 
190 	spin_lock(&src_lock);
191 	val = readl(src_base + SRC_PLLCR);
192 	if (pll->id == 1) {
193 		if (val & SRC_PLLCR_PLL1OVER) {
194 			val &= ~SRC_PLLCR_PLL1EN;
195 			writel(val, src_base + SRC_PLLCR);
196 		}
197 	} else if (pll->id == 2) {
198 		val &= ~SRC_PLLCR_PLL2EN;
199 		writel(val, src_base + SRC_PLLCR);
200 	}
201 	spin_unlock(&src_lock);
202 }
203 
204 static int pll_clk_is_enabled(struct clk_hw *hw)
205 {
206 	struct clk_pll *pll = to_pll(hw);
207 	u32 val;
208 
209 	val = readl(src_base + SRC_PLLCR);
210 	if (pll->id == 1) {
211 		if (val & SRC_PLLCR_PLL1OVER)
212 			return !!(val & SRC_PLLCR_PLL1EN);
213 	} else if (pll->id == 2) {
214 		return !!(val & SRC_PLLCR_PLL2EN);
215 	}
216 	return 1;
217 }
218 
219 static unsigned long pll_clk_recalc_rate(struct clk_hw *hw,
220 					  unsigned long parent_rate)
221 {
222 	struct clk_pll *pll = to_pll(hw);
223 	u32 val;
224 
225 	val = readl(src_base + SRC_PLLFR);
226 
227 	if (pll->id == 1) {
228 		u8 mul;
229 		u8 div;
230 
231 		mul = (val >> 8) & 0x3FU;
232 		mul += 2;
233 		div = val & 0x07U;
234 		return (parent_rate * mul) >> div;
235 	}
236 
237 	if (pll->id == 2) {
238 		u8 mul;
239 
240 		mul = (val >> 24) & 0x3FU;
241 		mul += 2;
242 		return (parent_rate * mul);
243 	}
244 
245 	/* Unknown PLL */
246 	return 0;
247 }
248 
249 
250 static const struct clk_ops pll_clk_ops = {
251 	.enable = pll_clk_enable,
252 	.disable = pll_clk_disable,
253 	.is_enabled = pll_clk_is_enabled,
254 	.recalc_rate = pll_clk_recalc_rate,
255 };
256 
257 static struct clk * __init
258 pll_clk_register(struct device *dev, const char *name,
259 		 const char *parent_name, u32 id)
260 {
261 	struct clk *clk;
262 	struct clk_pll *pll;
263 	struct clk_init_data init;
264 
265 	if (id != 1 && id != 2) {
266 		pr_err("%s: the Nomadik has only PLL 1 & 2\n", __func__);
267 		return ERR_PTR(-EINVAL);
268 	}
269 
270 	pll = kzalloc(sizeof(*pll), GFP_KERNEL);
271 	if (!pll) {
272 		pr_err("%s: could not allocate PLL clk\n", __func__);
273 		return ERR_PTR(-ENOMEM);
274 	}
275 
276 	init.name = name;
277 	init.ops = &pll_clk_ops;
278 	init.parent_names = (parent_name ? &parent_name : NULL);
279 	init.num_parents = (parent_name ? 1 : 0);
280 	pll->hw.init = &init;
281 	pll->id = id;
282 
283 	pr_debug("register PLL1 clock \"%s\"\n", name);
284 
285 	clk = clk_register(dev, &pll->hw);
286 	if (IS_ERR(clk))
287 		kfree(pll);
288 
289 	return clk;
290 }
291 
292 /*
293  * The Nomadik SRC clocks are gated, but not in the sense that
294  * you read-modify-write a register. Instead there are separate
295  * clock enable and clock disable registers. Writing a '1' bit in
296  * the enable register for a certain clock ungates that clock without
297  * affecting the other clocks. The disable register works the opposite
298  * way.
299  */
300 
301 static int src_clk_enable(struct clk_hw *hw)
302 {
303 	struct clk_src *sclk = to_src(hw);
304 	u32 enreg = sclk->group1 ? SRC_PCKEN1 : SRC_PCKEN0;
305 	u32 sreg = sclk->group1 ? SRC_PCKSR1 : SRC_PCKSR0;
306 
307 	writel(sclk->clkbit, src_base + enreg);
308 	/* spin until enabled */
309 	while (!(readl(src_base + sreg) & sclk->clkbit))
310 		cpu_relax();
311 	return 0;
312 }
313 
314 static void src_clk_disable(struct clk_hw *hw)
315 {
316 	struct clk_src *sclk = to_src(hw);
317 	u32 disreg = sclk->group1 ? SRC_PCKDIS1 : SRC_PCKDIS0;
318 	u32 sreg = sclk->group1 ? SRC_PCKSR1 : SRC_PCKSR0;
319 
320 	writel(sclk->clkbit, src_base + disreg);
321 	/* spin until disabled */
322 	while (readl(src_base + sreg) & sclk->clkbit)
323 		cpu_relax();
324 }
325 
326 static int src_clk_is_enabled(struct clk_hw *hw)
327 {
328 	struct clk_src *sclk = to_src(hw);
329 	u32 sreg = sclk->group1 ? SRC_PCKSR1 : SRC_PCKSR0;
330 	u32 val = readl(src_base + sreg);
331 
332 	return !!(val & sclk->clkbit);
333 }
334 
335 static unsigned long
336 src_clk_recalc_rate(struct clk_hw *hw,
337 		    unsigned long parent_rate)
338 {
339 	return parent_rate;
340 }
341 
342 static const struct clk_ops src_clk_ops = {
343 	.enable = src_clk_enable,
344 	.disable = src_clk_disable,
345 	.is_enabled = src_clk_is_enabled,
346 	.recalc_rate = src_clk_recalc_rate,
347 };
348 
349 static struct clk * __init
350 src_clk_register(struct device *dev, const char *name,
351 		 const char *parent_name, u8 id)
352 {
353 	struct clk *clk;
354 	struct clk_src *sclk;
355 	struct clk_init_data init;
356 
357 	sclk = kzalloc(sizeof(*sclk), GFP_KERNEL);
358 	if (!sclk) {
359 		pr_err("could not allocate SRC clock %s\n",
360 			name);
361 		return ERR_PTR(-ENOMEM);
362 	}
363 	init.name = name;
364 	init.ops = &src_clk_ops;
365 	/* Do not force-disable the static SDRAM controller */
366 	if (id == 2)
367 		init.flags = CLK_IGNORE_UNUSED;
368 	else
369 		init.flags = 0;
370 	init.parent_names = (parent_name ? &parent_name : NULL);
371 	init.num_parents = (parent_name ? 1 : 0);
372 	sclk->hw.init = &init;
373 	sclk->id = id;
374 	sclk->group1 = (id > 31);
375 	sclk->clkbit = BIT(id & 0x1f);
376 
377 	pr_debug("register clock \"%s\" ID: %d group: %d bits: %08x\n",
378 		 name, id, sclk->group1, sclk->clkbit);
379 
380 	clk = clk_register(dev, &sclk->hw);
381 	if (IS_ERR(clk))
382 		kfree(sclk);
383 
384 	return clk;
385 }
386 
387 #ifdef CONFIG_DEBUG_FS
388 
389 static u32 src_pcksr0_boot;
390 static u32 src_pcksr1_boot;
391 
392 static const char * const src_clk_names[] = {
393 	"HCLKDMA0  ",
394 	"HCLKSMC   ",
395 	"HCLKSDRAM ",
396 	"HCLKDMA1  ",
397 	"HCLKCLCD  ",
398 	"PCLKIRDA  ",
399 	"PCLKSSP   ",
400 	"PCLKUART0 ",
401 	"PCLKSDI   ",
402 	"PCLKI2C0  ",
403 	"PCLKI2C1  ",
404 	"PCLKUART1 ",
405 	"PCLMSP0   ",
406 	"HCLKUSB   ",
407 	"HCLKDIF   ",
408 	"HCLKSAA   ",
409 	"HCLKSVA   ",
410 	"PCLKHSI   ",
411 	"PCLKXTI   ",
412 	"PCLKUART2 ",
413 	"PCLKMSP1  ",
414 	"PCLKMSP2  ",
415 	"PCLKOWM   ",
416 	"HCLKHPI   ",
417 	"PCLKSKE   ",
418 	"PCLKHSEM  ",
419 	"HCLK3D    ",
420 	"HCLKHASH  ",
421 	"HCLKCRYP  ",
422 	"PCLKMSHC  ",
423 	"HCLKUSBM  ",
424 	"HCLKRNG   ",
425 	"RESERVED  ",
426 	"RESERVED  ",
427 	"RESERVED  ",
428 	"RESERVED  ",
429 	"CLDCLK    ",
430 	"IRDACLK   ",
431 	"SSPICLK   ",
432 	"UART0CLK  ",
433 	"SDICLK    ",
434 	"I2C0CLK   ",
435 	"I2C1CLK   ",
436 	"UART1CLK  ",
437 	"MSPCLK0   ",
438 	"USBCLK    ",
439 	"DIFCLK    ",
440 	"IPI2CCLK  ",
441 	"IPBMCCLK  ",
442 	"HSICLKRX  ",
443 	"HSICLKTX  ",
444 	"UART2CLK  ",
445 	"MSPCLK1   ",
446 	"MSPCLK2   ",
447 	"OWMCLK    ",
448 	"RESERVED  ",
449 	"SKECLK    ",
450 	"RESERVED  ",
451 	"3DCLK     ",
452 	"PCLKMSP3  ",
453 	"MSPCLK3   ",
454 	"MSHCCLK   ",
455 	"USBMCLK   ",
456 	"RNGCCLK   ",
457 };
458 
459 static int nomadik_src_clk_show(struct seq_file *s, void *what)
460 {
461 	int i;
462 	u32 src_pcksr0 = readl(src_base + SRC_PCKSR0);
463 	u32 src_pcksr1 = readl(src_base + SRC_PCKSR1);
464 	u32 src_pckensr0 = readl(src_base + SRC_PCKENSR0);
465 	u32 src_pckensr1 = readl(src_base + SRC_PCKENSR1);
466 
467 	seq_printf(s, "Clock:      Boot:   Now:    Request: ASKED:\n");
468 	for (i = 0; i < ARRAY_SIZE(src_clk_names); i++) {
469 		u32 pcksrb = (i < 0x20) ? src_pcksr0_boot : src_pcksr1_boot;
470 		u32 pcksr = (i < 0x20) ? src_pcksr0 : src_pcksr1;
471 		u32 pckreq = (i < 0x20) ? src_pckensr0 : src_pckensr1;
472 		u32 mask = BIT(i & 0x1f);
473 
474 		seq_printf(s, "%s  %s     %s     %s\n",
475 			   src_clk_names[i],
476 			   (pcksrb & mask) ? "on " : "off",
477 			   (pcksr & mask) ? "on " : "off",
478 			   (pckreq & mask) ? "on " : "off");
479 	}
480 	return 0;
481 }
482 
483 static int nomadik_src_clk_open(struct inode *inode, struct file *file)
484 {
485 	return single_open(file, nomadik_src_clk_show, NULL);
486 }
487 
488 static const struct file_operations nomadik_src_clk_debugfs_ops = {
489 	.open           = nomadik_src_clk_open,
490 	.read           = seq_read,
491         .llseek         = seq_lseek,
492 	.release        = single_release,
493 };
494 
495 static int __init nomadik_src_clk_init_debugfs(void)
496 {
497 	src_pcksr0_boot = readl(src_base + SRC_PCKSR0);
498 	src_pcksr1_boot = readl(src_base + SRC_PCKSR1);
499 	debugfs_create_file("nomadik-src-clk", S_IFREG | S_IRUGO,
500 			    NULL, NULL, &nomadik_src_clk_debugfs_ops);
501 	return 0;
502 }
503 
504 module_init(nomadik_src_clk_init_debugfs);
505 
506 #endif
507 
508 static void __init of_nomadik_pll_setup(struct device_node *np)
509 {
510 	struct clk *clk = ERR_PTR(-EINVAL);
511 	const char *clk_name = np->name;
512 	const char *parent_name;
513 	u32 pll_id;
514 
515 	if (!src_base)
516 		nomadik_src_init();
517 
518 	if (of_property_read_u32(np, "pll-id", &pll_id)) {
519 		pr_err("%s: PLL \"%s\" missing pll-id property\n",
520 			__func__, clk_name);
521 		return;
522 	}
523 	parent_name = of_clk_get_parent_name(np, 0);
524 	clk = pll_clk_register(NULL, clk_name, parent_name, pll_id);
525 	if (!IS_ERR(clk))
526 		of_clk_add_provider(np, of_clk_src_simple_get, clk);
527 }
528 CLK_OF_DECLARE(nomadik_pll_clk,
529 	"st,nomadik-pll-clock", of_nomadik_pll_setup);
530 
531 static void __init of_nomadik_hclk_setup(struct device_node *np)
532 {
533 	struct clk *clk = ERR_PTR(-EINVAL);
534 	const char *clk_name = np->name;
535 	const char *parent_name;
536 
537 	if (!src_base)
538 		nomadik_src_init();
539 
540 	parent_name = of_clk_get_parent_name(np, 0);
541 	/*
542 	 * The HCLK divides PLL1 with 1 (passthru), 2, 3 or 4.
543 	 */
544 	clk = clk_register_divider(NULL, clk_name, parent_name,
545 			   0, src_base + SRC_CR,
546 			   13, 2,
547 			   CLK_DIVIDER_ONE_BASED | CLK_DIVIDER_ALLOW_ZERO,
548 			   &src_lock);
549 	if (!IS_ERR(clk))
550 		of_clk_add_provider(np, of_clk_src_simple_get, clk);
551 }
552 CLK_OF_DECLARE(nomadik_hclk_clk,
553 	"st,nomadik-hclk-clock", of_nomadik_hclk_setup);
554 
555 static void __init of_nomadik_src_clk_setup(struct device_node *np)
556 {
557 	struct clk *clk = ERR_PTR(-EINVAL);
558 	const char *clk_name = np->name;
559 	const char *parent_name;
560 	u32 clk_id;
561 
562 	if (!src_base)
563 		nomadik_src_init();
564 
565 	if (of_property_read_u32(np, "clock-id", &clk_id)) {
566 		pr_err("%s: SRC clock \"%s\" missing clock-id property\n",
567 			__func__, clk_name);
568 		return;
569 	}
570 	parent_name = of_clk_get_parent_name(np, 0);
571 	clk = src_clk_register(NULL, clk_name, parent_name, clk_id);
572 	if (!IS_ERR(clk))
573 		of_clk_add_provider(np, of_clk_src_simple_get, clk);
574 }
575 CLK_OF_DECLARE(nomadik_src_clk,
576 	"st,nomadik-src-clock", of_nomadik_src_clk_setup);
577