drivers/clk/ingenic/x1830-cgu.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * X1830 SoC CGU driver
   4  * Copyright (c) 2019 周琰杰 (Zhou Yanjie) <zhouyanjie@wanyeetech.com>
   5  */
   6
   7 #include <linux/clk-provider.h>
   8 #include <linux/delay.h>
   9 #include <linux/io.h>
  10 #include <linux/of.h>
  11
  12 #include <dt-bindings/clock/ingenic,x1830-cgu.h>
  13
  14 #include "cgu.h"
  15 #include "pm.h"
  16
  17 /* CGU register offsets */
  18 #define CGU_REG_CPCCR           0x00
  19 #define CGU_REG_CPPCR           0x0c
  20 #define CGU_REG_APLL            0x10
  21 #define CGU_REG_MPLL            0x14
  22 #define CGU_REG_CLKGR0          0x20
  23 #define CGU_REG_OPCR            0x24
  24 #define CGU_REG_CLKGR1          0x28
  25 #define CGU_REG_DDRCDR          0x2c
  26 #define CGU_REG_USBPCR          0x3c
  27 #define CGU_REG_USBRDT          0x40
  28 #define CGU_REG_USBVBFIL        0x44
  29 #define CGU_REG_USBPCR1         0x48
  30 #define CGU_REG_MACCDR          0x54
  31 #define CGU_REG_EPLL            0x58
  32 #define CGU_REG_I2SCDR          0x60
  33 #define CGU_REG_LPCDR           0x64
  34 #define CGU_REG_MSC0CDR         0x68
  35 #define CGU_REG_I2SCDR1         0x70
  36 #define CGU_REG_SSICDR          0x74
  37 #define CGU_REG_CIMCDR          0x7c
  38 #define CGU_REG_MSC1CDR         0xa4
  39 #define CGU_REG_CMP_INTR        0xb0
  40 #define CGU_REG_CMP_INTRE       0xb4
  41 #define CGU_REG_DRCG            0xd0
  42 #define CGU_REG_CPCSR           0xd4
  43 #define CGU_REG_VPLL            0xe0
  44 #define CGU_REG_MACPHYC         0xe8
  45
  46 /* bits within the OPCR register */
  47 #define OPCR_GATE_USBPHYCLK     BIT(23)
  48 #define OPCR_SPENDN0            BIT(7)
  49 #define OPCR_SPENDN1            BIT(6)
  50
  51 /* bits within the USBPCR register */
  52 #define USBPCR_SIDDQ            BIT(21)
  53 #define USBPCR_OTG_DISABLE      BIT(20)
  54
  55 static struct ingenic_cgu *cgu;
  56
  57 static int x1830_usb_phy_enable(struct clk_hw *hw)
  58 {
  59         void __iomem *reg_opcr          = cgu->base + CGU_REG_OPCR;
  60         void __iomem *reg_usbpcr        = cgu->base + CGU_REG_USBPCR;
  61
  62         writel((readl(reg_opcr) | OPCR_SPENDN0) & ~OPCR_GATE_USBPHYCLK, reg_opcr);
  63         writel(readl(reg_usbpcr) & ~USBPCR_OTG_DISABLE & ~USBPCR_SIDDQ, reg_usbpcr);
  64         return 0;
  65 }
  66
  67 static void x1830_usb_phy_disable(struct clk_hw *hw)
  68 {
  69         void __iomem *reg_opcr          = cgu->base + CGU_REG_OPCR;
  70         void __iomem *reg_usbpcr        = cgu->base + CGU_REG_USBPCR;
  71
  72         writel((readl(reg_opcr) & ~OPCR_SPENDN0) | OPCR_GATE_USBPHYCLK, reg_opcr);
  73         writel(readl(reg_usbpcr) | USBPCR_OTG_DISABLE | USBPCR_SIDDQ, reg_usbpcr);
  74 }
  75
  76 static int x1830_usb_phy_is_enabled(struct clk_hw *hw)
  77 {
  78         void __iomem *reg_opcr          = cgu->base + CGU_REG_OPCR;
  79         void __iomem *reg_usbpcr        = cgu->base + CGU_REG_USBPCR;
  80
  81         return (readl(reg_opcr) & OPCR_SPENDN0) &&
  82                 !(readl(reg_usbpcr) & USBPCR_SIDDQ) &&
  83                 !(readl(reg_usbpcr) & USBPCR_OTG_DISABLE);
  84 }
  85
  86 static const struct clk_ops x1830_otg_phy_ops = {
  87         .enable         = x1830_usb_phy_enable,
  88         .disable        = x1830_usb_phy_disable,
  89         .is_enabled     = x1830_usb_phy_is_enabled,
  90 };
  91
  92 static const s8 pll_od_encoding[64] = {
  93         0x0, 0x1,  -1, 0x2,  -1,  -1,  -1, 0x3,
  94          -1,  -1,  -1,  -1,  -1,  -1,  -1, 0x4,
  95          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
  96          -1,  -1,  -1,  -1,  -1,  -1,  -1, 0x5,
  97          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
  98          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
  99          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 100          -1,  -1,  -1,  -1,  -1,  -1,  -1, 0x6,
 101 };
 102
 103 static const struct ingenic_cgu_clk_info x1830_cgu_clocks[] = {
 104
 105         /* External clocks */
 106
 107         [X1830_CLK_EXCLK] = { "ext", CGU_CLK_EXT },
 108         [X1830_CLK_RTCLK] = { "rtc", CGU_CLK_EXT },
 109
 110         /* PLLs */
 111
 112         [X1830_CLK_APLL] = {
 113                 "apll", CGU_CLK_PLL,
 114                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 115                 .pll = {
 116                         .reg = CGU_REG_APLL,
 117                         .rate_multiplier = 2,
 118                         .m_shift = 20,
 119                         .m_bits = 9,
 120                         .m_offset = 1,
 121                         .n_shift = 14,
 122                         .n_bits = 6,
 123                         .n_offset = 1,
 124                         .od_shift = 11,
 125                         .od_bits = 3,
 126                         .od_max = 64,
 127                         .od_encoding = pll_od_encoding,
 128                         .bypass_reg = CGU_REG_CPPCR,
 129                         .bypass_bit = 30,
 130                         .enable_bit = 0,
 131                         .stable_bit = 3,
 132                 },
 133         },
 134
 135         [X1830_CLK_MPLL] = {
 136                 "mpll", CGU_CLK_PLL,
 137                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 138                 .pll = {
 139                         .reg = CGU_REG_MPLL,
 140                         .rate_multiplier = 2,
 141                         .m_shift = 20,
 142                         .m_bits = 9,
 143                         .m_offset = 1,
 144                         .n_shift = 14,
 145                         .n_bits = 6,
 146                         .n_offset = 1,
 147                         .od_shift = 11,
 148                         .od_bits = 3,
 149                         .od_max = 64,
 150                         .od_encoding = pll_od_encoding,
 151                         .bypass_reg = CGU_REG_CPPCR,
 152                         .bypass_bit = 28,
 153                         .enable_bit = 0,
 154                         .stable_bit = 3,
 155                 },
 156         },
 157
 158         [X1830_CLK_EPLL] = {
 159                 "epll", CGU_CLK_PLL,
 160                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 161                 .pll = {
 162                         .reg = CGU_REG_EPLL,
 163                         .rate_multiplier = 2,
 164                         .m_shift = 20,
 165                         .m_bits = 9,
 166                         .m_offset = 1,
 167                         .n_shift = 14,
 168                         .n_bits = 6,
 169                         .n_offset = 1,
 170                         .od_shift = 11,
 171                         .od_bits = 3,
 172                         .od_max = 64,
 173                         .od_encoding = pll_od_encoding,
 174                         .bypass_reg = CGU_REG_CPPCR,
 175                         .bypass_bit = 24,
 176                         .enable_bit = 0,
 177                         .stable_bit = 3,
 178                 },
 179         },
 180
 181         [X1830_CLK_VPLL] = {
 182                 "vpll", CGU_CLK_PLL,
 183                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 184                 .pll = {
 185                         .reg = CGU_REG_VPLL,
 186                         .rate_multiplier = 2,
 187                         .m_shift = 20,
 188                         .m_bits = 9,
 189                         .m_offset = 1,
 190                         .n_shift = 14,
 191                         .n_bits = 6,
 192                         .n_offset = 1,
 193                         .od_shift = 11,
 194                         .od_bits = 3,
 195                         .od_max = 64,
 196                         .od_encoding = pll_od_encoding,
 197                         .bypass_reg = CGU_REG_CPPCR,
 198                         .bypass_bit = 26,
 199                         .enable_bit = 0,
 200                         .stable_bit = 3,
 201                 },
 202         },
 203
 204         /* Custom (SoC-specific) OTG PHY */
 205
 206         [X1830_CLK_OTGPHY] = {
 207                 "otg_phy", CGU_CLK_CUSTOM,
 208                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 209                 .custom = { &x1830_otg_phy_ops },
 210         },
 211
 212         /* Muxes & dividers */
 213
 214         [X1830_CLK_SCLKA] = {
 215                 "sclk_a", CGU_CLK_MUX,
 216                 .parents = { -1, X1830_CLK_EXCLK, X1830_CLK_APLL, -1 },
 217                 .mux = { CGU_REG_CPCCR, 30, 2 },
 218         },
 219
 220         [X1830_CLK_CPUMUX] = {
 221                 "cpu_mux", CGU_CLK_MUX,
 222                 .parents = { -1, X1830_CLK_SCLKA, X1830_CLK_MPLL, -1 },
 223                 .mux = { CGU_REG_CPCCR, 28, 2 },
 224         },
 225
 226         [X1830_CLK_CPU] = {
 227                 "cpu", CGU_CLK_DIV | CGU_CLK_GATE,
 228                 .flags = CLK_IS_CRITICAL,
 229                 .parents = { X1830_CLK_CPUMUX, -1, -1, -1 },
 230                 .div = { CGU_REG_CPCCR, 0, 1, 4, 22, -1, -1 },
 231                 .gate = { CGU_REG_CLKGR1, 15 },
 232         },
 233
 234         [X1830_CLK_L2CACHE] = {
 235                 "l2cache", CGU_CLK_DIV,
 236                 /*
 237                  * The L2 cache clock is critical if caches are enabled and
 238                  * disabling it or any parent clocks will hang the system.
 239                  */
 240                 .flags = CLK_IS_CRITICAL,
 241                 .parents = { X1830_CLK_CPUMUX, -1, -1, -1 },
 242                 .div = { CGU_REG_CPCCR, 4, 1, 4, 22, -1, -1 },
 243         },
 244
 245         [X1830_CLK_AHB0] = {
 246                 "ahb0", CGU_CLK_MUX | CGU_CLK_DIV,
 247                 .parents = { -1, X1830_CLK_SCLKA, X1830_CLK_MPLL, -1 },
 248                 .mux = { CGU_REG_CPCCR, 26, 2 },
 249                 .div = { CGU_REG_CPCCR, 8, 1, 4, 21, -1, -1 },
 250         },
 251
 252         [X1830_CLK_AHB2PMUX] = {
 253                 "ahb2_apb_mux", CGU_CLK_MUX,
 254                 .parents = { -1, X1830_CLK_SCLKA, X1830_CLK_MPLL, -1 },
 255                 .mux = { CGU_REG_CPCCR, 24, 2 },
 256         },
 257
 258         [X1830_CLK_AHB2] = {
 259                 "ahb2", CGU_CLK_DIV,
 260                 .parents = { X1830_CLK_AHB2PMUX, -1, -1, -1 },
 261                 .div = { CGU_REG_CPCCR, 12, 1, 4, 20, -1, -1 },
 262         },
 263
 264         [X1830_CLK_PCLK] = {
 265                 "pclk", CGU_CLK_DIV | CGU_CLK_GATE,
 266                 .parents = { X1830_CLK_AHB2PMUX, -1, -1, -1 },
 267                 .div = { CGU_REG_CPCCR, 16, 1, 4, 20, -1, -1 },
 268                 .gate = { CGU_REG_CLKGR1, 14 },
 269         },
 270
 271         [X1830_CLK_DDR] = {
 272                 "ddr", CGU_CLK_MUX | CGU_CLK_DIV | CGU_CLK_GATE,
 273                 /*
 274                  * Disabling DDR clock or its parents will render DRAM
 275                  * inaccessible; mark it critical.
 276                  */
 277                 .flags = CLK_IS_CRITICAL,
 278                 .parents = { -1, X1830_CLK_SCLKA, X1830_CLK_MPLL, -1 },
 279                 .mux = { CGU_REG_DDRCDR, 30, 2 },
 280                 .div = { CGU_REG_DDRCDR, 0, 1, 4, 29, 28, 27 },
 281                 .gate = { CGU_REG_CLKGR0, 31 },
 282         },
 283
 284         [X1830_CLK_MAC] = {
 285                 "mac", CGU_CLK_MUX | CGU_CLK_DIV | CGU_CLK_GATE,
 286                 .parents = { X1830_CLK_SCLKA, X1830_CLK_MPLL,
 287                                          X1830_CLK_VPLL, X1830_CLK_EPLL },
 288                 .mux = { CGU_REG_MACCDR, 30, 2 },
 289                 .div = { CGU_REG_MACCDR, 0, 1, 8, 29, 28, 27 },
 290                 .gate = { CGU_REG_CLKGR1, 4 },
 291         },
 292
 293         [X1830_CLK_LCD] = {
 294                 "lcd", CGU_CLK_MUX | CGU_CLK_DIV | CGU_CLK_GATE,
 295                 .parents = { X1830_CLK_SCLKA, X1830_CLK_MPLL,
 296                                          X1830_CLK_VPLL, X1830_CLK_EPLL },
 297                 .mux = { CGU_REG_LPCDR, 30, 2 },
 298                 .div = { CGU_REG_LPCDR, 0, 1, 8, 28, 27, 26 },
 299                 .gate = { CGU_REG_CLKGR1, 9 },
 300         },
 301
 302         [X1830_CLK_MSCMUX] = {
 303                 "msc_mux", CGU_CLK_MUX,
 304                 .parents = { X1830_CLK_SCLKA, X1830_CLK_MPLL,
 305                                          X1830_CLK_VPLL, X1830_CLK_EPLL },
 306                 .mux = { CGU_REG_MSC0CDR, 30, 2 },
 307         },
 308
 309         [X1830_CLK_MSC0] = {
 310                 "msc0", CGU_CLK_DIV | CGU_CLK_GATE,
 311                 .parents = { X1830_CLK_MSCMUX, -1, -1, -1 },
 312                 .div = { CGU_REG_MSC0CDR, 0, 2, 8, 29, 28, 27 },
 313                 .gate = { CGU_REG_CLKGR0, 4 },
 314         },
 315
 316         [X1830_CLK_MSC1] = {
 317                 "msc1", CGU_CLK_DIV | CGU_CLK_GATE,
 318                 .parents = { X1830_CLK_MSCMUX, -1, -1, -1 },
 319                 .div = { CGU_REG_MSC1CDR, 0, 2, 8, 29, 28, 27 },
 320                 .gate = { CGU_REG_CLKGR0, 5 },
 321         },
 322
 323         [X1830_CLK_SSIPLL] = {
 324                 "ssi_pll", CGU_CLK_MUX | CGU_CLK_DIV,
 325                 .parents = { X1830_CLK_SCLKA, X1830_CLK_MPLL,
 326                                          X1830_CLK_VPLL, X1830_CLK_EPLL },
 327                 .mux = { CGU_REG_SSICDR, 30, 2 },
 328                 .div = { CGU_REG_SSICDR, 0, 1, 8, 28, 27, 26 },
 329         },
 330
 331         [X1830_CLK_SSIPLL_DIV2] = {
 332                 "ssi_pll_div2", CGU_CLK_FIXDIV,
 333                 .parents = { X1830_CLK_SSIPLL },
 334                 .fixdiv = { 2 },
 335         },
 336
 337         [X1830_CLK_SSIMUX] = {
 338                 "ssi_mux", CGU_CLK_MUX,
 339                 .parents = { X1830_CLK_EXCLK, X1830_CLK_SSIPLL_DIV2, -1, -1 },
 340                 .mux = { CGU_REG_SSICDR, 29, 1 },
 341         },
 342
 343         [X1830_CLK_EXCLK_DIV512] = {
 344                 "exclk_div512", CGU_CLK_FIXDIV,
 345                 .parents = { X1830_CLK_EXCLK },
 346                 .fixdiv = { 512 },
 347         },
 348
 349         [X1830_CLK_RTC] = {
 350                 "rtc_ercs", CGU_CLK_MUX | CGU_CLK_GATE,
 351                 .parents = { X1830_CLK_EXCLK_DIV512, X1830_CLK_RTCLK },
 352                 .mux = { CGU_REG_OPCR, 2, 1},
 353                 .gate = { CGU_REG_CLKGR0, 29 },
 354         },
 355
 356         /* Gate-only clocks */
 357
 358         [X1830_CLK_EMC] = {
 359                 "emc", CGU_CLK_GATE,
 360                 .parents = { X1830_CLK_AHB2, -1, -1, -1 },
 361                 .gate = { CGU_REG_CLKGR0, 0 },
 362         },
 363
 364         [X1830_CLK_EFUSE] = {
 365                 "efuse", CGU_CLK_GATE,
 366                 .parents = { X1830_CLK_AHB2, -1, -1, -1 },
 367                 .gate = { CGU_REG_CLKGR0, 1 },
 368         },
 369
 370         [X1830_CLK_OTG] = {
 371                 "otg", CGU_CLK_GATE,
 372                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 373                 .gate = { CGU_REG_CLKGR0, 3 },
 374         },
 375
 376         [X1830_CLK_SSI0] = {
 377                 "ssi0", CGU_CLK_GATE,
 378                 .parents = { X1830_CLK_SSIMUX, -1, -1, -1 },
 379                 .gate = { CGU_REG_CLKGR0, 6 },
 380         },
 381
 382         [X1830_CLK_SMB0] = {
 383                 "smb0", CGU_CLK_GATE,
 384                 .parents = { X1830_CLK_PCLK, -1, -1, -1 },
 385                 .gate = { CGU_REG_CLKGR0, 7 },
 386         },
 387
 388         [X1830_CLK_SMB1] = {
 389                 "smb1", CGU_CLK_GATE,
 390                 .parents = { X1830_CLK_PCLK, -1, -1, -1 },
 391                 .gate = { CGU_REG_CLKGR0, 8 },
 392         },
 393
 394         [X1830_CLK_SMB2] = {
 395                 "smb2", CGU_CLK_GATE,
 396                 .parents = { X1830_CLK_PCLK, -1, -1, -1 },
 397                 .gate = { CGU_REG_CLKGR0, 9 },
 398         },
 399
 400         [X1830_CLK_UART0] = {
 401                 "uart0", CGU_CLK_GATE,
 402                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 403                 .gate = { CGU_REG_CLKGR0, 14 },
 404         },
 405
 406         [X1830_CLK_UART1] = {
 407                 "uart1", CGU_CLK_GATE,
 408                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 409                 .gate = { CGU_REG_CLKGR0, 15 },
 410         },
 411
 412         [X1830_CLK_SSI1] = {
 413                 "ssi1", CGU_CLK_GATE,
 414                 .parents = { X1830_CLK_SSIMUX, -1, -1, -1 },
 415                 .gate = { CGU_REG_CLKGR0, 19 },
 416         },
 417
 418         [X1830_CLK_SFC] = {
 419                 "sfc", CGU_CLK_GATE,
 420                 .parents = { X1830_CLK_SSIPLL, -1, -1, -1 },
 421                 .gate = { CGU_REG_CLKGR0, 20 },
 422         },
 423
 424         [X1830_CLK_PDMA] = {
 425                 "pdma", CGU_CLK_GATE,
 426                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 427                 .gate = { CGU_REG_CLKGR0, 21 },
 428         },
 429
 430         [X1830_CLK_TCU] = {
 431                 "tcu", CGU_CLK_GATE,
 432                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 433                 .gate = { CGU_REG_CLKGR0, 30 },
 434         },
 435
 436         [X1830_CLK_DTRNG] = {
 437                 "dtrng", CGU_CLK_GATE,
 438                 .parents = { X1830_CLK_PCLK, -1, -1, -1 },
 439                 .gate = { CGU_REG_CLKGR1, 1 },
 440         },
 441
 442         [X1830_CLK_OST] = {
 443                 "ost", CGU_CLK_GATE,
 444                 .parents = { X1830_CLK_EXCLK, -1, -1, -1 },
 445                 .gate = { CGU_REG_CLKGR1, 11 },
 446         },
 447 };
 448
 449 static void __init x1830_cgu_init(struct device_node *np)
 450 {
 451         int retval;
 452
 453         cgu = ingenic_cgu_new(x1830_cgu_clocks,
 454                               ARRAY_SIZE(x1830_cgu_clocks), np);
 455         if (!cgu) {
 456                 pr_err("%s: failed to initialise CGU\n", __func__);
 457                 return;
 458         }
 459
 460         retval = ingenic_cgu_register_clocks(cgu);
 461         if (retval) {
 462                 pr_err("%s: failed to register CGU Clocks\n", __func__);
 463                 return;
 464         }
 465
 466         ingenic_cgu_register_syscore_ops(cgu);
 467 }
 468 /*
 469  * CGU has some children devices, this is useful for probing children devices
 470  * in the case where the device node is compatible with "simple-mfd".
 471  */
 472 CLK_OF_DECLARE_DRIVER(x1830_cgu, "ingenic,x1830-cgu", x1830_cgu_init);