Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Russell King | f8ce254 | 2006-01-07 16:15:52 +0000 | [diff] [blame] | 2 | * linux/include/linux/clk.h |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * |
| 4 | * Copyright (C) 2004 ARM Limited. |
| 5 | * Written by Deep Blue Solutions Limited. |
Mike Turquette | b2476490 | 2012-03-15 23:11:19 -0700 | [diff] [blame] | 6 | * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License version 2 as |
| 10 | * published by the Free Software Foundation. |
| 11 | */ |
Todd Poynor | 686f8c5 | 2006-03-25 18:15:24 +0000 | [diff] [blame] | 12 | #ifndef __LINUX_CLK_H |
| 13 | #define __LINUX_CLK_H |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | |
Shawn Guo | 9f1612d | 2012-07-18 11:52:22 +0800 | [diff] [blame] | 15 | #include <linux/err.h> |
Russell King | 40d3e0f | 2011-09-22 11:30:50 +0100 | [diff] [blame] | 16 | #include <linux/kernel.h> |
Mike Turquette | b2476490 | 2012-03-15 23:11:19 -0700 | [diff] [blame] | 17 | #include <linux/notifier.h> |
Russell King | 40d3e0f | 2011-09-22 11:30:50 +0100 | [diff] [blame] | 18 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | struct device; |
| 20 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | struct clk; |
| 22 | |
Mike Turquette | b2476490 | 2012-03-15 23:11:19 -0700 | [diff] [blame] | 23 | /** |
| 24 | * DOC: clk notifier callback types |
| 25 | * |
| 26 | * PRE_RATE_CHANGE - called immediately before the clk rate is changed, |
| 27 | * to indicate that the rate change will proceed. Drivers must |
| 28 | * immediately terminate any operations that will be affected by the |
Soren Brinkmann | fb72a05 | 2013-04-03 12:17:12 -0700 | [diff] [blame] | 29 | * rate change. Callbacks may either return NOTIFY_DONE, NOTIFY_OK, |
| 30 | * NOTIFY_STOP or NOTIFY_BAD. |
Mike Turquette | b2476490 | 2012-03-15 23:11:19 -0700 | [diff] [blame] | 31 | * |
| 32 | * ABORT_RATE_CHANGE: called if the rate change failed for some reason |
| 33 | * after PRE_RATE_CHANGE. In this case, all registered notifiers on |
| 34 | * the clk will be called with ABORT_RATE_CHANGE. Callbacks must |
Soren Brinkmann | fb72a05 | 2013-04-03 12:17:12 -0700 | [diff] [blame] | 35 | * always return NOTIFY_DONE or NOTIFY_OK. |
Mike Turquette | b2476490 | 2012-03-15 23:11:19 -0700 | [diff] [blame] | 36 | * |
| 37 | * POST_RATE_CHANGE - called after the clk rate change has successfully |
Soren Brinkmann | fb72a05 | 2013-04-03 12:17:12 -0700 | [diff] [blame] | 38 | * completed. Callbacks must always return NOTIFY_DONE or NOTIFY_OK. |
Mike Turquette | b2476490 | 2012-03-15 23:11:19 -0700 | [diff] [blame] | 39 | * |
| 40 | */ |
| 41 | #define PRE_RATE_CHANGE BIT(0) |
| 42 | #define POST_RATE_CHANGE BIT(1) |
| 43 | #define ABORT_RATE_CHANGE BIT(2) |
| 44 | |
| 45 | /** |
| 46 | * struct clk_notifier - associate a clk with a notifier |
| 47 | * @clk: struct clk * to associate the notifier with |
| 48 | * @notifier_head: a blocking_notifier_head for this clk |
| 49 | * @node: linked list pointers |
| 50 | * |
| 51 | * A list of struct clk_notifier is maintained by the notifier code. |
| 52 | * An entry is created whenever code registers the first notifier on a |
| 53 | * particular @clk. Future notifiers on that @clk are added to the |
| 54 | * @notifier_head. |
| 55 | */ |
| 56 | struct clk_notifier { |
| 57 | struct clk *clk; |
| 58 | struct srcu_notifier_head notifier_head; |
| 59 | struct list_head node; |
| 60 | }; |
| 61 | |
| 62 | /** |
| 63 | * struct clk_notifier_data - rate data to pass to the notifier callback |
| 64 | * @clk: struct clk * being changed |
| 65 | * @old_rate: previous rate of this clk |
| 66 | * @new_rate: new rate of this clk |
| 67 | * |
| 68 | * For a pre-notifier, old_rate is the clk's rate before this rate |
| 69 | * change, and new_rate is what the rate will be in the future. For a |
| 70 | * post-notifier, old_rate and new_rate are both set to the clk's |
| 71 | * current rate (this was done to optimize the implementation). |
| 72 | */ |
| 73 | struct clk_notifier_data { |
| 74 | struct clk *clk; |
| 75 | unsigned long old_rate; |
| 76 | unsigned long new_rate; |
| 77 | }; |
| 78 | |
Krzysztof Kozlowski | e81b87d | 2016-06-28 13:25:04 +0200 | [diff] [blame] | 79 | #ifdef CONFIG_COMMON_CLK |
| 80 | |
Mike Turquette | 86bcfa2 | 2014-02-24 16:08:41 -0800 | [diff] [blame] | 81 | /** |
| 82 | * clk_notifier_register: register a clock rate-change notifier callback |
| 83 | * @clk: clock whose rate we are interested in |
| 84 | * @nb: notifier block with callback function pointer |
| 85 | * |
| 86 | * ProTip: debugging across notifier chains can be frustrating. Make sure that |
| 87 | * your notifier callback function prints a nice big warning in case of |
| 88 | * failure. |
| 89 | */ |
Mike Turquette | b2476490 | 2012-03-15 23:11:19 -0700 | [diff] [blame] | 90 | int clk_notifier_register(struct clk *clk, struct notifier_block *nb); |
| 91 | |
Mike Turquette | 86bcfa2 | 2014-02-24 16:08:41 -0800 | [diff] [blame] | 92 | /** |
| 93 | * clk_notifier_unregister: unregister a clock rate-change notifier callback |
| 94 | * @clk: clock whose rate we are no longer interested in |
| 95 | * @nb: notifier block which will be unregistered |
| 96 | */ |
Mike Turquette | b2476490 | 2012-03-15 23:11:19 -0700 | [diff] [blame] | 97 | int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb); |
| 98 | |
Boris BREZILLON | 5279fc4 | 2013-12-21 10:34:47 +0100 | [diff] [blame] | 99 | /** |
| 100 | * clk_get_accuracy - obtain the clock accuracy in ppb (parts per billion) |
| 101 | * for a clock source. |
| 102 | * @clk: clock source |
| 103 | * |
| 104 | * This gets the clock source accuracy expressed in ppb. |
| 105 | * A perfect clock returns 0. |
| 106 | */ |
| 107 | long clk_get_accuracy(struct clk *clk); |
| 108 | |
Mike Turquette | e59c537 | 2014-02-18 21:21:25 -0800 | [diff] [blame] | 109 | /** |
| 110 | * clk_set_phase - adjust the phase shift of a clock signal |
| 111 | * @clk: clock signal source |
| 112 | * @degrees: number of degrees the signal is shifted |
| 113 | * |
| 114 | * Shifts the phase of a clock signal by the specified degrees. Returns 0 on |
| 115 | * success, -EERROR otherwise. |
| 116 | */ |
| 117 | int clk_set_phase(struct clk *clk, int degrees); |
| 118 | |
| 119 | /** |
| 120 | * clk_get_phase - return the phase shift of a clock signal |
| 121 | * @clk: clock signal source |
| 122 | * |
| 123 | * Returns the phase shift of a clock node in degrees, otherwise returns |
| 124 | * -EERROR. |
| 125 | */ |
| 126 | int clk_get_phase(struct clk *clk); |
| 127 | |
Michael Turquette | 3d3801e | 2015-02-25 09:11:01 -0800 | [diff] [blame] | 128 | /** |
| 129 | * clk_is_match - check if two clk's point to the same hardware clock |
| 130 | * @p: clk compared against q |
| 131 | * @q: clk compared against p |
| 132 | * |
| 133 | * Returns true if the two struct clk pointers both point to the same hardware |
| 134 | * clock node. Put differently, returns true if struct clk *p and struct clk *q |
| 135 | * share the same struct clk_core object. |
| 136 | * |
| 137 | * Returns false otherwise. Note that two NULL clks are treated as matching. |
| 138 | */ |
| 139 | bool clk_is_match(const struct clk *p, const struct clk *q); |
| 140 | |
Boris BREZILLON | 5279fc4 | 2013-12-21 10:34:47 +0100 | [diff] [blame] | 141 | #else |
| 142 | |
Krzysztof Kozlowski | e81b87d | 2016-06-28 13:25:04 +0200 | [diff] [blame] | 143 | static inline int clk_notifier_register(struct clk *clk, |
| 144 | struct notifier_block *nb) |
| 145 | { |
| 146 | return -ENOTSUPP; |
| 147 | } |
| 148 | |
| 149 | static inline int clk_notifier_unregister(struct clk *clk, |
| 150 | struct notifier_block *nb) |
| 151 | { |
| 152 | return -ENOTSUPP; |
| 153 | } |
| 154 | |
Boris BREZILLON | 5279fc4 | 2013-12-21 10:34:47 +0100 | [diff] [blame] | 155 | static inline long clk_get_accuracy(struct clk *clk) |
| 156 | { |
| 157 | return -ENOTSUPP; |
| 158 | } |
| 159 | |
Mike Turquette | e59c537 | 2014-02-18 21:21:25 -0800 | [diff] [blame] | 160 | static inline long clk_set_phase(struct clk *clk, int phase) |
| 161 | { |
| 162 | return -ENOTSUPP; |
| 163 | } |
| 164 | |
| 165 | static inline long clk_get_phase(struct clk *clk) |
| 166 | { |
| 167 | return -ENOTSUPP; |
| 168 | } |
| 169 | |
Michael Turquette | 3d3801e | 2015-02-25 09:11:01 -0800 | [diff] [blame] | 170 | static inline bool clk_is_match(const struct clk *p, const struct clk *q) |
| 171 | { |
| 172 | return p == q; |
| 173 | } |
| 174 | |
Mark Brown | 7e87aed | 2012-04-01 15:31:23 +0100 | [diff] [blame] | 175 | #endif |
Mike Turquette | b2476490 | 2012-03-15 23:11:19 -0700 | [diff] [blame] | 176 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | /** |
Viresh Kumar | 93abe8e | 2012-07-30 14:39:27 -0700 | [diff] [blame] | 178 | * clk_prepare - prepare a clock source |
| 179 | * @clk: clock source |
| 180 | * |
| 181 | * This prepares the clock source for use. |
| 182 | * |
| 183 | * Must not be called from within atomic context. |
| 184 | */ |
| 185 | #ifdef CONFIG_HAVE_CLK_PREPARE |
| 186 | int clk_prepare(struct clk *clk); |
| 187 | #else |
| 188 | static inline int clk_prepare(struct clk *clk) |
| 189 | { |
| 190 | might_sleep(); |
| 191 | return 0; |
| 192 | } |
| 193 | #endif |
| 194 | |
| 195 | /** |
| 196 | * clk_unprepare - undo preparation of a clock source |
| 197 | * @clk: clock source |
| 198 | * |
| 199 | * This undoes a previously prepared clock. The caller must balance |
| 200 | * the number of prepare and unprepare calls. |
| 201 | * |
| 202 | * Must not be called from within atomic context. |
| 203 | */ |
| 204 | #ifdef CONFIG_HAVE_CLK_PREPARE |
| 205 | void clk_unprepare(struct clk *clk); |
| 206 | #else |
| 207 | static inline void clk_unprepare(struct clk *clk) |
| 208 | { |
| 209 | might_sleep(); |
| 210 | } |
| 211 | #endif |
| 212 | |
| 213 | #ifdef CONFIG_HAVE_CLK |
| 214 | /** |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | * clk_get - lookup and obtain a reference to a clock producer. |
| 216 | * @dev: device for clock "consumer" |
Jan-Simon Möller | a58b3a4 | 2012-07-23 20:48:56 +0200 | [diff] [blame] | 217 | * @id: clock consumer ID |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | * |
| 219 | * Returns a struct clk corresponding to the clock producer, or |
Russell King | ea3f4ea | 2005-04-27 18:19:55 +0100 | [diff] [blame] | 220 | * valid IS_ERR() condition containing errno. The implementation |
| 221 | * uses @dev and @id to determine the clock consumer, and thereby |
| 222 | * the clock producer. (IOW, @id may be identical strings, but |
| 223 | * clk_get may return different clock producers depending on @dev.) |
Russell King | f47fc0a | 2006-01-03 18:34:20 +0000 | [diff] [blame] | 224 | * |
| 225 | * Drivers must assume that the clock source is not enabled. |
Alex Raimondi | f7ad160 | 2008-10-15 22:02:03 -0700 | [diff] [blame] | 226 | * |
| 227 | * clk_get should not be called from within interrupt context. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | */ |
| 229 | struct clk *clk_get(struct device *dev, const char *id); |
| 230 | |
| 231 | /** |
Mark Brown | a8a97db | 2012-04-05 11:42:09 +0100 | [diff] [blame] | 232 | * devm_clk_get - lookup and obtain a managed reference to a clock producer. |
| 233 | * @dev: device for clock "consumer" |
Jan-Simon Möller | a58b3a4 | 2012-07-23 20:48:56 +0200 | [diff] [blame] | 234 | * @id: clock consumer ID |
Mark Brown | a8a97db | 2012-04-05 11:42:09 +0100 | [diff] [blame] | 235 | * |
| 236 | * Returns a struct clk corresponding to the clock producer, or |
| 237 | * valid IS_ERR() condition containing errno. The implementation |
| 238 | * uses @dev and @id to determine the clock consumer, and thereby |
| 239 | * the clock producer. (IOW, @id may be identical strings, but |
| 240 | * clk_get may return different clock producers depending on @dev.) |
| 241 | * |
| 242 | * Drivers must assume that the clock source is not enabled. |
| 243 | * |
| 244 | * devm_clk_get should not be called from within interrupt context. |
| 245 | * |
| 246 | * The clock will automatically be freed when the device is unbound |
| 247 | * from the bus. |
| 248 | */ |
| 249 | struct clk *devm_clk_get(struct device *dev, const char *id); |
| 250 | |
| 251 | /** |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | * clk_enable - inform the system when the clock source should be running. |
| 253 | * @clk: clock source |
| 254 | * |
| 255 | * If the clock can not be enabled/disabled, this should return success. |
| 256 | * |
Russell King | 40d3e0f | 2011-09-22 11:30:50 +0100 | [diff] [blame] | 257 | * May be called from atomic contexts. |
| 258 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | * Returns success (0) or negative errno. |
| 260 | */ |
| 261 | int clk_enable(struct clk *clk); |
| 262 | |
| 263 | /** |
| 264 | * clk_disable - inform the system when the clock source is no longer required. |
| 265 | * @clk: clock source |
Russell King | f47fc0a | 2006-01-03 18:34:20 +0000 | [diff] [blame] | 266 | * |
| 267 | * Inform the system that a clock source is no longer required by |
| 268 | * a driver and may be shut down. |
| 269 | * |
Russell King | 40d3e0f | 2011-09-22 11:30:50 +0100 | [diff] [blame] | 270 | * May be called from atomic contexts. |
| 271 | * |
Russell King | f47fc0a | 2006-01-03 18:34:20 +0000 | [diff] [blame] | 272 | * Implementation detail: if the clock source is shared between |
| 273 | * multiple drivers, clk_enable() calls must be balanced by the |
| 274 | * same number of clk_disable() calls for the clock source to be |
| 275 | * disabled. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | */ |
| 277 | void clk_disable(struct clk *clk); |
| 278 | |
| 279 | /** |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | * clk_get_rate - obtain the current clock rate (in Hz) for a clock source. |
| 281 | * This is only valid once the clock source has been enabled. |
| 282 | * @clk: clock source |
| 283 | */ |
| 284 | unsigned long clk_get_rate(struct clk *clk); |
| 285 | |
| 286 | /** |
| 287 | * clk_put - "free" the clock source |
| 288 | * @clk: clock source |
Russell King | f47fc0a | 2006-01-03 18:34:20 +0000 | [diff] [blame] | 289 | * |
| 290 | * Note: drivers must ensure that all clk_enable calls made on this |
| 291 | * clock source are balanced by clk_disable calls prior to calling |
| 292 | * this function. |
Alex Raimondi | f7ad160 | 2008-10-15 22:02:03 -0700 | [diff] [blame] | 293 | * |
| 294 | * clk_put should not be called from within interrupt context. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 295 | */ |
| 296 | void clk_put(struct clk *clk); |
| 297 | |
Mark Brown | a8a97db | 2012-04-05 11:42:09 +0100 | [diff] [blame] | 298 | /** |
| 299 | * devm_clk_put - "free" a managed clock source |
Masanari Iida | da3dae5 | 2014-09-09 01:27:23 +0900 | [diff] [blame] | 300 | * @dev: device used to acquire the clock |
Mark Brown | a8a97db | 2012-04-05 11:42:09 +0100 | [diff] [blame] | 301 | * @clk: clock source acquired with devm_clk_get() |
| 302 | * |
| 303 | * Note: drivers must ensure that all clk_enable calls made on this |
| 304 | * clock source are balanced by clk_disable calls prior to calling |
| 305 | * this function. |
| 306 | * |
| 307 | * clk_put should not be called from within interrupt context. |
| 308 | */ |
| 309 | void devm_clk_put(struct device *dev, struct clk *clk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 310 | |
| 311 | /* |
| 312 | * The remaining APIs are optional for machine class support. |
| 313 | */ |
| 314 | |
| 315 | |
| 316 | /** |
| 317 | * clk_round_rate - adjust a rate to the exact rate a clock can provide |
| 318 | * @clk: clock source |
| 319 | * @rate: desired clock rate in Hz |
| 320 | * |
Russell King | d2d14a7 | 2015-03-14 15:12:35 +0000 | [diff] [blame] | 321 | * This answers the question "if I were to pass @rate to clk_set_rate(), |
| 322 | * what clock rate would I end up with?" without changing the hardware |
| 323 | * in any way. In other words: |
| 324 | * |
| 325 | * rate = clk_round_rate(clk, r); |
| 326 | * |
| 327 | * and: |
| 328 | * |
| 329 | * clk_set_rate(clk, r); |
| 330 | * rate = clk_get_rate(clk); |
| 331 | * |
| 332 | * are equivalent except the former does not modify the clock hardware |
| 333 | * in any way. |
| 334 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | * Returns rounded clock rate in Hz, or negative errno. |
| 336 | */ |
| 337 | long clk_round_rate(struct clk *clk, unsigned long rate); |
Rob Herring | 8b7730d | 2012-04-09 15:24:59 -0500 | [diff] [blame] | 338 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 339 | /** |
| 340 | * clk_set_rate - set the clock rate for a clock source |
| 341 | * @clk: clock source |
| 342 | * @rate: desired clock rate in Hz |
| 343 | * |
| 344 | * Returns success (0) or negative errno. |
| 345 | */ |
| 346 | int clk_set_rate(struct clk *clk, unsigned long rate); |
Rob Herring | 8b7730d | 2012-04-09 15:24:59 -0500 | [diff] [blame] | 347 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | /** |
Thierry Reding | 4e88f3d | 2015-01-21 17:13:00 +0100 | [diff] [blame] | 349 | * clk_has_parent - check if a clock is a possible parent for another |
| 350 | * @clk: clock source |
| 351 | * @parent: parent clock source |
| 352 | * |
| 353 | * This function can be used in drivers that need to check that a clock can be |
| 354 | * the parent of another without actually changing the parent. |
| 355 | * |
| 356 | * Returns true if @parent is a possible parent for @clk, false otherwise. |
| 357 | */ |
| 358 | bool clk_has_parent(struct clk *clk, struct clk *parent); |
| 359 | |
| 360 | /** |
Tomeu Vizoso | 1c8e600 | 2015-01-23 12:03:31 +0100 | [diff] [blame] | 361 | * clk_set_rate_range - set a rate range for a clock source |
| 362 | * @clk: clock source |
| 363 | * @min: desired minimum clock rate in Hz, inclusive |
| 364 | * @max: desired maximum clock rate in Hz, inclusive |
| 365 | * |
| 366 | * Returns success (0) or negative errno. |
| 367 | */ |
| 368 | int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max); |
| 369 | |
| 370 | /** |
| 371 | * clk_set_min_rate - set a minimum clock rate for a clock source |
| 372 | * @clk: clock source |
| 373 | * @rate: desired minimum clock rate in Hz, inclusive |
| 374 | * |
| 375 | * Returns success (0) or negative errno. |
| 376 | */ |
| 377 | int clk_set_min_rate(struct clk *clk, unsigned long rate); |
| 378 | |
| 379 | /** |
| 380 | * clk_set_max_rate - set a maximum clock rate for a clock source |
| 381 | * @clk: clock source |
| 382 | * @rate: desired maximum clock rate in Hz, inclusive |
| 383 | * |
| 384 | * Returns success (0) or negative errno. |
| 385 | */ |
| 386 | int clk_set_max_rate(struct clk *clk, unsigned long rate); |
| 387 | |
| 388 | /** |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | * clk_set_parent - set the parent clock source for this clock |
| 390 | * @clk: clock source |
| 391 | * @parent: parent clock source |
| 392 | * |
| 393 | * Returns success (0) or negative errno. |
| 394 | */ |
| 395 | int clk_set_parent(struct clk *clk, struct clk *parent); |
| 396 | |
| 397 | /** |
| 398 | * clk_get_parent - get the parent clock source for this clock |
| 399 | * @clk: clock source |
| 400 | * |
| 401 | * Returns struct clk corresponding to parent clock source, or |
| 402 | * valid IS_ERR() condition containing errno. |
| 403 | */ |
| 404 | struct clk *clk_get_parent(struct clk *clk); |
| 405 | |
Sascha Hauer | 05fd8e7 | 2009-03-07 12:55:49 +0100 | [diff] [blame] | 406 | /** |
| 407 | * clk_get_sys - get a clock based upon the device name |
| 408 | * @dev_id: device name |
| 409 | * @con_id: connection ID |
| 410 | * |
| 411 | * Returns a struct clk corresponding to the clock producer, or |
| 412 | * valid IS_ERR() condition containing errno. The implementation |
| 413 | * uses @dev_id and @con_id to determine the clock consumer, and |
| 414 | * thereby the clock producer. In contrast to clk_get() this function |
| 415 | * takes the device name instead of the device itself for identification. |
| 416 | * |
| 417 | * Drivers must assume that the clock source is not enabled. |
| 418 | * |
| 419 | * clk_get_sys should not be called from within interrupt context. |
| 420 | */ |
| 421 | struct clk *clk_get_sys(const char *dev_id, const char *con_id); |
| 422 | |
Taniya Das | 63c20c7 | 2016-06-15 12:15:01 +0530 | [diff] [blame] | 423 | /** |
| 424 | * clk_set_flags - set the custom HW specific flags for this clock |
| 425 | * @clk: clock source |
| 426 | * @flags: custom flags which would be hardware specific, defined for specific |
| 427 | * hardware. |
| 428 | * |
| 429 | * Returns success 0 or negative errno. |
| 430 | */ |
| 431 | int clk_set_flags(struct clk *clk, unsigned long flags); |
| 432 | |
Viresh Kumar | 93abe8e | 2012-07-30 14:39:27 -0700 | [diff] [blame] | 433 | #else /* !CONFIG_HAVE_CLK */ |
| 434 | |
| 435 | static inline struct clk *clk_get(struct device *dev, const char *id) |
| 436 | { |
| 437 | return NULL; |
| 438 | } |
| 439 | |
| 440 | static inline struct clk *devm_clk_get(struct device *dev, const char *id) |
| 441 | { |
| 442 | return NULL; |
| 443 | } |
| 444 | |
| 445 | static inline void clk_put(struct clk *clk) {} |
| 446 | |
| 447 | static inline void devm_clk_put(struct device *dev, struct clk *clk) {} |
| 448 | |
| 449 | static inline int clk_enable(struct clk *clk) |
| 450 | { |
| 451 | return 0; |
| 452 | } |
| 453 | |
| 454 | static inline void clk_disable(struct clk *clk) {} |
| 455 | |
| 456 | static inline unsigned long clk_get_rate(struct clk *clk) |
| 457 | { |
| 458 | return 0; |
| 459 | } |
| 460 | |
| 461 | static inline int clk_set_rate(struct clk *clk, unsigned long rate) |
| 462 | { |
| 463 | return 0; |
| 464 | } |
| 465 | |
| 466 | static inline long clk_round_rate(struct clk *clk, unsigned long rate) |
| 467 | { |
| 468 | return 0; |
| 469 | } |
| 470 | |
Thierry Reding | 4e88f3d | 2015-01-21 17:13:00 +0100 | [diff] [blame] | 471 | static inline bool clk_has_parent(struct clk *clk, struct clk *parent) |
| 472 | { |
| 473 | return true; |
| 474 | } |
| 475 | |
Viresh Kumar | 93abe8e | 2012-07-30 14:39:27 -0700 | [diff] [blame] | 476 | static inline int clk_set_parent(struct clk *clk, struct clk *parent) |
| 477 | { |
| 478 | return 0; |
| 479 | } |
| 480 | |
| 481 | static inline struct clk *clk_get_parent(struct clk *clk) |
| 482 | { |
| 483 | return NULL; |
| 484 | } |
| 485 | |
Daniel Lezcano | b81ea96 | 2016-06-02 22:44:49 +0200 | [diff] [blame] | 486 | static inline struct clk *clk_get_sys(const char *dev_id, const char *con_id) |
| 487 | { |
| 488 | return NULL; |
| 489 | } |
Viresh Kumar | 93abe8e | 2012-07-30 14:39:27 -0700 | [diff] [blame] | 490 | #endif |
| 491 | |
| 492 | /* clk_prepare_enable helps cases using clk_enable in non-atomic context. */ |
| 493 | static inline int clk_prepare_enable(struct clk *clk) |
| 494 | { |
| 495 | int ret; |
| 496 | |
| 497 | ret = clk_prepare(clk); |
| 498 | if (ret) |
| 499 | return ret; |
| 500 | ret = clk_enable(clk); |
| 501 | if (ret) |
| 502 | clk_unprepare(clk); |
| 503 | |
| 504 | return ret; |
| 505 | } |
| 506 | |
| 507 | /* clk_disable_unprepare helps cases using clk_disable in non-atomic context. */ |
| 508 | static inline void clk_disable_unprepare(struct clk *clk) |
| 509 | { |
| 510 | clk_disable(clk); |
| 511 | clk_unprepare(clk); |
| 512 | } |
| 513 | |
Grant Likely | 766e6a4 | 2012-04-09 14:50:06 -0500 | [diff] [blame] | 514 | struct device_node; |
| 515 | struct of_phandle_args; |
| 516 | |
Rob Herring | 137f8a7 | 2012-07-18 11:52:23 +0800 | [diff] [blame] | 517 | #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK) |
Grant Likely | 766e6a4 | 2012-04-09 14:50:06 -0500 | [diff] [blame] | 518 | struct clk *of_clk_get(struct device_node *np, int index); |
| 519 | struct clk *of_clk_get_by_name(struct device_node *np, const char *name); |
| 520 | struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec); |
| 521 | #else |
| 522 | static inline struct clk *of_clk_get(struct device_node *np, int index) |
| 523 | { |
Shawn Guo | 9f1612d | 2012-07-18 11:52:22 +0800 | [diff] [blame] | 524 | return ERR_PTR(-ENOENT); |
Grant Likely | 766e6a4 | 2012-04-09 14:50:06 -0500 | [diff] [blame] | 525 | } |
| 526 | static inline struct clk *of_clk_get_by_name(struct device_node *np, |
| 527 | const char *name) |
| 528 | { |
Shawn Guo | 9f1612d | 2012-07-18 11:52:22 +0800 | [diff] [blame] | 529 | return ERR_PTR(-ENOENT); |
Grant Likely | 766e6a4 | 2012-04-09 14:50:06 -0500 | [diff] [blame] | 530 | } |
| 531 | #endif |
| 532 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 533 | #endif |