drivers/clk/sunxi/clk-sunxi.c

   1 /*
   2  * Copyright 2013 Emilio López
   3  *
   4  * Emilio López <emilio@elopez.com.ar>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/clk.h>
  18 #include <linux/clk-provider.h>
  19 #include <linux/clkdev.h>
  20 #include <linux/of.h>
  21 #include <linux/of_address.h>
  22 #include <linux/reset-controller.h>
  23 #include <linux/slab.h>
  24 #include <linux/spinlock.h>
  25 #include <linux/log2.h>
  26
  27 #include "clk-factors.h"
  28
  29 static DEFINE_SPINLOCK(clk_lock);
  30
  31 /* Maximum number of parents our clocks have */
  32 #define SUNXI_MAX_PARENTS       5
  33
  34 /**
  35  * sun4i_get_pll1_factors() - calculates n, k, m, p factors for PLL1
  36  * PLL1 rate is calculated as follows
  37  * rate = (parent_rate * n * (k + 1) >> p) / (m + 1);
  38  * parent_rate is always 24Mhz
  39  */
  40
  41 static void sun4i_get_pll1_factors(struct factors_request *req)
  42 {
  43         u8 div;
  44
  45         /* Normalize value to a 6M multiple */
  46         div = req->rate / 6000000;
  47         req->rate = 6000000 * div;
  48
  49         /* m is always zero for pll1 */
  50         req->m = 0;
  51
  52         /* k is 1 only on these cases */
  53         if (req->rate >= 768000000 || req->rate == 42000000 ||
  54                         req->rate == 54000000)
  55                 req->k = 1;
  56         else
  57                 req->k = 0;
  58
  59         /* p will be 3 for divs under 10 */
  60         if (div < 10)
  61                 req->p = 3;
  62
  63         /* p will be 2 for divs between 10 - 20 and odd divs under 32 */
  64         else if (div < 20 || (div < 32 && (div & 1)))
  65                 req->p = 2;
  66
  67         /* p will be 1 for even divs under 32, divs under 40 and odd pairs
  68          * of divs between 40-62 */
  69         else if (div < 40 || (div < 64 && (div & 2)))
  70                 req->p = 1;
  71
  72         /* any other entries have p = 0 */
  73         else
  74                 req->p = 0;
  75
  76         /* calculate a suitable n based on k and p */
  77         div <<= req->p;
  78         div /= (req->k + 1);
  79         req->n = div / 4;
  80 }
  81
  82 /**
  83  * sun6i_a31_get_pll1_factors() - calculates n, k and m factors for PLL1
  84  * PLL1 rate is calculated as follows
  85  * rate = parent_rate * (n + 1) * (k + 1) / (m + 1);
  86  * parent_rate should always be 24MHz
  87  */
  88 static void sun6i_a31_get_pll1_factors(struct factors_request *req)
  89 {
  90         /*
  91          * We can operate only on MHz, this will make our life easier
  92          * later.
  93          */
  94         u32 freq_mhz = req->rate / 1000000;
  95         u32 parent_freq_mhz = req->parent_rate / 1000000;
  96
  97         /*
  98          * Round down the frequency to the closest multiple of either
  99          * 6 or 16
 100          */
 101         u32 round_freq_6 = round_down(freq_mhz, 6);
 102         u32 round_freq_16 = round_down(freq_mhz, 16);
 103
 104         if (round_freq_6 > round_freq_16)
 105                 freq_mhz = round_freq_6;
 106         else
 107                 freq_mhz = round_freq_16;
 108
 109         req->rate = freq_mhz * 1000000;
 110
 111         /* If the frequency is a multiple of 32 MHz, k is always 3 */
 112         if (!(freq_mhz % 32))
 113                 req->k = 3;
 114         /* If the frequency is a multiple of 9 MHz, k is always 2 */
 115         else if (!(freq_mhz % 9))
 116                 req->k = 2;
 117         /* If the frequency is a multiple of 8 MHz, k is always 1 */
 118         else if (!(freq_mhz % 8))
 119                 req->k = 1;
 120         /* Otherwise, we don't use the k factor */
 121         else
 122                 req->k = 0;
 123
 124         /*
 125          * If the frequency is a multiple of 2 but not a multiple of
 126          * 3, m is 3. This is the first time we use 6 here, yet we
 127          * will use it on several other places.
 128          * We use this number because it's the lowest frequency we can
 129          * generate (with n = 0, k = 0, m = 3), so every other frequency
 130          * somehow relates to this frequency.
 131          */
 132         if ((freq_mhz % 6) == 2 || (freq_mhz % 6) == 4)
 133                 req->m = 2;
 134         /*
 135          * If the frequency is a multiple of 6MHz, but the factor is
 136          * odd, m will be 3
 137          */
 138         else if ((freq_mhz / 6) & 1)
 139                 req->m = 3;
 140         /* Otherwise, we end up with m = 1 */
 141         else
 142                 req->m = 1;
 143
 144         /* Calculate n thanks to the above factors we already got */
 145         req->n = freq_mhz * (req->m + 1) / ((req->k + 1) * parent_freq_mhz)
 146                  - 1;
 147
 148         /*
 149          * If n end up being outbound, and that we can still decrease
 150          * m, do it.
 151          */
 152         if ((req->n + 1) > 31 && (req->m + 1) > 1) {
 153                 req->n = (req->n + 1) / 2 - 1;
 154                 req->m = (req->m + 1) / 2 - 1;
 155         }
 156 }
 157
 158 /**
 159  * sun8i_a23_get_pll1_factors() - calculates n, k, m, p factors for PLL1
 160  * PLL1 rate is calculated as follows
 161  * rate = (parent_rate * (n + 1) * (k + 1) >> p) / (m + 1);
 162  * parent_rate is always 24Mhz
 163  */
 164
 165 static void sun8i_a23_get_pll1_factors(struct factors_request *req)
 166 {
 167         u8 div;
 168
 169         /* Normalize value to a 6M multiple */
 170         div = req->rate / 6000000;
 171         req->rate = 6000000 * div;
 172
 173         /* m is always zero for pll1 */
 174         req->m = 0;
 175
 176         /* k is 1 only on these cases */
 177         if (req->rate >= 768000000 || req->rate == 42000000 ||
 178                         req->rate == 54000000)
 179                 req->k = 1;
 180         else
 181                 req->k = 0;
 182
 183         /* p will be 2 for divs under 20 and odd divs under 32 */
 184         if (div < 20 || (div < 32 && (div & 1)))
 185                 req->p = 2;
 186
 187         /* p will be 1 for even divs under 32, divs under 40 and odd pairs
 188          * of divs between 40-62 */
 189         else if (div < 40 || (div < 64 && (div & 2)))
 190                 req->p = 1;
 191
 192         /* any other entries have p = 0 */
 193         else
 194                 req->p = 0;
 195
 196         /* calculate a suitable n based on k and p */
 197         div <<= req->p;
 198         div /= (req->k + 1);
 199         req->n = div / 4 - 1;
 200 }
 201
 202 /**
 203  * sun4i_get_pll5_factors() - calculates n, k factors for PLL5
 204  * PLL5 rate is calculated as follows
 205  * rate = parent_rate * n * (k + 1)
 206  * parent_rate is always 24Mhz
 207  */
 208
 209 static void sun4i_get_pll5_factors(struct factors_request *req)
 210 {
 211         u8 div;
 212
 213         /* Normalize value to a parent_rate multiple (24M) */
 214         div = req->rate / req->parent_rate;
 215         req->rate = req->parent_rate * div;
 216
 217         if (div < 31)
 218                 req->k = 0;
 219         else if (div / 2 < 31)
 220                 req->k = 1;
 221         else if (div / 3 < 31)
 222                 req->k = 2;
 223         else
 224                 req->k = 3;
 225
 226         req->n = DIV_ROUND_UP(div, (req->k + 1));
 227 }
 228
 229 /**
 230  * sun6i_a31_get_pll6_factors() - calculates n, k factors for A31 PLL6x2
 231  * PLL6x2 rate is calculated as follows
 232  * rate = parent_rate * (n + 1) * (k + 1)
 233  * parent_rate is always 24Mhz
 234  */
 235
 236 static void sun6i_a31_get_pll6_factors(struct factors_request *req)
 237 {
 238         u8 div;
 239
 240         /* Normalize value to a parent_rate multiple (24M) */
 241         div = req->rate / req->parent_rate;
 242         req->rate = req->parent_rate * div;
 243
 244         req->k = div / 32;
 245         if (req->k > 3)
 246                 req->k = 3;
 247
 248         req->n = DIV_ROUND_UP(div, (req->k + 1)) - 1;
 249 }
 250
 251 /**
 252  * sun5i_a13_get_ahb_factors() - calculates m, p factors for AHB
 253  * AHB rate is calculated as follows
 254  * rate = parent_rate >> p
 255  */
 256
 257 static void sun5i_a13_get_ahb_factors(struct factors_request *req)
 258 {
 259         u32 div;
 260
 261         /* divide only */
 262         if (req->parent_rate < req->rate)
 263                 req->rate = req->parent_rate;
 264
 265         /*
 266          * user manual says valid speed is 8k ~ 276M, but tests show it
 267          * can work at speeds up to 300M, just after reparenting to pll6
 268          */
 269         if (req->rate < 8000)
 270                 req->rate = 8000;
 271         if (req->rate > 300000000)
 272                 req->rate = 300000000;
 273
 274         div = order_base_2(DIV_ROUND_UP(req->parent_rate, req->rate));
 275
 276         /* p = 0 ~ 3 */
 277         if (div > 3)
 278                 div = 3;
 279
 280         req->rate = req->parent_rate >> div;
 281
 282         req->p = div;
 283 }
 284
 285 #define SUN6I_AHB1_PARENT_PLL6  3
 286
 287 /**
 288  * sun6i_a31_get_ahb_factors() - calculates m, p factors for AHB
 289  * AHB rate is calculated as follows
 290  * rate = parent_rate >> p
 291  *
 292  * if parent is pll6, then
 293  * parent_rate = pll6 rate / (m + 1)
 294  */
 295
 296 static void sun6i_get_ahb1_factors(struct factors_request *req)
 297 {
 298         u8 div, calcp, calcm = 1;
 299
 300         /*
 301          * clock can only divide, so we will never be able to achieve
 302          * frequencies higher than the parent frequency
 303          */
 304         if (req->parent_rate && req->rate > req->parent_rate)
 305                 req->rate = req->parent_rate;
 306
 307         div = DIV_ROUND_UP(req->parent_rate, req->rate);
 308
 309         /* calculate pre-divider if parent is pll6 */
 310         if (req->parent_index == SUN6I_AHB1_PARENT_PLL6) {
 311                 if (div < 4)
 312                         calcp = 0;
 313                 else if (div / 2 < 4)
 314                         calcp = 1;
 315                 else if (div / 4 < 4)
 316                         calcp = 2;
 317                 else
 318                         calcp = 3;
 319
 320                 calcm = DIV_ROUND_UP(div, 1 << calcp);
 321         } else {
 322                 calcp = __roundup_pow_of_two(div);
 323                 calcp = calcp > 3 ? 3 : calcp;
 324         }
 325
 326         req->rate = (req->parent_rate / calcm) >> calcp;
 327         req->p = calcp;
 328         req->m = calcm - 1;
 329 }
 330
 331 /**
 332  * sun6i_ahb1_recalc() - calculates AHB clock rate from m, p factors and
 333  *                       parent index
 334  */
 335 static void sun6i_ahb1_recalc(struct factors_request *req)
 336 {
 337         req->rate = req->parent_rate;
 338
 339         /* apply pre-divider first if parent is pll6 */
 340         if (req->parent_index == SUN6I_AHB1_PARENT_PLL6)
 341                 req->rate /= req->m + 1;
 342
 343         /* clk divider */
 344         req->rate >>= req->p;
 345 }
 346
 347 /**
 348  * sun4i_get_apb1_factors() - calculates m, p factors for APB1
 349  * APB1 rate is calculated as follows
 350  * rate = (parent_rate >> p) / (m + 1);
 351  */
 352
 353 static void sun4i_get_apb1_factors(struct factors_request *req)
 354 {
 355         u8 calcm, calcp;
 356         int div;
 357
 358         if (req->parent_rate < req->rate)
 359                 req->rate = req->parent_rate;
 360
 361         div = DIV_ROUND_UP(req->parent_rate, req->rate);
 362
 363         /* Invalid rate! */
 364         if (div > 32)
 365                 return;
 366
 367         if (div <= 4)
 368                 calcp = 0;
 369         else if (div <= 8)
 370                 calcp = 1;
 371         else if (div <= 16)
 372                 calcp = 2;
 373         else
 374                 calcp = 3;
 375
 376         calcm = (req->parent_rate >> calcp) - 1;
 377
 378         req->rate = (req->parent_rate >> calcp) / (calcm + 1);
 379         req->m = calcm;
 380         req->p = calcp;
 381 }
 382
 383
 384
 385
 386 /**
 387  * sun7i_a20_get_out_factors() - calculates m, p factors for CLK_OUT_A/B
 388  * CLK_OUT rate is calculated as follows
 389  * rate = (parent_rate >> p) / (m + 1);
 390  */
 391
 392 static void sun7i_a20_get_out_factors(struct factors_request *req)
 393 {
 394         u8 div, calcm, calcp;
 395
 396         /* These clocks can only divide, so we will never be able to achieve
 397          * frequencies higher than the parent frequency */
 398         if (req->rate > req->parent_rate)
 399                 req->rate = req->parent_rate;
 400
 401         div = DIV_ROUND_UP(req->parent_rate, req->rate);
 402
 403         if (div < 32)
 404                 calcp = 0;
 405         else if (div / 2 < 32)
 406                 calcp = 1;
 407         else if (div / 4 < 32)
 408                 calcp = 2;
 409         else
 410                 calcp = 3;
 411
 412         calcm = DIV_ROUND_UP(div, 1 << calcp);
 413
 414         req->rate = (req->parent_rate >> calcp) / calcm;
 415         req->m = calcm - 1;
 416         req->p = calcp;
 417 }
 418
 419 /**
 420  * sunxi_factors_clk_setup() - Setup function for factor clocks
 421  */
 422
 423 static const struct clk_factors_config sun4i_pll1_config = {
 424         .nshift = 8,
 425         .nwidth = 5,
 426         .kshift = 4,
 427         .kwidth = 2,
 428         .mshift = 0,
 429         .mwidth = 2,
 430         .pshift = 16,
 431         .pwidth = 2,
 432 };
 433
 434 static const struct clk_factors_config sun6i_a31_pll1_config = {
 435         .nshift = 8,
 436         .nwidth = 5,
 437         .kshift = 4,
 438         .kwidth = 2,
 439         .mshift = 0,
 440         .mwidth = 2,
 441         .n_start = 1,
 442 };
 443
 444 static const struct clk_factors_config sun8i_a23_pll1_config = {
 445         .nshift = 8,
 446         .nwidth = 5,
 447         .kshift = 4,
 448         .kwidth = 2,
 449         .mshift = 0,
 450         .mwidth = 2,
 451         .pshift = 16,
 452         .pwidth = 2,
 453         .n_start = 1,
 454 };
 455
 456 static const struct clk_factors_config sun4i_pll5_config = {
 457         .nshift = 8,
 458         .nwidth = 5,
 459         .kshift = 4,
 460         .kwidth = 2,
 461 };
 462
 463 static const struct clk_factors_config sun6i_a31_pll6_config = {
 464         .nshift = 8,
 465         .nwidth = 5,
 466         .kshift = 4,
 467         .kwidth = 2,
 468         .n_start = 1,
 469 };
 470
 471 static const struct clk_factors_config sun5i_a13_ahb_config = {
 472         .pshift = 4,
 473         .pwidth = 2,
 474 };
 475
 476 static const struct clk_factors_config sun6i_ahb1_config = {
 477         .mshift = 6,
 478         .mwidth = 2,
 479         .pshift = 4,
 480         .pwidth = 2,
 481 };
 482
 483 static const struct clk_factors_config sun4i_apb1_config = {
 484         .mshift = 0,
 485         .mwidth = 5,
 486         .pshift = 16,
 487         .pwidth = 2,
 488 };
 489
 490 /* user manual says "n" but it's really "p" */
 491 static const struct clk_factors_config sun7i_a20_out_config = {
 492         .mshift = 8,
 493         .mwidth = 5,
 494         .pshift = 20,
 495         .pwidth = 2,
 496 };
 497
 498 static const struct factors_data sun4i_pll1_data __initconst = {
 499         .enable = 31,
 500         .table = &sun4i_pll1_config,
 501         .getter = sun4i_get_pll1_factors,
 502 };
 503
 504 static const struct factors_data sun6i_a31_pll1_data __initconst = {
 505         .enable = 31,
 506         .table = &sun6i_a31_pll1_config,
 507         .getter = sun6i_a31_get_pll1_factors,
 508 };
 509
 510 static const struct factors_data sun8i_a23_pll1_data __initconst = {
 511         .enable = 31,
 512         .table = &sun8i_a23_pll1_config,
 513         .getter = sun8i_a23_get_pll1_factors,
 514 };
 515
 516 static const struct factors_data sun7i_a20_pll4_data __initconst = {
 517         .enable = 31,
 518         .table = &sun4i_pll5_config,
 519         .getter = sun4i_get_pll5_factors,
 520 };
 521
 522 static const struct factors_data sun4i_pll5_data __initconst = {
 523         .enable = 31,
 524         .table = &sun4i_pll5_config,
 525         .getter = sun4i_get_pll5_factors,
 526         .name = "pll5",
 527 };
 528
 529 static const struct factors_data sun4i_pll6_data __initconst = {
 530         .enable = 31,
 531         .table = &sun4i_pll5_config,
 532         .getter = sun4i_get_pll5_factors,
 533         .name = "pll6",
 534 };
 535
 536 static const struct factors_data sun6i_a31_pll6_data __initconst = {
 537         .enable = 31,
 538         .table = &sun6i_a31_pll6_config,
 539         .getter = sun6i_a31_get_pll6_factors,
 540         .name = "pll6x2",
 541 };
 542
 543 static const struct factors_data sun5i_a13_ahb_data __initconst = {
 544         .mux = 6,
 545         .muxmask = BIT(1) | BIT(0),
 546         .table = &sun5i_a13_ahb_config,
 547         .getter = sun5i_a13_get_ahb_factors,
 548 };
 549
 550 static const struct factors_data sun6i_ahb1_data __initconst = {
 551         .mux = 12,
 552         .muxmask = BIT(1) | BIT(0),
 553         .table = &sun6i_ahb1_config,
 554         .getter = sun6i_get_ahb1_factors,
 555         .recalc = sun6i_ahb1_recalc,
 556 };
 557
 558 static const struct factors_data sun4i_apb1_data __initconst = {
 559         .mux = 24,
 560         .muxmask = BIT(1) | BIT(0),
 561         .table = &sun4i_apb1_config,
 562         .getter = sun4i_get_apb1_factors,
 563 };
 564
 565 static const struct factors_data sun7i_a20_out_data __initconst = {
 566         .enable = 31,
 567         .mux = 24,
 568         .muxmask = BIT(1) | BIT(0),
 569         .table = &sun7i_a20_out_config,
 570         .getter = sun7i_a20_get_out_factors,
 571 };
 572
 573 static struct clk * __init sunxi_factors_clk_setup(struct device_node *node,
 574                                                    const struct factors_data *data)
 575 {
 576         void __iomem *reg;
 577
 578         reg = of_iomap(node, 0);
 579         if (!reg) {
 580                 pr_err("Could not get registers for factors-clk: %s\n",
 581                        node->name);
 582                 return NULL;
 583         }
 584
 585         return sunxi_factors_register(node, data, &clk_lock, reg);
 586 }
 587
 588 static void __init sun6i_ahb1_clk_setup(struct device_node *node)
 589 {
 590         sunxi_factors_clk_setup(node, &sun6i_ahb1_data);
 591 }
 592 CLK_OF_DECLARE(sun6i_a31_ahb1, "allwinner,sun6i-a31-ahb1-clk",
 593                sun6i_ahb1_clk_setup);
 594
 595
 596 /**
 597  * sunxi_mux_clk_setup() - Setup function for muxes
 598  */
 599
 600 #define SUNXI_MUX_GATE_WIDTH    2
 601
 602 struct mux_data {
 603         u8 shift;
 604 };
 605
 606 static const struct mux_data sun4i_cpu_mux_data __initconst = {
 607         .shift = 16,
 608 };
 609
 610 static const struct mux_data sun6i_a31_ahb1_mux_data __initconst = {
 611         .shift = 12,
 612 };
 613
 614 static const struct mux_data sun8i_h3_ahb2_mux_data __initconst = {
 615         .shift = 0,
 616 };
 617
 618 static struct clk * __init sunxi_mux_clk_setup(struct device_node *node,
 619                                                const struct mux_data *data)
 620 {
 621         struct clk *clk;
 622         const char *clk_name = node->name;
 623         const char *parents[SUNXI_MAX_PARENTS];
 624         void __iomem *reg;
 625         int i;
 626
 627         reg = of_iomap(node, 0);
 628
 629         i = of_clk_parent_fill(node, parents, SUNXI_MAX_PARENTS);
 630         if (of_property_read_string(node, "clock-output-names", &clk_name)) {
 631                 pr_warn("%s: could not read clock-output-names for \"%s\"\n",
 632                         __func__, clk_name);
 633                 goto out_unmap;
 634         }
 635
 636         clk = clk_register_mux(NULL, clk_name, parents, i,
 637                                CLK_SET_RATE_PARENT, reg,
 638                                data->shift, SUNXI_MUX_GATE_WIDTH,
 639                                0, &clk_lock);
 640
 641         if (IS_ERR(clk)) {
 642                 pr_warn("%s: failed to register mux clock %s: %ld\n", __func__,
 643                         clk_name, PTR_ERR(clk));
 644                 goto out_unmap;
 645         }
 646
 647         of_clk_add_provider(node, of_clk_src_simple_get, clk);
 648         clk_register_clkdev(clk, clk_name, NULL);
 649
 650         return clk;
 651
 652 out_unmap:
 653         iounmap(reg);
 654         return NULL;
 655 }
 656
 657
 658
 659 /**
 660  * sunxi_divider_clk_setup() - Setup function for simple divider clocks
 661  */
 662
 663 struct div_data {
 664         u8      shift;
 665         u8      pow;
 666         u8      width;
 667         const struct clk_div_table *table;
 668 };
 669
 670 static const struct div_data sun4i_axi_data __initconst = {
 671         .shift  = 0,
 672         .pow    = 0,
 673         .width  = 2,
 674 };
 675
 676 static const struct clk_div_table sun8i_a23_axi_table[] __initconst = {
 677         { .val = 0, .div = 1 },
 678         { .val = 1, .div = 2 },
 679         { .val = 2, .div = 3 },
 680         { .val = 3, .div = 4 },
 681         { .val = 4, .div = 4 },
 682         { .val = 5, .div = 4 },
 683         { .val = 6, .div = 4 },
 684         { .val = 7, .div = 4 },
 685         { } /* sentinel */
 686 };
 687
 688 static const struct div_data sun8i_a23_axi_data __initconst = {
 689         .width  = 3,
 690         .table  = sun8i_a23_axi_table,
 691 };
 692
 693 static const struct div_data sun4i_ahb_data __initconst = {
 694         .shift  = 4,
 695         .pow    = 1,
 696         .width  = 2,
 697 };
 698
 699 static const struct clk_div_table sun4i_apb0_table[] __initconst = {
 700         { .val = 0, .div = 2 },
 701         { .val = 1, .div = 2 },
 702         { .val = 2, .div = 4 },
 703         { .val = 3, .div = 8 },
 704         { } /* sentinel */
 705 };
 706
 707 static const struct div_data sun4i_apb0_data __initconst = {
 708         .shift  = 8,
 709         .pow    = 1,
 710         .width  = 2,
 711         .table  = sun4i_apb0_table,
 712 };
 713
 714 static void __init sunxi_divider_clk_setup(struct device_node *node,
 715                                            const struct div_data *data)
 716 {
 717         struct clk *clk;
 718         const char *clk_name = node->name;
 719         const char *clk_parent;
 720         void __iomem *reg;
 721
 722         reg = of_iomap(node, 0);
 723
 724         clk_parent = of_clk_get_parent_name(node, 0);
 725
 726         of_property_read_string(node, "clock-output-names", &clk_name);
 727
 728         clk = clk_register_divider_table(NULL, clk_name, clk_parent, 0,
 729                                          reg, data->shift, data->width,
 730                                          data->pow ? CLK_DIVIDER_POWER_OF_TWO : 0,
 731                                          data->table, &clk_lock);
 732         if (clk) {
 733                 of_clk_add_provider(node, of_clk_src_simple_get, clk);
 734                 clk_register_clkdev(clk, clk_name, NULL);
 735         }
 736 }
 737
 738
 739
 740 /**
 741  * sunxi_gates_clk_setup() - Setup function for leaf gates on clocks
 742  */
 743
 744 #define SUNXI_GATES_MAX_SIZE    64
 745
 746 struct gates_data {
 747         DECLARE_BITMAP(mask, SUNXI_GATES_MAX_SIZE);
 748 };
 749
 750 /**
 751  * sunxi_divs_clk_setup() helper data
 752  */
 753
 754 #define SUNXI_DIVS_MAX_QTY      4
 755 #define SUNXI_DIVISOR_WIDTH     2
 756
 757 struct divs_data {
 758         const struct factors_data *factors; /* data for the factor clock */
 759         int ndivs; /* number of outputs */
 760         /*
 761          * List of outputs. Refer to the diagram for sunxi_divs_clk_setup():
 762          * self or base factor clock refers to the output from the pll
 763          * itself. The remaining refer to fixed or configurable divider
 764          * outputs.
 765          */
 766         struct {
 767                 u8 self; /* is it the base factor clock? (only one) */
 768                 u8 fixed; /* is it a fixed divisor? if not... */
 769                 struct clk_div_table *table; /* is it a table based divisor? */
 770                 u8 shift; /* otherwise it's a normal divisor with this shift */
 771                 u8 pow;   /* is it power-of-two based? */
 772                 u8 gate;  /* is it independently gateable? */
 773         } div[SUNXI_DIVS_MAX_QTY];
 774 };
 775
 776 static struct clk_div_table pll6_sata_tbl[] = {
 777         { .val = 0, .div = 6, },
 778         { .val = 1, .div = 12, },
 779         { .val = 2, .div = 18, },
 780         { .val = 3, .div = 24, },
 781         { } /* sentinel */
 782 };
 783
 784 static const struct divs_data pll5_divs_data __initconst = {
 785         .factors = &sun4i_pll5_data,
 786         .ndivs = 2,
 787         .div = {
 788                 { .shift = 0, .pow = 0, }, /* M, DDR */
 789                 { .shift = 16, .pow = 1, }, /* P, other */
 790                 /* No output for the base factor clock */
 791         }
 792 };
 793
 794 static const struct divs_data pll6_divs_data __initconst = {
 795         .factors = &sun4i_pll6_data,
 796         .ndivs = 4,
 797         .div = {
 798                 { .shift = 0, .table = pll6_sata_tbl, .gate = 14 }, /* M, SATA */
 799                 { .fixed = 2 }, /* P, other */
 800                 { .self = 1 }, /* base factor clock, 2x */
 801                 { .fixed = 4 }, /* pll6 / 4, used as ahb input */
 802         }
 803 };
 804
 805 static const struct divs_data sun6i_a31_pll6_divs_data __initconst = {
 806         .factors = &sun6i_a31_pll6_data,
 807         .ndivs = 2,
 808         .div = {
 809                 { .fixed = 2 }, /* normal output */
 810                 { .self = 1 }, /* base factor clock, 2x */
 811         }
 812 };
 813
 814 /**
 815  * sunxi_divs_clk_setup() - Setup function for leaf divisors on clocks
 816  *
 817  * These clocks look something like this
 818  *            ________________________
 819  *           |         ___divisor 1---|----> to consumer
 820  * parent >--|  pll___/___divisor 2---|----> to consumer
 821  *           |        \_______________|____> to consumer
 822  *           |________________________|
 823  */
 824
 825 static struct clk ** __init sunxi_divs_clk_setup(struct device_node *node,
 826                                                  const struct divs_data *data)
 827 {
 828         struct clk_onecell_data *clk_data;
 829         const char *parent;
 830         const char *clk_name;
 831         struct clk **clks, *pclk;
 832         struct clk_hw *gate_hw, *rate_hw;
 833         const struct clk_ops *rate_ops;
 834         struct clk_gate *gate = NULL;
 835         struct clk_fixed_factor *fix_factor;
 836         struct clk_divider *divider;
 837         void __iomem *reg;
 838         int ndivs = SUNXI_DIVS_MAX_QTY, i = 0;
 839         int flags, clkflags;
 840
 841         /* if number of children known, use it */
 842         if (data->ndivs)
 843                 ndivs = data->ndivs;
 844
 845         /* Set up factor clock that we will be dividing */
 846         pclk = sunxi_factors_clk_setup(node, data->factors);
 847         parent = __clk_get_name(pclk);
 848
 849         reg = of_iomap(node, 0);
 850
 851         clk_data = kmalloc(sizeof(struct clk_onecell_data), GFP_KERNEL);
 852         if (!clk_data)
 853                 return NULL;
 854
 855         clks = kcalloc(ndivs, sizeof(*clks), GFP_KERNEL);
 856         if (!clks)
 857                 goto free_clkdata;
 858
 859         clk_data->clks = clks;
 860
 861         /* It's not a good idea to have automatic reparenting changing
 862          * our RAM clock! */
 863         clkflags = !strcmp("pll5", parent) ? 0 : CLK_SET_RATE_PARENT;
 864
 865         for (i = 0; i < ndivs; i++) {
 866                 if (of_property_read_string_index(node, "clock-output-names",
 867                                                   i, &clk_name) != 0)
 868                         break;
 869
 870                 /* If this is the base factor clock, only update clks */
 871                 if (data->div[i].self) {
 872                         clk_data->clks[i] = pclk;
 873                         continue;
 874                 }
 875
 876                 gate_hw = NULL;
 877                 rate_hw = NULL;
 878                 rate_ops = NULL;
 879
 880                 /* If this leaf clock can be gated, create a gate */
 881                 if (data->div[i].gate) {
 882                         gate = kzalloc(sizeof(*gate), GFP_KERNEL);
 883                         if (!gate)
 884                                 goto free_clks;
 885
 886                         gate->reg = reg;
 887                         gate->bit_idx = data->div[i].gate;
 888                         gate->lock = &clk_lock;
 889
 890                         gate_hw = &gate->hw;
 891                 }
 892
 893                 /* Leaves can be fixed or configurable divisors */
 894                 if (data->div[i].fixed) {
 895                         fix_factor = kzalloc(sizeof(*fix_factor), GFP_KERNEL);
 896                         if (!fix_factor)
 897                                 goto free_gate;
 898
 899                         fix_factor->mult = 1;
 900                         fix_factor->div = data->div[i].fixed;
 901
 902                         rate_hw = &fix_factor->hw;
 903                         rate_ops = &clk_fixed_factor_ops;
 904                 } else {
 905                         divider = kzalloc(sizeof(*divider), GFP_KERNEL);
 906                         if (!divider)
 907                                 goto free_gate;
 908
 909                         flags = data->div[i].pow ? CLK_DIVIDER_POWER_OF_TWO : 0;
 910
 911                         divider->reg = reg;
 912                         divider->shift = data->div[i].shift;
 913                         divider->width = SUNXI_DIVISOR_WIDTH;
 914                         divider->flags = flags;
 915                         divider->lock = &clk_lock;
 916                         divider->table = data->div[i].table;
 917
 918                         rate_hw = &divider->hw;
 919                         rate_ops = &clk_divider_ops;
 920                 }
 921
 922                 /* Wrap the (potential) gate and the divisor on a composite
 923                  * clock to unify them */
 924                 clks[i] = clk_register_composite(NULL, clk_name, &parent, 1,
 925                                                  NULL, NULL,
 926                                                  rate_hw, rate_ops,
 927                                                  gate_hw, &clk_gate_ops,
 928                                                  clkflags);
 929
 930                 WARN_ON(IS_ERR(clk_data->clks[i]));
 931                 clk_register_clkdev(clks[i], clk_name, NULL);
 932         }
 933
 934         /* Adjust to the real max */
 935         clk_data->clk_num = i;
 936
 937         of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
 938
 939         return clks;
 940
 941 free_gate:
 942         kfree(gate);
 943 free_clks:
 944         kfree(clks);
 945 free_clkdata:
 946         kfree(clk_data);
 947         return NULL;
 948 }
 949
 950
 951
 952 /* Matches for factors clocks */
 953 static const struct of_device_id clk_factors_match[] __initconst = {
 954         {.compatible = "allwinner,sun4i-a10-pll1-clk", .data = &sun4i_pll1_data,},
 955         {.compatible = "allwinner,sun6i-a31-pll1-clk", .data = &sun6i_a31_pll1_data,},
 956         {.compatible = "allwinner,sun8i-a23-pll1-clk", .data = &sun8i_a23_pll1_data,},
 957         {.compatible = "allwinner,sun7i-a20-pll4-clk", .data = &sun7i_a20_pll4_data,},
 958         {.compatible = "allwinner,sun5i-a13-ahb-clk", .data = &sun5i_a13_ahb_data,},
 959         {.compatible = "allwinner,sun4i-a10-apb1-clk", .data = &sun4i_apb1_data,},
 960         {.compatible = "allwinner,sun7i-a20-out-clk", .data = &sun7i_a20_out_data,},
 961         {}
 962 };
 963
 964 /* Matches for divider clocks */
 965 static const struct of_device_id clk_div_match[] __initconst = {
 966         {.compatible = "allwinner,sun4i-a10-axi-clk", .data = &sun4i_axi_data,},
 967         {.compatible = "allwinner,sun8i-a23-axi-clk", .data = &sun8i_a23_axi_data,},
 968         {.compatible = "allwinner,sun4i-a10-ahb-clk", .data = &sun4i_ahb_data,},
 969         {.compatible = "allwinner,sun4i-a10-apb0-clk", .data = &sun4i_apb0_data,},
 970         {}
 971 };
 972
 973 /* Matches for divided outputs */
 974 static const struct of_device_id clk_divs_match[] __initconst = {
 975         {.compatible = "allwinner,sun4i-a10-pll5-clk", .data = &pll5_divs_data,},
 976         {.compatible = "allwinner,sun4i-a10-pll6-clk", .data = &pll6_divs_data,},
 977         {.compatible = "allwinner,sun6i-a31-pll6-clk", .data = &sun6i_a31_pll6_divs_data,},
 978         {}
 979 };
 980
 981 /* Matches for mux clocks */
 982 static const struct of_device_id clk_mux_match[] __initconst = {
 983         {.compatible = "allwinner,sun4i-a10-cpu-clk", .data = &sun4i_cpu_mux_data,},
 984         {.compatible = "allwinner,sun6i-a31-ahb1-mux-clk", .data = &sun6i_a31_ahb1_mux_data,},
 985         {.compatible = "allwinner,sun8i-h3-ahb2-clk", .data = &sun8i_h3_ahb2_mux_data,},
 986         {}
 987 };
 988
 989
 990 static void __init of_sunxi_table_clock_setup(const struct of_device_id *clk_match,
 991                                               void *function)
 992 {
 993         struct device_node *np;
 994         const struct div_data *data;
 995         const struct of_device_id *match;
 996         void (*setup_function)(struct device_node *, const void *) = function;
 997
 998         for_each_matching_node_and_match(np, clk_match, &match) {
 999                 data = match->data;
1000                 setup_function(np, data);
1001         }
1002 }
1003
1004 static void __init sunxi_init_clocks(const char *clocks[], int nclocks)
1005 {
1006         unsigned int i;
1007
1008         /* Register divided output clocks */
1009         of_sunxi_table_clock_setup(clk_divs_match, sunxi_divs_clk_setup);
1010
1011         /* Register factor clocks */
1012         of_sunxi_table_clock_setup(clk_factors_match, sunxi_factors_clk_setup);
1013
1014         /* Register divider clocks */
1015         of_sunxi_table_clock_setup(clk_div_match, sunxi_divider_clk_setup);
1016
1017         /* Register mux clocks */
1018         of_sunxi_table_clock_setup(clk_mux_match, sunxi_mux_clk_setup);
1019
1020         /* Protect the clocks that needs to stay on */
1021         for (i = 0; i < nclocks; i++) {
1022                 struct clk *clk = clk_get(NULL, clocks[i]);
1023
1024                 if (!IS_ERR(clk))
1025                         clk_prepare_enable(clk);
1026         }
1027 }
1028
1029 static const char *sun4i_a10_critical_clocks[] __initdata = {
1030         "pll5_ddr",
1031 };
1032
1033 static void __init sun4i_a10_init_clocks(struct device_node *node)
1034 {
1035         sunxi_init_clocks(sun4i_a10_critical_clocks,
1036                           ARRAY_SIZE(sun4i_a10_critical_clocks));
1037 }
1038 CLK_OF_DECLARE(sun4i_a10_clk_init, "allwinner,sun4i-a10", sun4i_a10_init_clocks);
1039
1040 static const char *sun5i_critical_clocks[] __initdata = {
1041         "cpu",
1042         "pll5_ddr",
1043 };
1044
1045 static void __init sun5i_init_clocks(struct device_node *node)
1046 {
1047         sunxi_init_clocks(sun5i_critical_clocks,
1048                           ARRAY_SIZE(sun5i_critical_clocks));
1049 }
1050 CLK_OF_DECLARE(sun5i_a10s_clk_init, "allwinner,sun5i-a10s", sun5i_init_clocks);
1051 CLK_OF_DECLARE(sun5i_a13_clk_init, "allwinner,sun5i-a13", sun5i_init_clocks);
1052 CLK_OF_DECLARE(sun5i_r8_clk_init, "allwinner,sun5i-r8", sun5i_init_clocks);
1053 CLK_OF_DECLARE(sun7i_a20_clk_init, "allwinner,sun7i-a20", sun5i_init_clocks);
1054
1055 static const char *sun6i_critical_clocks[] __initdata = {
1056         "cpu",
1057 };
1058
1059 static void __init sun6i_init_clocks(struct device_node *node)
1060 {
1061         sunxi_init_clocks(sun6i_critical_clocks,
1062                           ARRAY_SIZE(sun6i_critical_clocks));
1063 }
1064 CLK_OF_DECLARE(sun6i_a31_clk_init, "allwinner,sun6i-a31", sun6i_init_clocks);
1065 CLK_OF_DECLARE(sun6i_a31s_clk_init, "allwinner,sun6i-a31s", sun6i_init_clocks);
1066 CLK_OF_DECLARE(sun8i_a23_clk_init, "allwinner,sun8i-a23", sun6i_init_clocks);
1067 CLK_OF_DECLARE(sun8i_a33_clk_init, "allwinner,sun8i-a33", sun6i_init_clocks);
1068 CLK_OF_DECLARE(sun8i_h3_clk_init, "allwinner,sun8i-h3", sun6i_init_clocks);
1069
1070 static void __init sun9i_init_clocks(struct device_node *node)
1071 {
1072         sunxi_init_clocks(NULL, 0);
1073 }
1074 CLK_OF_DECLARE(sun9i_a80_clk_init, "allwinner,sun9i-a80", sun9i_init_clocks);