1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2018 Emmanuel Vadot <manu@freebsd.org>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/bus.h>
32
33 #include <dev/extres/clk/clk.h>
34
35 #include <arm64/rockchip/clk/rk_clk_pll.h>
36
37 #include "clkdev_if.h"
38
39 struct rk_clk_pll_sc {
40 uint32_t base_offset;
41
42 uint32_t gate_offset;
43 uint32_t gate_shift;
44
45 uint32_t mode_reg;
46 uint32_t mode_shift;
47
48 uint32_t flags;
49
50 struct rk_clk_pll_rate *rates;
51 struct rk_clk_pll_rate *frac_rates;
52 };
53
54 #define WRITE4(_clk, off, val) \
55 CLKDEV_WRITE_4(clknode_get_device(_clk), off, val)
56 #define READ4(_clk, off, val) \
57 CLKDEV_READ_4(clknode_get_device(_clk), off, val)
58 #define DEVICE_LOCK(_clk) \
59 CLKDEV_DEVICE_LOCK(clknode_get_device(_clk))
60 #define DEVICE_UNLOCK(_clk) \
61 CLKDEV_DEVICE_UNLOCK(clknode_get_device(_clk))
62
63 #define RK_CLK_PLL_MASK_SHIFT 16
64
65 #if 0
66 #define dprintf(format, arg...) \
67 printf("%s:(%s)" format, __func__, clknode_get_name(clk), arg)
68 #else
69 #define dprintf(format, arg...)
70 #endif
71
72 static int
rk_clk_pll_set_gate(struct clknode * clk,bool enable)73 rk_clk_pll_set_gate(struct clknode *clk, bool enable)
74 {
75 struct rk_clk_pll_sc *sc;
76 uint32_t val = 0;
77
78 sc = clknode_get_softc(clk);
79
80 if ((sc->flags & RK_CLK_PLL_HAVE_GATE) == 0)
81 return (0);
82
83 dprintf("%sabling gate\n", enable ? "En" : "Dis");
84 if (!enable)
85 val |= 1 << sc->gate_shift;
86 dprintf("sc->gate_shift: %x\n", sc->gate_shift);
87 val |= (1 << sc->gate_shift) << RK_CLK_PLL_MASK_SHIFT;
88 dprintf("Write: gate_offset=%x, val=%x\n", sc->gate_offset, val);
89 DEVICE_LOCK(clk);
90 WRITE4(clk, sc->gate_offset, val);
91 DEVICE_UNLOCK(clk);
92
93 return (0);
94 }
95
96 /* CON0 */
97 #define RK3066_CLK_PLL_REFDIV_SHIFT 8
98 #define RK3066_CLK_PLL_REFDIV_MASK 0x3F00
99 #define RK3066_CLK_PLL_POSTDIV_SHIFT 0
100 #define RK3066_CLK_PLL_POSTDIV_MASK 0x000F
101 /* CON1 */
102 #define RK3066_CLK_PLL_LOCK_MASK (1U << 31)
103 #define RK3066_CLK_PLL_FBDIV_SHIFT 0
104 #define RK3066_CLK_PLL_FBDIV_MASK 0x0FFF
105 /* CON2 */
106
107 /* CON3 */
108 #define RK3066_CLK_PLL_RESET (1 << 5)
109 #define RK3066_CLK_PLL_TEST (1 << 4)
110 #define RK3066_CLK_PLL_ENSAT (1 << 3)
111 #define RK3066_CLK_PLL_FASTEN (1 << 2)
112 #define RK3066_CLK_PLL_POWER_DOWN (1 << 1)
113 #define RK3066_CLK_PLL_BYPASS (1 << 0)
114
115 #define RK3066_CLK_PLL_MODE_SLOW 0
116 #define RK3066_CLK_PLL_MODE_NORMAL 1
117 #define RK3066_CLK_PLL_MODE_DEEP_SLOW 2
118 #define RK3066_CLK_PLL_MODE_MASK 0x3
119
120 static int
rk3066_clk_pll_init(struct clknode * clk,device_t dev)121 rk3066_clk_pll_init(struct clknode *clk, device_t dev)
122 {
123 struct rk_clk_pll_sc *sc;
124 uint32_t reg;
125
126 sc = clknode_get_softc(clk);
127
128 DEVICE_LOCK(clk);
129 READ4(clk, sc->mode_reg, ®);
130 DEVICE_UNLOCK(clk);
131
132 reg = (reg >> sc->mode_shift) & RK3066_CLK_PLL_MODE_MASK;
133 clknode_init_parent_idx(clk, reg);
134
135 return (0);
136 }
137
138 static int
rk3066_clk_pll_set_mux(struct clknode * clk,int idx)139 rk3066_clk_pll_set_mux(struct clknode *clk, int idx)
140 {
141 uint32_t reg;
142 struct rk_clk_pll_sc *sc;
143
144 sc = clknode_get_softc(clk);
145
146 reg = (idx & RK3066_CLK_PLL_MODE_MASK) << sc->mode_shift;
147 reg |= (RK3066_CLK_PLL_MODE_MASK << sc->mode_shift) <<
148 RK_CLK_PLL_MASK_SHIFT;
149
150 DEVICE_LOCK(clk);
151 WRITE4(clk, sc->mode_reg, reg);
152 DEVICE_UNLOCK(clk);
153 return(0);
154 }
155
156 static int
rk3066_clk_pll_recalc(struct clknode * clk,uint64_t * freq)157 rk3066_clk_pll_recalc(struct clknode *clk, uint64_t *freq)
158 {
159 struct rk_clk_pll_sc *sc;
160 uint64_t rate;
161 uint32_t refdiv, fbdiv, postdiv;
162 uint32_t raw0, raw1, raw2, reg;
163
164 sc = clknode_get_softc(clk);
165
166 DEVICE_LOCK(clk);
167
168 READ4(clk, sc->base_offset, &raw0);
169 READ4(clk, sc->base_offset + 4, &raw1);
170 READ4(clk, sc->base_offset + 8, &raw2);
171 READ4(clk, sc->mode_reg, ®);
172
173 DEVICE_UNLOCK(clk);
174
175 reg = (reg >> sc->mode_shift) & RK3066_CLK_PLL_MODE_MASK;
176
177 if (reg != RK3066_CLK_PLL_MODE_NORMAL)
178 return (0);
179
180 if (!(raw1 & RK3066_CLK_PLL_LOCK_MASK)) {
181 *freq = 0;
182 return (0);
183 }
184
185 /* TODO MUX */
186 refdiv = (raw0 & RK3066_CLK_PLL_REFDIV_MASK) >>
187 RK3066_CLK_PLL_REFDIV_SHIFT;
188 refdiv += 1;
189 postdiv = (raw0 & RK3066_CLK_PLL_POSTDIV_MASK) >>
190 RK3066_CLK_PLL_POSTDIV_SHIFT;
191 postdiv += 1;
192 fbdiv = (raw1 & RK3066_CLK_PLL_FBDIV_MASK) >>
193 RK3066_CLK_PLL_FBDIV_SHIFT;
194 fbdiv += 1;
195
196 rate = *freq * fbdiv;
197 rate /= refdiv;
198 *freq = rate / postdiv;
199
200 return (0);
201 }
202
203 static int
rk3066_clk_pll_set_freq(struct clknode * clk,uint64_t fparent,uint64_t * fout,int flags,int * stop)204 rk3066_clk_pll_set_freq(struct clknode *clk, uint64_t fparent, uint64_t *fout,
205 int flags, int *stop)
206 {
207 struct rk_clk_pll_rate *rates;
208 struct rk_clk_pll_sc *sc;
209 uint32_t reg;
210 int rv, timeout;
211
212 sc = clknode_get_softc(clk);
213
214 if (sc->rates == NULL)
215 return (EINVAL);
216
217 for (rates = sc->rates; rates->freq; rates++) {
218 if (rates->freq == *fout)
219 break;
220 }
221 if (rates->freq == 0) {
222 *stop = 1;
223 return (EINVAL);
224 }
225
226 DEVICE_LOCK(clk);
227
228 /* Setting to slow mode during frequency change */
229 reg = (RK3066_CLK_PLL_MODE_MASK << sc->mode_shift) <<
230 RK_CLK_PLL_MASK_SHIFT;
231 dprintf("Set PLL_MODEREG to %x\n", reg);
232 WRITE4(clk, sc->mode_reg, reg);
233
234 /* Reset PLL */
235 WRITE4(clk, sc->base_offset + 12, RK3066_CLK_PLL_RESET |
236 RK3066_CLK_PLL_RESET << RK_CLK_PLL_MASK_SHIFT);
237
238 /* Setting postdiv and refdiv */
239 reg = 0;
240 reg |= RK3066_CLK_PLL_POSTDIV_MASK << 16;
241 reg |= (rates->postdiv1 - 1) << RK3066_CLK_PLL_POSTDIV_SHIFT;
242
243 reg |= RK3066_CLK_PLL_REFDIV_MASK << 16;
244 reg |= (rates->refdiv - 1)<< RK3066_CLK_PLL_REFDIV_SHIFT;
245
246 dprintf("Set PLL_CON0 to %x\n", reg);
247 WRITE4(clk, sc->base_offset, reg);
248
249
250 /* Setting fbdiv (no write mask)*/
251 READ4(clk, sc->base_offset + 4, ®);
252 reg &= ~RK3066_CLK_PLL_FBDIV_MASK;
253 reg |= RK3066_CLK_PLL_FBDIV_MASK << 16;
254 reg = (rates->fbdiv - 1) << RK3066_CLK_PLL_FBDIV_SHIFT;
255
256 dprintf("Set PLL_CON1 to %x\n", reg);
257 WRITE4(clk, sc->base_offset + 0x4, reg);
258
259 /* PLL loop bandwidth adjust */
260 reg = rates->bwadj - 1;
261 dprintf("Set PLL_CON2 to %x (%x)\n", reg, rates->bwadj);
262 WRITE4(clk, sc->base_offset + 0x8, reg);
263
264 /* Clear reset */
265 WRITE4(clk, sc->base_offset + 12,
266 RK3066_CLK_PLL_RESET << RK_CLK_PLL_MASK_SHIFT);
267 DELAY(100000);
268
269 /* Reading lock */
270 for (timeout = 1000; timeout >= 0; timeout--) {
271 READ4(clk, sc->base_offset + 0x4, ®);
272 if ((reg & RK3066_CLK_PLL_LOCK_MASK) != 0)
273 break;
274 DELAY(1);
275 }
276
277 rv = 0;
278 if (timeout < 0) {
279 device_printf(clknode_get_device(clk),
280 "%s - Timedout while waiting for lock.\n",
281 clknode_get_name(clk));
282 dprintf("PLL_CON1: %x\n", reg);
283 rv = ETIMEDOUT;
284 }
285
286 /* Set back to normal mode */
287 reg = (RK3066_CLK_PLL_MODE_NORMAL << sc->mode_shift);
288 reg |= (RK3066_CLK_PLL_MODE_MASK << sc->mode_shift) <<
289 RK_CLK_PLL_MASK_SHIFT;
290 dprintf("Set PLL_MODEREG to %x\n", reg);
291 WRITE4(clk, sc->mode_reg, reg);
292
293 DEVICE_UNLOCK(clk);
294 *stop = 1;
295 rv = clknode_set_parent_by_idx(clk, 1);
296 return (rv);
297 }
298
299 static clknode_method_t rk3066_clk_pll_clknode_methods[] = {
300 /* Device interface */
301 CLKNODEMETHOD(clknode_init, rk3066_clk_pll_init),
302 CLKNODEMETHOD(clknode_set_gate, rk_clk_pll_set_gate),
303 CLKNODEMETHOD(clknode_recalc_freq, rk3066_clk_pll_recalc),
304 CLKNODEMETHOD(clknode_set_freq, rk3066_clk_pll_set_freq),
305 CLKNODEMETHOD(clknode_set_mux, rk3066_clk_pll_set_mux),
306 CLKNODEMETHOD_END
307 };
308
309 DEFINE_CLASS_1(rk3066_clk_pll_clknode, rk3066_clk_pll_clknode_class,
310 rk3066_clk_pll_clknode_methods, sizeof(struct rk_clk_pll_sc), clknode_class);
311
312 int
rk3066_clk_pll_register(struct clkdom * clkdom,struct rk_clk_pll_def * clkdef)313 rk3066_clk_pll_register(struct clkdom *clkdom, struct rk_clk_pll_def *clkdef)
314 {
315 struct clknode *clk;
316 struct rk_clk_pll_sc *sc;
317
318 clk = clknode_create(clkdom, &rk3066_clk_pll_clknode_class,
319 &clkdef->clkdef);
320 if (clk == NULL)
321 return (1);
322
323 sc = clknode_get_softc(clk);
324
325 sc->base_offset = clkdef->base_offset;
326 sc->gate_offset = clkdef->gate_offset;
327 sc->gate_shift = clkdef->gate_shift;
328 sc->mode_reg = clkdef->mode_reg;
329 sc->mode_shift = clkdef->mode_shift;
330 sc->flags = clkdef->flags;
331 sc->rates = clkdef->rates;
332 sc->frac_rates = clkdef->frac_rates;
333
334 clknode_register(clkdom, clk);
335
336 return (0);
337 }
338
339 #define RK3328_CLK_PLL_FBDIV_OFFSET 0
340 #define RK3328_CLK_PLL_FBDIV_SHIFT 0
341 #define RK3328_CLK_PLL_FBDIV_MASK 0xFFF
342
343 #define RK3328_CLK_PLL_POSTDIV1_OFFSET 0
344 #define RK3328_CLK_PLL_POSTDIV1_SHIFT 12
345 #define RK3328_CLK_PLL_POSTDIV1_MASK 0x7000
346
347 #define RK3328_CLK_PLL_DSMPD_OFFSET 4
348 #define RK3328_CLK_PLL_DSMPD_SHIFT 12
349 #define RK3328_CLK_PLL_DSMPD_MASK 0x1000
350
351 #define RK3328_CLK_PLL_REFDIV_OFFSET 4
352 #define RK3328_CLK_PLL_REFDIV_SHIFT 0
353 #define RK3328_CLK_PLL_REFDIV_MASK 0x3F
354
355 #define RK3328_CLK_PLL_POSTDIV2_OFFSET 4
356 #define RK3328_CLK_PLL_POSTDIV2_SHIFT 6
357 #define RK3328_CLK_PLL_POSTDIV2_MASK 0x1C0
358
359 #define RK3328_CLK_PLL_FRAC_OFFSET 8
360 #define RK3328_CLK_PLL_FRAC_SHIFT 0
361 #define RK3328_CLK_PLL_FRAC_MASK 0xFFFFFF
362
363 #define RK3328_CLK_PLL_LOCK_MASK 0x400
364
365 #define RK3328_CLK_PLL_MODE_SLOW 0
366 #define RK3328_CLK_PLL_MODE_NORMAL 1
367 #define RK3328_CLK_PLL_MODE_MASK 0x1
368
369 static int
rk3328_clk_pll_init(struct clknode * clk,device_t dev)370 rk3328_clk_pll_init(struct clknode *clk, device_t dev)
371 {
372 struct rk_clk_pll_sc *sc;
373
374 sc = clknode_get_softc(clk);
375
376 clknode_init_parent_idx(clk, 0);
377
378 return (0);
379 }
380
381 static int
rk3328_clk_pll_recalc(struct clknode * clk,uint64_t * freq)382 rk3328_clk_pll_recalc(struct clknode *clk, uint64_t *freq)
383 {
384 struct rk_clk_pll_sc *sc;
385 uint64_t rate;
386 uint32_t dsmpd, refdiv, fbdiv;
387 uint32_t postdiv1, postdiv2, frac;
388 uint32_t raw1, raw2, raw3;
389
390 sc = clknode_get_softc(clk);
391
392 DEVICE_LOCK(clk);
393
394 READ4(clk, sc->base_offset, &raw1);
395 READ4(clk, sc->base_offset + 4, &raw2);
396 READ4(clk, sc->base_offset + 8, &raw3);
397
398 fbdiv = (raw1 & RK3328_CLK_PLL_FBDIV_MASK) >> RK3328_CLK_PLL_FBDIV_SHIFT;
399 postdiv1 = (raw1 & RK3328_CLK_PLL_POSTDIV1_MASK) >> RK3328_CLK_PLL_POSTDIV1_SHIFT;
400
401 dsmpd = (raw2 & RK3328_CLK_PLL_DSMPD_MASK) >> RK3328_CLK_PLL_DSMPD_SHIFT;
402 refdiv = (raw2 & RK3328_CLK_PLL_REFDIV_MASK) >> RK3328_CLK_PLL_REFDIV_SHIFT;
403 postdiv2 = (raw2 & RK3328_CLK_PLL_POSTDIV2_MASK) >> RK3328_CLK_PLL_POSTDIV2_SHIFT;
404
405 frac = (raw3 & RK3328_CLK_PLL_FRAC_MASK) >> RK3328_CLK_PLL_FRAC_SHIFT;
406
407 DEVICE_UNLOCK(clk);
408
409 rate = *freq * fbdiv / refdiv;
410 if (dsmpd == 0) {
411 /* Fractional mode */
412 uint64_t frac_rate;
413
414 frac_rate = *freq * frac / refdiv;
415 rate += frac_rate >> 24;
416 }
417
418 *freq = rate / postdiv1 / postdiv2;
419
420 if (*freq % 2)
421 *freq = *freq + 1;
422
423 return (0);
424 }
425
426 static int
rk3328_clk_pll_set_freq(struct clknode * clk,uint64_t fparent,uint64_t * fout,int flags,int * stop)427 rk3328_clk_pll_set_freq(struct clknode *clk, uint64_t fparent, uint64_t *fout,
428 int flags, int *stop)
429 {
430 struct rk_clk_pll_rate *rates;
431 struct rk_clk_pll_sc *sc;
432 uint32_t reg;
433 int timeout;
434
435 sc = clknode_get_softc(clk);
436
437 if (sc->rates)
438 rates = sc->rates;
439 else if (sc->frac_rates)
440 rates = sc->frac_rates;
441 else
442 return (EINVAL);
443
444 for (; rates->freq; rates++) {
445 if (rates->freq == *fout)
446 break;
447 }
448 if (rates->freq == 0) {
449 *stop = 1;
450 return (EINVAL);
451 }
452
453 DEVICE_LOCK(clk);
454
455 /* Setting to slow mode during frequency change */
456 reg = (RK3328_CLK_PLL_MODE_MASK << sc->mode_shift) <<
457 RK_CLK_PLL_MASK_SHIFT;
458 dprintf("Set PLL_MODEREG to %x\n", reg);
459 WRITE4(clk, sc->mode_reg, reg);
460
461 /* Setting postdiv1 and fbdiv */
462 reg = (rates->postdiv1 << RK3328_CLK_PLL_POSTDIV1_SHIFT) |
463 (rates->fbdiv << RK3328_CLK_PLL_FBDIV_SHIFT);
464 reg |= (RK3328_CLK_PLL_POSTDIV1_MASK | RK3328_CLK_PLL_FBDIV_MASK) << 16;
465 dprintf("Set PLL_CON0 to %x\n", reg);
466 WRITE4(clk, sc->base_offset, reg);
467
468 /* Setting dsmpd, postdiv2 and refdiv */
469 reg = (rates->dsmpd << RK3328_CLK_PLL_DSMPD_SHIFT) |
470 (rates->postdiv2 << RK3328_CLK_PLL_POSTDIV2_SHIFT) |
471 (rates->refdiv << RK3328_CLK_PLL_REFDIV_SHIFT);
472 reg |= (RK3328_CLK_PLL_DSMPD_MASK |
473 RK3328_CLK_PLL_POSTDIV2_MASK |
474 RK3328_CLK_PLL_REFDIV_MASK) << RK_CLK_PLL_MASK_SHIFT;
475 dprintf("Set PLL_CON1 to %x\n", reg);
476 WRITE4(clk, sc->base_offset + 0x4, reg);
477
478 /* Setting frac */
479 READ4(clk, sc->base_offset + 0x8, ®);
480 reg &= ~RK3328_CLK_PLL_FRAC_MASK;
481 reg |= rates->frac << RK3328_CLK_PLL_FRAC_SHIFT;
482 dprintf("Set PLL_CON2 to %x\n", reg);
483 WRITE4(clk, sc->base_offset + 0x8, reg);
484
485 /* Reading lock */
486 for (timeout = 1000; timeout; timeout--) {
487 READ4(clk, sc->base_offset + 0x4, ®);
488 if ((reg & RK3328_CLK_PLL_LOCK_MASK) == 0)
489 break;
490 DELAY(1);
491 }
492
493 /* Set back to normal mode */
494 reg = (RK3328_CLK_PLL_MODE_NORMAL << sc->mode_shift);
495 reg |= (RK3328_CLK_PLL_MODE_MASK << sc->mode_shift) <<
496 RK_CLK_PLL_MASK_SHIFT;
497 dprintf("Set PLL_MODEREG to %x\n", reg);
498 WRITE4(clk, sc->mode_reg, reg);
499
500 DEVICE_UNLOCK(clk);
501
502 *stop = 1;
503 return (0);
504 }
505
506 static clknode_method_t rk3328_clk_pll_clknode_methods[] = {
507 /* Device interface */
508 CLKNODEMETHOD(clknode_init, rk3328_clk_pll_init),
509 CLKNODEMETHOD(clknode_set_gate, rk_clk_pll_set_gate),
510 CLKNODEMETHOD(clknode_recalc_freq, rk3328_clk_pll_recalc),
511 CLKNODEMETHOD(clknode_set_freq, rk3328_clk_pll_set_freq),
512 CLKNODEMETHOD_END
513 };
514
515 DEFINE_CLASS_1(rk3328_clk_pll_clknode, rk3328_clk_pll_clknode_class,
516 rk3328_clk_pll_clknode_methods, sizeof(struct rk_clk_pll_sc), clknode_class);
517
518 int
rk3328_clk_pll_register(struct clkdom * clkdom,struct rk_clk_pll_def * clkdef)519 rk3328_clk_pll_register(struct clkdom *clkdom, struct rk_clk_pll_def *clkdef)
520 {
521 struct clknode *clk;
522 struct rk_clk_pll_sc *sc;
523
524 clk = clknode_create(clkdom, &rk3328_clk_pll_clknode_class,
525 &clkdef->clkdef);
526 if (clk == NULL)
527 return (1);
528
529 sc = clknode_get_softc(clk);
530
531 sc->base_offset = clkdef->base_offset;
532 sc->gate_offset = clkdef->gate_offset;
533 sc->gate_shift = clkdef->gate_shift;
534 sc->mode_reg = clkdef->mode_reg;
535 sc->mode_shift = clkdef->mode_shift;
536 sc->flags = clkdef->flags;
537 sc->rates = clkdef->rates;
538 sc->frac_rates = clkdef->frac_rates;
539
540 clknode_register(clkdom, clk);
541
542 return (0);
543 }
544
545 #define RK3399_CLK_PLL_FBDIV_OFFSET 0
546 #define RK3399_CLK_PLL_FBDIV_SHIFT 0
547 #define RK3399_CLK_PLL_FBDIV_MASK 0xFFF
548
549 #define RK3399_CLK_PLL_POSTDIV2_OFFSET 4
550 #define RK3399_CLK_PLL_POSTDIV2_SHIFT 12
551 #define RK3399_CLK_PLL_POSTDIV2_MASK 0x7000
552
553 #define RK3399_CLK_PLL_POSTDIV1_OFFSET 4
554 #define RK3399_CLK_PLL_POSTDIV1_SHIFT 8
555 #define RK3399_CLK_PLL_POSTDIV1_MASK 0x700
556
557 #define RK3399_CLK_PLL_REFDIV_OFFSET 4
558 #define RK3399_CLK_PLL_REFDIV_SHIFT 0
559 #define RK3399_CLK_PLL_REFDIV_MASK 0x3F
560
561 #define RK3399_CLK_PLL_FRAC_OFFSET 8
562 #define RK3399_CLK_PLL_FRAC_SHIFT 0
563 #define RK3399_CLK_PLL_FRAC_MASK 0xFFFFFF
564
565 #define RK3399_CLK_PLL_DSMPD_OFFSET 0xC
566 #define RK3399_CLK_PLL_DSMPD_SHIFT 3
567 #define RK3399_CLK_PLL_DSMPD_MASK 0x8
568
569 #define RK3399_CLK_PLL_LOCK_OFFSET 8
570 #define RK3399_CLK_PLL_LOCK_MASK 0x400
571
572 #define RK3399_CLK_PLL_MODE_OFFSET 0xC
573 #define RK3399_CLK_PLL_MODE_MASK 0x300
574 #define RK3399_CLK_PLL_MODE_SLOW 0
575 #define RK3399_CLK_PLL_MODE_NORMAL 1
576 #define RK3399_CLK_PLL_MODE_DEEPSLOW 2
577 #define RK3399_CLK_PLL_MODE_SHIFT 8
578
579 #define RK3399_CLK_PLL_WRITE_MASK 0xFFFF0000
580
581 static int
rk3399_clk_pll_init(struct clknode * clk,device_t dev)582 rk3399_clk_pll_init(struct clknode *clk, device_t dev)
583 {
584 struct rk_clk_pll_sc *sc;
585
586 sc = clknode_get_softc(clk);
587 clknode_init_parent_idx(clk, 0);
588
589 return (0);
590 }
591
592 static int
rk3399_clk_pll_recalc(struct clknode * clk,uint64_t * freq)593 rk3399_clk_pll_recalc(struct clknode *clk, uint64_t *freq)
594 {
595 struct rk_clk_pll_sc *sc;
596 uint32_t dsmpd, refdiv, fbdiv;
597 uint32_t postdiv1, postdiv2, fracdiv;
598 uint32_t con1, con2, con3, con4;
599 uint64_t foutvco;
600 uint32_t mode;
601 sc = clknode_get_softc(clk);
602
603 DEVICE_LOCK(clk);
604 READ4(clk, sc->base_offset, &con1);
605 READ4(clk, sc->base_offset + 4, &con2);
606 READ4(clk, sc->base_offset + 8, &con3);
607 READ4(clk, sc->base_offset + 0xC, &con4);
608 DEVICE_UNLOCK(clk);
609
610 /*
611 * if we are in slow mode the output freq
612 * is the parent one, the 24Mhz external oscillator
613 * if we are in deep mode the output freq is 32.768khz
614 */
615 mode = (con4 & RK3399_CLK_PLL_MODE_MASK) >> RK3399_CLK_PLL_MODE_SHIFT;
616 if (mode == RK3399_CLK_PLL_MODE_SLOW) {
617 dprintf("pll in slow mode, con4=%x\n", con4);
618 return (0);
619 } else if (mode == RK3399_CLK_PLL_MODE_DEEPSLOW) {
620 dprintf("pll in deep slow, con4=%x\n", con4);
621 *freq = 32768;
622 return (0);
623 }
624
625 dprintf("con0: %x\n", con1);
626 dprintf("con1: %x\n", con2);
627 dprintf("con2: %x\n", con3);
628 dprintf("con3: %x\n", con4);
629
630 fbdiv = (con1 & RK3399_CLK_PLL_FBDIV_MASK)
631 >> RK3399_CLK_PLL_FBDIV_SHIFT;
632
633 postdiv1 = (con2 & RK3399_CLK_PLL_POSTDIV1_MASK)
634 >> RK3399_CLK_PLL_POSTDIV1_SHIFT;
635 postdiv2 = (con2 & RK3399_CLK_PLL_POSTDIV2_MASK)
636 >> RK3399_CLK_PLL_POSTDIV2_SHIFT;
637 refdiv = (con2 & RK3399_CLK_PLL_REFDIV_MASK)
638 >> RK3399_CLK_PLL_REFDIV_SHIFT;
639
640 fracdiv = (con3 & RK3399_CLK_PLL_FRAC_MASK)
641 >> RK3399_CLK_PLL_FRAC_SHIFT;
642 fracdiv >>= 24;
643
644 dsmpd = (con4 & RK3399_CLK_PLL_DSMPD_MASK) >> RK3399_CLK_PLL_DSMPD_SHIFT;
645
646 dprintf("fbdiv: %d\n", fbdiv);
647 dprintf("postdiv1: %d\n", postdiv1);
648 dprintf("postdiv2: %d\n", postdiv2);
649 dprintf("refdiv: %d\n", refdiv);
650 dprintf("fracdiv: %d\n", fracdiv);
651 dprintf("dsmpd: %d\n", dsmpd);
652
653 dprintf("parent freq=%ju\n", *freq);
654
655 if (dsmpd == 0) {
656 /* Fractional mode */
657 foutvco = *freq / refdiv * (fbdiv + fracdiv);
658 } else {
659 /* Integer mode */
660 foutvco = *freq / refdiv * fbdiv;
661 }
662 dprintf("foutvco: %ju\n", foutvco);
663
664 *freq = foutvco / postdiv1 / postdiv2;
665 dprintf("freq: %ju\n", *freq);
666
667 return (0);
668 }
669
670 static int
rk3399_clk_pll_set_freq(struct clknode * clk,uint64_t fparent,uint64_t * fout,int flags,int * stop)671 rk3399_clk_pll_set_freq(struct clknode *clk, uint64_t fparent, uint64_t *fout,
672 int flags, int *stop)
673 {
674 struct rk_clk_pll_rate *rates;
675 struct rk_clk_pll_sc *sc;
676 uint32_t reg;
677 int timeout;
678
679 sc = clknode_get_softc(clk);
680
681 if (sc->rates)
682 rates = sc->rates;
683 else if (sc->frac_rates)
684 rates = sc->frac_rates;
685 else
686 return (EINVAL);
687
688 for (; rates->freq; rates++) {
689 if (rates->freq == *fout)
690 break;
691 }
692 if (rates->freq == 0) {
693 *stop = 1;
694 return (EINVAL);
695 }
696
697 DEVICE_LOCK(clk);
698
699 /* Set to slow mode during frequency change */
700 reg = RK3399_CLK_PLL_MODE_SLOW << RK3399_CLK_PLL_MODE_SHIFT;
701 reg |= RK3399_CLK_PLL_MODE_MASK << RK_CLK_PLL_MASK_SHIFT;
702 WRITE4(clk, sc->base_offset + 0xC, reg);
703
704 /* Setting fbdiv */
705 reg = rates->fbdiv << RK3399_CLK_PLL_FBDIV_SHIFT;
706 reg |= RK3399_CLK_PLL_FBDIV_MASK << RK_CLK_PLL_MASK_SHIFT;
707 WRITE4(clk, sc->base_offset, reg);
708
709 /* Setting postdiv1, postdiv2 and refdiv */
710 reg = rates->postdiv1 << RK3399_CLK_PLL_POSTDIV1_SHIFT;
711 reg |= rates->postdiv2 << RK3399_CLK_PLL_POSTDIV2_SHIFT;
712 reg |= rates->refdiv << RK3399_CLK_PLL_REFDIV_SHIFT;
713 reg |= (RK3399_CLK_PLL_POSTDIV1_MASK | RK3399_CLK_PLL_POSTDIV2_MASK |
714 RK3399_CLK_PLL_REFDIV_MASK) << RK_CLK_PLL_MASK_SHIFT;
715 WRITE4(clk, sc->base_offset + 0x4, reg);
716
717 /* Setting frac */
718 READ4(clk, sc->base_offset + 0x8, ®);
719 reg &= ~RK3399_CLK_PLL_FRAC_MASK;
720 reg |= rates->frac << RK3399_CLK_PLL_FRAC_SHIFT;
721 WRITE4(clk, sc->base_offset + 0x8, reg | RK3399_CLK_PLL_WRITE_MASK);
722
723 /* Set dsmpd */
724 reg = rates->dsmpd << RK3399_CLK_PLL_DSMPD_SHIFT;
725 reg |= RK3399_CLK_PLL_DSMPD_MASK << RK_CLK_PLL_MASK_SHIFT;
726 WRITE4(clk, sc->base_offset + 0xC, reg);
727
728 /* Reading lock */
729 for (timeout = 1000; timeout; timeout--) {
730 READ4(clk, sc->base_offset + RK3399_CLK_PLL_LOCK_OFFSET, ®);
731 if ((reg & RK3399_CLK_PLL_LOCK_MASK) == 0)
732 break;
733 DELAY(1);
734 }
735
736 /* Set back to normal mode */
737 reg = RK3399_CLK_PLL_MODE_NORMAL << RK3399_CLK_PLL_MODE_SHIFT;
738 reg |= RK3399_CLK_PLL_MODE_MASK << RK_CLK_PLL_MASK_SHIFT;
739 WRITE4(clk, sc->base_offset + 0xC, reg);
740
741 DEVICE_UNLOCK(clk);
742
743 *stop = 1;
744 return (0);
745 }
746
747 static clknode_method_t rk3399_clk_pll_clknode_methods[] = {
748 /* Device interface */
749 CLKNODEMETHOD(clknode_init, rk3399_clk_pll_init),
750 CLKNODEMETHOD(clknode_set_gate, rk_clk_pll_set_gate),
751 CLKNODEMETHOD(clknode_recalc_freq, rk3399_clk_pll_recalc),
752 CLKNODEMETHOD(clknode_set_freq, rk3399_clk_pll_set_freq),
753 CLKNODEMETHOD_END
754 };
755
756 DEFINE_CLASS_1(rk3399_clk_pll_clknode, rk3399_clk_pll_clknode_class,
757 rk3399_clk_pll_clknode_methods, sizeof(struct rk_clk_pll_sc), clknode_class);
758
759 int
rk3399_clk_pll_register(struct clkdom * clkdom,struct rk_clk_pll_def * clkdef)760 rk3399_clk_pll_register(struct clkdom *clkdom, struct rk_clk_pll_def *clkdef)
761 {
762 struct clknode *clk;
763 struct rk_clk_pll_sc *sc;
764
765 clk = clknode_create(clkdom, &rk3399_clk_pll_clknode_class,
766 &clkdef->clkdef);
767 if (clk == NULL)
768 return (1);
769
770 sc = clknode_get_softc(clk);
771
772 sc->base_offset = clkdef->base_offset;
773 sc->gate_offset = clkdef->gate_offset;
774 sc->gate_shift = clkdef->gate_shift;
775 sc->flags = clkdef->flags;
776 sc->rates = clkdef->rates;
777 sc->frac_rates = clkdef->frac_rates;
778
779 clknode_register(clkdom, clk);
780
781 return (0);
782 }
783