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 DRIVER_MODULE(a10_ccm, simplebus, a10_ccm_driver, a10_ccm_devclass, 0, 0);
 113
 114 int
 115 a10_clk_usb_activate(void)
 116 {
 117         struct a10_ccm_softc *sc = a10_ccm_sc;
 118         uint32_t reg_value;
 119
 120         if (sc == NULL)
 121                 return (ENXIO);
 122
 123         /* Gating AHB clock for USB */
 124         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 125         reg_value |= CCM_AHB_GATING_USB0; /* AHB clock gate usb0 */
 126         reg_value |= CCM_AHB_GATING_EHCI0; /* AHB clock gate ehci0 */
 127         reg_value |= CCM_AHB_GATING_EHCI1; /* AHB clock gate ehci1 */
 128         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 129
 130         /* Enable clock for USB */
 131         reg_value = ccm_read_4(sc, CCM_USB_CLK);
 132         reg_value |= CCM_USB_PHY; /* USBPHY */
 133         reg_value |= CCM_USB0_RESET; /* disable reset for USB0 */
 134         reg_value |= CCM_USB1_RESET; /* disable reset for USB1 */
 135         reg_value |= CCM_USB2_RESET; /* disable reset for USB2 */
 136         ccm_write_4(sc, CCM_USB_CLK, reg_value);
 137
 138         return (0);
 139 }
 140
 141 int
 142 a10_clk_usb_deactivate(void)
 143 {
 144         struct a10_ccm_softc *sc = a10_ccm_sc;
 145         uint32_t reg_value;
 146
 147         if (sc == NULL)
 148                 return (ENXIO);
 149
 150         /* Disable clock for USB */
 151         reg_value = ccm_read_4(sc, CCM_USB_CLK);
 152         reg_value &= ~CCM_USB_PHY; /* USBPHY */
 153         reg_value &= ~CCM_USB0_RESET; /* reset for USB0 */
 154         reg_value &= ~CCM_USB1_RESET; /* reset for USB1 */
 155         reg_value &= ~CCM_USB2_RESET; /* reset for USB2 */
 156         ccm_write_4(sc, CCM_USB_CLK, reg_value);
 157
 158         /* Disable gating AHB clock for USB */
 159         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 160         reg_value &= ~CCM_AHB_GATING_USB0; /* disable AHB clock gate usb0 */
 161         reg_value &= ~CCM_AHB_GATING_EHCI0; /* disable AHB clock gate ehci0 */
 162         reg_value &= ~CCM_AHB_GATING_EHCI1; /* disable AHB clock gate ehci1 */
 163         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 164
 165         return (0);
 166 }
 167
 168 int
 169 a10_clk_emac_activate(void)
 170 {
 171         struct a10_ccm_softc *sc = a10_ccm_sc;
 172         uint32_t reg_value;
 173
 174         if (sc == NULL)
 175                 return (ENXIO);
 176
 177         /* Gating AHB clock for EMAC */
 178         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 179         reg_value |= CCM_AHB_GATING_EMAC;
 180         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 181
 182         return (0);
 183 }
 184
 185 int
 186 a10_clk_gmac_activate(phandle_t node)
 187 {
 188         char *phy_type;
 189         struct a10_ccm_softc *sc;
 190         uint32_t reg_value;
 191
 192         sc = a10_ccm_sc;
 193         if (sc == NULL)
 194                 return (ENXIO);
 195
 196         /* Gating AHB clock for GMAC */
 197         reg_value = ccm_read_4(sc, CCM_AHB_GATING1);
 198         reg_value |= CCM_AHB_GATING_GMAC;
 199         ccm_write_4(sc, CCM_AHB_GATING1, reg_value);
 200
 201         /* Set GMAC mode. */
 202         reg_value = CCM_GMAC_CLK_MII;
 203         if (OF_getprop_alloc(node, "phy-type", 1, (void **)&phy_type) > 0) {
 204                 if (strcasecmp(phy_type, "rgmii") == 0)
 205                         reg_value = CCM_GMAC_CLK_RGMII | CCM_GMAC_MODE_RGMII;
 206                 else if (strcasecmp(phy_type, "rgmii-bpi") == 0) {
 207                         reg_value = CCM_GMAC_CLK_RGMII | CCM_GMAC_MODE_RGMII;
 208                         reg_value |= (3 << CCM_GMAC_CLK_DELAY_SHIFT);
 209                 }
 210                 free(phy_type, M_OFWPROP);
 211         }
 212         ccm_write_4(sc, CCM_GMAC_CLK, reg_value);
 213
 214         return (0);
 215 }
 216
 217 static void
 218 a10_clk_pll6_enable(void)
 219 {
 220         struct a10_ccm_softc *sc;
 221         uint32_t reg_value;
 222
 223         /*
 224          * SATA needs PLL6 to be a 100MHz clock.
 225          * The SATA output frequency is 24MHz * n * k / m / 6.
 226          * To get to 100MHz, k & m must be equal and n must be 25.
 227          * For other uses the output frequency is 24MHz * n * k / 2.
 228          */
 229         sc = a10_ccm_sc;
 230         if (sc->pll6_enabled)
 231                 return;
 232         reg_value = ccm_read_4(sc, CCM_PLL6_CFG);
 233         reg_value &= ~CCM_PLL_CFG_BYPASS;
 234         reg_value &= ~(CCM_PLL_CFG_FACTOR_K | CCM_PLL_CFG_FACTOR_M |
 235             CCM_PLL_CFG_FACTOR_N);
 236         reg_value |= (25 << CCM_PLL_CFG_FACTOR_N_SHIFT);
 237         reg_value |= CCM_PLL6_CFG_SATA_CLKEN;
 238         reg_value |= CCM_PLL_CFG_ENABLE;
 239         ccm_write_4(sc, CCM_PLL6_CFG, reg_value);
 240         sc->pll6_enabled = 1;
 241 }
 242
 243 static unsigned int
 244 a10_clk_pll6_get_rate(void)
 245 {
 246         struct a10_ccm_softc *sc;
 247         uint32_t k, n, reg_value;
 248
 249         sc = a10_ccm_sc;
 250         reg_value = ccm_read_4(sc, CCM_PLL6_CFG);
 251         n = ((reg_value & CCM_PLL_CFG_FACTOR_N) >> CCM_PLL_CFG_FACTOR_N_SHIFT);
 252         k = ((reg_value & CCM_PLL_CFG_FACTOR_K) >> CCM_PLL_CFG_FACTOR_K_SHIFT) +
 253             1;
 254
 255         return ((CCM_CLK_REF_FREQ * n * k) / 2);
 256 }
 257
 258 static int
 259 a10_clk_pll2_set_rate(unsigned int freq)
 260 {
 261         struct a10_ccm_softc *sc;
 262         uint32_t reg_value;
 263         unsigned int prediv, postdiv, n;
 264
 265         sc = a10_ccm_sc;
 266         if (sc == NULL)
 267                 return (ENXIO);
 268
 269         reg_value = ccm_read_4(sc, CCM_PLL2_CFG);
 270         reg_value &= ~(CCM_PLL2_CFG_PREDIV | CCM_PLL2_CFG_POSTDIV |
 271             CCM_PLL_CFG_FACTOR_N);
 272
 273         /*
 274          * Audio Codec needs PLL2 to be either 24576000 Hz or 22579200 Hz
 275          *
 276          * PLL2 output frequency is 24MHz * n / prediv / postdiv.
 277          * To get as close as possible to the desired rate, we use a
 278          * pre-divider of 21 and a post-divider of 4. With these values,
 279          * a multiplier of 86 or 79 gets us close to the target rates.
 280          */
 281         prediv = 21;
 282         postdiv = 4;
 283
 284         switch (freq) {
 285         case 24576000:
 286                 n = 86;
 287                 reg_value |= CCM_PLL_CFG_ENABLE;
 288                 break;
 289         case 22579200:
 290                 n = 79;
 291                 reg_value |= CCM_PLL_CFG_ENABLE;
 292                 break;
 293         case 0:
 294                 n = 1;
 295                 reg_value &= ~CCM_PLL_CFG_ENABLE;
 296                 break;
 297         default:
 298                 return (EINVAL);
 299         }
 300
 301         reg_value |= (prediv << CCM_PLL2_CFG_PREDIV_SHIFT);
 302         reg_value |= (postdiv << CCM_PLL2_CFG_POSTDIV_SHIFT);
 303         reg_value |= (n << CCM_PLL_CFG_FACTOR_N_SHIFT);
 304         ccm_write_4(sc, CCM_PLL2_CFG, reg_value);
 305
 306         return (0);
 307 }
 308
 309 int
 310 a10_clk_ahci_activate(void)
 311 {
 312         struct a10_ccm_softc *sc;
 313         uint32_t reg_value;
 314
 315         sc = a10_ccm_sc;
 316         if (sc == NULL)
 317                 return (ENXIO);
 318
 319         a10_clk_pll6_enable();
 320
 321         /* Gating AHB clock for SATA */
 322         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 323         reg_value |= CCM_AHB_GATING_SATA;
 324         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 325         DELAY(1000);
 326
 327         ccm_write_4(sc, CCM_SATA_CLK, CCM_PLL_CFG_ENABLE);
 328
 329         return (0);
 330 }
 331
 332 int
 333 a10_clk_mmc_activate(int devid)
 334 {
 335         struct a10_ccm_softc *sc;
 336         uint32_t reg_value;
 337
 338         sc = a10_ccm_sc;
 339         if (sc == NULL)
 340                 return (ENXIO);
 341
 342         a10_clk_pll6_enable();
 343
 344         /* Gating AHB clock for SD/MMC */
 345         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 346         reg_value |= CCM_AHB_GATING_SDMMC0 << devid;
 347         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 348
 349         return (0);
 350 }
 351
 352 int
 353 a10_clk_mmc_cfg(int devid, int freq)
 354 {
 355         struct a10_ccm_softc *sc;
 356         uint32_t clksrc, m, n, ophase, phase, reg_value;
 357         unsigned int pll_freq;
 358
 359         sc = a10_ccm_sc;
 360         if (sc == NULL)
 361                 return (ENXIO);
 362
 363         freq /= 1000;
 364         if (freq <= 400) {
 365                 pll_freq = CCM_CLK_REF_FREQ / 1000;
 366                 clksrc = CCM_SD_CLK_SRC_SEL_OSC24M;
 367                 ophase = 0;
 368                 phase = 0;
 369                 n = 2;
 370         } else if (freq <= 25000) {
 371                 pll_freq = a10_clk_pll6_get_rate() / 1000;
 372                 clksrc = CCM_SD_CLK_SRC_SEL_PLL6;
 373                 ophase = 0;
 374                 phase = 5;
 375                 n = 2;
 376         } else if (freq <= 50000) {
 377                 pll_freq = a10_clk_pll6_get_rate() / 1000;
 378                 clksrc = CCM_SD_CLK_SRC_SEL_PLL6;
 379                 ophase = 3;
 380                 phase = 5;
 381                 n = 0;
 382         } else
 383                 return (EINVAL);
 384         m = ((pll_freq / (1 << n)) / (freq)) - 1;
 385         reg_value = ccm_read_4(sc, CCM_MMC0_SCLK_CFG + (devid * 4));
 386         reg_value &= ~CCM_SD_CLK_SRC_SEL;
 387         reg_value |= (clksrc << CCM_SD_CLK_SRC_SEL_SHIFT);
 388         reg_value &= ~CCM_SD_CLK_PHASE_CTR;
 389         reg_value |= (phase << CCM_SD_CLK_PHASE_CTR_SHIFT);
 390         reg_value &= ~CCM_SD_CLK_DIV_RATIO_N;
 391         reg_value |= (n << CCM_SD_CLK_DIV_RATIO_N_SHIFT);
 392         reg_value &= ~CCM_SD_CLK_OPHASE_CTR;
 393         reg_value |= (ophase << CCM_SD_CLK_OPHASE_CTR_SHIFT);
 394         reg_value &= ~CCM_SD_CLK_DIV_RATIO_M;
 395         reg_value |= m;
 396         reg_value |= CCM_PLL_CFG_ENABLE;
 397         ccm_write_4(sc, CCM_MMC0_SCLK_CFG + (devid * 4), reg_value);
 398
 399         return (0);
 400 }
 401
 402 int
 403 a10_clk_dmac_activate(void)
 404 {
 405         struct a10_ccm_softc *sc;
 406         uint32_t reg_value;
 407
 408         sc = a10_ccm_sc;
 409         if (sc == NULL)
 410                 return (ENXIO);
 411
 412         /* Gating AHB clock for DMA controller */
 413         reg_value = ccm_read_4(sc, CCM_AHB_GATING0);
 414         reg_value |= CCM_AHB_GATING_DMA;
 415         ccm_write_4(sc, CCM_AHB_GATING0, reg_value);
 416
 417         return (0);
 418 }
 419
 420 int
 421 a10_clk_codec_activate(unsigned int freq)
 422 {
 423         struct a10_ccm_softc *sc;
 424         uint32_t reg_value;
 425
 426         sc = a10_ccm_sc;
 427         if (sc == NULL)
 428                 return (ENXIO);
 429
 430         a10_clk_pll2_set_rate(freq);
 431
 432         /* Gating APB clock for ADDA */
 433         reg_value = ccm_read_4(sc, CCM_APB0_GATING);
 434         reg_value |= CCM_APB0_GATING_ADDA;
 435         ccm_write_4(sc, CCM_APB0_GATING, reg_value);
 436
 437         /* Enable audio codec clock */
 438         reg_value = ccm_read_4(sc, CCM_AUDIO_CODEC_CLK);
 439         reg_value |= CCM_AUDIO_CODEC_ENABLE;
 440         ccm_write_4(sc, CCM_AUDIO_CODEC_CLK, reg_value);
 441
 442         return (0);
 443 }