drivers/clk/mmp/clk-pll.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * MMP PLL clock rate calculation
   4  *
   5  * Copyright (C) 2020 Lubomir Rintel <lkundrak@v3.sk>
   6  */
   7
   8 #include <linux/clk-provider.h>
   9 #include <linux/slab.h>
  10 #include <linux/io.h>
  11
  12 #include "clk.h"
  13
  14 #define to_clk_mmp_pll(hw)      container_of(hw, struct mmp_clk_pll, hw)
  15
  16 struct mmp_clk_pll {
  17         struct clk_hw hw;
  18         unsigned long default_rate;
  19         void __iomem *enable_reg;
  20         u32 enable;
  21         void __iomem *reg;
  22         u8 shift;
  23
  24         unsigned long input_rate;
  25         void __iomem *postdiv_reg;
  26         u8 postdiv_shift;
  27 };
  28
  29 static int mmp_clk_pll_is_enabled(struct clk_hw *hw)
  30 {
  31         struct mmp_clk_pll *pll = to_clk_mmp_pll(hw);
  32         u32 val;
  33
  34         val = readl_relaxed(pll->enable_reg);
  35         if ((val & pll->enable) == pll->enable)
  36                 return 1;
  37
  38         /* Some PLLs, if not software controlled, output default clock. */
  39         if (pll->default_rate > 0)
  40                 return 1;
  41
  42         return 0;
  43 }
  44
  45 static unsigned long mmp_clk_pll_recalc_rate(struct clk_hw *hw,
  46                                         unsigned long parent_rate)
  47 {
  48         struct mmp_clk_pll *pll = to_clk_mmp_pll(hw);
  49         u32 fbdiv, refdiv, postdiv;
  50         u64 rate;
  51         u32 val;
  52
  53         val = readl_relaxed(pll->enable_reg);
  54         if ((val & pll->enable) != pll->enable)
  55                 return pll->default_rate;
  56
  57         if (pll->reg) {
  58                 val = readl_relaxed(pll->reg);
  59                 fbdiv = (val >> pll->shift) & 0x1ff;
  60                 refdiv = (val >> (pll->shift + 9)) & 0x1f;
  61         } else {
  62                 fbdiv = 2;
  63                 refdiv = 1;
  64         }
  65
  66         if (pll->postdiv_reg) {
  67                 /* MMP3 clock rate calculation */
  68                 static const u8 postdivs[] = {2, 3, 4, 5, 6, 8, 10, 12, 16};
  69
  70                 val = readl_relaxed(pll->postdiv_reg);
  71                 postdiv = (val >> pll->postdiv_shift) & 0x7;
  72
  73                 rate = pll->input_rate;
  74                 rate *= 2 * fbdiv;
  75                 do_div(rate, refdiv);
  76                 do_div(rate, postdivs[postdiv]);
  77         } else {
  78                 /* MMP2 clock rate calculation */
  79                 if (refdiv == 3) {
  80                         rate = 19200000;
  81                 } else if (refdiv == 4) {
  82                         rate = 26000000;
  83                 } else {
  84                         pr_err("bad refdiv: %d (0x%08x)\n", refdiv, val);
  85                         return 0;
  86                 }
  87
  88                 rate *= fbdiv + 2;
  89                 do_div(rate, refdiv + 2);
  90         }
  91
  92         return (unsigned long)rate;
  93 }
  94
  95 static const struct clk_ops mmp_clk_pll_ops = {
  96         .is_enabled = mmp_clk_pll_is_enabled,
  97         .recalc_rate = mmp_clk_pll_recalc_rate,
  98 };
  99
 100 static struct clk *mmp_clk_register_pll(char *name,
 101                         unsigned long default_rate,
 102                         void __iomem *enable_reg, u32 enable,
 103                         void __iomem *reg, u8 shift,
 104                         unsigned long input_rate,
 105                         void __iomem *postdiv_reg, u8 postdiv_shift)
 106 {
 107         struct mmp_clk_pll *pll;
 108         struct clk *clk;
 109         struct clk_init_data init;
 110
 111         pll = kzalloc(sizeof(*pll), GFP_KERNEL);
 112         if (!pll)
 113                 return ERR_PTR(-ENOMEM);
 114
 115         init.name = name;
 116         init.ops = &mmp_clk_pll_ops;
 117         init.flags = 0;
 118         init.parent_names = NULL;
 119         init.num_parents = 0;
 120
 121         pll->default_rate = default_rate;
 122         pll->enable_reg = enable_reg;
 123         pll->enable = enable;
 124         pll->reg = reg;
 125         pll->shift = shift;
 126
 127         pll->input_rate = input_rate;
 128         pll->postdiv_reg = postdiv_reg;
 129         pll->postdiv_shift = postdiv_shift;
 130
 131         pll->hw.init = &init;
 132
 133         clk = clk_register(NULL, &pll->hw);
 134
 135         if (IS_ERR(clk))
 136                 kfree(pll);
 137
 138         return clk;
 139 }
 140
 141 void mmp_register_pll_clks(struct mmp_clk_unit *unit,
 142                         struct mmp_param_pll_clk *clks,
 143                         void __iomem *base, int size)
 144 {
 145         struct clk *clk;
 146         int i;
 147
 148         for (i = 0; i < size; i++) {
 149                 void __iomem *reg = NULL;
 150
 151                 if (clks[i].offset)
 152                         reg = base + clks[i].offset;
 153
 154                 clk = mmp_clk_register_pll(clks[i].name,
 155                                         clks[i].default_rate,
 156                                         base + clks[i].enable_offset,
 157                                         clks[i].enable,
 158                                         reg, clks[i].shift,
 159                                         clks[i].input_rate,
 160                                         base + clks[i].postdiv_offset,
 161                                         clks[i].postdiv_shift);
 162                 if (IS_ERR(clk)) {
 163                         pr_err("%s: failed to register clock %s\n",
 164                                __func__, clks[i].name);
 165                         continue;
 166                 }
 167                 if (clks[i].id)
 168                         unit->clk_table[clks[i].id] = clk;
 169         }
 170 }