root/drivers/clk/clk-fixed-rate.c

DEFINITIONS

1. clk_fixed_rate_recalc_rate
2. clk_fixed_rate_recalc_accuracy
3. clk_hw_register_fixed_rate_with_accuracy
4. clk_register_fixed_rate_with_accuracy
5. clk_hw_register_fixed_rate
6. clk_register_fixed_rate
7. clk_unregister_fixed_rate
8. clk_hw_unregister_fixed_rate
9. _of_fixed_clk_setup
10. of_fixed_clk_setup
11. of_fixed_clk_remove
12. of_fixed_clk_probe

   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 static unsigned long clk_fixed_rate_recalc_rate(struct clk_hw *hw,
  28                 unsigned long parent_rate)
  29 {
  30         return to_clk_fixed_rate(hw)->fixed_rate;
  31 }
  32 
  33 static unsigned long clk_fixed_rate_recalc_accuracy(struct clk_hw *hw,
  34                 unsigned long parent_accuracy)
  35 {
  36         return to_clk_fixed_rate(hw)->fixed_accuracy;
  37 }
  38 
  39 const struct clk_ops clk_fixed_rate_ops = {
  40         .recalc_rate = clk_fixed_rate_recalc_rate,
  41         .recalc_accuracy = clk_fixed_rate_recalc_accuracy,
  42 };
  43 EXPORT_SYMBOL_GPL(clk_fixed_rate_ops);
  44 
  45 /**
  46  * clk_hw_register_fixed_rate_with_accuracy - register fixed-rate clock with
  47  * the clock framework
  48  * @dev: device that is registering this clock
  49  * @name: name of this clock
  50  * @parent_name: name of clock's parent
  51  * @flags: framework-specific flags
  52  * @fixed_rate: non-adjustable clock rate
  53  * @fixed_accuracy: non-adjustable clock rate
  54  */
  55 struct clk_hw *clk_hw_register_fixed_rate_with_accuracy(struct device *dev,
  56                 const char *name, const char *parent_name, unsigned long flags,
  57                 unsigned long fixed_rate, unsigned long fixed_accuracy)
  58 {
  59         struct clk_fixed_rate *fixed;
  60         struct clk_hw *hw;
  61         struct clk_init_data init;
  62         int ret;
  63 
  64         /* allocate fixed-rate clock */
  65         fixed = kzalloc(sizeof(*fixed), GFP_KERNEL);
  66         if (!fixed)
  67                 return ERR_PTR(-ENOMEM);
  68 
  69         init.name = name;
  70         init.ops = &clk_fixed_rate_ops;
  71         init.flags = flags;
  72         init.parent_names = (parent_name ? &parent_name: NULL);
  73         init.num_parents = (parent_name ? 1 : 0);
  74 
  75         /* struct clk_fixed_rate assignments */
  76         fixed->fixed_rate = fixed_rate;
  77         fixed->fixed_accuracy = fixed_accuracy;
  78         fixed->hw.init = &init;
  79 
  80         /* register the clock */
  81         hw = &fixed->hw;
  82         ret = clk_hw_register(dev, hw);
  83         if (ret) {
  84                 kfree(fixed);
  85                 hw = ERR_PTR(ret);
  86         }
  87 
  88         return hw;
  89 }
  90 EXPORT_SYMBOL_GPL(clk_hw_register_fixed_rate_with_accuracy);
  91 
  92 struct clk *clk_register_fixed_rate_with_accuracy(struct device *dev,
  93                 const char *name, const char *parent_name, unsigned long flags,
  94                 unsigned long fixed_rate, unsigned long fixed_accuracy)
  95 {
  96         struct clk_hw *hw;
  97 
  98         hw = clk_hw_register_fixed_rate_with_accuracy(dev, name, parent_name,
  99                         flags, fixed_rate, fixed_accuracy);
 100         if (IS_ERR(hw))
 101                 return ERR_CAST(hw);
 102         return hw->clk;
 103 }
 104 EXPORT_SYMBOL_GPL(clk_register_fixed_rate_with_accuracy);
 105 
 106 /**
 107  * clk_hw_register_fixed_rate - register fixed-rate clock with the clock
 108  * framework
 109  * @dev: device that is registering this clock
 110  * @name: name of this clock
 111  * @parent_name: name of clock's parent
 112  * @flags: framework-specific flags
 113  * @fixed_rate: non-adjustable clock rate
 114  */
 115 struct clk_hw *clk_hw_register_fixed_rate(struct device *dev, const char *name,
 116                 const char *parent_name, unsigned long flags,
 117                 unsigned long fixed_rate)
 118 {
 119         return clk_hw_register_fixed_rate_with_accuracy(dev, name, parent_name,
 120                                                      flags, fixed_rate, 0);
 121 }
 122 EXPORT_SYMBOL_GPL(clk_hw_register_fixed_rate);
 123 
 124 struct clk *clk_register_fixed_rate(struct device *dev, const char *name,
 125                 const char *parent_name, unsigned long flags,
 126                 unsigned long fixed_rate)
 127 {
 128         return clk_register_fixed_rate_with_accuracy(dev, name, parent_name,
 129                                                      flags, fixed_rate, 0);
 130 }
 131 EXPORT_SYMBOL_GPL(clk_register_fixed_rate);
 132 
 133 void clk_unregister_fixed_rate(struct clk *clk)
 134 {
 135         struct clk_hw *hw;
 136 
 137         hw = __clk_get_hw(clk);
 138         if (!hw)
 139                 return;
 140 
 141         clk_unregister(clk);
 142         kfree(to_clk_fixed_rate(hw));
 143 }
 144 EXPORT_SYMBOL_GPL(clk_unregister_fixed_rate);
 145 
 146 void clk_hw_unregister_fixed_rate(struct clk_hw *hw)
 147 {
 148         struct clk_fixed_rate *fixed;
 149 
 150         fixed = to_clk_fixed_rate(hw);
 151 
 152         clk_hw_unregister(hw);
 153         kfree(fixed);
 154 }
 155 EXPORT_SYMBOL_GPL(clk_hw_unregister_fixed_rate);
 156 
 157 #ifdef CONFIG_OF
 158 static struct clk *_of_fixed_clk_setup(struct device_node *node)
 159 {
 160         struct clk *clk;
 161         const char *clk_name = node->name;
 162         u32 rate;
 163         u32 accuracy = 0;
 164         int ret;
 165 
 166         if (of_property_read_u32(node, "clock-frequency", &rate))
 167                 return ERR_PTR(-EIO);
 168 
 169         of_property_read_u32(node, "clock-accuracy", &accuracy);
 170 
 171         of_property_read_string(node, "clock-output-names", &clk_name);
 172 
 173         clk = clk_register_fixed_rate_with_accuracy(NULL, clk_name, NULL,
 174                                                     0, rate, accuracy);
 175         if (IS_ERR(clk))
 176                 return clk;
 177 
 178         ret = of_clk_add_provider(node, of_clk_src_simple_get, clk);
 179         if (ret) {
 180                 clk_unregister(clk);
 181                 return ERR_PTR(ret);
 182         }
 183 
 184         return clk;
 185 }
 186 
 187 /**
 188  * of_fixed_clk_setup() - Setup function for simple fixed rate clock
 189  */
 190 void __init of_fixed_clk_setup(struct device_node *node)
 191 {
 192         _of_fixed_clk_setup(node);
 193 }
 194 CLK_OF_DECLARE(fixed_clk, "fixed-clock", of_fixed_clk_setup);
 195 
 196 static int of_fixed_clk_remove(struct platform_device *pdev)
 197 {
 198         struct clk *clk = platform_get_drvdata(pdev);
 199 
 200         of_clk_del_provider(pdev->dev.of_node);
 201         clk_unregister_fixed_rate(clk);
 202 
 203         return 0;
 204 }
 205 
 206 static int of_fixed_clk_probe(struct platform_device *pdev)
 207 {
 208         struct clk *clk;
 209 
 210         /*
 211          * This function is not executed when of_fixed_clk_setup
 212          * succeeded.
 213          */
 214         clk = _of_fixed_clk_setup(pdev->dev.of_node);
 215         if (IS_ERR(clk))
 216                 return PTR_ERR(clk);
 217 
 218         platform_set_drvdata(pdev, clk);
 219 
 220         return 0;
 221 }
 222 
 223 static const struct of_device_id of_fixed_clk_ids[] = {
 224         { .compatible = "fixed-clock" },
 225         { }
 226 };
 227 MODULE_DEVICE_TABLE(of, of_fixed_clk_ids);
 228 
 229 static struct platform_driver of_fixed_clk_driver = {
 230         .driver = {
 231                 .name = "of_fixed_clk",
 232                 .of_match_table = of_fixed_clk_ids,
 233         },
 234         .probe = of_fixed_clk_probe,
 235         .remove = of_fixed_clk_remove,
 236 };
 237 builtin_platform_driver(of_fixed_clk_driver);
 238 #endif