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

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

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ 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.69 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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 struct clk;
 21 struct device_node;
 22 struct of_phandle_args;
 23 
 24 /**
 25  * DOC: clk notifier callback types
 26  *
 27  * PRE_RATE_CHANGE - called immediately before the clk rate is changed,
 28  *     to indicate that the rate change will proceed.  Drivers must
 29  *     immediately terminate any operations that will be affected by the
 30  *     rate change.  Callbacks may either return NOTIFY_DONE, NOTIFY_OK,
 31  *     NOTIFY_STOP or NOTIFY_BAD.
 32  *
 33  * ABORT_RATE_CHANGE: called if the rate change failed for some reason
 34  *     after PRE_RATE_CHANGE.  In this case, all registered notifiers on
 35  *     the clk will be called with ABORT_RATE_CHANGE. Callbacks must
 36  *     always return NOTIFY_DONE or NOTIFY_OK.
 37  *
 38  * POST_RATE_CHANGE - called after the clk rate change has successfully
 39  *     completed.  Callbacks must always return NOTIFY_DONE or NOTIFY_OK.
 40  *
 41  */
 42 #define PRE_RATE_CHANGE                 BIT(0)
 43 #define POST_RATE_CHANGE                BIT(1)
 44 #define ABORT_RATE_CHANGE               BIT(2)
 45 
 46 /**
 47  * struct clk_notifier - associate a clk with a notifier
 48  * @clk: struct clk * to associate the notifier with
 49  * @notifier_head: a blocking_notifier_head for this clk
 50  * @node: linked list pointers
 51  *
 52  * A list of struct clk_notifier is maintained by the notifier code.
 53  * An entry is created whenever code registers the first notifier on a
 54  * particular @clk.  Future notifiers on that @clk are added to the
 55  * @notifier_head.
 56  */
 57 struct clk_notifier {
 58         struct clk                      *clk;
 59         struct srcu_notifier_head       notifier_head;
 60         struct list_head                node;
 61 };
 62 
 63 /**
 64  * struct clk_notifier_data - rate data to pass to the notifier callback
 65  * @clk: struct clk * being changed
 66  * @old_rate: previous rate of this clk
 67  * @new_rate: new rate of this clk
 68  *
 69  * For a pre-notifier, old_rate is the clk's rate before this rate
 70  * change, and new_rate is what the rate will be in the future.  For a
 71  * post-notifier, old_rate and new_rate are both set to the clk's
 72  * current rate (this was done to optimize the implementation).
 73  */
 74 struct clk_notifier_data {
 75         struct clk              *clk;
 76         unsigned long           old_rate;
 77         unsigned long           new_rate;
 78 };
 79 
 80 /**
 81  * struct clk_bulk_data - Data used for bulk clk operations.
 82  *
 83  * @id: clock consumer ID
 84  * @clk: struct clk * to store the associated clock
 85  *
 86  * The CLK APIs provide a series of clk_bulk_() API calls as
 87  * a convenience to consumers which require multiple clks.  This
 88  * structure is used to manage data for these calls.
 89  */
 90 struct clk_bulk_data {
 91         const char              *id;
 92         struct clk              *clk;
 93 };
 94 
 95 #ifdef CONFIG_COMMON_CLK
 96 
 97 /**
 98  * clk_notifier_register: register a clock rate-change notifier callback
 99  * @clk: clock whose rate we are interested in
100  * @nb: notifier block with callback function pointer
101  *
102  * ProTip: debugging across notifier chains can be frustrating. Make sure that
103  * your notifier callback function prints a nice big warning in case of
104  * failure.
105  */
106 int clk_notifier_register(struct clk *clk, struct notifier_block *nb);
107 
108 /**
109  * clk_notifier_unregister: unregister a clock rate-change notifier callback
110  * @clk: clock whose rate we are no longer interested in
111  * @nb: notifier block which will be unregistered
112  */
113 int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb);
114 
115 /**
116  * clk_get_accuracy - obtain the clock accuracy in ppb (parts per billion)
117  *                    for a clock source.
118  * @clk: clock source
119  *
120  * This gets the clock source accuracy expressed in ppb.
121  * A perfect clock returns 0.
122  */
123 long clk_get_accuracy(struct clk *clk);
124 
125 /**
126  * clk_set_phase - adjust the phase shift of a clock signal
127  * @clk: clock signal source
128  * @degrees: number of degrees the signal is shifted
129  *
130  * Shifts the phase of a clock signal by the specified degrees. Returns 0 on
131  * success, -EERROR otherwise.
132  */
133 int clk_set_phase(struct clk *clk, int degrees);
134 
135 /**
136  * clk_get_phase - return the phase shift of a clock signal
137  * @clk: clock signal source
138  *
139  * Returns the phase shift of a clock node in degrees, otherwise returns
140  * -EERROR.
141  */
142 int clk_get_phase(struct clk *clk);
143 
144 /**
145  * clk_is_match - check if two clk's point to the same hardware clock
146  * @p: clk compared against q
147  * @q: clk compared against p
148  *
149  * Returns true if the two struct clk pointers both point to the same hardware
150  * clock node. Put differently, returns true if @p and @q
151  * share the same &struct clk_core object.
152  *
153  * Returns false otherwise. Note that two NULL clks are treated as matching.
154  */
155 bool clk_is_match(const struct clk *p, const struct clk *q);
156 
157 #else
158 
159 static inline int clk_notifier_register(struct clk *clk,
160                                         struct notifier_block *nb)
161 {
162         return -ENOTSUPP;
163 }
164 
165 static inline int clk_notifier_unregister(struct clk *clk,
166                                           struct notifier_block *nb)
167 {
168         return -ENOTSUPP;
169 }
170 
171 static inline long clk_get_accuracy(struct clk *clk)
172 {
173         return -ENOTSUPP;
174 }
175 
176 static inline long clk_set_phase(struct clk *clk, int phase)
177 {
178         return -ENOTSUPP;
179 }
180 
181 static inline long clk_get_phase(struct clk *clk)
182 {
183         return -ENOTSUPP;
184 }
185 
186 static inline bool clk_is_match(const struct clk *p, const struct clk *q)
187 {
188         return p == q;
189 }
190 
191 #endif
192 
193 /**
194  * clk_prepare - prepare a clock source
195  * @clk: clock source
196  *
197  * This prepares the clock source for use.
198  *
199  * Must not be called from within atomic context.
200  */
201 #ifdef CONFIG_HAVE_CLK_PREPARE
202 int clk_prepare(struct clk *clk);
203 int __must_check clk_bulk_prepare(int num_clks,
204                                   const struct clk_bulk_data *clks);
205 #else
206 static inline int clk_prepare(struct clk *clk)
207 {
208         might_sleep();
209         return 0;
210 }
211 
212 static inline int clk_bulk_prepare(int num_clks, struct clk_bulk_data *clks)
213 {
214         might_sleep();
215         return 0;
216 }
217 #endif
218 
219 /**
220  * clk_unprepare - undo preparation of a clock source
221  * @clk: clock source
222  *
223  * This undoes a previously prepared clock.  The caller must balance
224  * the number of prepare and unprepare calls.
225  *
226  * Must not be called from within atomic context.
227  */
228 #ifdef CONFIG_HAVE_CLK_PREPARE
229 void clk_unprepare(struct clk *clk);
230 void clk_bulk_unprepare(int num_clks, const struct clk_bulk_data *clks);
231 #else
232 static inline void clk_unprepare(struct clk *clk)
233 {
234         might_sleep();
235 }
236 static inline void clk_bulk_unprepare(int num_clks, struct clk_bulk_data *clks)
237 {
238         might_sleep();
239 }
240 #endif
241 
242 #ifdef CONFIG_HAVE_CLK
243 /**
244  * clk_get - lookup and obtain a reference to a clock producer.
245  * @dev: device for clock "consumer"
246  * @id: clock consumer ID
247  *
248  * Returns a struct clk corresponding to the clock producer, or
249  * valid IS_ERR() condition containing errno.  The implementation
250  * uses @dev and @id to determine the clock consumer, and thereby
251  * the clock producer.  (IOW, @id may be identical strings, but
252  * clk_get may return different clock producers depending on @dev.)
253  *
254  * Drivers must assume that the clock source is not enabled.
255  *
256  * clk_get should not be called from within interrupt context.
257  */
258 struct clk *clk_get(struct device *dev, const char *id);
259 
260 /**
261  * clk_bulk_get - lookup and obtain a number of references to clock producer.
262  * @dev: device for clock "consumer"
263  * @num_clks: the number of clk_bulk_data
264  * @clks: the clk_bulk_data table of consumer
265  *
266  * This helper function allows drivers to get several clk consumers in one
267  * operation. If any of the clk cannot be acquired then any clks
268  * that were obtained will be freed before returning to the caller.
269  *
270  * Returns 0 if all clocks specified in clk_bulk_data table are obtained
271  * successfully, or valid IS_ERR() condition containing errno.
272  * The implementation uses @dev and @clk_bulk_data.id to determine the
273  * clock consumer, and thereby the clock producer.
274  * The clock returned is stored in each @clk_bulk_data.clk field.
275  *
276  * Drivers must assume that the clock source is not enabled.
277  *
278  * clk_bulk_get should not be called from within interrupt context.
279  */
280 int __must_check clk_bulk_get(struct device *dev, int num_clks,
281                               struct clk_bulk_data *clks);
282 
283 /**
284  * devm_clk_bulk_get - managed get multiple clk consumers
285  * @dev: device for clock "consumer"
286  * @num_clks: the number of clk_bulk_data
287  * @clks: the clk_bulk_data table of consumer
288  *
289  * Return 0 on success, an errno on failure.
290  *
291  * This helper function allows drivers to get several clk
292  * consumers in one operation with management, the clks will
293  * automatically be freed when the device is unbound.
294  */
295 int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
296                                    struct clk_bulk_data *clks);
297 
298 /**
299  * devm_clk_get - lookup and obtain a managed reference to a clock producer.
300  * @dev: device for clock "consumer"
301  * @id: clock consumer ID
302  *
303  * Returns a struct clk corresponding to the clock producer, or
304  * valid IS_ERR() condition containing errno.  The implementation
305  * uses @dev and @id to determine the clock consumer, and thereby
306  * the clock producer.  (IOW, @id may be identical strings, but
307  * clk_get may return different clock producers depending on @dev.)
308  *
309  * Drivers must assume that the clock source is not enabled.
310  *
311  * devm_clk_get should not be called from within interrupt context.
312  *
313  * The clock will automatically be freed when the device is unbound
314  * from the bus.
315  */
316 struct clk *devm_clk_get(struct device *dev, const char *id);
317 
318 /**
319  * devm_get_clk_from_child - lookup and obtain a managed reference to a
320  *                           clock producer from child node.
321  * @dev: device for clock "consumer"
322  * @np: pointer to clock consumer node
323  * @con_id: clock consumer ID
324  *
325  * This function parses the clocks, and uses them to look up the
326  * struct clk from the registered list of clock providers by using
327  * @np and @con_id
328  *
329  * The clock will automatically be freed when the device is unbound
330  * from the bus.
331  */
332 struct clk *devm_get_clk_from_child(struct device *dev,
333                                     struct device_node *np, const char *con_id);
334 /**
335  * clk_rate_exclusive_get - get exclusivity over the rate control of a
336  *                          producer
337  * @clk: clock source
338  *
339  * This function allows drivers to get exclusive control over the rate of a
340  * provider. It prevents any other consumer to execute, even indirectly,
341  * opereation which could alter the rate of the provider or cause glitches
342  *
343  * If exlusivity is claimed more than once on clock, even by the same driver,
344  * the rate effectively gets locked as exclusivity can't be preempted.
345  *
346  * Must not be called from within atomic context.
347  *
348  * Returns success (0) or negative errno.
349  */
350 int clk_rate_exclusive_get(struct clk *clk);
351 
352 /**
353  * clk_rate_exclusive_put - release exclusivity over the rate control of a
354  *                          producer
355  * @clk: clock source
356  *
357  * This function allows drivers to release the exclusivity it previously got
358  * from clk_rate_exclusive_get()
359  *
360  * The caller must balance the number of clk_rate_exclusive_get() and
361  * clk_rate_exclusive_put() calls.
362  *
363  * Must not be called from within atomic context.
364  */
365 void clk_rate_exclusive_put(struct clk *clk);
366 
367 /**
368  * clk_enable - inform the system when the clock source should be running.
369  * @clk: clock source
370  *
371  * If the clock can not be enabled/disabled, this should return success.
372  *
373  * May be called from atomic contexts.
374  *
375  * Returns success (0) or negative errno.
376  */
377 int clk_enable(struct clk *clk);
378 
379 /**
380  * clk_bulk_enable - inform the system when the set of clks should be running.
381  * @num_clks: the number of clk_bulk_data
382  * @clks: the clk_bulk_data table of consumer
383  *
384  * May be called from atomic contexts.
385  *
386  * Returns success (0) or negative errno.
387  */
388 int __must_check clk_bulk_enable(int num_clks,
389                                  const struct clk_bulk_data *clks);
390 
391 /**
392  * clk_disable - inform the system when the clock source is no longer required.
393  * @clk: clock source
394  *
395  * Inform the system that a clock source is no longer required by
396  * a driver and may be shut down.
397  *
398  * May be called from atomic contexts.
399  *
400  * Implementation detail: if the clock source is shared between
401  * multiple drivers, clk_enable() calls must be balanced by the
402  * same number of clk_disable() calls for the clock source to be
403  * disabled.
404  */
405 void clk_disable(struct clk *clk);
406 
407 /**
408  * clk_bulk_disable - inform the system when the set of clks is no
409  *                    longer required.
410  * @num_clks: the number of clk_bulk_data
411  * @clks: the clk_bulk_data table of consumer
412  *
413  * Inform the system that a set of clks is no longer required by
414  * a driver and may be shut down.
415  *
416  * May be called from atomic contexts.
417  *
418  * Implementation detail: if the set of clks is shared between
419  * multiple drivers, clk_bulk_enable() calls must be balanced by the
420  * same number of clk_bulk_disable() calls for the clock source to be
421  * disabled.
422  */
423 void clk_bulk_disable(int num_clks, const struct clk_bulk_data *clks);
424 
425 /**
426  * clk_get_rate - obtain the current clock rate (in Hz) for a clock source.
427  *                This is only valid once the clock source has been enabled.
428  * @clk: clock source
429  */
430 unsigned long clk_get_rate(struct clk *clk);
431 
432 /**
433  * clk_put      - "free" the clock source
434  * @clk: clock source
435  *
436  * Note: drivers must ensure that all clk_enable calls made on this
437  * clock source are balanced by clk_disable calls prior to calling
438  * this function.
439  *
440  * clk_put should not be called from within interrupt context.
441  */
442 void clk_put(struct clk *clk);
443 
444 /**
445  * clk_bulk_put - "free" the clock source
446  * @num_clks: the number of clk_bulk_data
447  * @clks: the clk_bulk_data table of consumer
448  *
449  * Note: drivers must ensure that all clk_bulk_enable calls made on this
450  * clock source are balanced by clk_bulk_disable calls prior to calling
451  * this function.
452  *
453  * clk_bulk_put should not be called from within interrupt context.
454  */
455 void clk_bulk_put(int num_clks, struct clk_bulk_data *clks);
456 
457 /**
458  * devm_clk_put - "free" a managed clock source
459  * @dev: device used to acquire the clock
460  * @clk: clock source acquired with devm_clk_get()
461  *
462  * Note: drivers must ensure that all clk_enable calls made on this
463  * clock source are balanced by clk_disable calls prior to calling
464  * this function.
465  *
466  * clk_put should not be called from within interrupt context.
467  */
468 void devm_clk_put(struct device *dev, struct clk *clk);
469 
470 /*
471  * The remaining APIs are optional for machine class support.
472  */
473 
474 
475 /**
476  * clk_round_rate - adjust a rate to the exact rate a clock can provide
477  * @clk: clock source
478  * @rate: desired clock rate in Hz
479  *
480  * This answers the question "if I were to pass @rate to clk_set_rate(),
481  * what clock rate would I end up with?" without changing the hardware
482  * in any way.  In other words:
483  *
484  *   rate = clk_round_rate(clk, r);
485  *
486  * and:
487  *
488  *   clk_set_rate(clk, r);
489  *   rate = clk_get_rate(clk);
490  *
491  * are equivalent except the former does not modify the clock hardware
492  * in any way.
493  *
494  * Returns rounded clock rate in Hz, or negative errno.
495  */
496 long clk_round_rate(struct clk *clk, unsigned long rate);
497 
498 /**
499  * clk_set_rate - set the clock rate for a clock source
500  * @clk: clock source
501  * @rate: desired clock rate in Hz
502  *
503  * Returns success (0) or negative errno.
504  */
505 int clk_set_rate(struct clk *clk, unsigned long rate);
506 
507 /**
508  * clk_set_rate_exclusive- set the clock rate and claim exclusivity over
509  *                         clock source
510  * @clk: clock source
511  * @rate: desired clock rate in Hz
512  *
513  * This helper function allows drivers to atomically set the rate of a producer
514  * and claim exclusivity over the rate control of the producer.
515  *
516  * It is essentially a combination of clk_set_rate() and
517  * clk_rate_exclusite_get(). Caller must balance this call with a call to
518  * clk_rate_exclusive_put()
519  *
520  * Returns success (0) or negative errno.
521  */
522 int clk_set_rate_exclusive(struct clk *clk, unsigned long rate);
523 
524 /**
525  * clk_has_parent - check if a clock is a possible parent for another
526  * @clk: clock source
527  * @parent: parent clock source
528  *
529  * This function can be used in drivers that need to check that a clock can be
530  * the parent of another without actually changing the parent.
531  *
532  * Returns true if @parent is a possible parent for @clk, false otherwise.
533  */
534 bool clk_has_parent(struct clk *clk, struct clk *parent);
535 
536 /**
537  * clk_set_rate_range - set a rate range for a clock source
538  * @clk: clock source
539  * @min: desired minimum clock rate in Hz, inclusive
540  * @max: desired maximum clock rate in Hz, inclusive
541  *
542  * Returns success (0) or negative errno.
543  */
544 int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max);
545 
546 /**
547  * clk_set_min_rate - set a minimum clock rate for a clock source
548  * @clk: clock source
549  * @rate: desired minimum clock rate in Hz, inclusive
550  *
551  * Returns success (0) or negative errno.
552  */
553 int clk_set_min_rate(struct clk *clk, unsigned long rate);
554 
555 /**
556  * clk_set_max_rate - set a maximum clock rate for a clock source
557  * @clk: clock source
558  * @rate: desired maximum clock rate in Hz, inclusive
559  *
560  * Returns success (0) or negative errno.
561  */
562 int clk_set_max_rate(struct clk *clk, unsigned long rate);
563 
564 /**
565  * clk_set_parent - set the parent clock source for this clock
566  * @clk: clock source
567  * @parent: parent clock source
568  *
569  * Returns success (0) or negative errno.
570  */
571 int clk_set_parent(struct clk *clk, struct clk *parent);
572 
573 /**
574  * clk_get_parent - get the parent clock source for this clock
575  * @clk: clock source
576  *
577  * Returns struct clk corresponding to parent clock source, or
578  * valid IS_ERR() condition containing errno.
579  */
580 struct clk *clk_get_parent(struct clk *clk);
581 
582 /**
583  * clk_get_sys - get a clock based upon the device name
584  * @dev_id: device name
585  * @con_id: connection ID
586  *
587  * Returns a struct clk corresponding to the clock producer, or
588  * valid IS_ERR() condition containing errno.  The implementation
589  * uses @dev_id and @con_id to determine the clock consumer, and
590  * thereby the clock producer. In contrast to clk_get() this function
591  * takes the device name instead of the device itself for identification.
592  *
593  * Drivers must assume that the clock source is not enabled.
594  *
595  * clk_get_sys should not be called from within interrupt context.
596  */
597 struct clk *clk_get_sys(const char *dev_id, const char *con_id);
598 
599 #else /* !CONFIG_HAVE_CLK */
600 
601 static inline struct clk *clk_get(struct device *dev, const char *id)
602 {
603         return NULL;
604 }
605 
606 static inline int clk_bulk_get(struct device *dev, int num_clks,
607                                struct clk_bulk_data *clks)
608 {
609         return 0;
610 }
611 
612 static inline struct clk *devm_clk_get(struct device *dev, const char *id)
613 {
614         return NULL;
615 }
616 
617 static inline int devm_clk_bulk_get(struct device *dev, int num_clks,
618                                     struct clk_bulk_data *clks)
619 {
620         return 0;
621 }
622 
623 static inline struct clk *devm_get_clk_from_child(struct device *dev,
624                                 struct device_node *np, const char *con_id)
625 {
626         return NULL;
627 }
628 
629 static inline void clk_put(struct clk *clk) {}
630 
631 static inline void clk_bulk_put(int num_clks, struct clk_bulk_data *clks) {}
632 
633 static inline void devm_clk_put(struct device *dev, struct clk *clk) {}
634 
635 
636 static inline int clk_rate_exclusive_get(struct clk *clk)
637 {
638         return 0;
639 }
640 
641 static inline void clk_rate_exclusive_put(struct clk *clk) {}
642 
643 static inline int clk_enable(struct clk *clk)
644 {
645         return 0;
646 }
647 
648 static inline int clk_bulk_enable(int num_clks, struct clk_bulk_data *clks)
649 {
650         return 0;
651 }
652 
653 static inline void clk_disable(struct clk *clk) {}
654 
655 
656 static inline void clk_bulk_disable(int num_clks,
657                                     struct clk_bulk_data *clks) {}
658 
659 static inline unsigned long clk_get_rate(struct clk *clk)
660 {
661         return 0;
662 }
663 
664 static inline int clk_set_rate(struct clk *clk, unsigned long rate)
665 {
666         return 0;
667 }
668 
669 static inline int clk_set_rate_exclusive(struct clk *clk, unsigned long rate)
670 {
671         return 0;
672 }
673 
674 static inline long clk_round_rate(struct clk *clk, unsigned long rate)
675 {
676         return 0;
677 }
678 
679 static inline bool clk_has_parent(struct clk *clk, struct clk *parent)
680 {
681         return true;
682 }
683 
684 static inline int clk_set_parent(struct clk *clk, struct clk *parent)
685 {
686         return 0;
687 }
688 
689 static inline struct clk *clk_get_parent(struct clk *clk)
690 {
691         return NULL;
692 }
693 
694 static inline struct clk *clk_get_sys(const char *dev_id, const char *con_id)
695 {
696         return NULL;
697 }
698 #endif
699 
700 /* clk_prepare_enable helps cases using clk_enable in non-atomic context. */
701 static inline int clk_prepare_enable(struct clk *clk)
702 {
703         int ret;
704 
705         ret = clk_prepare(clk);
706         if (ret)
707                 return ret;
708         ret = clk_enable(clk);
709         if (ret)
710                 clk_unprepare(clk);
711 
712         return ret;
713 }
714 
715 /* clk_disable_unprepare helps cases using clk_disable in non-atomic context. */
716 static inline void clk_disable_unprepare(struct clk *clk)
717 {
718         clk_disable(clk);
719         clk_unprepare(clk);
720 }
721 
722 static inline int clk_bulk_prepare_enable(int num_clks,
723                                           struct clk_bulk_data *clks)
724 {
725         int ret;
726 
727         ret = clk_bulk_prepare(num_clks, clks);
728         if (ret)
729                 return ret;
730         ret = clk_bulk_enable(num_clks, clks);
731         if (ret)
732                 clk_bulk_unprepare(num_clks, clks);
733 
734         return ret;
735 }
736 
737 static inline void clk_bulk_disable_unprepare(int num_clks,
738                                               struct clk_bulk_data *clks)
739 {
740         clk_bulk_disable(num_clks, clks);
741         clk_bulk_unprepare(num_clks, clks);
742 }
743 
744 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
745 struct clk *of_clk_get(struct device_node *np, int index);
746 struct clk *of_clk_get_by_name(struct device_node *np, const char *name);
747 struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec);
748 #else
749 static inline struct clk *of_clk_get(struct device_node *np, int index)
750 {
751         return ERR_PTR(-ENOENT);
752 }
753 static inline struct clk *of_clk_get_by_name(struct device_node *np,
754                                              const char *name)
755 {
756         return ERR_PTR(-ENOENT);
757 }
758 static inline struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
759 {
760         return ERR_PTR(-ENOENT);
761 }
762 #endif
763 
764 #endif
765 

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