xref: /linux/drivers/clk/samsung/clk.c (revision 1517d90cfafe0f95fd7863d04e1596f7beb7dfa8) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2013 Samsung Electronics Co., Ltd.
4  * Copyright (c) 2013 Linaro Ltd.
5  * Author: Thomas Abraham <thomas.ab@samsung.com>
6  *
7  * This file includes utility functions to register clocks to common
8  * clock framework for Samsung platforms.
9 */
10 
11 #include <linux/slab.h>
12 #include <linux/clkdev.h>
13 #include <linux/clk.h>
14 #include <linux/clk-provider.h>
15 #include <linux/io.h>
16 #include <linux/of_address.h>
17 #include <linux/syscore_ops.h>
18 
19 #include "clk.h"
20 
21 static LIST_HEAD(clock_reg_cache_list);
22 
23 void samsung_clk_save(void __iomem *base,
24 				    struct samsung_clk_reg_dump *rd,
25 				    unsigned int num_regs)
26 {
27 	for (; num_regs > 0; --num_regs, ++rd)
28 		rd->value = readl(base + rd->offset);
29 }
30 
31 void samsung_clk_restore(void __iomem *base,
32 				      const struct samsung_clk_reg_dump *rd,
33 				      unsigned int num_regs)
34 {
35 	for (; num_regs > 0; --num_regs, ++rd)
36 		writel(rd->value, base + rd->offset);
37 }
38 
39 struct samsung_clk_reg_dump *samsung_clk_alloc_reg_dump(
40 						const unsigned long *rdump,
41 						unsigned long nr_rdump)
42 {
43 	struct samsung_clk_reg_dump *rd;
44 	unsigned int i;
45 
46 	rd = kcalloc(nr_rdump, sizeof(*rd), GFP_KERNEL);
47 	if (!rd)
48 		return NULL;
49 
50 	for (i = 0; i < nr_rdump; ++i)
51 		rd[i].offset = rdump[i];
52 
53 	return rd;
54 }
55 
56 /* setup the essentials required to support clock lookup using ccf */
57 struct samsung_clk_provider *__init samsung_clk_init(struct device_node *np,
58 			void __iomem *base, unsigned long nr_clks)
59 {
60 	struct samsung_clk_provider *ctx;
61 	int i;
62 
63 	ctx = kzalloc(sizeof(struct samsung_clk_provider) +
64 		      sizeof(*ctx->clk_data.hws) * nr_clks, GFP_KERNEL);
65 	if (!ctx)
66 		panic("could not allocate clock provider context.\n");
67 
68 	for (i = 0; i < nr_clks; ++i)
69 		ctx->clk_data.hws[i] = ERR_PTR(-ENOENT);
70 
71 	ctx->reg_base = base;
72 	ctx->clk_data.num = nr_clks;
73 	spin_lock_init(&ctx->lock);
74 
75 	return ctx;
76 }
77 
78 void __init samsung_clk_of_add_provider(struct device_node *np,
79 				struct samsung_clk_provider *ctx)
80 {
81 	if (np) {
82 		if (of_clk_add_hw_provider(np, of_clk_hw_onecell_get,
83 					&ctx->clk_data))
84 			panic("could not register clk provider\n");
85 	}
86 }
87 
88 /* add a clock instance to the clock lookup table used for dt based lookup */
89 void samsung_clk_add_lookup(struct samsung_clk_provider *ctx,
90 			    struct clk_hw *clk_hw, unsigned int id)
91 {
92 	if (id)
93 		ctx->clk_data.hws[id] = clk_hw;
94 }
95 
96 /* register a list of aliases */
97 void __init samsung_clk_register_alias(struct samsung_clk_provider *ctx,
98 				const struct samsung_clock_alias *list,
99 				unsigned int nr_clk)
100 {
101 	struct clk_hw *clk_hw;
102 	unsigned int idx, ret;
103 
104 	for (idx = 0; idx < nr_clk; idx++, list++) {
105 		if (!list->id) {
106 			pr_err("%s: clock id missing for index %d\n", __func__,
107 				idx);
108 			continue;
109 		}
110 
111 		clk_hw = ctx->clk_data.hws[list->id];
112 		if (!clk_hw) {
113 			pr_err("%s: failed to find clock %d\n", __func__,
114 				list->id);
115 			continue;
116 		}
117 
118 		ret = clk_hw_register_clkdev(clk_hw, list->alias,
119 					     list->dev_name);
120 		if (ret)
121 			pr_err("%s: failed to register lookup %s\n",
122 					__func__, list->alias);
123 	}
124 }
125 
126 /* register a list of fixed clocks */
127 void __init samsung_clk_register_fixed_rate(struct samsung_clk_provider *ctx,
128 		const struct samsung_fixed_rate_clock *list,
129 		unsigned int nr_clk)
130 {
131 	struct clk_hw *clk_hw;
132 	unsigned int idx, ret;
133 
134 	for (idx = 0; idx < nr_clk; idx++, list++) {
135 		clk_hw = clk_hw_register_fixed_rate(ctx->dev, list->name,
136 			list->parent_name, list->flags, list->fixed_rate);
137 		if (IS_ERR(clk_hw)) {
138 			pr_err("%s: failed to register clock %s\n", __func__,
139 				list->name);
140 			continue;
141 		}
142 
143 		samsung_clk_add_lookup(ctx, clk_hw, list->id);
144 
145 		/*
146 		 * Unconditionally add a clock lookup for the fixed rate clocks.
147 		 * There are not many of these on any of Samsung platforms.
148 		 */
149 		ret = clk_hw_register_clkdev(clk_hw, list->name, NULL);
150 		if (ret)
151 			pr_err("%s: failed to register clock lookup for %s",
152 				__func__, list->name);
153 	}
154 }
155 
156 /* register a list of fixed factor clocks */
157 void __init samsung_clk_register_fixed_factor(struct samsung_clk_provider *ctx,
158 		const struct samsung_fixed_factor_clock *list, unsigned int nr_clk)
159 {
160 	struct clk_hw *clk_hw;
161 	unsigned int idx;
162 
163 	for (idx = 0; idx < nr_clk; idx++, list++) {
164 		clk_hw = clk_hw_register_fixed_factor(ctx->dev, list->name,
165 			list->parent_name, list->flags, list->mult, list->div);
166 		if (IS_ERR(clk_hw)) {
167 			pr_err("%s: failed to register clock %s\n", __func__,
168 				list->name);
169 			continue;
170 		}
171 
172 		samsung_clk_add_lookup(ctx, clk_hw, list->id);
173 	}
174 }
175 
176 /* register a list of mux clocks */
177 void __init samsung_clk_register_mux(struct samsung_clk_provider *ctx,
178 				const struct samsung_mux_clock *list,
179 				unsigned int nr_clk)
180 {
181 	struct clk_hw *clk_hw;
182 	unsigned int idx;
183 
184 	for (idx = 0; idx < nr_clk; idx++, list++) {
185 		clk_hw = clk_hw_register_mux(ctx->dev, list->name,
186 			list->parent_names, list->num_parents, list->flags,
187 			ctx->reg_base + list->offset,
188 			list->shift, list->width, list->mux_flags, &ctx->lock);
189 		if (IS_ERR(clk_hw)) {
190 			pr_err("%s: failed to register clock %s\n", __func__,
191 				list->name);
192 			continue;
193 		}
194 
195 		samsung_clk_add_lookup(ctx, clk_hw, list->id);
196 	}
197 }
198 
199 /* register a list of div clocks */
200 void __init samsung_clk_register_div(struct samsung_clk_provider *ctx,
201 				const struct samsung_div_clock *list,
202 				unsigned int nr_clk)
203 {
204 	struct clk_hw *clk_hw;
205 	unsigned int idx;
206 
207 	for (idx = 0; idx < nr_clk; idx++, list++) {
208 		if (list->table)
209 			clk_hw = clk_hw_register_divider_table(ctx->dev,
210 				list->name, list->parent_name, list->flags,
211 				ctx->reg_base + list->offset,
212 				list->shift, list->width, list->div_flags,
213 				list->table, &ctx->lock);
214 		else
215 			clk_hw = clk_hw_register_divider(ctx->dev, list->name,
216 				list->parent_name, list->flags,
217 				ctx->reg_base + list->offset, list->shift,
218 				list->width, list->div_flags, &ctx->lock);
219 		if (IS_ERR(clk_hw)) {
220 			pr_err("%s: failed to register clock %s\n", __func__,
221 				list->name);
222 			continue;
223 		}
224 
225 		samsung_clk_add_lookup(ctx, clk_hw, list->id);
226 	}
227 }
228 
229 /* register a list of gate clocks */
230 void __init samsung_clk_register_gate(struct samsung_clk_provider *ctx,
231 				const struct samsung_gate_clock *list,
232 				unsigned int nr_clk)
233 {
234 	struct clk_hw *clk_hw;
235 	unsigned int idx;
236 
237 	for (idx = 0; idx < nr_clk; idx++, list++) {
238 		clk_hw = clk_hw_register_gate(ctx->dev, list->name, list->parent_name,
239 				list->flags, ctx->reg_base + list->offset,
240 				list->bit_idx, list->gate_flags, &ctx->lock);
241 		if (IS_ERR(clk_hw)) {
242 			pr_err("%s: failed to register clock %s\n", __func__,
243 				list->name);
244 			continue;
245 		}
246 
247 		samsung_clk_add_lookup(ctx, clk_hw, list->id);
248 	}
249 }
250 
251 /*
252  * obtain the clock speed of all external fixed clock sources from device
253  * tree and register it
254  */
255 void __init samsung_clk_of_register_fixed_ext(struct samsung_clk_provider *ctx,
256 			struct samsung_fixed_rate_clock *fixed_rate_clk,
257 			unsigned int nr_fixed_rate_clk,
258 			const struct of_device_id *clk_matches)
259 {
260 	const struct of_device_id *match;
261 	struct device_node *clk_np;
262 	u32 freq;
263 
264 	for_each_matching_node_and_match(clk_np, clk_matches, &match) {
265 		if (of_property_read_u32(clk_np, "clock-frequency", &freq))
266 			continue;
267 		fixed_rate_clk[(unsigned long)match->data].fixed_rate = freq;
268 	}
269 	samsung_clk_register_fixed_rate(ctx, fixed_rate_clk, nr_fixed_rate_clk);
270 }
271 
272 /* utility function to get the rate of a specified clock */
273 unsigned long _get_rate(const char *clk_name)
274 {
275 	struct clk *clk;
276 
277 	clk = __clk_lookup(clk_name);
278 	if (!clk) {
279 		pr_err("%s: could not find clock %s\n", __func__, clk_name);
280 		return 0;
281 	}
282 
283 	return clk_get_rate(clk);
284 }
285 
286 #ifdef CONFIG_PM_SLEEP
287 static int samsung_clk_suspend(void)
288 {
289 	struct samsung_clock_reg_cache *reg_cache;
290 
291 	list_for_each_entry(reg_cache, &clock_reg_cache_list, node) {
292 		samsung_clk_save(reg_cache->reg_base, reg_cache->rdump,
293 				reg_cache->rd_num);
294 		samsung_clk_restore(reg_cache->reg_base, reg_cache->rsuspend,
295 				reg_cache->rsuspend_num);
296 	}
297 	return 0;
298 }
299 
300 static void samsung_clk_resume(void)
301 {
302 	struct samsung_clock_reg_cache *reg_cache;
303 
304 	list_for_each_entry(reg_cache, &clock_reg_cache_list, node)
305 		samsung_clk_restore(reg_cache->reg_base, reg_cache->rdump,
306 				reg_cache->rd_num);
307 }
308 
309 static struct syscore_ops samsung_clk_syscore_ops = {
310 	.suspend = samsung_clk_suspend,
311 	.resume = samsung_clk_resume,
312 };
313 
314 void samsung_clk_extended_sleep_init(void __iomem *reg_base,
315 			const unsigned long *rdump,
316 			unsigned long nr_rdump,
317 			const struct samsung_clk_reg_dump *rsuspend,
318 			unsigned long nr_rsuspend)
319 {
320 	struct samsung_clock_reg_cache *reg_cache;
321 
322 	reg_cache = kzalloc(sizeof(struct samsung_clock_reg_cache),
323 			GFP_KERNEL);
324 	if (!reg_cache)
325 		panic("could not allocate register reg_cache.\n");
326 	reg_cache->rdump = samsung_clk_alloc_reg_dump(rdump, nr_rdump);
327 
328 	if (!reg_cache->rdump)
329 		panic("could not allocate register dump storage.\n");
330 
331 	if (list_empty(&clock_reg_cache_list))
332 		register_syscore_ops(&samsung_clk_syscore_ops);
333 
334 	reg_cache->reg_base = reg_base;
335 	reg_cache->rd_num = nr_rdump;
336 	reg_cache->rsuspend = rsuspend;
337 	reg_cache->rsuspend_num = nr_rsuspend;
338 	list_add_tail(&reg_cache->node, &clock_reg_cache_list);
339 }
340 #endif
341 
342 /*
343  * Common function which registers plls, muxes, dividers and gates
344  * for each CMU. It also add CMU register list to register cache.
345  */
346 struct samsung_clk_provider * __init samsung_cmu_register_one(
347 			struct device_node *np,
348 			const struct samsung_cmu_info *cmu)
349 {
350 	void __iomem *reg_base;
351 	struct samsung_clk_provider *ctx;
352 
353 	reg_base = of_iomap(np, 0);
354 	if (!reg_base) {
355 		panic("%s: failed to map registers\n", __func__);
356 		return NULL;
357 	}
358 
359 	ctx = samsung_clk_init(np, reg_base, cmu->nr_clk_ids);
360 	if (!ctx) {
361 		panic("%s: unable to allocate ctx\n", __func__);
362 		return ctx;
363 	}
364 
365 	if (cmu->pll_clks)
366 		samsung_clk_register_pll(ctx, cmu->pll_clks, cmu->nr_pll_clks,
367 			reg_base);
368 	if (cmu->mux_clks)
369 		samsung_clk_register_mux(ctx, cmu->mux_clks,
370 			cmu->nr_mux_clks);
371 	if (cmu->div_clks)
372 		samsung_clk_register_div(ctx, cmu->div_clks, cmu->nr_div_clks);
373 	if (cmu->gate_clks)
374 		samsung_clk_register_gate(ctx, cmu->gate_clks,
375 			cmu->nr_gate_clks);
376 	if (cmu->fixed_clks)
377 		samsung_clk_register_fixed_rate(ctx, cmu->fixed_clks,
378 			cmu->nr_fixed_clks);
379 	if (cmu->fixed_factor_clks)
380 		samsung_clk_register_fixed_factor(ctx, cmu->fixed_factor_clks,
381 			cmu->nr_fixed_factor_clks);
382 	if (cmu->clk_regs)
383 		samsung_clk_extended_sleep_init(reg_base,
384 			cmu->clk_regs, cmu->nr_clk_regs,
385 			cmu->suspend_regs, cmu->nr_suspend_regs);
386 
387 	samsung_clk_of_add_provider(np, ctx);
388 
389 	return ctx;
390 }
391