drivers/clk/socfpga/clk.c

   1 /*
   2  *  Copyright 2011-2012 Calxeda, Inc.
   3  *  Copyright (C) 2012-2013 Altera Corporation <www.altera.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * Based from clk-highbank.c
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20 #include <linux/clk.h>
  21 #include <linux/clkdev.h>
  22 #include <linux/clk-provider.h>
  23 #include <linux/io.h>
  24 #include <linux/of.h>
  25
  26 /* Clock Manager offsets */
  27 #define CLKMGR_CTRL     0x0
  28 #define CLKMGR_BYPASS   0x4
  29 #define CLKMGR_L4SRC    0x70
  30 #define CLKMGR_PERPLL_SRC       0xAC
  31
  32 /* Clock bypass bits */
  33 #define MAINPLL_BYPASS          (1<<0)
  34 #define SDRAMPLL_BYPASS         (1<<1)
  35 #define SDRAMPLL_SRC_BYPASS     (1<<2)
  36 #define PERPLL_BYPASS           (1<<3)
  37 #define PERPLL_SRC_BYPASS       (1<<4)
  38
  39 #define SOCFPGA_PLL_BG_PWRDWN           0
  40 #define SOCFPGA_PLL_EXT_ENA             1
  41 #define SOCFPGA_PLL_PWR_DOWN            2
  42 #define SOCFPGA_PLL_DIVF_MASK           0x0000FFF8
  43 #define SOCFPGA_PLL_DIVF_SHIFT  3
  44 #define SOCFPGA_PLL_DIVQ_MASK           0x003F0000
  45 #define SOCFPGA_PLL_DIVQ_SHIFT  16
  46 #define SOCFGPA_MAX_PARENTS     3
  47
  48 #define SOCFPGA_L4_MP_CLK               "l4_mp_clk"
  49 #define SOCFPGA_L4_SP_CLK               "l4_sp_clk"
  50 #define SOCFPGA_NAND_CLK                "nand_clk"
  51 #define SOCFPGA_NAND_X_CLK              "nand_x_clk"
  52 #define SOCFPGA_MMC_CLK                 "sdmmc_clk"
  53 #define SOCFPGA_DB_CLK                  "gpio_db_clk"
  54
  55 #define div_mask(width) ((1 << (width)) - 1)
  56 #define streq(a, b) (strcmp((a), (b)) == 0)
  57
  58 extern void __iomem *clk_mgr_base_addr;
  59
  60 struct socfpga_clk {
  61         struct clk_gate hw;
  62         char *parent_name;
  63         char *clk_name;
  64         u32 fixed_div;
  65         void __iomem *div_reg;
  66         u32 width;      /* only valid if div_reg != 0 */
  67         u32 shift;      /* only valid if div_reg != 0 */
  68 };
  69 #define to_socfpga_clk(p) container_of(p, struct socfpga_clk, hw.hw)
  70
  71 static unsigned long clk_pll_recalc_rate(struct clk_hw *hwclk,
  72                                          unsigned long parent_rate)
  73 {
  74         struct socfpga_clk *socfpgaclk = to_socfpga_clk(hwclk);
  75         unsigned long divf, divq, vco_freq, reg;
  76         unsigned long bypass;
  77
  78         reg = readl(socfpgaclk->hw.reg);
  79         bypass = readl(clk_mgr_base_addr + CLKMGR_BYPASS);
  80         if (bypass & MAINPLL_BYPASS)
  81                 return parent_rate;
  82
  83         divf = (reg & SOCFPGA_PLL_DIVF_MASK) >> SOCFPGA_PLL_DIVF_SHIFT;
  84         divq = (reg & SOCFPGA_PLL_DIVQ_MASK) >> SOCFPGA_PLL_DIVQ_SHIFT;
  85         vco_freq = parent_rate * (divf + 1);
  86         return vco_freq / (1 + divq);
  87 }
  88
  89
  90 static struct clk_ops clk_pll_ops = {
  91         .recalc_rate = clk_pll_recalc_rate,
  92 };
  93
  94 static unsigned long clk_periclk_recalc_rate(struct clk_hw *hwclk,
  95                                              unsigned long parent_rate)
  96 {
  97         struct socfpga_clk *socfpgaclk = to_socfpga_clk(hwclk);
  98         u32 div;
  99
 100         if (socfpgaclk->fixed_div)
 101                 div = socfpgaclk->fixed_div;
 102         else
 103                 div = ((readl(socfpgaclk->hw.reg) & 0x1ff) + 1);
 104
 105         return parent_rate / div;
 106 }
 107
 108 static const struct clk_ops periclk_ops = {
 109         .recalc_rate = clk_periclk_recalc_rate,
 110 };
 111
 112 static __init struct clk *socfpga_clk_init(struct device_node *node,
 113         const struct clk_ops *ops)
 114 {
 115         u32 reg;
 116         struct clk *clk;
 117         struct socfpga_clk *socfpga_clk;
 118         const char *clk_name = node->name;
 119         const char *parent_name;
 120         struct clk_init_data init;
 121         int rc;
 122         u32 fixed_div;
 123
 124         of_property_read_u32(node, "reg", &reg);
 125
 126         socfpga_clk = kzalloc(sizeof(*socfpga_clk), GFP_KERNEL);
 127         if (WARN_ON(!socfpga_clk))
 128                 return NULL;
 129
 130         socfpga_clk->hw.reg = clk_mgr_base_addr + reg;
 131
 132         rc = of_property_read_u32(node, "fixed-divider", &fixed_div);
 133         if (rc)
 134                 socfpga_clk->fixed_div = 0;
 135         else
 136                 socfpga_clk->fixed_div = fixed_div;
 137
 138         of_property_read_string(node, "clock-output-names", &clk_name);
 139
 140         init.name = clk_name;
 141         init.ops = ops;
 142         init.flags = 0;
 143         parent_name = of_clk_get_parent_name(node, 0);
 144         init.parent_names = &parent_name;
 145         init.num_parents = 1;
 146
 147         socfpga_clk->hw.hw.init = &init;
 148
 149         if (streq(clk_name, "main_pll") ||
 150                 streq(clk_name, "periph_pll") ||
 151                 streq(clk_name, "sdram_pll")) {
 152                 socfpga_clk->hw.bit_idx = SOCFPGA_PLL_EXT_ENA;
 153                 clk_pll_ops.enable = clk_gate_ops.enable;
 154                 clk_pll_ops.disable = clk_gate_ops.disable;
 155         }
 156
 157         clk = clk_register(NULL, &socfpga_clk->hw.hw);
 158         if (WARN_ON(IS_ERR(clk))) {
 159                 kfree(socfpga_clk);
 160                 return NULL;
 161         }
 162         rc = of_clk_add_provider(node, of_clk_src_simple_get, clk);
 163         return clk;
 164 }
 165
 166 static u8 socfpga_clk_get_parent(struct clk_hw *hwclk)
 167 {
 168         u32 l4_src;
 169         u32 perpll_src;
 170
 171         if (streq(hwclk->init->name, SOCFPGA_L4_MP_CLK)) {
 172                 l4_src = readl(clk_mgr_base_addr + CLKMGR_L4SRC);
 173                 return l4_src &= 0x1;
 174         }
 175         if (streq(hwclk->init->name, SOCFPGA_L4_SP_CLK)) {
 176                 l4_src = readl(clk_mgr_base_addr + CLKMGR_L4SRC);
 177                 return !!(l4_src & 2);
 178         }
 179
 180         perpll_src = readl(clk_mgr_base_addr + CLKMGR_PERPLL_SRC);
 181         if (streq(hwclk->init->name, SOCFPGA_MMC_CLK))
 182                 return perpll_src &= 0x3;
 183         if (streq(hwclk->init->name, SOCFPGA_NAND_CLK) ||
 184                         streq(hwclk->init->name, SOCFPGA_NAND_X_CLK))
 185                         return (perpll_src >> 2) & 3;
 186
 187         /* QSPI clock */
 188         return (perpll_src >> 4) & 3;
 189
 190 }
 191
 192 static int socfpga_clk_set_parent(struct clk_hw *hwclk, u8 parent)
 193 {
 194         u32 src_reg;
 195
 196         if (streq(hwclk->init->name, SOCFPGA_L4_MP_CLK)) {
 197                 src_reg = readl(clk_mgr_base_addr + CLKMGR_L4SRC);
 198                 src_reg &= ~0x1;
 199                 src_reg |= parent;
 200                 writel(src_reg, clk_mgr_base_addr + CLKMGR_L4SRC);
 201         } else if (streq(hwclk->init->name, SOCFPGA_L4_SP_CLK)) {
 202                 src_reg = readl(clk_mgr_base_addr + CLKMGR_L4SRC);
 203                 src_reg &= ~0x2;
 204                 src_reg |= (parent << 1);
 205                 writel(src_reg, clk_mgr_base_addr + CLKMGR_L4SRC);
 206         } else {
 207                 src_reg = readl(clk_mgr_base_addr + CLKMGR_PERPLL_SRC);
 208                 if (streq(hwclk->init->name, SOCFPGA_MMC_CLK)) {
 209                         src_reg &= ~0x3;
 210                         src_reg |= parent;
 211                 } else if (streq(hwclk->init->name, SOCFPGA_NAND_CLK) ||
 212                         streq(hwclk->init->name, SOCFPGA_NAND_X_CLK)) {
 213                         src_reg &= ~0xC;
 214                         src_reg |= (parent << 2);
 215                 } else {/* QSPI clock */
 216                         src_reg &= ~0x30;
 217                         src_reg |= (parent << 4);
 218                 }
 219                 writel(src_reg, clk_mgr_base_addr + CLKMGR_PERPLL_SRC);
 220         }
 221
 222         return 0;
 223 }
 224
 225 static unsigned long socfpga_clk_recalc_rate(struct clk_hw *hwclk,
 226         unsigned long parent_rate)
 227 {
 228         struct socfpga_clk *socfpgaclk = to_socfpga_clk(hwclk);
 229         u32 div = 1, val;
 230
 231         if (socfpgaclk->fixed_div)
 232                 div = socfpgaclk->fixed_div;
 233         else if (socfpgaclk->div_reg) {
 234                 val = readl(socfpgaclk->div_reg) >> socfpgaclk->shift;
 235                 val &= div_mask(socfpgaclk->width);
 236                 if (streq(hwclk->init->name, SOCFPGA_DB_CLK))
 237                         div = val + 1;
 238                 else
 239                         div = (1 << val);
 240         }
 241
 242         return parent_rate / div;
 243 }
 244
 245 static struct clk_ops gateclk_ops = {
 246         .recalc_rate = socfpga_clk_recalc_rate,
 247         .get_parent = socfpga_clk_get_parent,
 248         .set_parent = socfpga_clk_set_parent,
 249 };
 250
 251 static void __init socfpga_gate_clk_init(struct device_node *node,
 252         const struct clk_ops *ops)
 253 {
 254         u32 clk_gate[2];
 255         u32 div_reg[3];
 256         u32 fixed_div;
 257         struct clk *clk;
 258         struct socfpga_clk *socfpga_clk;
 259         const char *clk_name = node->name;
 260         const char *parent_name[SOCFGPA_MAX_PARENTS];
 261         struct clk_init_data init;
 262         int rc;
 263         int i = 0;
 264
 265         socfpga_clk = kzalloc(sizeof(*socfpga_clk), GFP_KERNEL);
 266         if (WARN_ON(!socfpga_clk))
 267                 return;
 268
 269         rc = of_property_read_u32_array(node, "clk-gate", clk_gate, 2);
 270         if (rc)
 271                 clk_gate[0] = 0;
 272
 273         if (clk_gate[0]) {
 274                 socfpga_clk->hw.reg = clk_mgr_base_addr + clk_gate[0];
 275                 socfpga_clk->hw.bit_idx = clk_gate[1];
 276
 277                 gateclk_ops.enable = clk_gate_ops.enable;
 278                 gateclk_ops.disable = clk_gate_ops.disable;
 279         }
 280
 281         rc = of_property_read_u32(node, "fixed-divider", &fixed_div);
 282         if (rc)
 283                 socfpga_clk->fixed_div = 0;
 284         else
 285                 socfpga_clk->fixed_div = fixed_div;
 286
 287         rc = of_property_read_u32_array(node, "div-reg", div_reg, 3);
 288         if (!rc) {
 289                 socfpga_clk->div_reg = clk_mgr_base_addr + div_reg[0];
 290                 socfpga_clk->shift = div_reg[1];
 291                 socfpga_clk->width = div_reg[2];
 292         } else {
 293                 socfpga_clk->div_reg = NULL;
 294         }
 295
 296         of_property_read_string(node, "clock-output-names", &clk_name);
 297
 298         init.name = clk_name;
 299         init.ops = ops;
 300         init.flags = 0;
 301         while (i < SOCFGPA_MAX_PARENTS && (parent_name[i] =
 302                         of_clk_get_parent_name(node, i)) != NULL)
 303                 i++;
 304
 305         init.parent_names = parent_name;
 306         init.num_parents = i;
 307         socfpga_clk->hw.hw.init = &init;
 308
 309         clk = clk_register(NULL, &socfpga_clk->hw.hw);
 310         if (WARN_ON(IS_ERR(clk))) {
 311                 kfree(socfpga_clk);
 312                 return;
 313         }
 314         rc = of_clk_add_provider(node, of_clk_src_simple_get, clk);
 315         if (WARN_ON(rc))
 316                 return;
 317 }
 318
 319 static void __init socfpga_pll_init(struct device_node *node)
 320 {
 321         socfpga_clk_init(node, &clk_pll_ops);
 322 }
 323 CLK_OF_DECLARE(socfpga_pll, "altr,socfpga-pll-clock", socfpga_pll_init);
 324
 325 static void __init socfpga_periph_init(struct device_node *node)
 326 {
 327         socfpga_clk_init(node, &periclk_ops);
 328 }
 329 CLK_OF_DECLARE(socfpga_periph, "altr,socfpga-perip-clk", socfpga_periph_init);
 330
 331 static void __init socfpga_gate_init(struct device_node *node)
 332 {
 333         socfpga_gate_clk_init(node, &gateclk_ops);
 334 }
 335 CLK_OF_DECLARE(socfpga_gate, "altr,socfpga-gate-clk", socfpga_gate_init);
 336
 337 void __init socfpga_init_clocks(void)
 338 {
 339         struct clk *clk;
 340         int ret;
 341
 342         clk = clk_register_fixed_factor(NULL, "smp_twd", "mpuclk", 0, 1, 4);
 343         ret = clk_register_clkdev(clk, NULL, "smp_twd");
 344         if (ret)
 345                 pr_err("smp_twd alias not registered\n");
 346 }