Stephen Boyd | e1bd55e | 2018-12-11 09:57:48 -0800 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2011 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de> |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 4 | */ |
| 5 | #include <linux/module.h> |
| 6 | #include <linux/clk-provider.h> |
| 7 | #include <linux/slab.h> |
| 8 | #include <linux/err.h> |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 9 | #include <linux/of.h> |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 10 | #include <linux/platform_device.h> |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 11 | |
| 12 | /* |
| 13 | * DOC: basic fixed multiplier and divider clock that cannot gate |
| 14 | * |
| 15 | * Traits of this clock: |
| 16 | * prepare - clk_prepare only ensures that parents are prepared |
| 17 | * enable - clk_enable only ensures that parents are enabled |
| 18 | * rate - rate is fixed. clk->rate = parent->rate / div * mult |
| 19 | * parent - fixed parent. No clk_set_parent support |
| 20 | */ |
| 21 | |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 22 | static unsigned long clk_factor_recalc_rate(struct clk_hw *hw, |
| 23 | unsigned long parent_rate) |
| 24 | { |
| 25 | struct clk_fixed_factor *fix = to_clk_fixed_factor(hw); |
Haojian Zhuang | bab5330 | 2012-12-03 16:14:37 +0800 | [diff] [blame] | 26 | unsigned long long int rate; |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 27 | |
Haojian Zhuang | bab5330 | 2012-12-03 16:14:37 +0800 | [diff] [blame] | 28 | rate = (unsigned long long int)parent_rate * fix->mult; |
| 29 | do_div(rate, fix->div); |
| 30 | return (unsigned long)rate; |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 31 | } |
| 32 | |
| 33 | static long clk_factor_round_rate(struct clk_hw *hw, unsigned long rate, |
| 34 | unsigned long *prate) |
| 35 | { |
| 36 | struct clk_fixed_factor *fix = to_clk_fixed_factor(hw); |
| 37 | |
Stephen Boyd | 98d8a60 | 2015-06-29 16:56:30 -0700 | [diff] [blame] | 38 | if (clk_hw_get_flags(hw) & CLK_SET_RATE_PARENT) { |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 39 | unsigned long best_parent; |
| 40 | |
| 41 | best_parent = (rate / fix->mult) * fix->div; |
Stephen Boyd | 2f508a9 | 2015-07-30 17:20:57 -0700 | [diff] [blame] | 42 | *prate = clk_hw_round_rate(clk_hw_get_parent(hw), best_parent); |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 43 | } |
| 44 | |
| 45 | return (*prate / fix->div) * fix->mult; |
| 46 | } |
| 47 | |
| 48 | static int clk_factor_set_rate(struct clk_hw *hw, unsigned long rate, |
| 49 | unsigned long parent_rate) |
| 50 | { |
Daniel Thompson | 3037e9e | 2015-06-10 21:04:54 +0100 | [diff] [blame] | 51 | /* |
| 52 | * We must report success but we can do so unconditionally because |
| 53 | * clk_factor_round_rate returns values that ensure this call is a |
| 54 | * nop. |
| 55 | */ |
| 56 | |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 57 | return 0; |
| 58 | } |
| 59 | |
Daniel Thompson | 3037e9e | 2015-06-10 21:04:54 +0100 | [diff] [blame] | 60 | const struct clk_ops clk_fixed_factor_ops = { |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 61 | .round_rate = clk_factor_round_rate, |
| 62 | .set_rate = clk_factor_set_rate, |
| 63 | .recalc_rate = clk_factor_recalc_rate, |
| 64 | }; |
| 65 | EXPORT_SYMBOL_GPL(clk_fixed_factor_ops); |
| 66 | |
Daniel Palmer | 0b9266d | 2021-02-11 14:22:02 +0900 | [diff] [blame] | 67 | static void devm_clk_hw_register_fixed_factor_release(struct device *dev, void *res) |
| 68 | { |
Dmitry Baryshkov | 50ce6826 | 2021-04-07 02:06:06 +0300 | [diff] [blame] | 69 | struct clk_fixed_factor *fix = res; |
| 70 | |
| 71 | /* |
| 72 | * We can not use clk_hw_unregister_fixed_factor, since it will kfree() |
| 73 | * the hw, resulting in double free. Just unregister the hw and let |
| 74 | * devres code kfree() it. |
| 75 | */ |
| 76 | clk_hw_unregister(&fix->hw); |
Daniel Palmer | 0b9266d | 2021-02-11 14:22:02 +0900 | [diff] [blame] | 77 | } |
| 78 | |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 79 | static struct clk_hw * |
| 80 | __clk_hw_register_fixed_factor(struct device *dev, struct device_node *np, |
Marijn Suijten | 6ebd524 | 2022-06-30 00:53:23 +0200 | [diff] [blame] | 81 | const char *name, const char *parent_name, |
| 82 | const struct clk_hw *parent_hw, int index, |
Daniel Palmer | 0b9266d | 2021-02-11 14:22:02 +0900 | [diff] [blame] | 83 | unsigned long flags, unsigned int mult, unsigned int div, |
| 84 | bool devm) |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 85 | { |
| 86 | struct clk_fixed_factor *fix; |
Stephen Boyd | e4818d6 | 2019-04-23 10:46:51 -0700 | [diff] [blame] | 87 | struct clk_init_data init = { }; |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 88 | struct clk_parent_data pdata = { .index = index }; |
Stephen Boyd | 0759ac8 | 2016-02-07 00:11:06 -0800 | [diff] [blame] | 89 | struct clk_hw *hw; |
| 90 | int ret; |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 91 | |
Daniel Palmer | 0b9266d | 2021-02-11 14:22:02 +0900 | [diff] [blame] | 92 | /* You can't use devm without a dev */ |
| 93 | if (devm && !dev) |
| 94 | return ERR_PTR(-EINVAL); |
| 95 | |
| 96 | if (devm) |
| 97 | fix = devres_alloc(devm_clk_hw_register_fixed_factor_release, |
| 98 | sizeof(*fix), GFP_KERNEL); |
| 99 | else |
| 100 | fix = kmalloc(sizeof(*fix), GFP_KERNEL); |
Stephen Boyd | d122db7 | 2015-05-14 16:47:10 -0700 | [diff] [blame] | 101 | if (!fix) |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 102 | return ERR_PTR(-ENOMEM); |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 103 | |
| 104 | /* struct clk_fixed_factor assignments */ |
| 105 | fix->mult = mult; |
| 106 | fix->div = div; |
| 107 | fix->hw.init = &init; |
| 108 | |
| 109 | init.name = name; |
| 110 | init.ops = &clk_fixed_factor_ops; |
Stephen Boyd | 90b6c5c | 2019-04-25 10:57:37 -0700 | [diff] [blame] | 111 | init.flags = flags; |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 112 | if (parent_name) |
| 113 | init.parent_names = &parent_name; |
Marijn Suijten | 6ebd524 | 2022-06-30 00:53:23 +0200 | [diff] [blame] | 114 | else if (parent_hw) |
| 115 | init.parent_hws = &parent_hw; |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 116 | else |
| 117 | init.parent_data = &pdata; |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 118 | init.num_parents = 1; |
| 119 | |
Stephen Boyd | 0759ac8 | 2016-02-07 00:11:06 -0800 | [diff] [blame] | 120 | hw = &fix->hw; |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 121 | if (dev) |
| 122 | ret = clk_hw_register(dev, hw); |
| 123 | else |
| 124 | ret = of_clk_hw_register(np, hw); |
Stephen Boyd | 0759ac8 | 2016-02-07 00:11:06 -0800 | [diff] [blame] | 125 | if (ret) { |
Daniel Palmer | 0b9266d | 2021-02-11 14:22:02 +0900 | [diff] [blame] | 126 | if (devm) |
| 127 | devres_free(fix); |
| 128 | else |
| 129 | kfree(fix); |
Stephen Boyd | 0759ac8 | 2016-02-07 00:11:06 -0800 | [diff] [blame] | 130 | hw = ERR_PTR(ret); |
Daniel Palmer | 0b9266d | 2021-02-11 14:22:02 +0900 | [diff] [blame] | 131 | } else if (devm) |
| 132 | devres_add(dev, fix); |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 133 | |
Stephen Boyd | 0759ac8 | 2016-02-07 00:11:06 -0800 | [diff] [blame] | 134 | return hw; |
| 135 | } |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 136 | |
Marek Vasut | 0c125f8 | 2022-02-26 05:07:22 +0100 | [diff] [blame] | 137 | /** |
| 138 | * devm_clk_hw_register_fixed_factor_index - Register a fixed factor clock with |
| 139 | * parent from DT index |
| 140 | * @dev: device that is registering this clock |
| 141 | * @name: name of this clock |
| 142 | * @index: index of phandle in @dev 'clocks' property |
| 143 | * @flags: fixed factor flags |
| 144 | * @mult: multiplier |
| 145 | * @div: divider |
| 146 | * |
| 147 | * Return: Pointer to fixed factor clk_hw structure that was registered or |
| 148 | * an error pointer. |
| 149 | */ |
| 150 | struct clk_hw *devm_clk_hw_register_fixed_factor_index(struct device *dev, |
| 151 | const char *name, unsigned int index, unsigned long flags, |
| 152 | unsigned int mult, unsigned int div) |
| 153 | { |
Marijn Suijten | 6ebd524 | 2022-06-30 00:53:23 +0200 | [diff] [blame] | 154 | return __clk_hw_register_fixed_factor(dev, NULL, name, NULL, NULL, index, |
Marek Vasut | 0c125f8 | 2022-02-26 05:07:22 +0100 | [diff] [blame] | 155 | flags, mult, div, true); |
| 156 | } |
| 157 | EXPORT_SYMBOL_GPL(devm_clk_hw_register_fixed_factor_index); |
| 158 | |
Marijn Suijten | 6ebd524 | 2022-06-30 00:53:23 +0200 | [diff] [blame] | 159 | /** |
| 160 | * devm_clk_hw_register_fixed_factor_parent_hw - Register a fixed factor clock with |
| 161 | * pointer to parent clock |
| 162 | * @dev: device that is registering this clock |
| 163 | * @name: name of this clock |
| 164 | * @parent_hw: pointer to parent clk |
| 165 | * @flags: fixed factor flags |
| 166 | * @mult: multiplier |
| 167 | * @div: divider |
| 168 | * |
| 169 | * Return: Pointer to fixed factor clk_hw structure that was registered or |
| 170 | * an error pointer. |
| 171 | */ |
| 172 | struct clk_hw *devm_clk_hw_register_fixed_factor_parent_hw(struct device *dev, |
| 173 | const char *name, const struct clk_hw *parent_hw, |
| 174 | unsigned long flags, unsigned int mult, unsigned int div) |
| 175 | { |
| 176 | return __clk_hw_register_fixed_factor(dev, NULL, name, NULL, parent_hw, |
| 177 | -1, flags, mult, div, true); |
| 178 | } |
| 179 | EXPORT_SYMBOL_GPL(devm_clk_hw_register_fixed_factor_parent_hw); |
| 180 | |
| 181 | struct clk_hw *clk_hw_register_fixed_factor_parent_hw(struct device *dev, |
| 182 | const char *name, const struct clk_hw *parent_hw, |
| 183 | unsigned long flags, unsigned int mult, unsigned int div) |
| 184 | { |
| 185 | return __clk_hw_register_fixed_factor(dev, NULL, name, NULL, |
| 186 | parent_hw, -1, flags, mult, div, |
| 187 | false); |
| 188 | } |
| 189 | EXPORT_SYMBOL_GPL(clk_hw_register_fixed_factor_parent_hw); |
| 190 | |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 191 | struct clk_hw *clk_hw_register_fixed_factor(struct device *dev, |
| 192 | const char *name, const char *parent_name, unsigned long flags, |
| 193 | unsigned int mult, unsigned int div) |
| 194 | { |
Marijn Suijten | 6ebd524 | 2022-06-30 00:53:23 +0200 | [diff] [blame] | 195 | return __clk_hw_register_fixed_factor(dev, NULL, name, parent_name, NULL, -1, |
Daniel Palmer | 0b9266d | 2021-02-11 14:22:02 +0900 | [diff] [blame] | 196 | flags, mult, div, false); |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 197 | } |
Stephen Boyd | 0759ac8 | 2016-02-07 00:11:06 -0800 | [diff] [blame] | 198 | EXPORT_SYMBOL_GPL(clk_hw_register_fixed_factor); |
| 199 | |
| 200 | struct clk *clk_register_fixed_factor(struct device *dev, const char *name, |
| 201 | const char *parent_name, unsigned long flags, |
| 202 | unsigned int mult, unsigned int div) |
| 203 | { |
| 204 | struct clk_hw *hw; |
| 205 | |
| 206 | hw = clk_hw_register_fixed_factor(dev, name, parent_name, flags, mult, |
| 207 | div); |
| 208 | if (IS_ERR(hw)) |
| 209 | return ERR_CAST(hw); |
| 210 | return hw->clk; |
Sascha Hauer | f0948f5 | 2012-05-03 15:36:14 +0530 | [diff] [blame] | 211 | } |
Mike Turquette | 5cfe10b | 2013-08-15 19:06:29 -0700 | [diff] [blame] | 212 | EXPORT_SYMBOL_GPL(clk_register_fixed_factor); |
| 213 | |
Masahiro Yamada | cbf9591 | 2016-01-06 13:25:09 +0900 | [diff] [blame] | 214 | void clk_unregister_fixed_factor(struct clk *clk) |
| 215 | { |
| 216 | struct clk_hw *hw; |
| 217 | |
| 218 | hw = __clk_get_hw(clk); |
| 219 | if (!hw) |
| 220 | return; |
| 221 | |
| 222 | clk_unregister(clk); |
| 223 | kfree(to_clk_fixed_factor(hw)); |
| 224 | } |
| 225 | EXPORT_SYMBOL_GPL(clk_unregister_fixed_factor); |
| 226 | |
Stephen Boyd | 0759ac8 | 2016-02-07 00:11:06 -0800 | [diff] [blame] | 227 | void clk_hw_unregister_fixed_factor(struct clk_hw *hw) |
| 228 | { |
| 229 | struct clk_fixed_factor *fix; |
| 230 | |
| 231 | fix = to_clk_fixed_factor(hw); |
| 232 | |
| 233 | clk_hw_unregister(hw); |
| 234 | kfree(fix); |
| 235 | } |
| 236 | EXPORT_SYMBOL_GPL(clk_hw_unregister_fixed_factor); |
| 237 | |
Daniel Palmer | 0b9266d | 2021-02-11 14:22:02 +0900 | [diff] [blame] | 238 | struct clk_hw *devm_clk_hw_register_fixed_factor(struct device *dev, |
| 239 | const char *name, const char *parent_name, unsigned long flags, |
| 240 | unsigned int mult, unsigned int div) |
| 241 | { |
Marijn Suijten | 6ebd524 | 2022-06-30 00:53:23 +0200 | [diff] [blame] | 242 | return __clk_hw_register_fixed_factor(dev, NULL, name, parent_name, NULL, -1, |
Daniel Palmer | 0b9266d | 2021-02-11 14:22:02 +0900 | [diff] [blame] | 243 | flags, mult, div, true); |
| 244 | } |
| 245 | EXPORT_SYMBOL_GPL(devm_clk_hw_register_fixed_factor); |
| 246 | |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 247 | #ifdef CONFIG_OF |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 248 | static struct clk_hw *_of_fixed_factor_clk_setup(struct device_node *node) |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 249 | { |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 250 | struct clk_hw *hw; |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 251 | const char *clk_name = node->name; |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 252 | u32 div, mult; |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 253 | int ret; |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 254 | |
| 255 | if (of_property_read_u32(node, "clock-div", &div)) { |
Rob Herring | e665f02 | 2018-08-28 10:44:29 -0500 | [diff] [blame] | 256 | pr_err("%s Fixed factor clock <%pOFn> must have a clock-div property\n", |
| 257 | __func__, node); |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 258 | return ERR_PTR(-EIO); |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | if (of_property_read_u32(node, "clock-mult", &mult)) { |
Rob Herring | e665f02 | 2018-08-28 10:44:29 -0500 | [diff] [blame] | 262 | pr_err("%s Fixed factor clock <%pOFn> must have a clock-mult property\n", |
| 263 | __func__, node); |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 264 | return ERR_PTR(-EIO); |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 265 | } |
| 266 | |
| 267 | of_property_read_string(node, "clock-output-names", &clk_name); |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 268 | |
Marijn Suijten | 6ebd524 | 2022-06-30 00:53:23 +0200 | [diff] [blame] | 269 | hw = __clk_hw_register_fixed_factor(NULL, node, clk_name, NULL, NULL, 0, |
Samuel Holland | c33ed61 | 2022-05-31 00:17:41 -0500 | [diff] [blame] | 270 | 0, mult, div, false); |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 271 | if (IS_ERR(hw)) { |
Rajan Vaja | f6dab42 | 2018-07-17 06:17:00 -0700 | [diff] [blame] | 272 | /* |
Rajan Vaja | f6dab42 | 2018-07-17 06:17:00 -0700 | [diff] [blame] | 273 | * Clear OF_POPULATED flag so that clock registration can be |
| 274 | * attempted again from probe function. |
| 275 | */ |
| 276 | of_node_clear_flag(node, OF_POPULATED); |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 277 | return ERR_CAST(hw); |
Rajan Vaja | f6dab42 | 2018-07-17 06:17:00 -0700 | [diff] [blame] | 278 | } |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 279 | |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 280 | ret = of_clk_add_hw_provider(node, of_clk_hw_simple_get, hw); |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 281 | if (ret) { |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 282 | clk_hw_unregister_fixed_factor(hw); |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 283 | return ERR_PTR(ret); |
| 284 | } |
| 285 | |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 286 | return hw; |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | /** |
| 290 | * of_fixed_factor_clk_setup() - Setup function for simple fixed factor clock |
Krzysztof Kozlowski | 52ba4fa | 2020-09-16 18:17:36 +0200 | [diff] [blame] | 291 | * @node: device node for the clock |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 292 | */ |
| 293 | void __init of_fixed_factor_clk_setup(struct device_node *node) |
| 294 | { |
| 295 | _of_fixed_factor_clk_setup(node); |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 296 | } |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 297 | CLK_OF_DECLARE(fixed_factor_clk, "fixed-factor-clock", |
| 298 | of_fixed_factor_clk_setup); |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 299 | |
Uwe Kleine-König | 27237f4 | 2023-03-12 17:14:50 +0100 | [diff] [blame] | 300 | static void of_fixed_factor_clk_remove(struct platform_device *pdev) |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 301 | { |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 302 | struct clk_hw *clk = platform_get_drvdata(pdev); |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 303 | |
Ricardo Ribalda Delgado | f98e8a5 | 2018-11-01 14:15:49 +0100 | [diff] [blame] | 304 | of_clk_del_provider(pdev->dev.of_node); |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 305 | clk_hw_unregister_fixed_factor(clk); |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 306 | } |
| 307 | |
| 308 | static int of_fixed_factor_clk_probe(struct platform_device *pdev) |
| 309 | { |
Stephen Boyd | ecbf3f1 | 2019-04-12 11:31:50 -0700 | [diff] [blame] | 310 | struct clk_hw *clk; |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 311 | |
| 312 | /* |
| 313 | * This function is not executed when of_fixed_factor_clk_setup |
| 314 | * succeeded. |
| 315 | */ |
| 316 | clk = _of_fixed_factor_clk_setup(pdev->dev.of_node); |
| 317 | if (IS_ERR(clk)) |
| 318 | return PTR_ERR(clk); |
| 319 | |
| 320 | platform_set_drvdata(pdev, clk); |
| 321 | |
| 322 | return 0; |
| 323 | } |
| 324 | |
| 325 | static const struct of_device_id of_fixed_factor_clk_ids[] = { |
| 326 | { .compatible = "fixed-factor-clock" }, |
| 327 | { } |
| 328 | }; |
| 329 | MODULE_DEVICE_TABLE(of, of_fixed_factor_clk_ids); |
| 330 | |
| 331 | static struct platform_driver of_fixed_factor_clk_driver = { |
| 332 | .driver = { |
| 333 | .name = "of_fixed_factor_clk", |
| 334 | .of_match_table = of_fixed_factor_clk_ids, |
| 335 | }, |
| 336 | .probe = of_fixed_factor_clk_probe, |
Uwe Kleine-König | 27237f4 | 2023-03-12 17:14:50 +0100 | [diff] [blame] | 337 | .remove_new = of_fixed_factor_clk_remove, |
Ricardo Ribalda Delgado | 971451b | 2016-07-05 18:23:33 +0200 | [diff] [blame] | 338 | }; |
| 339 | builtin_platform_driver(of_fixed_factor_clk_driver); |
Gregory CLEMENT | 79b1664 | 2013-04-12 13:57:44 +0200 | [diff] [blame] | 340 | #endif |