1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Ingenic JZ4780 SoC CGU driver
5 * Copyright (c) 2013-2015 Imagination Technologies
6 * Author: Paul Burton <paul.burton@mips.com>
9 #include <linux/clk-provider.h>
10 #include <linux/delay.h>
12 #include <linux/iopoll.h>
15 #include <dt-bindings/clock/jz4780-cgu.h>
19 /* CGU register offsets */
20 #define CGU_REG_CLOCKCONTROL 0x00
21 #define CGU_REG_LCR 0x04
22 #define CGU_REG_APLL 0x10
23 #define CGU_REG_MPLL 0x14
24 #define CGU_REG_EPLL 0x18
25 #define CGU_REG_VPLL 0x1c
26 #define CGU_REG_CLKGR0 0x20
27 #define CGU_REG_OPCR 0x24
28 #define CGU_REG_CLKGR1 0x28
29 #define CGU_REG_DDRCDR 0x2c
30 #define CGU_REG_VPUCDR 0x30
31 #define CGU_REG_USBPCR 0x3c
32 #define CGU_REG_USBRDT 0x40
33 #define CGU_REG_USBVBFIL 0x44
34 #define CGU_REG_USBPCR1 0x48
35 #define CGU_REG_LP0CDR 0x54
36 #define CGU_REG_I2SCDR 0x60
37 #define CGU_REG_LP1CDR 0x64
38 #define CGU_REG_MSC0CDR 0x68
39 #define CGU_REG_UHCCDR 0x6c
40 #define CGU_REG_SSICDR 0x74
41 #define CGU_REG_CIMCDR 0x7c
42 #define CGU_REG_PCMCDR 0x84
43 #define CGU_REG_GPUCDR 0x88
44 #define CGU_REG_HDMICDR 0x8c
45 #define CGU_REG_MSC1CDR 0xa4
46 #define CGU_REG_MSC2CDR 0xa8
47 #define CGU_REG_BCHCDR 0xac
48 #define CGU_REG_CLOCKSTATUS 0xd4
50 /* bits within the OPCR register */
51 #define OPCR_SPENDN0 BIT(7)
52 #define OPCR_SPENDN1 BIT(6)
54 /* bits within the USBPCR register */
55 #define USBPCR_USB_MODE BIT(31)
56 #define USBPCR_IDPULLUP_MASK (0x3 << 28)
57 #define USBPCR_COMMONONN BIT(25)
58 #define USBPCR_VBUSVLDEXT BIT(24)
59 #define USBPCR_VBUSVLDEXTSEL BIT(23)
60 #define USBPCR_POR BIT(22)
61 #define USBPCR_OTG_DISABLE BIT(20)
62 #define USBPCR_COMPDISTUNE_MASK (0x7 << 17)
63 #define USBPCR_OTGTUNE_MASK (0x7 << 14)
64 #define USBPCR_SQRXTUNE_MASK (0x7 << 11)
65 #define USBPCR_TXFSLSTUNE_MASK (0xf << 7)
66 #define USBPCR_TXPREEMPHTUNE BIT(6)
67 #define USBPCR_TXHSXVTUNE_MASK (0x3 << 4)
68 #define USBPCR_TXVREFTUNE_MASK 0xf
70 /* bits within the USBPCR1 register */
71 #define USBPCR1_REFCLKSEL_SHIFT 26
72 #define USBPCR1_REFCLKSEL_MASK (0x3 << USBPCR1_REFCLKSEL_SHIFT)
73 #define USBPCR1_REFCLKSEL_CORE (0x2 << USBPCR1_REFCLKSEL_SHIFT)
74 #define USBPCR1_REFCLKDIV_SHIFT 24
75 #define USBPCR1_REFCLKDIV_MASK (0x3 << USBPCR1_REFCLKDIV_SHIFT)
76 #define USBPCR1_REFCLKDIV_19_2 (0x3 << USBPCR1_REFCLKDIV_SHIFT)
77 #define USBPCR1_REFCLKDIV_48 (0x2 << USBPCR1_REFCLKDIV_SHIFT)
78 #define USBPCR1_REFCLKDIV_24 (0x1 << USBPCR1_REFCLKDIV_SHIFT)
79 #define USBPCR1_REFCLKDIV_12 (0x0 << USBPCR1_REFCLKDIV_SHIFT)
80 #define USBPCR1_USB_SEL BIT(28)
81 #define USBPCR1_WORD_IF0 BIT(19)
82 #define USBPCR1_WORD_IF1 BIT(18)
84 /* bits within the USBRDT register */
85 #define USBRDT_VBFIL_LD_EN BIT(25)
86 #define USBRDT_USBRDT_MASK 0x7fffff
88 /* bits within the USBVBFIL register */
89 #define USBVBFIL_IDDIGFIL_SHIFT 16
90 #define USBVBFIL_IDDIGFIL_MASK (0xffff << USBVBFIL_IDDIGFIL_SHIFT)
91 #define USBVBFIL_USBVBFIL_MASK (0xffff)
93 /* bits within the LCR register */
94 #define LCR_PD_SCPU BIT(31)
95 #define LCR_SCPUS BIT(27)
97 /* bits within the CLKGR1 register */
98 #define CLKGR1_CORE1 BIT(15)
100 static struct ingenic_cgu *cgu;
102 static u8 jz4780_otg_phy_get_parent(struct clk_hw *hw)
104 /* we only use CLKCORE, revisit if that ever changes */
108 static int jz4780_otg_phy_set_parent(struct clk_hw *hw, u8 idx)
116 spin_lock_irqsave(&cgu->lock, flags);
118 usbpcr1 = readl(cgu->base + CGU_REG_USBPCR1);
119 usbpcr1 &= ~USBPCR1_REFCLKSEL_MASK;
120 /* we only use CLKCORE */
121 usbpcr1 |= USBPCR1_REFCLKSEL_CORE;
122 writel(usbpcr1, cgu->base + CGU_REG_USBPCR1);
124 spin_unlock_irqrestore(&cgu->lock, flags);
128 static unsigned long jz4780_otg_phy_recalc_rate(struct clk_hw *hw,
129 unsigned long parent_rate)
134 usbpcr1 = readl(cgu->base + CGU_REG_USBPCR1);
135 refclk_div = usbpcr1 & USBPCR1_REFCLKDIV_MASK;
137 switch (refclk_div) {
138 case USBPCR1_REFCLKDIV_12:
141 case USBPCR1_REFCLKDIV_24:
144 case USBPCR1_REFCLKDIV_48:
147 case USBPCR1_REFCLKDIV_19_2:
155 static long jz4780_otg_phy_round_rate(struct clk_hw *hw, unsigned long req_rate,
156 unsigned long *parent_rate)
158 if (req_rate < 15600000)
161 if (req_rate < 21600000)
164 if (req_rate < 36000000)
170 static int jz4780_otg_phy_set_rate(struct clk_hw *hw, unsigned long req_rate,
171 unsigned long parent_rate)
174 u32 usbpcr1, div_bits;
178 div_bits = USBPCR1_REFCLKDIV_12;
182 div_bits = USBPCR1_REFCLKDIV_19_2;
186 div_bits = USBPCR1_REFCLKDIV_24;
190 div_bits = USBPCR1_REFCLKDIV_48;
197 spin_lock_irqsave(&cgu->lock, flags);
199 usbpcr1 = readl(cgu->base + CGU_REG_USBPCR1);
200 usbpcr1 &= ~USBPCR1_REFCLKDIV_MASK;
202 writel(usbpcr1, cgu->base + CGU_REG_USBPCR1);
204 spin_unlock_irqrestore(&cgu->lock, flags);
208 static const struct clk_ops jz4780_otg_phy_ops = {
209 .get_parent = jz4780_otg_phy_get_parent,
210 .set_parent = jz4780_otg_phy_set_parent,
212 .recalc_rate = jz4780_otg_phy_recalc_rate,
213 .round_rate = jz4780_otg_phy_round_rate,
214 .set_rate = jz4780_otg_phy_set_rate,
217 static int jz4780_core1_enable(struct clk_hw *hw)
219 struct ingenic_clk *ingenic_clk = to_ingenic_clk(hw);
220 struct ingenic_cgu *cgu = ingenic_clk->cgu;
221 const unsigned int timeout = 5000;
226 spin_lock_irqsave(&cgu->lock, flags);
228 lcr = readl(cgu->base + CGU_REG_LCR);
230 writel(lcr, cgu->base + CGU_REG_LCR);
232 clkgr1 = readl(cgu->base + CGU_REG_CLKGR1);
233 clkgr1 &= ~CLKGR1_CORE1;
234 writel(clkgr1, cgu->base + CGU_REG_CLKGR1);
236 spin_unlock_irqrestore(&cgu->lock, flags);
238 /* wait for the CPU to be powered up */
239 retval = readl_poll_timeout(cgu->base + CGU_REG_LCR, lcr,
240 !(lcr & LCR_SCPUS), 10, timeout);
241 if (retval == -ETIMEDOUT) {
242 pr_err("%s: Wait for power up core1 timeout\n", __func__);
249 static const struct clk_ops jz4780_core1_ops = {
250 .enable = jz4780_core1_enable,
253 static const s8 pll_od_encoding[16] = {
254 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
255 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
258 static const struct ingenic_cgu_clk_info jz4780_cgu_clocks[] = {
260 /* External clocks */
262 [JZ4780_CLK_EXCLK] = { "ext", CGU_CLK_EXT },
263 [JZ4780_CLK_RTCLK] = { "rtc", CGU_CLK_EXT },
267 #define DEF_PLL(name) { \
268 .reg = CGU_REG_ ## name, \
278 .od_encoding = pll_od_encoding, \
284 [JZ4780_CLK_APLL] = {
286 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
287 .pll = DEF_PLL(APLL),
290 [JZ4780_CLK_MPLL] = {
292 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
293 .pll = DEF_PLL(MPLL),
296 [JZ4780_CLK_EPLL] = {
298 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
299 .pll = DEF_PLL(EPLL),
302 [JZ4780_CLK_VPLL] = {
304 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
305 .pll = DEF_PLL(VPLL),
310 /* Custom (SoC-specific) OTG PHY */
312 [JZ4780_CLK_OTGPHY] = {
313 "otg_phy", CGU_CLK_CUSTOM,
314 .parents = { -1, -1, JZ4780_CLK_EXCLK, -1 },
315 .custom = { &jz4780_otg_phy_ops },
318 /* Muxes & dividers */
320 [JZ4780_CLK_SCLKA] = {
321 "sclk_a", CGU_CLK_MUX,
322 .parents = { -1, JZ4780_CLK_APLL, JZ4780_CLK_EXCLK,
324 .mux = { CGU_REG_CLOCKCONTROL, 30, 2 },
327 [JZ4780_CLK_CPUMUX] = {
328 "cpumux", CGU_CLK_MUX,
329 .parents = { -1, JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
331 .mux = { CGU_REG_CLOCKCONTROL, 28, 2 },
336 .parents = { JZ4780_CLK_CPUMUX, -1, -1, -1 },
337 .div = { CGU_REG_CLOCKCONTROL, 0, 1, 4, 22, -1, -1 },
340 [JZ4780_CLK_L2CACHE] = {
341 "l2cache", CGU_CLK_DIV,
342 .parents = { JZ4780_CLK_CPUMUX, -1, -1, -1 },
343 .div = { CGU_REG_CLOCKCONTROL, 4, 1, 4, -1, -1, -1 },
346 [JZ4780_CLK_AHB0] = {
347 "ahb0", CGU_CLK_MUX | CGU_CLK_DIV,
348 .parents = { -1, JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
350 .mux = { CGU_REG_CLOCKCONTROL, 26, 2 },
351 .div = { CGU_REG_CLOCKCONTROL, 8, 1, 4, 21, -1, -1 },
354 [JZ4780_CLK_AHB2PMUX] = {
355 "ahb2_apb_mux", CGU_CLK_MUX,
356 .parents = { -1, JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
358 .mux = { CGU_REG_CLOCKCONTROL, 24, 2 },
361 [JZ4780_CLK_AHB2] = {
363 .parents = { JZ4780_CLK_AHB2PMUX, -1, -1, -1 },
364 .div = { CGU_REG_CLOCKCONTROL, 12, 1, 4, 20, -1, -1 },
367 [JZ4780_CLK_PCLK] = {
369 .parents = { JZ4780_CLK_AHB2PMUX, -1, -1, -1 },
370 .div = { CGU_REG_CLOCKCONTROL, 16, 1, 4, 20, -1, -1 },
374 "ddr", CGU_CLK_MUX | CGU_CLK_DIV,
375 .parents = { -1, JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL, -1 },
376 .mux = { CGU_REG_DDRCDR, 30, 2 },
377 .div = { CGU_REG_DDRCDR, 0, 1, 4, 29, 28, 27 },
381 "vpu", CGU_CLK_MUX | CGU_CLK_DIV | CGU_CLK_GATE,
382 .parents = { JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
383 JZ4780_CLK_EPLL, -1 },
384 .mux = { CGU_REG_VPUCDR, 30, 2 },
385 .div = { CGU_REG_VPUCDR, 0, 1, 4, 29, 28, 27 },
386 .gate = { CGU_REG_CLKGR1, 2 },
389 [JZ4780_CLK_I2SPLL] = {
390 "i2s_pll", CGU_CLK_MUX | CGU_CLK_DIV,
391 .parents = { JZ4780_CLK_SCLKA, JZ4780_CLK_EPLL, -1, -1 },
392 .mux = { CGU_REG_I2SCDR, 30, 1 },
393 .div = { CGU_REG_I2SCDR, 0, 1, 8, 29, 28, 27 },
398 .parents = { JZ4780_CLK_EXCLK, JZ4780_CLK_I2SPLL, -1, -1 },
399 .mux = { CGU_REG_I2SCDR, 31, 1 },
402 [JZ4780_CLK_LCD0PIXCLK] = {
403 "lcd0pixclk", CGU_CLK_MUX | CGU_CLK_DIV,
404 .parents = { JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
405 JZ4780_CLK_VPLL, -1 },
406 .mux = { CGU_REG_LP0CDR, 30, 2 },
407 .div = { CGU_REG_LP0CDR, 0, 1, 8, 28, 27, 26 },
410 [JZ4780_CLK_LCD1PIXCLK] = {
411 "lcd1pixclk", CGU_CLK_MUX | CGU_CLK_DIV,
412 .parents = { JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
413 JZ4780_CLK_VPLL, -1 },
414 .mux = { CGU_REG_LP1CDR, 30, 2 },
415 .div = { CGU_REG_LP1CDR, 0, 1, 8, 28, 27, 26 },
418 [JZ4780_CLK_MSCMUX] = {
419 "msc_mux", CGU_CLK_MUX,
420 .parents = { -1, JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL, -1 },
421 .mux = { CGU_REG_MSC0CDR, 30, 2 },
424 [JZ4780_CLK_MSC0] = {
425 "msc0", CGU_CLK_DIV | CGU_CLK_GATE,
426 .parents = { JZ4780_CLK_MSCMUX, -1, -1, -1 },
427 .div = { CGU_REG_MSC0CDR, 0, 2, 8, 29, 28, 27 },
428 .gate = { CGU_REG_CLKGR0, 3 },
431 [JZ4780_CLK_MSC1] = {
432 "msc1", CGU_CLK_DIV | CGU_CLK_GATE,
433 .parents = { JZ4780_CLK_MSCMUX, -1, -1, -1 },
434 .div = { CGU_REG_MSC1CDR, 0, 2, 8, 29, 28, 27 },
435 .gate = { CGU_REG_CLKGR0, 11 },
438 [JZ4780_CLK_MSC2] = {
439 "msc2", CGU_CLK_DIV | CGU_CLK_GATE,
440 .parents = { JZ4780_CLK_MSCMUX, -1, -1, -1 },
441 .div = { CGU_REG_MSC2CDR, 0, 2, 8, 29, 28, 27 },
442 .gate = { CGU_REG_CLKGR0, 12 },
446 "uhc", CGU_CLK_MUX | CGU_CLK_DIV | CGU_CLK_GATE,
447 .parents = { JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
448 JZ4780_CLK_EPLL, JZ4780_CLK_OTGPHY },
449 .mux = { CGU_REG_UHCCDR, 30, 2 },
450 .div = { CGU_REG_UHCCDR, 0, 1, 8, 29, 28, 27 },
451 .gate = { CGU_REG_CLKGR0, 24 },
454 [JZ4780_CLK_SSIPLL] = {
455 "ssi_pll", CGU_CLK_MUX | CGU_CLK_DIV,
456 .parents = { JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL, -1, -1 },
457 .mux = { CGU_REG_SSICDR, 30, 1 },
458 .div = { CGU_REG_SSICDR, 0, 1, 8, 29, 28, 27 },
463 .parents = { JZ4780_CLK_EXCLK, JZ4780_CLK_SSIPLL, -1, -1 },
464 .mux = { CGU_REG_SSICDR, 31, 1 },
467 [JZ4780_CLK_CIMMCLK] = {
468 "cim_mclk", CGU_CLK_MUX | CGU_CLK_DIV,
469 .parents = { JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL, -1, -1 },
470 .mux = { CGU_REG_CIMCDR, 31, 1 },
471 .div = { CGU_REG_CIMCDR, 0, 1, 8, 30, 29, 28 },
474 [JZ4780_CLK_PCMPLL] = {
475 "pcm_pll", CGU_CLK_MUX | CGU_CLK_DIV,
476 .parents = { JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
477 JZ4780_CLK_EPLL, JZ4780_CLK_VPLL },
478 .mux = { CGU_REG_PCMCDR, 29, 2 },
479 .div = { CGU_REG_PCMCDR, 0, 1, 8, 28, 27, 26 },
483 "pcm", CGU_CLK_MUX | CGU_CLK_GATE,
484 .parents = { JZ4780_CLK_EXCLK, JZ4780_CLK_PCMPLL, -1, -1 },
485 .mux = { CGU_REG_PCMCDR, 31, 1 },
486 .gate = { CGU_REG_CLKGR1, 3 },
490 "gpu", CGU_CLK_MUX | CGU_CLK_DIV | CGU_CLK_GATE,
491 .parents = { -1, JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
493 .mux = { CGU_REG_GPUCDR, 30, 2 },
494 .div = { CGU_REG_GPUCDR, 0, 1, 4, 29, 28, 27 },
495 .gate = { CGU_REG_CLKGR1, 4 },
498 [JZ4780_CLK_HDMI] = {
499 "hdmi", CGU_CLK_MUX | CGU_CLK_DIV | CGU_CLK_GATE,
500 .parents = { JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
501 JZ4780_CLK_VPLL, -1 },
502 .mux = { CGU_REG_HDMICDR, 30, 2 },
503 .div = { CGU_REG_HDMICDR, 0, 1, 8, 29, 28, 26 },
504 .gate = { CGU_REG_CLKGR1, 9 },
508 "bch", CGU_CLK_MUX | CGU_CLK_DIV | CGU_CLK_GATE,
509 .parents = { -1, JZ4780_CLK_SCLKA, JZ4780_CLK_MPLL,
511 .mux = { CGU_REG_BCHCDR, 30, 2 },
512 .div = { CGU_REG_BCHCDR, 0, 1, 4, 29, 28, 27 },
513 .gate = { CGU_REG_CLKGR0, 1 },
516 /* Gate-only clocks */
518 [JZ4780_CLK_NEMC] = {
519 "nemc", CGU_CLK_GATE,
520 .parents = { JZ4780_CLK_AHB2, -1, -1, -1 },
521 .gate = { CGU_REG_CLKGR0, 0 },
524 [JZ4780_CLK_OTG0] = {
525 "otg0", CGU_CLK_GATE,
526 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
527 .gate = { CGU_REG_CLKGR0, 2 },
530 [JZ4780_CLK_SSI0] = {
531 "ssi0", CGU_CLK_GATE,
532 .parents = { JZ4780_CLK_SSI, -1, -1, -1 },
533 .gate = { CGU_REG_CLKGR0, 4 },
536 [JZ4780_CLK_SMB0] = {
537 "smb0", CGU_CLK_GATE,
538 .parents = { JZ4780_CLK_PCLK, -1, -1, -1 },
539 .gate = { CGU_REG_CLKGR0, 5 },
542 [JZ4780_CLK_SMB1] = {
543 "smb1", CGU_CLK_GATE,
544 .parents = { JZ4780_CLK_PCLK, -1, -1, -1 },
545 .gate = { CGU_REG_CLKGR0, 6 },
550 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
551 .gate = { CGU_REG_CLKGR0, 7 },
556 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
557 .gate = { CGU_REG_CLKGR0, 8 },
560 [JZ4780_CLK_TSSI0] = {
561 "tssi0", CGU_CLK_GATE,
562 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
563 .gate = { CGU_REG_CLKGR0, 9 },
568 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
569 .gate = { CGU_REG_CLKGR0, 10 },
574 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
575 .gate = { CGU_REG_CLKGR0, 13 },
578 [JZ4780_CLK_SADC] = {
579 "sadc", CGU_CLK_GATE,
580 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
581 .gate = { CGU_REG_CLKGR0, 14 },
584 [JZ4780_CLK_UART0] = {
585 "uart0", CGU_CLK_GATE,
586 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
587 .gate = { CGU_REG_CLKGR0, 15 },
590 [JZ4780_CLK_UART1] = {
591 "uart1", CGU_CLK_GATE,
592 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
593 .gate = { CGU_REG_CLKGR0, 16 },
596 [JZ4780_CLK_UART2] = {
597 "uart2", CGU_CLK_GATE,
598 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
599 .gate = { CGU_REG_CLKGR0, 17 },
602 [JZ4780_CLK_UART3] = {
603 "uart3", CGU_CLK_GATE,
604 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
605 .gate = { CGU_REG_CLKGR0, 18 },
608 [JZ4780_CLK_SSI1] = {
609 "ssi1", CGU_CLK_GATE,
610 .parents = { JZ4780_CLK_SSI, -1, -1, -1 },
611 .gate = { CGU_REG_CLKGR0, 19 },
614 [JZ4780_CLK_SSI2] = {
615 "ssi2", CGU_CLK_GATE,
616 .parents = { JZ4780_CLK_SSI, -1, -1, -1 },
617 .gate = { CGU_REG_CLKGR0, 20 },
620 [JZ4780_CLK_PDMA] = {
621 "pdma", CGU_CLK_GATE,
622 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
623 .gate = { CGU_REG_CLKGR0, 21 },
628 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
629 .gate = { CGU_REG_CLKGR0, 22 },
634 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
635 .gate = { CGU_REG_CLKGR0, 23 },
638 [JZ4780_CLK_SMB2] = {
639 "smb2", CGU_CLK_GATE,
640 .parents = { JZ4780_CLK_PCLK, -1, -1, -1 },
641 .gate = { CGU_REG_CLKGR0, 24 },
646 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
647 .gate = { CGU_REG_CLKGR0, 26 },
652 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
653 .gate = { CGU_REG_CLKGR0, 28 },
658 .parents = { JZ4780_CLK_LCD, -1, -1, -1 },
659 .gate = { CGU_REG_CLKGR0, 27 },
664 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
665 .gate = { CGU_REG_CLKGR0, 29 },
668 [JZ4780_CLK_DDR0] = {
669 "ddr0", CGU_CLK_GATE,
670 .parents = { JZ4780_CLK_DDR, -1, -1, -1 },
671 .gate = { CGU_REG_CLKGR0, 30 },
674 [JZ4780_CLK_DDR1] = {
675 "ddr1", CGU_CLK_GATE,
676 .parents = { JZ4780_CLK_DDR, -1, -1, -1 },
677 .gate = { CGU_REG_CLKGR0, 31 },
680 [JZ4780_CLK_SMB3] = {
681 "smb3", CGU_CLK_GATE,
682 .parents = { JZ4780_CLK_PCLK, -1, -1, -1 },
683 .gate = { CGU_REG_CLKGR1, 0 },
686 [JZ4780_CLK_TSSI1] = {
687 "tssi1", CGU_CLK_GATE,
688 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
689 .gate = { CGU_REG_CLKGR1, 1 },
692 [JZ4780_CLK_COMPRESS] = {
693 "compress", CGU_CLK_GATE,
694 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
695 .gate = { CGU_REG_CLKGR1, 5 },
698 [JZ4780_CLK_AIC1] = {
699 "aic1", CGU_CLK_GATE,
700 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
701 .gate = { CGU_REG_CLKGR1, 6 },
704 [JZ4780_CLK_GPVLC] = {
705 "gpvlc", CGU_CLK_GATE,
706 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
707 .gate = { CGU_REG_CLKGR1, 7 },
710 [JZ4780_CLK_OTG1] = {
711 "otg1", CGU_CLK_GATE,
712 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
713 .gate = { CGU_REG_CLKGR1, 8 },
716 [JZ4780_CLK_UART4] = {
717 "uart4", CGU_CLK_GATE,
718 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
719 .gate = { CGU_REG_CLKGR1, 10 },
722 [JZ4780_CLK_AHBMON] = {
723 "ahb_mon", CGU_CLK_GATE,
724 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
725 .gate = { CGU_REG_CLKGR1, 11 },
728 [JZ4780_CLK_SMB4] = {
729 "smb4", CGU_CLK_GATE,
730 .parents = { JZ4780_CLK_PCLK, -1, -1, -1 },
731 .gate = { CGU_REG_CLKGR1, 12 },
736 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
737 .gate = { CGU_REG_CLKGR1, 13 },
742 .parents = { JZ4780_CLK_EXCLK, -1, -1, -1 },
743 .gate = { CGU_REG_CLKGR1, 14 },
746 [JZ4780_CLK_CORE1] = {
747 "core1", CGU_CLK_CUSTOM,
748 .parents = { JZ4780_CLK_CPU, -1, -1, -1 },
749 .custom = { &jz4780_core1_ops },
754 static void __init jz4780_cgu_init(struct device_node *np)
758 cgu = ingenic_cgu_new(jz4780_cgu_clocks,
759 ARRAY_SIZE(jz4780_cgu_clocks), np);
761 pr_err("%s: failed to initialise CGU\n", __func__);
765 retval = ingenic_cgu_register_clocks(cgu);
767 pr_err("%s: failed to register CGU Clocks\n", __func__);
771 ingenic_cgu_register_syscore_ops(cgu);
773 CLK_OF_DECLARE_DRIVER(jz4780_cgu, "ingenic,jz4780-cgu", jz4780_cgu_init);