~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/clk.h

Version: ~ [ linux-5.14-rc1 ] ~ [ linux-5.13.1 ] ~ [ linux-5.12.16 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.49 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.131 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.197 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.239 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.275 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.275 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  linux/include/linux/clk.h
  3  *
  4  *  Copyright (C) 2004 ARM Limited.
  5  *  Written by Deep Blue Solutions Limited.
  6  *  Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
  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  */
 12 #ifndef __LINUX_CLK_H
 13 #define __LINUX_CLK_H
 14 
 15 #include <linux/err.h>
 16 #include <linux/kernel.h>
 17 #include <linux/notifier.h>
 18 
 19 struct device;
 20 
 21 struct clk;
 22 
 23 #ifdef CONFIG_COMMON_CLK
 24 
 25 /**
 26  * DOC: clk notifier callback types
 27  *
 28  * PRE_RATE_CHANGE - called immediately before the clk rate is changed,
 29  *     to indicate that the rate change will proceed.  Drivers must
 30  *     immediately terminate any operations that will be affected by the
 31  *     rate change.  Callbacks may either return NOTIFY_DONE, NOTIFY_OK,
 32  *     NOTIFY_STOP or NOTIFY_BAD.
 33  *
 34  * ABORT_RATE_CHANGE: called if the rate change failed for some reason
 35  *     after PRE_RATE_CHANGE.  In this case, all registered notifiers on
 36  *     the clk will be called with ABORT_RATE_CHANGE. Callbacks must
 37  *     always return NOTIFY_DONE or NOTIFY_OK.
 38  *
 39  * POST_RATE_CHANGE - called after the clk rate change has successfully
 40  *     completed.  Callbacks must always return NOTIFY_DONE or NOTIFY_OK.
 41  *
 42  */
 43 #define PRE_RATE_CHANGE                 BIT(0)
 44 #define POST_RATE_CHANGE                BIT(1)
 45 #define ABORT_RATE_CHANGE               BIT(2)
 46 
 47 /**
 48  * struct clk_notifier - associate a clk with a notifier
 49  * @clk: struct clk * to associate the notifier with
 50  * @notifier_head: a blocking_notifier_head for this clk
 51  * @node: linked list pointers
 52  *
 53  * A list of struct clk_notifier is maintained by the notifier code.
 54  * An entry is created whenever code registers the first notifier on a
 55  * particular @clk.  Future notifiers on that @clk are added to the
 56  * @notifier_head.
 57  */
 58 struct clk_notifier {
 59         struct clk                      *clk;
 60         struct srcu_notifier_head       notifier_head;
 61         struct list_head                node;
 62 };
 63 
 64 /**
 65  * struct clk_notifier_data - rate data to pass to the notifier callback
 66  * @clk: struct clk * being changed
 67  * @old_rate: previous rate of this clk
 68  * @new_rate: new rate of this clk
 69  *
 70  * For a pre-notifier, old_rate is the clk's rate before this rate
 71  * change, and new_rate is what the rate will be in the future.  For a
 72  * post-notifier, old_rate and new_rate are both set to the clk's
 73  * current rate (this was done to optimize the implementation).
 74  */
 75 struct clk_notifier_data {
 76         struct clk              *clk;
 77         unsigned long           old_rate;
 78         unsigned long           new_rate;
 79 };
 80 
 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  */
 90 int clk_notifier_register(struct clk *clk, struct notifier_block *nb);
 91 
 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  */
 97 int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb);
 98 
 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 
