1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Clock driver for DA8xx/AM17xx/AM18xx/OMAP-L13x CFGCHIP
4  *
5  * Copyright (C) 2018 David Lechner <david@lechnology.com>
6  */
7 
8 #include <linux/clk-provider.h>
9 #include <linux/clk.h>
10 #include <linux/clkdev.h>
11 #include <linux/init.h>
12 #include <linux/mfd/da8xx-cfgchip.h>
13 #include <linux/mfd/syscon.h>
14 #include <linux/of_device.h>
15 #include <linux/of.h>
16 #include <linux/platform_data/clk-da8xx-cfgchip.h>
17 #include <linux/platform_device.h>
18 #include <linux/regmap.h>
19 #include <linux/slab.h>
20 
21 /* --- Gate clocks --- */
22 
23 #define DA8XX_GATE_CLOCK_IS_DIV4P5	BIT(1)
24 
25 struct da8xx_cfgchip_gate_clk_info {
26 	const char *name;
27 	u32 cfgchip;
28 	u32 bit;
29 	u32 flags;
30 };
31 
32 struct da8xx_cfgchip_gate_clk {
33 	struct clk_hw hw;
34 	struct regmap *regmap;
35 	u32 reg;
36 	u32 mask;
37 };
38 
39 #define to_da8xx_cfgchip_gate_clk(_hw) \
40 	container_of((_hw), struct da8xx_cfgchip_gate_clk, hw)
41 
42 static int da8xx_cfgchip_gate_clk_enable(struct clk_hw *hw)
43 {
44 	struct da8xx_cfgchip_gate_clk *clk = to_da8xx_cfgchip_gate_clk(hw);
45 
46 	return regmap_write_bits(clk->regmap, clk->reg, clk->mask, clk->mask);
47 }
48 
49 static void da8xx_cfgchip_gate_clk_disable(struct clk_hw *hw)
50 {
51 	struct da8xx_cfgchip_gate_clk *clk = to_da8xx_cfgchip_gate_clk(hw);
52 
53 	regmap_write_bits(clk->regmap, clk->reg, clk->mask, 0);
54 }
55 
56 static int da8xx_cfgchip_gate_clk_is_enabled(struct clk_hw *hw)
57 {
58 	struct da8xx_cfgchip_gate_clk *clk = to_da8xx_cfgchip_gate_clk(hw);
59 	unsigned int val;
60 
61 	regmap_read(clk->regmap, clk->reg, &val);
62 
63 	return !!(val & clk->mask);
64 }
65 
66 static unsigned long da8xx_cfgchip_div4p5_recalc_rate(struct clk_hw *hw,
67 						      unsigned long parent_rate)
68 {
69 	/* this clock divides by 4.5 */
70 	return parent_rate * 2 / 9;
71 }
72 
73 static const struct clk_ops da8xx_cfgchip_gate_clk_ops = {
74 	.enable		= da8xx_cfgchip_gate_clk_enable,
75 	.disable	= da8xx_cfgchip_gate_clk_disable,
76 	.is_enabled	= da8xx_cfgchip_gate_clk_is_enabled,
77 };
78 
79 static const struct clk_ops da8xx_cfgchip_div4p5_clk_ops = {
80 	.enable		= da8xx_cfgchip_gate_clk_enable,
81 	.disable	= da8xx_cfgchip_gate_clk_disable,
82 	.is_enabled	= da8xx_cfgchip_gate_clk_is_enabled,
83 	.recalc_rate	= da8xx_cfgchip_div4p5_recalc_rate,
84 };
85 
86 static struct da8xx_cfgchip_gate_clk * __init
87 da8xx_cfgchip_gate_clk_register(struct device *dev,
88 				const struct da8xx_cfgchip_gate_clk_info *info,
89 				struct regmap *regmap)
90 {
91 	struct clk *parent;
92 	const char *parent_name;
93 	struct da8xx_cfgchip_gate_clk *gate;
94 	struct clk_init_data init;
95 	int ret;
96 
97 	parent = devm_clk_get(dev, NULL);
98 	if (IS_ERR(parent))
99 		return ERR_CAST(parent);
100 
101 	parent_name = __clk_get_name(parent);
102 
103 	gate = devm_kzalloc(dev, sizeof(*gate), GFP_KERNEL);
104 	if (!gate)
105 		return ERR_PTR(-ENOMEM);
106 
107 	init.name = info->name;
108 	if (info->flags & DA8XX_GATE_CLOCK_IS_DIV4P5)
109 		init.ops = &da8xx_cfgchip_div4p5_clk_ops;
110 	else
111 		init.ops = &da8xx_cfgchip_gate_clk_ops;
112 	init.parent_names = &parent_name;
113 	init.num_parents = 1;
114 	init.flags = 0;
115 
116 	gate->hw.init = &init;
117 	gate->regmap = regmap;
118 	gate->reg = info->cfgchip;
119 	gate->mask = info->bit;
120 
121 	ret = devm_clk_hw_register(dev, &gate->hw);
122 	if (ret < 0)
123 		return ERR_PTR(ret);
124 
125 	return gate;
126 }
127 
128 static const struct da8xx_cfgchip_gate_clk_info da8xx_tbclksync_info __initconst = {
129 	.name = "ehrpwm_tbclk",
130 	.cfgchip = CFGCHIP(1),
131 	.bit = CFGCHIP1_TBCLKSYNC,
132 };
133 
134 static int __init da8xx_cfgchip_register_tbclk(struct device *dev,
135 					       struct regmap *regmap)
136 {
137 	struct da8xx_cfgchip_gate_clk *gate;
138 
139 	gate = da8xx_cfgchip_gate_clk_register(dev, &da8xx_tbclksync_info,
140 					       regmap);
141 	if (IS_ERR(gate))
142 		return PTR_ERR(gate);
143 
144 	clk_hw_register_clkdev(&gate->hw, "tbclk", "ehrpwm.0");
145 	clk_hw_register_clkdev(&gate->hw, "tbclk", "ehrpwm.1");
146 
147 	return 0;
148 }
149 
150 static const struct da8xx_cfgchip_gate_clk_info da8xx_div4p5ena_info __initconst = {
151 	.name = "div4.5",
152 	.cfgchip = CFGCHIP(3),
153 	.bit = CFGCHIP3_DIV45PENA,
154 	.flags = DA8XX_GATE_CLOCK_IS_DIV4P5,
155 };
156 
157 static int __init da8xx_cfgchip_register_div4p5(struct device *dev,
158 						struct regmap *regmap)
159 {
160 	struct da8xx_cfgchip_gate_clk *gate;
161 
162 	gate = da8xx_cfgchip_gate_clk_register(dev, &da8xx_div4p5ena_info, regmap);
163 
164 	return PTR_ERR_OR_ZERO(gate);
165 }
166 
167 static int __init
168 of_da8xx_cfgchip_gate_clk_init(struct device *dev,
169 			       const struct da8xx_cfgchip_gate_clk_info *info,
170 			       struct regmap *regmap)
171 {
172 	struct da8xx_cfgchip_gate_clk *gate;
173 
174 	gate = da8xx_cfgchip_gate_clk_register(dev, info, regmap);
175 	if (IS_ERR(gate))
176 		return PTR_ERR(gate);
177 
178 	return devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get, gate);
179 }
180 
181 static int __init of_da8xx_tbclksync_init(struct device *dev,
182 					  struct regmap *regmap)
183 {
184 	return of_da8xx_cfgchip_gate_clk_init(dev, &da8xx_tbclksync_info, regmap);
185 }
186 
187 static int __init of_da8xx_div4p5ena_init(struct device *dev,
188 					  struct regmap *regmap)
189 {
190 	return of_da8xx_cfgchip_gate_clk_init(dev, &da8xx_div4p5ena_info, regmap);
191 }
192 
193 /* --- MUX clocks --- */
194 
195 struct da8xx_cfgchip_mux_clk_info {
196 	const char *name;
197 	const char *parent0;
198 	const char *parent1;
199 	u32 cfgchip;
200 	u32 bit;
201 };
202 
203 struct da8xx_cfgchip_mux_clk {
204 	struct clk_hw hw;
205 	struct regmap *regmap;
206 	u32 reg;
207 	u32 mask;
208 };
209 
210 #define to_da8xx_cfgchip_mux_clk(_hw) \
211 	container_of((_hw), struct da8xx_cfgchip_mux_clk, hw)
212 
213 static int da8xx_cfgchip_mux_clk_set_parent(struct clk_hw *hw, u8 index)
214 {
215 	struct da8xx_cfgchip_mux_clk *clk = to_da8xx_cfgchip_mux_clk(hw);
216 	unsigned int val = index ? clk->mask : 0;
217 
218 	return regmap_write_bits(clk->regmap, clk->reg, clk->mask, val);
219 }
220 
221 static u8 da8xx_cfgchip_mux_clk_get_parent(struct clk_hw *hw)
222 {
223 	struct da8xx_cfgchip_mux_clk *clk = to_da8xx_cfgchip_mux_clk(hw);
224 	unsigned int val;
225 
226 	regmap_read(clk->regmap, clk->reg, &val);
227 
228 	return (val & clk->mask) ? 1 : 0;
229 }
230 
231 static const struct clk_ops da8xx_cfgchip_mux_clk_ops = {
232 	.set_parent	= da8xx_cfgchip_mux_clk_set_parent,
233 	.get_parent	= da8xx_cfgchip_mux_clk_get_parent,
234 };
235 
236 static struct da8xx_cfgchip_mux_clk * __init
237 da8xx_cfgchip_mux_clk_register(struct device *dev,
238 			       const struct da8xx_cfgchip_mux_clk_info *info,
239 			       struct regmap *regmap)
240 {
241 	const char * const parent_names[] = { info->parent0, info->parent1 };
242 	struct da8xx_cfgchip_mux_clk *mux;
243 	struct clk_init_data init;
244 	int ret;
245 
246 	mux = devm_kzalloc(dev, sizeof(*mux), GFP_KERNEL);
247 	if (!mux)
248 		return ERR_PTR(-ENOMEM);
249 
250 	init.name = info->name;
251 	init.ops = &da8xx_cfgchip_mux_clk_ops;
252 	init.parent_names = parent_names;
253 	init.num_parents = 2;
254 	init.flags = 0;
255 
256 	mux->hw.init = &init;
257 	mux->regmap = regmap;
258 	mux->reg = info->cfgchip;
259 	mux->mask = info->bit;
260 
261 	ret = devm_clk_hw_register(dev, &mux->hw);
262 	if (ret < 0)
263 		return ERR_PTR(ret);
264 
265 	return mux;
266 }
267 
268 static const struct da8xx_cfgchip_mux_clk_info da850_async1_info __initconst = {
269 	.name = "async1",
270 	.parent0 = "pll0_sysclk3",
271 	.parent1 = "div4.5",
272 	.cfgchip = CFGCHIP(3),
273 	.bit = CFGCHIP3_EMA_CLKSRC,
274 };
275 
276 static int __init da8xx_cfgchip_register_async1(struct device *dev,
277 						struct regmap *regmap)
278 {
279 	struct da8xx_cfgchip_mux_clk *mux;
280 
281 	mux = da8xx_cfgchip_mux_clk_register(dev, &da850_async1_info, regmap);
282 	if (IS_ERR(mux))
283 		return PTR_ERR(mux);
284 
285 	clk_hw_register_clkdev(&mux->hw, "async1", "da850-psc0");
286 
287 	return 0;
288 }
289 
290 static const struct da8xx_cfgchip_mux_clk_info da850_async3_info __initconst = {
291 	.name = "async3",
292 	.parent0 = "pll0_sysclk2",
293 	.parent1 = "pll1_sysclk2",
294 	.cfgchip = CFGCHIP(3),
295 	.bit = CFGCHIP3_ASYNC3_CLKSRC,
296 };
297 
298 static int __init da850_cfgchip_register_async3(struct device *dev,
299 						struct regmap *regmap)
300 {
301 	struct da8xx_cfgchip_mux_clk *mux;
302 	struct clk_hw *parent;
303 
304 	mux = da8xx_cfgchip_mux_clk_register(dev, &da850_async3_info, regmap);
305 	if (IS_ERR(mux))
306 		return PTR_ERR(mux);
307 
308 	clk_hw_register_clkdev(&mux->hw, "async3", "da850-psc1");
309 
310 	/* pll1_sysclk2 is not affected by CPU scaling, so use it for async3 */
311 	parent = clk_hw_get_parent_by_index(&mux->hw, 1);
312 	if (parent)
313 		clk_set_parent(mux->hw.clk, parent->clk);
314 	else
315 		dev_warn(dev, "Failed to find async3 parent clock\n");
316 
317 	return 0;
318 }
319 
320 static int __init
321 of_da8xx_cfgchip_init_mux_clock(struct device *dev,
322 				const struct da8xx_cfgchip_mux_clk_info *info,
323 				struct regmap *regmap)
324 {
325 	struct da8xx_cfgchip_mux_clk *mux;
326 
327 	mux = da8xx_cfgchip_mux_clk_register(dev, info, regmap);
328 	if (IS_ERR(mux))
329 		return PTR_ERR(mux);
330 
331 	return devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get, &mux->hw);
332 }
333 
334 static int __init of_da850_async1_init(struct device *dev, struct regmap *regmap)
335 {
336 	return of_da8xx_cfgchip_init_mux_clock(dev, &da850_async1_info, regmap);
337 }
338 
339 static int __init of_da850_async3_init(struct device *dev, struct regmap *regmap)
340 {
341 	return of_da8xx_cfgchip_init_mux_clock(dev, &da850_async3_info, regmap);
342 }
343 
344 /* --- USB 2.0 PHY clock --- */
345 
346 struct da8xx_usb0_clk48 {
347 	struct clk_hw hw;
348 	struct clk *fck;
349 	struct regmap *regmap;
350 };
351 
352 #define to_da8xx_usb0_clk48(_hw) \
353 	container_of((_hw), struct da8xx_usb0_clk48, hw)
354 
355 static int da8xx_usb0_clk48_prepare(struct clk_hw *hw)
356 {
357 	struct da8xx_usb0_clk48 *usb0 = to_da8xx_usb0_clk48(hw);
358 
359 	/* The USB 2.0 PSC clock is only needed temporarily during the USB 2.0
360 	 * PHY clock enable, but since clk_prepare() can't be called in an
361 	 * atomic context (i.e. in clk_enable()), we have to prepare it here.
362 	 */
363 	return clk_prepare(usb0->fck);
364 }
365 
366 static void da8xx_usb0_clk48_unprepare(struct clk_hw *hw)
367 {
368 	struct da8xx_usb0_clk48 *usb0 = to_da8xx_usb0_clk48(hw);
369 
370 	clk_unprepare(usb0->fck);
371 }
372 
373 static int da8xx_usb0_clk48_enable(struct clk_hw *hw)
374 {
375 	struct da8xx_usb0_clk48 *usb0 = to_da8xx_usb0_clk48(hw);
376 	unsigned int mask, val;
377 	int ret;
378 
379 	/* Locking the USB 2.O PLL requires that the USB 2.O PSC is enabled
380 	 * temporaily. It can be turned back off once the PLL is locked.
381 	 */
382 	clk_enable(usb0->fck);
383 
384 	/* Turn on the USB 2.0 PHY, but just the PLL, and not OTG. The USB 1.1
385 	 * PHY may use the USB 2.0 PLL clock without USB 2.0 OTG being used.
386 	 */
387 	mask = CFGCHIP2_RESET | CFGCHIP2_PHYPWRDN | CFGCHIP2_PHY_PLLON;
388 	val = CFGCHIP2_PHY_PLLON;
389 
390 	regmap_write_bits(usb0->regmap, CFGCHIP(2), mask, val);
391 	ret = regmap_read_poll_timeout(usb0->regmap, CFGCHIP(2), val,
392 				       val & CFGCHIP2_PHYCLKGD, 0, 500000);
393 
394 	clk_disable(usb0->fck);
395 
396 	return ret;
397 }
398 
399 static void da8xx_usb0_clk48_disable(struct clk_hw *hw)
400 {
401 	struct da8xx_usb0_clk48 *usb0 = to_da8xx_usb0_clk48(hw);
402 	unsigned int val;
403 
404 	val = CFGCHIP2_PHYPWRDN;
405 	regmap_write_bits(usb0->regmap, CFGCHIP(2), val, val);
406 }
407 
408 static int da8xx_usb0_clk48_is_enabled(struct clk_hw *hw)
409 {
410 	struct da8xx_usb0_clk48 *usb0 = to_da8xx_usb0_clk48(hw);
411 	unsigned int val;
412 
413 	regmap_read(usb0->regmap, CFGCHIP(2), &val);
414 
415 	return !!(val & CFGCHIP2_PHYCLKGD);
416 }
417 
418 static unsigned long da8xx_usb0_clk48_recalc_rate(struct clk_hw *hw,
419 						  unsigned long parent_rate)
420 {
421 	struct da8xx_usb0_clk48 *usb0 = to_da8xx_usb0_clk48(hw);
422 	unsigned int mask, val;
423 
424 	/* The parent clock rate must be one of the following */
425 	mask = CFGCHIP2_REFFREQ_MASK;
426 	switch (parent_rate) {
427 	case 12000000:
428 		val = CFGCHIP2_REFFREQ_12MHZ;
429 		break;
430 	case 13000000:
431 		val = CFGCHIP2_REFFREQ_13MHZ;
432 		break;
433 	case 19200000:
434 		val = CFGCHIP2_REFFREQ_19_2MHZ;
435 		break;
436 	case 20000000:
437 		val = CFGCHIP2_REFFREQ_20MHZ;
438 		break;
439 	case 24000000:
440 		val = CFGCHIP2_REFFREQ_24MHZ;
441 		break;
442 	case 26000000:
443 		val = CFGCHIP2_REFFREQ_26MHZ;
444 		break;
445 	case 38400000:
446 		val = CFGCHIP2_REFFREQ_38_4MHZ;
447 		break;
448 	case 40000000:
449 		val = CFGCHIP2_REFFREQ_40MHZ;
450 		break;
451 	case 48000000:
452 		val = CFGCHIP2_REFFREQ_48MHZ;
453 		break;
454 	default:
455 		return 0;
456 	}
457 
458 	regmap_write_bits(usb0->regmap, CFGCHIP(2), mask, val);
459 
460 	/* USB 2.0 PLL always supplies 48MHz */
461 	return 48000000;
462 }
463 
464 static long da8xx_usb0_clk48_round_rate(struct clk_hw *hw, unsigned long rate,
465 					unsigned long *parent_rate)
466 {
467 	return 48000000;
468 }
469 
470 static int da8xx_usb0_clk48_set_parent(struct clk_hw *hw, u8 index)
471 {
472 	struct da8xx_usb0_clk48 *usb0 = to_da8xx_usb0_clk48(hw);
473 
474 	return regmap_write_bits(usb0->regmap, CFGCHIP(2),
475 				 CFGCHIP2_USB2PHYCLKMUX,
476 				 index ? CFGCHIP2_USB2PHYCLKMUX : 0);
477 }
478 
479 static u8 da8xx_usb0_clk48_get_parent(struct clk_hw *hw)
480 {
481 	struct da8xx_usb0_clk48 *usb0 = to_da8xx_usb0_clk48(hw);
482 	unsigned int val;
483 
484 	regmap_read(usb0->regmap, CFGCHIP(2), &val);
485 
486 	return (val & CFGCHIP2_USB2PHYCLKMUX) ? 1 : 0;
487 }
488 
489 static const struct clk_ops da8xx_usb0_clk48_ops = {
490 	.prepare	= da8xx_usb0_clk48_prepare,
491 	.unprepare	= da8xx_usb0_clk48_unprepare,
492 	.enable		= da8xx_usb0_clk48_enable,
493 	.disable	= da8xx_usb0_clk48_disable,
494 	.is_enabled	= da8xx_usb0_clk48_is_enabled,
495 	.recalc_rate	= da8xx_usb0_clk48_recalc_rate,
496 	.round_rate	= da8xx_usb0_clk48_round_rate,
497 	.set_parent	= da8xx_usb0_clk48_set_parent,
498 	.get_parent	= da8xx_usb0_clk48_get_parent,
499 };
500 
501 static struct da8xx_usb0_clk48 *
502 da8xx_cfgchip_register_usb0_clk48(struct device *dev,
503 				  struct regmap *regmap)
504 {
505 	const char * const parent_names[] = { "usb_refclkin", "pll0_auxclk" };
506 	struct clk *fck_clk;
507 	struct da8xx_usb0_clk48 *usb0;
508 	struct clk_init_data init;
509 	int ret;
510 
511 	fck_clk = devm_clk_get(dev, "fck");
512 	if (IS_ERR(fck_clk)) {
513 		dev_err_probe(dev, PTR_ERR(fck_clk), "Missing fck clock\n");
514 		return ERR_CAST(fck_clk);
515 	}
516 
517 	usb0 = devm_kzalloc(dev, sizeof(*usb0), GFP_KERNEL);
518 	if (!usb0)
519 		return ERR_PTR(-ENOMEM);
520 
521 	init.name = "usb0_clk48";
522 	init.ops = &da8xx_usb0_clk48_ops;
523 	init.parent_names = parent_names;
524 	init.num_parents = 2;
525 
526 	usb0->hw.init = &init;
527 	usb0->fck = fck_clk;
528 	usb0->regmap = regmap;
529 
530 	ret = devm_clk_hw_register(dev, &usb0->hw);
531 	if (ret < 0)
532 		return ERR_PTR(ret);
533 
534 	return usb0;
535 }
536 
537 /* --- USB 1.1 PHY clock --- */
538 
539 struct da8xx_usb1_clk48 {
540 	struct clk_hw hw;
541 	struct regmap *regmap;
542 };
543 
544 #define to_da8xx_usb1_clk48(_hw) \
545 	container_of((_hw), struct da8xx_usb1_clk48, hw)
546 
547 static int da8xx_usb1_clk48_set_parent(struct clk_hw *hw, u8 index)
548 {
549 	struct da8xx_usb1_clk48 *usb1 = to_da8xx_usb1_clk48(hw);
550 
551 	return regmap_write_bits(usb1->regmap, CFGCHIP(2),
552 				 CFGCHIP2_USB1PHYCLKMUX,
553 				 index ? CFGCHIP2_USB1PHYCLKMUX : 0);
554 }
555 
556 static u8 da8xx_usb1_clk48_get_parent(struct clk_hw *hw)
557 {
558 	struct da8xx_usb1_clk48 *usb1 = to_da8xx_usb1_clk48(hw);
559 	unsigned int val;
560 
561 	regmap_read(usb1->regmap, CFGCHIP(2), &val);
562 
563 	return (val & CFGCHIP2_USB1PHYCLKMUX) ? 1 : 0;
564 }
565 
566 static const struct clk_ops da8xx_usb1_clk48_ops = {
567 	.set_parent	= da8xx_usb1_clk48_set_parent,
568 	.get_parent	= da8xx_usb1_clk48_get_parent,
569 };
570 
571 /**
572  * da8xx_cfgchip_register_usb1_clk48 - Register a new USB 1.1 PHY clock
573  * @dev: The device
574  * @regmap: The CFGCHIP regmap
575  */
576 static struct da8xx_usb1_clk48 *
577 da8xx_cfgchip_register_usb1_clk48(struct device *dev,
578 				  struct regmap *regmap)
579 {
580 	const char * const parent_names[] = { "usb0_clk48", "usb_refclkin" };
581 	struct da8xx_usb1_clk48 *usb1;
582 	struct clk_init_data init;
583 	int ret;
584 
585 	usb1 = devm_kzalloc(dev, sizeof(*usb1), GFP_KERNEL);
586 	if (!usb1)
587 		return ERR_PTR(-ENOMEM);
588 
589 	init.name = "usb1_clk48";
590 	init.ops = &da8xx_usb1_clk48_ops;
591 	init.parent_names = parent_names;
592 	init.num_parents = 2;
593 
594 	usb1->hw.init = &init;
595 	usb1->regmap = regmap;
596 
597 	ret = devm_clk_hw_register(dev, &usb1->hw);
598 	if (ret < 0)
599 		return ERR_PTR(ret);
600 
601 	return usb1;
602 }
603 
604 static int da8xx_cfgchip_register_usb_phy_clk(struct device *dev,
605 					      struct regmap *regmap)
606 {
607 	struct da8xx_usb0_clk48 *usb0;
608 	struct da8xx_usb1_clk48 *usb1;
609 	struct clk_hw *parent;
610 
611 	usb0 = da8xx_cfgchip_register_usb0_clk48(dev, regmap);
612 	if (IS_ERR(usb0))
613 		return PTR_ERR(usb0);
614 
615 	/*
616 	 * All existing boards use pll0_auxclk as the parent and new boards
617 	 * should use device tree, so hard-coding the value (1) here.
618 	 */
619 	parent = clk_hw_get_parent_by_index(&usb0->hw, 1);
620 	if (parent)
621 		clk_set_parent(usb0->hw.clk, parent->clk);
622 	else
623 		dev_warn(dev, "Failed to find usb0 parent clock\n");
624 
625 	usb1 = da8xx_cfgchip_register_usb1_clk48(dev, regmap);
626 	if (IS_ERR(usb1))
627 		return PTR_ERR(usb1);
628 
629 	/*
630 	 * All existing boards use usb0_clk48 as the parent and new boards
631 	 * should use device tree, so hard-coding the value (0) here.
632 	 */
633 	parent = clk_hw_get_parent_by_index(&usb1->hw, 0);
634 	if (parent)
635 		clk_set_parent(usb1->hw.clk, parent->clk);
636 	else
637 		dev_warn(dev, "Failed to find usb1 parent clock\n");
638 
639 	clk_hw_register_clkdev(&usb0->hw, "usb0_clk48", "da8xx-usb-phy");
640 	clk_hw_register_clkdev(&usb1->hw, "usb1_clk48", "da8xx-usb-phy");
641 
642 	return 0;
643 }
644 
645 static int of_da8xx_usb_phy_clk_init(struct device *dev, struct regmap *regmap)
646 {
647 	struct clk_hw_onecell_data *clk_data;
648 	struct da8xx_usb0_clk48 *usb0;
649 	struct da8xx_usb1_clk48 *usb1;
650 
651 	clk_data = devm_kzalloc(dev, struct_size(clk_data, hws, 2),
652 				GFP_KERNEL);
653 	if (!clk_data)
654 		return -ENOMEM;
655 
656 	clk_data->num = 2;
657 
658 	usb0 = da8xx_cfgchip_register_usb0_clk48(dev, regmap);
659 	if (IS_ERR(usb0)) {
660 		if (PTR_ERR(usb0) == -EPROBE_DEFER)
661 			return -EPROBE_DEFER;
662 
663 		dev_warn(dev, "Failed to register usb0_clk48 (%ld)\n",
664 			 PTR_ERR(usb0));
665 
666 		clk_data->hws[0] = ERR_PTR(-ENOENT);
667 	} else {
668 		clk_data->hws[0] = &usb0->hw;
669 	}
670 
671 	usb1 = da8xx_cfgchip_register_usb1_clk48(dev, regmap);
672 	if (IS_ERR(usb1)) {
673 		if (PTR_ERR(usb1) == -EPROBE_DEFER)
674 			return -EPROBE_DEFER;
675 
676 		dev_warn(dev, "Failed to register usb1_clk48 (%ld)\n",
677 			 PTR_ERR(usb1));
678 
679 		clk_data->hws[1] = ERR_PTR(-ENOENT);
680 	} else {
681 		clk_data->hws[1] = &usb1->hw;
682 	}
683 
684 	return devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get, clk_data);
685 }
686 
687 /* --- platform device --- */
688 
689 static const struct of_device_id da8xx_cfgchip_of_match[] = {
690 	{
691 		.compatible = "ti,da830-tbclksync",
692 		.data = of_da8xx_tbclksync_init,
693 	},
694 	{
695 		.compatible = "ti,da830-div4p5ena",
696 		.data = of_da8xx_div4p5ena_init,
697 	},
698 	{
699 		.compatible = "ti,da850-async1-clksrc",
700 		.data = of_da850_async1_init,
701 	},
702 	{
703 		.compatible = "ti,da850-async3-clksrc",
704 		.data = of_da850_async3_init,
705 	},
706 	{
707 		.compatible = "ti,da830-usb-phy-clocks",
708 		.data = of_da8xx_usb_phy_clk_init,
709 	},
710 	{ }
711 };
712 
713 static const struct platform_device_id da8xx_cfgchip_id_table[] = {
714 	{
715 		.name = "da830-tbclksync",
716 		.driver_data = (kernel_ulong_t)da8xx_cfgchip_register_tbclk,
717 	},
718 	{
719 		.name = "da830-div4p5ena",
720 		.driver_data = (kernel_ulong_t)da8xx_cfgchip_register_div4p5,
721 	},
722 	{
723 		.name = "da850-async1-clksrc",
724 		.driver_data = (kernel_ulong_t)da8xx_cfgchip_register_async1,
725 	},
726 	{
727 		.name = "da850-async3-clksrc",
728 		.driver_data = (kernel_ulong_t)da850_cfgchip_register_async3,
729 	},
730 	{
731 		.name = "da830-usb-phy-clks",
732 		.driver_data = (kernel_ulong_t)da8xx_cfgchip_register_usb_phy_clk,
733 	},
734 	{ }
735 };
736 
737 typedef int (*da8xx_cfgchip_init)(struct device *dev, struct regmap *regmap);
738 
739 static int da8xx_cfgchip_probe(struct platform_device *pdev)
740 {
741 	struct device *dev = &pdev->dev;
742 	struct da8xx_cfgchip_clk_platform_data *pdata = dev->platform_data;
743 	const struct of_device_id *of_id;
744 	da8xx_cfgchip_init clk_init = NULL;
745 	struct regmap *regmap = NULL;
746 
747 	of_id = of_match_device(da8xx_cfgchip_of_match, dev);
748 	if (of_id) {
749 		struct device_node *parent;
750 
751 		clk_init = of_id->data;
752 		parent = of_get_parent(dev->of_node);
753 		regmap = syscon_node_to_regmap(parent);
754 		of_node_put(parent);
755 	} else if (pdev->id_entry && pdata) {
756 		clk_init = (void *)pdev->id_entry->driver_data;
757 		regmap = pdata->cfgchip;
758 	}
759 
760 	if (!clk_init) {
761 		dev_err(dev, "unable to find driver data\n");
762 		return -EINVAL;
763 	}
764 
765 	if (IS_ERR_OR_NULL(regmap)) {
766 		dev_err(dev, "no regmap for CFGCHIP syscon\n");
767 		return regmap ? PTR_ERR(regmap) : -ENOENT;
768 	}
769 
770 	return clk_init(dev, regmap);
771 }
772 
773 static struct platform_driver da8xx_cfgchip_driver = {
774 	.probe		= da8xx_cfgchip_probe,
775 	.driver		= {
776 		.name		= "da8xx-cfgchip-clk",
777 		.of_match_table	= da8xx_cfgchip_of_match,
778 	},
779 	.id_table	= da8xx_cfgchip_id_table,
780 };
781 
782 static int __init da8xx_cfgchip_driver_init(void)
783 {
784 	return platform_driver_register(&da8xx_cfgchip_driver);
785 }
786 
787 /* has to be postcore_initcall because PSC devices depend on the async3 clock */
788 postcore_initcall(da8xx_cfgchip_driver_init);
789