drivers/media/platform/atmel/atmel-isc-clk.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Microchip Image Sensor Controller (ISC) common clock driver setup
   4  *
   5  * Copyright (C) 2016 Microchip Technology, Inc.
   6  *
   7  * Author: Songjun Wu
   8  * Author: Eugen Hristev <eugen.hristev@microchip.com>
   9  *
  10  */
  11 #include <linux/clk.h>
  12 #include <linux/clkdev.h>
  13 #include <linux/clk-provider.h>
  14 #include <linux/pm_runtime.h>
  15 #include <linux/regmap.h>
  16
  17 #include "atmel-isc-regs.h"
  18 #include "atmel-isc.h"
  19
  20 static int isc_wait_clk_stable(struct clk_hw *hw)
  21 {
  22         struct isc_clk *isc_clk = to_isc_clk(hw);
  23         struct regmap *regmap = isc_clk->regmap;
  24         unsigned long timeout = jiffies + usecs_to_jiffies(1000);
  25         unsigned int status;
  26
  27         while (time_before(jiffies, timeout)) {
  28                 regmap_read(regmap, ISC_CLKSR, &status);
  29                 if (!(status & ISC_CLKSR_SIP))
  30                         return 0;
  31
  32                 usleep_range(10, 250);
  33         }
  34
  35         return -ETIMEDOUT;
  36 }
  37
  38 static int isc_clk_prepare(struct clk_hw *hw)
  39 {
  40         struct isc_clk *isc_clk = to_isc_clk(hw);
  41         int ret;
  42
  43         ret = pm_runtime_resume_and_get(isc_clk->dev);
  44         if (ret < 0)
  45                 return ret;
  46
  47         return isc_wait_clk_stable(hw);
  48 }
  49
  50 static void isc_clk_unprepare(struct clk_hw *hw)
  51 {
  52         struct isc_clk *isc_clk = to_isc_clk(hw);
  53
  54         isc_wait_clk_stable(hw);
  55
  56         pm_runtime_put_sync(isc_clk->dev);
  57 }
  58
  59 static int isc_clk_enable(struct clk_hw *hw)
  60 {
  61         struct isc_clk *isc_clk = to_isc_clk(hw);
  62         u32 id = isc_clk->id;
  63         struct regmap *regmap = isc_clk->regmap;
  64         unsigned long flags;
  65         unsigned int status;
  66
  67         dev_dbg(isc_clk->dev, "ISC CLK: %s, id = %d, div = %d, parent id = %d\n",
  68                 __func__, id, isc_clk->div, isc_clk->parent_id);
  69
  70         spin_lock_irqsave(&isc_clk->lock, flags);
  71         regmap_update_bits(regmap, ISC_CLKCFG,
  72                            ISC_CLKCFG_DIV_MASK(id) | ISC_CLKCFG_SEL_MASK(id),
  73                            (isc_clk->div << ISC_CLKCFG_DIV_SHIFT(id)) |
  74                            (isc_clk->parent_id << ISC_CLKCFG_SEL_SHIFT(id)));
  75
  76         regmap_write(regmap, ISC_CLKEN, ISC_CLK(id));
  77         spin_unlock_irqrestore(&isc_clk->lock, flags);
  78
  79         regmap_read(regmap, ISC_CLKSR, &status);
  80         if (status & ISC_CLK(id))
  81                 return 0;
  82         else
  83                 return -EINVAL;
  84 }
  85
  86 static void isc_clk_disable(struct clk_hw *hw)
  87 {
  88         struct isc_clk *isc_clk = to_isc_clk(hw);
  89         u32 id = isc_clk->id;
  90         unsigned long flags;
  91
  92         spin_lock_irqsave(&isc_clk->lock, flags);
  93         regmap_write(isc_clk->regmap, ISC_CLKDIS, ISC_CLK(id));
  94         spin_unlock_irqrestore(&isc_clk->lock, flags);
  95 }
  96
  97 static int isc_clk_is_enabled(struct clk_hw *hw)
  98 {
  99         struct isc_clk *isc_clk = to_isc_clk(hw);
 100         u32 status;
 101         int ret;
 102
 103         ret = pm_runtime_resume_and_get(isc_clk->dev);
 104         if (ret < 0)
 105                 return 0;
 106
 107         regmap_read(isc_clk->regmap, ISC_CLKSR, &status);
 108
 109         pm_runtime_put_sync(isc_clk->dev);
 110
 111         return status & ISC_CLK(isc_clk->id) ? 1 : 0;
 112 }
 113
 114 static unsigned long
 115 isc_clk_recalc_rate(struct clk_hw *hw, unsigned long parent_rate)
 116 {
 117         struct isc_clk *isc_clk = to_isc_clk(hw);
 118
 119         return DIV_ROUND_CLOSEST(parent_rate, isc_clk->div + 1);
 120 }
 121
 122 static int isc_clk_determine_rate(struct clk_hw *hw,
 123                                   struct clk_rate_request *req)
 124 {
 125         struct isc_clk *isc_clk = to_isc_clk(hw);
 126         long best_rate = -EINVAL;
 127         int best_diff = -1;
 128         unsigned int i, div;
 129
 130         for (i = 0; i < clk_hw_get_num_parents(hw); i++) {
 131                 struct clk_hw *parent;
 132                 unsigned long parent_rate;
 133
 134                 parent = clk_hw_get_parent_by_index(hw, i);
 135                 if (!parent)
 136                         continue;
 137
 138                 parent_rate = clk_hw_get_rate(parent);
 139                 if (!parent_rate)
 140                         continue;
 141
 142                 for (div = 1; div < ISC_CLK_MAX_DIV + 2; div++) {
 143                         unsigned long rate;
 144                         int diff;
 145
 146                         rate = DIV_ROUND_CLOSEST(parent_rate, div);
 147                         diff = abs(req->rate - rate);
 148
 149                         if (best_diff < 0 || best_diff > diff) {
 150                                 best_rate = rate;
 151                                 best_diff = diff;
 152                                 req->best_parent_rate = parent_rate;
 153                                 req->best_parent_hw = parent;
 154                         }
 155
 156                         if (!best_diff || rate < req->rate)
 157                                 break;
 158                 }
 159
 160                 if (!best_diff)
 161                         break;
 162         }
 163
 164         dev_dbg(isc_clk->dev,
 165                 "ISC CLK: %s, best_rate = %ld, parent clk: %s @ %ld\n",
 166                 __func__, best_rate,
 167                 __clk_get_name((req->best_parent_hw)->clk),
 168                 req->best_parent_rate);
 169
 170         if (best_rate < 0)
 171                 return best_rate;
 172
 173         req->rate = best_rate;
 174
 175         return 0;
 176 }
 177
 178 static int isc_clk_set_parent(struct clk_hw *hw, u8 index)
 179 {
 180         struct isc_clk *isc_clk = to_isc_clk(hw);
 181
 182         if (index >= clk_hw_get_num_parents(hw))
 183                 return -EINVAL;
 184
 185         isc_clk->parent_id = index;
 186
 187         return 0;
 188 }
 189
 190 static u8 isc_clk_get_parent(struct clk_hw *hw)
 191 {
 192         struct isc_clk *isc_clk = to_isc_clk(hw);
 193
 194         return isc_clk->parent_id;
 195 }
 196
 197 static int isc_clk_set_rate(struct clk_hw *hw,
 198                             unsigned long rate,
 199                             unsigned long parent_rate)
 200 {
 201         struct isc_clk *isc_clk = to_isc_clk(hw);
 202         u32 div;
 203
 204         if (!rate)
 205                 return -EINVAL;
 206
 207         div = DIV_ROUND_CLOSEST(parent_rate, rate);
 208         if (div > (ISC_CLK_MAX_DIV + 1) || !div)
 209                 return -EINVAL;
 210
 211         isc_clk->div = div - 1;
 212
 213         return 0;
 214 }
 215
 216 static const struct clk_ops isc_clk_ops = {
 217         .prepare        = isc_clk_prepare,
 218         .unprepare      = isc_clk_unprepare,
 219         .enable         = isc_clk_enable,
 220         .disable        = isc_clk_disable,
 221         .is_enabled     = isc_clk_is_enabled,
 222         .recalc_rate    = isc_clk_recalc_rate,
 223         .determine_rate = isc_clk_determine_rate,
 224         .set_parent     = isc_clk_set_parent,
 225         .get_parent     = isc_clk_get_parent,
 226         .set_rate       = isc_clk_set_rate,
 227 };
 228
 229 static int isc_clk_register(struct isc_device *isc, unsigned int id)
 230 {
 231         struct regmap *regmap = isc->regmap;
 232         struct device_node *np = isc->dev->of_node;
 233         struct isc_clk *isc_clk;
 234         struct clk_init_data init;
 235         const char *clk_name = np->name;
 236         const char *parent_names[3];
 237         int num_parents;
 238
 239         if (id == ISC_ISPCK && !isc->ispck_required)
 240                 return 0;
 241
 242         num_parents = of_clk_get_parent_count(np);
 243         if (num_parents < 1 || num_parents > 3)
 244                 return -EINVAL;
 245
 246         if (num_parents > 2 && id == ISC_ISPCK)
 247                 num_parents = 2;
 248
 249         of_clk_parent_fill(np, parent_names, num_parents);
 250
 251         if (id == ISC_MCK)
 252                 of_property_read_string(np, "clock-output-names", &clk_name);
 253         else
 254                 clk_name = "isc-ispck";
 255
 256         init.parent_names       = parent_names;
 257         init.num_parents        = num_parents;
 258         init.name               = clk_name;
 259         init.ops                = &isc_clk_ops;
 260         init.flags              = CLK_SET_RATE_GATE | CLK_SET_PARENT_GATE;
 261
 262         isc_clk = &isc->isc_clks[id];
 263         isc_clk->hw.init        = &init;
 264         isc_clk->regmap         = regmap;
 265         isc_clk->id             = id;
 266         isc_clk->dev            = isc->dev;
 267         spin_lock_init(&isc_clk->lock);
 268
 269         isc_clk->clk = clk_register(isc->dev, &isc_clk->hw);
 270         if (IS_ERR(isc_clk->clk)) {
 271                 dev_err(isc->dev, "%s: clock register fail\n", clk_name);
 272                 return PTR_ERR(isc_clk->clk);
 273         } else if (id == ISC_MCK) {
 274                 of_clk_add_provider(np, of_clk_src_simple_get, isc_clk->clk);
 275         }
 276
 277         return 0;
 278 }
 279
 280 int isc_clk_init(struct isc_device *isc)
 281 {
 282         unsigned int i;
 283         int ret;
 284
 285         for (i = 0; i < ARRAY_SIZE(isc->isc_clks); i++)
 286                 isc->isc_clks[i].clk = ERR_PTR(-EINVAL);
 287
 288         for (i = 0; i < ARRAY_SIZE(isc->isc_clks); i++) {
 289                 ret = isc_clk_register(isc, i);
 290                 if (ret)
 291                         return ret;
 292         }
 293
 294         return 0;
 295 }
 296 EXPORT_SYMBOL_GPL(isc_clk_init);
 297
 298 void isc_clk_cleanup(struct isc_device *isc)
 299 {
 300         unsigned int i;
 301
 302         of_clk_del_provider(isc->dev->of_node);
 303
 304         for (i = 0; i < ARRAY_SIZE(isc->isc_clks); i++) {
 305                 struct isc_clk *isc_clk = &isc->isc_clks[i];
 306
 307                 if (!IS_ERR(isc_clk->clk))
 308                         clk_unregister(isc_clk->clk);
 309         }
 310 }
 311 EXPORT_SYMBOL_GPL(isc_clk_cleanup);