target/linux/sunxi/patches-4.9/0005-clk-sunxi-ng-Add-minimums-for-all-the-relevant-struc.patch

   1 From 6e0d50daa97f4bf9706e343b4f71171e88921209 Mon Sep 17 00:00:00 2001
   2 From: Maxime Ripard <maxime.ripard@free-electrons.com>
   3 Date: Thu, 29 Sep 2016 22:57:26 +0200
   4 Subject: clk: sunxi-ng: Add minimums for all the relevant structures and
   5  clocks
   6
   7 Modify the current clocks we have to be able to specify the minimum for
   8 each clocks we support, just like we support the max.
   9
  10 Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
  11 Acked-by: Chen-Yu Tsai <wens@csie.org>
  12 ---
  13  drivers/clk/sunxi-ng/ccu_mult.c |  7 ++++++-
  14  drivers/clk/sunxi-ng/ccu_nk.c   | 12 ++++++++----
  15  drivers/clk/sunxi-ng/ccu_nkm.c  | 18 ++++++++++++------
  16  drivers/clk/sunxi-ng/ccu_nkmp.c | 24 ++++++++++++++++--------
  17  drivers/clk/sunxi-ng/ccu_nm.c   | 12 ++++++++----
  18  5 files changed, 50 insertions(+), 23 deletions(-)
  19
  20 --- a/drivers/clk/sunxi-ng/ccu_mult.c
  21 +++ b/drivers/clk/sunxi-ng/ccu_mult.c
  22 @@ -14,7 +14,7 @@
  23  #include "ccu_mult.h"
  24
  25  struct _ccu_mult {
  26 -       unsigned long   mult, max;
  27 +       unsigned long   mult, min, max;
  28  };
  29
  30  static void ccu_mult_find_best(unsigned long parent, unsigned long rate,
  31 @@ -23,6 +23,9 @@ static void ccu_mult_find_best(unsigned
  32         int _mult;
  33
  34         _mult = rate / parent;
  35 +       if (_mult < mult->min)
  36 +               _mult = mult->min;
  37 +
  38         if (_mult > mult->max)
  39                 _mult = mult->max;
  40
  41 @@ -37,6 +40,7 @@ static unsigned long ccu_mult_round_rate
  42         struct ccu_mult *cm = data;
  43         struct _ccu_mult _cm;
  44
  45 +       _cm.min = 1;
  46         _cm.max = 1 << cm->mult.width;
  47         ccu_mult_find_best(parent_rate, rate, &_cm);
  48
  49 @@ -101,6 +105,7 @@ static int ccu_mult_set_rate(struct clk_
  50         ccu_mux_helper_adjust_parent_for_prediv(&cm->common, &cm->mux, -1,
  51                                                 &parent_rate);
  52
  53 +       _cm.min = 1;
  54         _cm.max = 1 << cm->mult.width;
  55         ccu_mult_find_best(parent_rate, rate, &_cm);
  56
  57 --- a/drivers/clk/sunxi-ng/ccu_nk.c
  58 +++ b/drivers/clk/sunxi-ng/ccu_nk.c
  59 @@ -14,8 +14,8 @@
  60  #include "ccu_nk.h"
  61
  62  struct _ccu_nk {
  63 -       unsigned long   n, max_n;
  64 -       unsigned long   k, max_k;
  65 +       unsigned long   n, min_n, max_n;
  66 +       unsigned long   k, min_k, max_k;
  67  };
  68
  69  static void ccu_nk_find_best(unsigned long parent, unsigned long rate,
  70 @@ -25,8 +25,8 @@ static void ccu_nk_find_best(unsigned lo
  71         unsigned int best_k = 0, best_n = 0;
  72         unsigned int _k, _n;
  73
  74 -       for (_k = 1; _k <= nk->max_k; _k++) {
  75 -               for (_n = 1; _n <= nk->max_n; _n++) {
  76 +       for (_k = nk->min_k; _k <= nk->max_k; _k++) {
  77 +               for (_n = nk->min_n; _n <= nk->max_n; _n++) {
  78                         unsigned long tmp_rate = parent * _n * _k;
  79
  80                         if (tmp_rate > rate)
  81 @@ -97,7 +97,9 @@ static long ccu_nk_round_rate(struct clk
  82         if (nk->common.features & CCU_FEATURE_FIXED_POSTDIV)
  83                 rate *= nk->fixed_post_div;
  84
  85 +       _nk.min_n = 1;
  86         _nk.max_n = 1 << nk->n.width;
  87 +       _nk.min_k = 1;
  88         _nk.max_k = 1 << nk->k.width;
  89
  90         ccu_nk_find_best(*parent_rate, rate, &_nk);
  91 @@ -120,7 +122,9 @@ static int ccu_nk_set_rate(struct clk_hw
  92         if (nk->common.features & CCU_FEATURE_FIXED_POSTDIV)
  93                 rate = rate * nk->fixed_post_div;
  94
  95 +       _nk.min_n = 1;
  96         _nk.max_n = 1 << nk->n.width;
  97 +       _nk.min_k = 1;
  98         _nk.max_k = 1 << nk->k.width;
  99
 100         ccu_nk_find_best(parent_rate, rate, &_nk);
 101 --- a/drivers/clk/sunxi-ng/ccu_nkm.c
 102 +++ b/drivers/clk/sunxi-ng/ccu_nkm.c
 103 @@ -14,9 +14,9 @@
 104  #include "ccu_nkm.h"
 105
 106  struct _ccu_nkm {
 107 -       unsigned long   n, max_n;
 108 -       unsigned long   k, max_k;
 109 -       unsigned long   m, max_m;
 110 +       unsigned long   n, min_n, max_n;
 111 +       unsigned long   k, min_k, max_k;
 112 +       unsigned long   m, min_m, max_m;
 113  };
 114
 115  static void ccu_nkm_find_best(unsigned long parent, unsigned long rate,
 116 @@ -26,9 +26,9 @@ static void ccu_nkm_find_best(unsigned l
 117         unsigned long best_n = 0, best_k = 0, best_m = 0;
 118         unsigned long _n, _k, _m;
 119
 120 -       for (_k = 1; _k <= nkm->max_k; _k++) {
 121 -               for (_n = 1; _n <= nkm->max_n; _n++) {
 122 -                       for (_m = 1; _n <= nkm->max_m; _m++) {
 123 +       for (_k = nkm->min_k; _k <= nkm->max_k; _k++) {
 124 +               for (_n = nkm->min_n; _n <= nkm->max_n; _n++) {
 125 +                       for (_m = nkm->min_m; _m <= nkm->max_m; _m++) {
 126                                 unsigned long tmp_rate;
 127
 128                                 tmp_rate = parent * _n * _k / _m;
 129 @@ -100,8 +100,11 @@ static unsigned long ccu_nkm_round_rate(
 130         struct ccu_nkm *nkm = data;
 131         struct _ccu_nkm _nkm;
 132
 133 +       _nkm.min_n = 1;
 134         _nkm.max_n = 1 << nkm->n.width;
 135 +       _nkm.min_k = 1;
 136         _nkm.max_k = 1 << nkm->k.width;
 137 +       _nkm.min_m = 1;
 138         _nkm.max_m = nkm->m.max ?: 1 << nkm->m.width;
 139
 140         ccu_nkm_find_best(parent_rate, rate, &_nkm);
 141 @@ -126,8 +129,11 @@ static int ccu_nkm_set_rate(struct clk_h
 142         unsigned long flags;
 143         u32 reg;
 144
 145 +       _nkm.min_n = 1;
 146         _nkm.max_n = 1 << nkm->n.width;
 147 +       _nkm.min_k = 1;
 148         _nkm.max_k = 1 << nkm->k.width;
 149 +       _nkm.min_m = 1;
 150         _nkm.max_m = nkm->m.max ?: 1 << nkm->m.width;
 151
 152         ccu_nkm_find_best(parent_rate, rate, &_nkm);
 153 --- a/drivers/clk/sunxi-ng/ccu_nkmp.c
 154 +++ b/drivers/clk/sunxi-ng/ccu_nkmp.c
 155 @@ -14,10 +14,10 @@
 156  #include "ccu_nkmp.h"
 157
 158  struct _ccu_nkmp {
 159 -       unsigned long   n, max_n;
 160 -       unsigned long   k, max_k;
 161 -       unsigned long   m, max_m;
 162 -       unsigned long   p, max_p;
 163 +       unsigned long   n, min_n, max_n;
 164 +       unsigned long   k, min_k, max_k;
 165 +       unsigned long   m, min_m, max_m;
 166 +       unsigned long   p, min_p, max_p;
 167  };
 168
 169  static void ccu_nkmp_find_best(unsigned long parent, unsigned long rate,
 170 @@ -27,10 +27,10 @@ static void ccu_nkmp_find_best(unsigned
 171         unsigned long best_n = 0, best_k = 0, best_m = 0, best_p = 0;
 172         unsigned long _n, _k, _m, _p;
 173
 174 -       for (_k = 1; _k <= nkmp->max_k; _k++) {
 175 -               for (_n = 1; _n <= nkmp->max_n; _n++) {
 176 -                       for (_m = 1; _n <= nkmp->max_m; _m++) {
 177 -                               for (_p = 1; _p <= nkmp->max_p; _p <<= 1) {
 178 +       for (_k = nkmp->min_k; _k <= nkmp->max_k; _k++) {
 179 +               for (_n = nkmp->min_n; _n <= nkmp->max_n; _n++) {
 180 +                       for (_m = nkmp->min_m; _m <= nkmp->max_m; _m++) {
 181 +                               for (_p = nkmp->min_p; _p <= nkmp->max_p; _p <<= 1) {
 182                                         unsigned long tmp_rate;
 183
 184                                         tmp_rate = parent * _n * _k / (_m * _p);
 185 @@ -107,9 +107,13 @@ static long ccu_nkmp_round_rate(struct c
 186         struct ccu_nkmp *nkmp = hw_to_ccu_nkmp(hw);
 187         struct _ccu_nkmp _nkmp;
 188
 189 +       _nkmp.min_n = 1;
 190         _nkmp.max_n = 1 << nkmp->n.width;
 191 +       _nkmp.min_k = 1;
 192         _nkmp.max_k = 1 << nkmp->k.width;
 193 +       _nkmp.min_m = 1;
 194         _nkmp.max_m = nkmp->m.max ?: 1 << nkmp->m.width;
 195 +       _nkmp.min_p = 1;
 196         _nkmp.max_p = nkmp->p.max ?: 1 << ((1 << nkmp->p.width) - 1);
 197
 198         ccu_nkmp_find_best(*parent_rate, rate, &_nkmp);
 199 @@ -125,9 +129,13 @@ static int ccu_nkmp_set_rate(struct clk_
 200         unsigned long flags;
 201         u32 reg;
 202
 203 +       _nkmp.min_n = 1;
 204         _nkmp.max_n = 1 << nkmp->n.width;
 205 +       _nkmp.min_k = 1;
 206         _nkmp.max_k = 1 << nkmp->k.width;
 207 +       _nkmp.min_m = 1;
 208         _nkmp.max_m = nkmp->m.max ?: 1 << nkmp->m.width;
 209 +       _nkmp.min_p = 1;
 210         _nkmp.max_p = nkmp->p.max ?: 1 << ((1 << nkmp->p.width) - 1);
 211
 212         ccu_nkmp_find_best(parent_rate, rate, &_nkmp);
 213 --- a/drivers/clk/sunxi-ng/ccu_nm.c
 214 +++ b/drivers/clk/sunxi-ng/ccu_nm.c
 215 @@ -15,8 +15,8 @@
 216  #include "ccu_nm.h"
 217
 218  struct _ccu_nm {
 219 -       unsigned long   n, max_n;
 220 -       unsigned long   m, max_m;
 221 +       unsigned long   n, min_n, max_n;
 222 +       unsigned long   m, min_m, max_m;
 223  };
 224
 225  static void ccu_nm_find_best(unsigned long parent, unsigned long rate,
 226 @@ -26,8 +26,8 @@ static void ccu_nm_find_best(unsigned lo
 227         unsigned long best_n = 0, best_m = 0;
 228         unsigned long _n, _m;
 229
 230 -       for (_n = 1; _n <= nm->max_n; _n++) {
 231 -               for (_m = 1; _n <= nm->max_m; _m++) {
 232 +       for (_n = nm->min_n; _n <= nm->max_n; _n++) {
 233 +               for (_m = nm->min_m; _m <= nm->max_m; _m++) {
 234                         unsigned long tmp_rate = parent * _n  / _m;
 235
 236                         if (tmp_rate > rate)
 237 @@ -93,7 +93,9 @@ static long ccu_nm_round_rate(struct clk
 238         struct ccu_nm *nm = hw_to_ccu_nm(hw);
 239         struct _ccu_nm _nm;
 240
 241 +       _nm.min_n = 1;
 242         _nm.max_n = 1 << nm->n.width;
 243 +       _nm.min_m = 1;
 244         _nm.max_m = nm->m.max ?: 1 << nm->m.width;
 245
 246         ccu_nm_find_best(*parent_rate, rate, &_nm);
 247 @@ -114,7 +116,9 @@ static int ccu_nm_set_rate(struct clk_hw
 248         else
 249                 ccu_frac_helper_disable(&nm->common, &nm->frac);
 250
 251 +       _nm.min_n = 1;
 252         _nm.max_n = 1 << nm->n.width;
 253 +       _nm.min_m = 1;
 254         _nm.max_m = nm->m.max ?: 1 << nm->m.width;
 255
 256         ccu_nm_find_best(parent_rate, rate, &_nm);