drivers/clk/meson/clk-mpll.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
   2 /*
   3  * Copyright (c) 2016 AmLogic, Inc.
   4  * Author: Michael Turquette <[email protected]>
   5  */
   6
   7 /*
   8  * MultiPhase Locked Loops are outputs from a PLL with additional frequency
   9  * scaling capabilities. MPLL rates are calculated as:
  10  *
  11  * f(N2_integer, SDM_IN ) = 2.0G/(N2_integer + SDM_IN/16384)
  12  */
  13
  14 #include <linux/clk-provider.h>
  15 #include <linux/module.h>
  16 #include <linux/spinlock.h>
  17
  18 #include "clk-regmap.h"
  19 #include "clk-mpll.h"
  20
  21 #define SDM_DEN 16384
  22 #define N2_MIN  4
  23 #define N2_MAX  511
  24
  25 static inline struct meson_clk_mpll_data *
  26 meson_clk_mpll_data(struct clk_regmap *clk)
  27 {
  28         return (struct meson_clk_mpll_data *)clk->data;
  29 }
  30
  31 static long rate_from_params(unsigned long parent_rate,
  32                              unsigned int sdm,
  33                              unsigned int n2)
  34 {
  35         unsigned long divisor = (SDM_DEN * n2) + sdm;
  36
  37         if (n2 < N2_MIN)
  38                 return -EINVAL;
  39
  40         return DIV_ROUND_UP_ULL((u64)parent_rate * SDM_DEN, divisor);
  41 }
  42
  43 static void params_from_rate(unsigned long requested_rate,
  44                              unsigned long parent_rate,
  45                              unsigned int *sdm,
  46                              unsigned int *n2,
  47                              u8 flags)
  48 {
  49         uint64_t div = parent_rate;
  50         uint64_t frac = do_div(div, requested_rate);
  51
  52         frac *= SDM_DEN;
  53
  54         if (flags & CLK_MESON_MPLL_ROUND_CLOSEST)
  55                 *sdm = DIV_ROUND_CLOSEST_ULL(frac, requested_rate);
  56         else
  57                 *sdm = DIV_ROUND_UP_ULL(frac, requested_rate);
  58
  59         if (*sdm == SDM_DEN) {
  60                 *sdm = 0;
  61                 div += 1;
  62         }
  63
  64         if (div < N2_MIN) {
  65                 *n2 = N2_MIN;
  66                 *sdm = 0;
  67         } else if (div > N2_MAX) {
  68                 *n2 = N2_MAX;
  69                 *sdm = SDM_DEN - 1;
  70         } else {
  71                 *n2 = div;
  72         }
  73 }
  74
  75 static unsigned long mpll_recalc_rate(struct clk_hw *hw,
  76                 unsigned long parent_rate)
  77 {
  78         struct clk_regmap *clk = to_clk_regmap(hw);
  79         struct meson_clk_mpll_data *mpll = meson_clk_mpll_data(clk);
  80         unsigned int sdm, n2;
  81         long rate;
  82
  83         sdm = meson_parm_read(clk->map, &mpll->sdm);
  84         n2 = meson_parm_read(clk->map, &mpll->n2);
  85
  86         rate = rate_from_params(parent_rate, sdm, n2);
  87         return rate < 0 ? 0 : rate;
  88 }
  89
  90 static int mpll_determine_rate(struct clk_hw *hw, struct clk_rate_request *req)
  91 {
  92         struct clk_regmap *clk = to_clk_regmap(hw);
  93         struct meson_clk_mpll_data *mpll = meson_clk_mpll_data(clk);
  94         unsigned int sdm, n2;
  95         long rate;
  96
  97         params_from_rate(req->rate, req->best_parent_rate, &sdm, &n2,
  98                          mpll->flags);
  99
 100         rate = rate_from_params(req->best_parent_rate, sdm, n2);
 101         if (rate < 0)
 102                 return rate;
 103
 104         req->rate = rate;
 105         return 0;
 106 }
 107
 108 static int mpll_set_rate(struct clk_hw *hw,
 109                          unsigned long rate,
 110                          unsigned long parent_rate)
 111 {
 112         struct clk_regmap *clk = to_clk_regmap(hw);
 113         struct meson_clk_mpll_data *mpll = meson_clk_mpll_data(clk);
 114         unsigned int sdm, n2;
 115
 116         params_from_rate(rate, parent_rate, &sdm, &n2, mpll->flags);
 117
 118         /* Set the fractional part */
 119         meson_parm_write(clk->map, &mpll->sdm, sdm);
 120
 121         /* Set the integer divider part */
 122         meson_parm_write(clk->map, &mpll->n2, n2);
 123
 124         return 0;
 125 }
 126
 127 static int mpll_init(struct clk_hw *hw)
 128 {
 129         struct clk_regmap *clk = to_clk_regmap(hw);
 130         struct meson_clk_mpll_data *mpll = meson_clk_mpll_data(clk);
 131
 132         if (mpll->init_count)
 133                 regmap_multi_reg_write(clk->map, mpll->init_regs,
 134                                        mpll->init_count);
 135
 136         /* Enable the fractional part */
 137         meson_parm_write(clk->map, &mpll->sdm_en, 1);
 138
 139         /* Set spread spectrum if possible */
 140         if (MESON_PARM_APPLICABLE(&mpll->ssen)) {
 141                 unsigned int ss =
 142                         mpll->flags & CLK_MESON_MPLL_SPREAD_SPECTRUM ? 1 : 0;
 143                 meson_parm_write(clk->map, &mpll->ssen, ss);
 144         }
 145
 146         /* Set the magic misc bit if required */
 147         if (MESON_PARM_APPLICABLE(&mpll->misc))
 148                 meson_parm_write(clk->map, &mpll->misc, 1);
 149
 150         return 0;
 151 }
 152
 153 const struct clk_ops meson_clk_mpll_ro_ops = {
 154         .recalc_rate    = mpll_recalc_rate,
 155         .determine_rate = mpll_determine_rate,
 156 };
 157 EXPORT_SYMBOL_NS_GPL(meson_clk_mpll_ro_ops, "CLK_MESON");
 158
 159 const struct clk_ops meson_clk_mpll_ops = {
 160         .recalc_rate    = mpll_recalc_rate,
 161         .determine_rate = mpll_determine_rate,
 162         .set_rate       = mpll_set_rate,
 163         .init           = mpll_init,
 164 };
 165 EXPORT_SYMBOL_NS_GPL(meson_clk_mpll_ops, "CLK_MESON");
 166
 167 MODULE_DESCRIPTION("Amlogic MPLL driver");
 168 MODULE_AUTHOR("Michael Turquette <[email protected]>");
 169 MODULE_LICENSE("GPL");
 170 MODULE_IMPORT_NS("CLK_MESON");