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