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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.