2 * linux/arch/arm/mach-omap2/clock.c
4 * Copyright (C) 2005-2008 Texas Instruments, Inc.
5 * Copyright (C) 2004-2010 Nokia Corporation
8 * Richard Woodruff <r-woodruff2@ti.com>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
17 #include <linux/kernel.h>
18 #include <linux/export.h>
19 #include <linux/list.h>
20 #include <linux/errno.h>
21 #include <linux/err.h>
22 #include <linux/delay.h>
23 #include <linux/clk.h>
25 #include <linux/bitops.h>
30 #include <trace/events/power.h>
33 #include "clockdomain.h"
38 #include "cm-regbits-24xx.h"
39 #include "cm-regbits-34xx.h"
43 * MAX_MODULE_ENABLE_WAIT: maximum of number of microseconds to wait
44 * for a module to indicate that it is no longer in idle
46 #define MAX_MODULE_ENABLE_WAIT 100000
51 * clkdm_control: if true, then when a clock is enabled in the
52 * hardware, its clockdomain will first be enabled; and when a clock
53 * is disabled in the hardware, its clockdomain will be disabled
56 static bool clkdm_control
= true;
58 static LIST_HEAD(clocks
);
59 static DEFINE_MUTEX(clocks_mutex
);
60 static DEFINE_SPINLOCK(clockfw_lock
);
63 * OMAP2+ specific clock functions
66 /* Private functions */
70 * _wait_idlest_generic - wait for a module to leave the idle state
71 * @reg: virtual address of module IDLEST register
72 * @mask: value to mask against to determine if the module is active
73 * @idlest: idle state indicator (0 or 1) for the clock
74 * @name: name of the clock (for printk)
76 * Wait for a module to leave idle, where its idle-status register is
77 * not inside the CM module. Returns 1 if the module left idle
78 * promptly, or 0 if the module did not leave idle before the timeout
79 * elapsed. XXX Deprecated - should be moved into drivers for the
80 * individual IP block that the IDLEST register exists in.
82 static int _wait_idlest_generic(void __iomem
*reg
, u32 mask
, u8 idlest
,
87 ena
= (idlest
) ? 0 : mask
;
89 omap_test_timeout(((__raw_readl(reg
) & mask
) == ena
),
90 MAX_MODULE_ENABLE_WAIT
, i
);
92 if (i
< MAX_MODULE_ENABLE_WAIT
)
93 pr_debug("omap clock: module associated with clock %s ready after %d loops\n",
96 pr_err("omap clock: module associated with clock %s didn't enable in %d tries\n",
97 name
, MAX_MODULE_ENABLE_WAIT
);
99 return (i
< MAX_MODULE_ENABLE_WAIT
) ? 1 : 0;
103 * _omap2_module_wait_ready - wait for an OMAP module to leave IDLE
104 * @clk: struct clk * belonging to the module
106 * If the necessary clocks for the OMAP hardware IP block that
107 * corresponds to clock @clk are enabled, then wait for the module to
108 * indicate readiness (i.e., to leave IDLE). This code does not
109 * belong in the clock code and will be moved in the medium term to
110 * module-dependent code. No return value.
112 static void _omap2_module_wait_ready(struct clk
*clk
)
114 void __iomem
*companion_reg
, *idlest_reg
;
115 u8 other_bit
, idlest_bit
, idlest_val
, idlest_reg_id
;
119 /* Not all modules have multiple clocks that their IDLEST depends on */
120 if (clk
->ops
->find_companion
) {
121 clk
->ops
->find_companion(clk
, &companion_reg
, &other_bit
);
122 if (!(__raw_readl(companion_reg
) & (1 << other_bit
)))
126 clk
->ops
->find_idlest(clk
, &idlest_reg
, &idlest_bit
, &idlest_val
);
128 r
= cm_split_idlest_reg(idlest_reg
, &prcm_mod
, &idlest_reg_id
);
130 /* IDLEST register not in the CM module */
131 _wait_idlest_generic(idlest_reg
, (1 << idlest_bit
), idlest_val
,
134 cm_wait_module_ready(prcm_mod
, idlest_reg_id
, idlest_bit
);
138 /* Public functions */
141 * omap2_init_clk_clkdm - look up a clockdomain name, store pointer in clk
142 * @clk: OMAP clock struct ptr to use
144 * Convert a clockdomain name stored in a struct clk 'clk' into a
145 * clockdomain pointer, and save it into the struct clk. Intended to be
146 * called during clk_register(). No return value.
148 void omap2_init_clk_clkdm(struct clk
*clk
)
150 struct clockdomain
*clkdm
;
151 const char *clk_name
;
153 if (!clk
->clkdm_name
)
156 clk_name
= __clk_get_name(clk
);
158 clkdm
= clkdm_lookup(clk
->clkdm_name
);
160 pr_debug("clock: associated clk %s to clkdm %s\n",
161 clk_name
, clk
->clkdm_name
);
164 pr_debug("clock: could not associate clk %s to clkdm %s\n",
165 clk_name
, clk
->clkdm_name
);
170 * omap2_clk_disable_clkdm_control - disable clkdm control on clk enable/disable
172 * Prevent the OMAP clock code from calling into the clockdomain code
173 * when a hardware clock in that clockdomain is enabled or disabled.
174 * Intended to be called at init time from omap*_clk_init(). No
177 void __init
omap2_clk_disable_clkdm_control(void)
179 clkdm_control
= false;
183 * omap2_clk_dflt_find_companion - find companion clock to @clk
184 * @clk: struct clk * to find the companion clock of
185 * @other_reg: void __iomem ** to return the companion clock CM_*CLKEN va in
186 * @other_bit: u8 ** to return the companion clock bit shift in
188 * Note: We don't need special code here for INVERT_ENABLE for the
189 * time being since INVERT_ENABLE only applies to clocks enabled by
192 * Convert CM_ICLKEN* <-> CM_FCLKEN*. This conversion assumes it's
193 * just a matter of XORing the bits.
195 * Some clocks don't have companion clocks. For example, modules with
196 * only an interface clock (such as MAILBOXES) don't have a companion
197 * clock. Right now, this code relies on the hardware exporting a bit
198 * in the correct companion register that indicates that the
199 * nonexistent 'companion clock' is active. Future patches will
200 * associate this type of code with per-module data structures to
201 * avoid this issue, and remove the casts. No return value.
203 void omap2_clk_dflt_find_companion(struct clk
*clk
, void __iomem
**other_reg
,
209 * Convert CM_ICLKEN* <-> CM_FCLKEN*. This conversion assumes
210 * it's just a matter of XORing the bits.
212 r
= ((__force u32
)clk
->enable_reg
^ (CM_FCLKEN
^ CM_ICLKEN
));
214 *other_reg
= (__force
void __iomem
*)r
;
215 *other_bit
= clk
->enable_bit
;
219 * omap2_clk_dflt_find_idlest - find CM_IDLEST reg va, bit shift for @clk
220 * @clk: struct clk * to find IDLEST info for
221 * @idlest_reg: void __iomem ** to return the CM_IDLEST va in
222 * @idlest_bit: u8 * to return the CM_IDLEST bit shift in
223 * @idlest_val: u8 * to return the idle status indicator
225 * Return the CM_IDLEST register address and bit shift corresponding
226 * to the module that "owns" this clock. This default code assumes
227 * that the CM_IDLEST bit shift is the CM_*CLKEN bit shift, and that
228 * the IDLEST register address ID corresponds to the CM_*CLKEN
229 * register address ID (e.g., that CM_FCLKEN2 corresponds to
230 * CM_IDLEST2). This is not true for all modules. No return value.
232 void omap2_clk_dflt_find_idlest(struct clk
*clk
, void __iomem
**idlest_reg
,
233 u8
*idlest_bit
, u8
*idlest_val
)
237 r
= (((__force u32
)clk
->enable_reg
& ~0xf0) | 0x20);
238 *idlest_reg
= (__force
void __iomem
*)r
;
239 *idlest_bit
= clk
->enable_bit
;
242 * 24xx uses 0 to indicate not ready, and 1 to indicate ready.
243 * 34xx reverses this, just to keep us on our toes
244 * AM35xx uses both, depending on the module.
246 if (cpu_is_omap24xx())
247 *idlest_val
= OMAP24XX_CM_IDLEST_VAL
;
248 else if (cpu_is_omap34xx())
249 *idlest_val
= OMAP34XX_CM_IDLEST_VAL
;
255 int omap2_dflt_clk_enable(struct clk
*clk
)
259 if (unlikely(clk
->enable_reg
== NULL
)) {
260 pr_err("clock.c: Enable for %s without enable code\n",
262 return 0; /* REVISIT: -EINVAL */
265 v
= __raw_readl(clk
->enable_reg
);
266 if (clk
->flags
& INVERT_ENABLE
)
267 v
&= ~(1 << clk
->enable_bit
);
269 v
|= (1 << clk
->enable_bit
);
270 __raw_writel(v
, clk
->enable_reg
);
271 v
= __raw_readl(clk
->enable_reg
); /* OCP barrier */
273 if (clk
->ops
->find_idlest
)
274 _omap2_module_wait_ready(clk
);
279 void omap2_dflt_clk_disable(struct clk
*clk
)
283 if (!clk
->enable_reg
) {
285 * 'Independent' here refers to a clock which is not
286 * controlled by its parent.
288 pr_err("clock: clk_disable called on independent clock %s which has no enable_reg\n", clk
->name
);
292 v
= __raw_readl(clk
->enable_reg
);
293 if (clk
->flags
& INVERT_ENABLE
)
294 v
|= (1 << clk
->enable_bit
);
296 v
&= ~(1 << clk
->enable_bit
);
297 __raw_writel(v
, clk
->enable_reg
);
298 /* No OCP barrier needed here since it is a disable operation */
301 const struct clkops clkops_omap2_dflt_wait
= {
302 .enable
= omap2_dflt_clk_enable
,
303 .disable
= omap2_dflt_clk_disable
,
304 .find_companion
= omap2_clk_dflt_find_companion
,
305 .find_idlest
= omap2_clk_dflt_find_idlest
,
308 const struct clkops clkops_omap2_dflt
= {
309 .enable
= omap2_dflt_clk_enable
,
310 .disable
= omap2_dflt_clk_disable
,
314 * omap2_clk_disable - disable a clock, if the system is not using it
315 * @clk: struct clk * to disable
317 * Decrements the usecount on struct clk @clk. If there are no users
318 * left, call the clkops-specific clock disable function to disable it
319 * in hardware. If the clock is part of a clockdomain (which they all
320 * should be), request that the clockdomain be disabled. (It too has
321 * a usecount, and so will not be disabled in the hardware until it no
322 * longer has any users.) If the clock has a parent clock (most of
323 * them do), then call ourselves, recursing on the parent clock. This
324 * can cause an entire branch of the clock tree to be powered off by
325 * simply disabling one clock. Intended to be called with the clockfw_lock
326 * spinlock held. No return value.
328 void omap2_clk_disable(struct clk
*clk
)
330 if (clk
->usecount
== 0) {
331 WARN(1, "clock: %s: omap2_clk_disable() called, but usecount already 0?", clk
->name
);
335 pr_debug("clock: %s: decrementing usecount\n", clk
->name
);
339 if (clk
->usecount
> 0)
342 pr_debug("clock: %s: disabling in hardware\n", clk
->name
);
344 if (clk
->ops
&& clk
->ops
->disable
) {
345 trace_clock_disable(clk
->name
, 0, smp_processor_id());
346 clk
->ops
->disable(clk
);
349 if (clkdm_control
&& clk
->clkdm
)
350 clkdm_clk_disable(clk
->clkdm
, clk
);
353 omap2_clk_disable(clk
->parent
);
357 * omap2_clk_enable - request that the system enable a clock
358 * @clk: struct clk * to enable
360 * Increments the usecount on struct clk @clk. If there were no users
361 * previously, then recurse up the clock tree, enabling all of the
362 * clock's parents and all of the parent clockdomains, and finally,
363 * enabling @clk's clockdomain, and @clk itself. Intended to be
364 * called with the clockfw_lock spinlock held. Returns 0 upon success
365 * or a negative error code upon failure.
367 int omap2_clk_enable(struct clk
*clk
)
371 pr_debug("clock: %s: incrementing usecount\n", clk
->name
);
375 if (clk
->usecount
> 1)
378 pr_debug("clock: %s: enabling in hardware\n", clk
->name
);
381 ret
= omap2_clk_enable(clk
->parent
);
383 WARN(1, "clock: %s: could not enable parent %s: %d\n",
384 clk
->name
, clk
->parent
->name
, ret
);
389 if (clkdm_control
&& clk
->clkdm
) {
390 ret
= clkdm_clk_enable(clk
->clkdm
, clk
);
392 WARN(1, "clock: %s: could not enable clockdomain %s: %d\n",
393 clk
->name
, clk
->clkdm
->name
, ret
);
398 if (clk
->ops
&& clk
->ops
->enable
) {
399 trace_clock_enable(clk
->name
, 1, smp_processor_id());
400 ret
= clk
->ops
->enable(clk
);
402 WARN(1, "clock: %s: could not enable: %d\n",
411 if (clkdm_control
&& clk
->clkdm
)
412 clkdm_clk_disable(clk
->clkdm
, clk
);
415 omap2_clk_disable(clk
->parent
);
422 /* Given a clock and a rate apply a clock specific rounding function */
423 long omap2_clk_round_rate(struct clk
*clk
, unsigned long rate
)
426 return clk
->round_rate(clk
, rate
);
431 /* Set the clock rate for a clock source */
432 int omap2_clk_set_rate(struct clk
*clk
, unsigned long rate
)
436 pr_debug("clock: set_rate for clock %s to rate %ld\n", clk
->name
, rate
);
438 /* dpll_ck, core_ck, virt_prcm_set; plus all clksel clocks */
440 trace_clock_set_rate(clk
->name
, rate
, smp_processor_id());
441 ret
= clk
->set_rate(clk
, rate
);
447 int omap2_clk_set_parent(struct clk
*clk
, struct clk
*new_parent
)
452 if (clk
->parent
== new_parent
)
455 return omap2_clksel_set_parent(clk
, new_parent
);
459 * OMAP2+ clock reset and init functions
462 #ifdef CONFIG_OMAP_RESET_CLOCKS
463 void omap2_clk_disable_unused(struct clk
*clk
)
467 v
= (clk
->flags
& INVERT_ENABLE
) ? (1 << clk
->enable_bit
) : 0;
469 regval32
= __raw_readl(clk
->enable_reg
);
470 if ((regval32
& (1 << clk
->enable_bit
)) == v
)
473 pr_debug("Disabling unused clock \"%s\"\n", clk
->name
);
474 if (cpu_is_omap34xx()) {
475 omap2_clk_enable(clk
);
476 omap2_clk_disable(clk
);
478 clk
->ops
->disable(clk
);
480 if (clk
->clkdm
!= NULL
)
481 pwrdm_state_switch(clk
->clkdm
->pwrdm
.ptr
);
486 * omap2_clk_switch_mpurate_at_boot - switch ARM MPU rate by boot-time argument
487 * @mpurate_ck_name: clk name of the clock to change rate
489 * Change the ARM MPU clock rate to the rate specified on the command
490 * line, if one was specified. @mpurate_ck_name should be
491 * "virt_prcm_set" on OMAP2xxx and "dpll1_ck" on OMAP34xx/OMAP36xx.
492 * XXX Does not handle voltage scaling - on OMAP2xxx this is currently
493 * handled by the virt_prcm_set clock, but this should be handled by
494 * the OPP layer. XXX This is intended to be handled by the OPP layer
495 * code in the near future and should be removed from the clock code.
496 * Returns -EINVAL if 'mpurate' is zero or if clk_set_rate() rejects
497 * the rate, -ENOENT if the struct clk referred to by @mpurate_ck_name
498 * cannot be found, or 0 upon success.
500 int __init
omap2_clk_switch_mpurate_at_boot(const char *mpurate_ck_name
)
502 struct clk
*mpurate_ck
;
508 mpurate_ck
= clk_get(NULL
, mpurate_ck_name
);
509 if (WARN(IS_ERR(mpurate_ck
), "Failed to get %s.\n", mpurate_ck_name
))
512 r
= clk_set_rate(mpurate_ck
, mpurate
);
513 if (IS_ERR_VALUE(r
)) {
514 WARN(1, "clock: %s: unable to set MPU rate to %d: %d\n",
515 mpurate_ck
->name
, mpurate
, r
);
521 recalculate_root_clocks();
529 * omap2_clk_print_new_rates - print summary of current clock tree rates
530 * @hfclkin_ck_name: clk name for the off-chip HF oscillator
531 * @core_ck_name: clk name for the on-chip CORE_CLK
532 * @mpu_ck_name: clk name for the ARM MPU clock
534 * Prints a short message to the console with the HFCLKIN oscillator
535 * rate, the rate of the CORE clock, and the rate of the ARM MPU clock.
536 * Called by the boot-time MPU rate switching code. XXX This is intended
537 * to be handled by the OPP layer code in the near future and should be
538 * removed from the clock code. No return value.
540 void __init
omap2_clk_print_new_rates(const char *hfclkin_ck_name
,
541 const char *core_ck_name
,
542 const char *mpu_ck_name
)
544 struct clk
*hfclkin_ck
, *core_ck
, *mpu_ck
;
545 unsigned long hfclkin_rate
;
547 mpu_ck
= clk_get(NULL
, mpu_ck_name
);
548 if (WARN(IS_ERR(mpu_ck
), "clock: failed to get %s.\n", mpu_ck_name
))
551 core_ck
= clk_get(NULL
, core_ck_name
);
552 if (WARN(IS_ERR(core_ck
), "clock: failed to get %s.\n", core_ck_name
))
555 hfclkin_ck
= clk_get(NULL
, hfclkin_ck_name
);
556 if (WARN(IS_ERR(hfclkin_ck
), "Failed to get %s.\n", hfclkin_ck_name
))
559 hfclkin_rate
= clk_get_rate(hfclkin_ck
);
561 pr_info("Switched to new clocking rate (Crystal/Core/MPU): %ld.%01ld/%ld/%ld MHz\n",
562 (hfclkin_rate
/ 1000000), ((hfclkin_rate
/ 100000) % 10),
563 (clk_get_rate(core_ck
) / 1000000),
564 (clk_get_rate(mpu_ck
) / 1000000));
569 int clk_enable(struct clk
*clk
)
574 if (clk
== NULL
|| IS_ERR(clk
))
577 spin_lock_irqsave(&clockfw_lock
, flags
);
578 ret
= omap2_clk_enable(clk
);
579 spin_unlock_irqrestore(&clockfw_lock
, flags
);
583 EXPORT_SYMBOL(clk_enable
);
585 void clk_disable(struct clk
*clk
)
589 if (clk
== NULL
|| IS_ERR(clk
))
592 spin_lock_irqsave(&clockfw_lock
, flags
);
593 if (clk
->usecount
== 0) {
594 pr_err("Trying disable clock %s with 0 usecount\n",
600 omap2_clk_disable(clk
);
603 spin_unlock_irqrestore(&clockfw_lock
, flags
);
605 EXPORT_SYMBOL(clk_disable
);
607 unsigned long clk_get_rate(struct clk
*clk
)
612 if (clk
== NULL
|| IS_ERR(clk
))
615 spin_lock_irqsave(&clockfw_lock
, flags
);
617 spin_unlock_irqrestore(&clockfw_lock
, flags
);
621 EXPORT_SYMBOL(clk_get_rate
);
624 * Optional clock functions defined in include/linux/clk.h
627 long clk_round_rate(struct clk
*clk
, unsigned long rate
)
632 if (clk
== NULL
|| IS_ERR(clk
))
635 spin_lock_irqsave(&clockfw_lock
, flags
);
636 ret
= omap2_clk_round_rate(clk
, rate
);
637 spin_unlock_irqrestore(&clockfw_lock
, flags
);
641 EXPORT_SYMBOL(clk_round_rate
);
643 int clk_set_rate(struct clk
*clk
, unsigned long rate
)
648 if (clk
== NULL
|| IS_ERR(clk
))
651 spin_lock_irqsave(&clockfw_lock
, flags
);
652 ret
= omap2_clk_set_rate(clk
, rate
);
655 spin_unlock_irqrestore(&clockfw_lock
, flags
);
659 EXPORT_SYMBOL(clk_set_rate
);
661 int clk_set_parent(struct clk
*clk
, struct clk
*parent
)
666 if (clk
== NULL
|| IS_ERR(clk
) || parent
== NULL
|| IS_ERR(parent
))
669 spin_lock_irqsave(&clockfw_lock
, flags
);
670 if (clk
->usecount
== 0) {
671 ret
= omap2_clk_set_parent(clk
, parent
);
677 spin_unlock_irqrestore(&clockfw_lock
, flags
);
681 EXPORT_SYMBOL(clk_set_parent
);
683 struct clk
*clk_get_parent(struct clk
*clk
)
687 EXPORT_SYMBOL(clk_get_parent
);
690 * OMAP specific clock functions shared between omap1 and omap2
693 int __initdata mpurate
;
696 * By default we use the rate set by the bootloader.
697 * You can override this with mpurate= cmdline option.
699 static int __init
omap_clk_setup(char *str
)
701 get_option(&str
, &mpurate
);
711 __setup("mpurate=", omap_clk_setup
);
713 /* Used for clocks that always have same value as the parent clock */
714 unsigned long followparent_recalc(struct clk
*clk
)
716 return clk
->parent
->rate
;
720 * Used for clocks that have the same value as the parent clock,
721 * divided by some factor
723 unsigned long omap_fixed_divisor_recalc(struct clk
*clk
)
725 WARN_ON(!clk
->fixed_div
);
727 return clk
->parent
->rate
/ clk
->fixed_div
;
730 void clk_reparent(struct clk
*child
, struct clk
*parent
)
732 list_del_init(&child
->sibling
);
734 list_add(&child
->sibling
, &parent
->children
);
735 child
->parent
= parent
;
737 /* now do the debugfs renaming to reattach the child
738 to the proper parent */
741 /* Propagate rate to children */
742 void propagate_rate(struct clk
*tclk
)
746 list_for_each_entry(clkp
, &tclk
->children
, sibling
) {
748 clkp
->rate
= clkp
->recalc(clkp
);
749 propagate_rate(clkp
);
753 static LIST_HEAD(root_clks
);
756 * recalculate_root_clocks - recalculate and propagate all root clocks
758 * Recalculates all root clocks (clocks with no parent), which if the
759 * clock's .recalc is set correctly, should also propagate their rates.
762 void recalculate_root_clocks(void)
766 list_for_each_entry(clkp
, &root_clks
, sibling
) {
768 clkp
->rate
= clkp
->recalc(clkp
);
769 propagate_rate(clkp
);
774 * clk_preinit - initialize any fields in the struct clk before clk init
775 * @clk: struct clk * to initialize
777 * Initialize any struct clk fields needed before normal clk initialization
778 * can run. No return value.
780 void clk_preinit(struct clk
*clk
)
782 INIT_LIST_HEAD(&clk
->children
);
785 int clk_register(struct clk
*clk
)
787 if (clk
== NULL
|| IS_ERR(clk
))
791 * trap out already registered clocks
793 if (clk
->node
.next
|| clk
->node
.prev
)
796 mutex_lock(&clocks_mutex
);
798 list_add(&clk
->sibling
, &clk
->parent
->children
);
800 list_add(&clk
->sibling
, &root_clks
);
802 list_add(&clk
->node
, &clocks
);
805 mutex_unlock(&clocks_mutex
);
809 EXPORT_SYMBOL(clk_register
);
811 void clk_unregister(struct clk
*clk
)
813 if (clk
== NULL
|| IS_ERR(clk
))
816 mutex_lock(&clocks_mutex
);
817 list_del(&clk
->sibling
);
818 list_del(&clk
->node
);
819 mutex_unlock(&clocks_mutex
);
821 EXPORT_SYMBOL(clk_unregister
);
823 void clk_enable_init_clocks(void)
827 list_for_each_entry(clkp
, &clocks
, node
)
828 if (clkp
->flags
& ENABLE_ON_INIT
)
833 * omap_clk_get_by_name - locate OMAP struct clk by its name
834 * @name: name of the struct clk to locate
836 * Locate an OMAP struct clk by its name. Assumes that struct clk
837 * names are unique. Returns NULL if not found or a pointer to the
838 * struct clk if found.
840 struct clk
*omap_clk_get_by_name(const char *name
)
843 struct clk
*ret
= NULL
;
845 mutex_lock(&clocks_mutex
);
847 list_for_each_entry(c
, &clocks
, node
) {
848 if (!strcmp(c
->name
, name
)) {
854 mutex_unlock(&clocks_mutex
);
859 int omap_clk_enable_autoidle_all(void)
864 spin_lock_irqsave(&clockfw_lock
, flags
);
866 list_for_each_entry(c
, &clocks
, node
)
867 if (c
->ops
->allow_idle
)
868 c
->ops
->allow_idle(c
);
870 spin_unlock_irqrestore(&clockfw_lock
, flags
);
875 int omap_clk_disable_autoidle_all(void)
880 spin_lock_irqsave(&clockfw_lock
, flags
);
882 list_for_each_entry(c
, &clocks
, node
)
883 if (c
->ops
->deny_idle
)
884 c
->ops
->deny_idle(c
);
886 spin_unlock_irqrestore(&clockfw_lock
, flags
);
894 static int clkll_enable_null(struct clk
*clk
)
899 static void clkll_disable_null(struct clk
*clk
)
903 const struct clkops clkops_null
= {
904 .enable
= clkll_enable_null
,
905 .disable
= clkll_disable_null
,
911 * Used for clock aliases that are needed on some OMAPs, but not others
913 struct clk dummy_ck
= {
922 #ifdef CONFIG_OMAP_RESET_CLOCKS
924 * Disable any unused clocks left on by the bootloader
926 static int __init
clk_disable_unused(void)
931 pr_info("clock: disabling unused clocks to save power\n");
933 spin_lock_irqsave(&clockfw_lock
, flags
);
934 list_for_each_entry(ck
, &clocks
, node
) {
935 if (ck
->ops
== &clkops_null
)
938 if (ck
->usecount
> 0 || !ck
->enable_reg
)
941 omap2_clk_disable_unused(ck
);
943 spin_unlock_irqrestore(&clockfw_lock
, flags
);
947 late_initcall(clk_disable_unused
);
948 late_initcall(omap_clk_enable_autoidle_all
);
951 #if defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS)
953 * debugfs support to trace clock tree hierarchy and attributes
956 #include <linux/debugfs.h>
957 #include <linux/seq_file.h>
959 static struct dentry
*clk_debugfs_root
;
961 static int clk_dbg_show_summary(struct seq_file
*s
, void *unused
)
966 mutex_lock(&clocks_mutex
);
967 seq_printf(s
, "%-30s %-30s %-10s %s\n",
968 "clock-name", "parent-name", "rate", "use-count");
970 list_for_each_entry(c
, &clocks
, node
) {
972 seq_printf(s
, "%-30s %-30s %-10lu %d\n",
973 c
->name
, pa
? pa
->name
: "none", c
->rate
,
976 mutex_unlock(&clocks_mutex
);
981 static int clk_dbg_open(struct inode
*inode
, struct file
*file
)
983 return single_open(file
, clk_dbg_show_summary
, inode
->i_private
);
986 static const struct file_operations debug_clock_fops
= {
987 .open
= clk_dbg_open
,
990 .release
= single_release
,
993 static int clk_debugfs_register_one(struct clk
*c
)
997 struct clk
*pa
= c
->parent
;
999 d
= debugfs_create_dir(c
->name
, pa
? pa
->dent
: clk_debugfs_root
);
1004 d
= debugfs_create_u8("usecount", S_IRUGO
, c
->dent
, (u8
*)&c
->usecount
);
1009 d
= debugfs_create_u32("rate", S_IRUGO
, c
->dent
, (u32
*)&c
->rate
);
1014 d
= debugfs_create_x32("flags", S_IRUGO
, c
->dent
, (u32
*)&c
->flags
);
1022 debugfs_remove_recursive(c
->dent
);
1026 static int clk_debugfs_register(struct clk
*c
)
1029 struct clk
*pa
= c
->parent
;
1031 if (pa
&& !pa
->dent
) {
1032 err
= clk_debugfs_register(pa
);
1038 err
= clk_debugfs_register_one(c
);
1045 static int __init
clk_debugfs_init(void)
1051 d
= debugfs_create_dir("clock", NULL
);
1054 clk_debugfs_root
= d
;
1056 list_for_each_entry(c
, &clocks
, node
) {
1057 err
= clk_debugfs_register(c
);
1062 d
= debugfs_create_file("summary", S_IRUGO
,
1063 d
, NULL
, &debug_clock_fops
);
1069 debugfs_remove_recursive(clk_debugfs_root
);
1072 late_initcall(clk_debugfs_init
);
1074 #endif /* defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS) */