drivers/clk/clk_pic32.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Purna Chandra Mandal <purna.mandal@microchip.com>
   4  *
   5  */
   6
   7 #include <common.h>
   8 #include <clk-uclass.h>
   9 #include <dm.h>
  10 #include <div64.h>
  11 #include <wait_bit.h>
  12 #include <dm/lists.h>
  13 #include <asm/io.h>
  14 #include <mach/pic32.h>
  15 #include <dt-bindings/clock/microchip,clock.h>
  16
  17 DECLARE_GLOBAL_DATA_PTR;
  18
  19 /* Primary oscillator */
  20 #define SYS_POSC_CLK_HZ 24000000
  21
  22 /* FRC clk rate */
  23 #define SYS_FRC_CLK_HZ  8000000
  24
  25 /* Clock Registers */
  26 #define OSCCON          0x0000
  27 #define OSCTUNE         0x0010
  28 #define SPLLCON         0x0020
  29 #define REFO1CON        0x0080
  30 #define REFO1TRIM       0x0090
  31 #define PB1DIV          0x0140
  32
  33 /* SPLL */
  34 #define ICLK_MASK       0x00000080
  35 #define PLLIDIV_MASK    0x00000007
  36 #define PLLODIV_MASK    0x00000007
  37 #define CUROSC_MASK     0x00000007
  38 #define PLLMUL_MASK     0x0000007F
  39 #define FRCDIV_MASK     0x00000007
  40
  41 /* PBCLK */
  42 #define PBDIV_MASK      0x00000007
  43
  44 /* SYSCLK MUX */
  45 #define SCLK_SRC_FRC1   0
  46 #define SCLK_SRC_SPLL   1
  47 #define SCLK_SRC_POSC   2
  48 #define SCLK_SRC_FRC2   7
  49
  50 /* Reference Oscillator Control Reg fields */
  51 #define REFO_SEL_MASK   0x0f
  52 #define REFO_SEL_SHIFT  0
  53 #define REFO_ACTIVE     BIT(8)
  54 #define REFO_DIVSW_EN   BIT(9)
  55 #define REFO_OE         BIT(12)
  56 #define REFO_ON         BIT(15)
  57 #define REFO_DIV_SHIFT  16
  58 #define REFO_DIV_MASK   0x7fff
  59
  60 /* Reference Oscillator Trim Register Fields */
  61 #define REFO_TRIM_REG   0x10
  62 #define REFO_TRIM_MASK  0x1ff
  63 #define REFO_TRIM_SHIFT 23
  64 #define REFO_TRIM_MAX   511
  65
  66 #define ROCLK_SRC_SCLK          0x0
  67 #define ROCLK_SRC_SPLL          0x7
  68 #define ROCLK_SRC_ROCLKI        0x8
  69
  70 /* Memory PLL */
  71 #define MPLL_IDIV               0x3f
  72 #define MPLL_MULT               0xff
  73 #define MPLL_ODIV1              0x7
  74 #define MPLL_ODIV2              0x7
  75 #define MPLL_VREG_RDY           BIT(23)
  76 #define MPLL_RDY                BIT(31)
  77 #define MPLL_IDIV_SHIFT         0
  78 #define MPLL_MULT_SHIFT         8
  79 #define MPLL_ODIV1_SHIFT        24
  80 #define MPLL_ODIV2_SHIFT        27
  81 #define MPLL_IDIV_INIT          0x03
  82 #define MPLL_MULT_INIT          0x32
  83 #define MPLL_ODIV1_INIT         0x02
  84 #define MPLL_ODIV2_INIT         0x01
  85
  86 struct pic32_clk_priv {
  87         void __iomem *iobase;
  88         void __iomem *syscfg_base;
  89 };
  90
  91 static ulong pic32_get_pll_rate(struct pic32_clk_priv *priv)
  92 {
  93         u32 iclk, idiv, odiv, mult;
  94         ulong plliclk, v;
  95
  96         v = readl(priv->iobase + SPLLCON);
  97         iclk = (v & ICLK_MASK);
  98         idiv = ((v >> 8) & PLLIDIV_MASK) + 1;
  99         odiv = ((v >> 24) & PLLODIV_MASK);
 100         mult = ((v >> 16) & PLLMUL_MASK) + 1;
 101
 102         plliclk = iclk ? SYS_FRC_CLK_HZ : SYS_POSC_CLK_HZ;
 103
 104         if (odiv < 2)
 105                 odiv = 2;
 106         else if (odiv < 5)
 107                 odiv = (1 << odiv);
 108         else
 109                 odiv = 32;
 110
 111         return ((plliclk / idiv) * mult) / odiv;
 112 }
 113
 114 static ulong pic32_get_sysclk(struct pic32_clk_priv *priv)
 115 {
 116         ulong v;
 117         ulong hz;
 118         ulong div, frcdiv;
 119         ulong curr_osc;
 120
 121         /* get clk source */
 122         v = readl(priv->iobase + OSCCON);
 123         curr_osc = (v >> 12) & CUROSC_MASK;
 124         switch (curr_osc) {
 125         case SCLK_SRC_FRC1:
 126         case SCLK_SRC_FRC2:
 127                 frcdiv = ((v >> 24) & FRCDIV_MASK);
 128                 div = ((1 << frcdiv) + 1) + (128 * (frcdiv == 7));
 129                 hz = SYS_FRC_CLK_HZ / div;
 130                 break;
 131
 132         case SCLK_SRC_SPLL:
 133                 hz = pic32_get_pll_rate(priv);
 134                 break;
 135
 136         case SCLK_SRC_POSC:
 137                 hz = SYS_POSC_CLK_HZ;
 138                 break;
 139
 140         default:
 141                 hz = 0;
 142                 printf("clk: unknown sclk_src.\n");
 143                 break;
 144         }
 145
 146         return hz;
 147 }
 148
 149 static ulong pic32_get_pbclk(struct pic32_clk_priv *priv, int periph)
 150 {
 151         void __iomem *reg;
 152         ulong div, clk_freq;
 153
 154         WARN_ON((periph < PB1CLK) || (periph > PB7CLK));
 155
 156         clk_freq = pic32_get_sysclk(priv);
 157
 158         reg = priv->iobase + PB1DIV + (periph - PB1CLK) * 0x10;
 159         div = (readl(reg) & PBDIV_MASK) + 1;
 160
 161         return clk_freq / div;
 162 }
 163
 164 static ulong pic32_get_cpuclk(struct pic32_clk_priv *priv)
 165 {
 166         return pic32_get_pbclk(priv, PB7CLK);
 167 }
 168
 169 static ulong pic32_set_refclk(struct pic32_clk_priv *priv, int periph,
 170                               int parent_rate, int rate, int parent_id)
 171 {
 172         void __iomem *reg;
 173         u32 div, trim, v;
 174         u64 frac;
 175
 176         WARN_ON((periph < REF1CLK) || (periph > REF5CLK));
 177
 178         /* calculate dividers,
 179          *   rate = parent_rate / [2 * (div + (trim / 512))]
 180          */
 181         if (parent_rate <= rate) {
 182                 div = 0;
 183                 trim = 0;
 184         } else {
 185                 div = parent_rate / (rate << 1);
 186                 frac = parent_rate;
 187                 frac <<= 8;
 188                 do_div(frac, rate);
 189                 frac -= (u64)(div << 9);
 190                 trim = (frac >= REFO_TRIM_MAX) ? REFO_TRIM_MAX : (u32)frac;
 191         }
 192
 193         reg = priv->iobase + REFO1CON + (periph - REF1CLK) * 0x20;
 194
 195         /* disable clk */
 196         writel(REFO_ON | REFO_OE, reg + _CLR_OFFSET);
 197
 198         /* wait till previous src change is active */
 199         wait_for_bit_le32(reg, REFO_DIVSW_EN | REFO_ACTIVE,
 200                           false, CONFIG_SYS_HZ, false);
 201
 202         /* parent_id */
 203         v = readl(reg);
 204         v &= ~(REFO_SEL_MASK << REFO_SEL_SHIFT);
 205         v |= (parent_id << REFO_SEL_SHIFT);
 206
 207         /* apply rodiv */
 208         v &= ~(REFO_DIV_MASK << REFO_DIV_SHIFT);
 209         v |= (div << REFO_DIV_SHIFT);
 210         writel(v, reg);
 211
 212         /* apply trim */
 213         v = readl(reg + REFO_TRIM_REG);
 214         v &= ~(REFO_TRIM_MASK << REFO_TRIM_SHIFT);
 215         v |= (trim << REFO_TRIM_SHIFT);
 216         writel(v, reg + REFO_TRIM_REG);
 217
 218         /* enable clk */
 219         writel(REFO_ON | REFO_OE, reg + _SET_OFFSET);
 220
 221         /* switch divider */
 222         writel(REFO_DIVSW_EN, reg + _SET_OFFSET);
 223
 224         /* wait for divider switching to complete */
 225         return wait_for_bit_le32(reg, REFO_DIVSW_EN, false,
 226                                  CONFIG_SYS_HZ, false);
 227 }
 228
 229 static ulong pic32_get_refclk(struct pic32_clk_priv *priv, int periph)
 230 {
 231         u32 rodiv, rotrim, rosel, v, parent_rate;
 232         void __iomem *reg;
 233         u64 rate64;
 234
 235         WARN_ON((periph < REF1CLK) || (periph > REF5CLK));
 236
 237         reg = priv->iobase + REFO1CON + (periph - REF1CLK) * 0x20;
 238         v = readl(reg);
 239         /* get rosel */
 240         rosel = (v >> REFO_SEL_SHIFT) & REFO_SEL_MASK;
 241         /* get div */
 242         rodiv = (v >> REFO_DIV_SHIFT) & REFO_DIV_MASK;
 243
 244         /* get trim */
 245         v = readl(reg + REFO_TRIM_REG);
 246         rotrim = (v >> REFO_TRIM_SHIFT) & REFO_TRIM_MASK;
 247
 248         if (!rodiv)
 249                 return 0;
 250
 251         /* get parent rate */
 252         switch (rosel) {
 253         case ROCLK_SRC_SCLK:
 254                 parent_rate = pic32_get_cpuclk(priv);
 255                 break;
 256         case ROCLK_SRC_SPLL:
 257                 parent_rate = pic32_get_pll_rate(priv);
 258                 break;
 259         default:
 260                 parent_rate = 0;
 261                 break;
 262         }
 263
 264         /* Calculation
 265          * rate = parent_rate / [2 * (div + (trim / 512))]
 266          */
 267         if (rotrim) {
 268                 rodiv <<= 9;
 269                 rodiv += rotrim;
 270                 rate64 = parent_rate;
 271                 rate64 <<= 8;
 272                 do_div(rate64, rodiv);
 273                 v = (u32)rate64;
 274         } else {
 275                 v = parent_rate / (rodiv << 1);
 276         }
 277         return v;
 278 }
 279
 280 static ulong pic32_get_mpll_rate(struct pic32_clk_priv *priv)
 281 {
 282         u32 v, idiv, mul;
 283         u32 odiv1, odiv2;
 284         u64 rate;
 285
 286         v = readl(priv->syscfg_base + CFGMPLL);
 287         idiv = v & MPLL_IDIV;
 288         mul = (v >> MPLL_MULT_SHIFT) & MPLL_MULT;
 289         odiv1 = (v >> MPLL_ODIV1_SHIFT) & MPLL_ODIV1;
 290         odiv2 = (v >> MPLL_ODIV2_SHIFT) & MPLL_ODIV2;
 291
 292         rate = (SYS_POSC_CLK_HZ / idiv) * mul;
 293         do_div(rate, odiv1);
 294         do_div(rate, odiv2);
 295
 296         return (ulong)rate;
 297 }
 298
 299 static int pic32_mpll_init(struct pic32_clk_priv *priv)
 300 {
 301         u32 v, mask;
 302
 303         /* initialize */
 304         v = (MPLL_IDIV_INIT << MPLL_IDIV_SHIFT) |
 305             (MPLL_MULT_INIT << MPLL_MULT_SHIFT) |
 306             (MPLL_ODIV1_INIT << MPLL_ODIV1_SHIFT) |
 307             (MPLL_ODIV2_INIT << MPLL_ODIV2_SHIFT);
 308
 309         writel(v, priv->syscfg_base + CFGMPLL);
 310
 311         /* Wait for ready */
 312         mask = MPLL_RDY | MPLL_VREG_RDY;
 313         return wait_for_bit_le32(priv->syscfg_base + CFGMPLL, mask,
 314                                  true, get_tbclk(), false);
 315 }
 316
 317 static void pic32_clk_init(struct udevice *dev)
 318 {
 319         const void *blob = gd->fdt_blob;
 320         struct pic32_clk_priv *priv;
 321         ulong rate, pll_hz;
 322         char propname[50];
 323         int i;
 324
 325         priv = dev_get_priv(dev);
 326         pll_hz = pic32_get_pll_rate(priv);
 327
 328         /* Initialize REFOs as not initialized and enabled on reset. */
 329         for (i = REF1CLK; i <= REF5CLK; i++) {
 330                 snprintf(propname, sizeof(propname),
 331                          "microchip,refo%d-frequency", i - REF1CLK + 1);
 332                 rate = fdtdec_get_int(blob, dev_of_offset(dev), propname, 0);
 333                 if (rate)
 334                         pic32_set_refclk(priv, i, pll_hz, rate, ROCLK_SRC_SPLL);
 335         }
 336
 337         /* Memory PLL */
 338         pic32_mpll_init(priv);
 339 }
 340
 341 static ulong pic32_get_rate(struct clk *clk)
 342 {
 343         struct pic32_clk_priv *priv = dev_get_priv(clk->dev);
 344         ulong rate;
 345
 346         switch (clk->id) {
 347         case PB1CLK ... PB7CLK:
 348                 rate = pic32_get_pbclk(priv, clk->id);
 349                 break;
 350         case REF1CLK ... REF5CLK:
 351                 rate = pic32_get_refclk(priv, clk->id);
 352                 break;
 353         case PLLCLK:
 354                 rate = pic32_get_pll_rate(priv);
 355                 break;
 356         case MPLL:
 357                 rate = pic32_get_mpll_rate(priv);
 358                 break;
 359         default:
 360                 rate = 0;
 361                 break;
 362         }
 363
 364         return rate;
 365 }
 366
 367 static ulong pic32_set_rate(struct clk *clk, ulong rate)
 368 {
 369         struct pic32_clk_priv *priv = dev_get_priv(clk->dev);
 370         ulong pll_hz;
 371
 372         switch (clk->id) {
 373         case REF1CLK ... REF5CLK:
 374                 pll_hz = pic32_get_pll_rate(priv);
 375                 pic32_set_refclk(priv, clk->id, pll_hz, rate, ROCLK_SRC_SPLL);
 376                 break;
 377         default:
 378                 break;
 379         }
 380
 381         return rate;
 382 }
 383
 384 static struct clk_ops pic32_pic32_clk_ops = {
 385         .set_rate = pic32_set_rate,
 386         .get_rate = pic32_get_rate,
 387 };
 388
 389 static int pic32_clk_probe(struct udevice *dev)
 390 {
 391         struct pic32_clk_priv *priv = dev_get_priv(dev);
 392         fdt_addr_t addr;
 393         fdt_size_t size;
 394
 395         addr = fdtdec_get_addr_size(gd->fdt_blob, dev_of_offset(dev), "reg",
 396                                     &size);
 397         if (addr == FDT_ADDR_T_NONE)
 398                 return -EINVAL;
 399
 400         priv->iobase = ioremap(addr, size);
 401         if (!priv->iobase)
 402                 return -EINVAL;
 403
 404         priv->syscfg_base = pic32_get_syscfg_base();
 405
 406         /* initialize clocks */
 407         pic32_clk_init(dev);
 408
 409         return 0;
 410 }
 411
 412 static const struct udevice_id pic32_clk_ids[] = {
 413         { .compatible = "microchip,pic32mzda-clk"},
 414         {}
 415 };
 416
 417 U_BOOT_DRIVER(pic32_clk) = {
 418         .name           = "pic32_clk",
 419         .id             = UCLASS_CLK,
 420         .of_match       = pic32_clk_ids,
 421         .ops            = &pic32_pic32_clk_ops,
 422         .probe          = pic32_clk_probe,
 423         .priv_auto_alloc_size = sizeof(struct pic32_clk_priv),
 424 };