drivers/clk/clk-fixed-rate.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
   4  * Copyright (C) 2011-2012 Mike Turquette, Linaro Ltd <mturquette@linaro.org>
   5  *
   6  * Fixed rate clock implementation
   7  */
   8
   9 #include <linux/clk-provider.h>
  10 #include <linux/module.h>
  11 #include <linux/slab.h>
  12 #include <linux/io.h>
  13 #include <linux/err.h>
  14 #include <linux/of.h>
  15 #include <linux/platform_device.h>
  16
  17 /*
  18  * DOC: basic fixed-rate clock that cannot gate
  19  *
  20  * Traits of this clock:
  21  * prepare - clk_(un)prepare only ensures parents are prepared
  22  * enable - clk_enable only ensures parents are enabled
  23  * rate - rate is always a fixed value.  No clk_set_rate support
  24  * parent - fixed parent.  No clk_set_parent support
  25  */
  26
  27 #define to_clk_fixed_rate(_hw) container_of(_hw, struct clk_fixed_rate, hw)
  28
  29 static unsigned long clk_fixed_rate_recalc_rate(struct clk_hw *hw,
  30                 unsigned long parent_rate)
  31 {
  32         return to_clk_fixed_rate(hw)->fixed_rate;
  33 }
  34
  35 static unsigned long clk_fixed_rate_recalc_accuracy(struct clk_hw *hw,
  36                 unsigned long parent_accuracy)
  37 {
  38         struct clk_fixed_rate *fixed = to_clk_fixed_rate(hw);
  39
  40         if (fixed->flags & CLK_FIXED_RATE_PARENT_ACCURACY)
  41                 return parent_accuracy;
  42
  43         return fixed->fixed_accuracy;
  44 }
  45
  46 const struct clk_ops clk_fixed_rate_ops = {
  47         .recalc_rate = clk_fixed_rate_recalc_rate,
  48         .recalc_accuracy = clk_fixed_rate_recalc_accuracy,
  49 };
  50 EXPORT_SYMBOL_GPL(clk_fixed_rate_ops);
  51
  52 static void devm_clk_hw_register_fixed_rate_release(struct device *dev, void *res)
  53 {
  54         struct clk_fixed_rate *fix = res;
  55
  56         /*
  57          * We can not use clk_hw_unregister_fixed_rate, since it will kfree()
  58          * the hw, resulting in double free. Just unregister the hw and let
  59          * devres code kfree() it.
  60          */
  61         clk_hw_unregister(&fix->hw);
  62 }
  63
  64 struct clk_hw *__clk_hw_register_fixed_rate(struct device *dev,
  65                 struct device_node *np, const char *name,
  66                 const char *parent_name, const struct clk_hw *parent_hw,
  67                 const struct clk_parent_data *parent_data, unsigned long flags,
  68                 unsigned long fixed_rate, unsigned long fixed_accuracy,
  69                 unsigned long clk_fixed_flags, bool devm)
  70 {
  71         struct clk_fixed_rate *fixed;
  72         struct clk_hw *hw;
  73         struct clk_init_data init = {};
  74         int ret = -EINVAL;
  75
  76         /* allocate fixed-rate clock */
  77         if (devm)
  78                 fixed = devres_alloc(devm_clk_hw_register_fixed_rate_release,
  79                                      sizeof(*fixed), GFP_KERNEL);
  80         else
  81                 fixed = kzalloc(sizeof(*fixed), GFP_KERNEL);
  82         if (!fixed)
  83                 return ERR_PTR(-ENOMEM);
  84
  85         init.name = name;
  86         init.ops = &clk_fixed_rate_ops;
  87         init.flags = flags;
  88         init.parent_names = parent_name ? &parent_name : NULL;
  89         init.parent_hws = parent_hw ? &parent_hw : NULL;
  90         init.parent_data = parent_data;
  91         if (parent_name || parent_hw || parent_data)
  92                 init.num_parents = 1;
  93         else
  94                 init.num_parents = 0;
  95
  96         /* struct clk_fixed_rate assignments */
  97         fixed->flags = clk_fixed_flags;
  98         fixed->fixed_rate = fixed_rate;
  99         fixed->fixed_accuracy = fixed_accuracy;
 100         fixed->hw.init = &init;
 101
 102         /* register the clock */
 103         hw = &fixed->hw;
 104         if (dev || !np)
 105                 ret = clk_hw_register(dev, hw);
 106         else if (np)
 107                 ret = of_clk_hw_register(np, hw);
 108         if (ret) {
 109                 if (devm)
 110                         devres_free(fixed);
 111                 else
 112                         kfree(fixed);
 113                 hw = ERR_PTR(ret);
 114         } else if (devm)
 115                 devres_add(dev, fixed);
 116
 117         return hw;
 118 }
 119 EXPORT_SYMBOL_GPL(__clk_hw_register_fixed_rate);
 120
 121 struct clk *clk_register_fixed_rate(struct device *dev, const char *name,
 122                 const char *parent_name, unsigned long flags,
 123                 unsigned long fixed_rate)
 124 {
 125         struct clk_hw *hw;
 126
 127         hw = clk_hw_register_fixed_rate_with_accuracy(dev, name, parent_name,
 128                                                       flags, fixed_rate, 0);
 129         if (IS_ERR(hw))
 130                 return ERR_CAST(hw);
 131         return hw->clk;
 132 }
 133 EXPORT_SYMBOL_GPL(clk_register_fixed_rate);
 134
 135 void clk_unregister_fixed_rate(struct clk *clk)
 136 {
 137         struct clk_hw *hw;
 138
 139         hw = __clk_get_hw(clk);
 140         if (!hw)
 141                 return;
 142
 143         clk_unregister(clk);
 144         kfree(to_clk_fixed_rate(hw));
 145 }
 146 EXPORT_SYMBOL_GPL(clk_unregister_fixed_rate);
 147
 148 void clk_hw_unregister_fixed_rate(struct clk_hw *hw)
 149 {
 150         struct clk_fixed_rate *fixed;
 151
 152         fixed = to_clk_fixed_rate(hw);
 153
 154         clk_hw_unregister(hw);
 155         kfree(fixed);
 156 }
 157 EXPORT_SYMBOL_GPL(clk_hw_unregister_fixed_rate);
 158
 159 #ifdef CONFIG_OF
 160 static struct clk_hw *_of_fixed_clk_setup(struct device_node *node)
 161 {
 162         struct clk_hw *hw;
 163         const char *clk_name = node->name;
 164         u32 rate;
 165         u32 accuracy = 0;
 166         int ret;
 167
 168         if (of_property_read_u32(node, "clock-frequency", &rate))
 169                 return ERR_PTR(-EIO);
 170
 171         of_property_read_u32(node, "clock-accuracy", &accuracy);
 172
 173         of_property_read_string(node, "clock-output-names", &clk_name);
 174
 175         hw = clk_hw_register_fixed_rate_with_accuracy(NULL, clk_name, NULL,
 176                                                     0, rate, accuracy);
 177         if (IS_ERR(hw))
 178                 return hw;
 179
 180         ret = of_clk_add_hw_provider(node, of_clk_hw_simple_get, hw);
 181         if (ret) {
 182                 clk_hw_unregister_fixed_rate(hw);
 183                 return ERR_PTR(ret);
 184         }
 185
 186         return hw;
 187 }
 188
 189 /**
 190  * of_fixed_clk_setup() - Setup function for simple fixed rate clock
 191  * @node:       device node for the clock
 192  */
 193 void __init of_fixed_clk_setup(struct device_node *node)
 194 {
 195         _of_fixed_clk_setup(node);
 196 }
 197 CLK_OF_DECLARE(fixed_clk, "fixed-clock", of_fixed_clk_setup);
 198
 199 static int of_fixed_clk_remove(struct platform_device *pdev)
 200 {
 201         struct clk_hw *hw = platform_get_drvdata(pdev);
 202
 203         of_clk_del_provider(pdev->dev.of_node);
 204         clk_hw_unregister_fixed_rate(hw);
 205
 206         return 0;
 207 }
 208
 209 static int of_fixed_clk_probe(struct platform_device *pdev)
 210 {
 211         struct clk_hw *hw;
 212
 213         /*
 214          * This function is not executed when of_fixed_clk_setup
 215          * succeeded.
 216          */
 217         hw = _of_fixed_clk_setup(pdev->dev.of_node);
 218         if (IS_ERR(hw))
 219                 return PTR_ERR(hw);
 220
 221         platform_set_drvdata(pdev, hw);
 222
 223         return 0;
 224 }
 225
 226 static const struct of_device_id of_fixed_clk_ids[] = {
 227         { .compatible = "fixed-clock" },
 228         { }
 229 };
 230
 231 static struct platform_driver of_fixed_clk_driver = {
 232         .driver = {
 233                 .name = "of_fixed_clk",
 234                 .of_match_table = of_fixed_clk_ids,
 235         },
 236         .probe = of_fixed_clk_probe,
 237         .remove = of_fixed_clk_remove,
 238 };
 239 builtin_platform_driver(of_fixed_clk_driver);
 240 #endif