xref: /openbmc/linux/drivers/clk/clk-nomadik.c (revision 94cdda6b) 
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 	/* Vital for multiplatform */
498 	if (!src_base)
499 		return -ENODEV;
500 	src_pcksr0_boot = readl(src_base + SRC_PCKSR0);
501 	src_pcksr1_boot = readl(src_base + SRC_PCKSR1);
502 	debugfs_create_file("nomadik-src-clk", S_IFREG | S_IRUGO,
503 			    NULL, NULL, &nomadik_src_clk_debugfs_ops);
504 	return 0;
505 }
506 
507 module_init(nomadik_src_clk_init_debugfs);
508 
509 #endif
510 
511 static void __init of_nomadik_pll_setup(struct device_node *np)
512 {
513 	struct clk *clk = ERR_PTR(-EINVAL);
514 	const char *clk_name = np->name;
515 	const char *parent_name;
516 	u32 pll_id;
517 
518 	if (!src_base)
519 		nomadik_src_init();
520 
521 	if (of_property_read_u32(np, "pll-id", &pll_id)) {
522 		pr_err("%s: PLL \"%s\" missing pll-id property\n",
523 			__func__, clk_name);
524 		return;
525 	}
526 	parent_name = of_clk_get_parent_name(np, 0);
527 	clk = pll_clk_register(NULL, clk_name, parent_name, pll_id);
528 	if (!IS_ERR(clk))
529 		of_clk_add_provider(np, of_clk_src_simple_get, clk);
530 }
531 CLK_OF_DECLARE(nomadik_pll_clk,
532 	"st,nomadik-pll-clock", of_nomadik_pll_setup);
533 
534 static void __init of_nomadik_hclk_setup(struct device_node *np)
535 {
536 	struct clk *clk = ERR_PTR(-EINVAL);
537 	const char *clk_name = np->name;
538 	const char *parent_name;
539 
540 	if (!src_base)
541 		nomadik_src_init();
542 
543 	parent_name = of_clk_get_parent_name(np, 0);
544 	/*
545 	 * The HCLK divides PLL1 with 1 (passthru), 2, 3 or 4.
546 	 */
547 	clk = clk_register_divider(NULL, clk_name, parent_name,
548 			   0, src_base + SRC_CR,
549 			   13, 2,
550 			   CLK_DIVIDER_ONE_BASED | CLK_DIVIDER_ALLOW_ZERO,
551 			   &src_lock);
552 	if (!IS_ERR(clk))
553 		of_clk_add_provider(np, of_clk_src_simple_get, clk);
554 }
555 CLK_OF_DECLARE(nomadik_hclk_clk,
556 	"st,nomadik-hclk-clock", of_nomadik_hclk_setup);
557 
558 static void __init of_nomadik_src_clk_setup(struct device_node *np)
559 {
560 	struct clk *clk = ERR_PTR(-EINVAL);
561 	const char *clk_name = np->name;
562 	const char *parent_name;
563 	u32 clk_id;
564 
565 	if (!src_base)
566 		nomadik_src_init();
567 
568 	if (of_property_read_u32(np, "clock-id", &clk_id)) {
569 		pr_err("%s: SRC clock \"%s\" missing clock-id property\n",
570 			__func__, clk_name);
571 		return;
572 	}
573 	parent_name = of_clk_get_parent_name(np, 0);
574 	clk = src_clk_register(NULL, clk_name, parent_name, clk_id);
575 	if (!IS_ERR(clk))
576 		of_clk_add_provider(np, of_clk_src_simple_get, clk);
577 }
578 CLK_OF_DECLARE(nomadik_src_clk,
579 	"st,nomadik-src-clock", of_nomadik_src_clk_setup);
580