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