sys/arm/allwinner/clk/aw_pll.c

   1 /*-
   2  * Copyright (c) 2016 Jared McNeill <jmcneill@invisible.ca>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  19  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  21  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 /*
  30  * Allwinner PLL clock
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/bus.h>
  39 #include <sys/rman.h>
  40 #include <sys/kernel.h>
  41 #include <sys/module.h>
  42 #include <machine/bus.h>
  43
  44 #include <dev/ofw/ofw_bus.h>
  45 #include <dev/ofw/ofw_bus_subr.h>
  46 #include <dev/ofw/ofw_subr.h>
  47
  48 #include <dev/extres/clk/clk.h>
  49
  50 #include <arm/allwinner/aw_machdep.h>
  51
  52 #include "clkdev_if.h"
  53
  54 #define SUN4I_A10_PLL2_1X               0
  55 #define SUN4I_A10_PLL2_2X               1
  56 #define SUN4I_A10_PLL2_4X               2
  57 #define SUN4I_A10_PLL2_8X               3
  58
  59 #define AW_PLL_ENABLE                   (1 << 31)
  60
  61 #define A10_PLL1_OUT_EXT_DIVP           (0x3 << 16)
  62 #define A10_PLL1_OUT_EXT_DIVP_SHIFT     16
  63 #define A10_PLL1_FACTOR_N               (0x1f << 8)
  64 #define A10_PLL1_FACTOR_N_SHIFT         8
  65 #define A10_PLL1_FACTOR_K               (0x3 << 4)
  66 #define A10_PLL1_FACTOR_K_SHIFT         4
  67 #define A10_PLL1_FACTOR_M               (0x3 << 0)
  68 #define A10_PLL1_FACTOR_M_SHIFT         0
  69
  70 #define A10_PLL2_POST_DIV               (0xf << 26)
  71 #define A10_PLL2_POST_DIV_SHIFT         26
  72 #define A10_PLL2_FACTOR_N               (0x7f << 8)
  73 #define A10_PLL2_FACTOR_N_SHIFT         8
  74 #define A10_PLL2_PRE_DIV                (0x1f << 0)
  75 #define A10_PLL2_PRE_DIV_SHIFT          0
  76
  77 #define A10_PLL3_MODE_SEL               (0x1 << 15)
  78 #define A10_PLL3_MODE_SEL_FRACT         (0 << 15)
  79 #define A10_PLL3_MODE_SEL_INT           (1 << 15)
  80 #define A10_PLL3_FUNC_SET               (0x1 << 14)
  81 #define A10_PLL3_FUNC_SET_270MHZ        (0 << 14)
  82 #define A10_PLL3_FUNC_SET_297MHZ        (1 << 14)
  83 #define A10_PLL3_FACTOR_M               (0x7f << 0)
  84 #define A10_PLL3_FACTOR_M_SHIFT         0
  85 #define A10_PLL3_REF_FREQ               3000000
  86
  87 #define A10_PLL5_OUT_EXT_DIVP           (0x3 << 16)
  88 #define A10_PLL5_OUT_EXT_DIVP_SHIFT     16
  89 #define A10_PLL5_FACTOR_N               (0x1f << 8)
  90 #define A10_PLL5_FACTOR_N_SHIFT         8
  91 #define A10_PLL5_FACTOR_K               (0x3 << 4)
  92 #define A10_PLL5_FACTOR_K_SHIFT         4
  93 #define A10_PLL5_FACTOR_M1              (0x3 << 2)
  94 #define A10_PLL5_FACTOR_M1_SHIFT        2
  95 #define A10_PLL5_FACTOR_M               (0x3 << 0)
  96 #define A10_PLL5_FACTOR_M_SHIFT         0
  97
  98 #define A10_PLL6_BYPASS_EN              (1 << 30)
  99 #define A10_PLL6_SATA_CLK_EN            (1 << 14)
 100 #define A10_PLL6_FACTOR_N               (0x1f << 8)
 101 #define A10_PLL6_FACTOR_N_SHIFT         8
 102 #define A10_PLL6_FACTOR_K               (0x3 << 4)
 103 #define A10_PLL6_FACTOR_K_SHIFT         4
 104 #define A10_PLL6_FACTOR_M               (0x3 << 0)
 105 #define A10_PLL6_FACTOR_M_SHIFT         0
 106
 107 #define A10_PLL2_POST_DIV               (0xf << 26)
 108
 109 #define A13_PLL2_POST_DIV               (0xf << 26)
 110 #define A13_PLL2_POST_DIV_SHIFT         26
 111 #define A13_PLL2_FACTOR_N               (0x7f << 8)
 112 #define A13_PLL2_FACTOR_N_SHIFT         8
 113 #define A13_PLL2_PRE_DIV                (0x1f << 0)
 114 #define A13_PLL2_PRE_DIV_SHIFT          0
 115
 116 #define A23_PLL1_FACTOR_P               (0x3 << 16)
 117 #define A23_PLL1_FACTOR_P_SHIFT         16
 118 #define A23_PLL1_FACTOR_N               (0x1f << 8)
 119 #define A23_PLL1_FACTOR_N_SHIFT         8
 120 #define A23_PLL1_FACTOR_K               (0x3 << 4)
 121 #define A23_PLL1_FACTOR_K_SHIFT         4
 122 #define A23_PLL1_FACTOR_M               (0x3 << 0)
 123 #define A23_PLL1_FACTOR_M_SHIFT         0
 124
 125 #define A31_PLL1_LOCK                   (1 << 28)
 126 #define A31_PLL1_CPU_SIGMA_DELTA_EN     (1 << 24)
 127 #define A31_PLL1_FACTOR_N               (0x1f << 8)
 128 #define A31_PLL1_FACTOR_N_SHIFT         8
 129 #define A31_PLL1_FACTOR_K               (0x3 << 4)
 130 #define A31_PLL1_FACTOR_K_SHIFT         4
 131 #define A31_PLL1_FACTOR_M               (0x3 << 0)
 132 #define A31_PLL1_FACTOR_M_SHIFT         0
 133
 134 #define A31_PLL6_LOCK                   (1 << 28)
 135 #define A31_PLL6_BYPASS_EN              (1 << 25)
 136 #define A31_PLL6_CLK_OUT_EN             (1 << 24)
 137 #define A31_PLL6_24M_OUT_EN             (1 << 18)
 138 #define A31_PLL6_24M_POST_DIV           (0x3 << 16)
 139 #define A31_PLL6_24M_POST_DIV_SHIFT     16
 140 #define A31_PLL6_FACTOR_N               (0x1f << 8)
 141 #define A31_PLL6_FACTOR_N_SHIFT         8
 142 #define A31_PLL6_FACTOR_K               (0x3 << 4)
 143 #define A31_PLL6_FACTOR_K_SHIFT         4
 144 #define A31_PLL6_DEFAULT_N              0x18
 145 #define A31_PLL6_DEFAULT_K              0x1
 146 #define A31_PLL6_TIMEOUT                10
 147
 148 #define A64_PLLHSIC_LOCK                (1 << 28)
 149 #define A64_PLLHSIC_FRAC_CLK_OUT        (1 << 25)
 150 #define A64_PLLHSIC_PLL_MODE_SEL        (1 << 24)
 151 #define A64_PLLHSIC_PLL_SDM_EN          (1 << 20)
 152 #define A64_PLLHSIC_FACTOR_N            (0x7f << 8)
 153 #define A64_PLLHSIC_FACTOR_N_SHIFT      8
 154 #define A64_PLLHSIC_PRE_DIV_M           (0xf << 0)
 155 #define A64_PLLHSIC_PRE_DIV_M_SHIFT     0
 156
 157 #define A80_PLL4_CLK_OUT_EN             (1 << 20)
 158 #define A80_PLL4_PLL_DIV2               (1 << 18)
 159 #define A80_PLL4_PLL_DIV1               (1 << 16)
 160 #define A80_PLL4_FACTOR_N               (0xff << 8)
 161 #define A80_PLL4_FACTOR_N_SHIFT         8
 162
 163 #define A83T_PLLCPUX_LOCK_TIME          (0x7 << 24)
 164 #define A83T_PLLCPUX_LOCK_TIME_SHIFT    24
 165 #define A83T_PLLCPUX_CLOCK_OUTPUT_DIS   (1 << 20)
 166 #define A83T_PLLCPUX_OUT_EXT_DIVP       (1 << 16)
 167 #define A83T_PLLCPUX_FACTOR_N           (0xff << 8)
 168 #define A83T_PLLCPUX_FACTOR_N_SHIFT     8
 169 #define A83T_PLLCPUX_FACTOR_N_MIN       12
 170 #define A83T_PLLCPUX_FACTOR_N_MAX       125
 171 #define A83T_PLLCPUX_POSTDIV_M          (0x3 << 0)
 172 #define A83T_PLLCPUX_POSTDIV_M_SHIFT    0
 173
 174 #define H3_PLL2_LOCK                    (1 << 28)
 175 #define H3_PLL2_SDM_EN                  (1 << 24)
 176 #define H3_PLL2_POST_DIV                (0xf << 16)
 177 #define H3_PLL2_POST_DIV_SHIFT          16
 178 #define H3_PLL2_FACTOR_N                (0x7f << 8)
 179 #define H3_PLL2_FACTOR_N_SHIFT          8
 180 #define H3_PLL2_PRE_DIV                 (0x1f << 0)
 181 #define H3_PLL2_PRE_DIV_SHIFT           0
 182
 183 #define CLKID_A10_PLL5_DDR              0
 184 #define CLKID_A10_PLL5_OTHER            1
 185
 186 #define CLKID_A10_PLL6_SATA             0
 187 #define CLKID_A10_PLL6_OTHER            1
 188 #define CLKID_A10_PLL6                  2
 189 #define CLKID_A10_PLL6_DIV_4            3
 190
 191 #define CLKID_A31_PLL6                  0
 192 #define CLKID_A31_PLL6_X2               1
 193
 194 struct aw_pll_factor {
 195         unsigned int            n;
 196         unsigned int            k;
 197         unsigned int            m;
 198         unsigned int            p;
 199         uint64_t                freq;
 200 };
 201 #define PLLFACTOR(_n, _k, _m, _p, _freq)        \
 202         { .n = (_n), .k = (_k), .m = (_m), .p = (_p), .freq = (_freq) }
 203
 204 static struct aw_pll_factor aw_a10_pll1_factors[] = {
 205         PLLFACTOR(6, 0, 0, 0, 144000000),
 206         PLLFACTOR(12, 0, 0, 0, 312000000),
 207         PLLFACTOR(21, 0, 0, 0, 528000000),
 208         PLLFACTOR(29, 0, 0, 0, 720000000),
 209         PLLFACTOR(18, 1, 0, 0, 864000000),
 210         PLLFACTOR(19, 1, 0, 0, 912000000),
 211         PLLFACTOR(20, 1, 0, 0, 960000000),
 212 };
 213
 214 static struct aw_pll_factor aw_a23_pll1_factors[] = {
 215         PLLFACTOR(9, 0, 0, 2, 60000000),
 216         PLLFACTOR(10, 0, 0, 2, 66000000),
 217         PLLFACTOR(11, 0, 0, 2, 72000000),
 218         PLLFACTOR(12, 0, 0, 2, 78000000),
 219         PLLFACTOR(13, 0, 0, 2, 84000000),
 220         PLLFACTOR(14, 0, 0, 2, 90000000),
 221         PLLFACTOR(15, 0, 0, 2, 96000000),
 222         PLLFACTOR(16, 0, 0, 2, 102000000),
 223         PLLFACTOR(17, 0, 0, 2, 108000000),
 224         PLLFACTOR(18, 0, 0, 2, 114000000),
 225         PLLFACTOR(9, 0, 0, 1, 120000000),
 226         PLLFACTOR(10, 0, 0, 1, 132000000),
 227         PLLFACTOR(11, 0, 0, 1, 144000000),
 228         PLLFACTOR(12, 0, 0, 1, 156000000),
 229         PLLFACTOR(13, 0, 0, 1, 168000000),
 230         PLLFACTOR(14, 0, 0, 1, 180000000),
 231         PLLFACTOR(15, 0, 0, 1, 192000000),
 232         PLLFACTOR(16, 0, 0, 1, 204000000),
 233         PLLFACTOR(17, 0, 0, 1, 216000000),
 234         PLLFACTOR(18, 0, 0, 1, 228000000),
 235         PLLFACTOR(9, 0, 0, 0, 240000000),
 236         PLLFACTOR(10, 0, 0, 0, 264000000),
 237         PLLFACTOR(11, 0, 0, 0, 288000000),
 238         PLLFACTOR(12, 0, 0, 0, 312000000),
 239         PLLFACTOR(13, 0, 0, 0, 336000000),
 240         PLLFACTOR(14, 0, 0, 0, 360000000),
 241         PLLFACTOR(15, 0, 0, 0, 384000000),
 242         PLLFACTOR(16, 0, 0, 0, 408000000),
 243         PLLFACTOR(17, 0, 0, 0, 432000000),
 244         PLLFACTOR(18, 0, 0, 0, 456000000),
 245         PLLFACTOR(19, 0, 0, 0, 480000000),
 246         PLLFACTOR(20, 0, 0, 0, 504000000),
 247         PLLFACTOR(21, 0, 0, 0, 528000000),
 248         PLLFACTOR(22, 0, 0, 0, 552000000),
 249         PLLFACTOR(23, 0, 0, 0, 576000000),
 250         PLLFACTOR(24, 0, 0, 0, 600000000),
 251         PLLFACTOR(25, 0, 0, 0, 624000000),
 252         PLLFACTOR(26, 0, 0, 0, 648000000),
 253         PLLFACTOR(27, 0, 0, 0, 672000000),
 254         PLLFACTOR(28, 0, 0, 0, 696000000),
 255         PLLFACTOR(29, 0, 0, 0, 720000000),
 256         PLLFACTOR(15, 1, 0, 0, 768000000),
 257         PLLFACTOR(10, 2, 0, 0, 792000000),
 258         PLLFACTOR(16, 1, 0, 0, 816000000),
 259         PLLFACTOR(17, 1, 0, 0, 864000000),
 260         PLLFACTOR(18, 1, 0, 0, 912000000),
 261         PLLFACTOR(12, 2, 0, 0, 936000000),
 262         PLLFACTOR(19, 1, 0, 0, 960000000),
 263         PLLFACTOR(20, 1, 0, 0, 1008000000),
 264         PLLFACTOR(21, 1, 0, 0, 1056000000),
 265         PLLFACTOR(14, 2, 0, 0, 1080000000),
 266         PLLFACTOR(22, 1, 0, 0, 1104000000),
 267         PLLFACTOR(23, 1, 0, 0, 1152000000),
 268         PLLFACTOR(24, 1, 0, 0, 1200000000),
 269         PLLFACTOR(16, 2, 0, 0, 1224000000),
 270         PLLFACTOR(25, 1, 0, 0, 1248000000),
 271         PLLFACTOR(26, 1, 0, 0, 1296000000),
 272         PLLFACTOR(27, 1, 0, 0, 1344000000),
 273         PLLFACTOR(18, 2, 0, 0, 1368000000),
 274         PLLFACTOR(28, 1, 0, 0, 1392000000),
 275         PLLFACTOR(29, 1, 0, 0, 1440000000),
 276         PLLFACTOR(20, 2, 0, 0, 1512000000),
 277         PLLFACTOR(15, 3, 0, 0, 1536000000),
 278         PLLFACTOR(21, 2, 0, 0, 1584000000),
 279         PLLFACTOR(16, 3, 0, 0, 1632000000),
 280         PLLFACTOR(22, 2, 0, 0, 1656000000),
 281         PLLFACTOR(23, 2, 0, 0, 1728000000),
 282         PLLFACTOR(24, 2, 0, 0, 1800000000),
 283         PLLFACTOR(18, 3, 0, 0, 1824000000),
 284         PLLFACTOR(25, 2, 0, 0, 1872000000),
 285 };
 286
 287 static struct aw_pll_factor aw_h3_pll2_factors[] = {
 288         PLLFACTOR(13, 0, 0, 13, 24576000),
 289         PLLFACTOR(6, 0, 0, 7, 22579200),
 290 };
 291
 292 enum aw_pll_type {
 293         AWPLL_A10_PLL1 = 1,
 294         AWPLL_A10_PLL2,
 295         AWPLL_A10_PLL3,
 296         AWPLL_A10_PLL5,
 297         AWPLL_A10_PLL6,
 298         AWPLL_A13_PLL2,
 299         AWPLL_A23_PLL1,
 300         AWPLL_A31_PLL1,
 301         AWPLL_A31_PLL6,
 302         AWPLL_A64_PLLHSIC,
 303         AWPLL_A80_PLL4,
 304         AWPLL_A83T_PLLCPUX,
 305         AWPLL_H3_PLL1,
 306         AWPLL_H3_PLL2,
 307 };
 308
 309 struct aw_pll_sc {
 310         enum aw_pll_type        type;
 311         device_t                clkdev;
 312         bus_addr_t              reg;
 313         int                     id;
 314 };
 315
 316 struct aw_pll_funcs {
 317         int     (*recalc)(struct aw_pll_sc *, uint64_t *);
 318         int     (*set_freq)(struct aw_pll_sc *, uint64_t, uint64_t *, int);
 319         int     (*init)(device_t, bus_addr_t, struct clknode_init_def *);
 320 };
 321
 322 #define PLL_READ(sc, val)       CLKDEV_READ_4((sc)->clkdev, (sc)->reg, (val))
 323 #define PLL_WRITE(sc, val)      CLKDEV_WRITE_4((sc)->clkdev, (sc)->reg, (val))
 324 #define DEVICE_LOCK(sc)         CLKDEV_DEVICE_LOCK((sc)->clkdev)
 325 #define DEVICE_UNLOCK(sc)       CLKDEV_DEVICE_UNLOCK((sc)->clkdev)
 326
 327 static int
 328 a10_pll1_set_freq(struct aw_pll_sc *sc, uint64_t fin, uint64_t *fout,
 329     int flags)
 330 {
 331         struct aw_pll_factor *f;
 332         uint32_t val;
 333         int n;
 334
 335         f = NULL;
 336         for (n = 0; n < nitems(aw_a10_pll1_factors); n++) {
 337                 if (aw_a10_pll1_factors[n].freq == *fout) {
 338                         f = &aw_a10_pll1_factors[n];
 339                         break;
 340                 }
 341         }
 342         if (f == NULL)
 343                 return (EINVAL);
 344
 345         DEVICE_LOCK(sc);
 346         PLL_READ(sc, &val);
 347         val &= ~(A10_PLL1_FACTOR_N|A10_PLL1_FACTOR_K|A10_PLL1_FACTOR_M|
 348                 A10_PLL1_OUT_EXT_DIVP);
 349         val |= (f->p << A10_PLL1_OUT_EXT_DIVP_SHIFT);
 350         val |= (f->n << A10_PLL1_FACTOR_N_SHIFT);
 351         val |= (f->k << A10_PLL1_FACTOR_K_SHIFT);
 352         val |= (f->m << A10_PLL1_FACTOR_M_SHIFT);
 353         PLL_WRITE(sc, val);
 354         DEVICE_UNLOCK(sc);
 355
 356         return (0);
 357 }
 358
 359 static int
 360 a10_pll1_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 361 {
 362         uint32_t val, m, n, k, p;
 363
 364         DEVICE_LOCK(sc);
 365         PLL_READ(sc, &val);
 366         DEVICE_UNLOCK(sc);
 367
 368         p = 1 << ((val & A10_PLL1_OUT_EXT_DIVP) >> A10_PLL1_OUT_EXT_DIVP_SHIFT);
 369         m = ((val & A10_PLL1_FACTOR_M) >> A10_PLL1_FACTOR_M_SHIFT) + 1;
 370         k = ((val & A10_PLL1_FACTOR_K) >> A10_PLL1_FACTOR_K_SHIFT) + 1;
 371         n = (val & A10_PLL1_FACTOR_N) >> A10_PLL1_FACTOR_N_SHIFT;
 372         if (n == 0)
 373                 n = 1;
 374
 375         *freq = (*freq * n * k) / (m * p);
 376
 377         return (0);
 378 }
 379
 380 static int
 381 a10_pll2_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 382 {
 383         uint32_t val, post_div, n, pre_div;
 384
 385         DEVICE_LOCK(sc);
 386         PLL_READ(sc, &val);
 387         DEVICE_UNLOCK(sc);
 388
 389         post_div = (val & A10_PLL2_POST_DIV) >> A10_PLL2_POST_DIV_SHIFT;
 390         if (post_div == 0)
 391                 post_div = 1;
 392         n = (val & A10_PLL2_FACTOR_N) >> A10_PLL2_FACTOR_N_SHIFT;
 393         if (n == 0)
 394                 n = 1;
 395         pre_div = (val & A10_PLL2_PRE_DIV) >> A10_PLL2_PRE_DIV_SHIFT;
 396         if (pre_div == 0)
 397                 pre_div = 1;
 398
 399         switch (sc->id) {
 400         case SUN4I_A10_PLL2_1X:
 401                 *freq = (*freq * 2 * n) / pre_div / post_div / 2;
 402                 break;
 403         case SUN4I_A10_PLL2_2X:
 404                 *freq = (*freq * 2 * n) / pre_div / 4;
 405                 break;
 406         case SUN4I_A10_PLL2_4X:
 407                 *freq = (*freq * 2 * n) / pre_div / 2;
 408                 break;
 409         case SUN4I_A10_PLL2_8X:
 410                 *freq = (*freq * 2 * n) / pre_div;
 411                 break;
 412         default:
 413                 return (EINVAL);
 414         }
 415
 416         return (0);
 417 }
 418
 419 static int
 420 a10_pll2_set_freq(struct aw_pll_sc *sc, uint64_t fin, uint64_t *fout,
 421     int flags)
 422 {
 423         uint32_t val, post_div, n, pre_div;
 424
 425         if (sc->id != SUN4I_A10_PLL2_1X)
 426                 return (ENXIO);
 427
 428         /*
 429          * Audio Codec needs PLL2-1X to be either 24576000 or 22579200.
 430          *
 431          * PLL2-1X output frequency is (48MHz * n) / pre_div / post_div / 2.
 432          * To get as close as possible to the desired rate, we use a
 433          * pre-divider of 21 and a post-divider of 4. With these values,
 434          * a multiplier of 86 or 79 gets us close to the target rates.
 435          */
 436         if (*fout != 24576000 && *fout != 22579200)
 437                 return (EINVAL);
 438
 439         pre_div = 21;
 440         post_div = 4;
 441         n = (*fout * pre_div * post_div * 2) / (2 * fin);
 442
 443         DEVICE_LOCK(sc);
 444         PLL_READ(sc, &val);
 445         val &= ~(A10_PLL2_POST_DIV | A10_PLL2_FACTOR_N | A10_PLL2_PRE_DIV);
 446         val |= (post_div << A10_PLL2_POST_DIV_SHIFT);
 447         val |= (n << A10_PLL2_FACTOR_N_SHIFT);
 448         val |= (pre_div << A10_PLL2_PRE_DIV_SHIFT);
 449         PLL_WRITE(sc, val);
 450         DEVICE_UNLOCK(sc);
 451
 452         return (0);
 453 }
 454
 455 static int
 456 a10_pll3_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 457 {
 458         uint32_t val, m;
 459
 460         DEVICE_LOCK(sc);
 461         PLL_READ(sc, &val);
 462         DEVICE_UNLOCK(sc);
 463
 464         if ((val & A10_PLL3_MODE_SEL) == A10_PLL3_MODE_SEL_INT) {
 465                 /* In integer mode, output is 3MHz * m */
 466                 m = (val & A10_PLL3_FACTOR_M) >> A10_PLL3_FACTOR_M_SHIFT;
 467                 *freq = A10_PLL3_REF_FREQ * m;
 468         } else {
 469                 /* In fractional mode, output is either 270MHz or 297MHz */
 470                 if ((val & A10_PLL3_FUNC_SET) == A10_PLL3_FUNC_SET_270MHZ)
 471                         *freq = 270000000;
 472                 else
 473                         *freq = 297000000;
 474         }
 475
 476         return (0);
 477 }
 478
 479 static int
 480 a10_pll3_set_freq(struct aw_pll_sc *sc, uint64_t fin, uint64_t *fout,
 481     int flags)
 482 {
 483         uint32_t val, m, mode, func;
 484
 485         if (*fout == 297000000) {
 486                 func = A10_PLL3_FUNC_SET_297MHZ;
 487                 mode = A10_PLL3_MODE_SEL_FRACT;
 488                 m = 0;
 489         } else if (*fout == 270000000) {
 490                 func = A10_PLL3_FUNC_SET_270MHZ;
 491                 mode = A10_PLL3_MODE_SEL_FRACT;
 492                 m = 0;
 493         } else {
 494                 mode = A10_PLL3_MODE_SEL_INT;
 495                 func = 0;
 496                 m = *fout / A10_PLL3_REF_FREQ;
 497                 *fout = m * A10_PLL3_REF_FREQ;
 498         }
 499
 500         DEVICE_LOCK(sc);
 501         PLL_READ(sc, &val);
 502         val &= ~(A10_PLL3_MODE_SEL | A10_PLL3_FUNC_SET | A10_PLL3_FACTOR_M);
 503         val |= mode;
 504         val |= func;
 505         val |= (m << A10_PLL3_FACTOR_M_SHIFT);
 506         PLL_WRITE(sc, val);
 507         DEVICE_UNLOCK(sc);
 508
 509         return (0);
 510 }
 511
 512 static int
 513 a10_pll3_init(device_t dev, bus_addr_t reg, struct clknode_init_def *def)
 514 {
 515         uint32_t val;
 516
 517         /* Allow changing PLL frequency while enabled */
 518         def->flags = CLK_NODE_GLITCH_FREE;
 519
 520         /* Set PLL to 297MHz */
 521         CLKDEV_DEVICE_LOCK(dev);
 522         CLKDEV_READ_4(dev, reg, &val);
 523         val &= ~(A10_PLL3_MODE_SEL | A10_PLL3_FUNC_SET | A10_PLL3_FACTOR_M);
 524         val |= A10_PLL3_MODE_SEL_FRACT;
 525         val |= A10_PLL3_FUNC_SET_297MHZ;
 526         CLKDEV_WRITE_4(dev, reg, val);
 527         CLKDEV_DEVICE_UNLOCK(dev);
 528
 529         return (0);
 530 }
 531
 532 static int
 533 a10_pll5_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 534 {
 535         uint32_t val, m, n, k, p;
 536
 537         DEVICE_LOCK(sc);
 538         PLL_READ(sc, &val);
 539         DEVICE_UNLOCK(sc);
 540
 541         p = 1 << ((val & A10_PLL5_OUT_EXT_DIVP) >> A10_PLL5_OUT_EXT_DIVP_SHIFT);
 542         m = ((val & A10_PLL5_FACTOR_M) >> A10_PLL5_FACTOR_M_SHIFT) + 1;
 543         k = ((val & A10_PLL5_FACTOR_K) >> A10_PLL5_FACTOR_K_SHIFT) + 1;
 544         n = (val & A10_PLL5_FACTOR_N) >> A10_PLL5_FACTOR_N_SHIFT;
 545         if (n == 0)
 546                 return (ENXIO);
 547
 548         switch (sc->id) {
 549         case CLKID_A10_PLL5_DDR:
 550                 *freq = (*freq * n * k) / m;
 551                 break;
 552         case CLKID_A10_PLL5_OTHER:
 553                 *freq = (*freq * n * k) / p;
 554                 break;
 555         default:
 556                 return (ENXIO);
 557         }
 558
 559         return (0);
 560 }
 561
 562 static int
 563 a10_pll6_init(device_t dev, bus_addr_t reg, struct clknode_init_def *def)
 564 {
 565         uint32_t val, m, n, k;
 566
 567         /*
 568          * SATA needs PLL6 to be a 100MHz clock.
 569          *
 570          * The SATA output frequency is (24MHz * n * k) / m / 6.
 571          * To get to 100MHz, k & m must be equal and n must be 25.
 572          */
 573         m = k = 0;
 574         n = 25;
 575
 576         CLKDEV_DEVICE_LOCK(dev);
 577         CLKDEV_READ_4(dev, reg, &val);
 578         val &= ~(A10_PLL6_FACTOR_N | A10_PLL6_FACTOR_K | A10_PLL6_FACTOR_M);
 579         val &= ~A10_PLL6_BYPASS_EN;
 580         val |= A10_PLL6_SATA_CLK_EN;
 581         val |= (n << A10_PLL6_FACTOR_N_SHIFT);
 582         val |= (k << A10_PLL6_FACTOR_K_SHIFT);
 583         val |= (m << A10_PLL6_FACTOR_M_SHIFT);
 584         CLKDEV_WRITE_4(dev, reg, val);
 585         CLKDEV_DEVICE_UNLOCK(dev);
 586
 587         return (0);
 588 }
 589
 590 static int
 591 a10_pll6_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 592 {
 593         uint32_t val, m, k, n;
 594
 595         DEVICE_LOCK(sc);
 596         PLL_READ(sc, &val);
 597         DEVICE_UNLOCK(sc);
 598
 599         m = ((val & A10_PLL6_FACTOR_M) >> A10_PLL6_FACTOR_M_SHIFT) + 1;
 600         k = ((val & A10_PLL6_FACTOR_K) >> A10_PLL6_FACTOR_K_SHIFT) + 1;
 601         n = (val & A10_PLL6_FACTOR_N) >> A10_PLL6_FACTOR_N_SHIFT;
 602         if (n == 0)
 603                 return (ENXIO);
 604
 605         switch (sc->id) {
 606         case CLKID_A10_PLL6_SATA:
 607                 *freq = (*freq * n * k) / m / 6;
 608                 break;
 609         case CLKID_A10_PLL6_OTHER:
 610                 *freq = (*freq * n * k) / 2;
 611                 break;
 612         case CLKID_A10_PLL6:
 613                 *freq = (*freq * n * k);
 614                 break;
 615         case CLKID_A10_PLL6_DIV_4:
 616                 *freq = (*freq * n * k) / 4;
 617                 break;
 618         default:
 619                 return (ENXIO);
 620         }
 621
 622         return (0);
 623 }
 624
 625 static int
 626 a10_pll6_set_freq(struct aw_pll_sc *sc, uint64_t fin, uint64_t *fout,
 627     int flags)
 628 {
 629         if (sc->id != CLKID_A10_PLL6_SATA)
 630                 return (ENXIO);
 631
 632         /* PLL6 SATA output has been set to 100MHz in a10_pll6_init */
 633         if (*fout != 100000000)
 634                 return (ERANGE);
 635
 636         return (0);
 637 }
 638
 639 static int
 640 a13_pll2_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 641 {
 642         uint32_t val, post_div, n, pre_div;
 643
 644         DEVICE_LOCK(sc);
 645         PLL_READ(sc, &val);
 646         DEVICE_UNLOCK(sc);
 647
 648         post_div = ((val & A13_PLL2_POST_DIV) >> A13_PLL2_POST_DIV_SHIFT) + 1;
 649         if (post_div == 0)
 650                 post_div = 1;
 651         n = (val & A13_PLL2_FACTOR_N) >> A13_PLL2_FACTOR_N_SHIFT;
 652         if (n == 0)
 653                 n = 1;
 654         pre_div = ((val & A13_PLL2_PRE_DIV) >> A13_PLL2_PRE_DIV_SHIFT) + 1;
 655         if (pre_div == 0)
 656                 pre_div = 1;
 657
 658         switch (sc->id) {
 659         case SUN4I_A10_PLL2_1X:
 660                 *freq = (*freq * 2 * n) / pre_div / post_div / 2;
 661                 break;
 662         case SUN4I_A10_PLL2_2X:
 663                 *freq = (*freq * 2 * n) / pre_div / 4;
 664                 break;
 665         case SUN4I_A10_PLL2_4X:
 666                 *freq = (*freq * 2 * n) / pre_div / 2;
 667                 break;
 668         case SUN4I_A10_PLL2_8X:
 669                 *freq = (*freq * 2 * n) / pre_div;
 670                 break;
 671         default:
 672                 return (EINVAL);
 673         }
 674
 675         return (0);
 676 }
 677
 678 static int
 679 a13_pll2_set_freq(struct aw_pll_sc *sc, uint64_t fin, uint64_t *fout,
 680     int flags)
 681 {
 682         uint32_t val, post_div, n, pre_div;
 683
 684         if (sc->id != SUN4I_A10_PLL2_1X)
 685                 return (ENXIO);
 686
 687         /*
 688          * Audio Codec needs PLL2-1X to be either 24576000 or 22579200.
 689          *
 690          * PLL2-1X output frequency is (48MHz * n) / pre_div / post_div / 2.
 691          * To get as close as possible to the desired rate, we use a
 692          * pre-divider of 21 and a post-divider of 4. With these values,
 693          * a multiplier of 86 or 79 gets us close to the target rates.
 694          */
 695         if (*fout != 24576000 && *fout != 22579200)
 696                 return (EINVAL);
 697
 698         pre_div = 21;
 699         post_div = 4;
 700         n = (*fout * pre_div * post_div * 2) / (2 * fin);
 701
 702         DEVICE_LOCK(sc);
 703         PLL_READ(sc, &val);
 704         val &= ~(A13_PLL2_POST_DIV | A13_PLL2_FACTOR_N | A13_PLL2_PRE_DIV);
 705         val |= ((post_div - 1) << A13_PLL2_POST_DIV_SHIFT);
 706         val |= (n << A13_PLL2_FACTOR_N_SHIFT);
 707         val |= ((pre_div - 1) << A13_PLL2_PRE_DIV_SHIFT);
 708         PLL_WRITE(sc, val);
 709         DEVICE_UNLOCK(sc);
 710
 711         return (0);
 712 }
 713
 714 static int
 715 h3_pll2_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 716 {
 717         uint32_t val, p, n, m;
 718
 719         DEVICE_LOCK(sc);
 720         PLL_READ(sc, &val);
 721         DEVICE_UNLOCK(sc);
 722
 723         p = ((val & H3_PLL2_POST_DIV) >> H3_PLL2_POST_DIV_SHIFT) + 1;
 724         n = ((val & H3_PLL2_FACTOR_N) >> H3_PLL2_FACTOR_N_SHIFT) + 1;
 725         m = ((val & H3_PLL2_PRE_DIV) >> H3_PLL2_PRE_DIV_SHIFT) + 1;
 726
 727         switch (sc->id) {
 728         case SUN4I_A10_PLL2_1X:
 729                 *freq = (*freq * n) / (m * p);
 730                 break;
 731         case SUN4I_A10_PLL2_2X:
 732                 *freq = (*freq * 2 * n) / m / 4;
 733                 break;
 734         case SUN4I_A10_PLL2_4X:
 735                 *freq = (*freq * 2 * n) / m / 2;
 736                 break;
 737         case SUN4I_A10_PLL2_8X:
 738                 *freq = (*freq * 2 * n) / m;
 739                 break;
 740         default:
 741                 return (EINVAL);
 742         }
 743
 744         return (0);
 745 }
 746
 747 static int
 748 h3_pll2_set_freq(struct aw_pll_sc *sc, uint64_t fin, uint64_t *fout,
 749     int flags)
 750 {
 751         struct aw_pll_factor *f;
 752         uint32_t val;
 753         int n, error, retry;
 754
 755         if (sc->id != SUN4I_A10_PLL2_1X)
 756                 return (ENXIO);
 757
 758         f = NULL;
 759         for (n = 0; n < nitems(aw_h3_pll2_factors); n++) {
 760                 if (aw_h3_pll2_factors[n].freq == *fout) {
 761                         f = &aw_h3_pll2_factors[n];
 762                         break;
 763                 }
 764         }
 765         if (f == NULL)
 766                 return (EINVAL);
 767
 768         DEVICE_LOCK(sc);
 769         PLL_READ(sc, &val);
 770         val &= ~(H3_PLL2_POST_DIV|H3_PLL2_FACTOR_N|H3_PLL2_PRE_DIV);
 771         val |= (f->p << H3_PLL2_POST_DIV_SHIFT);
 772         val |= (f->n << H3_PLL2_FACTOR_N_SHIFT);
 773         val |= (f->m << H3_PLL2_PRE_DIV_SHIFT);
 774         val |= AW_PLL_ENABLE;
 775         PLL_WRITE(sc, val);
 776
 777         /* Wait for lock */
 778         error = 0;
 779         for (retry = 0; retry < 1000; retry++) {
 780                 PLL_READ(sc, &val);
 781                 if ((val & H3_PLL2_LOCK) != 0)
 782                         break;
 783                 DELAY(100);
 784         }
 785         if (retry == 0)
 786                 error = ETIMEDOUT;
 787
 788         DEVICE_UNLOCK(sc);
 789
 790         return (error);
 791 }
 792
 793 static int
 794 a23_pll1_set_freq(struct aw_pll_sc *sc, uint64_t fin, uint64_t *fout,
 795     int flags)
 796 {
 797         struct aw_pll_factor *f;
 798         uint32_t val;
 799         int n;
 800
 801         f = NULL;
 802         for (n = 0; n < nitems(aw_a23_pll1_factors); n++) {
 803                 if (aw_a23_pll1_factors[n].freq == *fout) {
 804                         f = &aw_a23_pll1_factors[n];
 805                         break;
 806                 }
 807         }
 808         if (f == NULL)
 809                 return (EINVAL);
 810
 811         DEVICE_LOCK(sc);
 812         PLL_READ(sc, &val);
 813         val &= ~(A23_PLL1_FACTOR_N|A23_PLL1_FACTOR_K|A23_PLL1_FACTOR_M|
 814                  A23_PLL1_FACTOR_P);
 815         val |= (f->n << A23_PLL1_FACTOR_N_SHIFT);
 816         val |= (f->k << A23_PLL1_FACTOR_K_SHIFT);
 817         val |= (f->m << A23_PLL1_FACTOR_M_SHIFT);
 818         val |= (f->p << A23_PLL1_FACTOR_P_SHIFT);
 819         PLL_WRITE(sc, val);
 820         DEVICE_UNLOCK(sc);
 821
 822         return (0);
 823
 824 }
 825
 826 static int
 827 a23_pll1_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 828 {
 829         uint32_t val, m, n, k, p;
 830
 831         DEVICE_LOCK(sc);
 832         PLL_READ(sc, &val);
 833         DEVICE_UNLOCK(sc);
 834
 835         m = ((val & A23_PLL1_FACTOR_M) >> A23_PLL1_FACTOR_M_SHIFT) + 1;
 836         k = ((val & A23_PLL1_FACTOR_K) >> A23_PLL1_FACTOR_K_SHIFT) + 1;
 837         n = ((val & A23_PLL1_FACTOR_N) >> A23_PLL1_FACTOR_N_SHIFT) + 1;
 838         p = ((val & A23_PLL1_FACTOR_P) >> A23_PLL1_FACTOR_P_SHIFT) + 1;
 839
 840         *freq = (*freq * n * k) / (m * p);
 841
 842         return (0);
 843 }
 844
 845 static int
 846 h3_pll1_set_freq(struct aw_pll_sc *sc, uint64_t fin, uint64_t *fout,
 847     int flags)
 848 {
 849         struct aw_pll_factor *f;
 850         uint32_t val, n, k, m, p;
 851         int i;
 852
 853         f = NULL;
 854         for (i = 0; i < nitems(aw_a23_pll1_factors); i++) {
 855                 if (aw_a23_pll1_factors[i].freq == *fout) {
 856                         f = &aw_a23_pll1_factors[i];
 857                         break;
 858                 }
 859         }
 860         if (f == NULL)
 861                 return (EINVAL);
 862
 863         DEVICE_LOCK(sc);
 864         PLL_READ(sc, &val);
 865
 866         n = (val & A23_PLL1_FACTOR_N) >> A23_PLL1_FACTOR_N_SHIFT;
 867         k = (val & A23_PLL1_FACTOR_K) >> A23_PLL1_FACTOR_K_SHIFT;
 868         m = (val & A23_PLL1_FACTOR_M) >> A23_PLL1_FACTOR_M_SHIFT;
 869         p = (val & A23_PLL1_FACTOR_P) >> A23_PLL1_FACTOR_P_SHIFT;
 870
 871         if (p < f->p) {
 872                 val &= ~A23_PLL1_FACTOR_P;
 873                 val |= (f->p << A23_PLL1_FACTOR_P_SHIFT);
 874                 PLL_WRITE(sc, val);
 875                 DELAY(2000);
 876         }
 877
 878         if (m < f->m) {
 879                 val &= ~A23_PLL1_FACTOR_M;
 880                 val |= (f->m << A23_PLL1_FACTOR_M_SHIFT);
 881                 PLL_WRITE(sc, val);
 882                 DELAY(2000);
 883         }
 884
 885         val &= ~(A23_PLL1_FACTOR_N|A23_PLL1_FACTOR_K);
 886         val |= (f->n << A23_PLL1_FACTOR_N_SHIFT);
 887         val |= (f->k << A23_PLL1_FACTOR_K_SHIFT);
 888         PLL_WRITE(sc, val);
 889         DELAY(2000);
 890
 891         if (m > f->m) {
 892                 val &= ~A23_PLL1_FACTOR_M;
 893                 val |= (f->m << A23_PLL1_FACTOR_M_SHIFT);
 894                 PLL_WRITE(sc, val);
 895                 DELAY(2000);
 896         }
 897
 898         if (p > f->p) {
 899                 val &= ~A23_PLL1_FACTOR_P;
 900                 val |= (f->p << A23_PLL1_FACTOR_P_SHIFT);
 901                 PLL_WRITE(sc, val);
 902                 DELAY(2000);
 903         }
 904
 905         DEVICE_UNLOCK(sc);
 906
 907         return (0);
 908
 909 }
 910
 911 static int
 912 a31_pll1_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 913 {
 914         uint32_t val, m, n, k;
 915
 916         DEVICE_LOCK(sc);
 917         PLL_READ(sc, &val);
 918         DEVICE_UNLOCK(sc);
 919
 920         m = ((val & A31_PLL1_FACTOR_M) >> A31_PLL1_FACTOR_M_SHIFT) + 1;
 921         k = ((val & A31_PLL1_FACTOR_K) >> A31_PLL1_FACTOR_K_SHIFT) + 1;
 922         n = ((val & A31_PLL1_FACTOR_N) >> A31_PLL1_FACTOR_N_SHIFT) + 1;
 923
 924         *freq = (*freq * n * k) / m;
 925
 926         return (0);
 927 }
 928
 929 static int
 930 a31_pll6_init(device_t dev, bus_addr_t reg, struct clknode_init_def *def)
 931 {
 932         uint32_t val;
 933         int retry;
 934
 935         if (def->id != CLKID_A31_PLL6)
 936                 return (0);
 937
 938         /*
 939          * The datasheet recommends that PLL6 output should be fixed to
 940          * 600MHz.
 941          */
 942         CLKDEV_DEVICE_LOCK(dev);
 943         CLKDEV_READ_4(dev, reg, &val);
 944         val &= ~(A31_PLL6_FACTOR_N | A31_PLL6_FACTOR_K | A31_PLL6_BYPASS_EN);
 945         val |= (A31_PLL6_DEFAULT_N << A31_PLL6_FACTOR_N_SHIFT);
 946         val |= (A31_PLL6_DEFAULT_K << A31_PLL6_FACTOR_K_SHIFT);
 947         val |= AW_PLL_ENABLE;
 948         CLKDEV_WRITE_4(dev, reg, val);
 949
 950         /* Wait for PLL to become stable */
 951         for (retry = A31_PLL6_TIMEOUT; retry > 0; retry--) {
 952                 CLKDEV_READ_4(dev, reg, &val);
 953                 if ((val & A31_PLL6_LOCK) == A31_PLL6_LOCK)
 954                         break;
 955                 DELAY(1);
 956         }
 957
 958         CLKDEV_DEVICE_UNLOCK(dev);
 959
 960         return (0);
 961 }
 962
 963 static int
 964 a31_pll6_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 965 {
 966         uint32_t val, k, n;
 967
 968         DEVICE_LOCK(sc);
 969         PLL_READ(sc, &val);
 970         DEVICE_UNLOCK(sc);
 971
 972         k = ((val & A10_PLL6_FACTOR_K) >> A10_PLL6_FACTOR_K_SHIFT) + 1;
 973         n = ((val & A10_PLL6_FACTOR_N) >> A10_PLL6_FACTOR_N_SHIFT) + 1;
 974
 975         switch (sc->id) {
 976         case CLKID_A31_PLL6:
 977                 *freq = (*freq * n * k) / 2;
 978                 break;
 979         case CLKID_A31_PLL6_X2:
 980                 *freq = *freq * n * k;
 981                 break;
 982         default:
 983                 return (ENXIO);
 984         }
 985
 986         return (0);
 987 }
 988
 989 static int
 990 a80_pll4_recalc(struct aw_pll_sc *sc, uint64_t *freq)
 991 {
 992         uint32_t val, n, div1, div2;
 993
 994         DEVICE_LOCK(sc);
 995         PLL_READ(sc, &val);
 996         DEVICE_UNLOCK(sc);
 997
 998         n = (val & A80_PLL4_FACTOR_N) >> A80_PLL4_FACTOR_N_SHIFT;
 999         div1 = (val & A80_PLL4_PLL_DIV1) == 0 ? 1 : 2;
1000         div2 = (val & A80_PLL4_PLL_DIV2) == 0 ? 1 : 2;
1001
1002         *freq = (*freq * n) / div1 / div2;
1003
1004         return (0);
1005 }
1006
1007 static int
1008 a64_pllhsic_recalc(struct aw_pll_sc *sc, uint64_t *freq)
1009 {
1010         uint32_t val, n, m;
1011
1012         DEVICE_LOCK(sc);
1013         PLL_READ(sc, &val);
1014         DEVICE_UNLOCK(sc);
1015
1016         n = ((val & A64_PLLHSIC_FACTOR_N) >> A64_PLLHSIC_FACTOR_N_SHIFT) + 1;
1017         m = ((val & A64_PLLHSIC_PRE_DIV_M) >> A64_PLLHSIC_PRE_DIV_M_SHIFT) + 1;
1018
1019         *freq = (*freq * n) / m;
1020
1021         return (0);
1022 }
1023
1024 static int
1025 a64_pllhsic_init(device_t dev, bus_addr_t reg, struct clknode_init_def *def)
1026 {
1027         uint32_t val;
1028
1029         /*
1030          * PLL_HSIC default is 480MHz, just enable it.
1031          */
1032         CLKDEV_DEVICE_LOCK(dev);
1033         CLKDEV_READ_4(dev, reg, &val);
1034         val |= AW_PLL_ENABLE;
1035         CLKDEV_WRITE_4(dev, reg, val);
1036         CLKDEV_DEVICE_UNLOCK(dev);
1037
1038         return (0);
1039 }
1040
1041 static int
1042 a83t_pllcpux_recalc(struct aw_pll_sc *sc, uint64_t *freq)
1043 {
1044         uint32_t val, n, p;
1045
1046         DEVICE_LOCK(sc);
1047         PLL_READ(sc, &val);
1048         DEVICE_UNLOCK(sc);
1049
1050         n = (val & A83T_PLLCPUX_FACTOR_N) >> A83T_PLLCPUX_FACTOR_N_SHIFT;
1051         p = (val & A83T_PLLCPUX_OUT_EXT_DIVP) ? 4 : 1;
1052
1053         *freq = (*freq * n) / p;
1054
1055         return (0);
1056 }
1057
1058 static int
1059 a83t_pllcpux_set_freq(struct aw_pll_sc *sc, uint64_t fin, uint64_t *fout,
1060     int flags)
1061 {
1062         uint32_t val;
1063         u_int n;
1064
1065         n = *fout / fin;
1066
1067         if (n < A83T_PLLCPUX_FACTOR_N_MIN || n > A83T_PLLCPUX_FACTOR_N_MAX)
1068                 return (EINVAL);
1069
1070         DEVICE_LOCK(sc);
1071         PLL_READ(sc, &val);
1072         val &= ~A83T_PLLCPUX_FACTOR_N;
1073         val |= (n << A83T_PLLCPUX_FACTOR_N_SHIFT);
1074         val &= ~A83T_PLLCPUX_CLOCK_OUTPUT_DIS;
1075         PLL_WRITE(sc, val);
1076         DEVICE_UNLOCK(sc);
1077
1078         return (0);
1079 }
1080
1081 #define PLL(_type, _recalc, _set_freq, _init)   \
1082         [(_type)] = {                           \
1083                 .recalc = (_recalc),            \
1084                 .set_freq = (_set_freq),        \
1085                 .init = (_init)                 \
1086         }
1087
1088 static struct aw_pll_funcs aw_pll_func[] = {
1089         PLL(AWPLL_A10_PLL1, a10_pll1_recalc, a10_pll1_set_freq, NULL),
1090         PLL(AWPLL_A10_PLL2, a10_pll2_recalc, a10_pll2_set_freq, NULL),
1091         PLL(AWPLL_A10_PLL3, a10_pll3_recalc, a10_pll3_set_freq, a10_pll3_init),
1092         PLL(AWPLL_A10_PLL5, a10_pll5_recalc, NULL, NULL),
1093         PLL(AWPLL_A10_PLL6, a10_pll6_recalc, a10_pll6_set_freq, a10_pll6_init),
1094         PLL(AWPLL_A13_PLL2, a13_pll2_recalc, a13_pll2_set_freq, NULL),
1095         PLL(AWPLL_A23_PLL1, a23_pll1_recalc, a23_pll1_set_freq, NULL),
1096         PLL(AWPLL_A31_PLL1, a31_pll1_recalc, NULL, NULL),
1097         PLL(AWPLL_A31_PLL6, a31_pll6_recalc, NULL, a31_pll6_init),
1098         PLL(AWPLL_A80_PLL4, a80_pll4_recalc, NULL, NULL),
1099         PLL(AWPLL_A83T_PLLCPUX, a83t_pllcpux_recalc, a83t_pllcpux_set_freq, NULL),
1100         PLL(AWPLL_A64_PLLHSIC, a64_pllhsic_recalc, NULL, a64_pllhsic_init),
1101         PLL(AWPLL_H3_PLL1, a23_pll1_recalc, h3_pll1_set_freq, NULL),
1102         PLL(AWPLL_H3_PLL2, h3_pll2_recalc, h3_pll2_set_freq, NULL),
1103 };
1104
1105 static struct ofw_compat_data compat_data[] = {
1106         { "allwinner,sun4i-a10-pll1-clk",       AWPLL_A10_PLL1 },
1107         { "allwinner,sun4i-a10-pll2-clk",       AWPLL_A10_PLL2 },
1108         { "allwinner,sun4i-a10-pll3-clk",       AWPLL_A10_PLL3 },
1109         { "allwinner,sun4i-a10-pll5-clk",       AWPLL_A10_PLL5 },
1110         { "allwinner,sun4i-a10-pll6-clk",       AWPLL_A10_PLL6 },
1111         { "allwinner,sun5i-a13-pll2-clk",       AWPLL_A13_PLL2 },
1112         { "allwinner,sun6i-a31-pll1-clk",       AWPLL_A31_PLL1 },
1113         { "allwinner,sun6i-a31-pll6-clk",       AWPLL_A31_PLL6 },
1114         { "allwinner,sun8i-a23-pll1-clk",       AWPLL_A23_PLL1 },
1115         { "allwinner,sun8i-a83t-pllcpux-clk",   AWPLL_A83T_PLLCPUX },
1116         { "allwinner,sun8i-h3-pll1-clk",        AWPLL_H3_PLL1 },
1117         { "allwinner,sun8i-h3-pll2-clk",        AWPLL_H3_PLL2 },
1118         { "allwinner,sun9i-a80-pll4-clk",       AWPLL_A80_PLL4 },
1119         { "allwinner,sun50i-a64-pllhsic-clk",   AWPLL_A64_PLLHSIC },
1120         { NULL, 0 }
1121 };
1122
1123 static int
1124 aw_pll_init(struct clknode *clk, device_t dev)
1125 {
1126         clknode_init_parent_idx(clk, 0);
1127         return (0);
1128 }
1129
1130 static int
1131 aw_pll_set_gate(struct clknode *clk, bool enable)
1132 {
1133         struct aw_pll_sc *sc;
1134         uint32_t val;
1135
1136         sc = clknode_get_softc(clk);
1137
1138         DEVICE_LOCK(sc);
1139         PLL_READ(sc, &val);
1140         if (enable)
1141                 val |= AW_PLL_ENABLE;
1142         else
1143                 val &= ~AW_PLL_ENABLE;
1144         PLL_WRITE(sc, val);
1145         DEVICE_UNLOCK(sc);
1146
1147         return (0);
1148 }
1149
1150 static int
1151 aw_pll_recalc(struct clknode *clk, uint64_t *freq)
1152 {
1153         struct aw_pll_sc *sc;
1154
1155         sc = clknode_get_softc(clk);
1156
1157         if (aw_pll_func[sc->type].recalc == NULL)
1158                 return (ENXIO);
1159
1160         return (aw_pll_func[sc->type].recalc(sc, freq));
1161 }
1162
1163 static int
1164 aw_pll_set_freq(struct clknode *clk, uint64_t fin, uint64_t *fout,
1165     int flags, int *stop)
1166 {
1167         struct aw_pll_sc *sc;
1168
1169         sc = clknode_get_softc(clk);
1170
1171         *stop = 1;
1172
1173         if (aw_pll_func[sc->type].set_freq == NULL)
1174                 return (ENXIO);
1175
1176         return (aw_pll_func[sc->type].set_freq(sc, fin, fout, flags));
1177 }
1178
1179 static clknode_method_t aw_pll_clknode_methods[] = {
1180         /* Device interface */
1181         CLKNODEMETHOD(clknode_init,             aw_pll_init),
1182         CLKNODEMETHOD(clknode_set_gate,         aw_pll_set_gate),
1183         CLKNODEMETHOD(clknode_recalc_freq,      aw_pll_recalc),
1184         CLKNODEMETHOD(clknode_set_freq,         aw_pll_set_freq),
1185         CLKNODEMETHOD_END
1186 };
1187
1188 DEFINE_CLASS_1(aw_pll_clknode, aw_pll_clknode_class, aw_pll_clknode_methods,
1189     sizeof(struct aw_pll_sc), clknode_class);
1190
1191 static int
1192 aw_pll_create(device_t dev, bus_addr_t paddr, struct clkdom *clkdom,
1193     const char *pclkname, const char *clkname, int index)
1194 {
1195         enum aw_pll_type type;
1196         struct clknode_init_def clkdef;
1197         struct aw_pll_sc *sc;
1198         struct clknode *clk;
1199         int error;
1200
1201         type = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
1202
1203         memset(&clkdef, 0, sizeof(clkdef));
1204         clkdef.id = index;
1205         clkdef.name = clkname;
1206         if (pclkname != NULL) {
1207                 clkdef.parent_names = malloc(sizeof(char *), M_OFWPROP,
1208                     M_WAITOK);
1209                 clkdef.parent_names[0] = pclkname;
1210                 clkdef.parent_cnt = 1;
1211         } else
1212                 clkdef.parent_cnt = 0;
1213
1214         if (aw_pll_func[type].init != NULL) {
1215                 error = aw_pll_func[type].init(device_get_parent(dev),
1216                     paddr, &clkdef);
1217                 if (error != 0) {
1218                         device_printf(dev, "clock %s init failed\n", clkname);
1219                         return (error);
1220                 }
1221         }
1222
1223         clk = clknode_create(clkdom, &aw_pll_clknode_class, &clkdef);
1224         if (clk == NULL) {
1225                 device_printf(dev, "cannot create clock node\n");
1226                 return (ENXIO);
1227         }
1228         sc = clknode_get_softc(clk);
1229         sc->clkdev = device_get_parent(dev);
1230         sc->reg = paddr;
1231         sc->type = type;
1232         sc->id = clkdef.id;
1233
1234         clknode_register(clkdom, clk);
1235
1236         OF_prop_free(__DECONST(char *, clkdef.parent_names));
1237
1238         return (0);
1239 }
1240
1241 static int
1242 aw_pll_probe(device_t dev)
1243 {
1244         if (!ofw_bus_status_okay(dev))
1245                 return (ENXIO);
1246
1247         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
1248                 return (ENXIO);
1249
1250         device_set_desc(dev, "Allwinner PLL Clock");
1251         return (BUS_PROBE_DEFAULT);
1252 }
1253
1254 static int
1255 aw_pll_attach(device_t dev)
1256 {
1257         struct clkdom *clkdom;
1258         const char **names;
1259         int index, nout, error;
1260         clk_t clk_parent;
1261         uint32_t *indices;
1262         bus_addr_t paddr;
1263         bus_size_t psize;
1264         phandle_t node;
1265
1266         node = ofw_bus_get_node(dev);
1267
1268         if (ofw_reg_to_paddr(node, 0, &paddr, &psize, NULL) != 0) {
1269                 device_printf(dev, "couldn't parse 'reg' property\n");
1270                 return (ENXIO);
1271         }
1272
1273         clkdom = clkdom_create(dev);
1274
1275         nout = clk_parse_ofw_out_names(dev, node, &names, &indices);
1276         if (nout == 0) {
1277                 device_printf(dev, "no clock outputs found\n");
1278                 error = ENOENT;
1279                 goto fail;
1280         }
1281
1282         if (clk_get_by_ofw_index(dev, 0, 0, &clk_parent) != 0)
1283                 clk_parent = NULL;
1284
1285         for (index = 0; index < nout; index++) {
1286                 error = aw_pll_create(dev, paddr, clkdom,
1287                     clk_parent ? clk_get_name(clk_parent) : NULL,
1288                     names[index], nout == 1 ? 1 : index);
1289                 if (error)
1290                         goto fail;
1291         }
1292
1293         if (clkdom_finit(clkdom) != 0) {
1294                 device_printf(dev, "cannot finalize clkdom initialization\n");
1295                 error = ENXIO;
1296                 goto fail;
1297         }
1298
1299         if (bootverbose)
1300                 clkdom_dump(clkdom);
1301
1302         return (0);
1303
1304 fail:
1305         return (error);
1306 }
1307
1308 static device_method_t aw_pll_methods[] = {
1309         /* Device interface */
1310         DEVMETHOD(device_probe,         aw_pll_probe),
1311         DEVMETHOD(device_attach,        aw_pll_attach),
1312
1313         DEVMETHOD_END
1314 };
1315
1316 static driver_t aw_pll_driver = {
1317         "aw_pll",
1318         aw_pll_methods,
1319         0,
1320 };
1321
1322 static devclass_t aw_pll_devclass;
1323
1324 EARLY_DRIVER_MODULE(aw_pll, simplebus, aw_pll_driver,
1325     aw_pll_devclass, 0, 0, BUS_PASS_BUS + BUS_PASS_ORDER_MIDDLE);