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                 ccu_frac_helper_enable(&cm->common, &cm->frac);
 116
 117                 return ccu_frac_helper_set_rate(&cm->common, &cm->frac,
 118                                                 rate, cm->lock);
 119         } else {
 120                 ccu_frac_helper_disable(&cm->common, &cm->frac);
 121         }
 122
 123         parent_rate = ccu_mux_helper_apply_prediv(&cm->common, &cm->mux, -1,
 124                                                   parent_rate);
 125
 126         _cm.min = cm->mult.min;
 127
 128         if (cm->mult.max)
 129                 _cm.max = cm->mult.max;
 130         else
 131                 _cm.max = (1 << cm->mult.width) + cm->mult.offset - 1;
 132
 133         ccu_mult_find_best(parent_rate, rate, &_cm);
 134
 135         spin_lock_irqsave(cm->common.lock, flags);
 136
 137         reg = readl(cm->common.base + cm->common.reg);
 138         reg &= ~GENMASK(cm->mult.width + cm->mult.shift - 1, cm->mult.shift);
 139         reg |= ((_cm.mult - cm->mult.offset) << cm->mult.shift);
 140
 141         writel(reg, cm->common.base + cm->common.reg);
 142
 143         spin_unlock_irqrestore(cm->common.lock, flags);
 144
 145         ccu_helper_wait_for_lock(&cm->common, cm->lock);
 146
 147         return 0;
 148 }
 149
 150 static u8 ccu_mult_get_parent(struct clk_hw *hw)
 151 {
 152         struct ccu_mult *cm = hw_to_ccu_mult(hw);
 153
 154         return ccu_mux_helper_get_parent(&cm->common, &cm->mux);
 155 }
 156
 157 static int ccu_mult_set_parent(struct clk_hw *hw, u8 index)
 158 {
 159         struct ccu_mult *cm = hw_to_ccu_mult(hw);
 160
 161         return ccu_mux_helper_set_parent(&cm->common, &cm->mux, index);
 162 }
 163
 164 const struct clk_ops ccu_mult_ops = {
 165         .disable        = ccu_mult_disable,
 166         .enable         = ccu_mult_enable,
 167         .is_enabled     = ccu_mult_is_enabled,
 168
 169         .get_parent     = ccu_mult_get_parent,
 170         .set_parent     = ccu_mult_set_parent,
 171
 172         .determine_rate = ccu_mult_determine_rate,
 173         .recalc_rate    = ccu_mult_recalc_rate,
 174         .set_rate       = ccu_mult_set_rate,
 175 };