109 #else
110 
111 static inline long clk_get_accuracy(struct clk *clk)
112 {
113         return -ENOTSUPP;
114 }
115 
116 #endif
117 
118 /**
119  * clk_prepare - prepare a clock source
120  * @clk: clock source
121  *
122  * This prepares the clock source for use.
123  *
124  * Must not be called from within atomic context.
125  */
126 #ifdef CONFIG_HAVE_CLK_PREPARE
127 int clk_prepare(struct clk *clk);
128 #else
129 static inline int clk_prepare(struct clk *clk)
130 {
131         might_sleep();
132         return 0;
133 }
134 #endif
135 
136 /**
137  * clk_unprepare - undo preparation of a clock source
138  * @clk: clock source
139  *
140  * This undoes a previously prepared clock.  The caller must balance
141  * the number of prepare and unprepare calls.
142  *
143  * Must not be called from within atomic context.
144  */
145 #ifdef CONFIG_HAVE_CLK_PREPARE
146 void clk_unprepare(struct clk *clk);
147 #else
148 static inline void clk_unprepare(struct clk *clk)
149 {
150         might_sleep();
151 }
152 #endif
153 
154 #ifdef CONFIG_HAVE_CLK
155 /**
156  * clk_get - lookup and obtain a reference to a clock producer.
157  * @dev: device for clock "consumer"
158  * @id: clock consumer ID
159  *
160  * Returns a struct clk corresponding to the clock producer, or
161  * valid IS_ERR() condition containing errno.  The implementation
162  * uses @dev and @id to determine the clock consumer, and thereby
163  * the clock producer.  (IOW, @id may be identical strings, but
164  * clk_get may return different clock producers depending on @dev.)
165  *
166  * Drivers must assume that the clock source is not enabled.
167  *
168  * clk_get should not be called from within interrupt context.
169  */
170 struct clk *clk_get(struct device *dev, const char *id);
171 
172 /**
173  * devm_clk_get - lookup and obtain a managed reference to a clock producer.
174  * @dev: device for clock "consumer"
175  * @id: clock consumer ID
176  *
177  * Returns a struct clk corresponding to the clock producer, or
178  * valid IS_ERR() condition containing errno.  The implementation
179  * uses @dev and @id to determine the clock consumer, and thereby
180  * the clock producer.  (IOW, @id may be identical strings, but
181  * clk_get may return different clock producers depending on @dev.)
182  *
183  * Drivers must assume that the clock source is not enabled.
184  *
185  * devm_clk_get should not be called from within interrupt context.
186  *
187  * The clock will automatically be freed when the device is unbound
188  * from the bus.
189  */
190 struct clk *devm_clk_get(struct device *dev, const char *id);
191 
192 /**
193  * clk_enable - inform the system when the clock source should be running.
194  * @clk: clock source
195  *
196  * If the clock can not be enabled/disabled, this should return success.
197  *
198  * May be called from atomic contexts.
199  *
200  * Returns success (0) or negative errno.
201  */
202 int clk_enable(struct clk *clk);
203 
204 /**
205  * clk_disable - inform the system when the clock source is no longer required.
206  * @clk: clock source
207  *
208  * Inform the system that a clock source is no longer required by
209  * a driver and may be shut down.
210  *
211  * May be called from atomic contexts.
212  *
213  * Implementation detail: if the clock source is shared between
214  * multiple drivers, clk_enable() calls must be balanced by the
215  * same number of clk_disable() calls for the clock source to be
216  * disabled.
217  */
218 void clk_disable(struct clk *clk);
219 
220 /**
221  * clk_get_rate - obtain the current clock rate (in Hz) for a clock source.
222  *                This is only valid once the clock source has been enabled.
223  * @clk: clock source
224  */
225 unsigned long clk_get_rate(struct clk *clk);
226 
227 /**
228  * clk_put      - "free" the clock source
229  * @clk: clock source
230  *
231  * Note: drivers must ensure that all clk_enable calls made on this
232  * clock source are balanced by clk_disable calls prior to calling
233  * this function.
234  *
235  * clk_put should not be called from within interrupt context.
236  */
237 void clk_put(struct clk *clk);
238 
239 /**
240  * devm_clk_put - "free" a managed clock source
241  * @dev: device used to acuqire the clock
242  * @clk: clock source acquired with devm_clk_get()
243  *
244  * Note: drivers must ensure that all clk_enable calls made on this
245  * clock source are balanced by clk_disable calls prior to calling
246  * this function.
247  *
248  * clk_put should not be called from within interrupt context.
249  */
250 void devm_clk_put(struct device *dev, struct clk *clk);
251 
252 /*
253  * The remaining APIs are optional for machine class support.
254  */
255 
256 
257 /**
258  * clk_round_rate - adjust a rate to the exact rate a clock can provide
259  * @clk: clock source
260  * @rate: desired clock rate in Hz
261  *
262  * Returns rounded clock rate in Hz, or negative errno.
263  */
264 long clk_round_rate(struct clk *clk, unsigned long rate);
265 
266 /**
267  * clk_set_rate - set the clock rate for a clock source
268  * @clk: clock source
269  * @rate: desired clock rate in Hz
270  *
271  * Returns success (0) or negative errno.
272  */
273 int clk_set_rate(struct clk *clk, unsigned long rate);
274 
275 /**
276  * clk_set_parent - set the parent clock source for this clock
277  * @clk: clock source
278  * @parent: parent clock source
279  *
280  * Returns success (0) or negative errno.
281  */
282 int clk_set_parent(struct clk *clk, struct clk *parent);
283 
284 /**
285  * clk_get_parent - get the parent clock source for this clock
286  * @clk: clock source
287  *
288  * Returns struct clk corresponding to parent clock source, or
289  * valid IS_ERR() condition containing errno.
290  */
291 struct clk *clk_get_parent(struct clk *clk);
292 
293 /**
294  * clk_get_sys - get a clock based upon the device name
295  * @dev_id: device name
296  * @con_id: connection ID
297  *
298  * Returns a struct clk corresponding to the clock producer, or
299  * valid IS_ERR() condition containing errno.  The implementation
300  * uses @dev_id and @con_id to determine the clock consumer, and
301  * thereby the clock producer. In contrast to clk_get() this function
302  * takes the device name instead of the device itself for identification.
303  *
304  * Drivers must assume that the clock source is not enabled.
305  *
306  * clk_get_sys should not be called from within interrupt context.
307  */
308 struct clk *clk_get_sys(const char *dev_id, const char *con_id);
309 
310 #else /* !CONFIG_HAVE_CLK */
311 
312 static inline struct clk *clk_get(struct device *dev, const char *id)
313 {
314         return NULL;
315 }
316 
317 static inline struct clk *devm_clk_get(struct device *dev, const char *id)
318 {
319         return NULL;
320 }
321 
322 static inline void clk_put(struct clk *clk) {}
323 
324 static inline void devm_clk_put(struct device *dev, struct clk *clk) {}
325 
326 static inline int clk_enable(struct clk *clk)
327 {
328         return 0;
329 }
330 
331 static inline void clk_disable(struct clk *clk) {}
332 
333 static inline unsigned long clk_get_rate(struct clk *clk)
334 {
335         return 0;
336 }
337 
338 static inline int clk_set_rate(struct clk *clk, unsigned long rate)
339 {
340         return 0;
341 }
342 
343 static inline long clk_round_rate(struct clk *clk, unsigned long rate)
344 {
345         return 0;
346 }
347 
348 static inline int clk_set_parent(struct clk *clk, struct clk *parent)
349 {
350         return 0;
351 }
352 
353 static inline struct clk *clk_get_parent(struct clk *clk)
354 {
355         return NULL;
356 }
357 
358 #endif
359 
360 /* clk_prepare_enable helps cases using clk_enable in non-atomic context. */
361 static inline int clk_prepare_enable(struct clk *clk)
362 {
363         int ret;
364 
365         ret = clk_prepare(clk);
366         if (ret)
367                 return ret;
368         ret = clk_enable(clk);
369         if (ret)
370                 clk_unprepare(clk);
371 
372         return ret;
373 }
374 
375 /* clk_disable_unprepare helps cases using clk_disable in non-atomic context. */
376 static inline void clk_disable_unprepare(struct clk *clk)
377 {
378         clk_disable(clk);
379         clk_unprepare(clk);
380 }
381 
382 /**
383  * clk_add_alias - add a new clock alias
384  * @alias: name for clock alias
385  * @alias_dev_name: device name
386  * @id: platform specific clock name
387  * @dev: device
388  *
389  * Allows using generic clock names for drivers by adding a new alias.
390  * Assumes clkdev, see clkdev.h for more info.
391  */
392 int clk_add_alias(const char *alias, const char *alias_dev_name, char *id,
393                         struct device *dev);
394 
395 struct device_node;
396 struct of_phandle_args;
397 
398 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
399 struct clk *of_clk_get(struct device_node *np, int index);
400 struct clk *of_clk_get_by_name(struct device_node *np, const char *name);
401 struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec);
402 #else
403 static inline struct clk *of_clk_get(struct device_node *np, int index)
404 {
405         return ERR_PTR(-ENOENT);
406 }
407 static inline struct clk *of_clk_get_by_name(struct device_node *np,
408                                              const char *name)
409 {
410         return ERR_PTR(-ENOENT);
411 }
412 #endif
413 
414 #endif
415 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp