sys/arm/allwinner/a10_clk.c

   1 /*-
   2  * Copyright (c) 2013 Ganbold Tsagaankhuu <ganbold@freebsd.org>
   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 AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, 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
  27 /* Simple clock driver for Allwinner A10 */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/bus.h>
  35 #include <sys/kernel.h>
  36 #include <sys/module.h>
  37 #include <sys/malloc.h>
  38 #include <sys/rman.h>
  39 #include <machine/bus.h>
  40
  41 #include <dev/ofw/openfirm.h>
  42 #include <dev/ofw/ofw_bus_subr.h>
  43
  44 #include "a10_clk.h"
  45
  46 struct a10_ccm_softc {
  47         struct resource         *res;
  48         bus_space_tag_t         bst;
  49         bus_space_handle_t      bsh;
  50         int                     pll6_enabled;
  51 };
  52
  53 static struct a10_ccm_softc *a10_ccm_sc = NULL;
  54
  55 #define ccm_read_4(sc, reg)             \
  56         bus_space_read_4((sc)->bst, (sc)->bsh, (reg))
  57 #define ccm_write_4(sc, reg, val)       \
  58         bus_space_write_4((sc)->bst, (sc)->bsh, (reg), (val))
  59
  60 static int
  61 a10_ccm_probe(device_t dev)
  62 {
  63
  64         if (!ofw_bus_status_okay(dev))
  65                 return (ENXIO);
  66
  67         if (ofw_bus_is_compatible(dev, "allwinner,sun4i-ccm")) {
  68                 device_set_desc(dev, "Allwinner Clock Control Module");
  69                 return(BUS_PROBE_DEFAULT);
  70         }
  71
  72         return (ENXIO);
  73 }
  74
  75 static int
  76 a10_ccm_attach(device_t dev)
  77 {
  78         struct a10_ccm_softc *sc = device_get_softc(dev);
  79         int rid = 0;
  80
  81         if (a10_ccm_sc)
  82                 return (ENXIO);
  83
  84         sc->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
  85         if (!sc->res) {
  86                 device_printf(dev, "could not allocate resource\n");
  87                 return (ENXIO);
  88         }
  89
  90         sc->bst = rman_get_bustag(sc->res);
  91         sc->bsh = rman_get_bushandle(sc->res);
  92
  93         a10_ccm_sc = sc;
  94
  95         return (0);
  96 }
  97
  98 static device_method_t a10_ccm_methods[] = {
  99         DEVMETHOD(device_probe,         a10_ccm_probe),
 100         DEVMETHOD(device_attach,        a10_ccm_attach),
 101         { 0, 0 }
 102 };
 103
 104 static driver_t a10_ccm_driver = {
 105         "a10_ccm",
 106         a10_ccm_methods,
 107         sizeof(struct a10_ccm_softc),
 108 };
 109
 110 static devclass_t a10_ccm_devclass;
 111
 112 EARLY_DRIVER_MODULE(a10_ccm, simplebus, a10_ccm_driver, a10_ccm_devclass, 0, 0,
 113     BUS_PASS_TIMER + BUS_PASS_ORDER_MIDDLE);
 114
 115 int
 116 a10_clk_usb_activate(void)
 117 {
 118         struct a10_ccm_softc *sc = a10_ccm_sc;
 119         uint32_t reg_value;
 120
 121         if (sc == NULL)
 122                 return (ENXIO);
 123
 124         /* Gating AHB clock for USB */
 125         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 126         reg_value |= CCM_AHB_GATING_USB0; /* AHB clock gate usb0 */
 127         reg_value |= CCM_AHB_GATING_EHCI0; /* AHB clock gate ehci0 */
 128         reg_value |= CCM_AHB_GATING_EHCI1; /* AHB clock gate ehci1 */
 129         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 130
 131         /* Enable clock for USB */
 132         reg_value = ccm_read_4(sc, CCM_USB_CLK);
 133         reg_value |= CCM_USB_PHY; /* USBPHY */
 134         reg_value |= CCM_USB0_RESET; /* disable reset for USB0 */
 135         reg_value |= CCM_USB1_RESET; /* disable reset for USB1 */
 136         reg_value |= CCM_USB2_RESET; /* disable reset for USB2 */
 137         ccm_write_4(sc, CCM_USB_CLK, reg_value);
 138
 139         return (0);
 140 }
 141
 142 int
 143 a10_clk_usb_deactivate(void)
 144 {
 145         struct a10_ccm_softc *sc = a10_ccm_sc;
 146         uint32_t reg_value;
 147
 148         if (sc == NULL)
 149                 return (ENXIO);
 150
 151         /* Disable clock for USB */
 152         reg_value = ccm_read_4(sc, CCM_USB_CLK);
 153         reg_value &= ~CCM_USB_PHY; /* USBPHY */
 154         reg_value &= ~CCM_USB0_RESET; /* reset for USB0 */
 155         reg_value &= ~CCM_USB1_RESET; /* reset for USB1 */
 156         reg_value &= ~CCM_USB2_RESET; /* reset for USB2 */
 157         ccm_write_4(sc, CCM_USB_CLK, reg_value);
 158
 159         /* Disable gating AHB clock for USB */
 160         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 161         reg_value &= ~CCM_AHB_GATING_USB0; /* disable AHB clock gate usb0 */
 162         reg_value &= ~CCM_AHB_GATING_EHCI0; /* disable AHB clock gate ehci0 */
 163         reg_value &= ~CCM_AHB_GATING_EHCI1; /* disable AHB clock gate ehci1 */
 164         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 165
 166         return (0);
 167 }
 168
 169 int
 170 a10_clk_emac_activate(void)
 171 {
 172         struct a10_ccm_softc *sc = a10_ccm_sc;
 173         uint32_t reg_value;
 174
 175         if (sc == NULL)
 176                 return (ENXIO);
 177
 178         /* Gating AHB clock for EMAC */
 179         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 180         reg_value |= CCM_AHB_GATING_EMAC;
 181         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 182
 183         return (0);
 184 }
 185
 186 int
 187 a10_clk_gmac_activate(phandle_t node)
 188 {
 189         char *phy_type;
 190         struct a10_ccm_softc *sc;
 191         uint32_t reg_value;
 192
 193         sc = a10_ccm_sc;
 194         if (sc == NULL)
 195                 return (ENXIO);
 196
 197         /* Gating AHB clock for GMAC */
 198         reg_value = ccm_read_4(sc, CCM_AHB_GATING1);
 199         reg_value |= CCM_AHB_GATING_GMAC;
 200         ccm_write_4(sc, CCM_AHB_GATING1, reg_value);
 201
 202         /* Set GMAC mode. */
 203         reg_value = CCM_GMAC_CLK_MII;
 204         if (OF_getprop_alloc(node, "phy-mode", 1, (void **)&phy_type) > 0) {
 205                 if (strcasecmp(phy_type, "rgmii") == 0)
 206                         reg_value = CCM_GMAC_CLK_RGMII | CCM_GMAC_MODE_RGMII;
 207                 else if (strcasecmp(phy_type, "rgmii-bpi") == 0) {
 208                         reg_value = CCM_GMAC_CLK_RGMII | CCM_GMAC_MODE_RGMII;
 209                         reg_value |= (3 << CCM_GMAC_CLK_DELAY_SHIFT);
 210                 }
 211                 free(phy_type, M_OFWPROP);
 212         }
 213         ccm_write_4(sc, CCM_GMAC_CLK, reg_value);
 214
 215         return (0);
 216 }
 217
 218 static void
 219 a10_clk_pll6_enable(void)
 220 {
 221         struct a10_ccm_softc *sc;
 222         uint32_t reg_value;
 223
 224         /*
 225          * SATA needs PLL6 to be a 100MHz clock.
 226          * The SATA output frequency is 24MHz * n * k / m / 6.
 227          * To get to 100MHz, k & m must be equal and n must be 25.
 228          * For other uses the output frequency is 24MHz * n * k / 2.
 229          */
 230         sc = a10_ccm_sc;
 231         if (sc->pll6_enabled)
 232                 return;
 233         reg_value = ccm_read_4(sc, CCM_PLL6_CFG);
 234         reg_value &= ~CCM_PLL_CFG_BYPASS;
 235         reg_value &= ~(CCM_PLL_CFG_FACTOR_K | CCM_PLL_CFG_FACTOR_M |
 236             CCM_PLL_CFG_FACTOR_N);
 237         reg_value |= (25 << CCM_PLL_CFG_FACTOR_N_SHIFT);
 238         reg_value |= CCM_PLL6_CFG_SATA_CLKEN;
 239         reg_value |= CCM_PLL_CFG_ENABLE;
 240         ccm_write_4(sc, CCM_PLL6_CFG, reg_value);
 241         sc->pll6_enabled = 1;
 242 }
 243
 244 static unsigned int
 245 a10_clk_pll6_get_rate(void)
 246 {
 247         struct a10_ccm_softc *sc;
 248         uint32_t k, n, reg_value;
 249
 250         sc = a10_ccm_sc;
 251         reg_value = ccm_read_4(sc, CCM_PLL6_CFG);
 252         n = ((reg_value & CCM_PLL_CFG_FACTOR_N) >> CCM_PLL_CFG_FACTOR_N_SHIFT);
 253         k = ((reg_value & CCM_PLL_CFG_FACTOR_K) >> CCM_PLL_CFG_FACTOR_K_SHIFT) +
 254             1;
 255
 256         return ((CCM_CLK_REF_FREQ * n * k) / 2);
 257 }
 258
 259 static int
 260 a10_clk_pll2_set_rate(unsigned int freq)
 261 {
 262         struct a10_ccm_softc *sc;
 263         uint32_t reg_value;
 264         unsigned int prediv, postdiv, n;
 265
 266         sc = a10_ccm_sc;
 267         if (sc == NULL)
 268                 return (ENXIO);
 269
 270         reg_value = ccm_read_4(sc, CCM_PLL2_CFG);
 271         reg_value &= ~(CCM_PLL2_CFG_PREDIV | CCM_PLL2_CFG_POSTDIV |
 272             CCM_PLL_CFG_FACTOR_N);
 273
 274         /*
 275          * Audio Codec needs PLL2 to be either 24576000 Hz or 22579200 Hz
 276          *
 277          * PLL2 output frequency is 24MHz * n / prediv / postdiv.
 278          * To get as close as possible to the desired rate, we use a
 279          * pre-divider of 21 and a post-divider of 4. With these values,
 280          * a multiplier of 86 or 79 gets us close to the target rates.
 281          */
 282         prediv = 21;
 283         postdiv = 4;
 284
 285         switch (freq) {
 286         case 24576000:
 287                 n = 86;
 288                 reg_value |= CCM_PLL_CFG_ENABLE;
 289                 break;
 290         case 22579200:
 291                 n = 79;
 292                 reg_value |= CCM_PLL_CFG_ENABLE;
 293                 break;
 294         case 0:
 295                 n = 1;
 296                 reg_value &= ~CCM_PLL_CFG_ENABLE;
 297                 break;
 298         default:
 299                 return (EINVAL);
 300         }
 301
 302         reg_value |= (prediv << CCM_PLL2_CFG_PREDIV_SHIFT);
 303         reg_value |= (postdiv << CCM_PLL2_CFG_POSTDIV_SHIFT);
 304         reg_value |= (n << CCM_PLL_CFG_FACTOR_N_SHIFT);
 305         ccm_write_4(sc, CCM_PLL2_CFG, reg_value);
 306
 307         return (0);
 308 }
 309
 310 int
 311 a10_clk_ahci_activate(void)
 312 {
 313         struct a10_ccm_softc *sc;
 314         uint32_t reg_value;
 315
 316         sc = a10_ccm_sc;
 317         if (sc == NULL)
 318                 return (ENXIO);
 319
 320         a10_clk_pll6_enable();
 321
 322         /* Gating AHB clock for SATA */
 323         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 324         reg_value |= CCM_AHB_GATING_SATA;
 325         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 326         DELAY(1000);
 327
 328         ccm_write_4(sc, CCM_SATA_CLK, CCM_PLL_CFG_ENABLE);
 329
 330         return (0);
 331 }
 332
 333 int
 334 a10_clk_mmc_activate(int devid)
 335 {
 336         struct a10_ccm_softc *sc;
 337         uint32_t reg_value;
 338
 339         sc = a10_ccm_sc;
 340         if (sc == NULL)
 341                 return (ENXIO);
 342
 343         a10_clk_pll6_enable();
 344
 345         /* Gating AHB clock for SD/MMC */
 346         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 347         reg_value |= CCM_AHB_GATING_SDMMC0 << devid;
 348         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 349
 350         return (0);
 351 }
 352
 353 int
 354 a10_clk_mmc_cfg(int devid, int freq)
 355 {
 356         struct a10_ccm_softc *sc;
 357         uint32_t clksrc, m, n, ophase, phase, reg_value;
 358         unsigned int pll_freq;
 359
 360         sc = a10_ccm_sc;
 361         if (sc == NULL)
 362                 return (ENXIO);
 363
 364         freq /= 1000;
 365         if (freq <= 400) {
 366                 pll_freq = CCM_CLK_REF_FREQ / 1000;
 367                 clksrc = CCM_SD_CLK_SRC_SEL_OSC24M;
 368                 ophase = 0;
 369                 phase = 0;
 370                 n = 2;
 371         } else if (freq <= 25000) {
 372                 pll_freq = a10_clk_pll6_get_rate() / 1000;
 373                 clksrc = CCM_SD_CLK_SRC_SEL_PLL6;
 374                 ophase = 0;
 375                 phase = 5;
 376                 n = 2;
 377         } else if (freq <= 50000) {
 378                 pll_freq = a10_clk_pll6_get_rate() / 1000;
 379                 clksrc = CCM_SD_CLK_SRC_SEL_PLL6;
 380                 ophase = 3;
 381                 phase = 5;
 382                 n = 0;
 383         } else
 384                 return (EINVAL);
 385         m = ((pll_freq / (1 << n)) / (freq)) - 1;
 386         reg_value = ccm_read_4(sc, CCM_MMC0_SCLK_CFG + (devid * 4));
 387         reg_value &= ~CCM_SD_CLK_SRC_SEL;
 388         reg_value |= (clksrc << CCM_SD_CLK_SRC_SEL_SHIFT);
 389         reg_value &= ~CCM_SD_CLK_PHASE_CTR;
 390         reg_value |= (phase << CCM_SD_CLK_PHASE_CTR_SHIFT);
 391         reg_value &= ~CCM_SD_CLK_DIV_RATIO_N;
 392         reg_value |= (n << CCM_SD_CLK_DIV_RATIO_N_SHIFT);
 393         reg_value &= ~CCM_SD_CLK_OPHASE_CTR;
 394         reg_value |= (ophase << CCM_SD_CLK_OPHASE_CTR_SHIFT);
 395         reg_value &= ~CCM_SD_CLK_DIV_RATIO_M;
 396         reg_value |= m;
 397         reg_value |= CCM_PLL_CFG_ENABLE;
 398         ccm_write_4(sc, CCM_MMC0_SCLK_CFG + (devid * 4), reg_value);
 399
 400         return (0);
 401 }
 402
 403 int
 404 a10_clk_dmac_activate(void)
 405 {
 406         struct a10_ccm_softc *sc;
 407         uint32_t reg_value;
 408
 409         sc = a10_ccm_sc;
 410         if (sc == NULL)
 411                 return (ENXIO);
 412
 413         /* Gating AHB clock for DMA controller */
 414         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 415         reg_value |= CCM_AHB_GATING_DMA;
 416         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 417
 418         return (0);
 419 }
 420
 421 int
 422 a10_clk_codec_activate(unsigned int freq)
 423 {
 424         struct a10_ccm_softc *sc;
 425         uint32_t reg_value;
 426
 427         sc = a10_ccm_sc;
 428         if (sc == NULL)
 429                 return (ENXIO);
 430
 431         a10_clk_pll2_set_rate(freq);
 432
 433         /* Gating APB clock for ADDA */
 434         reg_value = ccm_read_4(sc, CCM_APB0_GATING);
 435         reg_value |= CCM_APB0_GATING_ADDA;
 436         ccm_write_4(sc, CCM_APB0_GATING, reg_value);
 437
 438         /* Enable audio codec clock */
 439         reg_value = ccm_read_4(sc, CCM_AUDIO_CODEC_CLK);
 440         reg_value |= CCM_AUDIO_CODEC_ENABLE;
 441         ccm_write_4(sc, CCM_AUDIO_CODEC_CLK, reg_value);
 442
 443         return (0);
 444 }