1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * PLL clock driver for TI Davinci SoCs
4 *
5 * Copyright (C) 2018 David Lechner <david@lechnology.com>
6 *
7 * Based on arch/arm/mach-davinci/clock.c
8 * Copyright (C) 2006-2007 Texas Instruments.
9 * Copyright (C) 2008-2009 Deep Root Systems, LLC
10 */
11
12 #include <linux/clk-provider.h>
13 #include <linux/clk.h>
14 #include <linux/clk/davinci.h>
15 #include <linux/delay.h>
16 #include <linux/err.h>
17 #include <linux/io.h>
18 #include <linux/kernel.h>
19 #include <linux/mfd/syscon.h>
20 #include <linux/notifier.h>
21 #include <linux/of.h>
22 #include <linux/platform_data/clk-davinci-pll.h>
23 #include <linux/platform_device.h>
24 #include <linux/property.h>
25 #include <linux/regmap.h>
26 #include <linux/slab.h>
27 #include <linux/types.h>
28
29 #include "pll.h"
30
31 #define MAX_NAME_SIZE 20
32 #define OSCIN_CLK_NAME "oscin"
33
34 #define REVID 0x000
35 #define PLLCTL 0x100
36 #define OCSEL 0x104
37 #define PLLSECCTL 0x108
38 #define PLLM 0x110
39 #define PREDIV 0x114
40 #define PLLDIV1 0x118
41 #define PLLDIV2 0x11c
42 #define PLLDIV3 0x120
43 #define OSCDIV 0x124
44 #define POSTDIV 0x128
45 #define BPDIV 0x12c
46 #define PLLCMD 0x138
47 #define PLLSTAT 0x13c
48 #define ALNCTL 0x140
49 #define DCHANGE 0x144
50 #define CKEN 0x148
51 #define CKSTAT 0x14c
52 #define SYSTAT 0x150
53 #define PLLDIV4 0x160
54 #define PLLDIV5 0x164
55 #define PLLDIV6 0x168
56 #define PLLDIV7 0x16c
57 #define PLLDIV8 0x170
58 #define PLLDIV9 0x174
59
60 #define PLLCTL_PLLEN BIT(0)
61 #define PLLCTL_PLLPWRDN BIT(1)
62 #define PLLCTL_PLLRST BIT(3)
63 #define PLLCTL_PLLDIS BIT(4)
64 #define PLLCTL_PLLENSRC BIT(5)
65 #define PLLCTL_CLKMODE BIT(8)
66
67 /* shared by most *DIV registers */
68 #define DIV_RATIO_SHIFT 0
69 #define DIV_RATIO_WIDTH 5
70 #define DIV_ENABLE_SHIFT 15
71
72 #define PLLCMD_GOSET BIT(0)
73 #define PLLSTAT_GOSTAT BIT(0)
74
75 #define CKEN_OBSCLK_SHIFT 1
76 #define CKEN_AUXEN_SHIFT 0
77
78 /*
79 * OMAP-L138 system reference guide recommends a wait for 4 OSCIN/CLKIN
80 * cycles to ensure that the PLLC has switched to bypass mode. Delay of 1us
81 * ensures we are good for all > 4MHz OSCIN/CLKIN inputs. Typically the input
82 * is ~25MHz. Units are micro seconds.
83 */
84 #define PLL_BYPASS_TIME 1
85
86 /* From OMAP-L138 datasheet table 6-4. Units are micro seconds */
87 #define PLL_RESET_TIME 1
88
89 /*
90 * From OMAP-L138 datasheet table 6-4; assuming prediv = 1, sqrt(pllm) = 4
91 * Units are micro seconds.
92 */
93 #define PLL_LOCK_TIME 20
94
95 /**
96 * struct davinci_pll_clk - Main PLL clock (aka PLLOUT)
97 * @hw: clk_hw for the pll
98 * @base: Base memory address
99 * @pllm_min: The minimum allowable PLLM[PLLM] value
100 * @pllm_max: The maximum allowable PLLM[PLLM] value
101 * @pllm_mask: Bitmask for PLLM[PLLM] value
102 */
103 struct davinci_pll_clk {
104 struct clk_hw hw;
105 void __iomem *base;
106 u32 pllm_min;
107 u32 pllm_max;
108 u32 pllm_mask;
109 };
110
111 #define to_davinci_pll_clk(_hw) \
112 container_of((_hw), struct davinci_pll_clk, hw)
113
davinci_pll_recalc_rate(struct clk_hw * hw,unsigned long parent_rate)114 static unsigned long davinci_pll_recalc_rate(struct clk_hw *hw,
115 unsigned long parent_rate)
116 {
117 struct davinci_pll_clk *pll = to_davinci_pll_clk(hw);
118 unsigned long rate = parent_rate;
119 u32 mult;
120
121 mult = readl(pll->base + PLLM) & pll->pllm_mask;
122 rate *= mult + 1;
123
124 return rate;
125 }
126
davinci_pll_determine_rate(struct clk_hw * hw,struct clk_rate_request * req)127 static int davinci_pll_determine_rate(struct clk_hw *hw,
128 struct clk_rate_request *req)
129 {
130 struct davinci_pll_clk *pll = to_davinci_pll_clk(hw);
131 struct clk_hw *parent = req->best_parent_hw;
132 unsigned long parent_rate = req->best_parent_rate;
133 unsigned long rate = req->rate;
134 unsigned long best_rate, r;
135 u32 mult;
136
137 /* there is a limited range of valid outputs (see datasheet) */
138 if (rate < req->min_rate)
139 return -EINVAL;
140
141 rate = min(rate, req->max_rate);
142 mult = rate / parent_rate;
143 best_rate = parent_rate * mult;
144
145 /* easy case when there is no PREDIV */
146 if (!(clk_hw_get_flags(hw) & CLK_SET_RATE_PARENT)) {
147 if (best_rate < req->min_rate)
148 return -EINVAL;
149
150 if (mult < pll->pllm_min || mult > pll->pllm_max)
151 return -EINVAL;
152
153 req->rate = best_rate;
154
155 return 0;
156 }
157
158 /* see if the PREDIV clock can help us */
159 best_rate = 0;
160
161 for (mult = pll->pllm_min; mult <= pll->pllm_max; mult++) {
162 parent_rate = clk_hw_round_rate(parent, rate / mult);
163 r = parent_rate * mult;
164 if (r < req->min_rate)
165 continue;
166 if (r > rate || r > req->max_rate)
167 break;
168 if (r > best_rate) {
169 best_rate = r;
170 req->rate = best_rate;
171 req->best_parent_rate = parent_rate;
172 if (best_rate == rate)
173 break;
174 }
175 }
176
177 return 0;
178 }
179
davinci_pll_set_rate(struct clk_hw * hw,unsigned long rate,unsigned long parent_rate)180 static int davinci_pll_set_rate(struct clk_hw *hw, unsigned long rate,
181 unsigned long parent_rate)
182 {
183 struct davinci_pll_clk *pll = to_davinci_pll_clk(hw);
184 u32 mult;
185
186 mult = rate / parent_rate;
187 writel(mult - 1, pll->base + PLLM);
188
189 return 0;
190 }
191
192 #ifdef CONFIG_DEBUG_FS
193 static void davinci_pll_debug_init(struct clk_hw *hw, struct dentry *dentry);
194 #else
195 #define davinci_pll_debug_init NULL
196 #endif
197
198 static const struct clk_ops davinci_pll_ops = {
199 .recalc_rate = davinci_pll_recalc_rate,
200 .determine_rate = davinci_pll_determine_rate,
201 .set_rate = davinci_pll_set_rate,
202 .debug_init = davinci_pll_debug_init,
203 };
204
205 /* PLLM works differently on DM365 */
dm365_pll_recalc_rate(struct clk_hw * hw,unsigned long parent_rate)206 static unsigned long dm365_pll_recalc_rate(struct clk_hw *hw,
207 unsigned long parent_rate)
208 {
209 struct davinci_pll_clk *pll = to_davinci_pll_clk(hw);
210 unsigned long rate = parent_rate;
211 u32 mult;
212
213 mult = readl(pll->base + PLLM) & pll->pllm_mask;
214 rate *= mult * 2;
215
216 return rate;
217 }
218
219 static const struct clk_ops dm365_pll_ops = {
220 .recalc_rate = dm365_pll_recalc_rate,
221 .debug_init = davinci_pll_debug_init,
222 };
223
224 /**
225 * davinci_pll_div_register - common *DIV clock implementation
226 * @dev: The PLL platform device or NULL
227 * @name: the clock name
228 * @parent_name: the parent clock name
229 * @reg: the *DIV register
230 * @fixed: if true, the divider is a fixed value
231 * @flags: bitmap of CLK_* flags from clock-provider.h
232 */
davinci_pll_div_register(struct device * dev,const char * name,const char * parent_name,void __iomem * reg,bool fixed,u32 flags)233 static struct clk *davinci_pll_div_register(struct device *dev,
234 const char *name,
235 const char *parent_name,
236 void __iomem *reg,
237 bool fixed, u32 flags)
238 {
239 const char * const *parent_names = parent_name ? &parent_name : NULL;
240 int num_parents = parent_name ? 1 : 0;
241 const struct clk_ops *divider_ops = &clk_divider_ops;
242 struct clk_gate *gate;
243 struct clk_divider *divider;
244 struct clk *clk;
245 int ret;
246
247 gate = kzalloc(sizeof(*gate), GFP_KERNEL);
248 if (!gate)
249 return ERR_PTR(-ENOMEM);
250
251 gate->reg = reg;
252 gate->bit_idx = DIV_ENABLE_SHIFT;
253
254 divider = kzalloc(sizeof(*divider), GFP_KERNEL);
255 if (!divider) {
256 ret = -ENOMEM;
257 goto err_free_gate;
258 }
259
260 divider->reg = reg;
261 divider->shift = DIV_RATIO_SHIFT;
262 divider->width = DIV_RATIO_WIDTH;
263
264 if (fixed) {
265 divider->flags |= CLK_DIVIDER_READ_ONLY;
266 divider_ops = &clk_divider_ro_ops;
267 }
268
269 clk = clk_register_composite(dev, name, parent_names, num_parents,
270 NULL, NULL, ÷r->hw, divider_ops,
271 &gate->hw, &clk_gate_ops, flags);
272 if (IS_ERR(clk)) {
273 ret = PTR_ERR(clk);
274 goto err_free_divider;
275 }
276
277 return clk;
278
279 err_free_divider:
280 kfree(divider);
281 err_free_gate:
282 kfree(gate);
283
284 return ERR_PTR(ret);
285 }
286
287 struct davinci_pllen_clk {
288 struct clk_hw hw;
289 void __iomem *base;
290 };
291
292 #define to_davinci_pllen_clk(_hw) \
293 container_of((_hw), struct davinci_pllen_clk, hw)
294
295 static const struct clk_ops davinci_pllen_ops = {
296 /* this clocks just uses the clock notification feature */
297 };
298
299 /*
300 * The PLL has to be switched into bypass mode while we are chaning the rate,
301 * so we do that on the PLLEN clock since it is the end of the line. This will
302 * switch to bypass before any of the parent clocks (PREDIV, PLL, POSTDIV) are
303 * changed and will switch back to the PLL after the changes have been made.
304 */
davinci_pllen_rate_change(struct notifier_block * nb,unsigned long flags,void * data)305 static int davinci_pllen_rate_change(struct notifier_block *nb,
306 unsigned long flags, void *data)
307 {
308 struct clk_notifier_data *cnd = data;
309 struct clk_hw *hw = __clk_get_hw(cnd->clk);
310 struct davinci_pllen_clk *pll = to_davinci_pllen_clk(hw);
311 u32 ctrl;
312
313 ctrl = readl(pll->base + PLLCTL);
314
315 if (flags == PRE_RATE_CHANGE) {
316 /* Switch the PLL to bypass mode */
317 ctrl &= ~(PLLCTL_PLLENSRC | PLLCTL_PLLEN);
318 writel(ctrl, pll->base + PLLCTL);
319
320 udelay(PLL_BYPASS_TIME);
321
322 /* Reset and enable PLL */
323 ctrl &= ~(PLLCTL_PLLRST | PLLCTL_PLLDIS);
324 writel(ctrl, pll->base + PLLCTL);
325 } else {
326 udelay(PLL_RESET_TIME);
327
328 /* Bring PLL out of reset */
329 ctrl |= PLLCTL_PLLRST;
330 writel(ctrl, pll->base + PLLCTL);
331
332 udelay(PLL_LOCK_TIME);
333
334 /* Remove PLL from bypass mode */
335 ctrl |= PLLCTL_PLLEN;
336 writel(ctrl, pll->base + PLLCTL);
337 }
338
339 return NOTIFY_OK;
340 }
341
342 static struct notifier_block davinci_pllen_notifier = {
343 .notifier_call = davinci_pllen_rate_change,
344 };
345
346 /**
347 * davinci_pll_clk_register - Register a PLL clock
348 * @dev: The PLL platform device or NULL
349 * @info: The device-specific clock info
350 * @parent_name: The parent clock name
351 * @base: The PLL's memory region
352 * @cfgchip: CFGCHIP syscon regmap for info->unlock_reg or NULL
353 *
354 * This creates a series of clocks that represent the PLL.
355 *
356 * OSCIN > [PREDIV >] PLL > [POSTDIV >] PLLEN
357 *
358 * - OSCIN is the parent clock (on secondary PLL, may come from primary PLL)
359 * - PREDIV and POSTDIV are optional (depends on the PLL controller)
360 * - PLL is the PLL output (aka PLLOUT)
361 * - PLLEN is the bypass multiplexer
362 *
363 * Returns: The PLLOUT clock or a negative error code.
364 */
davinci_pll_clk_register(struct device * dev,const struct davinci_pll_clk_info * info,const char * parent_name,void __iomem * base,struct regmap * cfgchip)365 struct clk *davinci_pll_clk_register(struct device *dev,
366 const struct davinci_pll_clk_info *info,
367 const char *parent_name,
368 void __iomem *base,
369 struct regmap *cfgchip)
370 {
371 char prediv_name[MAX_NAME_SIZE];
372 char pllout_name[MAX_NAME_SIZE];
373 char postdiv_name[MAX_NAME_SIZE];
374 char pllen_name[MAX_NAME_SIZE];
375 struct clk_init_data init;
376 struct davinci_pll_clk *pllout;
377 struct davinci_pllen_clk *pllen;
378 struct clk *oscin_clk = NULL;
379 struct clk *prediv_clk = NULL;
380 struct clk *pllout_clk;
381 struct clk *postdiv_clk = NULL;
382 struct clk *pllen_clk;
383 int ret;
384
385 if (info->flags & PLL_HAS_CLKMODE) {
386 /*
387 * If a PLL has PLLCTL[CLKMODE], then it is the primary PLL.
388 * We register a clock named "oscin" that serves as the internal
389 * "input clock" domain shared by both PLLs (if there are 2)
390 * and will be the parent clock to the AUXCLK, SYSCLKBP and
391 * OBSCLK domains. NB: The various TRMs use "OSCIN" to mean
392 * a number of different things. In this driver we use it to
393 * mean the signal after the PLLCTL[CLKMODE] switch.
394 */
395 oscin_clk = clk_register_fixed_factor(dev, OSCIN_CLK_NAME,
396 parent_name, 0, 1, 1);
397 if (IS_ERR(oscin_clk))
398 return oscin_clk;
399
400 parent_name = OSCIN_CLK_NAME;
401 }
402
403 if (info->flags & PLL_HAS_PREDIV) {
404 bool fixed = info->flags & PLL_PREDIV_FIXED_DIV;
405 u32 flags = 0;
406
407 snprintf(prediv_name, MAX_NAME_SIZE, "%s_prediv", info->name);
408
409 if (info->flags & PLL_PREDIV_ALWAYS_ENABLED)
410 flags |= CLK_IS_CRITICAL;
411
412 /* Some? DM355 chips don't correctly report the PREDIV value */
413 if (info->flags & PLL_PREDIV_FIXED8)
414 prediv_clk = clk_register_fixed_factor(dev, prediv_name,
415 parent_name, flags, 1, 8);
416 else
417 prediv_clk = davinci_pll_div_register(dev, prediv_name,
418 parent_name, base + PREDIV, fixed, flags);
419 if (IS_ERR(prediv_clk)) {
420 ret = PTR_ERR(prediv_clk);
421 goto err_unregister_oscin;
422 }
423
424 parent_name = prediv_name;
425 }
426
427 /* Unlock writing to PLL registers */
428 if (info->unlock_reg) {
429 if (IS_ERR_OR_NULL(cfgchip))
430 dev_warn(dev, "Failed to get CFGCHIP (%ld)\n",
431 PTR_ERR(cfgchip));
432 else
433 regmap_write_bits(cfgchip, info->unlock_reg,
434 info->unlock_mask, 0);
435 }
436
437 pllout = kzalloc(sizeof(*pllout), GFP_KERNEL);
438 if (!pllout) {
439 ret = -ENOMEM;
440 goto err_unregister_prediv;
441 }
442
443 snprintf(pllout_name, MAX_NAME_SIZE, "%s_pllout", info->name);
444
445 init.name = pllout_name;
446 if (info->flags & PLL_PLLM_2X)
447 init.ops = &dm365_pll_ops;
448 else
449 init.ops = &davinci_pll_ops;
450 init.parent_names = &parent_name;
451 init.num_parents = 1;
452 init.flags = 0;
453
454 if (info->flags & PLL_HAS_PREDIV)
455 init.flags |= CLK_SET_RATE_PARENT;
456
457 pllout->hw.init = &init;
458 pllout->base = base;
459 pllout->pllm_mask = info->pllm_mask;
460 pllout->pllm_min = info->pllm_min;
461 pllout->pllm_max = info->pllm_max;
462
463 pllout_clk = clk_register(dev, &pllout->hw);
464 if (IS_ERR(pllout_clk)) {
465 ret = PTR_ERR(pllout_clk);
466 goto err_free_pllout;
467 }
468
469 clk_hw_set_rate_range(&pllout->hw, info->pllout_min_rate,
470 info->pllout_max_rate);
471
472 parent_name = pllout_name;
473
474 if (info->flags & PLL_HAS_POSTDIV) {
475 bool fixed = info->flags & PLL_POSTDIV_FIXED_DIV;
476 u32 flags = CLK_SET_RATE_PARENT;
477
478 snprintf(postdiv_name, MAX_NAME_SIZE, "%s_postdiv", info->name);
479
480 if (info->flags & PLL_POSTDIV_ALWAYS_ENABLED)
481 flags |= CLK_IS_CRITICAL;
482
483 postdiv_clk = davinci_pll_div_register(dev, postdiv_name,
484 parent_name, base + POSTDIV, fixed, flags);
485 if (IS_ERR(postdiv_clk)) {
486 ret = PTR_ERR(postdiv_clk);
487 goto err_unregister_pllout;
488 }
489
490 parent_name = postdiv_name;
491 }
492
493 pllen = kzalloc(sizeof(*pllen), GFP_KERNEL);
494 if (!pllen) {
495 ret = -ENOMEM;
496 goto err_unregister_postdiv;
497 }
498
499 snprintf(pllen_name, MAX_NAME_SIZE, "%s_pllen", info->name);
500
501 init.name = pllen_name;
502 init.ops = &davinci_pllen_ops;
503 init.parent_names = &parent_name;
504 init.num_parents = 1;
505 init.flags = CLK_SET_RATE_PARENT;
506
507 pllen->hw.init = &init;
508 pllen->base = base;
509
510 pllen_clk = clk_register(dev, &pllen->hw);
511 if (IS_ERR(pllen_clk)) {
512 ret = PTR_ERR(pllen_clk);
513 goto err_free_pllen;
514 }
515
516 clk_notifier_register(pllen_clk, &davinci_pllen_notifier);
517
518 return pllout_clk;
519
520 err_free_pllen:
521 kfree(pllen);
522 err_unregister_postdiv:
523 clk_unregister(postdiv_clk);
524 err_unregister_pllout:
525 clk_unregister(pllout_clk);
526 err_free_pllout:
527 kfree(pllout);
528 err_unregister_prediv:
529 clk_unregister(prediv_clk);
530 err_unregister_oscin:
531 clk_unregister(oscin_clk);
532
533 return ERR_PTR(ret);
534 }
535
536 /**
537 * davinci_pll_auxclk_register - Register bypass clock (AUXCLK)
538 * @dev: The PLL platform device or NULL
539 * @name: The clock name
540 * @base: The PLL memory region
541 */
davinci_pll_auxclk_register(struct device * dev,const char * name,void __iomem * base)542 struct clk *davinci_pll_auxclk_register(struct device *dev,
543 const char *name,
544 void __iomem *base)
545 {
546 return clk_register_gate(dev, name, OSCIN_CLK_NAME, 0, base + CKEN,
547 CKEN_AUXEN_SHIFT, 0, NULL);
548 }
549
550 /**
551 * davinci_pll_sysclkbp_clk_register - Register bypass divider clock (SYSCLKBP)
552 * @dev: The PLL platform device or NULL
553 * @name: The clock name
554 * @base: The PLL memory region
555 */
davinci_pll_sysclkbp_clk_register(struct device * dev,const char * name,void __iomem * base)556 struct clk *davinci_pll_sysclkbp_clk_register(struct device *dev,
557 const char *name,
558 void __iomem *base)
559 {
560 return clk_register_divider(dev, name, OSCIN_CLK_NAME, 0, base + BPDIV,
561 DIV_RATIO_SHIFT, DIV_RATIO_WIDTH,
562 CLK_DIVIDER_READ_ONLY, NULL);
563 }
564
565 /**
566 * davinci_pll_obsclk_register - Register oscillator divider clock (OBSCLK)
567 * @dev: The PLL platform device or NULL
568 * @info: The clock info
569 * @base: The PLL memory region
570 */
571 struct clk *
davinci_pll_obsclk_register(struct device * dev,const struct davinci_pll_obsclk_info * info,void __iomem * base)572 davinci_pll_obsclk_register(struct device *dev,
573 const struct davinci_pll_obsclk_info *info,
574 void __iomem *base)
575 {
576 struct clk_mux *mux;
577 struct clk_gate *gate;
578 struct clk_divider *divider;
579 struct clk *clk;
580 u32 oscdiv;
581 int ret;
582
583 mux = kzalloc(sizeof(*mux), GFP_KERNEL);
584 if (!mux)
585 return ERR_PTR(-ENOMEM);
586
587 mux->reg = base + OCSEL;
588 mux->table = info->table;
589 mux->mask = info->ocsrc_mask;
590
591 gate = kzalloc(sizeof(*gate), GFP_KERNEL);
592 if (!gate) {
593 ret = -ENOMEM;
594 goto err_free_mux;
595 }
596
597 gate->reg = base + CKEN;
598 gate->bit_idx = CKEN_OBSCLK_SHIFT;
599
600 divider = kzalloc(sizeof(*divider), GFP_KERNEL);
601 if (!divider) {
602 ret = -ENOMEM;
603 goto err_free_gate;
604 }
605
606 divider->reg = base + OSCDIV;
607 divider->shift = DIV_RATIO_SHIFT;
608 divider->width = DIV_RATIO_WIDTH;
609
610 /* make sure divider is enabled just in case bootloader disabled it */
611 oscdiv = readl(base + OSCDIV);
612 oscdiv |= BIT(DIV_ENABLE_SHIFT);
613 writel(oscdiv, base + OSCDIV);
614
615 clk = clk_register_composite(dev, info->name, info->parent_names,
616 info->num_parents,
617 &mux->hw, &clk_mux_ops,
618 ÷r->hw, &clk_divider_ops,
619 &gate->hw, &clk_gate_ops, 0);
620
621 if (IS_ERR(clk)) {
622 ret = PTR_ERR(clk);
623 goto err_free_divider;
624 }
625
626 return clk;
627
628 err_free_divider:
629 kfree(divider);
630 err_free_gate:
631 kfree(gate);
632 err_free_mux:
633 kfree(mux);
634
635 return ERR_PTR(ret);
636 }
637
638 /* The PLL SYSCLKn clocks have a mechanism for synchronizing rate changes. */
davinci_pll_sysclk_rate_change(struct notifier_block * nb,unsigned long flags,void * data)639 static int davinci_pll_sysclk_rate_change(struct notifier_block *nb,
640 unsigned long flags, void *data)
641 {
642 struct clk_notifier_data *cnd = data;
643 struct clk_hw *hw = __clk_get_hw(clk_get_parent(cnd->clk));
644 struct davinci_pllen_clk *pll = to_davinci_pllen_clk(hw);
645 u32 pllcmd, pllstat;
646
647 switch (flags) {
648 case POST_RATE_CHANGE:
649 /* apply the changes */
650 pllcmd = readl(pll->base + PLLCMD);
651 pllcmd |= PLLCMD_GOSET;
652 writel(pllcmd, pll->base + PLLCMD);
653 fallthrough;
654 case PRE_RATE_CHANGE:
655 /* Wait until for outstanding changes to take effect */
656 do {
657 pllstat = readl(pll->base + PLLSTAT);
658 } while (pllstat & PLLSTAT_GOSTAT);
659 break;
660 }
661
662 return NOTIFY_OK;
663 }
664
665 static struct notifier_block davinci_pll_sysclk_notifier = {
666 .notifier_call = davinci_pll_sysclk_rate_change,
667 };
668
669 /**
670 * davinci_pll_sysclk_register - Register divider clocks (SYSCLKn)
671 * @dev: The PLL platform device or NULL
672 * @info: The clock info
673 * @base: The PLL memory region
674 */
675 struct clk *
davinci_pll_sysclk_register(struct device * dev,const struct davinci_pll_sysclk_info * info,void __iomem * base)676 davinci_pll_sysclk_register(struct device *dev,
677 const struct davinci_pll_sysclk_info *info,
678 void __iomem *base)
679 {
680 const struct clk_ops *divider_ops = &clk_divider_ops;
681 struct clk_gate *gate;
682 struct clk_divider *divider;
683 struct clk *clk;
684 u32 reg;
685 u32 flags = 0;
686 int ret;
687
688 /* PLLDIVn registers are not entirely consecutive */
689 if (info->id < 4)
690 reg = PLLDIV1 + 4 * (info->id - 1);
691 else
692 reg = PLLDIV4 + 4 * (info->id - 4);
693
694 gate = kzalloc(sizeof(*gate), GFP_KERNEL);
695 if (!gate)
696 return ERR_PTR(-ENOMEM);
697
698 gate->reg = base + reg;
699 gate->bit_idx = DIV_ENABLE_SHIFT;
700
701 divider = kzalloc(sizeof(*divider), GFP_KERNEL);
702 if (!divider) {
703 ret = -ENOMEM;
704 goto err_free_gate;
705 }
706
707 divider->reg = base + reg;
708 divider->shift = DIV_RATIO_SHIFT;
709 divider->width = info->ratio_width;
710 divider->flags = 0;
711
712 if (info->flags & SYSCLK_FIXED_DIV) {
713 divider->flags |= CLK_DIVIDER_READ_ONLY;
714 divider_ops = &clk_divider_ro_ops;
715 }
716
717 /* Only the ARM clock can change the parent PLL rate */
718 if (info->flags & SYSCLK_ARM_RATE)
719 flags |= CLK_SET_RATE_PARENT;
720
721 if (info->flags & SYSCLK_ALWAYS_ENABLED)
722 flags |= CLK_IS_CRITICAL;
723
724 clk = clk_register_composite(dev, info->name, &info->parent_name, 1,
725 NULL, NULL, ÷r->hw, divider_ops,
726 &gate->hw, &clk_gate_ops, flags);
727 if (IS_ERR(clk)) {
728 ret = PTR_ERR(clk);
729 goto err_free_divider;
730 }
731
732 clk_notifier_register(clk, &davinci_pll_sysclk_notifier);
733
734 return clk;
735
736 err_free_divider:
737 kfree(divider);
738 err_free_gate:
739 kfree(gate);
740
741 return ERR_PTR(ret);
742 }
743
of_davinci_pll_init(struct device * dev,struct device_node * node,const struct davinci_pll_clk_info * info,const struct davinci_pll_obsclk_info * obsclk_info,const struct davinci_pll_sysclk_info ** div_info,u8 max_sysclk_id,void __iomem * base,struct regmap * cfgchip)744 int of_davinci_pll_init(struct device *dev, struct device_node *node,
745 const struct davinci_pll_clk_info *info,
746 const struct davinci_pll_obsclk_info *obsclk_info,
747 const struct davinci_pll_sysclk_info **div_info,
748 u8 max_sysclk_id,
749 void __iomem *base,
750 struct regmap *cfgchip)
751 {
752 struct device_node *child;
753 const char *parent_name;
754 struct clk *clk;
755
756 if (info->flags & PLL_HAS_CLKMODE)
757 parent_name = of_clk_get_parent_name(node, 0);
758 else
759 parent_name = OSCIN_CLK_NAME;
760
761 clk = davinci_pll_clk_register(dev, info, parent_name, base, cfgchip);
762 if (IS_ERR(clk)) {
763 dev_err(dev, "failed to register %s\n", info->name);
764 return PTR_ERR(clk);
765 }
766
767 child = of_get_child_by_name(node, "pllout");
768 if (of_device_is_available(child))
769 of_clk_add_provider(child, of_clk_src_simple_get, clk);
770 of_node_put(child);
771
772 child = of_get_child_by_name(node, "sysclk");
773 if (of_device_is_available(child)) {
774 struct clk_onecell_data *clk_data;
775 struct clk **clks;
776 int n_clks = max_sysclk_id + 1;
777 int i;
778
779 clk_data = kzalloc(sizeof(*clk_data), GFP_KERNEL);
780 if (!clk_data) {
781 of_node_put(child);
782 return -ENOMEM;
783 }
784
785 clks = kmalloc_array(n_clks, sizeof(*clks), GFP_KERNEL);
786 if (!clks) {
787 kfree(clk_data);
788 of_node_put(child);
789 return -ENOMEM;
790 }
791
792 clk_data->clks = clks;
793 clk_data->clk_num = n_clks;
794
795 for (i = 0; i < n_clks; i++)
796 clks[i] = ERR_PTR(-ENOENT);
797
798 for (; *div_info; div_info++) {
799 clk = davinci_pll_sysclk_register(dev, *div_info, base);
800 if (IS_ERR(clk))
801 dev_warn(dev, "failed to register %s (%ld)\n",
802 (*div_info)->name, PTR_ERR(clk));
803 else
804 clks[(*div_info)->id] = clk;
805 }
806 of_clk_add_provider(child, of_clk_src_onecell_get, clk_data);
807 }
808 of_node_put(child);
809
810 child = of_get_child_by_name(node, "auxclk");
811 if (of_device_is_available(child)) {
812 char child_name[MAX_NAME_SIZE];
813
814 snprintf(child_name, MAX_NAME_SIZE, "%s_auxclk", info->name);
815
816 clk = davinci_pll_auxclk_register(dev, child_name, base);
817 if (IS_ERR(clk))
818 dev_warn(dev, "failed to register %s (%ld)\n",
819 child_name, PTR_ERR(clk));
820 else
821 of_clk_add_provider(child, of_clk_src_simple_get, clk);
822 }
823 of_node_put(child);
824
825 child = of_get_child_by_name(node, "obsclk");
826 if (of_device_is_available(child)) {
827 if (obsclk_info)
828 clk = davinci_pll_obsclk_register(dev, obsclk_info, base);
829 else
830 clk = ERR_PTR(-EINVAL);
831
832 if (IS_ERR(clk))
833 dev_warn(dev, "failed to register obsclk (%ld)\n",
834 PTR_ERR(clk));
835 else
836 of_clk_add_provider(child, of_clk_src_simple_get, clk);
837 }
838 of_node_put(child);
839
840 return 0;
841 }
842
davinci_pll_get_pdata(struct device * dev)843 static struct davinci_pll_platform_data *davinci_pll_get_pdata(struct device *dev)
844 {
845 struct davinci_pll_platform_data *pdata = dev_get_platdata(dev);
846
847 /*
848 * Platform data is optional, so allocate a new struct if one was not
849 * provided. For device tree, this will always be the case.
850 */
851 if (!pdata)
852 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
853 if (!pdata)
854 return NULL;
855
856 /* for device tree, we need to fill in the struct */
857 if (dev->of_node)
858 pdata->cfgchip =
859 syscon_regmap_lookup_by_compatible("ti,da830-cfgchip");
860
861 return pdata;
862 }
863
864 /* needed in early boot for clocksource/clockevent */
865 #ifdef CONFIG_ARCH_DAVINCI_DA850
866 CLK_OF_DECLARE(da850_pll0, "ti,da850-pll0", of_da850_pll0_init);
867 #endif
868
869 static const struct of_device_id davinci_pll_of_match[] = {
870 #ifdef CONFIG_ARCH_DAVINCI_DA850
871 { .compatible = "ti,da850-pll1", .data = of_da850_pll1_init },
872 #endif
873 { }
874 };
875
876 static const struct platform_device_id davinci_pll_id_table[] = {
877 #ifdef CONFIG_ARCH_DAVINCI_DA830
878 { .name = "da830-pll", .driver_data = (kernel_ulong_t)da830_pll_init },
879 #endif
880 #ifdef CONFIG_ARCH_DAVINCI_DA850
881 { .name = "da850-pll0", .driver_data = (kernel_ulong_t)da850_pll0_init },
882 { .name = "da850-pll1", .driver_data = (kernel_ulong_t)da850_pll1_init },
883 #endif
884 { }
885 };
886
887 typedef int (*davinci_pll_init)(struct device *dev, void __iomem *base,
888 struct regmap *cfgchip);
889
davinci_pll_probe(struct platform_device * pdev)890 static int davinci_pll_probe(struct platform_device *pdev)
891 {
892 struct device *dev = &pdev->dev;
893 struct davinci_pll_platform_data *pdata;
894 davinci_pll_init pll_init = NULL;
895 void __iomem *base;
896
897 pll_init = device_get_match_data(dev);
898 if (!pll_init && pdev->id_entry)
899 pll_init = (void *)pdev->id_entry->driver_data;
900
901 if (!pll_init) {
902 dev_err(dev, "unable to find driver data\n");
903 return -EINVAL;
904 }
905
906 pdata = davinci_pll_get_pdata(dev);
907 if (!pdata) {
908 dev_err(dev, "missing platform data\n");
909 return -EINVAL;
910 }
911
912 base = devm_platform_ioremap_resource(pdev, 0);
913 if (IS_ERR(base))
914 return PTR_ERR(base);
915
916 return pll_init(dev, base, pdata->cfgchip);
917 }
918
919 static struct platform_driver davinci_pll_driver = {
920 .probe = davinci_pll_probe,
921 .driver = {
922 .name = "davinci-pll-clk",
923 .of_match_table = davinci_pll_of_match,
924 },
925 .id_table = davinci_pll_id_table,
926 };
927
davinci_pll_driver_init(void)928 static int __init davinci_pll_driver_init(void)
929 {
930 return platform_driver_register(&davinci_pll_driver);
931 }
932
933 /* has to be postcore_initcall because PSC devices depend on PLL parent clocks */
934 postcore_initcall(davinci_pll_driver_init);
935
936 #ifdef CONFIG_DEBUG_FS
937 #include <linux/debugfs.h>
938
939 #define DEBUG_REG(n) \
940 { \
941 .name = #n, \
942 .offset = n, \
943 }
944
945 static const struct debugfs_reg32 davinci_pll_regs[] = {
946 DEBUG_REG(REVID),
947 DEBUG_REG(PLLCTL),
948 DEBUG_REG(OCSEL),
949 DEBUG_REG(PLLSECCTL),
950 DEBUG_REG(PLLM),
951 DEBUG_REG(PREDIV),
952 DEBUG_REG(PLLDIV1),
953 DEBUG_REG(PLLDIV2),
954 DEBUG_REG(PLLDIV3),
955 DEBUG_REG(OSCDIV),
956 DEBUG_REG(POSTDIV),
957 DEBUG_REG(BPDIV),
958 DEBUG_REG(PLLCMD),
959 DEBUG_REG(PLLSTAT),
960 DEBUG_REG(ALNCTL),
961 DEBUG_REG(DCHANGE),
962 DEBUG_REG(CKEN),
963 DEBUG_REG(CKSTAT),
964 DEBUG_REG(SYSTAT),
965 DEBUG_REG(PLLDIV4),
966 DEBUG_REG(PLLDIV5),
967 DEBUG_REG(PLLDIV6),
968 DEBUG_REG(PLLDIV7),
969 DEBUG_REG(PLLDIV8),
970 DEBUG_REG(PLLDIV9),
971 };
972
davinci_pll_debug_init(struct clk_hw * hw,struct dentry * dentry)973 static void davinci_pll_debug_init(struct clk_hw *hw, struct dentry *dentry)
974 {
975 struct davinci_pll_clk *pll = to_davinci_pll_clk(hw);
976 struct debugfs_regset32 *regset;
977
978 regset = kzalloc(sizeof(*regset), GFP_KERNEL);
979 if (!regset)
980 return;
981
982 regset->regs = davinci_pll_regs;
983 regset->nregs = ARRAY_SIZE(davinci_pll_regs);
984 regset->base = pll->base;
985
986 debugfs_create_regset32("registers", 0400, dentry, regset);
987 }
988 #endif
989