Loading...
1/*
2 * Alchemy clocks.
3 *
4 * Exposes all configurable internal clock sources to the clk framework.
5 *
6 * We have:
7 * - Root source, usually 12MHz supplied by an external crystal
8 * - 3 PLLs which generate multiples of root rate [AUX, CPU, AUX2]
9 *
10 * Dividers:
11 * - 6 clock dividers with:
12 * * selectable source [one of the PLLs],
13 * * output divided between [2 .. 512 in steps of 2] (!Au1300)
14 * or [1 .. 256 in steps of 1] (Au1300),
15 * * can be enabled individually.
16 *
17 * - up to 6 "internal" (fixed) consumers which:
18 * * take either AUXPLL or one of the above 6 dividers as input,
19 * * divide this input by 1, 2, or 4 (and 3 on Au1300).
20 * * can be disabled separately.
21 *
22 * Misc clocks:
23 * - sysbus clock: CPU core clock (CPUPLL) divided by 2, 3 or 4.
24 * depends on board design and should be set by bootloader, read-only.
25 * - peripheral clock: half the rate of sysbus clock, source for a lot
26 * of peripheral blocks, read-only.
27 * - memory clock: clk rate to main memory chips, depends on board
28 * design and is read-only,
29 * - lrclk: the static bus clock signal for synchronous operation.
30 * depends on board design, must be set by bootloader,
31 * but may be required to correctly configure devices attached to
32 * the static bus. The Au1000/1500/1100 manuals call it LCLK, on
33 * later models it's called RCLK.
34 */
35
36#include <linux/init.h>
37#include <linux/io.h>
38#include <linux/clk.h>
39#include <linux/clk-provider.h>
40#include <linux/clkdev.h>
41#include <linux/slab.h>
42#include <linux/spinlock.h>
43#include <linux/types.h>
44#include <asm/mach-au1x00/au1000.h>
45
46/* Base clock: 12MHz is the default in all databooks, and I haven't
47 * found any board yet which uses a different rate.
48 */
49#define ALCHEMY_ROOTCLK_RATE 12000000
50
51/*
52 * the internal sources which can be driven by the PLLs and dividers.
53 * Names taken from the databooks, refer to them for more information,
54 * especially which ones are share a clock line.
55 */
56static const char * const alchemy_au1300_intclknames[] = {
57 "lcd_intclk", "gpemgp_clk", "maempe_clk", "maebsa_clk",
58 "EXTCLK0", "EXTCLK1"
59};
60
61static const char * const alchemy_au1200_intclknames[] = {
62 "lcd_intclk", NULL, NULL, NULL, "EXTCLK0", "EXTCLK1"
63};
64
65static const char * const alchemy_au1550_intclknames[] = {
66 "usb_clk", "psc0_intclk", "psc1_intclk", "pci_clko",
67 "EXTCLK0", "EXTCLK1"
68};
69
70static const char * const alchemy_au1100_intclknames[] = {
71 "usb_clk", "lcd_intclk", NULL, "i2s_clk", "EXTCLK0", "EXTCLK1"
72};
73
74static const char * const alchemy_au1500_intclknames[] = {
75 NULL, "usbd_clk", "usbh_clk", "pci_clko", "EXTCLK0", "EXTCLK1"
76};
77
78static const char * const alchemy_au1000_intclknames[] = {
79 "irda_clk", "usbd_clk", "usbh_clk", "i2s_clk", "EXTCLK0",
80 "EXTCLK1"
81};
82
83/* aliases for a few on-chip sources which are either shared
84 * or have gone through name changes.
85 */
86static struct clk_aliastable {
87 char *alias;
88 char *base;
89 int cputype;
90} alchemy_clk_aliases[] __initdata = {
91 { "usbh_clk", "usb_clk", ALCHEMY_CPU_AU1100 },
92 { "usbd_clk", "usb_clk", ALCHEMY_CPU_AU1100 },
93 { "irda_clk", "usb_clk", ALCHEMY_CPU_AU1100 },
94 { "usbh_clk", "usb_clk", ALCHEMY_CPU_AU1550 },
95 { "usbd_clk", "usb_clk", ALCHEMY_CPU_AU1550 },
96 { "psc2_intclk", "usb_clk", ALCHEMY_CPU_AU1550 },
97 { "psc3_intclk", "EXTCLK0", ALCHEMY_CPU_AU1550 },
98 { "psc0_intclk", "EXTCLK0", ALCHEMY_CPU_AU1200 },
99 { "psc1_intclk", "EXTCLK1", ALCHEMY_CPU_AU1200 },
100 { "psc0_intclk", "EXTCLK0", ALCHEMY_CPU_AU1300 },
101 { "psc2_intclk", "EXTCLK0", ALCHEMY_CPU_AU1300 },
102 { "psc1_intclk", "EXTCLK1", ALCHEMY_CPU_AU1300 },
103 { "psc3_intclk", "EXTCLK1", ALCHEMY_CPU_AU1300 },
104
105 { NULL, NULL, 0 },
106};
107
108#define IOMEM(x) ((void __iomem *)(KSEG1ADDR(CPHYSADDR(x))))
109
110/* access locks to SYS_FREQCTRL0/1 and SYS_CLKSRC registers */
111static spinlock_t alchemy_clk_fg0_lock;
112static spinlock_t alchemy_clk_fg1_lock;
113static spinlock_t alchemy_clk_csrc_lock;
114
115/* CPU Core clock *****************************************************/
116
117static unsigned long alchemy_clk_cpu_recalc(struct clk_hw *hw,
118 unsigned long parent_rate)
119{
120 unsigned long t;
121
122 /*
123 * On early Au1000, sys_cpupll was write-only. Since these
124 * silicon versions of Au1000 are not sold, we don't bend
125 * over backwards trying to determine the frequency.
126 */
127 if (unlikely(au1xxx_cpu_has_pll_wo()))
128 t = 396000000;
129 else {
130 t = alchemy_rdsys(AU1000_SYS_CPUPLL) & 0x7f;
131 if (alchemy_get_cputype() < ALCHEMY_CPU_AU1300)
132 t &= 0x3f;
133 t *= parent_rate;
134 }
135
136 return t;
137}
138
139void __init alchemy_set_lpj(void)
140{
141 preset_lpj = alchemy_clk_cpu_recalc(NULL, ALCHEMY_ROOTCLK_RATE);
142 preset_lpj /= 2 * HZ;
143}
144
145static struct clk_ops alchemy_clkops_cpu = {
146 .recalc_rate = alchemy_clk_cpu_recalc,
147};
148
149static struct clk __init *alchemy_clk_setup_cpu(const char *parent_name,
150 int ctype)
151{
152 struct clk_init_data id;
153 struct clk_hw *h;
154
155 h = kzalloc(sizeof(*h), GFP_KERNEL);
156 if (!h)
157 return ERR_PTR(-ENOMEM);
158
159 id.name = ALCHEMY_CPU_CLK;
160 id.parent_names = &parent_name;
161 id.num_parents = 1;
162 id.flags = CLK_IS_BASIC;
163 id.ops = &alchemy_clkops_cpu;
164 h->init = &id;
165
166 return clk_register(NULL, h);
167}
168
169/* AUXPLLs ************************************************************/
170
171struct alchemy_auxpll_clk {
172 struct clk_hw hw;
173 unsigned long reg; /* au1300 has also AUXPLL2 */
174 int maxmult; /* max multiplier */
175};
176#define to_auxpll_clk(x) container_of(x, struct alchemy_auxpll_clk, hw)
177
178static unsigned long alchemy_clk_aux_recalc(struct clk_hw *hw,
179 unsigned long parent_rate)
180{
181 struct alchemy_auxpll_clk *a = to_auxpll_clk(hw);
182
183 return (alchemy_rdsys(a->reg) & 0xff) * parent_rate;
184}
185
186static int alchemy_clk_aux_setr(struct clk_hw *hw,
187 unsigned long rate,
188 unsigned long parent_rate)
189{
190 struct alchemy_auxpll_clk *a = to_auxpll_clk(hw);
191 unsigned long d = rate;
192
193 if (rate)
194 d /= parent_rate;
195 else
196 d = 0;
197
198 /* minimum is 84MHz, max is 756-1032 depending on variant */
199 if (((d < 7) && (d != 0)) || (d > a->maxmult))
200 return -EINVAL;
201
202 alchemy_wrsys(d, a->reg);
203 return 0;
204}
205
206static long alchemy_clk_aux_roundr(struct clk_hw *hw,
207 unsigned long rate,
208 unsigned long *parent_rate)
209{
210 struct alchemy_auxpll_clk *a = to_auxpll_clk(hw);
211 unsigned long mult;
212
213 if (!rate || !*parent_rate)
214 return 0;
215
216 mult = rate / (*parent_rate);
217
218 if (mult && (mult < 7))
219 mult = 7;
220 if (mult > a->maxmult)
221 mult = a->maxmult;
222
223 return (*parent_rate) * mult;
224}
225
226static struct clk_ops alchemy_clkops_aux = {
227 .recalc_rate = alchemy_clk_aux_recalc,
228 .set_rate = alchemy_clk_aux_setr,
229 .round_rate = alchemy_clk_aux_roundr,
230};
231
232static struct clk __init *alchemy_clk_setup_aux(const char *parent_name,
233 char *name, int maxmult,
234 unsigned long reg)
235{
236 struct clk_init_data id;
237 struct clk *c;
238 struct alchemy_auxpll_clk *a;
239
240 a = kzalloc(sizeof(*a), GFP_KERNEL);
241 if (!a)
242 return ERR_PTR(-ENOMEM);
243
244 id.name = name;
245 id.parent_names = &parent_name;
246 id.num_parents = 1;
247 id.flags = CLK_GET_RATE_NOCACHE;
248 id.ops = &alchemy_clkops_aux;
249
250 a->reg = reg;
251 a->maxmult = maxmult;
252 a->hw.init = &id;
253
254 c = clk_register(NULL, &a->hw);
255 if (!IS_ERR(c))
256 clk_register_clkdev(c, name, NULL);
257 else
258 kfree(a);
259
260 return c;
261}
262
263/* sysbus_clk *********************************************************/
264
265static struct clk __init *alchemy_clk_setup_sysbus(const char *pn)
266{
267 unsigned long v = (alchemy_rdsys(AU1000_SYS_POWERCTRL) & 3) + 2;
268 struct clk *c;
269
270 c = clk_register_fixed_factor(NULL, ALCHEMY_SYSBUS_CLK,
271 pn, 0, 1, v);
272 if (!IS_ERR(c))
273 clk_register_clkdev(c, ALCHEMY_SYSBUS_CLK, NULL);
274 return c;
275}
276
277/* Peripheral Clock ***************************************************/
278
279static struct clk __init *alchemy_clk_setup_periph(const char *pn)
280{
281 /* Peripheral clock runs at half the rate of sysbus clk */
282 struct clk *c;
283
284 c = clk_register_fixed_factor(NULL, ALCHEMY_PERIPH_CLK,
285 pn, 0, 1, 2);
286 if (!IS_ERR(c))
287 clk_register_clkdev(c, ALCHEMY_PERIPH_CLK, NULL);
288 return c;
289}
290
291/* mem clock **********************************************************/
292
293static struct clk __init *alchemy_clk_setup_mem(const char *pn, int ct)
294{
295 void __iomem *addr = IOMEM(AU1000_MEM_PHYS_ADDR);
296 unsigned long v;
297 struct clk *c;
298 int div;
299
300 switch (ct) {
301 case ALCHEMY_CPU_AU1550:
302 case ALCHEMY_CPU_AU1200:
303 v = __raw_readl(addr + AU1550_MEM_SDCONFIGB);
304 div = (v & (1 << 15)) ? 1 : 2;
305 break;
306 case ALCHEMY_CPU_AU1300:
307 v = __raw_readl(addr + AU1550_MEM_SDCONFIGB);
308 div = (v & (1 << 31)) ? 1 : 2;
309 break;
310 case ALCHEMY_CPU_AU1000:
311 case ALCHEMY_CPU_AU1500:
312 case ALCHEMY_CPU_AU1100:
313 default:
314 div = 2;
315 break;
316 }
317
318 c = clk_register_fixed_factor(NULL, ALCHEMY_MEM_CLK, pn,
319 0, 1, div);
320 if (!IS_ERR(c))
321 clk_register_clkdev(c, ALCHEMY_MEM_CLK, NULL);
322 return c;
323}
324
325/* lrclk: external synchronous static bus clock ***********************/
326
327static struct clk __init *alchemy_clk_setup_lrclk(const char *pn, int t)
328{
329 /* Au1000, Au1500: MEM_STCFG0[11]: If bit is set, lrclk=pclk/5,
330 * otherwise lrclk=pclk/4.
331 * All other variants: MEM_STCFG0[15:13] = divisor.
332 * L/RCLK = periph_clk / (divisor + 1)
333 * On Au1000, Au1500, Au1100 it's called LCLK,
334 * on later models it's called RCLK, but it's the same thing.
335 */
336 struct clk *c;
337 unsigned long v = alchemy_rdsmem(AU1000_MEM_STCFG0);
338
339 switch (t) {
340 case ALCHEMY_CPU_AU1000:
341 case ALCHEMY_CPU_AU1500:
342 v = 4 + ((v >> 11) & 1);
343 break;
344 default: /* all other models */
345 v = ((v >> 13) & 7) + 1;
346 }
347 c = clk_register_fixed_factor(NULL, ALCHEMY_LR_CLK,
348 pn, 0, 1, v);
349 if (!IS_ERR(c))
350 clk_register_clkdev(c, ALCHEMY_LR_CLK, NULL);
351 return c;
352}
353
354/* Clock dividers and muxes *******************************************/
355
356/* data for fgen and csrc mux-dividers */
357struct alchemy_fgcs_clk {
358 struct clk_hw hw;
359 spinlock_t *reglock; /* register lock */
360 unsigned long reg; /* SYS_FREQCTRL0/1 */
361 int shift; /* offset in register */
362 int parent; /* parent before disable [Au1300] */
363 int isen; /* is it enabled? */
364 int *dt; /* dividertable for csrc */
365};
366#define to_fgcs_clk(x) container_of(x, struct alchemy_fgcs_clk, hw)
367
368static long alchemy_calc_div(unsigned long rate, unsigned long prate,
369 int scale, int maxdiv, unsigned long *rv)
370{
371 long div1, div2;
372
373 div1 = prate / rate;
374 if ((prate / div1) > rate)
375 div1++;
376
377 if (scale == 2) { /* only div-by-multiple-of-2 possible */
378 if (div1 & 1)
379 div1++; /* stay <=prate */
380 }
381
382 div2 = (div1 / scale) - 1; /* value to write to register */
383
384 if (div2 > maxdiv)
385 div2 = maxdiv;
386 if (rv)
387 *rv = div2;
388
389 div1 = ((div2 + 1) * scale);
390 return div1;
391}
392
393static int alchemy_clk_fgcs_detr(struct clk_hw *hw,
394 struct clk_rate_request *req,
395 int scale, int maxdiv)
396{
397 struct clk_hw *pc, *bpc, *free;
398 long tdv, tpr, pr, nr, br, bpr, diff, lastdiff;
399 int j;
400
401 lastdiff = INT_MAX;
402 bpr = 0;
403 bpc = NULL;
404 br = -EINVAL;
405 free = NULL;
406
407 /* look at the rates each enabled parent supplies and select
408 * the one that gets closest to but not over the requested rate.
409 */
410 for (j = 0; j < 7; j++) {
411 pc = clk_hw_get_parent_by_index(hw, j);
412 if (!pc)
413 break;
414
415 /* if this parent is currently unused, remember it.
416 * XXX: we would actually want clk_has_active_children()
417 * but this is a good-enough approximation for now.
418 */
419 if (!clk_hw_is_prepared(pc)) {
420 if (!free)
421 free = pc;
422 }
423
424 pr = clk_hw_get_rate(pc);
425 if (pr < req->rate)
426 continue;
427
428 /* what can hardware actually provide */
429 tdv = alchemy_calc_div(req->rate, pr, scale, maxdiv, NULL);
430 nr = pr / tdv;
431 diff = req->rate - nr;
432 if (nr > req->rate)
433 continue;
434
435 if (diff < lastdiff) {
436 lastdiff = diff;
437 bpr = pr;
438 bpc = pc;
439 br = nr;
440 }
441 if (diff == 0)
442 break;
443 }
444
445 /* if we couldn't get the exact rate we wanted from the enabled
446 * parents, maybe we can tell an available disabled/inactive one
447 * to give us a rate we can divide down to the requested rate.
448 */
449 if (lastdiff && free) {
450 for (j = (maxdiv == 4) ? 1 : scale; j <= maxdiv; j += scale) {
451 tpr = req->rate * j;
452 if (tpr < 0)
453 break;
454 pr = clk_hw_round_rate(free, tpr);
455
456 tdv = alchemy_calc_div(req->rate, pr, scale, maxdiv,
457 NULL);
458 nr = pr / tdv;
459 diff = req->rate - nr;
460 if (nr > req->rate)
461 continue;
462 if (diff < lastdiff) {
463 lastdiff = diff;
464 bpr = pr;
465 bpc = free;
466 br = nr;
467 }
468 if (diff == 0)
469 break;
470 }
471 }
472
473 if (br < 0)
474 return br;
475
476 req->best_parent_rate = bpr;
477 req->best_parent_hw = bpc;
478 req->rate = br;
479
480 return 0;
481}
482
483static int alchemy_clk_fgv1_en(struct clk_hw *hw)
484{
485 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
486 unsigned long v, flags;
487
488 spin_lock_irqsave(c->reglock, flags);
489 v = alchemy_rdsys(c->reg);
490 v |= (1 << 1) << c->shift;
491 alchemy_wrsys(v, c->reg);
492 spin_unlock_irqrestore(c->reglock, flags);
493
494 return 0;
495}
496
497static int alchemy_clk_fgv1_isen(struct clk_hw *hw)
498{
499 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
500 unsigned long v = alchemy_rdsys(c->reg) >> (c->shift + 1);
501
502 return v & 1;
503}
504
505static void alchemy_clk_fgv1_dis(struct clk_hw *hw)
506{
507 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
508 unsigned long v, flags;
509
510 spin_lock_irqsave(c->reglock, flags);
511 v = alchemy_rdsys(c->reg);
512 v &= ~((1 << 1) << c->shift);
513 alchemy_wrsys(v, c->reg);
514 spin_unlock_irqrestore(c->reglock, flags);
515}
516
517static int alchemy_clk_fgv1_setp(struct clk_hw *hw, u8 index)
518{
519 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
520 unsigned long v, flags;
521
522 spin_lock_irqsave(c->reglock, flags);
523 v = alchemy_rdsys(c->reg);
524 if (index)
525 v |= (1 << c->shift);
526 else
527 v &= ~(1 << c->shift);
528 alchemy_wrsys(v, c->reg);
529 spin_unlock_irqrestore(c->reglock, flags);
530
531 return 0;
532}
533
534static u8 alchemy_clk_fgv1_getp(struct clk_hw *hw)
535{
536 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
537
538 return (alchemy_rdsys(c->reg) >> c->shift) & 1;
539}
540
541static int alchemy_clk_fgv1_setr(struct clk_hw *hw, unsigned long rate,
542 unsigned long parent_rate)
543{
544 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
545 unsigned long div, v, flags, ret;
546 int sh = c->shift + 2;
547
548 if (!rate || !parent_rate || rate > (parent_rate / 2))
549 return -EINVAL;
550 ret = alchemy_calc_div(rate, parent_rate, 2, 512, &div);
551 spin_lock_irqsave(c->reglock, flags);
552 v = alchemy_rdsys(c->reg);
553 v &= ~(0xff << sh);
554 v |= div << sh;
555 alchemy_wrsys(v, c->reg);
556 spin_unlock_irqrestore(c->reglock, flags);
557
558 return 0;
559}
560
561static unsigned long alchemy_clk_fgv1_recalc(struct clk_hw *hw,
562 unsigned long parent_rate)
563{
564 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
565 unsigned long v = alchemy_rdsys(c->reg) >> (c->shift + 2);
566
567 v = ((v & 0xff) + 1) * 2;
568 return parent_rate / v;
569}
570
571static int alchemy_clk_fgv1_detr(struct clk_hw *hw,
572 struct clk_rate_request *req)
573{
574 return alchemy_clk_fgcs_detr(hw, req, 2, 512);
575}
576
577/* Au1000, Au1100, Au15x0, Au12x0 */
578static struct clk_ops alchemy_clkops_fgenv1 = {
579 .recalc_rate = alchemy_clk_fgv1_recalc,
580 .determine_rate = alchemy_clk_fgv1_detr,
581 .set_rate = alchemy_clk_fgv1_setr,
582 .set_parent = alchemy_clk_fgv1_setp,
583 .get_parent = alchemy_clk_fgv1_getp,
584 .enable = alchemy_clk_fgv1_en,
585 .disable = alchemy_clk_fgv1_dis,
586 .is_enabled = alchemy_clk_fgv1_isen,
587};
588
589static void __alchemy_clk_fgv2_en(struct alchemy_fgcs_clk *c)
590{
591 unsigned long v = alchemy_rdsys(c->reg);
592
593 v &= ~(3 << c->shift);
594 v |= (c->parent & 3) << c->shift;
595 alchemy_wrsys(v, c->reg);
596 c->isen = 1;
597}
598
599static int alchemy_clk_fgv2_en(struct clk_hw *hw)
600{
601 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
602 unsigned long flags;
603
604 /* enable by setting the previous parent clock */
605 spin_lock_irqsave(c->reglock, flags);
606 __alchemy_clk_fgv2_en(c);
607 spin_unlock_irqrestore(c->reglock, flags);
608
609 return 0;
610}
611
612static int alchemy_clk_fgv2_isen(struct clk_hw *hw)
613{
614 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
615
616 return ((alchemy_rdsys(c->reg) >> c->shift) & 3) != 0;
617}
618
619static void alchemy_clk_fgv2_dis(struct clk_hw *hw)
620{
621 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
622 unsigned long v, flags;
623
624 spin_lock_irqsave(c->reglock, flags);
625 v = alchemy_rdsys(c->reg);
626 v &= ~(3 << c->shift); /* set input mux to "disabled" state */
627 alchemy_wrsys(v, c->reg);
628 c->isen = 0;
629 spin_unlock_irqrestore(c->reglock, flags);
630}
631
632static int alchemy_clk_fgv2_setp(struct clk_hw *hw, u8 index)
633{
634 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
635 unsigned long flags;
636
637 spin_lock_irqsave(c->reglock, flags);
638 c->parent = index + 1; /* value to write to register */
639 if (c->isen)
640 __alchemy_clk_fgv2_en(c);
641 spin_unlock_irqrestore(c->reglock, flags);
642
643 return 0;
644}
645
646static u8 alchemy_clk_fgv2_getp(struct clk_hw *hw)
647{
648 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
649 unsigned long flags, v;
650
651 spin_lock_irqsave(c->reglock, flags);
652 v = c->parent - 1;
653 spin_unlock_irqrestore(c->reglock, flags);
654 return v;
655}
656
657/* fg0-2 and fg4-6 share a "scale"-bit. With this bit cleared, the
658 * dividers behave exactly as on previous models (dividers are multiples
659 * of 2); with the bit set, dividers are multiples of 1, halving their
660 * range, but making them also much more flexible.
661 */
662static int alchemy_clk_fgv2_setr(struct clk_hw *hw, unsigned long rate,
663 unsigned long parent_rate)
664{
665 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
666 int sh = c->shift + 2;
667 unsigned long div, v, flags, ret;
668
669 if (!rate || !parent_rate || rate > parent_rate)
670 return -EINVAL;
671
672 v = alchemy_rdsys(c->reg) & (1 << 30); /* test "scale" bit */
673 ret = alchemy_calc_div(rate, parent_rate, v ? 1 : 2,
674 v ? 256 : 512, &div);
675
676 spin_lock_irqsave(c->reglock, flags);
677 v = alchemy_rdsys(c->reg);
678 v &= ~(0xff << sh);
679 v |= (div & 0xff) << sh;
680 alchemy_wrsys(v, c->reg);
681 spin_unlock_irqrestore(c->reglock, flags);
682
683 return 0;
684}
685
686static unsigned long alchemy_clk_fgv2_recalc(struct clk_hw *hw,
687 unsigned long parent_rate)
688{
689 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
690 int sh = c->shift + 2;
691 unsigned long v, t;
692
693 v = alchemy_rdsys(c->reg);
694 t = parent_rate / (((v >> sh) & 0xff) + 1);
695 if ((v & (1 << 30)) == 0) /* test scale bit */
696 t /= 2;
697
698 return t;
699}
700
701static int alchemy_clk_fgv2_detr(struct clk_hw *hw,
702 struct clk_rate_request *req)
703{
704 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
705 int scale, maxdiv;
706
707 if (alchemy_rdsys(c->reg) & (1 << 30)) {
708 scale = 1;
709 maxdiv = 256;
710 } else {
711 scale = 2;
712 maxdiv = 512;
713 }
714
715 return alchemy_clk_fgcs_detr(hw, req, scale, maxdiv);
716}
717
718/* Au1300 larger input mux, no separate disable bit, flexible divider */
719static struct clk_ops alchemy_clkops_fgenv2 = {
720 .recalc_rate = alchemy_clk_fgv2_recalc,
721 .determine_rate = alchemy_clk_fgv2_detr,
722 .set_rate = alchemy_clk_fgv2_setr,
723 .set_parent = alchemy_clk_fgv2_setp,
724 .get_parent = alchemy_clk_fgv2_getp,
725 .enable = alchemy_clk_fgv2_en,
726 .disable = alchemy_clk_fgv2_dis,
727 .is_enabled = alchemy_clk_fgv2_isen,
728};
729
730static const char * const alchemy_clk_fgv1_parents[] = {
731 ALCHEMY_CPU_CLK, ALCHEMY_AUXPLL_CLK
732};
733
734static const char * const alchemy_clk_fgv2_parents[] = {
735 ALCHEMY_AUXPLL2_CLK, ALCHEMY_CPU_CLK, ALCHEMY_AUXPLL_CLK
736};
737
738static const char * const alchemy_clk_fgen_names[] = {
739 ALCHEMY_FG0_CLK, ALCHEMY_FG1_CLK, ALCHEMY_FG2_CLK,
740 ALCHEMY_FG3_CLK, ALCHEMY_FG4_CLK, ALCHEMY_FG5_CLK };
741
742static int __init alchemy_clk_init_fgens(int ctype)
743{
744 struct clk *c;
745 struct clk_init_data id;
746 struct alchemy_fgcs_clk *a;
747 unsigned long v;
748 int i, ret;
749
750 switch (ctype) {
751 case ALCHEMY_CPU_AU1000...ALCHEMY_CPU_AU1200:
752 id.ops = &alchemy_clkops_fgenv1;
753 id.parent_names = alchemy_clk_fgv1_parents;
754 id.num_parents = 2;
755 break;
756 case ALCHEMY_CPU_AU1300:
757 id.ops = &alchemy_clkops_fgenv2;
758 id.parent_names = alchemy_clk_fgv2_parents;
759 id.num_parents = 3;
760 break;
761 default:
762 return -ENODEV;
763 }
764 id.flags = CLK_SET_RATE_PARENT | CLK_GET_RATE_NOCACHE;
765
766 a = kzalloc((sizeof(*a)) * 6, GFP_KERNEL);
767 if (!a)
768 return -ENOMEM;
769
770 spin_lock_init(&alchemy_clk_fg0_lock);
771 spin_lock_init(&alchemy_clk_fg1_lock);
772 ret = 0;
773 for (i = 0; i < 6; i++) {
774 id.name = alchemy_clk_fgen_names[i];
775 a->shift = 10 * (i < 3 ? i : i - 3);
776 if (i > 2) {
777 a->reg = AU1000_SYS_FREQCTRL1;
778 a->reglock = &alchemy_clk_fg1_lock;
779 } else {
780 a->reg = AU1000_SYS_FREQCTRL0;
781 a->reglock = &alchemy_clk_fg0_lock;
782 }
783
784 /* default to first parent if bootloader has set
785 * the mux to disabled state.
786 */
787 if (ctype == ALCHEMY_CPU_AU1300) {
788 v = alchemy_rdsys(a->reg);
789 a->parent = (v >> a->shift) & 3;
790 if (!a->parent) {
791 a->parent = 1;
792 a->isen = 0;
793 } else
794 a->isen = 1;
795 }
796
797 a->hw.init = &id;
798 c = clk_register(NULL, &a->hw);
799 if (IS_ERR(c))
800 ret++;
801 else
802 clk_register_clkdev(c, id.name, NULL);
803 a++;
804 }
805
806 return ret;
807}
808
809/* internal sources muxes *********************************************/
810
811static int alchemy_clk_csrc_isen(struct clk_hw *hw)
812{
813 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
814 unsigned long v = alchemy_rdsys(c->reg);
815
816 return (((v >> c->shift) >> 2) & 7) != 0;
817}
818
819static void __alchemy_clk_csrc_en(struct alchemy_fgcs_clk *c)
820{
821 unsigned long v = alchemy_rdsys(c->reg);
822
823 v &= ~((7 << 2) << c->shift);
824 v |= ((c->parent & 7) << 2) << c->shift;
825 alchemy_wrsys(v, c->reg);
826 c->isen = 1;
827}
828
829static int alchemy_clk_csrc_en(struct clk_hw *hw)
830{
831 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
832 unsigned long flags;
833
834 /* enable by setting the previous parent clock */
835 spin_lock_irqsave(c->reglock, flags);
836 __alchemy_clk_csrc_en(c);
837 spin_unlock_irqrestore(c->reglock, flags);
838
839 return 0;
840}
841
842static void alchemy_clk_csrc_dis(struct clk_hw *hw)
843{
844 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
845 unsigned long v, flags;
846
847 spin_lock_irqsave(c->reglock, flags);
848 v = alchemy_rdsys(c->reg);
849 v &= ~((3 << 2) << c->shift); /* mux to "disabled" state */
850 alchemy_wrsys(v, c->reg);
851 c->isen = 0;
852 spin_unlock_irqrestore(c->reglock, flags);
853}
854
855static int alchemy_clk_csrc_setp(struct clk_hw *hw, u8 index)
856{
857 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
858 unsigned long flags;
859
860 spin_lock_irqsave(c->reglock, flags);
861 c->parent = index + 1; /* value to write to register */
862 if (c->isen)
863 __alchemy_clk_csrc_en(c);
864 spin_unlock_irqrestore(c->reglock, flags);
865
866 return 0;
867}
868
869static u8 alchemy_clk_csrc_getp(struct clk_hw *hw)
870{
871 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
872
873 return c->parent - 1;
874}
875
876static unsigned long alchemy_clk_csrc_recalc(struct clk_hw *hw,
877 unsigned long parent_rate)
878{
879 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
880 unsigned long v = (alchemy_rdsys(c->reg) >> c->shift) & 3;
881
882 return parent_rate / c->dt[v];
883}
884
885static int alchemy_clk_csrc_setr(struct clk_hw *hw, unsigned long rate,
886 unsigned long parent_rate)
887{
888 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
889 unsigned long d, v, flags;
890 int i;
891
892 if (!rate || !parent_rate || rate > parent_rate)
893 return -EINVAL;
894
895 d = (parent_rate + (rate / 2)) / rate;
896 if (d > 4)
897 return -EINVAL;
898 if ((d == 3) && (c->dt[2] != 3))
899 d = 4;
900
901 for (i = 0; i < 4; i++)
902 if (c->dt[i] == d)
903 break;
904
905 if (i >= 4)
906 return -EINVAL; /* oops */
907
908 spin_lock_irqsave(c->reglock, flags);
909 v = alchemy_rdsys(c->reg);
910 v &= ~(3 << c->shift);
911 v |= (i & 3) << c->shift;
912 alchemy_wrsys(v, c->reg);
913 spin_unlock_irqrestore(c->reglock, flags);
914
915 return 0;
916}
917
918static int alchemy_clk_csrc_detr(struct clk_hw *hw,
919 struct clk_rate_request *req)
920{
921 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
922 int scale = c->dt[2] == 3 ? 1 : 2; /* au1300 check */
923
924 return alchemy_clk_fgcs_detr(hw, req, scale, 4);
925}
926
927static struct clk_ops alchemy_clkops_csrc = {
928 .recalc_rate = alchemy_clk_csrc_recalc,
929 .determine_rate = alchemy_clk_csrc_detr,
930 .set_rate = alchemy_clk_csrc_setr,
931 .set_parent = alchemy_clk_csrc_setp,
932 .get_parent = alchemy_clk_csrc_getp,
933 .enable = alchemy_clk_csrc_en,
934 .disable = alchemy_clk_csrc_dis,
935 .is_enabled = alchemy_clk_csrc_isen,
936};
937
938static const char * const alchemy_clk_csrc_parents[] = {
939 /* disabled at index 0 */ ALCHEMY_AUXPLL_CLK,
940 ALCHEMY_FG0_CLK, ALCHEMY_FG1_CLK, ALCHEMY_FG2_CLK,
941 ALCHEMY_FG3_CLK, ALCHEMY_FG4_CLK, ALCHEMY_FG5_CLK
942};
943
944/* divider tables */
945static int alchemy_csrc_dt1[] = { 1, 4, 1, 2 }; /* rest */
946static int alchemy_csrc_dt2[] = { 1, 4, 3, 2 }; /* Au1300 */
947
948static int __init alchemy_clk_setup_imux(int ctype)
949{
950 struct alchemy_fgcs_clk *a;
951 const char * const *names;
952 struct clk_init_data id;
953 unsigned long v;
954 int i, ret, *dt;
955 struct clk *c;
956
957 id.ops = &alchemy_clkops_csrc;
958 id.parent_names = alchemy_clk_csrc_parents;
959 id.num_parents = 7;
960 id.flags = CLK_SET_RATE_PARENT | CLK_GET_RATE_NOCACHE;
961
962 dt = alchemy_csrc_dt1;
963 switch (ctype) {
964 case ALCHEMY_CPU_AU1000:
965 names = alchemy_au1000_intclknames;
966 break;
967 case ALCHEMY_CPU_AU1500:
968 names = alchemy_au1500_intclknames;
969 break;
970 case ALCHEMY_CPU_AU1100:
971 names = alchemy_au1100_intclknames;
972 break;
973 case ALCHEMY_CPU_AU1550:
974 names = alchemy_au1550_intclknames;
975 break;
976 case ALCHEMY_CPU_AU1200:
977 names = alchemy_au1200_intclknames;
978 break;
979 case ALCHEMY_CPU_AU1300:
980 dt = alchemy_csrc_dt2;
981 names = alchemy_au1300_intclknames;
982 break;
983 default:
984 return -ENODEV;
985 }
986
987 a = kzalloc((sizeof(*a)) * 6, GFP_KERNEL);
988 if (!a)
989 return -ENOMEM;
990
991 spin_lock_init(&alchemy_clk_csrc_lock);
992 ret = 0;
993
994 for (i = 0; i < 6; i++) {
995 id.name = names[i];
996 if (!id.name)
997 goto next;
998
999 a->shift = i * 5;
1000 a->reg = AU1000_SYS_CLKSRC;
1001 a->reglock = &alchemy_clk_csrc_lock;
1002 a->dt = dt;
1003
1004 /* default to first parent clock if mux is initially
1005 * set to disabled state.
1006 */
1007 v = alchemy_rdsys(a->reg);
1008 a->parent = ((v >> a->shift) >> 2) & 7;
1009 if (!a->parent) {
1010 a->parent = 1;
1011 a->isen = 0;
1012 } else
1013 a->isen = 1;
1014
1015 a->hw.init = &id;
1016 c = clk_register(NULL, &a->hw);
1017 if (IS_ERR(c))
1018 ret++;
1019 else
1020 clk_register_clkdev(c, id.name, NULL);
1021next:
1022 a++;
1023 }
1024
1025 return ret;
1026}
1027
1028
1029/**********************************************************************/
1030
1031
1032#define ERRCK(x) \
1033 if (IS_ERR(x)) { \
1034 ret = PTR_ERR(x); \
1035 goto out; \
1036 }
1037
1038static int __init alchemy_clk_init(void)
1039{
1040 int ctype = alchemy_get_cputype(), ret, i;
1041 struct clk_aliastable *t = alchemy_clk_aliases;
1042 struct clk *c;
1043
1044 /* Root of the Alchemy clock tree: external 12MHz crystal osc */
1045 c = clk_register_fixed_rate(NULL, ALCHEMY_ROOT_CLK, NULL,
1046 CLK_IS_ROOT,
1047 ALCHEMY_ROOTCLK_RATE);
1048 ERRCK(c)
1049
1050 /* CPU core clock */
1051 c = alchemy_clk_setup_cpu(ALCHEMY_ROOT_CLK, ctype);
1052 ERRCK(c)
1053
1054 /* AUXPLLs: max 1GHz on Au1300, 748MHz on older models */
1055 i = (ctype == ALCHEMY_CPU_AU1300) ? 84 : 63;
1056 c = alchemy_clk_setup_aux(ALCHEMY_ROOT_CLK, ALCHEMY_AUXPLL_CLK,
1057 i, AU1000_SYS_AUXPLL);
1058 ERRCK(c)
1059
1060 if (ctype == ALCHEMY_CPU_AU1300) {
1061 c = alchemy_clk_setup_aux(ALCHEMY_ROOT_CLK,
1062 ALCHEMY_AUXPLL2_CLK, i,
1063 AU1300_SYS_AUXPLL2);
1064 ERRCK(c)
1065 }
1066
1067 /* sysbus clock: cpu core clock divided by 2, 3 or 4 */
1068 c = alchemy_clk_setup_sysbus(ALCHEMY_CPU_CLK);
1069 ERRCK(c)
1070
1071 /* peripheral clock: runs at half rate of sysbus clk */
1072 c = alchemy_clk_setup_periph(ALCHEMY_SYSBUS_CLK);
1073 ERRCK(c)
1074
1075 /* SDR/DDR memory clock */
1076 c = alchemy_clk_setup_mem(ALCHEMY_SYSBUS_CLK, ctype);
1077 ERRCK(c)
1078
1079 /* L/RCLK: external static bus clock for synchronous mode */
1080 c = alchemy_clk_setup_lrclk(ALCHEMY_PERIPH_CLK, ctype);
1081 ERRCK(c)
1082
1083 /* Frequency dividers 0-5 */
1084 ret = alchemy_clk_init_fgens(ctype);
1085 if (ret) {
1086 ret = -ENODEV;
1087 goto out;
1088 }
1089
1090 /* diving muxes for internal sources */
1091 ret = alchemy_clk_setup_imux(ctype);
1092 if (ret) {
1093 ret = -ENODEV;
1094 goto out;
1095 }
1096
1097 /* set up aliases drivers might look for */
1098 while (t->base) {
1099 if (t->cputype == ctype)
1100 clk_add_alias(t->alias, NULL, t->base, NULL);
1101 t++;
1102 }
1103
1104 pr_info("Alchemy clocktree installed\n");
1105 return 0;
1106
1107out:
1108 return ret;
1109}
1110postcore_initcall(alchemy_clk_init);
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Alchemy clocks.
4 *
5 * Exposes all configurable internal clock sources to the clk framework.
6 *
7 * We have:
8 * - Root source, usually 12MHz supplied by an external crystal
9 * - 3 PLLs which generate multiples of root rate [AUX, CPU, AUX2]
10 *
11 * Dividers:
12 * - 6 clock dividers with:
13 * * selectable source [one of the PLLs],
14 * * output divided between [2 .. 512 in steps of 2] (!Au1300)
15 * or [1 .. 256 in steps of 1] (Au1300),
16 * * can be enabled individually.
17 *
18 * - up to 6 "internal" (fixed) consumers which:
19 * * take either AUXPLL or one of the above 6 dividers as input,
20 * * divide this input by 1, 2, or 4 (and 3 on Au1300).
21 * * can be disabled separately.
22 *
23 * Misc clocks:
24 * - sysbus clock: CPU core clock (CPUPLL) divided by 2, 3 or 4.
25 * depends on board design and should be set by bootloader, read-only.
26 * - peripheral clock: half the rate of sysbus clock, source for a lot
27 * of peripheral blocks, read-only.
28 * - memory clock: clk rate to main memory chips, depends on board
29 * design and is read-only,
30 * - lrclk: the static bus clock signal for synchronous operation.
31 * depends on board design, must be set by bootloader,
32 * but may be required to correctly configure devices attached to
33 * the static bus. The Au1000/1500/1100 manuals call it LCLK, on
34 * later models it's called RCLK.
35 */
36
37#include <linux/init.h>
38#include <linux/io.h>
39#include <linux/clk.h>
40#include <linux/clk-provider.h>
41#include <linux/clkdev.h>
42#include <linux/slab.h>
43#include <linux/spinlock.h>
44#include <linux/types.h>
45#include <asm/mach-au1x00/au1000.h>
46
47/* Base clock: 12MHz is the default in all databooks, and I haven't
48 * found any board yet which uses a different rate.
49 */
50#define ALCHEMY_ROOTCLK_RATE 12000000
51
52/*
53 * the internal sources which can be driven by the PLLs and dividers.
54 * Names taken from the databooks, refer to them for more information,
55 * especially which ones are share a clock line.
56 */
57static const char * const alchemy_au1300_intclknames[] = {
58 "lcd_intclk", "gpemgp_clk", "maempe_clk", "maebsa_clk",
59 "EXTCLK0", "EXTCLK1"
60};
61
62static const char * const alchemy_au1200_intclknames[] = {
63 "lcd_intclk", NULL, NULL, NULL, "EXTCLK0", "EXTCLK1"
64};
65
66static const char * const alchemy_au1550_intclknames[] = {
67 "usb_clk", "psc0_intclk", "psc1_intclk", "pci_clko",
68 "EXTCLK0", "EXTCLK1"
69};
70
71static const char * const alchemy_au1100_intclknames[] = {
72 "usb_clk", "lcd_intclk", NULL, "i2s_clk", "EXTCLK0", "EXTCLK1"
73};
74
75static const char * const alchemy_au1500_intclknames[] = {
76 NULL, "usbd_clk", "usbh_clk", "pci_clko", "EXTCLK0", "EXTCLK1"
77};
78
79static const char * const alchemy_au1000_intclknames[] = {
80 "irda_clk", "usbd_clk", "usbh_clk", "i2s_clk", "EXTCLK0",
81 "EXTCLK1"
82};
83
84/* aliases for a few on-chip sources which are either shared
85 * or have gone through name changes.
86 */
87static struct clk_aliastable {
88 char *alias;
89 char *base;
90 int cputype;
91} alchemy_clk_aliases[] __initdata = {
92 { "usbh_clk", "usb_clk", ALCHEMY_CPU_AU1100 },
93 { "usbd_clk", "usb_clk", ALCHEMY_CPU_AU1100 },
94 { "irda_clk", "usb_clk", ALCHEMY_CPU_AU1100 },
95 { "usbh_clk", "usb_clk", ALCHEMY_CPU_AU1550 },
96 { "usbd_clk", "usb_clk", ALCHEMY_CPU_AU1550 },
97 { "psc2_intclk", "usb_clk", ALCHEMY_CPU_AU1550 },
98 { "psc3_intclk", "EXTCLK0", ALCHEMY_CPU_AU1550 },
99 { "psc0_intclk", "EXTCLK0", ALCHEMY_CPU_AU1200 },
100 { "psc1_intclk", "EXTCLK1", ALCHEMY_CPU_AU1200 },
101 { "psc0_intclk", "EXTCLK0", ALCHEMY_CPU_AU1300 },
102 { "psc2_intclk", "EXTCLK0", ALCHEMY_CPU_AU1300 },
103 { "psc1_intclk", "EXTCLK1", ALCHEMY_CPU_AU1300 },
104 { "psc3_intclk", "EXTCLK1", ALCHEMY_CPU_AU1300 },
105
106 { NULL, NULL, 0 },
107};
108
109#define IOMEM(x) ((void __iomem *)(KSEG1ADDR(CPHYSADDR(x))))
110
111/* access locks to SYS_FREQCTRL0/1 and SYS_CLKSRC registers */
112static spinlock_t alchemy_clk_fg0_lock;
113static spinlock_t alchemy_clk_fg1_lock;
114static spinlock_t alchemy_clk_csrc_lock;
115
116/* CPU Core clock *****************************************************/
117
118static unsigned long alchemy_clk_cpu_recalc(struct clk_hw *hw,
119 unsigned long parent_rate)
120{
121 unsigned long t;
122
123 /*
124 * On early Au1000, sys_cpupll was write-only. Since these
125 * silicon versions of Au1000 are not sold, we don't bend
126 * over backwards trying to determine the frequency.
127 */
128 if (unlikely(au1xxx_cpu_has_pll_wo()))
129 t = 396000000;
130 else {
131 t = alchemy_rdsys(AU1000_SYS_CPUPLL) & 0x7f;
132 if (alchemy_get_cputype() < ALCHEMY_CPU_AU1300)
133 t &= 0x3f;
134 t *= parent_rate;
135 }
136
137 return t;
138}
139
140void __init alchemy_set_lpj(void)
141{
142 preset_lpj = alchemy_clk_cpu_recalc(NULL, ALCHEMY_ROOTCLK_RATE);
143 preset_lpj /= 2 * HZ;
144}
145
146static const struct clk_ops alchemy_clkops_cpu = {
147 .recalc_rate = alchemy_clk_cpu_recalc,
148};
149
150static struct clk __init *alchemy_clk_setup_cpu(const char *parent_name,
151 int ctype)
152{
153 struct clk_init_data id;
154 struct clk_hw *h;
155
156 h = kzalloc(sizeof(*h), GFP_KERNEL);
157 if (!h)
158 return ERR_PTR(-ENOMEM);
159
160 id.name = ALCHEMY_CPU_CLK;
161 id.parent_names = &parent_name;
162 id.num_parents = 1;
163 id.flags = CLK_IS_BASIC;
164 id.ops = &alchemy_clkops_cpu;
165 h->init = &id;
166
167 return clk_register(NULL, h);
168}
169
170/* AUXPLLs ************************************************************/
171
172struct alchemy_auxpll_clk {
173 struct clk_hw hw;
174 unsigned long reg; /* au1300 has also AUXPLL2 */
175 int maxmult; /* max multiplier */
176};
177#define to_auxpll_clk(x) container_of(x, struct alchemy_auxpll_clk, hw)
178
179static unsigned long alchemy_clk_aux_recalc(struct clk_hw *hw,
180 unsigned long parent_rate)
181{
182 struct alchemy_auxpll_clk *a = to_auxpll_clk(hw);
183
184 return (alchemy_rdsys(a->reg) & 0xff) * parent_rate;
185}
186
187static int alchemy_clk_aux_setr(struct clk_hw *hw,
188 unsigned long rate,
189 unsigned long parent_rate)
190{
191 struct alchemy_auxpll_clk *a = to_auxpll_clk(hw);
192 unsigned long d = rate;
193
194 if (rate)
195 d /= parent_rate;
196 else
197 d = 0;
198
199 /* minimum is 84MHz, max is 756-1032 depending on variant */
200 if (((d < 7) && (d != 0)) || (d > a->maxmult))
201 return -EINVAL;
202
203 alchemy_wrsys(d, a->reg);
204 return 0;
205}
206
207static long alchemy_clk_aux_roundr(struct clk_hw *hw,
208 unsigned long rate,
209 unsigned long *parent_rate)
210{
211 struct alchemy_auxpll_clk *a = to_auxpll_clk(hw);
212 unsigned long mult;
213
214 if (!rate || !*parent_rate)
215 return 0;
216
217 mult = rate / (*parent_rate);
218
219 if (mult && (mult < 7))
220 mult = 7;
221 if (mult > a->maxmult)
222 mult = a->maxmult;
223
224 return (*parent_rate) * mult;
225}
226
227static const struct clk_ops alchemy_clkops_aux = {
228 .recalc_rate = alchemy_clk_aux_recalc,
229 .set_rate = alchemy_clk_aux_setr,
230 .round_rate = alchemy_clk_aux_roundr,
231};
232
233static struct clk __init *alchemy_clk_setup_aux(const char *parent_name,
234 char *name, int maxmult,
235 unsigned long reg)
236{
237 struct clk_init_data id;
238 struct clk *c;
239 struct alchemy_auxpll_clk *a;
240
241 a = kzalloc(sizeof(*a), GFP_KERNEL);
242 if (!a)
243 return ERR_PTR(-ENOMEM);
244
245 id.name = name;
246 id.parent_names = &parent_name;
247 id.num_parents = 1;
248 id.flags = CLK_GET_RATE_NOCACHE;
249 id.ops = &alchemy_clkops_aux;
250
251 a->reg = reg;
252 a->maxmult = maxmult;
253 a->hw.init = &id;
254
255 c = clk_register(NULL, &a->hw);
256 if (!IS_ERR(c))
257 clk_register_clkdev(c, name, NULL);
258 else
259 kfree(a);
260
261 return c;
262}
263
264/* sysbus_clk *********************************************************/
265
266static struct clk __init *alchemy_clk_setup_sysbus(const char *pn)
267{
268 unsigned long v = (alchemy_rdsys(AU1000_SYS_POWERCTRL) & 3) + 2;
269 struct clk *c;
270
271 c = clk_register_fixed_factor(NULL, ALCHEMY_SYSBUS_CLK,
272 pn, 0, 1, v);
273 if (!IS_ERR(c))
274 clk_register_clkdev(c, ALCHEMY_SYSBUS_CLK, NULL);
275 return c;
276}
277
278/* Peripheral Clock ***************************************************/
279
280static struct clk __init *alchemy_clk_setup_periph(const char *pn)
281{
282 /* Peripheral clock runs at half the rate of sysbus clk */
283 struct clk *c;
284
285 c = clk_register_fixed_factor(NULL, ALCHEMY_PERIPH_CLK,
286 pn, 0, 1, 2);
287 if (!IS_ERR(c))
288 clk_register_clkdev(c, ALCHEMY_PERIPH_CLK, NULL);
289 return c;
290}
291
292/* mem clock **********************************************************/
293
294static struct clk __init *alchemy_clk_setup_mem(const char *pn, int ct)
295{
296 void __iomem *addr = IOMEM(AU1000_MEM_PHYS_ADDR);
297 unsigned long v;
298 struct clk *c;
299 int div;
300
301 switch (ct) {
302 case ALCHEMY_CPU_AU1550:
303 case ALCHEMY_CPU_AU1200:
304 v = __raw_readl(addr + AU1550_MEM_SDCONFIGB);
305 div = (v & (1 << 15)) ? 1 : 2;
306 break;
307 case ALCHEMY_CPU_AU1300:
308 v = __raw_readl(addr + AU1550_MEM_SDCONFIGB);
309 div = (v & (1 << 31)) ? 1 : 2;
310 break;
311 case ALCHEMY_CPU_AU1000:
312 case ALCHEMY_CPU_AU1500:
313 case ALCHEMY_CPU_AU1100:
314 default:
315 div = 2;
316 break;
317 }
318
319 c = clk_register_fixed_factor(NULL, ALCHEMY_MEM_CLK, pn,
320 0, 1, div);
321 if (!IS_ERR(c))
322 clk_register_clkdev(c, ALCHEMY_MEM_CLK, NULL);
323 return c;
324}
325
326/* lrclk: external synchronous static bus clock ***********************/
327
328static struct clk __init *alchemy_clk_setup_lrclk(const char *pn, int t)
329{
330 /* Au1000, Au1500: MEM_STCFG0[11]: If bit is set, lrclk=pclk/5,
331 * otherwise lrclk=pclk/4.
332 * All other variants: MEM_STCFG0[15:13] = divisor.
333 * L/RCLK = periph_clk / (divisor + 1)
334 * On Au1000, Au1500, Au1100 it's called LCLK,
335 * on later models it's called RCLK, but it's the same thing.
336 */
337 struct clk *c;
338 unsigned long v = alchemy_rdsmem(AU1000_MEM_STCFG0);
339
340 switch (t) {
341 case ALCHEMY_CPU_AU1000:
342 case ALCHEMY_CPU_AU1500:
343 v = 4 + ((v >> 11) & 1);
344 break;
345 default: /* all other models */
346 v = ((v >> 13) & 7) + 1;
347 }
348 c = clk_register_fixed_factor(NULL, ALCHEMY_LR_CLK,
349 pn, 0, 1, v);
350 if (!IS_ERR(c))
351 clk_register_clkdev(c, ALCHEMY_LR_CLK, NULL);
352 return c;
353}
354
355/* Clock dividers and muxes *******************************************/
356
357/* data for fgen and csrc mux-dividers */
358struct alchemy_fgcs_clk {
359 struct clk_hw hw;
360 spinlock_t *reglock; /* register lock */
361 unsigned long reg; /* SYS_FREQCTRL0/1 */
362 int shift; /* offset in register */
363 int parent; /* parent before disable [Au1300] */
364 int isen; /* is it enabled? */
365 int *dt; /* dividertable for csrc */
366};
367#define to_fgcs_clk(x) container_of(x, struct alchemy_fgcs_clk, hw)
368
369static long alchemy_calc_div(unsigned long rate, unsigned long prate,
370 int scale, int maxdiv, unsigned long *rv)
371{
372 long div1, div2;
373
374 div1 = prate / rate;
375 if ((prate / div1) > rate)
376 div1++;
377
378 if (scale == 2) { /* only div-by-multiple-of-2 possible */
379 if (div1 & 1)
380 div1++; /* stay <=prate */
381 }
382
383 div2 = (div1 / scale) - 1; /* value to write to register */
384
385 if (div2 > maxdiv)
386 div2 = maxdiv;
387 if (rv)
388 *rv = div2;
389
390 div1 = ((div2 + 1) * scale);
391 return div1;
392}
393
394static int alchemy_clk_fgcs_detr(struct clk_hw *hw,
395 struct clk_rate_request *req,
396 int scale, int maxdiv)
397{
398 struct clk_hw *pc, *bpc, *free;
399 long tdv, tpr, pr, nr, br, bpr, diff, lastdiff;
400 int j;
401
402 lastdiff = INT_MAX;
403 bpr = 0;
404 bpc = NULL;
405 br = -EINVAL;
406 free = NULL;
407
408 /* look at the rates each enabled parent supplies and select
409 * the one that gets closest to but not over the requested rate.
410 */
411 for (j = 0; j < 7; j++) {
412 pc = clk_hw_get_parent_by_index(hw, j);
413 if (!pc)
414 break;
415
416 /* if this parent is currently unused, remember it.
417 * XXX: we would actually want clk_has_active_children()
418 * but this is a good-enough approximation for now.
419 */
420 if (!clk_hw_is_prepared(pc)) {
421 if (!free)
422 free = pc;
423 }
424
425 pr = clk_hw_get_rate(pc);
426 if (pr < req->rate)
427 continue;
428
429 /* what can hardware actually provide */
430 tdv = alchemy_calc_div(req->rate, pr, scale, maxdiv, NULL);
431 nr = pr / tdv;
432 diff = req->rate - nr;
433 if (nr > req->rate)
434 continue;
435
436 if (diff < lastdiff) {
437 lastdiff = diff;
438 bpr = pr;
439 bpc = pc;
440 br = nr;
441 }
442 if (diff == 0)
443 break;
444 }
445
446 /* if we couldn't get the exact rate we wanted from the enabled
447 * parents, maybe we can tell an available disabled/inactive one
448 * to give us a rate we can divide down to the requested rate.
449 */
450 if (lastdiff && free) {
451 for (j = (maxdiv == 4) ? 1 : scale; j <= maxdiv; j += scale) {
452 tpr = req->rate * j;
453 if (tpr < 0)
454 break;
455 pr = clk_hw_round_rate(free, tpr);
456
457 tdv = alchemy_calc_div(req->rate, pr, scale, maxdiv,
458 NULL);
459 nr = pr / tdv;
460 diff = req->rate - nr;
461 if (nr > req->rate)
462 continue;
463 if (diff < lastdiff) {
464 lastdiff = diff;
465 bpr = pr;
466 bpc = free;
467 br = nr;
468 }
469 if (diff == 0)
470 break;
471 }
472 }
473
474 if (br < 0)
475 return br;
476
477 req->best_parent_rate = bpr;
478 req->best_parent_hw = bpc;
479 req->rate = br;
480
481 return 0;
482}
483
484static int alchemy_clk_fgv1_en(struct clk_hw *hw)
485{
486 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
487 unsigned long v, flags;
488
489 spin_lock_irqsave(c->reglock, flags);
490 v = alchemy_rdsys(c->reg);
491 v |= (1 << 1) << c->shift;
492 alchemy_wrsys(v, c->reg);
493 spin_unlock_irqrestore(c->reglock, flags);
494
495 return 0;
496}
497
498static int alchemy_clk_fgv1_isen(struct clk_hw *hw)
499{
500 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
501 unsigned long v = alchemy_rdsys(c->reg) >> (c->shift + 1);
502
503 return v & 1;
504}
505
506static void alchemy_clk_fgv1_dis(struct clk_hw *hw)
507{
508 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
509 unsigned long v, flags;
510
511 spin_lock_irqsave(c->reglock, flags);
512 v = alchemy_rdsys(c->reg);
513 v &= ~((1 << 1) << c->shift);
514 alchemy_wrsys(v, c->reg);
515 spin_unlock_irqrestore(c->reglock, flags);
516}
517
518static int alchemy_clk_fgv1_setp(struct clk_hw *hw, u8 index)
519{
520 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
521 unsigned long v, flags;
522
523 spin_lock_irqsave(c->reglock, flags);
524 v = alchemy_rdsys(c->reg);
525 if (index)
526 v |= (1 << c->shift);
527 else
528 v &= ~(1 << c->shift);
529 alchemy_wrsys(v, c->reg);
530 spin_unlock_irqrestore(c->reglock, flags);
531
532 return 0;
533}
534
535static u8 alchemy_clk_fgv1_getp(struct clk_hw *hw)
536{
537 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
538
539 return (alchemy_rdsys(c->reg) >> c->shift) & 1;
540}
541
542static int alchemy_clk_fgv1_setr(struct clk_hw *hw, unsigned long rate,
543 unsigned long parent_rate)
544{
545 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
546 unsigned long div, v, flags, ret;
547 int sh = c->shift + 2;
548
549 if (!rate || !parent_rate || rate > (parent_rate / 2))
550 return -EINVAL;
551 ret = alchemy_calc_div(rate, parent_rate, 2, 512, &div);
552 spin_lock_irqsave(c->reglock, flags);
553 v = alchemy_rdsys(c->reg);
554 v &= ~(0xff << sh);
555 v |= div << sh;
556 alchemy_wrsys(v, c->reg);
557 spin_unlock_irqrestore(c->reglock, flags);
558
559 return 0;
560}
561
562static unsigned long alchemy_clk_fgv1_recalc(struct clk_hw *hw,
563 unsigned long parent_rate)
564{
565 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
566 unsigned long v = alchemy_rdsys(c->reg) >> (c->shift + 2);
567
568 v = ((v & 0xff) + 1) * 2;
569 return parent_rate / v;
570}
571
572static int alchemy_clk_fgv1_detr(struct clk_hw *hw,
573 struct clk_rate_request *req)
574{
575 return alchemy_clk_fgcs_detr(hw, req, 2, 512);
576}
577
578/* Au1000, Au1100, Au15x0, Au12x0 */
579static const struct clk_ops alchemy_clkops_fgenv1 = {
580 .recalc_rate = alchemy_clk_fgv1_recalc,
581 .determine_rate = alchemy_clk_fgv1_detr,
582 .set_rate = alchemy_clk_fgv1_setr,
583 .set_parent = alchemy_clk_fgv1_setp,
584 .get_parent = alchemy_clk_fgv1_getp,
585 .enable = alchemy_clk_fgv1_en,
586 .disable = alchemy_clk_fgv1_dis,
587 .is_enabled = alchemy_clk_fgv1_isen,
588};
589
590static void __alchemy_clk_fgv2_en(struct alchemy_fgcs_clk *c)
591{
592 unsigned long v = alchemy_rdsys(c->reg);
593
594 v &= ~(3 << c->shift);
595 v |= (c->parent & 3) << c->shift;
596 alchemy_wrsys(v, c->reg);
597 c->isen = 1;
598}
599
600static int alchemy_clk_fgv2_en(struct clk_hw *hw)
601{
602 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
603 unsigned long flags;
604
605 /* enable by setting the previous parent clock */
606 spin_lock_irqsave(c->reglock, flags);
607 __alchemy_clk_fgv2_en(c);
608 spin_unlock_irqrestore(c->reglock, flags);
609
610 return 0;
611}
612
613static int alchemy_clk_fgv2_isen(struct clk_hw *hw)
614{
615 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
616
617 return ((alchemy_rdsys(c->reg) >> c->shift) & 3) != 0;
618}
619
620static void alchemy_clk_fgv2_dis(struct clk_hw *hw)
621{
622 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
623 unsigned long v, flags;
624
625 spin_lock_irqsave(c->reglock, flags);
626 v = alchemy_rdsys(c->reg);
627 v &= ~(3 << c->shift); /* set input mux to "disabled" state */
628 alchemy_wrsys(v, c->reg);
629 c->isen = 0;
630 spin_unlock_irqrestore(c->reglock, flags);
631}
632
633static int alchemy_clk_fgv2_setp(struct clk_hw *hw, u8 index)
634{
635 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
636 unsigned long flags;
637
638 spin_lock_irqsave(c->reglock, flags);
639 c->parent = index + 1; /* value to write to register */
640 if (c->isen)
641 __alchemy_clk_fgv2_en(c);
642 spin_unlock_irqrestore(c->reglock, flags);
643
644 return 0;
645}
646
647static u8 alchemy_clk_fgv2_getp(struct clk_hw *hw)
648{
649 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
650 unsigned long flags, v;
651
652 spin_lock_irqsave(c->reglock, flags);
653 v = c->parent - 1;
654 spin_unlock_irqrestore(c->reglock, flags);
655 return v;
656}
657
658/* fg0-2 and fg4-6 share a "scale"-bit. With this bit cleared, the
659 * dividers behave exactly as on previous models (dividers are multiples
660 * of 2); with the bit set, dividers are multiples of 1, halving their
661 * range, but making them also much more flexible.
662 */
663static int alchemy_clk_fgv2_setr(struct clk_hw *hw, unsigned long rate,
664 unsigned long parent_rate)
665{
666 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
667 int sh = c->shift + 2;
668 unsigned long div, v, flags, ret;
669
670 if (!rate || !parent_rate || rate > parent_rate)
671 return -EINVAL;
672
673 v = alchemy_rdsys(c->reg) & (1 << 30); /* test "scale" bit */
674 ret = alchemy_calc_div(rate, parent_rate, v ? 1 : 2,
675 v ? 256 : 512, &div);
676
677 spin_lock_irqsave(c->reglock, flags);
678 v = alchemy_rdsys(c->reg);
679 v &= ~(0xff << sh);
680 v |= (div & 0xff) << sh;
681 alchemy_wrsys(v, c->reg);
682 spin_unlock_irqrestore(c->reglock, flags);
683
684 return 0;
685}
686
687static unsigned long alchemy_clk_fgv2_recalc(struct clk_hw *hw,
688 unsigned long parent_rate)
689{
690 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
691 int sh = c->shift + 2;
692 unsigned long v, t;
693
694 v = alchemy_rdsys(c->reg);
695 t = parent_rate / (((v >> sh) & 0xff) + 1);
696 if ((v & (1 << 30)) == 0) /* test scale bit */
697 t /= 2;
698
699 return t;
700}
701
702static int alchemy_clk_fgv2_detr(struct clk_hw *hw,
703 struct clk_rate_request *req)
704{
705 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
706 int scale, maxdiv;
707
708 if (alchemy_rdsys(c->reg) & (1 << 30)) {
709 scale = 1;
710 maxdiv = 256;
711 } else {
712 scale = 2;
713 maxdiv = 512;
714 }
715
716 return alchemy_clk_fgcs_detr(hw, req, scale, maxdiv);
717}
718
719/* Au1300 larger input mux, no separate disable bit, flexible divider */
720static const struct clk_ops alchemy_clkops_fgenv2 = {
721 .recalc_rate = alchemy_clk_fgv2_recalc,
722 .determine_rate = alchemy_clk_fgv2_detr,
723 .set_rate = alchemy_clk_fgv2_setr,
724 .set_parent = alchemy_clk_fgv2_setp,
725 .get_parent = alchemy_clk_fgv2_getp,
726 .enable = alchemy_clk_fgv2_en,
727 .disable = alchemy_clk_fgv2_dis,
728 .is_enabled = alchemy_clk_fgv2_isen,
729};
730
731static const char * const alchemy_clk_fgv1_parents[] = {
732 ALCHEMY_CPU_CLK, ALCHEMY_AUXPLL_CLK
733};
734
735static const char * const alchemy_clk_fgv2_parents[] = {
736 ALCHEMY_AUXPLL2_CLK, ALCHEMY_CPU_CLK, ALCHEMY_AUXPLL_CLK
737};
738
739static const char * const alchemy_clk_fgen_names[] = {
740 ALCHEMY_FG0_CLK, ALCHEMY_FG1_CLK, ALCHEMY_FG2_CLK,
741 ALCHEMY_FG3_CLK, ALCHEMY_FG4_CLK, ALCHEMY_FG5_CLK };
742
743static int __init alchemy_clk_init_fgens(int ctype)
744{
745 struct clk *c;
746 struct clk_init_data id;
747 struct alchemy_fgcs_clk *a;
748 unsigned long v;
749 int i, ret;
750
751 switch (ctype) {
752 case ALCHEMY_CPU_AU1000...ALCHEMY_CPU_AU1200:
753 id.ops = &alchemy_clkops_fgenv1;
754 id.parent_names = alchemy_clk_fgv1_parents;
755 id.num_parents = 2;
756 break;
757 case ALCHEMY_CPU_AU1300:
758 id.ops = &alchemy_clkops_fgenv2;
759 id.parent_names = alchemy_clk_fgv2_parents;
760 id.num_parents = 3;
761 break;
762 default:
763 return -ENODEV;
764 }
765 id.flags = CLK_SET_RATE_PARENT | CLK_GET_RATE_NOCACHE;
766
767 a = kzalloc((sizeof(*a)) * 6, GFP_KERNEL);
768 if (!a)
769 return -ENOMEM;
770
771 spin_lock_init(&alchemy_clk_fg0_lock);
772 spin_lock_init(&alchemy_clk_fg1_lock);
773 ret = 0;
774 for (i = 0; i < 6; i++) {
775 id.name = alchemy_clk_fgen_names[i];
776 a->shift = 10 * (i < 3 ? i : i - 3);
777 if (i > 2) {
778 a->reg = AU1000_SYS_FREQCTRL1;
779 a->reglock = &alchemy_clk_fg1_lock;
780 } else {
781 a->reg = AU1000_SYS_FREQCTRL0;
782 a->reglock = &alchemy_clk_fg0_lock;
783 }
784
785 /* default to first parent if bootloader has set
786 * the mux to disabled state.
787 */
788 if (ctype == ALCHEMY_CPU_AU1300) {
789 v = alchemy_rdsys(a->reg);
790 a->parent = (v >> a->shift) & 3;
791 if (!a->parent) {
792 a->parent = 1;
793 a->isen = 0;
794 } else
795 a->isen = 1;
796 }
797
798 a->hw.init = &id;
799 c = clk_register(NULL, &a->hw);
800 if (IS_ERR(c))
801 ret++;
802 else
803 clk_register_clkdev(c, id.name, NULL);
804 a++;
805 }
806
807 return ret;
808}
809
810/* internal sources muxes *********************************************/
811
812static int alchemy_clk_csrc_isen(struct clk_hw *hw)
813{
814 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
815 unsigned long v = alchemy_rdsys(c->reg);
816
817 return (((v >> c->shift) >> 2) & 7) != 0;
818}
819
820static void __alchemy_clk_csrc_en(struct alchemy_fgcs_clk *c)
821{
822 unsigned long v = alchemy_rdsys(c->reg);
823
824 v &= ~((7 << 2) << c->shift);
825 v |= ((c->parent & 7) << 2) << c->shift;
826 alchemy_wrsys(v, c->reg);
827 c->isen = 1;
828}
829
830static int alchemy_clk_csrc_en(struct clk_hw *hw)
831{
832 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
833 unsigned long flags;
834
835 /* enable by setting the previous parent clock */
836 spin_lock_irqsave(c->reglock, flags);
837 __alchemy_clk_csrc_en(c);
838 spin_unlock_irqrestore(c->reglock, flags);
839
840 return 0;
841}
842
843static void alchemy_clk_csrc_dis(struct clk_hw *hw)
844{
845 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
846 unsigned long v, flags;
847
848 spin_lock_irqsave(c->reglock, flags);
849 v = alchemy_rdsys(c->reg);
850 v &= ~((3 << 2) << c->shift); /* mux to "disabled" state */
851 alchemy_wrsys(v, c->reg);
852 c->isen = 0;
853 spin_unlock_irqrestore(c->reglock, flags);
854}
855
856static int alchemy_clk_csrc_setp(struct clk_hw *hw, u8 index)
857{
858 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
859 unsigned long flags;
860
861 spin_lock_irqsave(c->reglock, flags);
862 c->parent = index + 1; /* value to write to register */
863 if (c->isen)
864 __alchemy_clk_csrc_en(c);
865 spin_unlock_irqrestore(c->reglock, flags);
866
867 return 0;
868}
869
870static u8 alchemy_clk_csrc_getp(struct clk_hw *hw)
871{
872 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
873
874 return c->parent - 1;
875}
876
877static unsigned long alchemy_clk_csrc_recalc(struct clk_hw *hw,
878 unsigned long parent_rate)
879{
880 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
881 unsigned long v = (alchemy_rdsys(c->reg) >> c->shift) & 3;
882
883 return parent_rate / c->dt[v];
884}
885
886static int alchemy_clk_csrc_setr(struct clk_hw *hw, unsigned long rate,
887 unsigned long parent_rate)
888{
889 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
890 unsigned long d, v, flags;
891 int i;
892
893 if (!rate || !parent_rate || rate > parent_rate)
894 return -EINVAL;
895
896 d = (parent_rate + (rate / 2)) / rate;
897 if (d > 4)
898 return -EINVAL;
899 if ((d == 3) && (c->dt[2] != 3))
900 d = 4;
901
902 for (i = 0; i < 4; i++)
903 if (c->dt[i] == d)
904 break;
905
906 if (i >= 4)
907 return -EINVAL; /* oops */
908
909 spin_lock_irqsave(c->reglock, flags);
910 v = alchemy_rdsys(c->reg);
911 v &= ~(3 << c->shift);
912 v |= (i & 3) << c->shift;
913 alchemy_wrsys(v, c->reg);
914 spin_unlock_irqrestore(c->reglock, flags);
915
916 return 0;
917}
918
919static int alchemy_clk_csrc_detr(struct clk_hw *hw,
920 struct clk_rate_request *req)
921{
922 struct alchemy_fgcs_clk *c = to_fgcs_clk(hw);
923 int scale = c->dt[2] == 3 ? 1 : 2; /* au1300 check */
924
925 return alchemy_clk_fgcs_detr(hw, req, scale, 4);
926}
927
928static const struct clk_ops alchemy_clkops_csrc = {
929 .recalc_rate = alchemy_clk_csrc_recalc,
930 .determine_rate = alchemy_clk_csrc_detr,
931 .set_rate = alchemy_clk_csrc_setr,
932 .set_parent = alchemy_clk_csrc_setp,
933 .get_parent = alchemy_clk_csrc_getp,
934 .enable = alchemy_clk_csrc_en,
935 .disable = alchemy_clk_csrc_dis,
936 .is_enabled = alchemy_clk_csrc_isen,
937};
938
939static const char * const alchemy_clk_csrc_parents[] = {
940 /* disabled at index 0 */ ALCHEMY_AUXPLL_CLK,
941 ALCHEMY_FG0_CLK, ALCHEMY_FG1_CLK, ALCHEMY_FG2_CLK,
942 ALCHEMY_FG3_CLK, ALCHEMY_FG4_CLK, ALCHEMY_FG5_CLK
943};
944
945/* divider tables */
946static int alchemy_csrc_dt1[] = { 1, 4, 1, 2 }; /* rest */
947static int alchemy_csrc_dt2[] = { 1, 4, 3, 2 }; /* Au1300 */
948
949static int __init alchemy_clk_setup_imux(int ctype)
950{
951 struct alchemy_fgcs_clk *a;
952 const char * const *names;
953 struct clk_init_data id;
954 unsigned long v;
955 int i, ret, *dt;
956 struct clk *c;
957
958 id.ops = &alchemy_clkops_csrc;
959 id.parent_names = alchemy_clk_csrc_parents;
960 id.num_parents = 7;
961 id.flags = CLK_SET_RATE_PARENT | CLK_GET_RATE_NOCACHE;
962
963 dt = alchemy_csrc_dt1;
964 switch (ctype) {
965 case ALCHEMY_CPU_AU1000:
966 names = alchemy_au1000_intclknames;
967 break;
968 case ALCHEMY_CPU_AU1500:
969 names = alchemy_au1500_intclknames;
970 break;
971 case ALCHEMY_CPU_AU1100:
972 names = alchemy_au1100_intclknames;
973 break;
974 case ALCHEMY_CPU_AU1550:
975 names = alchemy_au1550_intclknames;
976 break;
977 case ALCHEMY_CPU_AU1200:
978 names = alchemy_au1200_intclknames;
979 break;
980 case ALCHEMY_CPU_AU1300:
981 dt = alchemy_csrc_dt2;
982 names = alchemy_au1300_intclknames;
983 break;
984 default:
985 return -ENODEV;
986 }
987
988 a = kzalloc((sizeof(*a)) * 6, GFP_KERNEL);
989 if (!a)
990 return -ENOMEM;
991
992 spin_lock_init(&alchemy_clk_csrc_lock);
993 ret = 0;
994
995 for (i = 0; i < 6; i++) {
996 id.name = names[i];
997 if (!id.name)
998 goto next;
999
1000 a->shift = i * 5;
1001 a->reg = AU1000_SYS_CLKSRC;
1002 a->reglock = &alchemy_clk_csrc_lock;
1003 a->dt = dt;
1004
1005 /* default to first parent clock if mux is initially
1006 * set to disabled state.
1007 */
1008 v = alchemy_rdsys(a->reg);
1009 a->parent = ((v >> a->shift) >> 2) & 7;
1010 if (!a->parent) {
1011 a->parent = 1;
1012 a->isen = 0;
1013 } else
1014 a->isen = 1;
1015
1016 a->hw.init = &id;
1017 c = clk_register(NULL, &a->hw);
1018 if (IS_ERR(c))
1019 ret++;
1020 else
1021 clk_register_clkdev(c, id.name, NULL);
1022next:
1023 a++;
1024 }
1025
1026 return ret;
1027}
1028
1029
1030/**********************************************************************/
1031
1032
1033#define ERRCK(x) \
1034 if (IS_ERR(x)) { \
1035 ret = PTR_ERR(x); \
1036 goto out; \
1037 }
1038
1039static int __init alchemy_clk_init(void)
1040{
1041 int ctype = alchemy_get_cputype(), ret, i;
1042 struct clk_aliastable *t = alchemy_clk_aliases;
1043 struct clk *c;
1044
1045 /* Root of the Alchemy clock tree: external 12MHz crystal osc */
1046 c = clk_register_fixed_rate(NULL, ALCHEMY_ROOT_CLK, NULL,
1047 0, ALCHEMY_ROOTCLK_RATE);
1048 ERRCK(c)
1049
1050 /* CPU core clock */
1051 c = alchemy_clk_setup_cpu(ALCHEMY_ROOT_CLK, ctype);
1052 ERRCK(c)
1053
1054 /* AUXPLLs: max 1GHz on Au1300, 748MHz on older models */
1055 i = (ctype == ALCHEMY_CPU_AU1300) ? 84 : 63;
1056 c = alchemy_clk_setup_aux(ALCHEMY_ROOT_CLK, ALCHEMY_AUXPLL_CLK,
1057 i, AU1000_SYS_AUXPLL);
1058 ERRCK(c)
1059
1060 if (ctype == ALCHEMY_CPU_AU1300) {
1061 c = alchemy_clk_setup_aux(ALCHEMY_ROOT_CLK,
1062 ALCHEMY_AUXPLL2_CLK, i,
1063 AU1300_SYS_AUXPLL2);
1064 ERRCK(c)
1065 }
1066
1067 /* sysbus clock: cpu core clock divided by 2, 3 or 4 */
1068 c = alchemy_clk_setup_sysbus(ALCHEMY_CPU_CLK);
1069 ERRCK(c)
1070
1071 /* peripheral clock: runs at half rate of sysbus clk */
1072 c = alchemy_clk_setup_periph(ALCHEMY_SYSBUS_CLK);
1073 ERRCK(c)
1074
1075 /* SDR/DDR memory clock */
1076 c = alchemy_clk_setup_mem(ALCHEMY_SYSBUS_CLK, ctype);
1077 ERRCK(c)
1078
1079 /* L/RCLK: external static bus clock for synchronous mode */
1080 c = alchemy_clk_setup_lrclk(ALCHEMY_PERIPH_CLK, ctype);
1081 ERRCK(c)
1082
1083 /* Frequency dividers 0-5 */
1084 ret = alchemy_clk_init_fgens(ctype);
1085 if (ret) {
1086 ret = -ENODEV;
1087 goto out;
1088 }
1089
1090 /* diving muxes for internal sources */
1091 ret = alchemy_clk_setup_imux(ctype);
1092 if (ret) {
1093 ret = -ENODEV;
1094 goto out;
1095 }
1096
1097 /* set up aliases drivers might look for */
1098 while (t->base) {
1099 if (t->cputype == ctype)
1100 clk_add_alias(t->alias, NULL, t->base, NULL);
1101 t++;
1102 }
1103
1104 pr_info("Alchemy clocktree installed\n");
1105 return 0;
1106
1107out:
1108 return ret;
1109}
1110postcore_initcall(alchemy_clk_init);