drivers/clk/sunxi-ng/ccu_mult.c

   1 /*
   2  * Copyright (C) 2016 Maxime Ripard
   3  * Maxime Ripard <maxime.ripard@free-electrons.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or (at your option) any later version.
   9  */
  10
  11 #include <linux/clk-provider.h>
  12
  13 #include "ccu_gate.h"
  14 #include "ccu_mult.h"
  15
  16 struct _ccu_mult {
  17         unsigned long   mult, min, max;
  18 };
  19
  20 static void ccu_mult_find_best(unsigned long parent, unsigned long rate,
  21                                struct _ccu_mult *mult)
  22 {
  23         int _mult;
  24
  25         _mult = rate / parent;
  26         if (_mult < mult->min)
  27                 _mult = mult->min;
  28
  29         if (_mult > mult->max)
  30                 _mult = mult->max;
  31
  32         mult->mult = _mult;
  33 }
  34
  35 static unsigned long ccu_mult_round_rate(struct ccu_mux_internal *mux,
  36                                          struct clk_hw *parent,
  37                                          unsigned long *parent_rate,
  38                                          unsigned long rate,
  39                                          void *data)
  40 {
  41         struct ccu_mult *cm = data;
  42         struct _ccu_mult _cm;
  43
  44         _cm.min = cm->mult.min;
  45
  46         if (cm->mult.max)
  47                 _cm.max = cm->mult.max;
  48         else
  49                 _cm.max = (1 << cm->mult.width) + cm->mult.offset - 1;
  50
  51         ccu_mult_find_best(*parent_rate, rate, &_cm);
  52
  53         return *parent_rate * _cm.mult;
  54 }
  55
  56 static void ccu_mult_disable(struct clk_hw *hw)
  57 {
  58         struct ccu_mult *cm = hw_to_ccu_mult(hw);
  59
  60         return ccu_gate_helper_disable(&cm->common, cm->enable);
  61 }
  62
  63 static int ccu_mult_enable(struct clk_hw *hw)
  64 {
  65         struct ccu_mult *cm = hw_to_ccu_mult(hw);
  66
  67         return ccu_gate_helper_enable(&cm->common, cm->enable);
  68 }
  69
  70 static int ccu_mult_is_enabled(struct clk_hw *hw)
  71 {
  72         struct ccu_mult *cm = hw_to_ccu_mult(hw);
  73
  74         return ccu_gate_helper_is_enabled(&cm->common, cm->enable);
  75 }
  76
  77 static unsigned long ccu_mult_recalc_rate(struct clk_hw *hw,
  78                                         unsigned long parent_rate)
  79 {
  80         struct ccu_mult *cm = hw_to_ccu_mult(hw);
  81         unsigned long val;
  82         u32 reg;
  83
  84         if (ccu_frac_helper_is_enabled(&cm->common, &cm->frac))
  85                 return ccu_frac_helper_read_rate(&cm->common, &cm->frac);
  86
  87         reg = readl(cm->common.base + cm->common.reg);
  88         val = reg >> cm->mult.shift;
  89         val &= (1 << cm->mult.width) - 1;
  90
  91         parent_rate = ccu_mux_helper_apply_prediv(&cm->common, &cm->mux, -1,
  92                                                   parent_rate);
  93
  94         return parent_rate * (val + cm->mult.offset);
  95 }
  96
  97 static int ccu_mult_determine_rate(struct clk_hw *hw,
  98                                 struct clk_rate_request *req)
  99 {
 100         struct ccu_mult *cm = hw_to_ccu_mult(hw);
 101
 102         return ccu_mux_helper_determine_rate(&cm->common, &cm->mux,
 103                                              req, ccu_mult_round_rate, cm);
 104 }
 105
 106 static int ccu_mult_set_rate(struct clk_hw *hw, unsigned long rate,
 107                            unsigned long parent_rate)
 108 {
 109         struct ccu_mult *cm = hw_to_ccu_mult(hw);
 110         struct _ccu_mult _cm;
 111         unsigned long flags;
 112         u32 reg;
 113
 114         if (ccu_frac_helper_has_rate(&cm->common, &cm->frac, rate))
 115                 return ccu_frac_helper_set_rate(&cm->common, &cm->frac, rate);
 116         else
 117                 ccu_frac_helper_disable(&cm->common, &cm->frac);
 118
 119         parent_rate = ccu_mux_helper_apply_prediv(&cm->common, &cm->mux, -1,
 120                                                   parent_rate);
 121
 122         _cm.min = cm->mult.min;
 123
 124         if (cm->mult.max)
 125                 _cm.max = cm->mult.max;
 126         else
 127                 _cm.max = (1 << cm->mult.width) + cm->mult.offset - 1;
 128
 129         ccu_mult_find_best(parent_rate, rate, &_cm);
 130
 131         spin_lock_irqsave(cm->common.lock, flags);
 132
 133         reg = readl(cm->common.base + cm->common.reg);
 134         reg &= ~GENMASK(cm->mult.width + cm->mult.shift - 1, cm->mult.shift);
 135         reg |= ((_cm.mult - cm->mult.offset) << cm->mult.shift);
 136
 137         writel(reg, cm->common.base + cm->common.reg);
 138
 139         spin_unlock_irqrestore(cm->common.lock, flags);
 140
 141         ccu_helper_wait_for_lock(&cm->common, cm->lock);
 142
 143         return 0;
 144 }
 145
 146 static u8 ccu_mult_get_parent(struct clk_hw *hw)
 147 {
 148         struct ccu_mult *cm = hw_to_ccu_mult(hw);
 149
 150         return ccu_mux_helper_get_parent(&cm->common, &cm->mux);
 151 }
 152
 153 static int ccu_mult_set_parent(struct clk_hw *hw, u8 index)
 154 {
 155         struct ccu_mult *cm = hw_to_ccu_mult(hw);
 156
 157         return ccu_mux_helper_set_parent(&cm->common, &cm->mux, index);
 158 }
 159
 160 const struct clk_ops ccu_mult_ops = {
 161         .disable        = ccu_mult_disable,
 162         .enable         = ccu_mult_enable,
 163         .is_enabled     = ccu_mult_is_enabled,
 164
 165         .get_parent     = ccu_mult_get_parent,
 166         .set_parent     = ccu_mult_set_parent,
 167
 168         .determine_rate = ccu_mult_determine_rate,
 169         .recalc_rate    = ccu_mult_recalc_rate,
 170         .set_rate       = ccu_mult_set_rate,
 171 };