drivers/clk/mvebu/clk-core.c

   1 /*
   2  * Marvell EBU clock core handling defined at reset
   3  *
   4  * Copyright (C) 2012 Marvell
   5  *
   6  * Gregory CLEMENT <gregory.clement@free-electrons.com>
   7  * Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
   8  *
   9  * This file is licensed under the terms of the GNU General Public
  10  * License version 2.  This program is licensed "as is" without any
  11  * warranty of any kind, whether express or implied.
  12  */
  13 #include <linux/kernel.h>
  14 #include <linux/clk.h>
  15 #include <linux/clkdev.h>
  16 #include <linux/clk-provider.h>
  17 #include <linux/of_address.h>
  18 #include <linux/io.h>
  19 #include <linux/of.h>
  20 #include "clk-core.h"
  21
  22 struct core_ratio {
  23         int id;
  24         const char *name;
  25 };
  26
  27 struct core_clocks {
  28         u32 (*get_tclk_freq)(void __iomem *sar);
  29         u32 (*get_cpu_freq)(void __iomem *sar);
  30         void (*get_clk_ratio)(void __iomem *sar, int id, int *mult, int *div);
  31         const struct core_ratio *ratios;
  32         int num_ratios;
  33 };
  34
  35 static struct clk_onecell_data clk_data;
  36
  37 static void __init mvebu_clk_core_setup(struct device_node *np,
  38                                  struct core_clocks *coreclk)
  39 {
  40         const char *tclk_name = "tclk";
  41         const char *cpuclk_name = "cpuclk";
  42         void __iomem *base;
  43         unsigned long rate;
  44         int n;
  45
  46         base = of_iomap(np, 0);
  47         if (WARN_ON(!base))
  48                 return;
  49
  50         /*
  51          * Allocate struct for TCLK, cpu clk, and core ratio clocks
  52          */
  53         clk_data.clk_num = 2 + coreclk->num_ratios;
  54         clk_data.clks = kzalloc(clk_data.clk_num * sizeof(struct clk *),
  55                                 GFP_KERNEL);
  56         if (WARN_ON(!clk_data.clks))
  57                 return;
  58
  59         /*
  60          * Register TCLK
  61          */
  62         of_property_read_string_index(np, "clock-output-names", 0,
  63                                       &tclk_name);
  64         rate = coreclk->get_tclk_freq(base);
  65         clk_data.clks[0] = clk_register_fixed_rate(NULL, tclk_name, NULL,
  66                                                    CLK_IS_ROOT, rate);
  67         WARN_ON(IS_ERR(clk_data.clks[0]));
  68
  69         /*
  70          * Register CPU clock
  71          */
  72         of_property_read_string_index(np, "clock-output-names", 1,
  73                                       &cpuclk_name);
  74         rate = coreclk->get_cpu_freq(base);
  75         clk_data.clks[1] = clk_register_fixed_rate(NULL, cpuclk_name, NULL,
  76                                                    CLK_IS_ROOT, rate);
  77         WARN_ON(IS_ERR(clk_data.clks[1]));
  78
  79         /*
  80          * Register fixed-factor clocks derived from CPU clock
  81          */
  82         for (n = 0; n < coreclk->num_ratios; n++) {
  83                 const char *rclk_name = coreclk->ratios[n].name;
  84                 int mult, div;
  85
  86                 of_property_read_string_index(np, "clock-output-names",
  87                                               2+n, &rclk_name);
  88                 coreclk->get_clk_ratio(base, coreclk->ratios[n].id,
  89                                        &mult, &div);
  90                 clk_data.clks[2+n] = clk_register_fixed_factor(NULL, rclk_name,
  91                                        cpuclk_name, 0, mult, div);
  92                 WARN_ON(IS_ERR(clk_data.clks[2+n]));
  93         };
  94
  95         /*
  96          * SAR register isn't needed anymore
  97          */
  98         iounmap(base);
  99
 100         of_clk_add_provider(np, of_clk_src_onecell_get, &clk_data);
 101 }
 102
 103 #ifdef CONFIG_MACH_ARMADA_370_XP
 104 /*
 105  * Armada 370/XP Sample At Reset is a 64 bit bitfiled split in two
 106  * register of 32 bits
 107  */
 108
 109 #define SARL                                0   /* Low part [0:31] */
 110 #define     SARL_AXP_PCLK_FREQ_OPT          21
 111 #define     SARL_AXP_PCLK_FREQ_OPT_MASK     0x7
 112 #define     SARL_A370_PCLK_FREQ_OPT         11
 113 #define     SARL_A370_PCLK_FREQ_OPT_MASK    0xF
 114 #define     SARL_AXP_FAB_FREQ_OPT           24
 115 #define     SARL_AXP_FAB_FREQ_OPT_MASK      0xF
 116 #define     SARL_A370_FAB_FREQ_OPT          15
 117 #define     SARL_A370_FAB_FREQ_OPT_MASK     0x1F
 118 #define     SARL_A370_TCLK_FREQ_OPT         20
 119 #define     SARL_A370_TCLK_FREQ_OPT_MASK    0x1
 120 #define SARH                                4   /* High part [32:63] */
 121 #define     SARH_AXP_PCLK_FREQ_OPT          (52-32)
 122 #define     SARH_AXP_PCLK_FREQ_OPT_MASK     0x1
 123 #define     SARH_AXP_PCLK_FREQ_OPT_SHIFT    3
 124 #define     SARH_AXP_FAB_FREQ_OPT           (51-32)
 125 #define     SARH_AXP_FAB_FREQ_OPT_MASK      0x1
 126 #define     SARH_AXP_FAB_FREQ_OPT_SHIFT     4
 127
 128 static const u32 __initconst armada_370_tclk_frequencies[] = {
 129         166000000,
 130         200000000,
 131 };
 132
 133 static u32 __init armada_370_get_tclk_freq(void __iomem *sar)
 134 {
 135         u8 tclk_freq_select = 0;
 136
 137         tclk_freq_select = ((readl(sar) >> SARL_A370_TCLK_FREQ_OPT) &
 138                             SARL_A370_TCLK_FREQ_OPT_MASK);
 139         return armada_370_tclk_frequencies[tclk_freq_select];
 140 }
 141
 142 static const u32 __initconst armada_370_cpu_frequencies[] = {
 143         400000000,
 144         533000000,
 145         667000000,
 146         800000000,
 147         1000000000,
 148         1067000000,
 149         1200000000,
 150 };
 151
 152 static u32 __init armada_370_get_cpu_freq(void __iomem *sar)
 153 {
 154         u32 cpu_freq;
 155         u8 cpu_freq_select = 0;
 156
 157         cpu_freq_select = ((readl(sar) >> SARL_A370_PCLK_FREQ_OPT) &
 158                            SARL_A370_PCLK_FREQ_OPT_MASK);
 159         if (cpu_freq_select >= ARRAY_SIZE(armada_370_cpu_frequencies)) {
 160                 pr_err("CPU freq select unsupported %d\n", cpu_freq_select);
 161                 cpu_freq = 0;
 162         } else
 163                 cpu_freq = armada_370_cpu_frequencies[cpu_freq_select];
 164
 165         return cpu_freq;
 166 }
 167
 168 enum { A370_XP_NBCLK, A370_XP_HCLK, A370_XP_DRAMCLK };
 169
 170 static const struct core_ratio __initconst armada_370_xp_core_ratios[] = {
 171         { .id = A370_XP_NBCLK,   .name = "nbclk" },
 172         { .id = A370_XP_HCLK,    .name = "hclk" },
 173         { .id = A370_XP_DRAMCLK, .name = "dramclk" },
 174 };
 175
 176 static const int __initconst armada_370_xp_nbclk_ratios[32][2] = {
 177         {0, 1}, {1, 2}, {2, 2}, {2, 2},
 178         {1, 2}, {1, 2}, {1, 1}, {2, 3},
 179         {0, 1}, {1, 2}, {2, 4}, {0, 1},
 180         {1, 2}, {0, 1}, {0, 1}, {2, 2},
 181         {0, 1}, {0, 1}, {0, 1}, {1, 1},
 182         {2, 3}, {0, 1}, {0, 1}, {0, 1},
 183         {0, 1}, {0, 1}, {0, 1}, {1, 1},
 184         {0, 1}, {0, 1}, {0, 1}, {0, 1},
 185 };
 186
 187 static const int __initconst armada_370_xp_hclk_ratios[32][2] = {
 188         {0, 1}, {1, 2}, {2, 6}, {2, 3},
 189         {1, 3}, {1, 4}, {1, 2}, {2, 6},
 190         {0, 1}, {1, 6}, {2, 10}, {0, 1},
 191         {1, 4}, {0, 1}, {0, 1}, {2, 5},
 192         {0, 1}, {0, 1}, {0, 1}, {1, 2},
 193         {2, 6}, {0, 1}, {0, 1}, {0, 1},
 194         {0, 1}, {0, 1}, {0, 1}, {1, 1},
 195         {0, 1}, {0, 1}, {0, 1}, {0, 1},
 196 };
 197
 198 static const int __initconst armada_370_xp_dramclk_ratios[32][2] = {
 199         {0, 1}, {1, 2}, {2, 3}, {2, 3},
 200         {1, 3}, {1, 2}, {1, 2}, {2, 6},
 201         {0, 1}, {1, 3}, {2, 5}, {0, 1},
 202         {1, 4}, {0, 1}, {0, 1}, {2, 5},
 203         {0, 1}, {0, 1}, {0, 1}, {1, 1},
 204         {2, 3}, {0, 1}, {0, 1}, {0, 1},
 205         {0, 1}, {0, 1}, {0, 1}, {1, 1},
 206         {0, 1}, {0, 1}, {0, 1}, {0, 1},
 207 };
 208
 209 static void __init armada_370_xp_get_clk_ratio(u32 opt,
 210         void __iomem *sar, int id, int *mult, int *div)
 211 {
 212         switch (id) {
 213         case A370_XP_NBCLK:
 214                 *mult = armada_370_xp_nbclk_ratios[opt][0];
 215                 *div = armada_370_xp_nbclk_ratios[opt][1];
 216                 break;
 217         case A370_XP_HCLK:
 218                 *mult = armada_370_xp_hclk_ratios[opt][0];
 219                 *div = armada_370_xp_hclk_ratios[opt][1];
 220                 break;
 221         case A370_XP_DRAMCLK:
 222                 *mult = armada_370_xp_dramclk_ratios[opt][0];
 223                 *div = armada_370_xp_dramclk_ratios[opt][1];
 224                 break;
 225         }
 226 }
 227
 228 static void __init armada_370_get_clk_ratio(
 229         void __iomem *sar, int id, int *mult, int *div)
 230 {
 231         u32 opt = ((readl(sar) >> SARL_A370_FAB_FREQ_OPT) &
 232                 SARL_A370_FAB_FREQ_OPT_MASK);
 233
 234         armada_370_xp_get_clk_ratio(opt, sar, id, mult, div);
 235 }
 236
 237
 238 static const struct core_clocks armada_370_core_clocks = {
 239         .get_tclk_freq = armada_370_get_tclk_freq,
 240         .get_cpu_freq = armada_370_get_cpu_freq,
 241         .get_clk_ratio = armada_370_get_clk_ratio,
 242         .ratios = armada_370_xp_core_ratios,
 243         .num_ratios = ARRAY_SIZE(armada_370_xp_core_ratios),
 244 };
 245
 246 static const u32 __initconst armada_xp_cpu_frequencies[] = {
 247         1000000000,
 248         1066000000,
 249         1200000000,
 250         1333000000,
 251         1500000000,
 252         1666000000,
 253         1800000000,
 254         2000000000,
 255         667000000,
 256         0,
 257         800000000,
 258         1600000000,
 259 };
 260
 261 /* For Armada XP TCLK frequency is fix: 250MHz */
 262 static u32 __init armada_xp_get_tclk_freq(void __iomem *sar)
 263 {
 264         return 250 * 1000 * 1000;
 265 }
 266
 267 static u32 __init armada_xp_get_cpu_freq(void __iomem *sar)
 268 {
 269         u32 cpu_freq;
 270         u8 cpu_freq_select = 0;
 271
 272         cpu_freq_select = ((readl(sar) >> SARL_AXP_PCLK_FREQ_OPT) &
 273                            SARL_AXP_PCLK_FREQ_OPT_MASK);
 274         /*
 275          * The upper bit is not contiguous to the other ones and
 276          * located in the high part of the SAR registers
 277          */
 278         cpu_freq_select |= (((readl(sar+4) >> SARH_AXP_PCLK_FREQ_OPT) &
 279                              SARH_AXP_PCLK_FREQ_OPT_MASK)
 280                             << SARH_AXP_PCLK_FREQ_OPT_SHIFT);
 281         if (cpu_freq_select >= ARRAY_SIZE(armada_xp_cpu_frequencies)) {
 282                 pr_err("CPU freq select unsupported: %d\n", cpu_freq_select);
 283                 cpu_freq = 0;
 284         } else
 285                 cpu_freq = armada_xp_cpu_frequencies[cpu_freq_select];
 286
 287         return cpu_freq;
 288 }
 289
 290 static void __init armada_xp_get_clk_ratio(
 291         void __iomem *sar, int id, int *mult, int *div)
 292 {
 293
 294         u32 opt = ((readl(sar) >> SARL_AXP_FAB_FREQ_OPT) &
 295               SARL_AXP_FAB_FREQ_OPT_MASK);
 296         /*
 297          * The upper bit is not contiguous to the other ones and
 298          * located in the high part of the SAR registers
 299          */
 300         opt |= (((readl(sar+4) >> SARH_AXP_FAB_FREQ_OPT) &
 301                 SARH_AXP_FAB_FREQ_OPT_MASK)
 302                << SARH_AXP_FAB_FREQ_OPT_SHIFT);
 303
 304         armada_370_xp_get_clk_ratio(opt, sar, id, mult, div);
 305 }
 306
 307 static const struct core_clocks armada_xp_core_clocks = {
 308         .get_tclk_freq = armada_xp_get_tclk_freq,
 309         .get_cpu_freq = armada_xp_get_cpu_freq,
 310         .get_clk_ratio = armada_xp_get_clk_ratio,
 311         .ratios = armada_370_xp_core_ratios,
 312         .num_ratios = ARRAY_SIZE(armada_370_xp_core_ratios),
 313 };
 314
 315 #endif /* CONFIG_MACH_ARMADA_370_XP */
 316
 317 /*
 318  * Dove PLL sample-at-reset configuration
 319  *
 320  * SAR0[8:5]   : CPU frequency
 321  *               5  = 1000 MHz
 322  *               6  =  933 MHz
 323  *               7  =  933 MHz
 324  *               8  =  800 MHz
 325  *               9  =  800 MHz
 326  *               10 =  800 MHz
 327  *               11 = 1067 MHz
 328  *               12 =  667 MHz
 329  *               13 =  533 MHz
 330  *               14 =  400 MHz
 331  *               15 =  333 MHz
 332  *               others reserved.
 333  *
 334  * SAR0[11:9]  : CPU to L2 Clock divider ratio
 335  *               0 = (1/1) * CPU
 336  *               2 = (1/2) * CPU
 337  *               4 = (1/3) * CPU
 338  *               6 = (1/4) * CPU
 339  *               others reserved.
 340  *
 341  * SAR0[15:12] : CPU to DDR DRAM Clock divider ratio
 342  *               0  = (1/1) * CPU
 343  *               2  = (1/2) * CPU
 344  *               3  = (2/5) * CPU
 345  *               4  = (1/3) * CPU
 346  *               6  = (1/4) * CPU
 347  *               8  = (1/5) * CPU
 348  *               10 = (1/6) * CPU
 349  *               12 = (1/7) * CPU
 350  *               14 = (1/8) * CPU
 351  *               15 = (1/10) * CPU
 352  *               others reserved.
 353  *
 354  * SAR0[24:23] : TCLK frequency
 355  *               0 = 166 MHz
 356  *               1 = 125 MHz
 357  *               others reserved.
 358  */
 359 #ifdef CONFIG_ARCH_DOVE
 360 #define SAR_DOVE_CPU_FREQ               5
 361 #define SAR_DOVE_CPU_FREQ_MASK          0xf
 362 #define SAR_DOVE_L2_RATIO               9
 363 #define SAR_DOVE_L2_RATIO_MASK          0x7
 364 #define SAR_DOVE_DDR_RATIO              12
 365 #define SAR_DOVE_DDR_RATIO_MASK         0xf
 366 #define SAR_DOVE_TCLK_FREQ              23
 367 #define SAR_DOVE_TCLK_FREQ_MASK         0x3
 368
 369 static const u32 __initconst dove_tclk_frequencies[] = {
 370         166666667,
 371         125000000,
 372         0, 0
 373 };
 374
 375 static u32 __init dove_get_tclk_freq(void __iomem *sar)
 376 {
 377         u32 opt = (readl(sar) >> SAR_DOVE_TCLK_FREQ) &
 378                 SAR_DOVE_TCLK_FREQ_MASK;
 379         return dove_tclk_frequencies[opt];
 380 }
 381
 382 static const u32 __initconst dove_cpu_frequencies[] = {
 383         0, 0, 0, 0, 0,
 384         1000000000,
 385         933333333, 933333333,
 386         800000000, 800000000, 800000000,
 387         1066666667,
 388         666666667,
 389         533333333,
 390         400000000,
 391         333333333
 392 };
 393
 394 static u32 __init dove_get_cpu_freq(void __iomem *sar)
 395 {
 396         u32 opt = (readl(sar) >> SAR_DOVE_CPU_FREQ) &
 397                 SAR_DOVE_CPU_FREQ_MASK;
 398         return dove_cpu_frequencies[opt];
 399 }
 400
 401 enum { DOVE_CPU_TO_L2, DOVE_CPU_TO_DDR };
 402
 403 static const struct core_ratio __initconst dove_core_ratios[] = {
 404         { .id = DOVE_CPU_TO_L2, .name = "l2clk", },
 405         { .id = DOVE_CPU_TO_DDR, .name = "ddrclk", }
 406 };
 407
 408 static const int __initconst dove_cpu_l2_ratios[8][2] = {
 409         { 1, 1 }, { 0, 1 }, { 1, 2 }, { 0, 1 },
 410         { 1, 3 }, { 0, 1 }, { 1, 4 }, { 0, 1 }
 411 };
 412
 413 static const int __initconst dove_cpu_ddr_ratios[16][2] = {
 414         { 1, 1 }, { 0, 1 }, { 1, 2 }, { 2, 5 },
 415         { 1, 3 }, { 0, 1 }, { 1, 4 }, { 0, 1 },
 416         { 1, 5 }, { 0, 1 }, { 1, 6 }, { 0, 1 },
 417         { 1, 7 }, { 0, 1 }, { 1, 8 }, { 1, 10 }
 418 };
 419
 420 static void __init dove_get_clk_ratio(
 421         void __iomem *sar, int id, int *mult, int *div)
 422 {
 423         switch (id) {
 424         case DOVE_CPU_TO_L2:
 425         {
 426                 u32 opt = (readl(sar) >> SAR_DOVE_L2_RATIO) &
 427                         SAR_DOVE_L2_RATIO_MASK;
 428                 *mult = dove_cpu_l2_ratios[opt][0];
 429                 *div = dove_cpu_l2_ratios[opt][1];
 430                 break;
 431         }
 432         case DOVE_CPU_TO_DDR:
 433         {
 434                 u32 opt = (readl(sar) >> SAR_DOVE_DDR_RATIO) &
 435                         SAR_DOVE_DDR_RATIO_MASK;
 436                 *mult = dove_cpu_ddr_ratios[opt][0];
 437                 *div = dove_cpu_ddr_ratios[opt][1];
 438                 break;
 439         }
 440         }
 441 }
 442
 443 static const struct core_clocks dove_core_clocks = {
 444         .get_tclk_freq = dove_get_tclk_freq,
 445         .get_cpu_freq = dove_get_cpu_freq,
 446         .get_clk_ratio = dove_get_clk_ratio,
 447         .ratios = dove_core_ratios,
 448         .num_ratios = ARRAY_SIZE(dove_core_ratios),
 449 };
 450 #endif /* CONFIG_ARCH_DOVE */
 451
 452 /*
 453  * Kirkwood PLL sample-at-reset configuration
 454  * (6180 has different SAR layout than other Kirkwood SoCs)
 455  *
 456  * SAR0[4:3,22,1] : CPU frequency (6281,6292,6282)
 457  *      4  =  600 MHz
 458  *      6  =  800 MHz
 459  *      7  = 1000 MHz
 460  *      9  = 1200 MHz
 461  *      12 = 1500 MHz
 462  *      13 = 1600 MHz
 463  *      14 = 1800 MHz
 464  *      15 = 2000 MHz
 465  *      others reserved.
 466  *
 467  * SAR0[19,10:9] : CPU to L2 Clock divider ratio (6281,6292,6282)
 468  *      1 = (1/2) * CPU
 469  *      3 = (1/3) * CPU
 470  *      5 = (1/4) * CPU
 471  *      others reserved.
 472  *
 473  * SAR0[8:5] : CPU to DDR DRAM Clock divider ratio (6281,6292,6282)
 474  *      2 = (1/2) * CPU
 475  *      4 = (1/3) * CPU
 476  *      6 = (1/4) * CPU
 477  *      7 = (2/9) * CPU
 478  *      8 = (1/5) * CPU
 479  *      9 = (1/6) * CPU
 480  *      others reserved.
 481  *
 482  * SAR0[4:2] : Kirkwood 6180 cpu/l2/ddr clock configuration (6180 only)
 483  *      5 = [CPU =  600 MHz, L2 = (1/2) * CPU, DDR = 200 MHz = (1/3) * CPU]
 484  *      6 = [CPU =  800 MHz, L2 = (1/2) * CPU, DDR = 200 MHz = (1/4) * CPU]
 485  *      7 = [CPU = 1000 MHz, L2 = (1/2) * CPU, DDR = 200 MHz = (1/5) * CPU]
 486  *      others reserved.
 487  *
 488  * SAR0[21] : TCLK frequency
 489  *      0 = 200 MHz
 490  *      1 = 166 MHz
 491  *      others reserved.
 492  */
 493 #ifdef CONFIG_ARCH_KIRKWOOD
 494 #define SAR_KIRKWOOD_CPU_FREQ(x)        \
 495         (((x & (1 <<  1)) >>  1) |      \
 496          ((x & (1 << 22)) >> 21) |      \
 497          ((x & (3 <<  3)) >>  1))
 498 #define SAR_KIRKWOOD_L2_RATIO(x)        \
 499         (((x & (3 <<  9)) >> 9) |       \
 500          (((x & (1 << 19)) >> 17)))
 501 #define SAR_KIRKWOOD_DDR_RATIO          5
 502 #define SAR_KIRKWOOD_DDR_RATIO_MASK     0xf
 503 #define SAR_MV88F6180_CLK               2
 504 #define SAR_MV88F6180_CLK_MASK          0x7
 505 #define SAR_KIRKWOOD_TCLK_FREQ          21
 506 #define SAR_KIRKWOOD_TCLK_FREQ_MASK     0x1
 507
 508 enum { KIRKWOOD_CPU_TO_L2, KIRKWOOD_CPU_TO_DDR };
 509
 510 static const struct core_ratio __initconst kirkwood_core_ratios[] = {
 511         { .id = KIRKWOOD_CPU_TO_L2, .name = "l2clk", },
 512         { .id = KIRKWOOD_CPU_TO_DDR, .name = "ddrclk", }
 513 };
 514
 515 static u32 __init kirkwood_get_tclk_freq(void __iomem *sar)
 516 {
 517         u32 opt = (readl(sar) >> SAR_KIRKWOOD_TCLK_FREQ) &
 518                 SAR_KIRKWOOD_TCLK_FREQ_MASK;
 519         return (opt) ? 166666667 : 200000000;
 520 }
 521
 522 static const u32 __initconst kirkwood_cpu_frequencies[] = {
 523         0, 0, 0, 0,
 524         600000000,
 525         0,
 526         800000000,
 527         1000000000,
 528         0,
 529         1200000000,
 530         0, 0,
 531         1500000000,
 532         1600000000,
 533         1800000000,
 534         2000000000
 535 };
 536
 537 static u32 __init kirkwood_get_cpu_freq(void __iomem *sar)
 538 {
 539         u32 opt = SAR_KIRKWOOD_CPU_FREQ(readl(sar));
 540         return kirkwood_cpu_frequencies[opt];
 541 }
 542
 543 static const int __initconst kirkwood_cpu_l2_ratios[8][2] = {
 544         { 0, 1 }, { 1, 2 }, { 0, 1 }, { 1, 3 },
 545         { 0, 1 }, { 1, 4 }, { 0, 1 }, { 0, 1 }
 546 };
 547
 548 static const int __initconst kirkwood_cpu_ddr_ratios[16][2] = {
 549         { 0, 1 }, { 0, 1 }, { 1, 2 }, { 0, 1 },
 550         { 1, 3 }, { 0, 1 }, { 1, 4 }, { 2, 9 },
 551         { 1, 5 }, { 1, 6 }, { 0, 1 }, { 0, 1 },
 552         { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }
 553 };
 554
 555 static void __init kirkwood_get_clk_ratio(
 556         void __iomem *sar, int id, int *mult, int *div)
 557 {
 558         switch (id) {
 559         case KIRKWOOD_CPU_TO_L2:
 560         {
 561                 u32 opt = SAR_KIRKWOOD_L2_RATIO(readl(sar));
 562                 *mult = kirkwood_cpu_l2_ratios[opt][0];
 563                 *div = kirkwood_cpu_l2_ratios[opt][1];
 564                 break;
 565         }
 566         case KIRKWOOD_CPU_TO_DDR:
 567         {
 568                 u32 opt = (readl(sar) >> SAR_KIRKWOOD_DDR_RATIO) &
 569                         SAR_KIRKWOOD_DDR_RATIO_MASK;
 570                 *mult = kirkwood_cpu_ddr_ratios[opt][0];
 571                 *div = kirkwood_cpu_ddr_ratios[opt][1];
 572                 break;
 573         }
 574         }
 575 }
 576
 577 static const struct core_clocks kirkwood_core_clocks = {
 578         .get_tclk_freq = kirkwood_get_tclk_freq,
 579         .get_cpu_freq = kirkwood_get_cpu_freq,
 580         .get_clk_ratio = kirkwood_get_clk_ratio,
 581         .ratios = kirkwood_core_ratios,
 582         .num_ratios = ARRAY_SIZE(kirkwood_core_ratios),
 583 };
 584
 585 static const u32 __initconst mv88f6180_cpu_frequencies[] = {
 586         0, 0, 0, 0, 0,
 587         600000000,
 588         800000000,
 589         1000000000
 590 };
 591
 592 static u32 __init mv88f6180_get_cpu_freq(void __iomem *sar)
 593 {
 594         u32 opt = (readl(sar) >> SAR_MV88F6180_CLK) & SAR_MV88F6180_CLK_MASK;
 595         return mv88f6180_cpu_frequencies[opt];
 596 }
 597
 598 static const int __initconst mv88f6180_cpu_ddr_ratios[8][2] = {
 599         { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
 600         { 0, 1 }, { 1, 3 }, { 1, 4 }, { 1, 5 }
 601 };
 602
 603 static void __init mv88f6180_get_clk_ratio(
 604         void __iomem *sar, int id, int *mult, int *div)
 605 {
 606         switch (id) {
 607         case KIRKWOOD_CPU_TO_L2:
 608         {
 609                 /* mv88f6180 has a fixed 1:2 CPU-to-L2 ratio */
 610                 *mult = 1;
 611                 *div = 2;
 612                 break;
 613         }
 614         case KIRKWOOD_CPU_TO_DDR:
 615         {
 616                 u32 opt = (readl(sar) >> SAR_MV88F6180_CLK) &
 617                         SAR_MV88F6180_CLK_MASK;
 618                 *mult = mv88f6180_cpu_ddr_ratios[opt][0];
 619                 *div = mv88f6180_cpu_ddr_ratios[opt][1];
 620                 break;
 621         }
 622         }
 623 }
 624
 625 static const struct core_clocks mv88f6180_core_clocks = {
 626         .get_tclk_freq = kirkwood_get_tclk_freq,
 627         .get_cpu_freq = mv88f6180_get_cpu_freq,
 628         .get_clk_ratio = mv88f6180_get_clk_ratio,
 629         .ratios = kirkwood_core_ratios,
 630         .num_ratios = ARRAY_SIZE(kirkwood_core_ratios),
 631 };
 632 #endif /* CONFIG_ARCH_KIRKWOOD */
 633
 634 static const __initdata struct of_device_id clk_core_match[] = {
 635 #ifdef CONFIG_MACH_ARMADA_370_XP
 636         {
 637                 .compatible = "marvell,armada-370-core-clock",
 638                 .data = &armada_370_core_clocks,
 639         },
 640         {
 641                 .compatible = "marvell,armada-xp-core-clock",
 642                 .data = &armada_xp_core_clocks,
 643         },
 644 #endif
 645 #ifdef CONFIG_ARCH_DOVE
 646         {
 647                 .compatible = "marvell,dove-core-clock",
 648                 .data = &dove_core_clocks,
 649         },
 650 #endif
 651
 652 #ifdef CONFIG_ARCH_KIRKWOOD
 653         {
 654                 .compatible = "marvell,kirkwood-core-clock",
 655                 .data = &kirkwood_core_clocks,
 656         },
 657         {
 658                 .compatible = "marvell,mv88f6180-core-clock",
 659                 .data = &mv88f6180_core_clocks,
 660         },
 661 #endif
 662
 663         { }
 664 };
 665
 666 void __init mvebu_core_clk_init(void)
 667 {
 668         struct device_node *np;
 669
 670         for_each_matching_node(np, clk_core_match) {
 671                 const struct of_device_id *match =
 672                         of_match_node(clk_core_match, np);
 673                 mvebu_clk_core_setup(np, (struct core_clocks *)match->data);
 674         }
 675 }