xref: /openbmc/linux/drivers/clk/st/clk-flexgen.c (revision 36f8a30c)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * clk-flexgen.c
4  *
5  * Copyright (C) ST-Microelectronics SA 2013
6  * Author:  Maxime Coquelin <maxime.coquelin@st.com> for ST-Microelectronics.
7  */
8 
9 #include <linux/clk.h>
10 #include <linux/clk-provider.h>
11 #include <linux/module.h>
12 #include <linux/slab.h>
13 #include <linux/io.h>
14 #include <linux/err.h>
15 #include <linux/string.h>
16 #include <linux/of.h>
17 #include <linux/of_address.h>
18 
19 struct clkgen_clk_out {
20 	const char *name;
21 	unsigned long flags;
22 };
23 
24 struct clkgen_data {
25 	unsigned long flags;
26 	bool mode;
27 	const struct clkgen_clk_out *outputs;
28 	const unsigned int outputs_nb;
29 };
30 
31 struct flexgen {
32 	struct clk_hw hw;
33 
34 	/* Crossbar */
35 	struct clk_mux mux;
36 	/* Pre-divisor's gate */
37 	struct clk_gate pgate;
38 	/* Pre-divisor */
39 	struct clk_divider pdiv;
40 	/* Final divisor's gate */
41 	struct clk_gate fgate;
42 	/* Final divisor */
43 	struct clk_divider fdiv;
44 	/* Asynchronous mode control */
45 	struct clk_gate sync;
46 	/* hw control flags */
47 	bool control_mode;
48 };
49 
50 #define to_flexgen(_hw) container_of(_hw, struct flexgen, hw)
51 #define to_clk_gate(_hw) container_of(_hw, struct clk_gate, hw)
52 
flexgen_enable(struct clk_hw * hw)53 static int flexgen_enable(struct clk_hw *hw)
54 {
55 	struct flexgen *flexgen = to_flexgen(hw);
56 	struct clk_hw *pgate_hw = &flexgen->pgate.hw;
57 	struct clk_hw *fgate_hw = &flexgen->fgate.hw;
58 
59 	__clk_hw_set_clk(pgate_hw, hw);
60 	__clk_hw_set_clk(fgate_hw, hw);
61 
62 	clk_gate_ops.enable(pgate_hw);
63 
64 	clk_gate_ops.enable(fgate_hw);
65 
66 	pr_debug("%s: flexgen output enabled\n", clk_hw_get_name(hw));
67 	return 0;
68 }
69 
flexgen_disable(struct clk_hw * hw)70 static void flexgen_disable(struct clk_hw *hw)
71 {
72 	struct flexgen *flexgen = to_flexgen(hw);
73 	struct clk_hw *fgate_hw = &flexgen->fgate.hw;
74 
75 	/* disable only the final gate */
76 	__clk_hw_set_clk(fgate_hw, hw);
77 
78 	clk_gate_ops.disable(fgate_hw);
79 
80 	pr_debug("%s: flexgen output disabled\n", clk_hw_get_name(hw));
81 }
82 
flexgen_is_enabled(struct clk_hw * hw)83 static int flexgen_is_enabled(struct clk_hw *hw)
84 {
85 	struct flexgen *flexgen = to_flexgen(hw);
86 	struct clk_hw *fgate_hw = &flexgen->fgate.hw;
87 
88 	__clk_hw_set_clk(fgate_hw, hw);
89 
90 	if (!clk_gate_ops.is_enabled(fgate_hw))
91 		return 0;
92 
93 	return 1;
94 }
95 
flexgen_get_parent(struct clk_hw * hw)96 static u8 flexgen_get_parent(struct clk_hw *hw)
97 {
98 	struct flexgen *flexgen = to_flexgen(hw);
99 	struct clk_hw *mux_hw = &flexgen->mux.hw;
100 
101 	__clk_hw_set_clk(mux_hw, hw);
102 
103 	return clk_mux_ops.get_parent(mux_hw);
104 }
105 
flexgen_set_parent(struct clk_hw * hw,u8 index)106 static int flexgen_set_parent(struct clk_hw *hw, u8 index)
107 {
108 	struct flexgen *flexgen = to_flexgen(hw);
109 	struct clk_hw *mux_hw = &flexgen->mux.hw;
110 
111 	__clk_hw_set_clk(mux_hw, hw);
112 
113 	return clk_mux_ops.set_parent(mux_hw, index);
114 }
115 
116 static inline unsigned long
clk_best_div(unsigned long parent_rate,unsigned long rate)117 clk_best_div(unsigned long parent_rate, unsigned long rate)
118 {
119 	return parent_rate / rate + ((rate > (2*(parent_rate % rate))) ? 0 : 1);
120 }
121 
flexgen_determine_rate(struct clk_hw * hw,struct clk_rate_request * req)122 static int flexgen_determine_rate(struct clk_hw *hw,
123 				  struct clk_rate_request *req)
124 {
125 	unsigned long div;
126 
127 	/* Round div according to exact prate and wished rate */
128 	div = clk_best_div(req->best_parent_rate, req->rate);
129 
130 	if (clk_hw_get_flags(hw) & CLK_SET_RATE_PARENT) {
131 		req->best_parent_rate = req->rate * div;
132 		return 0;
133 	}
134 
135 	req->rate = req->best_parent_rate / div;
136 	return 0;
137 }
138 
flexgen_recalc_rate(struct clk_hw * hw,unsigned long parent_rate)139 static unsigned long flexgen_recalc_rate(struct clk_hw *hw,
140 		unsigned long parent_rate)
141 {
142 	struct flexgen *flexgen = to_flexgen(hw);
143 	struct clk_hw *pdiv_hw = &flexgen->pdiv.hw;
144 	struct clk_hw *fdiv_hw = &flexgen->fdiv.hw;
145 	unsigned long mid_rate;
146 
147 	__clk_hw_set_clk(pdiv_hw, hw);
148 	__clk_hw_set_clk(fdiv_hw, hw);
149 
150 	mid_rate = clk_divider_ops.recalc_rate(pdiv_hw, parent_rate);
151 
152 	return clk_divider_ops.recalc_rate(fdiv_hw, mid_rate);
153 }
154 
flexgen_set_rate(struct clk_hw * hw,unsigned long rate,unsigned long parent_rate)155 static int flexgen_set_rate(struct clk_hw *hw, unsigned long rate,
156 				unsigned long parent_rate)
157 {
158 	struct flexgen *flexgen = to_flexgen(hw);
159 	struct clk_hw *pdiv_hw = &flexgen->pdiv.hw;
160 	struct clk_hw *fdiv_hw = &flexgen->fdiv.hw;
161 	struct clk_hw *sync_hw = &flexgen->sync.hw;
162 	struct clk_gate *config = to_clk_gate(sync_hw);
163 	unsigned long div = 0;
164 	int ret = 0;
165 	u32 reg;
166 
167 	__clk_hw_set_clk(pdiv_hw, hw);
168 	__clk_hw_set_clk(fdiv_hw, hw);
169 
170 	if (flexgen->control_mode) {
171 		reg = readl(config->reg);
172 		reg &= ~BIT(config->bit_idx);
173 		writel(reg, config->reg);
174 	}
175 
176 	div = clk_best_div(parent_rate, rate);
177 
178 	/*
179 	* pdiv is mainly targeted for low freq results, while fdiv
180 	* should be used for div <= 64. The other way round can
181 	* lead to 'duty cycle' issues.
182 	*/
183 
184 	if (div <= 64) {
185 		clk_divider_ops.set_rate(pdiv_hw, parent_rate, parent_rate);
186 		ret = clk_divider_ops.set_rate(fdiv_hw, rate, rate * div);
187 	} else {
188 		clk_divider_ops.set_rate(fdiv_hw, parent_rate, parent_rate);
189 		ret = clk_divider_ops.set_rate(pdiv_hw, rate, rate * div);
190 	}
191 
192 	return ret;
193 }
194 
195 static const struct clk_ops flexgen_ops = {
196 	.enable = flexgen_enable,
197 	.disable = flexgen_disable,
198 	.is_enabled = flexgen_is_enabled,
199 	.get_parent = flexgen_get_parent,
200 	.set_parent = flexgen_set_parent,
201 	.determine_rate = flexgen_determine_rate,
202 	.recalc_rate = flexgen_recalc_rate,
203 	.set_rate = flexgen_set_rate,
204 };
205 
clk_register_flexgen(const char * name,const char ** parent_names,u8 num_parents,void __iomem * reg,spinlock_t * lock,u32 idx,unsigned long flexgen_flags,bool mode)206 static struct clk *clk_register_flexgen(const char *name,
207 				const char **parent_names, u8 num_parents,
208 				void __iomem *reg, spinlock_t *lock, u32 idx,
209 				unsigned long flexgen_flags, bool mode) {
210 	struct flexgen *fgxbar;
211 	struct clk *clk;
212 	struct clk_init_data init;
213 	u32  xbar_shift;
214 	void __iomem *xbar_reg, *fdiv_reg;
215 
216 	fgxbar = kzalloc(sizeof(struct flexgen), GFP_KERNEL);
217 	if (!fgxbar)
218 		return ERR_PTR(-ENOMEM);
219 
220 	init.name = name;
221 	init.ops = &flexgen_ops;
222 	init.flags = CLK_GET_RATE_NOCACHE | flexgen_flags;
223 	init.parent_names = parent_names;
224 	init.num_parents = num_parents;
225 
226 	xbar_reg = reg + 0x18 + (idx & ~0x3);
227 	xbar_shift = (idx % 4) * 0x8;
228 	fdiv_reg = reg + 0x164 + idx * 4;
229 
230 	/* Crossbar element config */
231 	fgxbar->mux.lock = lock;
232 	fgxbar->mux.mask = BIT(6) - 1;
233 	fgxbar->mux.reg = xbar_reg;
234 	fgxbar->mux.shift = xbar_shift;
235 	fgxbar->mux.table = NULL;
236 
237 
238 	/* Pre-divider's gate config (in xbar register)*/
239 	fgxbar->pgate.lock = lock;
240 	fgxbar->pgate.reg = xbar_reg;
241 	fgxbar->pgate.bit_idx = xbar_shift + 6;
242 
243 	/* Pre-divider config */
244 	fgxbar->pdiv.lock = lock;
245 	fgxbar->pdiv.reg = reg + 0x58 + idx * 4;
246 	fgxbar->pdiv.width = 10;
247 
248 	/* Final divider's gate config */
249 	fgxbar->fgate.lock = lock;
250 	fgxbar->fgate.reg = fdiv_reg;
251 	fgxbar->fgate.bit_idx = 6;
252 
253 	/* Final divider config */
254 	fgxbar->fdiv.lock = lock;
255 	fgxbar->fdiv.reg = fdiv_reg;
256 	fgxbar->fdiv.width = 6;
257 
258 	/* Final divider sync config */
259 	fgxbar->sync.lock = lock;
260 	fgxbar->sync.reg = fdiv_reg;
261 	fgxbar->sync.bit_idx = 7;
262 
263 	fgxbar->control_mode = mode;
264 
265 	fgxbar->hw.init = &init;
266 
267 	clk = clk_register(NULL, &fgxbar->hw);
268 	if (IS_ERR(clk))
269 		kfree(fgxbar);
270 	else
271 		pr_debug("%s: parent %s rate %u\n",
272 			__clk_get_name(clk),
273 			__clk_get_name(clk_get_parent(clk)),
274 			(unsigned int)clk_get_rate(clk));
275 	return clk;
276 }
277 
flexgen_get_parents(struct device_node * np,int * num_parents)278 static const char ** __init flexgen_get_parents(struct device_node *np,
279 						       int *num_parents)
280 {
281 	const char **parents;
282 	unsigned int nparents;
283 
284 	nparents = of_clk_get_parent_count(np);
285 	if (WARN_ON(!nparents))
286 		return NULL;
287 
288 	parents = kcalloc(nparents, sizeof(const char *), GFP_KERNEL);
289 	if (!parents)
290 		return NULL;
291 
292 	*num_parents = of_clk_parent_fill(np, parents, nparents);
293 
294 	return parents;
295 }
296 
297 static const struct clkgen_data clkgen_audio = {
298 	.flags = CLK_SET_RATE_PARENT,
299 };
300 
301 static const struct clkgen_data clkgen_video = {
302 	.flags = CLK_SET_RATE_PARENT,
303 	.mode = 1,
304 };
305 
306 static const struct clkgen_clk_out clkgen_stih407_a0_clk_out[] = {
307 	/* This clk needs to be on so that memory interface is accessible */
308 	{ .name = "clk-ic-lmi0", .flags = CLK_IS_CRITICAL },
309 };
310 
311 static const struct clkgen_data clkgen_stih407_a0 = {
312 	.outputs = clkgen_stih407_a0_clk_out,
313 	.outputs_nb = ARRAY_SIZE(clkgen_stih407_a0_clk_out),
314 };
315 
316 static const struct clkgen_clk_out clkgen_stih410_a0_clk_out[] = {
317 	/* Those clks need to be on so that memory interface is accessible */
318 	{ .name = "clk-ic-lmi0", .flags = CLK_IS_CRITICAL },
319 	{ .name = "clk-ic-lmi1", .flags = CLK_IS_CRITICAL },
320 };
321 
322 static const struct clkgen_data clkgen_stih410_a0 = {
323 	.outputs = clkgen_stih410_a0_clk_out,
324 	.outputs_nb = ARRAY_SIZE(clkgen_stih410_a0_clk_out),
325 };
326 
327 static const struct clkgen_clk_out clkgen_stih407_c0_clk_out[] = {
328 	{ .name = "clk-icn-gpu", },
329 	{ .name = "clk-fdma", },
330 	{ .name = "clk-nand", },
331 	{ .name = "clk-hva", },
332 	{ .name = "clk-proc-stfe", },
333 	{ .name = "clk-proc-tp", },
334 	{ .name = "clk-rx-icn-dmu", },
335 	{ .name = "clk-rx-icn-hva", },
336 	/* This clk needs to be on to keep bus interconnect alive */
337 	{ .name = "clk-icn-cpu", .flags = CLK_IS_CRITICAL },
338 	/* This clk needs to be on to keep bus interconnect alive */
339 	{ .name = "clk-tx-icn-dmu", .flags = CLK_IS_CRITICAL },
340 	{ .name = "clk-mmc-0", },
341 	{ .name = "clk-mmc-1", },
342 	{ .name = "clk-jpegdec", },
343 	/* This clk needs to be on to keep A9 running */
344 	{ .name = "clk-ext2fa9", .flags = CLK_IS_CRITICAL },
345 	{ .name = "clk-ic-bdisp-0", },
346 	{ .name = "clk-ic-bdisp-1", },
347 	{ .name = "clk-pp-dmu", },
348 	{ .name = "clk-vid-dmu", },
349 	{ .name = "clk-dss-lpc", },
350 	{ .name = "clk-st231-aud-0", },
351 	{ .name = "clk-st231-gp-1", },
352 	{ .name = "clk-st231-dmu", },
353 	/* This clk needs to be on to keep bus interconnect alive */
354 	{ .name = "clk-icn-lmi", .flags = CLK_IS_CRITICAL },
355 	{ .name = "clk-tx-icn-disp-1", },
356 	/* This clk needs to be on to keep bus interconnect alive */
357 	{ .name = "clk-icn-sbc", .flags = CLK_IS_CRITICAL },
358 	{ .name = "clk-stfe-frc2", },
359 	{ .name = "clk-eth-phy", },
360 	{ .name = "clk-eth-ref-phyclk", },
361 	{ .name = "clk-flash-promip", },
362 	{ .name = "clk-main-disp", },
363 	{ .name = "clk-aux-disp", },
364 	{ .name = "clk-compo-dvp", },
365 };
366 
367 static const struct clkgen_data clkgen_stih407_c0 = {
368 	.outputs = clkgen_stih407_c0_clk_out,
369 	.outputs_nb = ARRAY_SIZE(clkgen_stih407_c0_clk_out),
370 };
371 
372 static const struct clkgen_clk_out clkgen_stih410_c0_clk_out[] = {
373 	{ .name = "clk-icn-gpu", },
374 	{ .name = "clk-fdma", },
375 	{ .name = "clk-nand", },
376 	{ .name = "clk-hva", },
377 	{ .name = "clk-proc-stfe", },
378 	{ .name = "clk-proc-tp", },
379 	{ .name = "clk-rx-icn-dmu", },
380 	{ .name = "clk-rx-icn-hva", },
381 	/* This clk needs to be on to keep bus interconnect alive */
382 	{ .name = "clk-icn-cpu", .flags = CLK_IS_CRITICAL },
383 	/* This clk needs to be on to keep bus interconnect alive */
384 	{ .name = "clk-tx-icn-dmu", .flags = CLK_IS_CRITICAL },
385 	{ .name = "clk-mmc-0", },
386 	{ .name = "clk-mmc-1", },
387 	{ .name = "clk-jpegdec", },
388 	/* This clk needs to be on to keep A9 running */
389 	{ .name = "clk-ext2fa9", .flags = CLK_IS_CRITICAL },
390 	{ .name = "clk-ic-bdisp-0", },
391 	{ .name = "clk-ic-bdisp-1", },
392 	{ .name = "clk-pp-dmu", },
393 	{ .name = "clk-vid-dmu", },
394 	{ .name = "clk-dss-lpc", },
395 	{ .name = "clk-st231-aud-0", },
396 	{ .name = "clk-st231-gp-1", },
397 	{ .name = "clk-st231-dmu", },
398 	/* This clk needs to be on to keep bus interconnect alive */
399 	{ .name = "clk-icn-lmi", .flags = CLK_IS_CRITICAL },
400 	{ .name = "clk-tx-icn-disp-1", },
401 	/* This clk needs to be on to keep bus interconnect alive */
402 	{ .name = "clk-icn-sbc", .flags = CLK_IS_CRITICAL },
403 	{ .name = "clk-stfe-frc2", },
404 	{ .name = "clk-eth-phy", },
405 	{ .name = "clk-eth-ref-phyclk", },
406 	{ .name = "clk-flash-promip", },
407 	{ .name = "clk-main-disp", },
408 	{ .name = "clk-aux-disp", },
409 	{ .name = "clk-compo-dvp", },
410 	{ .name = "clk-tx-icn-hades", },
411 	{ .name = "clk-rx-icn-hades", },
412 	/* This clk needs to be on to keep bus interconnect alive */
413 	{ .name = "clk-icn-reg-16", .flags = CLK_IS_CRITICAL },
414 	{ .name = "clk-pp-hades", },
415 	{ .name = "clk-clust-hades", },
416 	{ .name = "clk-hwpe-hades", },
417 	{ .name = "clk-fc-hades", },
418 };
419 
420 static const struct clkgen_data clkgen_stih410_c0 = {
421 	.outputs = clkgen_stih410_c0_clk_out,
422 	.outputs_nb = ARRAY_SIZE(clkgen_stih410_c0_clk_out),
423 };
424 
425 static const struct clkgen_clk_out clkgen_stih418_c0_clk_out[] = {
426 	{ .name = "clk-icn-gpu", },
427 	{ .name = "clk-fdma", },
428 	{ .name = "clk-nand", },
429 	{ .name = "clk-hva", },
430 	{ .name = "clk-proc-stfe", },
431 	{ .name = "clk-tp", },
432 	/* This clk needs to be on to keep bus interconnect alive */
433 	{ .name = "clk-rx-icn-dmu", .flags = CLK_IS_CRITICAL },
434 	/* This clk needs to be on to keep bus interconnect alive */
435 	{ .name = "clk-rx-icn-hva", .flags = CLK_IS_CRITICAL },
436 	{ .name = "clk-icn-cpu", .flags = CLK_IS_CRITICAL },
437 	/* This clk needs to be on to keep bus interconnect alive */
438 	{ .name = "clk-tx-icn-dmu", .flags = CLK_IS_CRITICAL },
439 	{ .name = "clk-mmc-0", },
440 	{ .name = "clk-mmc-1", },
441 	{ .name = "clk-jpegdec", },
442 	/* This clk needs to be on to keep bus interconnect alive */
443 	{ .name = "clk-icn-reg", .flags = CLK_IS_CRITICAL },
444 	{ .name = "clk-proc-bdisp-0", },
445 	{ .name = "clk-proc-bdisp-1", },
446 	{ .name = "clk-pp-dmu", },
447 	{ .name = "clk-vid-dmu", },
448 	{ .name = "clk-dss-lpc", },
449 	{ .name = "clk-st231-aud-0", },
450 	{ .name = "clk-st231-gp-1", },
451 	{ .name = "clk-st231-dmu", },
452 	/* This clk needs to be on to keep bus interconnect alive */
453 	{ .name = "clk-icn-lmi", .flags = CLK_IS_CRITICAL },
454 	/* This clk needs to be on to keep bus interconnect alive */
455 	{ .name = "clk-tx-icn-1", .flags = CLK_IS_CRITICAL },
456 	/* This clk needs to be on to keep bus interconnect alive */
457 	{ .name = "clk-icn-sbc", .flags = CLK_IS_CRITICAL },
458 	{ .name = "clk-stfe-frc2", },
459 	{ .name = "clk-eth-phyref", },
460 	{ .name = "clk-eth-ref-phyclk", },
461 	{ .name = "clk-flash-promip", },
462 	{ .name = "clk-main-disp", },
463 	{ .name = "clk-aux-disp", },
464 	{ .name = "clk-compo-dvp", },
465 	/* This clk needs to be on to keep bus interconnect alive */
466 	{ .name = "clk-tx-icn-hades", .flags = CLK_IS_CRITICAL },
467 	/* This clk needs to be on to keep bus interconnect alive */
468 	{ .name = "clk-rx-icn-hades", .flags = CLK_IS_CRITICAL },
469 	/* This clk needs to be on to keep bus interconnect alive */
470 	{ .name = "clk-icn-reg-16", .flags = CLK_IS_CRITICAL },
471 	{ .name = "clk-pp-hevc", },
472 	{ .name = "clk-clust-hevc", },
473 	{ .name = "clk-hwpe-hevc", },
474 	{ .name = "clk-fc-hevc", },
475 	{ .name = "clk-proc-mixer", },
476 	{ .name = "clk-proc-sc", },
477 	{ .name = "clk-avsp-hevc", },
478 };
479 
480 static const struct clkgen_data clkgen_stih418_c0 = {
481 	.outputs = clkgen_stih418_c0_clk_out,
482 	.outputs_nb = ARRAY_SIZE(clkgen_stih418_c0_clk_out),
483 };
484 
485 static const struct clkgen_clk_out clkgen_stih407_d0_clk_out[] = {
486 	{ .name = "clk-pcm-0", },
487 	{ .name = "clk-pcm-1", },
488 	{ .name = "clk-pcm-2", },
489 	{ .name = "clk-spdiff", },
490 };
491 
492 static const struct clkgen_data clkgen_stih407_d0 = {
493 	.flags = CLK_SET_RATE_PARENT,
494 	.outputs = clkgen_stih407_d0_clk_out,
495 	.outputs_nb = ARRAY_SIZE(clkgen_stih407_d0_clk_out),
496 };
497 
498 static const struct clkgen_clk_out clkgen_stih410_d0_clk_out[] = {
499 	{ .name = "clk-pcm-0", },
500 	{ .name = "clk-pcm-1", },
501 	{ .name = "clk-pcm-2", },
502 	{ .name = "clk-spdiff", },
503 	{ .name = "clk-pcmr10-master", },
504 	{ .name = "clk-usb2-phy", },
505 };
506 
507 static const struct clkgen_data clkgen_stih410_d0 = {
508 	.flags = CLK_SET_RATE_PARENT,
509 	.outputs = clkgen_stih410_d0_clk_out,
510 	.outputs_nb = ARRAY_SIZE(clkgen_stih410_d0_clk_out),
511 };
512 
513 static const struct clkgen_clk_out clkgen_stih407_d2_clk_out[] = {
514 	{ .name = "clk-pix-main-disp", },
515 	{ .name = "clk-pix-pip", },
516 	{ .name = "clk-pix-gdp1", },
517 	{ .name = "clk-pix-gdp2", },
518 	{ .name = "clk-pix-gdp3", },
519 	{ .name = "clk-pix-gdp4", },
520 	{ .name = "clk-pix-aux-disp", },
521 	{ .name = "clk-denc", },
522 	{ .name = "clk-pix-hddac", },
523 	{ .name = "clk-hddac", },
524 	{ .name = "clk-sddac", },
525 	{ .name = "clk-pix-dvo", },
526 	{ .name = "clk-dvo", },
527 	{ .name = "clk-pix-hdmi", },
528 	{ .name = "clk-tmds-hdmi", },
529 	{ .name = "clk-ref-hdmiphy", },
530 };
531 
532 static const struct clkgen_data clkgen_stih407_d2 = {
533 	.outputs = clkgen_stih407_d2_clk_out,
534 	.outputs_nb = ARRAY_SIZE(clkgen_stih407_d2_clk_out),
535 	.flags = CLK_SET_RATE_PARENT,
536 	.mode = 1,
537 };
538 
539 static const struct clkgen_clk_out clkgen_stih418_d2_clk_out[] = {
540 	{ .name = "clk-pix-main-disp", },
541 	{ .name = "", },
542 	{ .name = "", },
543 	{ .name = "", },
544 	{ .name = "", },
545 	{ .name = "clk-tmds-hdmi-div2", },
546 	{ .name = "clk-pix-aux-disp", },
547 	{ .name = "clk-denc", },
548 	{ .name = "clk-pix-hddac", },
549 	{ .name = "clk-hddac", },
550 	{ .name = "clk-sddac", },
551 	{ .name = "clk-pix-dvo", },
552 	{ .name = "clk-dvo", },
553 	{ .name = "clk-pix-hdmi", },
554 	{ .name = "clk-tmds-hdmi", },
555 	{ .name = "clk-ref-hdmiphy", },
556 	{ .name = "", }, { .name = "", }, { .name = "", }, { .name = "", },
557 	{ .name = "", }, { .name = "", }, { .name = "", }, { .name = "", },
558 	{ .name = "", }, { .name = "", }, { .name = "", }, { .name = "", },
559 	{ .name = "", }, { .name = "", }, { .name = "", }, { .name = "", },
560 	{ .name = "", }, { .name = "", }, { .name = "", }, { .name = "", },
561 	{ .name = "", }, { .name = "", }, { .name = "", }, { .name = "", },
562 	{ .name = "", }, { .name = "", }, { .name = "", }, { .name = "", },
563 	{ .name = "", }, { .name = "", }, { .name = "", },
564 	{ .name = "clk-vp9", },
565 };
566 
567 static const struct clkgen_data clkgen_stih418_d2 = {
568 	.outputs = clkgen_stih418_d2_clk_out,
569 	.outputs_nb = ARRAY_SIZE(clkgen_stih418_d2_clk_out),
570 	.flags = CLK_SET_RATE_PARENT,
571 	.mode = 1,
572 };
573 
574 static const struct clkgen_clk_out clkgen_stih407_d3_clk_out[] = {
575 	{ .name = "clk-stfe-frc1", },
576 	{ .name = "clk-tsout-0", },
577 	{ .name = "clk-tsout-1", },
578 	{ .name = "clk-mchi", },
579 	{ .name = "clk-vsens-compo", },
580 	{ .name = "clk-frc1-remote", },
581 	{ .name = "clk-lpc-0", },
582 	{ .name = "clk-lpc-1", },
583 };
584 
585 static const struct clkgen_data clkgen_stih407_d3 = {
586 	.outputs = clkgen_stih407_d3_clk_out,
587 	.outputs_nb = ARRAY_SIZE(clkgen_stih407_d3_clk_out),
588 };
589 
590 static const struct of_device_id flexgen_of_match[] = {
591 	{
592 		.compatible = "st,flexgen-audio",
593 		.data = &clkgen_audio,
594 	},
595 	{
596 		.compatible = "st,flexgen-video",
597 		.data = &clkgen_video,
598 	},
599 	{
600 		.compatible = "st,flexgen-stih407-a0",
601 		.data = &clkgen_stih407_a0,
602 	},
603 	{
604 		.compatible = "st,flexgen-stih410-a0",
605 		.data = &clkgen_stih410_a0,
606 	},
607 	{
608 		.compatible = "st,flexgen-stih407-c0",
609 		.data = &clkgen_stih407_c0,
610 	},
611 	{
612 		.compatible = "st,flexgen-stih410-c0",
613 		.data = &clkgen_stih410_c0,
614 	},
615 	{
616 		.compatible = "st,flexgen-stih418-c0",
617 		.data = &clkgen_stih418_c0,
618 	},
619 	{
620 		.compatible = "st,flexgen-stih407-d0",
621 		.data = &clkgen_stih407_d0,
622 	},
623 	{
624 		.compatible = "st,flexgen-stih410-d0",
625 		.data = &clkgen_stih410_d0,
626 	},
627 	{
628 		.compatible = "st,flexgen-stih407-d2",
629 		.data = &clkgen_stih407_d2,
630 	},
631 	{
632 		.compatible = "st,flexgen-stih418-d2",
633 		.data = &clkgen_stih418_d2,
634 	},
635 	{
636 		.compatible = "st,flexgen-stih407-d3",
637 		.data = &clkgen_stih407_d3,
638 	},
639 	{}
640 };
641 
st_of_flexgen_setup(struct device_node * np)642 static void __init st_of_flexgen_setup(struct device_node *np)
643 {
644 	struct device_node *pnode;
645 	void __iomem *reg;
646 	struct clk_onecell_data *clk_data;
647 	const char **parents;
648 	int num_parents, i;
649 	spinlock_t *rlock = NULL;
650 	const struct of_device_id *match;
651 	struct clkgen_data *data = NULL;
652 	unsigned long flex_flags = 0;
653 	int ret;
654 	bool clk_mode = 0;
655 	const char *clk_name;
656 
657 	pnode = of_get_parent(np);
658 	if (!pnode)
659 		return;
660 
661 	reg = of_iomap(pnode, 0);
662 	of_node_put(pnode);
663 	if (!reg)
664 		return;
665 
666 	parents = flexgen_get_parents(np, &num_parents);
667 	if (!parents) {
668 		iounmap(reg);
669 		return;
670 	}
671 
672 	match = of_match_node(flexgen_of_match, np);
673 	if (match) {
674 		data = (struct clkgen_data *)match->data;
675 		flex_flags = data->flags;
676 		clk_mode = data->mode;
677 	}
678 
679 	clk_data = kzalloc(sizeof(*clk_data), GFP_KERNEL);
680 	if (!clk_data)
681 		goto err;
682 
683 	/* First try to get output information from the compatible data */
684 	if (!data || !data->outputs_nb || !data->outputs) {
685 		ret = of_property_count_strings(np, "clock-output-names");
686 		if (ret <= 0) {
687 			pr_err("%s: Failed to get number of output clocks (%d)",
688 					__func__, clk_data->clk_num);
689 			goto err;
690 		}
691 		clk_data->clk_num = ret;
692 	} else
693 		clk_data->clk_num = data->outputs_nb;
694 
695 	clk_data->clks = kcalloc(clk_data->clk_num, sizeof(struct clk *),
696 			GFP_KERNEL);
697 	if (!clk_data->clks)
698 		goto err;
699 
700 	rlock = kzalloc(sizeof(spinlock_t), GFP_KERNEL);
701 	if (!rlock)
702 		goto err;
703 
704 	spin_lock_init(rlock);
705 
706 	for (i = 0; i < clk_data->clk_num; i++) {
707 		struct clk *clk;
708 
709 		if (!data || !data->outputs_nb || !data->outputs) {
710 			if (of_property_read_string_index(np,
711 							  "clock-output-names",
712 							  i, &clk_name))
713 				break;
714 			flex_flags &= ~CLK_IS_CRITICAL;
715 			of_clk_detect_critical(np, i, &flex_flags);
716 		} else {
717 			clk_name = data->outputs[i].name;
718 			flex_flags = data->flags | data->outputs[i].flags;
719 		}
720 
721 		/*
722 		 * If we read an empty clock name then the output is unused
723 		 */
724 		if (*clk_name == '\0')
725 			continue;
726 
727 		clk = clk_register_flexgen(clk_name, parents, num_parents,
728 					   reg, rlock, i, flex_flags, clk_mode);
729 
730 		if (IS_ERR(clk))
731 			goto err;
732 
733 		clk_data->clks[i] = clk;
734 	}
735 
736 	kfree(parents);
737 	of_clk_add_provider(np, of_clk_src_onecell_get, clk_data);
738 
739 	return;
740 
741 err:
742 	iounmap(reg);
743 	if (clk_data)
744 		kfree(clk_data->clks);
745 	kfree(clk_data);
746 	kfree(parents);
747 	kfree(rlock);
748 }
749 CLK_OF_DECLARE(flexgen, "st,flexgen", st_of_flexgen_setup);
750