xref: /linux/drivers/clk/ti/clk.c (revision 79790b6818e96c58fe2bffee1b418c16e64e7b80)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * TI clock support
4  *
5  * Copyright (C) 2013 Texas Instruments, Inc.
6  *
7  * Tero Kristo <t-kristo@ti.com>
8  */
9 
10 #include <linux/cleanup.h>
11 #include <linux/clk.h>
12 #include <linux/clk-provider.h>
13 #include <linux/clkdev.h>
14 #include <linux/clk/ti.h>
15 #include <linux/io.h>
16 #include <linux/of.h>
17 #include <linux/of_address.h>
18 #include <linux/list.h>
19 #include <linux/minmax.h>
20 #include <linux/regmap.h>
21 #include <linux/string_helpers.h>
22 #include <linux/memblock.h>
23 #include <linux/device.h>
24 
25 #include "clock.h"
26 
27 #undef pr_fmt
28 #define pr_fmt(fmt) "%s: " fmt, __func__
29 
30 static LIST_HEAD(clk_hw_omap_clocks);
31 struct ti_clk_ll_ops *ti_clk_ll_ops;
32 static struct device_node *clocks_node_ptr[CLK_MAX_MEMMAPS];
33 
34 struct ti_clk_features ti_clk_features;
35 
36 struct clk_iomap {
37 	struct regmap *regmap;
38 	void __iomem *mem;
39 };
40 
41 static struct clk_iomap *clk_memmaps[CLK_MAX_MEMMAPS];
42 
clk_memmap_writel(u32 val,const struct clk_omap_reg * reg)43 static void clk_memmap_writel(u32 val, const struct clk_omap_reg *reg)
44 {
45 	struct clk_iomap *io = clk_memmaps[reg->index];
46 
47 	if (reg->ptr)
48 		writel_relaxed(val, reg->ptr);
49 	else if (io->regmap)
50 		regmap_write(io->regmap, reg->offset, val);
51 	else
52 		writel_relaxed(val, io->mem + reg->offset);
53 }
54 
_clk_rmw(u32 val,u32 mask,void __iomem * ptr)55 static void _clk_rmw(u32 val, u32 mask, void __iomem *ptr)
56 {
57 	u32 v;
58 
59 	v = readl_relaxed(ptr);
60 	v &= ~mask;
61 	v |= val;
62 	writel_relaxed(v, ptr);
63 }
64 
clk_memmap_rmw(u32 val,u32 mask,const struct clk_omap_reg * reg)65 static void clk_memmap_rmw(u32 val, u32 mask, const struct clk_omap_reg *reg)
66 {
67 	struct clk_iomap *io = clk_memmaps[reg->index];
68 
69 	if (reg->ptr) {
70 		_clk_rmw(val, mask, reg->ptr);
71 	} else if (io->regmap) {
72 		regmap_update_bits(io->regmap, reg->offset, mask, val);
73 	} else {
74 		_clk_rmw(val, mask, io->mem + reg->offset);
75 	}
76 }
77 
clk_memmap_readl(const struct clk_omap_reg * reg)78 static u32 clk_memmap_readl(const struct clk_omap_reg *reg)
79 {
80 	u32 val;
81 	struct clk_iomap *io = clk_memmaps[reg->index];
82 
83 	if (reg->ptr)
84 		val = readl_relaxed(reg->ptr);
85 	else if (io->regmap)
86 		regmap_read(io->regmap, reg->offset, &val);
87 	else
88 		val = readl_relaxed(io->mem + reg->offset);
89 
90 	return val;
91 }
92 
93 /**
94  * ti_clk_setup_ll_ops - setup low level clock operations
95  * @ops: low level clock ops descriptor
96  *
97  * Sets up low level clock operations for TI clock driver. This is used
98  * to provide various callbacks for the clock driver towards platform
99  * specific code. Returns 0 on success, -EBUSY if ll_ops have been
100  * registered already.
101  */
ti_clk_setup_ll_ops(struct ti_clk_ll_ops * ops)102 int ti_clk_setup_ll_ops(struct ti_clk_ll_ops *ops)
103 {
104 	if (ti_clk_ll_ops) {
105 		pr_err("Attempt to register ll_ops multiple times.\n");
106 		return -EBUSY;
107 	}
108 
109 	ti_clk_ll_ops = ops;
110 	ops->clk_readl = clk_memmap_readl;
111 	ops->clk_writel = clk_memmap_writel;
112 	ops->clk_rmw = clk_memmap_rmw;
113 
114 	return 0;
115 }
116 
117 /*
118  * Eventually we could standardize to using '_' for clk-*.c files to follow the
119  * TRM naming.
120  */
ti_find_clock_provider(struct device_node * from,const char * name)121 static struct device_node *ti_find_clock_provider(struct device_node *from,
122 						  const char *name)
123 {
124 	char *tmp __free(kfree) = NULL;
125 	struct device_node *np;
126 	bool found = false;
127 	const char *n;
128 	char *p;
129 
130 	tmp = kstrdup_and_replace(name, '-', '_', GFP_KERNEL);
131 	if (!tmp)
132 		return NULL;
133 
134 	/* Ignore a possible address for the node name */
135 	p = strchr(tmp, '@');
136 	if (p)
137 		*p = '\0';
138 
139 	/* Node named "clock" with "clock-output-names" */
140 	for_each_of_allnodes_from(from, np) {
141 		if (of_property_read_string_index(np, "clock-output-names",
142 						  0, &n))
143 			continue;
144 
145 		if (!strncmp(n, tmp, strlen(tmp))) {
146 			of_node_get(np);
147 			found = true;
148 			break;
149 		}
150 	}
151 
152 	if (found) {
153 		of_node_put(from);
154 		return np;
155 	}
156 
157 	/* Fall back to using old node name base provider name */
158 	return of_find_node_by_name(from, tmp);
159 }
160 
161 /**
162  * ti_dt_clocks_register - register DT alias clocks during boot
163  * @oclks: list of clocks to register
164  *
165  * Register alias or non-standard DT clock entries during boot. By
166  * default, DT clocks are found based on their clock-output-names
167  * property, or the clock node name for legacy cases. If any
168  * additional con-id / dev-id -> clock mapping is required, use this
169  * function to list these.
170  */
ti_dt_clocks_register(struct ti_dt_clk oclks[])171 void __init ti_dt_clocks_register(struct ti_dt_clk oclks[])
172 {
173 	struct ti_dt_clk *c;
174 	struct device_node *node, *parent, *child;
175 	struct clk *clk;
176 	struct of_phandle_args clkspec;
177 	char buf[64];
178 	char *ptr;
179 	char *tags[2];
180 	int i;
181 	int num_args;
182 	int ret;
183 	static bool clkctrl_nodes_missing;
184 	static bool has_clkctrl_data;
185 	static bool compat_mode;
186 
187 	compat_mode = ti_clk_get_features()->flags & TI_CLK_CLKCTRL_COMPAT;
188 
189 	for (c = oclks; c->node_name != NULL; c++) {
190 		strcpy(buf, c->node_name);
191 		ptr = buf;
192 		for (i = 0; i < 2; i++)
193 			tags[i] = NULL;
194 		num_args = 0;
195 		while (*ptr) {
196 			if (*ptr == ':') {
197 				if (num_args >= 2) {
198 					pr_warn("Bad number of tags on %s\n",
199 						c->node_name);
200 					return;
201 				}
202 				tags[num_args++] = ptr + 1;
203 				*ptr = 0;
204 			}
205 			ptr++;
206 		}
207 
208 		if (num_args && clkctrl_nodes_missing)
209 			continue;
210 
211 		node = ti_find_clock_provider(NULL, buf);
212 		if (num_args && compat_mode) {
213 			parent = node;
214 			child = of_get_child_by_name(parent, "clock");
215 			if (!child)
216 				child = of_get_child_by_name(parent, "clk");
217 			if (child) {
218 				of_node_put(parent);
219 				node = child;
220 			}
221 		}
222 
223 		clkspec.np = node;
224 		clkspec.args_count = num_args;
225 		for (i = 0; i < num_args; i++) {
226 			ret = kstrtoint(tags[i], i ? 10 : 16, clkspec.args + i);
227 			if (ret) {
228 				pr_warn("Bad tag in %s at %d: %s\n",
229 					c->node_name, i, tags[i]);
230 				of_node_put(node);
231 				return;
232 			}
233 		}
234 		clk = of_clk_get_from_provider(&clkspec);
235 		of_node_put(node);
236 		if (!IS_ERR(clk)) {
237 			c->lk.clk = clk;
238 			clkdev_add(&c->lk);
239 		} else {
240 			if (num_args && !has_clkctrl_data) {
241 				struct device_node *np;
242 
243 				np = of_find_compatible_node(NULL, NULL,
244 							     "ti,clkctrl");
245 				if (np) {
246 					has_clkctrl_data = true;
247 					of_node_put(np);
248 				} else {
249 					clkctrl_nodes_missing = true;
250 
251 					pr_warn("missing clkctrl nodes, please update your dts.\n");
252 					continue;
253 				}
254 			}
255 
256 			pr_warn("failed to lookup clock node %s, ret=%ld\n",
257 				c->node_name, PTR_ERR(clk));
258 		}
259 	}
260 }
261 
262 struct clk_init_item {
263 	struct device_node *node;
264 	void *user;
265 	ti_of_clk_init_cb_t func;
266 	struct list_head link;
267 };
268 
269 static LIST_HEAD(retry_list);
270 
271 /**
272  * ti_clk_retry_init - retries a failed clock init at later phase
273  * @node: device node for the clock
274  * @user: user data pointer
275  * @func: init function to be called for the clock
276  *
277  * Adds a failed clock init to the retry list. The retry list is parsed
278  * once all the other clocks have been initialized.
279  */
ti_clk_retry_init(struct device_node * node,void * user,ti_of_clk_init_cb_t func)280 int __init ti_clk_retry_init(struct device_node *node, void *user,
281 			     ti_of_clk_init_cb_t func)
282 {
283 	struct clk_init_item *retry;
284 
285 	pr_debug("%pOFn: adding to retry list...\n", node);
286 	retry = kzalloc(sizeof(*retry), GFP_KERNEL);
287 	if (!retry)
288 		return -ENOMEM;
289 
290 	retry->node = node;
291 	retry->func = func;
292 	retry->user = user;
293 	list_add(&retry->link, &retry_list);
294 
295 	return 0;
296 }
297 
298 /**
299  * ti_clk_get_reg_addr - get register address for a clock register
300  * @node: device node for the clock
301  * @index: register index from the clock node
302  * @reg: pointer to target register struct
303  *
304  * Builds clock register address from device tree information, and returns
305  * the data via the provided output pointer @reg. Returns 0 on success,
306  * negative error value on failure.
307  */
ti_clk_get_reg_addr(struct device_node * node,int index,struct clk_omap_reg * reg)308 int ti_clk_get_reg_addr(struct device_node *node, int index,
309 			struct clk_omap_reg *reg)
310 {
311 	u32 clksel_addr, val;
312 	bool is_clksel = false;
313 	int i, err;
314 
315 	for (i = 0; i < CLK_MAX_MEMMAPS; i++) {
316 		if (clocks_node_ptr[i] == node->parent)
317 			break;
318 		if (clocks_node_ptr[i] == node->parent->parent)
319 			break;
320 	}
321 
322 	if (i == CLK_MAX_MEMMAPS) {
323 		pr_err("clk-provider not found for %pOFn!\n", node);
324 		return -ENOENT;
325 	}
326 
327 	reg->index = i;
328 
329 	if (of_device_is_compatible(node->parent, "ti,clksel")) {
330 		err = of_property_read_u32_index(node->parent, "reg", index, &clksel_addr);
331 		if (err) {
332 			pr_err("%pOFn parent clksel must have reg[%d]!\n", node, index);
333 			return -EINVAL;
334 		}
335 		is_clksel = true;
336 	}
337 
338 	err = of_property_read_u32_index(node, "reg", index, &val);
339 	if (err && is_clksel) {
340 		/* Legacy clksel with no reg and a possible ti,bit-shift property */
341 		reg->offset = clksel_addr;
342 		reg->bit = ti_clk_get_legacy_bit_shift(node);
343 		reg->ptr = NULL;
344 
345 		return 0;
346 	}
347 
348 	/* Updated clksel clock with a proper reg property */
349 	if (is_clksel) {
350 		reg->offset = clksel_addr;
351 		reg->bit = val;
352 		reg->ptr = NULL;
353 		return 0;
354 	}
355 
356 	/* Other clocks that may or may not have ti,bit-shift property  */
357 	reg->offset = val;
358 	reg->bit = ti_clk_get_legacy_bit_shift(node);
359 	reg->ptr = NULL;
360 
361 	return 0;
362 }
363 
364 /**
365  * ti_clk_get_legacy_bit_shift - get bit shift for a clock register
366  * @node: device node for the clock
367  *
368  * Gets the clock register bit shift using the legacy ti,bit-shift
369  * property. Only needed for legacy clock, and can be eventually
370  * dropped once all the composite clocks use a clksel node with a
371  * proper reg property.
372  */
ti_clk_get_legacy_bit_shift(struct device_node * node)373 int ti_clk_get_legacy_bit_shift(struct device_node *node)
374 {
375 	int err;
376 	u32 val;
377 
378 	err = of_property_read_u32(node, "ti,bit-shift", &val);
379 	if (!err && in_range(val, 0, 32))
380 		return val;
381 
382 	return 0;
383 }
384 
ti_clk_latch(struct clk_omap_reg * reg,s8 shift)385 void ti_clk_latch(struct clk_omap_reg *reg, s8 shift)
386 {
387 	u32 latch;
388 
389 	if (shift < 0)
390 		return;
391 
392 	latch = 1 << shift;
393 
394 	ti_clk_ll_ops->clk_rmw(latch, latch, reg);
395 	ti_clk_ll_ops->clk_rmw(0, latch, reg);
396 	ti_clk_ll_ops->clk_readl(reg); /* OCP barrier */
397 }
398 
399 /**
400  * omap2_clk_provider_init - init master clock provider
401  * @parent: master node
402  * @index: internal index for clk_reg_ops
403  * @syscon: syscon regmap pointer for accessing clock registers
404  * @mem: iomem pointer for the clock provider memory area, only used if
405  *       syscon is not provided
406  *
407  * Initializes a master clock IP block. This basically sets up the
408  * mapping from clocks node to the memory map index. All the clocks
409  * are then initialized through the common of_clk_init call, and the
410  * clocks will access their memory maps based on the node layout.
411  * Returns 0 in success.
412  */
omap2_clk_provider_init(struct device_node * parent,int index,struct regmap * syscon,void __iomem * mem)413 int __init omap2_clk_provider_init(struct device_node *parent, int index,
414 				   struct regmap *syscon, void __iomem *mem)
415 {
416 	struct device_node *clocks;
417 	struct clk_iomap *io;
418 
419 	/* get clocks for this parent */
420 	clocks = of_get_child_by_name(parent, "clocks");
421 	if (!clocks) {
422 		pr_err("%pOFn missing 'clocks' child node.\n", parent);
423 		return -EINVAL;
424 	}
425 
426 	/* add clocks node info */
427 	clocks_node_ptr[index] = clocks;
428 
429 	io = kzalloc(sizeof(*io), GFP_KERNEL);
430 	if (!io)
431 		return -ENOMEM;
432 
433 	io->regmap = syscon;
434 	io->mem = mem;
435 
436 	clk_memmaps[index] = io;
437 
438 	return 0;
439 }
440 
441 /**
442  * omap2_clk_legacy_provider_init - initialize a legacy clock provider
443  * @index: index for the clock provider
444  * @mem: iomem pointer for the clock provider memory area
445  *
446  * Initializes a legacy clock provider memory mapping.
447  */
omap2_clk_legacy_provider_init(int index,void __iomem * mem)448 void __init omap2_clk_legacy_provider_init(int index, void __iomem *mem)
449 {
450 	struct clk_iomap *io;
451 
452 	io = memblock_alloc(sizeof(*io), SMP_CACHE_BYTES);
453 	if (!io)
454 		panic("%s: Failed to allocate %zu bytes\n", __func__,
455 		      sizeof(*io));
456 
457 	io->mem = mem;
458 
459 	clk_memmaps[index] = io;
460 }
461 
462 /**
463  * ti_dt_clk_init_retry_clks - init clocks from the retry list
464  *
465  * Initializes any clocks that have failed to initialize before,
466  * reasons being missing parent node(s) during earlier init. This
467  * typically happens only for DPLLs which need to have both of their
468  * parent clocks ready during init.
469  */
ti_dt_clk_init_retry_clks(void)470 void ti_dt_clk_init_retry_clks(void)
471 {
472 	struct clk_init_item *retry;
473 	struct clk_init_item *tmp;
474 	int retries = 5;
475 
476 	while (!list_empty(&retry_list) && retries) {
477 		list_for_each_entry_safe(retry, tmp, &retry_list, link) {
478 			pr_debug("retry-init: %pOFn\n", retry->node);
479 			retry->func(retry->user, retry->node);
480 			list_del(&retry->link);
481 			kfree(retry);
482 		}
483 		retries--;
484 	}
485 }
486 
487 static const struct of_device_id simple_clk_match_table[] __initconst = {
488 	{ .compatible = "fixed-clock" },
489 	{ .compatible = "fixed-factor-clock" },
490 	{ }
491 };
492 
493 /**
494  * ti_dt_clk_name - init clock name from first output name or node name
495  * @np: device node
496  *
497  * Use the first clock-output-name for the clock name if found. Fall back
498  * to legacy naming based on node name.
499  */
ti_dt_clk_name(struct device_node * np)500 const char *ti_dt_clk_name(struct device_node *np)
501 {
502 	const char *name;
503 
504 	if (!of_property_read_string_index(np, "clock-output-names", 0,
505 					   &name))
506 		return name;
507 
508 	return np->name;
509 }
510 
511 /**
512  * ti_clk_add_aliases - setup clock aliases
513  *
514  * Sets up any missing clock aliases. No return value.
515  */
ti_clk_add_aliases(void)516 void __init ti_clk_add_aliases(void)
517 {
518 	struct device_node *np;
519 	struct clk *clk;
520 
521 	for_each_matching_node(np, simple_clk_match_table) {
522 		struct of_phandle_args clkspec;
523 
524 		clkspec.np = np;
525 		clk = of_clk_get_from_provider(&clkspec);
526 
527 		ti_clk_add_alias(clk, ti_dt_clk_name(np));
528 	}
529 }
530 
531 /**
532  * ti_clk_setup_features - setup clock features flags
533  * @features: features definition to use
534  *
535  * Initializes the clock driver features flags based on platform
536  * provided data. No return value.
537  */
ti_clk_setup_features(struct ti_clk_features * features)538 void __init ti_clk_setup_features(struct ti_clk_features *features)
539 {
540 	memcpy(&ti_clk_features, features, sizeof(*features));
541 }
542 
543 /**
544  * ti_clk_get_features - get clock driver features flags
545  *
546  * Get TI clock driver features description. Returns a pointer
547  * to the current feature setup.
548  */
ti_clk_get_features(void)549 const struct ti_clk_features *ti_clk_get_features(void)
550 {
551 	return &ti_clk_features;
552 }
553 
554 /**
555  * omap2_clk_enable_init_clocks - prepare & enable a list of clocks
556  * @clk_names: ptr to an array of strings of clock names to enable
557  * @num_clocks: number of clock names in @clk_names
558  *
559  * Prepare and enable a list of clocks, named by @clk_names.  No
560  * return value. XXX Deprecated; only needed until these clocks are
561  * properly claimed and enabled by the drivers or core code that uses
562  * them.  XXX What code disables & calls clk_put on these clocks?
563  */
omap2_clk_enable_init_clocks(const char ** clk_names,u8 num_clocks)564 void omap2_clk_enable_init_clocks(const char **clk_names, u8 num_clocks)
565 {
566 	struct clk *init_clk;
567 	int i;
568 
569 	for (i = 0; i < num_clocks; i++) {
570 		init_clk = clk_get(NULL, clk_names[i]);
571 		if (WARN(IS_ERR(init_clk), "could not find init clock %s\n",
572 			 clk_names[i]))
573 			continue;
574 		clk_prepare_enable(init_clk);
575 	}
576 }
577 
578 /**
579  * ti_clk_add_alias - add a clock alias for a TI clock
580  * @clk: clock handle to create alias for
581  * @con: connection ID for this clock
582  *
583  * Creates a clock alias for a TI clock. Allocates the clock lookup entry
584  * and assigns the data to it. Returns 0 if successful, negative error
585  * value otherwise.
586  */
ti_clk_add_alias(struct clk * clk,const char * con)587 int ti_clk_add_alias(struct clk *clk, const char *con)
588 {
589 	struct clk_lookup *cl;
590 
591 	if (!clk)
592 		return 0;
593 
594 	if (IS_ERR(clk))
595 		return PTR_ERR(clk);
596 
597 	cl = kzalloc(sizeof(*cl), GFP_KERNEL);
598 	if (!cl)
599 		return -ENOMEM;
600 
601 	cl->con_id = con;
602 	cl->clk = clk;
603 
604 	clkdev_add(cl);
605 
606 	return 0;
607 }
608 
609 /**
610  * of_ti_clk_register - register a TI clock to the common clock framework
611  * @node: device node for this clock
612  * @hw: hardware clock handle
613  * @con: connection ID for this clock
614  *
615  * Registers a TI clock to the common clock framework, and adds a clock
616  * alias for it. Returns a handle to the registered clock if successful,
617  * ERR_PTR value in failure.
618  */
of_ti_clk_register(struct device_node * node,struct clk_hw * hw,const char * con)619 struct clk *of_ti_clk_register(struct device_node *node, struct clk_hw *hw,
620 			       const char *con)
621 {
622 	struct clk *clk;
623 	int ret;
624 
625 	ret = of_clk_hw_register(node, hw);
626 	if (ret)
627 		return ERR_PTR(ret);
628 
629 	clk = hw->clk;
630 	ret = ti_clk_add_alias(clk, con);
631 	if (ret) {
632 		clk_unregister(clk);
633 		return ERR_PTR(ret);
634 	}
635 
636 	return clk;
637 }
638 
639 /**
640  * of_ti_clk_register_omap_hw - register a clk_hw_omap to the clock framework
641  * @node: device node for this clock
642  * @hw: hardware clock handle
643  * @con: connection ID for this clock
644  *
645  * Registers a clk_hw_omap clock to the clock framewor, adds a clock alias
646  * for it, and adds the list to the available clk_hw_omap type clocks.
647  * Returns a handle to the registered clock if successful, ERR_PTR value
648  * in failure.
649  */
of_ti_clk_register_omap_hw(struct device_node * node,struct clk_hw * hw,const char * con)650 struct clk *of_ti_clk_register_omap_hw(struct device_node *node,
651 				       struct clk_hw *hw, const char *con)
652 {
653 	struct clk *clk;
654 	struct clk_hw_omap *oclk;
655 
656 	clk = of_ti_clk_register(node, hw, con);
657 	if (IS_ERR(clk))
658 		return clk;
659 
660 	oclk = to_clk_hw_omap(hw);
661 
662 	list_add(&oclk->node, &clk_hw_omap_clocks);
663 
664 	return clk;
665 }
666 
667 /**
668  * omap2_clk_for_each - call function for each registered clk_hw_omap
669  * @fn: pointer to a callback function
670  *
671  * Call @fn for each registered clk_hw_omap, passing @hw to each
672  * function.  @fn must return 0 for success or any other value for
673  * failure.  If @fn returns non-zero, the iteration across clocks
674  * will stop and the non-zero return value will be passed to the
675  * caller of omap2_clk_for_each().
676  */
omap2_clk_for_each(int (* fn)(struct clk_hw_omap * hw))677 int omap2_clk_for_each(int (*fn)(struct clk_hw_omap *hw))
678 {
679 	int ret;
680 	struct clk_hw_omap *hw;
681 
682 	list_for_each_entry(hw, &clk_hw_omap_clocks, node) {
683 		ret = (*fn)(hw);
684 		if (ret)
685 			break;
686 	}
687 
688 	return ret;
689 }
690 
691 /**
692  * omap2_clk_is_hw_omap - check if the provided clk_hw is OMAP clock
693  * @hw: clk_hw to check if it is an omap clock or not
694  *
695  * Checks if the provided clk_hw is OMAP clock or not. Returns true if
696  * it is, false otherwise.
697  */
omap2_clk_is_hw_omap(struct clk_hw * hw)698 bool omap2_clk_is_hw_omap(struct clk_hw *hw)
699 {
700 	struct clk_hw_omap *oclk;
701 
702 	list_for_each_entry(oclk, &clk_hw_omap_clocks, node) {
703 		if (&oclk->hw == hw)
704 			return true;
705 	}
706 
707 	return false;
708 }
709