Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[~shefty/rdma-dev.git] / drivers / clk / clk-prima2.c
1 /*
2  * Clock tree for CSR SiRFprimaII
3  *
4  * Copyright (c) 2011 Cambridge Silicon Radio Limited, a CSR plc group company.
5  *
6  * Licensed under GPLv2 or later.
7  */
8
9 #include <linux/module.h>
10 #include <linux/bitops.h>
11 #include <linux/io.h>
12 #include <linux/clk.h>
13 #include <linux/clkdev.h>
14 #include <linux/clk-provider.h>
15 #include <linux/of_address.h>
16 #include <linux/syscore_ops.h>
17
18 #define SIRFSOC_CLKC_CLK_EN0    0x0000
19 #define SIRFSOC_CLKC_CLK_EN1    0x0004
20 #define SIRFSOC_CLKC_REF_CFG    0x0014
21 #define SIRFSOC_CLKC_CPU_CFG    0x0018
22 #define SIRFSOC_CLKC_MEM_CFG    0x001c
23 #define SIRFSOC_CLKC_SYS_CFG    0x0020
24 #define SIRFSOC_CLKC_IO_CFG     0x0024
25 #define SIRFSOC_CLKC_DSP_CFG    0x0028
26 #define SIRFSOC_CLKC_GFX_CFG    0x002c
27 #define SIRFSOC_CLKC_MM_CFG     0x0030
28 #define SIRFSOC_CLKC_LCD_CFG     0x0034
29 #define SIRFSOC_CLKC_MMC_CFG    0x0038
30 #define SIRFSOC_CLKC_PLL1_CFG0  0x0040
31 #define SIRFSOC_CLKC_PLL2_CFG0  0x0044
32 #define SIRFSOC_CLKC_PLL3_CFG0  0x0048
33 #define SIRFSOC_CLKC_PLL1_CFG1  0x004c
34 #define SIRFSOC_CLKC_PLL2_CFG1  0x0050
35 #define SIRFSOC_CLKC_PLL3_CFG1  0x0054
36 #define SIRFSOC_CLKC_PLL1_CFG2  0x0058
37 #define SIRFSOC_CLKC_PLL2_CFG2  0x005c
38 #define SIRFSOC_CLKC_PLL3_CFG2  0x0060
39 #define SIRFSOC_USBPHY_PLL_CTRL 0x0008
40 #define SIRFSOC_USBPHY_PLL_POWERDOWN  BIT(1)
41 #define SIRFSOC_USBPHY_PLL_BYPASS     BIT(2)
42 #define SIRFSOC_USBPHY_PLL_LOCK       BIT(3)
43
44 static void *sirfsoc_clk_vbase, *sirfsoc_rsc_vbase;
45
46 #define KHZ     1000
47 #define MHZ     (KHZ * KHZ)
48
49 /*
50  * SiRFprimaII clock controller
51  * - 2 oscillators: osc-26MHz, rtc-32.768KHz
52  * - 3 standard configurable plls: pll1, pll2 & pll3
53  * - 2 exclusive plls: usb phy pll and sata phy pll
54  * - 8 clock domains: cpu/cpudiv, mem/memdiv, sys/io, dsp, graphic, multimedia,
55  *     display and sdphy.
56  *     Each clock domain can select its own clock source from five clock sources,
57  *     X_XIN, X_XINW, PLL1, PLL2 and PLL3. The domain clock is used as the source
58  *     clock of the group clock.
59  *     - dsp domain: gps, mf
60  *     - io domain: dmac, nand, audio, uart, i2c, spi, usp, pwm, pulse
61  *     - sys domain: security
62  */
63
64 struct clk_pll {
65         struct clk_hw hw;
66         unsigned short regofs;  /* register offset */
67 };
68
69 #define to_pllclk(_hw) container_of(_hw, struct clk_pll, hw)
70
71 struct clk_dmn {
72         struct clk_hw hw;
73         signed char enable_bit; /* enable bit: 0 ~ 63 */
74         unsigned short regofs;  /* register offset */
75 };
76
77 #define to_dmnclk(_hw) container_of(_hw, struct clk_dmn, hw)
78
79 struct clk_std {
80         struct clk_hw hw;
81         signed char enable_bit; /* enable bit: 0 ~ 63 */
82 };
83
84 #define to_stdclk(_hw) container_of(_hw, struct clk_std, hw)
85
86 static int std_clk_is_enabled(struct clk_hw *hw);
87 static int std_clk_enable(struct clk_hw *hw);
88 static void std_clk_disable(struct clk_hw *hw);
89
90 static inline unsigned long clkc_readl(unsigned reg)
91 {
92         return readl(sirfsoc_clk_vbase + reg);
93 }
94
95 static inline void clkc_writel(u32 val, unsigned reg)
96 {
97         writel(val, sirfsoc_clk_vbase + reg);
98 }
99
100 /*
101  * std pll
102  */
103
104 static unsigned long pll_clk_recalc_rate(struct clk_hw *hw,
105         unsigned long parent_rate)
106 {
107         unsigned long fin = parent_rate;
108         struct clk_pll *clk = to_pllclk(hw);
109         u32 regcfg2 = clk->regofs + SIRFSOC_CLKC_PLL1_CFG2 -
110                 SIRFSOC_CLKC_PLL1_CFG0;
111
112         if (clkc_readl(regcfg2) & BIT(2)) {
113                 /* pll bypass mode */
114                 return fin;
115         } else {
116                 /* fout = fin * nf / nr / od */
117                 u32 cfg0 = clkc_readl(clk->regofs);
118                 u32 nf = (cfg0 & (BIT(13) - 1)) + 1;
119                 u32 nr = ((cfg0 >> 13) & (BIT(6) - 1)) + 1;
120                 u32 od = ((cfg0 >> 19) & (BIT(4) - 1)) + 1;
121                 WARN_ON(fin % MHZ);
122                 return fin / MHZ * nf / nr / od * MHZ;
123         }
124 }
125
126 static long pll_clk_round_rate(struct clk_hw *hw, unsigned long rate,
127         unsigned long *parent_rate)
128 {
129         unsigned long fin, nf, nr, od;
130
131         /*
132          * fout = fin * nf / (nr * od);
133          * set od = 1, nr = fin/MHz, so fout = nf * MHz
134          */
135         rate = rate - rate % MHZ;
136
137         nf = rate / MHZ;
138         if (nf > BIT(13))
139                 nf = BIT(13);
140         if (nf < 1)
141                 nf = 1;
142
143         fin = *parent_rate;
144
145         nr = fin / MHZ;
146         if (nr > BIT(6))
147                 nr = BIT(6);
148         od = 1;
149
150         return fin * nf / (nr * od);
151 }
152
153 static int pll_clk_set_rate(struct clk_hw *hw, unsigned long rate,
154         unsigned long parent_rate)
155 {
156         struct clk_pll *clk = to_pllclk(hw);
157         unsigned long fin, nf, nr, od, reg;
158
159         /*
160          * fout = fin * nf / (nr * od);
161          * set od = 1, nr = fin/MHz, so fout = nf * MHz
162          */
163
164         nf = rate / MHZ;
165         if (unlikely((rate % MHZ) || nf > BIT(13) || nf < 1))
166                 return -EINVAL;
167
168         fin = parent_rate;
169         BUG_ON(fin < MHZ);
170
171         nr = fin / MHZ;
172         BUG_ON((fin % MHZ) || nr > BIT(6));
173
174         od = 1;
175
176         reg = (nf - 1) | ((nr - 1) << 13) | ((od - 1) << 19);
177         clkc_writel(reg, clk->regofs);
178
179         reg = clk->regofs + SIRFSOC_CLKC_PLL1_CFG1 - SIRFSOC_CLKC_PLL1_CFG0;
180         clkc_writel((nf >> 1) - 1, reg);
181
182         reg = clk->regofs + SIRFSOC_CLKC_PLL1_CFG2 - SIRFSOC_CLKC_PLL1_CFG0;
183         while (!(clkc_readl(reg) & BIT(6)))
184                 cpu_relax();
185
186         return 0;
187 }
188
189 static struct clk_ops std_pll_ops = {
190         .recalc_rate = pll_clk_recalc_rate,
191         .round_rate = pll_clk_round_rate,
192         .set_rate = pll_clk_set_rate,
193 };
194
195 static const char *pll_clk_parents[] = {
196         "osc",
197 };
198
199 static struct clk_init_data clk_pll1_init = {
200         .name = "pll1",
201         .ops = &std_pll_ops,
202         .parent_names = pll_clk_parents,
203         .num_parents = ARRAY_SIZE(pll_clk_parents),
204 };
205
206 static struct clk_init_data clk_pll2_init = {
207         .name = "pll2",
208         .ops = &std_pll_ops,
209         .parent_names = pll_clk_parents,
210         .num_parents = ARRAY_SIZE(pll_clk_parents),
211 };
212
213 static struct clk_init_data clk_pll3_init = {
214         .name = "pll3",
215         .ops = &std_pll_ops,
216         .parent_names = pll_clk_parents,
217         .num_parents = ARRAY_SIZE(pll_clk_parents),
218 };
219
220 static struct clk_pll clk_pll1 = {
221         .regofs = SIRFSOC_CLKC_PLL1_CFG0,
222         .hw = {
223                 .init = &clk_pll1_init,
224         },
225 };
226
227 static struct clk_pll clk_pll2 = {
228         .regofs = SIRFSOC_CLKC_PLL2_CFG0,
229         .hw = {
230                 .init = &clk_pll2_init,
231         },
232 };
233
234 static struct clk_pll clk_pll3 = {
235         .regofs = SIRFSOC_CLKC_PLL3_CFG0,
236         .hw = {
237                 .init = &clk_pll3_init,
238         },
239 };
240
241 /*
242  * usb uses specified pll
243  */
244
245 static int usb_pll_clk_enable(struct clk_hw *hw)
246 {
247         u32 reg = readl(sirfsoc_rsc_vbase + SIRFSOC_USBPHY_PLL_CTRL);
248         reg &= ~(SIRFSOC_USBPHY_PLL_POWERDOWN | SIRFSOC_USBPHY_PLL_BYPASS);
249         writel(reg, sirfsoc_rsc_vbase + SIRFSOC_USBPHY_PLL_CTRL);
250         while (!(readl(sirfsoc_rsc_vbase + SIRFSOC_USBPHY_PLL_CTRL) &
251                         SIRFSOC_USBPHY_PLL_LOCK))
252                 cpu_relax();
253
254         return 0;
255 }
256
257 static void usb_pll_clk_disable(struct clk_hw *clk)
258 {
259         u32 reg = readl(sirfsoc_rsc_vbase + SIRFSOC_USBPHY_PLL_CTRL);
260         reg |= (SIRFSOC_USBPHY_PLL_POWERDOWN | SIRFSOC_USBPHY_PLL_BYPASS);
261         writel(reg, sirfsoc_rsc_vbase + SIRFSOC_USBPHY_PLL_CTRL);
262 }
263
264 static unsigned long usb_pll_clk_recalc_rate(struct clk_hw *hw, unsigned long parent_rate)
265 {
266         u32 reg = readl(sirfsoc_rsc_vbase + SIRFSOC_USBPHY_PLL_CTRL);
267         return (reg & SIRFSOC_USBPHY_PLL_BYPASS) ? parent_rate : 48*MHZ;
268 }
269
270 static struct clk_ops usb_pll_ops = {
271         .enable = usb_pll_clk_enable,
272         .disable = usb_pll_clk_disable,
273         .recalc_rate = usb_pll_clk_recalc_rate,
274 };
275
276 static struct clk_init_data clk_usb_pll_init = {
277         .name = "usb_pll",
278         .ops = &usb_pll_ops,
279         .parent_names = pll_clk_parents,
280         .num_parents = ARRAY_SIZE(pll_clk_parents),
281 };
282
283 static struct clk_hw usb_pll_clk_hw = {
284         .init = &clk_usb_pll_init,
285 };
286
287 /*
288  * clock domains - cpu, mem, sys/io, dsp, gfx
289  */
290
291 static const char *dmn_clk_parents[] = {
292         "rtc",
293         "osc",
294         "pll1",
295         "pll2",
296         "pll3",
297 };
298
299 static u8 dmn_clk_get_parent(struct clk_hw *hw)
300 {
301         struct clk_dmn *clk = to_dmnclk(hw);
302         u32 cfg = clkc_readl(clk->regofs);
303
304         /* parent of io domain can only be pll3 */
305         if (strcmp(hw->init->name, "io") == 0)
306                 return 4;
307
308         WARN_ON((cfg & (BIT(3) - 1)) > 4);
309
310         return cfg & (BIT(3) - 1);
311 }
312
313 static int dmn_clk_set_parent(struct clk_hw *hw, u8 parent)
314 {
315         struct clk_dmn *clk = to_dmnclk(hw);
316         u32 cfg = clkc_readl(clk->regofs);
317
318         /* parent of io domain can only be pll3 */
319         if (strcmp(hw->init->name, "io") == 0)
320                 return -EINVAL;
321
322         cfg &= ~(BIT(3) - 1);
323         clkc_writel(cfg | parent, clk->regofs);
324         /* BIT(3) - switching status: 1 - busy, 0 - done */
325         while (clkc_readl(clk->regofs) & BIT(3))
326                 cpu_relax();
327
328         return 0;
329 }
330
331 static unsigned long dmn_clk_recalc_rate(struct clk_hw *hw,
332         unsigned long parent_rate)
333
334 {
335         unsigned long fin = parent_rate;
336         struct clk_dmn *clk = to_dmnclk(hw);
337
338         u32 cfg = clkc_readl(clk->regofs);
339
340         if (cfg & BIT(24)) {
341                 /* fcd bypass mode */
342                 return fin;
343         } else {
344                 /*
345                  * wait count: bit[19:16], hold count: bit[23:20]
346                  */
347                 u32 wait = (cfg >> 16) & (BIT(4) - 1);
348                 u32 hold = (cfg >> 20) & (BIT(4) - 1);
349
350                 return fin / (wait + hold + 2);
351         }
352 }
353
354 static long dmn_clk_round_rate(struct clk_hw *hw, unsigned long rate,
355         unsigned long *parent_rate)
356 {
357         unsigned long fin;
358         unsigned ratio, wait, hold;
359         unsigned bits = (strcmp(hw->init->name, "mem") == 0) ? 3 : 4;
360
361         fin = *parent_rate;
362         ratio = fin / rate;
363
364         if (ratio < 2)
365                 ratio = 2;
366         if (ratio > BIT(bits + 1))
367                 ratio = BIT(bits + 1);
368
369         wait = (ratio >> 1) - 1;
370         hold = ratio - wait - 2;
371
372         return fin / (wait + hold + 2);
373 }
374
375 static int dmn_clk_set_rate(struct clk_hw *hw, unsigned long rate,
376         unsigned long parent_rate)
377 {
378         struct clk_dmn *clk = to_dmnclk(hw);
379         unsigned long fin;
380         unsigned ratio, wait, hold, reg;
381         unsigned bits = (strcmp(hw->init->name, "mem") == 0) ? 3 : 4;
382
383         fin = parent_rate;
384         ratio = fin / rate;
385
386         if (unlikely(ratio < 2 || ratio > BIT(bits + 1)))
387                 return -EINVAL;
388
389         WARN_ON(fin % rate);
390
391         wait = (ratio >> 1) - 1;
392         hold = ratio - wait - 2;
393
394         reg = clkc_readl(clk->regofs);
395         reg &= ~(((BIT(bits) - 1) << 16) | ((BIT(bits) - 1) << 20));
396         reg |= (wait << 16) | (hold << 20) | BIT(25);
397         clkc_writel(reg, clk->regofs);
398
399         /* waiting FCD been effective */
400         while (clkc_readl(clk->regofs) & BIT(25))
401                 cpu_relax();
402
403         return 0;
404 }
405
406 static struct clk_ops msi_ops = {
407         .set_rate = dmn_clk_set_rate,
408         .round_rate = dmn_clk_round_rate,
409         .recalc_rate = dmn_clk_recalc_rate,
410         .set_parent = dmn_clk_set_parent,
411         .get_parent = dmn_clk_get_parent,
412 };
413
414 static struct clk_init_data clk_mem_init = {
415         .name = "mem",
416         .ops = &msi_ops,
417         .parent_names = dmn_clk_parents,
418         .num_parents = ARRAY_SIZE(dmn_clk_parents),
419 };
420
421 static struct clk_dmn clk_mem = {
422         .regofs = SIRFSOC_CLKC_MEM_CFG,
423         .hw = {
424                 .init = &clk_mem_init,
425         },
426 };
427
428 static struct clk_init_data clk_sys_init = {
429         .name = "sys",
430         .ops = &msi_ops,
431         .parent_names = dmn_clk_parents,
432         .num_parents = ARRAY_SIZE(dmn_clk_parents),
433         .flags = CLK_SET_RATE_GATE,
434 };
435
436 static struct clk_dmn clk_sys = {
437         .regofs = SIRFSOC_CLKC_SYS_CFG,
438         .hw = {
439                 .init = &clk_sys_init,
440         },
441 };
442
443 static struct clk_init_data clk_io_init = {
444         .name = "io",
445         .ops = &msi_ops,
446         .parent_names = dmn_clk_parents,
447         .num_parents = ARRAY_SIZE(dmn_clk_parents),
448 };
449
450 static struct clk_dmn clk_io = {
451         .regofs = SIRFSOC_CLKC_IO_CFG,
452         .hw = {
453                 .init = &clk_io_init,
454         },
455 };
456
457 static struct clk_ops cpu_ops = {
458         .set_parent = dmn_clk_set_parent,
459         .get_parent = dmn_clk_get_parent,
460 };
461
462 static struct clk_init_data clk_cpu_init = {
463         .name = "cpu",
464         .ops = &cpu_ops,
465         .parent_names = dmn_clk_parents,
466         .num_parents = ARRAY_SIZE(dmn_clk_parents),
467         .flags = CLK_SET_RATE_PARENT,
468 };
469
470 static struct clk_dmn clk_cpu = {
471         .regofs = SIRFSOC_CLKC_CPU_CFG,
472         .hw = {
473                 .init = &clk_cpu_init,
474         },
475 };
476
477 static struct clk_ops dmn_ops = {
478         .is_enabled = std_clk_is_enabled,
479         .enable = std_clk_enable,
480         .disable = std_clk_disable,
481         .set_rate = dmn_clk_set_rate,
482         .round_rate = dmn_clk_round_rate,
483         .recalc_rate = dmn_clk_recalc_rate,
484         .set_parent = dmn_clk_set_parent,
485         .get_parent = dmn_clk_get_parent,
486 };
487
488 /* dsp, gfx, mm, lcd and vpp domain */
489
490 static struct clk_init_data clk_dsp_init = {
491         .name = "dsp",
492         .ops = &dmn_ops,
493         .parent_names = dmn_clk_parents,
494         .num_parents = ARRAY_SIZE(dmn_clk_parents),
495 };
496
497 static struct clk_dmn clk_dsp = {
498         .regofs = SIRFSOC_CLKC_DSP_CFG,
499         .enable_bit = 0,
500         .hw = {
501                 .init = &clk_dsp_init,
502         },
503 };
504
505 static struct clk_init_data clk_gfx_init = {
506         .name = "gfx",
507         .ops = &dmn_ops,
508         .parent_names = dmn_clk_parents,
509         .num_parents = ARRAY_SIZE(dmn_clk_parents),
510 };
511
512 static struct clk_dmn clk_gfx = {
513         .regofs = SIRFSOC_CLKC_GFX_CFG,
514         .enable_bit = 8,
515         .hw = {
516                 .init = &clk_gfx_init,
517         },
518 };
519
520 static struct clk_init_data clk_mm_init = {
521         .name = "mm",
522         .ops = &dmn_ops,
523         .parent_names = dmn_clk_parents,
524         .num_parents = ARRAY_SIZE(dmn_clk_parents),
525 };
526
527 static struct clk_dmn clk_mm = {
528         .regofs = SIRFSOC_CLKC_MM_CFG,
529         .enable_bit = 9,
530         .hw = {
531                 .init = &clk_mm_init,
532         },
533 };
534
535 static struct clk_init_data clk_lcd_init = {
536         .name = "lcd",
537         .ops = &dmn_ops,
538         .parent_names = dmn_clk_parents,
539         .num_parents = ARRAY_SIZE(dmn_clk_parents),
540 };
541
542 static struct clk_dmn clk_lcd = {
543         .regofs = SIRFSOC_CLKC_LCD_CFG,
544         .enable_bit = 10,
545         .hw = {
546                 .init = &clk_lcd_init,
547         },
548 };
549
550 static struct clk_init_data clk_vpp_init = {
551         .name = "vpp",
552         .ops = &dmn_ops,
553         .parent_names = dmn_clk_parents,
554         .num_parents = ARRAY_SIZE(dmn_clk_parents),
555 };
556
557 static struct clk_dmn clk_vpp = {
558         .regofs = SIRFSOC_CLKC_LCD_CFG,
559         .enable_bit = 11,
560         .hw = {
561                 .init = &clk_vpp_init,
562         },
563 };
564
565 static struct clk_init_data clk_mmc01_init = {
566         .name = "mmc01",
567         .ops = &dmn_ops,
568         .parent_names = dmn_clk_parents,
569         .num_parents = ARRAY_SIZE(dmn_clk_parents),
570 };
571
572 static struct clk_dmn clk_mmc01 = {
573         .regofs = SIRFSOC_CLKC_MMC_CFG,
574         .enable_bit = 59,
575         .hw = {
576                 .init = &clk_mmc01_init,
577         },
578 };
579
580 static struct clk_init_data clk_mmc23_init = {
581         .name = "mmc23",
582         .ops = &dmn_ops,
583         .parent_names = dmn_clk_parents,
584         .num_parents = ARRAY_SIZE(dmn_clk_parents),
585 };
586
587 static struct clk_dmn clk_mmc23 = {
588         .regofs = SIRFSOC_CLKC_MMC_CFG,
589         .enable_bit = 60,
590         .hw = {
591                 .init = &clk_mmc23_init,
592         },
593 };
594
595 static struct clk_init_data clk_mmc45_init = {
596         .name = "mmc45",
597         .ops = &dmn_ops,
598         .parent_names = dmn_clk_parents,
599         .num_parents = ARRAY_SIZE(dmn_clk_parents),
600 };
601
602 static struct clk_dmn clk_mmc45 = {
603         .regofs = SIRFSOC_CLKC_MMC_CFG,
604         .enable_bit = 61,
605         .hw = {
606                 .init = &clk_mmc45_init,
607         },
608 };
609
610 /*
611  * peripheral controllers in io domain
612  */
613
614 static int std_clk_is_enabled(struct clk_hw *hw)
615 {
616         u32 reg;
617         int bit;
618         struct clk_std *clk = to_stdclk(hw);
619
620         bit = clk->enable_bit % 32;
621         reg = clk->enable_bit / 32;
622         reg = SIRFSOC_CLKC_CLK_EN0 + reg * sizeof(reg);
623
624         return !!(clkc_readl(reg) & BIT(bit));
625 }
626
627 static int std_clk_enable(struct clk_hw *hw)
628 {
629         u32 val, reg;
630         int bit;
631         struct clk_std *clk = to_stdclk(hw);
632
633         BUG_ON(clk->enable_bit < 0 || clk->enable_bit > 63);
634
635         bit = clk->enable_bit % 32;
636         reg = clk->enable_bit / 32;
637         reg = SIRFSOC_CLKC_CLK_EN0 + reg * sizeof(reg);
638
639         val = clkc_readl(reg) | BIT(bit);
640         clkc_writel(val, reg);
641         return 0;
642 }
643
644 static void std_clk_disable(struct clk_hw *hw)
645 {
646         u32 val, reg;
647         int bit;
648         struct clk_std *clk = to_stdclk(hw);
649
650         BUG_ON(clk->enable_bit < 0 || clk->enable_bit > 63);
651
652         bit = clk->enable_bit % 32;
653         reg = clk->enable_bit / 32;
654         reg = SIRFSOC_CLKC_CLK_EN0 + reg * sizeof(reg);
655
656         val = clkc_readl(reg) & ~BIT(bit);
657         clkc_writel(val, reg);
658 }
659
660 static const char *std_clk_io_parents[] = {
661         "io",
662 };
663
664 static struct clk_ops ios_ops = {
665         .is_enabled = std_clk_is_enabled,
666         .enable = std_clk_enable,
667         .disable = std_clk_disable,
668 };
669
670 static struct clk_init_data clk_dmac0_init = {
671         .name = "dmac0",
672         .ops = &ios_ops,
673         .parent_names = std_clk_io_parents,
674         .num_parents = ARRAY_SIZE(std_clk_io_parents),
675 };
676
677 static struct clk_std clk_dmac0 = {
678         .enable_bit = 32,
679         .hw = {
680                 .init = &clk_dmac0_init,
681         },
682 };
683
684 static struct clk_init_data clk_dmac1_init = {
685         .name = "dmac1",
686         .ops = &ios_ops,
687         .parent_names = std_clk_io_parents,
688         .num_parents = ARRAY_SIZE(std_clk_io_parents),
689 };
690
691 static struct clk_std clk_dmac1 = {
692         .enable_bit = 33,
693         .hw = {
694                 .init = &clk_dmac1_init,
695         },
696 };
697
698 static struct clk_init_data clk_nand_init = {
699         .name = "nand",
700         .ops = &ios_ops,
701         .parent_names = std_clk_io_parents,
702         .num_parents = ARRAY_SIZE(std_clk_io_parents),
703 };
704
705 static struct clk_std clk_nand = {
706         .enable_bit = 34,
707         .hw = {
708                 .init = &clk_nand_init,
709         },
710 };
711
712 static struct clk_init_data clk_audio_init = {
713         .name = "audio",
714         .ops = &ios_ops,
715         .parent_names = std_clk_io_parents,
716         .num_parents = ARRAY_SIZE(std_clk_io_parents),
717 };
718
719 static struct clk_std clk_audio = {
720         .enable_bit = 35,
721         .hw = {
722                 .init = &clk_audio_init,
723         },
724 };
725
726 static struct clk_init_data clk_uart0_init = {
727         .name = "uart0",
728         .ops = &ios_ops,
729         .parent_names = std_clk_io_parents,
730         .num_parents = ARRAY_SIZE(std_clk_io_parents),
731 };
732
733 static struct clk_std clk_uart0 = {
734         .enable_bit = 36,
735         .hw = {
736                 .init = &clk_uart0_init,
737         },
738 };
739
740 static struct clk_init_data clk_uart1_init = {
741         .name = "uart1",
742         .ops = &ios_ops,
743         .parent_names = std_clk_io_parents,
744         .num_parents = ARRAY_SIZE(std_clk_io_parents),
745 };
746
747 static struct clk_std clk_uart1 = {
748         .enable_bit = 37,
749         .hw = {
750                 .init = &clk_uart1_init,
751         },
752 };
753
754 static struct clk_init_data clk_uart2_init = {
755         .name = "uart2",
756         .ops = &ios_ops,
757         .parent_names = std_clk_io_parents,
758         .num_parents = ARRAY_SIZE(std_clk_io_parents),
759 };
760
761 static struct clk_std clk_uart2 = {
762         .enable_bit = 38,
763         .hw = {
764                 .init = &clk_uart2_init,
765         },
766 };
767
768 static struct clk_init_data clk_usp0_init = {
769         .name = "usp0",
770         .ops = &ios_ops,
771         .parent_names = std_clk_io_parents,
772         .num_parents = ARRAY_SIZE(std_clk_io_parents),
773 };
774
775 static struct clk_std clk_usp0 = {
776         .enable_bit = 39,
777         .hw = {
778                 .init = &clk_usp0_init,
779         },
780 };
781
782 static struct clk_init_data clk_usp1_init = {
783         .name = "usp1",
784         .ops = &ios_ops,
785         .parent_names = std_clk_io_parents,
786         .num_parents = ARRAY_SIZE(std_clk_io_parents),
787 };
788
789 static struct clk_std clk_usp1 = {
790         .enable_bit = 40,
791         .hw = {
792                 .init = &clk_usp1_init,
793         },
794 };
795
796 static struct clk_init_data clk_usp2_init = {
797         .name = "usp2",
798         .ops = &ios_ops,
799         .parent_names = std_clk_io_parents,
800         .num_parents = ARRAY_SIZE(std_clk_io_parents),
801 };
802
803 static struct clk_std clk_usp2 = {
804         .enable_bit = 41,
805         .hw = {
806                 .init = &clk_usp2_init,
807         },
808 };
809
810 static struct clk_init_data clk_vip_init = {
811         .name = "vip",
812         .ops = &ios_ops,
813         .parent_names = std_clk_io_parents,
814         .num_parents = ARRAY_SIZE(std_clk_io_parents),
815 };
816
817 static struct clk_std clk_vip = {
818         .enable_bit = 42,
819         .hw = {
820                 .init = &clk_vip_init,
821         },
822 };
823
824 static struct clk_init_data clk_spi0_init = {
825         .name = "spi0",
826         .ops = &ios_ops,
827         .parent_names = std_clk_io_parents,
828         .num_parents = ARRAY_SIZE(std_clk_io_parents),
829 };
830
831 static struct clk_std clk_spi0 = {
832         .enable_bit = 43,
833         .hw = {
834                 .init = &clk_spi0_init,
835         },
836 };
837
838 static struct clk_init_data clk_spi1_init = {
839         .name = "spi1",
840         .ops = &ios_ops,
841         .parent_names = std_clk_io_parents,
842         .num_parents = ARRAY_SIZE(std_clk_io_parents),
843 };
844
845 static struct clk_std clk_spi1 = {
846         .enable_bit = 44,
847         .hw = {
848                 .init = &clk_spi1_init,
849         },
850 };
851
852 static struct clk_init_data clk_tsc_init = {
853         .name = "tsc",
854         .ops = &ios_ops,
855         .parent_names = std_clk_io_parents,
856         .num_parents = ARRAY_SIZE(std_clk_io_parents),
857 };
858
859 static struct clk_std clk_tsc = {
860         .enable_bit = 45,
861         .hw = {
862                 .init = &clk_tsc_init,
863         },
864 };
865
866 static struct clk_init_data clk_i2c0_init = {
867         .name = "i2c0",
868         .ops = &ios_ops,
869         .parent_names = std_clk_io_parents,
870         .num_parents = ARRAY_SIZE(std_clk_io_parents),
871 };
872
873 static struct clk_std clk_i2c0 = {
874         .enable_bit = 46,
875         .hw = {
876                 .init = &clk_i2c0_init,
877         },
878 };
879
880 static struct clk_init_data clk_i2c1_init = {
881         .name = "i2c1",
882         .ops = &ios_ops,
883         .parent_names = std_clk_io_parents,
884         .num_parents = ARRAY_SIZE(std_clk_io_parents),
885 };
886
887 static struct clk_std clk_i2c1 = {
888         .enable_bit = 47,
889         .hw = {
890                 .init = &clk_i2c1_init,
891         },
892 };
893
894 static struct clk_init_data clk_pwmc_init = {
895         .name = "pwmc",
896         .ops = &ios_ops,
897         .parent_names = std_clk_io_parents,
898         .num_parents = ARRAY_SIZE(std_clk_io_parents),
899 };
900
901 static struct clk_std clk_pwmc = {
902         .enable_bit = 48,
903         .hw = {
904                 .init = &clk_pwmc_init,
905         },
906 };
907
908 static struct clk_init_data clk_efuse_init = {
909         .name = "efuse",
910         .ops = &ios_ops,
911         .parent_names = std_clk_io_parents,
912         .num_parents = ARRAY_SIZE(std_clk_io_parents),
913 };
914
915 static struct clk_std clk_efuse = {
916         .enable_bit = 49,
917         .hw = {
918                 .init = &clk_efuse_init,
919         },
920 };
921
922 static struct clk_init_data clk_pulse_init = {
923         .name = "pulse",
924         .ops = &ios_ops,
925         .parent_names = std_clk_io_parents,
926         .num_parents = ARRAY_SIZE(std_clk_io_parents),
927 };
928
929 static struct clk_std clk_pulse = {
930         .enable_bit = 50,
931         .hw = {
932                 .init = &clk_pulse_init,
933         },
934 };
935
936 static const char *std_clk_dsp_parents[] = {
937         "dsp",
938 };
939
940 static struct clk_init_data clk_gps_init = {
941         .name = "gps",
942         .ops = &ios_ops,
943         .parent_names = std_clk_dsp_parents,
944         .num_parents = ARRAY_SIZE(std_clk_dsp_parents),
945 };
946
947 static struct clk_std clk_gps = {
948         .enable_bit = 1,
949         .hw = {
950                 .init = &clk_gps_init,
951         },
952 };
953
954 static struct clk_init_data clk_mf_init = {
955         .name = "mf",
956         .ops = &ios_ops,
957         .parent_names = std_clk_io_parents,
958         .num_parents = ARRAY_SIZE(std_clk_io_parents),
959 };
960
961 static struct clk_std clk_mf = {
962         .enable_bit = 2,
963         .hw = {
964                 .init = &clk_mf_init,
965         },
966 };
967
968 static const char *std_clk_sys_parents[] = {
969         "sys",
970 };
971
972 static struct clk_init_data clk_security_init = {
973         .name = "mf",
974         .ops = &ios_ops,
975         .parent_names = std_clk_sys_parents,
976         .num_parents = ARRAY_SIZE(std_clk_sys_parents),
977 };
978
979 static struct clk_std clk_security = {
980         .enable_bit = 19,
981         .hw = {
982                 .init = &clk_security_init,
983         },
984 };
985
986 static const char *std_clk_usb_parents[] = {
987         "usb_pll",
988 };
989
990 static struct clk_init_data clk_usb0_init = {
991         .name = "usb0",
992         .ops = &ios_ops,
993         .parent_names = std_clk_usb_parents,
994         .num_parents = ARRAY_SIZE(std_clk_usb_parents),
995 };
996
997 static struct clk_std clk_usb0 = {
998         .enable_bit = 16,
999         .hw = {
1000                 .init = &clk_usb0_init,
1001         },
1002 };
1003
1004 static struct clk_init_data clk_usb1_init = {
1005         .name = "usb1",
1006         .ops = &ios_ops,
1007         .parent_names = std_clk_usb_parents,
1008         .num_parents = ARRAY_SIZE(std_clk_usb_parents),
1009 };
1010
1011 static struct clk_std clk_usb1 = {
1012         .enable_bit = 17,
1013         .hw = {
1014                 .init = &clk_usb1_init,
1015         },
1016 };
1017
1018 static struct of_device_id clkc_ids[] = {
1019         { .compatible = "sirf,prima2-clkc" },
1020         {},
1021 };
1022
1023 static struct of_device_id rsc_ids[] = {
1024         { .compatible = "sirf,prima2-rsc" },
1025         {},
1026 };
1027
1028 void __init sirfsoc_of_clk_init(void)
1029 {
1030         struct clk *clk;
1031         struct device_node *np;
1032
1033         np = of_find_matching_node(NULL, clkc_ids);
1034         if (!np)
1035                 panic("unable to find compatible clkc node in dtb\n");
1036
1037         sirfsoc_clk_vbase = of_iomap(np, 0);
1038         if (!sirfsoc_clk_vbase)
1039                 panic("unable to map clkc registers\n");
1040
1041         of_node_put(np);
1042
1043         np = of_find_matching_node(NULL, rsc_ids);
1044         if (!np)
1045                 panic("unable to find compatible rsc node in dtb\n");
1046
1047         sirfsoc_rsc_vbase = of_iomap(np, 0);
1048         if (!sirfsoc_rsc_vbase)
1049                 panic("unable to map rsc registers\n");
1050
1051         of_node_put(np);
1052
1053
1054         /* These are always available (RTC and 26MHz OSC)*/
1055         clk = clk_register_fixed_rate(NULL, "rtc", NULL,
1056                 CLK_IS_ROOT, 32768);
1057         BUG_ON(IS_ERR(clk));
1058         clk = clk_register_fixed_rate(NULL, "osc", NULL,
1059                 CLK_IS_ROOT, 26000000);
1060         BUG_ON(IS_ERR(clk));
1061
1062         clk = clk_register(NULL, &clk_pll1.hw);
1063         BUG_ON(IS_ERR(clk));
1064         clk = clk_register(NULL, &clk_pll2.hw);
1065         BUG_ON(IS_ERR(clk));
1066         clk = clk_register(NULL, &clk_pll3.hw);
1067         BUG_ON(IS_ERR(clk));
1068         clk = clk_register(NULL, &clk_mem.hw);
1069         BUG_ON(IS_ERR(clk));
1070         clk = clk_register(NULL, &clk_sys.hw);
1071         BUG_ON(IS_ERR(clk));
1072         clk = clk_register(NULL, &clk_security.hw);
1073         BUG_ON(IS_ERR(clk));
1074         clk_register_clkdev(clk, NULL, "b8030000.security");
1075         clk = clk_register(NULL, &clk_dsp.hw);
1076         BUG_ON(IS_ERR(clk));
1077         clk = clk_register(NULL, &clk_gps.hw);
1078         BUG_ON(IS_ERR(clk));
1079         clk_register_clkdev(clk, NULL, "a8010000.gps");
1080         clk = clk_register(NULL, &clk_mf.hw);
1081         BUG_ON(IS_ERR(clk));
1082         clk = clk_register(NULL, &clk_io.hw);
1083         BUG_ON(IS_ERR(clk));
1084         clk_register_clkdev(clk, NULL, "io");
1085         clk = clk_register(NULL, &clk_cpu.hw);
1086         BUG_ON(IS_ERR(clk));
1087         clk_register_clkdev(clk, NULL, "cpu");
1088         clk = clk_register(NULL, &clk_uart0.hw);
1089         BUG_ON(IS_ERR(clk));
1090         clk_register_clkdev(clk, NULL, "b0050000.uart");
1091         clk = clk_register(NULL, &clk_uart1.hw);
1092         BUG_ON(IS_ERR(clk));
1093         clk_register_clkdev(clk, NULL, "b0060000.uart");
1094         clk = clk_register(NULL, &clk_uart2.hw);
1095         BUG_ON(IS_ERR(clk));
1096         clk_register_clkdev(clk, NULL, "b0070000.uart");
1097         clk = clk_register(NULL, &clk_tsc.hw);
1098         BUG_ON(IS_ERR(clk));
1099         clk_register_clkdev(clk, NULL, "b0110000.tsc");
1100         clk = clk_register(NULL, &clk_i2c0.hw);
1101         BUG_ON(IS_ERR(clk));
1102         clk_register_clkdev(clk, NULL, "b00e0000.i2c");
1103         clk = clk_register(NULL, &clk_i2c1.hw);
1104         BUG_ON(IS_ERR(clk));
1105         clk_register_clkdev(clk, NULL, "b00f0000.i2c");
1106         clk = clk_register(NULL, &clk_spi0.hw);
1107         BUG_ON(IS_ERR(clk));
1108         clk_register_clkdev(clk, NULL, "b00d0000.spi");
1109         clk = clk_register(NULL, &clk_spi1.hw);
1110         BUG_ON(IS_ERR(clk));
1111         clk_register_clkdev(clk, NULL, "b0170000.spi");
1112         clk = clk_register(NULL, &clk_pwmc.hw);
1113         BUG_ON(IS_ERR(clk));
1114         clk_register_clkdev(clk, NULL, "b0130000.pwm");
1115         clk = clk_register(NULL, &clk_efuse.hw);
1116         BUG_ON(IS_ERR(clk));
1117         clk_register_clkdev(clk, NULL, "b0140000.efusesys");
1118         clk = clk_register(NULL, &clk_pulse.hw);
1119         BUG_ON(IS_ERR(clk));
1120         clk_register_clkdev(clk, NULL, "b0150000.pulsec");
1121         clk = clk_register(NULL, &clk_dmac0.hw);
1122         BUG_ON(IS_ERR(clk));
1123         clk_register_clkdev(clk, NULL, "b00b0000.dma-controller");
1124         clk = clk_register(NULL, &clk_dmac1.hw);
1125         BUG_ON(IS_ERR(clk));
1126         clk_register_clkdev(clk, NULL, "b0160000.dma-controller");
1127         clk = clk_register(NULL, &clk_nand.hw);
1128         BUG_ON(IS_ERR(clk));
1129         clk_register_clkdev(clk, NULL, "b0030000.nand");
1130         clk = clk_register(NULL, &clk_audio.hw);
1131         BUG_ON(IS_ERR(clk));
1132         clk_register_clkdev(clk, NULL, "b0040000.audio");
1133         clk = clk_register(NULL, &clk_usp0.hw);
1134         BUG_ON(IS_ERR(clk));
1135         clk_register_clkdev(clk, NULL, "b0080000.usp");
1136         clk = clk_register(NULL, &clk_usp1.hw);
1137         BUG_ON(IS_ERR(clk));
1138         clk_register_clkdev(clk, NULL, "b0090000.usp");
1139         clk = clk_register(NULL, &clk_usp2.hw);
1140         BUG_ON(IS_ERR(clk));
1141         clk_register_clkdev(clk, NULL, "b00a0000.usp");
1142         clk = clk_register(NULL, &clk_vip.hw);
1143         BUG_ON(IS_ERR(clk));
1144         clk_register_clkdev(clk, NULL, "b00c0000.vip");
1145         clk = clk_register(NULL, &clk_gfx.hw);
1146         BUG_ON(IS_ERR(clk));
1147         clk_register_clkdev(clk, NULL, "98000000.graphics");
1148         clk = clk_register(NULL, &clk_mm.hw);
1149         BUG_ON(IS_ERR(clk));
1150         clk_register_clkdev(clk, NULL, "a0000000.multimedia");
1151         clk = clk_register(NULL, &clk_lcd.hw);
1152         BUG_ON(IS_ERR(clk));
1153         clk_register_clkdev(clk, NULL, "90010000.display");
1154         clk = clk_register(NULL, &clk_vpp.hw);
1155         BUG_ON(IS_ERR(clk));
1156         clk_register_clkdev(clk, NULL, "90020000.vpp");
1157         clk = clk_register(NULL, &clk_mmc01.hw);
1158         BUG_ON(IS_ERR(clk));
1159         clk = clk_register(NULL, &clk_mmc23.hw);
1160         BUG_ON(IS_ERR(clk));
1161         clk = clk_register(NULL, &clk_mmc45.hw);
1162         BUG_ON(IS_ERR(clk));
1163         clk = clk_register(NULL, &usb_pll_clk_hw);
1164         BUG_ON(IS_ERR(clk));
1165         clk = clk_register(NULL, &clk_usb0.hw);
1166         BUG_ON(IS_ERR(clk));
1167         clk_register_clkdev(clk, NULL, "b00e0000.usb");
1168         clk = clk_register(NULL, &clk_usb1.hw);
1169         BUG_ON(IS_ERR(clk));
1170         clk_register_clkdev(clk, NULL, "b00f0000.usb");
1171 }