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

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

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ 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 /* SPDX-License-Identifier: GPL-2.0-only */
  2 /*
  3  *  linux/include/linux/clk.h
  4  *
  5  *  Copyright (C) 2004 ARM Limited.
  6  *  Written by Deep Blue Solutions Limited.
  7  *  Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
  8  */
  9 #ifndef __LINUX_CLK_H
 10 #define __LINUX_CLK_H
 11 
 12 #include <linux/err.h>
 13 #include <linux/kernel.h>
 14 #include <linux/notifier.h>
 15 
 16 struct device;
 17 struct clk;
 18 struct device_node;
 19 struct of_phandle_args;
 20 
 21 /**
 22  * DOC: clk notifier callback types
 23  *
 24  * PRE_RATE_CHANGE - called immediately before the clk rate is changed,
 25  *     to indicate that the rate change will proceed.  Drivers must
 26  *     immediately terminate any operations that will be affected by the
 27  *     rate change.  Callbacks may either return NOTIFY_DONE, NOTIFY_OK,
 28  *     NOTIFY_STOP or NOTIFY_BAD.
 29  *
 30  * ABORT_RATE_CHANGE: called if the rate change failed for some reason
 31  *     after PRE_RATE_CHANGE.  In this case, all registered notifiers on
 32  *     the clk will be called with ABORT_RATE_CHANGE. Callbacks must
 33  *     always return NOTIFY_DONE or NOTIFY_OK.
 34  *
 35  * POST_RATE_CHANGE - called after the clk rate change has successfully
 36  *     completed.  Callbacks must always return NOTIFY_DONE or NOTIFY_OK.
 37  *
 38  */
 39 #define PRE_RATE_CHANGE                 BIT(0)
 40 #define POST_RATE_CHANGE                BIT(1)
 41 #define ABORT_RATE_CHANGE               BIT(2)
 42 
 43 /**
 44  * struct clk_notifier - associate a clk with a notifier
 45  * @clk: struct clk * to associate the notifier with
 46  * @notifier_head: a blocking_notifier_head for this clk
 47  * @node: linked list pointers
 48  *
 49  * A list of struct clk_notifier is maintained by the notifier code.
 50  * An entry is created whenever code registers the first notifier on a
 51  * particular @clk.  Future notifiers on that @clk are added to the
 52  * @notifier_head.
 53  */
 54 struct clk_notifier {
 55         struct clk                      *clk;
 56         struct srcu_notifier_head       notifier_head;
 57         struct list_head                node;
 58 };
 59 
 60 /**
 61  * struct clk_notifier_data - rate data to pass to the notifier callback
 62  * @clk: struct clk * being changed
 63  * @old_rate: previous rate of this clk
 64  * @new_rate: new rate of this clk
 65  *
 66  * For a pre-notifier, old_rate is the clk's rate before this rate
 67  * change, and new_rate is what the rate will be in the future.  For a
 68  * post-notifier, old_rate and new_rate are both set to the clk's
 69  * current rate (this was done to optimize the implementation).
 70  */
 71 struct clk_notifier_data {
 72         struct clk              *clk;
 73         unsigned long           old_rate;
 74         unsigned long           new_rate;
 75 };
 76 
 77 /**
 78  * struct clk_bulk_data - Data used for bulk clk operations.
 79  *
 80  * @id: clock consumer ID
 81  * @clk: struct clk * to store the associated clock
 82  *
 83  * The CLK APIs provide a series of clk_bulk_() API calls as
 84  * a convenience to consumers which require multiple clks.  This
 85  * structure is used to manage data for these calls.
 86  */
 87 struct clk_bulk_data {
 88         const char              *id;
 89         struct clk              *clk;
 90 };
 91 
 92 #ifdef CONFIG_COMMON_CLK
 93 
 94 /**
 95  * clk_notifier_register: register a clock rate-change notifier callback
 96  * @clk: clock whose rate we are interested in
 97  * @nb: notifier block with callback function pointer
 98  *
 99  * ProTip: debugging across notifier chains can be frustrating. Make sure that
100  * your notifier callback function prints a nice big warning in case of
101  * failure.
102  */
103 int clk_notifier_register(struct clk *clk, struct notifier_block *nb);
104 
105 /**
106  * clk_notifier_unregister: unregister a clock rate-change notifier callback
107  * @clk: clock whose rate we are no longer interested in
108  * @nb: notifier block which will be unregistered
109  */
110 int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb);
111 
112 /**
113  * clk_get_accuracy - obtain the clock accuracy in ppb (parts per billion)
114  *                    for a clock source.
115  * @clk: clock source
116  *
117  * This gets the clock source accuracy expressed in ppb.
118  * A perfect clock returns 0.
119  */
120 long clk_get_accuracy(struct clk *clk);
121 
122 /**
123  * clk_set_phase - adjust the phase shift of a clock signal
124  * @clk: clock signal source
125  * @degrees: number of degrees the signal is shifted
126  *
127  * Shifts the phase of a clock signal by the specified degrees. Returns 0 on
128  * success, -EERROR otherwise.
129  */
130 int clk_set_phase(struct clk *clk, int degrees);
131 
132 /**
133  * clk_get_phase - return the phase shift of a clock signal
134  * @clk: clock signal source
135  *
136  * Returns the phase shift of a clock node in degrees, otherwise returns
137  * -EERROR.
138  */
139 int clk_get_phase(struct clk *clk);
140 
141 /**
142  * clk_set_duty_cycle - adjust the duty cycle ratio of a clock signal
143  * @clk: clock signal source
144  * @num: numerator of the duty cycle ratio to be applied
145  * @den: denominator of the duty cycle ratio to be applied
146  *
147  * Adjust the duty cycle of a clock signal by the specified ratio. Returns 0 on
148  * success, -EERROR otherwise.
149  */
150 int clk_set_duty_cycle(struct clk *clk, unsigned int num, unsigned int den);
151 
152 /**
153  * clk_get_duty_cycle - return the duty cycle ratio of a clock signal
154  * @clk: clock signal source
155  * @scale: scaling factor to be applied to represent the ratio as an integer
156  *
157  * Returns the duty cycle ratio multiplied by the scale provided, otherwise
158  * returns -EERROR.
159  */
160 int clk_get_scaled_duty_cycle(struct clk *clk, unsigned int scale);
161 
162 /**
163  * clk_is_match - check if two clk's point to the same hardware clock
164  * @p: clk compared against q
165  * @q: clk compared against p
166  *
167  * Returns true if the two struct clk pointers both point to the same hardware
168  * clock node. Put differently, returns true if @p and @q
169  * share the same &struct clk_core object.
170  *
171  * Returns false otherwise. Note that two NULL clks are treated as matching.
172  */
173 bool clk_is_match(const struct clk *p, const struct clk *q);
174 
175 #else
176 
177 static inline int clk_notifier_register(struct clk *clk,
178                                         struct notifier_block *nb)
179 {
180         return -ENOTSUPP;
181 }
182 
183 static inline int clk_notifier_unregister(struct clk *clk,
184                                           struct notifier_block *nb)
185 {
186         return -ENOTSUPP;
187 }
188 
189 static inline long clk_get_accuracy(struct clk *clk)
190 {
191         return -ENOTSUPP;
192 }
193 
194 static inline long clk_set_phase(struct clk *clk, int phase)
195 {
196         return -ENOTSUPP;
197 }
198 
199 static inline long clk_get_phase(struct clk *clk)
200 {
201         return -ENOTSUPP;
202 }
203 
204 static inline int clk_set_duty_cycle(struct clk *clk, unsigned int num,
205                                      unsigned int den)
206 {
207         return -ENOTSUPP;
208 }
209 
210 static inline unsigned int clk_get_scaled_duty_cycle(struct clk *clk,
211                                                      unsigned int scale)
212 {
213         return 0;
214 }
215 
216 static inline bool clk_is_match(const struct clk *p, const struct clk *q)
217 {
218         return p == q;
219 }
220 
221 #endif
222 
223 /**
224  * clk_prepare - prepare a clock source
225  * @clk: clock source
226  *
227  * This prepares the clock source for use.
228  *
229  * Must not be called from within atomic context.
230  */
231 #ifdef CONFIG_HAVE_CLK_PREPARE
232 int clk_prepare(struct clk *clk);
233 int __must_check clk_bulk_prepare(int num_clks,
234                                   const struct clk_bulk_data *clks);
235 #else
236 static inline int clk_prepare(struct clk *clk)
237 {
238         might_sleep();
239         return 0;
240 }
241 
242 static inline int __must_check clk_bulk_prepare(int num_clks, struct clk_bulk_data *clks)
243 {
244         might_sleep();
245         return 0;
246 }
247 #endif
248 
249 /**
250  * clk_unprepare - undo preparation of a clock source
251  * @clk: clock source
252  *
253  * This undoes a previously prepared clock.  The caller must balance
254  * the number of prepare and unprepare calls.
255  *
256  * Must not be called from within atomic context.
257  */
258 #ifdef CONFIG_HAVE_CLK_PREPARE
259 void clk_unprepare(struct clk *clk);
260 void clk_bulk_unprepare(int num_clks, const struct clk_bulk_data *clks);
261 #else
262 static inline void clk_unprepare(struct clk *clk)
263 {
264         might_sleep();
265 }
266 static inline void clk_bulk_unprepare(int num_clks, struct clk_bulk_data *clks)
267 {
268         might_sleep();
269 }
270 #endif
271 
272 #ifdef CONFIG_HAVE_CLK
273 /**
274  * clk_get - lookup and obtain a reference to a clock producer.
275  * @dev: device for clock "consumer"
276  * @id: clock consumer ID
277  *
278  * Returns a struct clk corresponding to the clock producer, or
279  * valid IS_ERR() condition containing errno.  The implementation
280  * uses @dev and @id to determine the clock consumer, and thereby
281  * the clock producer.  (IOW, @id may be identical strings, but
282  * clk_get may return different clock producers depending on @dev.)
283  *
284  * Drivers must assume that the clock source is not enabled.
285  *
286  * clk_get should not be called from within interrupt context.
287  */
288 struct clk *clk_get(struct device *dev, const char *id);
289 
290 /**
291  * clk_bulk_get - lookup and obtain a number of references to clock producer.
292  * @dev: device for clock "consumer"
293  * @num_clks: the number of clk_bulk_data
294  * @clks: the clk_bulk_data table of consumer
295  *
296  * This helper function allows drivers to get several clk consumers in one
297  * operation. If any of the clk cannot be acquired then any clks
298  * that were obtained will be freed before returning to the caller.
299  *
300  * Returns 0 if all clocks specified in clk_bulk_data table are obtained
301  * successfully, or valid IS_ERR() condition containing errno.
302  * The implementation uses @dev and @clk_bulk_data.id to determine the
303  * clock consumer, and thereby the clock producer.
304  * The clock returned is stored in each @clk_bulk_data.clk field.
305  *
306  * Drivers must assume that the clock source is not enabled.
307  *
308  * clk_bulk_get should not be called from within interrupt context.
309  */
310 int __must_check clk_bulk_get(struct device *dev, int num_clks,
311                               struct clk_bulk_data *clks);
312 /**
313  * clk_bulk_get_all - lookup and obtain all available references to clock
314  *                    producer.
315  * @dev: device for clock "consumer"
316  * @clks: pointer to the clk_bulk_data table of consumer
317  *
318  * This helper function allows drivers to get all clk consumers in one
319  * operation. If any of the clk cannot be acquired then any clks
320  * that were obtained will be freed before returning to the caller.
321  *
322  * Returns a positive value for the number of clocks obtained while the
323  * clock references are stored in the clk_bulk_data table in @clks field.
324  * Returns 0 if there're none and a negative value if something failed.
325  *
326  * Drivers must assume that the clock source is not enabled.
327  *
328  * clk_bulk_get should not be called from within interrupt context.
329  */
330 int __must_check clk_bulk_get_all(struct device *dev,
331                                   struct clk_bulk_data **clks);
332 
333 /**
334  * clk_bulk_get_optional - lookup and obtain a number of references to clock producer
335  * @dev: device for clock "consumer"
336  * @num_clks: the number of clk_bulk_data
337  * @clks: the clk_bulk_data table of consumer
338  *
339  * Behaves the same as clk_bulk_get() except where there is no clock producer.
340  * In this case, instead of returning -ENOENT, the function returns 0 and
341  * NULL for a clk for which a clock producer could not be determined.
342  */
343 int __must_check clk_bulk_get_optional(struct device *dev, int num_clks,
344                                        struct clk_bulk_data *clks);
345 /**
346  * devm_clk_bulk_get - managed get multiple clk consumers
347  * @dev: device for clock "consumer"
348  * @num_clks: the number of clk_bulk_data
349  * @clks: the clk_bulk_data table of consumer
350  *
351  * Return 0 on success, an errno on failure.
352  *
353  * This helper function allows drivers to get several clk
354  * consumers in one operation with management, the clks will
355  * automatically be freed when the device is unbound.
356  */
357 int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
358                                    struct clk_bulk_data *clks);
359 /**
360  * devm_clk_bulk_get_optional - managed get multiple optional consumer clocks
361  * @dev: device for clock "consumer"
362  * @num_clks: the number of clk_bulk_data
363  * @clks: pointer to the clk_bulk_data table of consumer
364  *
365  * Behaves the same as devm_clk_bulk_get() except where there is no clock
366  * producer.  In this case, instead of returning -ENOENT, the function returns
367  * NULL for given clk. It is assumed all clocks in clk_bulk_data are optional.
368  *
369  * Returns 0 if all clocks specified in clk_bulk_data table are obtained
370  * successfully or for any clk there was no clk provider available, otherwise
371  * returns valid IS_ERR() condition containing errno.
372  * The implementation uses @dev and @clk_bulk_data.id to determine the
373  * clock consumer, and thereby the clock producer.
374  * The clock returned is stored in each @clk_bulk_data.clk field.
375  *
376  * Drivers must assume that the clock source is not enabled.
377  *
378  * clk_bulk_get should not be called from within interrupt context.
379  */
380 int __must_check devm_clk_bulk_get_optional(struct device *dev, int num_clks,
381                                             struct clk_bulk_data *clks);
382 /**
383  * devm_clk_bulk_get_all - managed get multiple clk consumers
384  * @dev: device for clock "consumer"
385  * @clks: pointer to the clk_bulk_data table of consumer
386  *
387  * Returns a positive value for the number of clocks obtained while the
388  * clock references are stored in the clk_bulk_data table in @clks field.
389  * Returns 0 if there're none and a negative value if something failed.
390  *
391  * This helper function allows drivers to get several clk
392  * consumers in one operation with management, the clks will
393  * automatically be freed when the device is unbound.
394  */
395 
396 int __must_check devm_clk_bulk_get_all(struct device *dev,
397                                        struct clk_bulk_data **clks);
398 
399 /**
400  * devm_clk_get - lookup and obtain a managed reference to a clock producer.
401  * @dev: device for clock "consumer"
402  * @id: clock consumer ID
403  *
404  * Returns a struct clk corresponding to the clock producer, or
405  * valid IS_ERR() condition containing errno.  The implementation
406  * uses @dev and @id to determine the clock consumer, and thereby
407  * the clock producer.  (IOW, @id may be identical strings, but
408  * clk_get may return different clock producers depending on @dev.)
409  *
410  * Drivers must assume that the clock source is not enabled.
411  *
412  * devm_clk_get should not be called from within interrupt context.
413  *
414  * The clock will automatically be freed when the device is unbound
415  * from the bus.
416  */
417 struct clk *devm_clk_get(struct device *dev, const char *id);
418 
419 /**
420  * devm_clk_get_optional - lookup and obtain a managed reference to an optional
421  *                         clock producer.
422  * @dev: device for clock "consumer"
423  * @id: clock consumer ID
424  *
425  * Behaves the same as devm_clk_get() except where there is no clock producer.
426  * In this case, instead of returning -ENOENT, the function returns NULL.
427  */
428 struct clk *devm_clk_get_optional(struct device *dev, const char *id);
429 
430 /**
431  * devm_get_clk_from_child - lookup and obtain a managed reference to a
432  *                           clock producer from child node.
433  * @dev: device for clock "consumer"
434  * @np: pointer to clock consumer node
435  * @con_id: clock consumer ID
436  *
437  * This function parses the clocks, and uses them to look up the
438  * struct clk from the registered list of clock providers by using
439  * @np and @con_id
440  *
441  * The clock will automatically be freed when the device is unbound
442  * from the bus.
443  */
444 struct clk *devm_get_clk_from_child(struct device *dev,
445                                     struct device_node *np, const char *con_id);
446 /**
447  * clk_rate_exclusive_get - get exclusivity over the rate control of a
448  *                          producer
449  * @clk: clock source
450  *
451  * This function allows drivers to get exclusive control over the rate of a
452  * provider. It prevents any other consumer to execute, even indirectly,
453  * opereation which could alter the rate of the provider or cause glitches
454  *
455  * If exlusivity is claimed more than once on clock, even by the same driver,
456  * the rate effectively gets locked as exclusivity can't be preempted.
457  *
458  * Must not be called from within atomic context.
459  *
460  * Returns success (0) or negative errno.
461  */
462 int clk_rate_exclusive_get(struct clk *clk);
463 
464 /**
465  * clk_rate_exclusive_put - release exclusivity over the rate control of a
466  *                          producer
467  * @clk: clock source
468  *
469  * This function allows drivers to release the exclusivity it previously got
470  * from clk_rate_exclusive_get()
471  *
472  * The caller must balance the number of clk_rate_exclusive_get() and
473  * clk_rate_exclusive_put() calls.
474  *
475  * Must not be called from within atomic context.
476  */
477 void clk_rate_exclusive_put(struct clk *clk);
478 
479 /**
480  * clk_enable - inform the system when the clock source should be running.
481  * @clk: clock source
482  *
483  * If the clock can not be enabled/disabled, this should return success.
484  *
485  * May be called from atomic contexts.
486  *
487  * Returns success (0) or negative errno.
488  */
489 int clk_enable(struct clk *clk);
490 
491 /**
492  * clk_bulk_enable - inform the system when the set of clks should be running.
493  * @num_clks: the number of clk_bulk_data
494  * @clks: the clk_bulk_data table of consumer
495  *
496  * May be called from atomic contexts.
497  *
498  * Returns success (0) or negative errno.
499  */
500 int __must_check clk_bulk_enable(int num_clks,
501                                  const struct clk_bulk_data *clks);
502 
503 /**
504  * clk_disable - inform the system when the clock source is no longer required.
505  * @clk: clock source
506  *
507  * Inform the system that a clock source is no longer required by
508  * a driver and may be shut down.
509  *
510  * May be called from atomic contexts.
511  *
512  * Implementation detail: if the clock source is shared between
513  * multiple drivers, clk_enable() calls must be balanced by the
514  * same number of clk_disable() calls for the clock source to be
515  * disabled.
516  */
517 void clk_disable(struct clk *clk);
518 
519 /**
520  * clk_bulk_disable - inform the system when the set of clks is no
521  *                    longer required.
522  * @num_clks: the number of clk_bulk_data
523  * @clks: the clk_bulk_data table of consumer
524  *
525  * Inform the system that a set of clks is no longer required by
526  * a driver and may be shut down.
527  *
528  * May be called from atomic contexts.
529  *
530  * Implementation detail: if the set of clks is shared between
531  * multiple drivers, clk_bulk_enable() calls must be balanced by the
532  * same number of clk_bulk_disable() calls for the clock source to be
533  * disabled.
534  */
535 void clk_bulk_disable(int num_clks, const struct clk_bulk_data *clks);
536 
537 /**
538  * clk_get_rate - obtain the current clock rate (in Hz) for a clock source.
539  *                This is only valid once the clock source has been enabled.
540  * @clk: clock source
541  */
542 unsigned long clk_get_rate(struct clk *clk);
543 
544 /**
545  * clk_put      - "free" the clock source
546  * @clk: clock source
547  *
548  * Note: drivers must ensure that all clk_enable calls made on this
549  * clock source are balanced by clk_disable calls prior to calling
550  * this function.
551  *
552  * clk_put should not be called from within interrupt context.
553  */
554 void clk_put(struct clk *clk);
555 
556 /**
557  * clk_bulk_put - "free" the clock source
558  * @num_clks: the number of clk_bulk_data
559  * @clks: the clk_bulk_data table of consumer
560  *
561  * Note: drivers must ensure that all clk_bulk_enable calls made on this
562  * clock source are balanced by clk_bulk_disable calls prior to calling
563  * this function.
564  *
565  * clk_bulk_put should not be called from within interrupt context.
566  */
567 void clk_bulk_put(int num_clks, struct clk_bulk_data *clks);
568 
569 /**
570  * clk_bulk_put_all - "free" all the clock source
571  * @num_clks: the number of clk_bulk_data
572  * @clks: the clk_bulk_data table of consumer
573  *
574  * Note: drivers must ensure that all clk_bulk_enable calls made on this
575  * clock source are balanced by clk_bulk_disable calls prior to calling
576  * this function.
577  *
578  * clk_bulk_put_all should not be called from within interrupt context.
579  */
580 void clk_bulk_put_all(int num_clks, struct clk_bulk_data *clks);
581 
582 /**
583  * devm_clk_put - "free" a managed clock source
584  * @dev: device used to acquire the clock
585  * @clk: clock source acquired with devm_clk_get()
586  *
587  * Note: drivers must ensure that all clk_enable calls made on this
588  * clock source are balanced by clk_disable calls prior to calling
589  * this function.
590  *
591  * clk_put should not be called from within interrupt context.
592  */
593 void devm_clk_put(struct device *dev, struct clk *clk);
594 
595 /*
596  * The remaining APIs are optional for machine class support.
597  */
598 
599 
600 /**
601  * clk_round_rate - adjust a rate to the exact rate a clock can provide
602  * @clk: clock source
603  * @rate: desired clock rate in Hz
604  *
605  * This answers the question "if I were to pass @rate to clk_set_rate(),
606  * what clock rate would I end up with?" without changing the hardware
607  * in any way.  In other words:
608  *
609  *   rate = clk_round_rate(clk, r);
610  *
611  * and:
612  *
613  *   clk_set_rate(clk, r);
614  *   rate = clk_get_rate(clk);
615  *
616  * are equivalent except the former does not modify the clock hardware
617  * in any way.
618  *
619  * Returns rounded clock rate in Hz, or negative errno.
620  */
621 long clk_round_rate(struct clk *clk, unsigned long rate);
622 
623 /**
624  * clk_set_rate - set the clock rate for a clock source
625  * @clk: clock source
626  * @rate: desired clock rate in Hz
627  *
628  * Returns success (0) or negative errno.
629  */
630 int clk_set_rate(struct clk *clk, unsigned long rate);
631 
632 /**
633  * clk_set_rate_exclusive- set the clock rate and claim exclusivity over
634  *                         clock source
635  * @clk: clock source
636  * @rate: desired clock rate in Hz
637  *
638  * This helper function allows drivers to atomically set the rate of a producer
639  * and claim exclusivity over the rate control of the producer.
640  *
641  * It is essentially a combination of clk_set_rate() and
642  * clk_rate_exclusite_get(). Caller must balance this call with a call to
643  * clk_rate_exclusive_put()
644  *
645  * Returns success (0) or negative errno.
646  */
647 int clk_set_rate_exclusive(struct clk *clk, unsigned long rate);
648 
649 /**
650  * clk_has_parent - check if a clock is a possible parent for another
651  * @clk: clock source
652  * @parent: parent clock source
653  *
654  * This function can be used in drivers that need to check that a clock can be
655  * the parent of another without actually changing the parent.
656  *
657  * Returns true if @parent is a possible parent for @clk, false otherwise.
658  */
659 bool clk_has_parent(struct clk *clk, struct clk *parent);
660 
661 /**
662  * clk_set_rate_range - set a rate range for a clock source
663  * @clk: clock source
664  * @min: desired minimum clock rate in Hz, inclusive
665  * @max: desired maximum clock rate in Hz, inclusive
666  *
667  * Returns success (0) or negative errno.
668  */
669 int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max);
670 
671 /**
672  * clk_set_min_rate - set a minimum clock rate for a clock source
673  * @clk: clock source
674  * @rate: desired minimum clock rate in Hz, inclusive
675  *
676  * Returns success (0) or negative errno.
677  */
678 int clk_set_min_rate(struct clk *clk, unsigned long rate);
679 
680 /**
681  * clk_set_max_rate - set a maximum clock rate for a clock source
682  * @clk: clock source
683  * @rate: desired maximum clock rate in Hz, inclusive
684  *
685  * Returns success (0) or negative errno.
686  */
687 int clk_set_max_rate(struct clk *clk, unsigned long rate);
688 
689 /**
690  * clk_set_parent - set the parent clock source for this clock
691  * @clk: clock source
692  * @parent: parent clock source
693  *
694  * Returns success (0) or negative errno.
695  */
696 int clk_set_parent(struct clk *clk, struct clk *parent);
697 
698 /**
699  * clk_get_parent - get the parent clock source for this clock
700  * @clk: clock source
701  *
702  * Returns struct clk corresponding to parent clock source, or
703  * valid IS_ERR() condition containing errno.
704  */
705 struct clk *clk_get_parent(struct clk *clk);
706 
707 /**
708  * clk_get_sys - get a clock based upon the device name
709  * @dev_id: device name
710  * @con_id: connection ID
711  *
712  * Returns a struct clk corresponding to the clock producer, or
713  * valid IS_ERR() condition containing errno.  The implementation
714  * uses @dev_id and @con_id to determine the clock consumer, and
715  * thereby the clock producer. In contrast to clk_get() this function
716  * takes the device name instead of the device itself for identification.
717  *
718  * Drivers must assume that the clock source is not enabled.
719  *
720  * clk_get_sys should not be called from within interrupt context.
721  */
722 struct clk *clk_get_sys(const char *dev_id, const char *con_id);
723 
724 /**
725  * clk_save_context - save clock context for poweroff
726  *
727  * Saves the context of the clock register for powerstates in which the
728  * contents of the registers will be lost. Occurs deep within the suspend
729  * code so locking is not necessary.
730  */
731 int clk_save_context(void);
732 
733 /**
734  * clk_restore_context - restore clock context after poweroff
735  *
736  * This occurs with all clocks enabled. Occurs deep within the resume code
737  * so locking is not necessary.
738  */
739 void clk_restore_context(void);
740 
741 #else /* !CONFIG_HAVE_CLK */
742 
743 static inline struct clk *clk_get(struct device *dev, const char *id)
744 {
745         return NULL;
746 }
747 
748 static inline int __must_check clk_bulk_get(struct device *dev, int num_clks,
749                                             struct clk_bulk_data *clks)
750 {
751         return 0;
752 }
753 
754 static inline int __must_check clk_bulk_get_optional(struct device *dev,
755                                 int num_clks, struct clk_bulk_data *clks)
756 {
757         return 0;
758 }
759 
760 static inline int __must_check clk_bulk_get_all(struct device *dev,
761                                          struct clk_bulk_data **clks)
762 {
763         return 0;
764 }
765 
766 static inline struct clk *devm_clk_get(struct device *dev, const char *id)
767 {
768         return NULL;
769 }
770 
771 static inline struct clk *devm_clk_get_optional(struct device *dev,
772                                                 const char *id)
773 {
774         return NULL;
775 }
776 
777 static inline int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
778                                                  struct clk_bulk_data *clks)
779 {
780         return 0;
781 }
782 
783 static inline int __must_check devm_clk_bulk_get_optional(struct device *dev,
784                                 int num_clks, struct clk_bulk_data *clks)
785 {
786         return 0;
787 }
788 
789 static inline int __must_check devm_clk_bulk_get_all(struct device *dev,
790                                                      struct clk_bulk_data **clks)
791 {
792 
793         return 0;
794 }
795 
796 static inline struct clk *devm_get_clk_from_child(struct device *dev,
797                                 struct device_node *np, const char *con_id)
798 {
799         return NULL;
800 }
801 
802 static inline void clk_put(struct clk *clk) {}
803 
804 static inline void clk_bulk_put(int num_clks, struct clk_bulk_data *clks) {}
805 
806 static inline void clk_bulk_put_all(int num_clks, struct clk_bulk_data *clks) {}
807 
808 static inline void devm_clk_put(struct device *dev, struct clk *clk) {}
809 
810 
811 static inline int clk_rate_exclusive_get(struct clk *clk)
812 {
813         return 0;
814 }
815 
816 static inline void clk_rate_exclusive_put(struct clk *clk) {}
817 
818 static inline int clk_enable(struct clk *clk)
819 {
820         return 0;
821 }
822 
823 static inline int __must_check clk_bulk_enable(int num_clks, struct clk_bulk_data *clks)
824 {
825         return 0;
826 }
827 
828 static inline void clk_disable(struct clk *clk) {}
829 
830 
831 static inline void clk_bulk_disable(int num_clks,
832                                     struct clk_bulk_data *clks) {}
833 
834 static inline unsigned long clk_get_rate(struct clk *clk)
835 {
836         return 0;
837 }
838 
839 static inline int clk_set_rate(struct clk *clk, unsigned long rate)
840 {
841         return 0;
842 }
843 
844 static inline int clk_set_rate_exclusive(struct clk *clk, unsigned long rate)
845 {
846         return 0;
847 }
848 
849 static inline long clk_round_rate(struct clk *clk, unsigned long rate)
850 {
851         return 0;
852 }
853 
854 static inline bool clk_has_parent(struct clk *clk, struct clk *parent)
855 {
856         return true;
857 }
858 
859 static inline int clk_set_rate_range(struct clk *clk, unsigned long min,
860                                      unsigned long max)
861 {
862         return 0;
863 }
864 
865 static inline int clk_set_min_rate(struct clk *clk, unsigned long rate)
866 {
867         return 0;
868 }
869 
870 static inline int clk_set_max_rate(struct clk *clk, unsigned long rate)
871 {
872         return 0;
873 }
874 
875 static inline int clk_set_parent(struct clk *clk, struct clk *parent)
876 {
877         return 0;
878 }
879 
880 static inline struct clk *clk_get_parent(struct clk *clk)
881 {
882         return NULL;
883 }
884 
885 static inline struct clk *clk_get_sys(const char *dev_id, const char *con_id)
886 {
887         return NULL;
888 }
889 
890 static inline int clk_save_context(void)
891 {
892         return 0;
893 }
894 
895 static inline void clk_restore_context(void) {}
896 
897 #endif
898 
899 /* clk_prepare_enable helps cases using clk_enable in non-atomic context. */
900 static inline int clk_prepare_enable(struct clk *clk)
901 {
902         int ret;
903 
904         ret = clk_prepare(clk);
905         if (ret)
906                 return ret;
907         ret = clk_enable(clk);
908         if (ret)
909                 clk_unprepare(clk);
910 
911         return ret;
912 }
913 
914 /* clk_disable_unprepare helps cases using clk_disable in non-atomic context. */
915 static inline void clk_disable_unprepare(struct clk *clk)
916 {
917         clk_disable(clk);
918         clk_unprepare(clk);
919 }
920 
921 static inline int __must_check clk_bulk_prepare_enable(int num_clks,
922                                         struct clk_bulk_data *clks)
923 {
924         int ret;
925 
926         ret = clk_bulk_prepare(num_clks, clks);
927         if (ret)
928                 return ret;
929         ret = clk_bulk_enable(num_clks, clks);
930         if (ret)
931                 clk_bulk_unprepare(num_clks, clks);
932 
933         return ret;
934 }
935 
936 static inline void clk_bulk_disable_unprepare(int num_clks,
937                                               struct clk_bulk_data *clks)
938 {
939         clk_bulk_disable(num_clks, clks);
940         clk_bulk_unprepare(num_clks, clks);
941 }
942 
943 /**
944  * clk_get_optional - lookup and obtain a reference to an optional clock
945  *                    producer.
946  * @dev: device for clock "consumer"
947  * @id: clock consumer ID
948  *
949  * Behaves the same as clk_get() except where there is no clock producer. In
950  * this case, instead of returning -ENOENT, the function returns NULL.
951  */
952 static inline struct clk *clk_get_optional(struct device *dev, const char *id)
953 {
954         struct clk *clk = clk_get(dev, id);
955 
956         if (clk == ERR_PTR(-ENOENT))
957                 return NULL;
958 
959         return clk;
960 }
961 
962 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
963 struct clk *of_clk_get(struct device_node *np, int index);
964 struct clk *of_clk_get_by_name(struct device_node *np, const char *name);
965 struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec);
966 #else
967 static inline struct clk *of_clk_get(struct device_node *np, int index)
968 {
969         return ERR_PTR(-ENOENT);
970 }
971 static inline struct clk *of_clk_get_by_name(struct device_node *np,
972                                              const char *name)
973 {
974         return ERR_PTR(-ENOENT);
975 }
976 static inline struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
977 {
978         return ERR_PTR(-ENOENT);
979 }
980 #endif
981 
982 #endif
983 

~ [ 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