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