2 * omap_hwmod implementation for OMAP2/3/4
4 * Copyright (C) 2009 Nokia Corporation
6 * With fixes and testing from Kevin Hilman
8 * Created in collaboration with (alphabetical order): Benoit Cousson,
9 * Kevin Hilman, Tony Lindgren, Rajendra Nayak, Vikram Pandita, Sakari
10 * Poussa, Anand Sawant, Santosh Shilimkar, Richard Woodruff
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
16 * This code manages "OMAP modules" (on-chip devices) and their
17 * integration with Linux device driver and bus code.
20 * - OMAP2420 Multimedia Processor Silicon Revision 2.1.1, 2.2 (SWPU064)
21 * - OMAP2430 Multimedia Device POP Silicon Revision 2.1 (SWPU090)
22 * - OMAP34xx Multimedia Device Silicon Revision 3.1 (SWPU108)
23 * - OMAP4430 Multimedia Device Silicon Revision 1.0 (SWPU140)
24 * - Open Core Protocol Specification 2.2
29 * - bus throughput & module latency measurement code
31 * XXX add tests at the beginning of each function to ensure the hwmod is
32 * in the appropriate state
33 * XXX error return values should be checked to ensure that they are
38 #include <linux/kernel.h>
39 #include <linux/errno.h>
41 #include <linux/clk.h>
42 #include <linux/delay.h>
43 #include <linux/err.h>
44 #include <linux/list.h>
45 #include <linux/mutex.h>
46 #include <linux/bootmem.h>
48 #include <plat/common.h>
50 #include <plat/clockdomain.h>
51 #include <plat/powerdomain.h>
52 #include <plat/clock.h>
53 #include <plat/omap_hwmod.h>
57 /* Maximum microseconds to wait for OMAP module to reset */
58 #define MAX_MODULE_RESET_WAIT 10000
60 /* Name of the OMAP hwmod for the MPU */
61 #define MPU_INITIATOR_NAME "mpu_hwmod"
63 /* omap_hwmod_list contains all registered struct omap_hwmods */
64 static LIST_HEAD(omap_hwmod_list
);
66 static DEFINE_MUTEX(omap_hwmod_mutex
);
68 /* mpu_oh: used to add/remove MPU initiator from sleepdep list */
69 static struct omap_hwmod
*mpu_oh
;
71 /* inited: 0 if omap_hwmod_init() has not yet been called; 1 otherwise */
75 /* Private functions */
78 * _update_sysc_cache - return the module OCP_SYSCONFIG register, keep copy
79 * @oh: struct omap_hwmod *
81 * Load the current value of the hwmod OCP_SYSCONFIG register into the
82 * struct omap_hwmod for later use. Returns -EINVAL if the hwmod has no
83 * OCP_SYSCONFIG register or 0 upon success.
85 static int _update_sysc_cache(struct omap_hwmod
*oh
)
88 WARN(!oh
->sysconfig
, "omap_hwmod: %s: cannot read "
89 "OCP_SYSCONFIG: not defined on hwmod\n", oh
->name
);
93 /* XXX ensure module interface clock is up */
95 oh
->_sysc_cache
= omap_hwmod_readl(oh
, oh
->sysconfig
->sysc_offs
);
97 if (!(oh
->sysconfig
->sysc_flags
& SYSC_NO_CACHE
))
98 oh
->_int_flags
|= _HWMOD_SYSCONFIG_LOADED
;
104 * _write_sysconfig - write a value to the module's OCP_SYSCONFIG register
105 * @v: OCP_SYSCONFIG value to write
106 * @oh: struct omap_hwmod *
108 * Write @v into the module OCP_SYSCONFIG register, if it has one. No
111 static void _write_sysconfig(u32 v
, struct omap_hwmod
*oh
)
113 if (!oh
->sysconfig
) {
114 WARN(!oh
->sysconfig
, "omap_hwmod: %s: cannot write "
115 "OCP_SYSCONFIG: not defined on hwmod\n", oh
->name
);
119 /* XXX ensure module interface clock is up */
121 if (oh
->_sysc_cache
!= v
) {
123 omap_hwmod_writel(v
, oh
, oh
->sysconfig
->sysc_offs
);
128 * _set_master_standbymode: set the OCP_SYSCONFIG MIDLEMODE field in @v
129 * @oh: struct omap_hwmod *
130 * @standbymode: MIDLEMODE field bits
131 * @v: pointer to register contents to modify
133 * Update the master standby mode bits in @v to be @standbymode for
134 * the @oh hwmod. Does not write to the hardware. Returns -EINVAL
135 * upon error or 0 upon success.
137 static int _set_master_standbymode(struct omap_hwmod
*oh
, u8 standbymode
,
140 if (!oh
->sysconfig
||
141 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_MIDLEMODE
))
144 *v
&= ~SYSC_MIDLEMODE_MASK
;
145 *v
|= __ffs(standbymode
) << SYSC_MIDLEMODE_SHIFT
;
151 * _set_slave_idlemode: set the OCP_SYSCONFIG SIDLEMODE field in @v
152 * @oh: struct omap_hwmod *
153 * @idlemode: SIDLEMODE field bits
154 * @v: pointer to register contents to modify
156 * Update the slave idle mode bits in @v to be @idlemode for the @oh
157 * hwmod. Does not write to the hardware. Returns -EINVAL upon error
160 static int _set_slave_idlemode(struct omap_hwmod
*oh
, u8 idlemode
, u32
*v
)
162 if (!oh
->sysconfig
||
163 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_SIDLEMODE
))
166 *v
&= ~SYSC_SIDLEMODE_MASK
;
167 *v
|= __ffs(idlemode
) << SYSC_SIDLEMODE_SHIFT
;
173 * _set_clockactivity: set OCP_SYSCONFIG.CLOCKACTIVITY bits in @v
174 * @oh: struct omap_hwmod *
175 * @clockact: CLOCKACTIVITY field bits
176 * @v: pointer to register contents to modify
178 * Update the clockactivity mode bits in @v to be @clockact for the
179 * @oh hwmod. Used for additional powersaving on some modules. Does
180 * not write to the hardware. Returns -EINVAL upon error or 0 upon
183 static int _set_clockactivity(struct omap_hwmod
*oh
, u8 clockact
, u32
*v
)
185 if (!oh
->sysconfig
||
186 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_CLOCKACTIVITY
))
189 *v
&= ~SYSC_CLOCKACTIVITY_MASK
;
190 *v
|= clockact
<< SYSC_CLOCKACTIVITY_SHIFT
;
196 * _set_softreset: set OCP_SYSCONFIG.CLOCKACTIVITY bits in @v
197 * @oh: struct omap_hwmod *
198 * @v: pointer to register contents to modify
200 * Set the SOFTRESET bit in @v for hwmod @oh. Returns -EINVAL upon
201 * error or 0 upon success.
203 static int _set_softreset(struct omap_hwmod
*oh
, u32
*v
)
205 if (!oh
->sysconfig
||
206 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_SOFTRESET
))
209 *v
|= SYSC_SOFTRESET_MASK
;
215 * _set_module_autoidle: set the OCP_SYSCONFIG AUTOIDLE field in @v
216 * @oh: struct omap_hwmod *
217 * @autoidle: desired AUTOIDLE bitfield value (0 or 1)
218 * @v: pointer to register contents to modify
220 * Update the module autoidle bit in @v to be @autoidle for the @oh
221 * hwmod. The autoidle bit controls whether the module can gate
222 * internal clocks automatically when it isn't doing anything; the
223 * exact function of this bit varies on a per-module basis. This
224 * function does not write to the hardware. Returns -EINVAL upon
225 * error or 0 upon success.
227 static int _set_module_autoidle(struct omap_hwmod
*oh
, u8 autoidle
,
230 if (!oh
->sysconfig
||
231 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_AUTOIDLE
))
234 *v
&= ~SYSC_AUTOIDLE_MASK
;
235 *v
|= autoidle
<< SYSC_AUTOIDLE_SHIFT
;
241 * _enable_wakeup: set OCP_SYSCONFIG.ENAWAKEUP bit in the hardware
242 * @oh: struct omap_hwmod *
244 * Allow the hardware module @oh to send wakeups. Returns -EINVAL
245 * upon error or 0 upon success.
247 static int _enable_wakeup(struct omap_hwmod
*oh
)
251 if (!oh
->sysconfig
||
252 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_ENAWAKEUP
))
256 v
|= SYSC_ENAWAKEUP_MASK
;
257 _write_sysconfig(v
, oh
);
259 /* XXX test pwrdm_get_wken for this hwmod's subsystem */
261 oh
->_int_flags
|= _HWMOD_WAKEUP_ENABLED
;
267 * _disable_wakeup: clear OCP_SYSCONFIG.ENAWAKEUP bit in the hardware
268 * @oh: struct omap_hwmod *
270 * Prevent the hardware module @oh to send wakeups. Returns -EINVAL
271 * upon error or 0 upon success.
273 static int _disable_wakeup(struct omap_hwmod
*oh
)
277 if (!oh
->sysconfig
||
278 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_ENAWAKEUP
))
282 v
&= ~SYSC_ENAWAKEUP_MASK
;
283 _write_sysconfig(v
, oh
);
285 /* XXX test pwrdm_get_wken for this hwmod's subsystem */
287 oh
->_int_flags
&= ~_HWMOD_WAKEUP_ENABLED
;
293 * _add_initiator_dep: prevent @oh from smart-idling while @init_oh is active
294 * @oh: struct omap_hwmod *
296 * Prevent the hardware module @oh from entering idle while the
297 * hardare module initiator @init_oh is active. Useful when a module
298 * will be accessed by a particular initiator (e.g., if a module will
299 * be accessed by the IVA, there should be a sleepdep between the IVA
300 * initiator and the module). Only applies to modules in smart-idle
301 * mode. Returns -EINVAL upon error or passes along
302 * clkdm_add_sleepdep() value upon success.
304 static int _add_initiator_dep(struct omap_hwmod
*oh
, struct omap_hwmod
*init_oh
)
309 return clkdm_add_sleepdep(oh
->_clk
->clkdm
, init_oh
->_clk
->clkdm
);
313 * _del_initiator_dep: allow @oh to smart-idle even if @init_oh is active
314 * @oh: struct omap_hwmod *
316 * Allow the hardware module @oh to enter idle while the hardare
317 * module initiator @init_oh is active. Useful when a module will not
318 * be accessed by a particular initiator (e.g., if a module will not
319 * be accessed by the IVA, there should be no sleepdep between the IVA
320 * initiator and the module). Only applies to modules in smart-idle
321 * mode. Returns -EINVAL upon error or passes along
322 * clkdm_del_sleepdep() value upon success.
324 static int _del_initiator_dep(struct omap_hwmod
*oh
, struct omap_hwmod
*init_oh
)
329 return clkdm_del_sleepdep(oh
->_clk
->clkdm
, init_oh
->_clk
->clkdm
);
333 * _init_main_clk - get a struct clk * for the the hwmod's main functional clk
334 * @oh: struct omap_hwmod *
336 * Called from _init_clocks(). Populates the @oh _clk (main
337 * functional clock pointer) if a main_clk is present. Returns 0 on
338 * success or -EINVAL on error.
340 static int _init_main_clk(struct omap_hwmod
*oh
)
345 if (!oh
->clkdev_con_id
)
348 c
= clk_get_sys(oh
->clkdev_dev_id
, oh
->clkdev_con_id
);
349 WARN(IS_ERR(c
), "omap_hwmod: %s: cannot clk_get main_clk %s.%s\n",
350 oh
->name
, oh
->clkdev_dev_id
, oh
->clkdev_con_id
);
355 WARN(!c
->clkdm
, "omap_hwmod: %s: missing clockdomain for %s.\n",
356 oh
->clkdev_con_id
, c
->name
);
362 * _init_interface_clk - get a struct clk * for the the hwmod's interface clks
363 * @oh: struct omap_hwmod *
365 * Called from _init_clocks(). Populates the @oh OCP slave interface
366 * clock pointers. Returns 0 on success or -EINVAL on error.
368 static int _init_interface_clks(struct omap_hwmod
*oh
)
370 struct omap_hwmod_ocp_if
*os
;
375 if (oh
->slaves_cnt
== 0)
378 for (i
= 0, os
= *oh
->slaves
; i
< oh
->slaves_cnt
; i
++, os
++) {
379 if (!os
->clkdev_con_id
)
382 c
= clk_get_sys(os
->clkdev_dev_id
, os
->clkdev_con_id
);
383 WARN(IS_ERR(c
), "omap_hwmod: %s: cannot clk_get "
384 "interface_clk %s.%s\n", oh
->name
,
385 os
->clkdev_dev_id
, os
->clkdev_con_id
);
395 * _init_opt_clk - get a struct clk * for the the hwmod's optional clocks
396 * @oh: struct omap_hwmod *
398 * Called from _init_clocks(). Populates the @oh omap_hwmod_opt_clk
399 * clock pointers. Returns 0 on success or -EINVAL on error.
401 static int _init_opt_clks(struct omap_hwmod
*oh
)
403 struct omap_hwmod_opt_clk
*oc
;
408 for (i
= oh
->opt_clks_cnt
, oc
= oh
->opt_clks
; i
> 0; i
--, oc
++) {
409 c
= clk_get_sys(oc
->clkdev_dev_id
, oc
->clkdev_con_id
);
410 WARN(IS_ERR(c
), "omap_hwmod: %s: cannot clk_get opt_clk "
411 "%s.%s\n", oh
->name
, oc
->clkdev_dev_id
,
422 * _enable_clocks - enable hwmod main clock and interface clocks
423 * @oh: struct omap_hwmod *
425 * Enables all clocks necessary for register reads and writes to succeed
426 * on the hwmod @oh. Returns 0.
428 static int _enable_clocks(struct omap_hwmod
*oh
)
430 struct omap_hwmod_ocp_if
*os
;
433 pr_debug("omap_hwmod: %s: enabling clocks\n", oh
->name
);
435 if (oh
->_clk
&& !IS_ERR(oh
->_clk
))
436 clk_enable(oh
->_clk
);
438 if (oh
->slaves_cnt
> 0) {
439 for (i
= 0, os
= *oh
->slaves
; i
< oh
->slaves_cnt
; i
++, os
++) {
440 struct clk
*c
= os
->_clk
;
442 if (c
&& !IS_ERR(c
) && (os
->flags
& OCPIF_SWSUP_IDLE
))
447 /* The opt clocks are controlled by the device driver. */
453 * _disable_clocks - disable hwmod main clock and interface clocks
454 * @oh: struct omap_hwmod *
456 * Disables the hwmod @oh main functional and interface clocks. Returns 0.
458 static int _disable_clocks(struct omap_hwmod
*oh
)
460 struct omap_hwmod_ocp_if
*os
;
463 pr_debug("omap_hwmod: %s: disabling clocks\n", oh
->name
);
465 if (oh
->_clk
&& !IS_ERR(oh
->_clk
))
466 clk_disable(oh
->_clk
);
468 if (oh
->slaves_cnt
> 0) {
469 for (i
= 0, os
= *oh
->slaves
; i
< oh
->slaves_cnt
; i
++, os
++) {
470 struct clk
*c
= os
->_clk
;
472 if (c
&& !IS_ERR(c
) && (os
->flags
& OCPIF_SWSUP_IDLE
))
477 /* The opt clocks are controlled by the device driver. */
483 * _find_mpu_port_index - find hwmod OCP slave port ID intended for MPU use
484 * @oh: struct omap_hwmod *
486 * Returns the array index of the OCP slave port that the MPU
487 * addresses the device on, or -EINVAL upon error or not found.
489 static int _find_mpu_port_index(struct omap_hwmod
*oh
)
491 struct omap_hwmod_ocp_if
*os
;
495 if (!oh
|| oh
->slaves_cnt
== 0)
498 for (i
= 0, os
= *oh
->slaves
; i
< oh
->slaves_cnt
; i
++, os
++) {
499 if (os
->user
& OCP_USER_MPU
) {
506 pr_debug("omap_hwmod: %s: MPU OCP slave port ID %d\n",
509 pr_debug("omap_hwmod: %s: no MPU OCP slave port found\n",
512 return (found
) ? i
: -EINVAL
;
516 * _find_mpu_rt_base - find hwmod register target base addr accessible by MPU
517 * @oh: struct omap_hwmod *
519 * Return the virtual address of the base of the register target of
520 * device @oh, or NULL on error.
522 static void __iomem
*_find_mpu_rt_base(struct omap_hwmod
*oh
, u8 index
)
524 struct omap_hwmod_ocp_if
*os
;
525 struct omap_hwmod_addr_space
*mem
;
528 void __iomem
*va_start
;
530 if (!oh
|| oh
->slaves_cnt
== 0)
533 os
= *oh
->slaves
+ index
;
535 for (i
= 0, mem
= os
->addr
; i
< os
->addr_cnt
; i
++, mem
++) {
536 if (mem
->flags
& ADDR_TYPE_RT
) {
543 va_start
= ioremap(mem
->pa_start
, mem
->pa_end
- mem
->pa_start
);
545 pr_err("omap_hwmod: %s: Could not ioremap\n", oh
->name
);
548 pr_debug("omap_hwmod: %s: MPU register target at va %p\n",
551 pr_debug("omap_hwmod: %s: no MPU register target found\n",
555 return (found
) ? va_start
: NULL
;
559 * _sysc_enable - try to bring a module out of idle via OCP_SYSCONFIG
560 * @oh: struct omap_hwmod *
562 * If module is marked as SWSUP_SIDLE, force the module out of slave
563 * idle; otherwise, configure it for smart-idle. If module is marked
564 * as SWSUP_MSUSPEND, force the module out of master standby;
565 * otherwise, configure it for smart-standby. No return value.
567 static void _sysc_enable(struct omap_hwmod
*oh
)
577 if (oh
->sysconfig
->sysc_flags
& SYSC_HAS_SIDLEMODE
) {
578 idlemode
= (oh
->flags
& HWMOD_SWSUP_SIDLE
) ?
579 HWMOD_IDLEMODE_NO
: HWMOD_IDLEMODE_SMART
;
580 _set_slave_idlemode(oh
, idlemode
, &v
);
583 if (oh
->sysconfig
->sysc_flags
& SYSC_HAS_MIDLEMODE
) {
584 idlemode
= (oh
->flags
& HWMOD_SWSUP_MSTANDBY
) ?
585 HWMOD_IDLEMODE_NO
: HWMOD_IDLEMODE_SMART
;
586 _set_master_standbymode(oh
, idlemode
, &v
);
589 if (oh
->sysconfig
->sysc_flags
& SYSC_HAS_AUTOIDLE
) {
590 idlemode
= (oh
->flags
& HWMOD_NO_OCP_AUTOIDLE
) ?
592 _set_module_autoidle(oh
, idlemode
, &v
);
595 /* XXX OCP ENAWAKEUP bit? */
598 * XXX The clock framework should handle this, by
599 * calling into this code. But this must wait until the
600 * clock structures are tagged with omap_hwmod entries
602 if (oh
->flags
& HWMOD_SET_DEFAULT_CLOCKACT
&&
603 oh
->sysconfig
->sysc_flags
& SYSC_HAS_CLOCKACTIVITY
)
604 _set_clockactivity(oh
, oh
->sysconfig
->clockact
, &v
);
606 _write_sysconfig(v
, oh
);
610 * _sysc_idle - try to put a module into idle via OCP_SYSCONFIG
611 * @oh: struct omap_hwmod *
613 * If module is marked as SWSUP_SIDLE, force the module into slave
614 * idle; otherwise, configure it for smart-idle. If module is marked
615 * as SWSUP_MSUSPEND, force the module into master standby; otherwise,
616 * configure it for smart-standby. No return value.
618 static void _sysc_idle(struct omap_hwmod
*oh
)
628 if (oh
->sysconfig
->sysc_flags
& SYSC_HAS_SIDLEMODE
) {
629 idlemode
= (oh
->flags
& HWMOD_SWSUP_SIDLE
) ?
630 HWMOD_IDLEMODE_FORCE
: HWMOD_IDLEMODE_SMART
;
631 _set_slave_idlemode(oh
, idlemode
, &v
);
634 if (oh
->sysconfig
->sysc_flags
& SYSC_HAS_MIDLEMODE
) {
635 idlemode
= (oh
->flags
& HWMOD_SWSUP_MSTANDBY
) ?
636 HWMOD_IDLEMODE_FORCE
: HWMOD_IDLEMODE_SMART
;
637 _set_master_standbymode(oh
, idlemode
, &v
);
640 _write_sysconfig(v
, oh
);
644 * _sysc_shutdown - force a module into idle via OCP_SYSCONFIG
645 * @oh: struct omap_hwmod *
647 * Force the module into slave idle and master suspend. No return
650 static void _sysc_shutdown(struct omap_hwmod
*oh
)
659 if (oh
->sysconfig
->sysc_flags
& SYSC_HAS_SIDLEMODE
)
660 _set_slave_idlemode(oh
, HWMOD_IDLEMODE_FORCE
, &v
);
662 if (oh
->sysconfig
->sysc_flags
& SYSC_HAS_MIDLEMODE
)
663 _set_master_standbymode(oh
, HWMOD_IDLEMODE_FORCE
, &v
);
665 if (oh
->sysconfig
->sysc_flags
& SYSC_HAS_AUTOIDLE
)
666 _set_module_autoidle(oh
, 1, &v
);
668 _write_sysconfig(v
, oh
);
672 * _lookup - find an omap_hwmod by name
673 * @name: find an omap_hwmod by name
675 * Return a pointer to an omap_hwmod by name, or NULL if not found.
676 * Caller must hold omap_hwmod_mutex.
678 static struct omap_hwmod
*_lookup(const char *name
)
680 struct omap_hwmod
*oh
, *temp_oh
;
684 list_for_each_entry(temp_oh
, &omap_hwmod_list
, node
) {
685 if (!strcmp(name
, temp_oh
->name
)) {
695 * _init_clocks - clk_get() all clocks associated with this hwmod
696 * @oh: struct omap_hwmod *
698 * Called by omap_hwmod_late_init() (after omap2_clk_init()).
699 * Resolves all clock names embedded in the hwmod. Must be called
700 * with omap_hwmod_mutex held. Returns -EINVAL if the omap_hwmod
701 * has not yet been registered or if the clocks have already been
702 * initialized, 0 on success, or a non-zero error on failure.
704 static int _init_clocks(struct omap_hwmod
*oh
)
708 if (!oh
|| (oh
->_state
!= _HWMOD_STATE_REGISTERED
))
711 pr_debug("omap_hwmod: %s: looking up clocks\n", oh
->name
);
713 ret
|= _init_main_clk(oh
);
714 ret
|= _init_interface_clks(oh
);
715 ret
|= _init_opt_clks(oh
);
717 oh
->_state
= _HWMOD_STATE_CLKS_INITED
;
723 * _wait_target_ready - wait for a module to leave slave idle
724 * @oh: struct omap_hwmod *
726 * Wait for a module @oh to leave slave idle. Returns 0 if the module
727 * does not have an IDLEST bit or if the module successfully leaves
728 * slave idle; otherwise, pass along the return value of the
729 * appropriate *_cm_wait_module_ready() function.
731 static int _wait_target_ready(struct omap_hwmod
*oh
)
733 struct omap_hwmod_ocp_if
*os
;
739 if (oh
->_int_flags
& _HWMOD_NO_MPU_PORT
)
742 os
= *oh
->slaves
+ oh
->_mpu_port_index
;
744 if (!(os
->flags
& OCPIF_HAS_IDLEST
))
747 /* XXX check module SIDLEMODE */
749 /* XXX check clock enable states */
751 if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
752 ret
= omap2_cm_wait_module_ready(oh
->prcm
.omap2
.module_offs
,
753 oh
->prcm
.omap2
.idlest_reg_id
,
754 oh
->prcm
.omap2
.idlest_idle_bit
);
756 } else if (cpu_is_omap44xx()) {
757 ret
= omap4_cm_wait_module_ready(oh
->prcm
.omap4
.module_offs
,
758 oh
->prcm
.omap4
.device_offs
);
768 * _reset - reset an omap_hwmod
769 * @oh: struct omap_hwmod *
771 * Resets an omap_hwmod @oh via the OCP_SYSCONFIG bit. hwmod must be
772 * enabled for this to work. Must be called with omap_hwmod_mutex
773 * held. Returns -EINVAL if the hwmod cannot be reset this way or if
774 * the hwmod is in the wrong state, -ETIMEDOUT if the module did not
775 * reset in time, or 0 upon success.
777 static int _reset(struct omap_hwmod
*oh
)
782 if (!oh
->sysconfig
||
783 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_SOFTRESET
) ||
784 (oh
->sysconfig
->sysc_flags
& SYSS_MISSING
))
787 /* clocks must be on for this operation */
788 if (oh
->_state
!= _HWMOD_STATE_ENABLED
) {
789 WARN(1, "omap_hwmod: %s: reset can only be entered from "
790 "enabled state\n", oh
->name
);
794 pr_debug("omap_hwmod: %s: resetting\n", oh
->name
);
797 r
= _set_softreset(oh
, &v
);
800 _write_sysconfig(v
, oh
);
802 omap_test_timeout((omap_hwmod_readl(oh
, oh
->sysconfig
->syss_offs
) &
803 SYSS_RESETDONE_MASK
),
804 MAX_MODULE_RESET_WAIT
, c
);
806 if (c
== MAX_MODULE_RESET_WAIT
)
807 WARN(1, "omap_hwmod: %s: failed to reset in %d usec\n",
808 oh
->name
, MAX_MODULE_RESET_WAIT
);
810 pr_debug("omap_hwmod: %s: reset in %d usec\n", oh
->name
, c
);
813 * XXX add _HWMOD_STATE_WEDGED for modules that don't come back from
814 * _wait_target_ready() or _reset()
817 return (c
== MAX_MODULE_RESET_WAIT
) ? -ETIMEDOUT
: 0;
821 * _enable - enable an omap_hwmod
822 * @oh: struct omap_hwmod *
824 * Enables an omap_hwmod @oh such that the MPU can access the hwmod's
825 * register target. Must be called with omap_hwmod_mutex held.
826 * Returns -EINVAL if the hwmod is in the wrong state or passes along
827 * the return value of _wait_target_ready().
829 static int _enable(struct omap_hwmod
*oh
)
833 if (oh
->_state
!= _HWMOD_STATE_INITIALIZED
&&
834 oh
->_state
!= _HWMOD_STATE_IDLE
&&
835 oh
->_state
!= _HWMOD_STATE_DISABLED
) {
836 WARN(1, "omap_hwmod: %s: enabled state can only be entered "
837 "from initialized, idle, or disabled state\n", oh
->name
);
841 pr_debug("omap_hwmod: %s: enabling\n", oh
->name
);
845 _add_initiator_dep(oh
, mpu_oh
);
849 if (!(oh
->_int_flags
& _HWMOD_SYSCONFIG_LOADED
))
850 _update_sysc_cache(oh
);
854 r
= _wait_target_ready(oh
);
856 oh
->_state
= _HWMOD_STATE_ENABLED
;
862 * _idle - idle an omap_hwmod
863 * @oh: struct omap_hwmod *
865 * Idles an omap_hwmod @oh. This should be called once the hwmod has
866 * no further work. Returns -EINVAL if the hwmod is in the wrong
867 * state or returns 0.
869 static int _idle(struct omap_hwmod
*oh
)
871 if (oh
->_state
!= _HWMOD_STATE_ENABLED
) {
872 WARN(1, "omap_hwmod: %s: idle state can only be entered from "
873 "enabled state\n", oh
->name
);
877 pr_debug("omap_hwmod: %s: idling\n", oh
->name
);
881 _del_initiator_dep(oh
, mpu_oh
);
884 oh
->_state
= _HWMOD_STATE_IDLE
;
890 * _shutdown - shutdown an omap_hwmod
891 * @oh: struct omap_hwmod *
893 * Shut down an omap_hwmod @oh. This should be called when the driver
894 * used for the hwmod is removed or unloaded or if the driver is not
895 * used by the system. Returns -EINVAL if the hwmod is in the wrong
896 * state or returns 0.
898 static int _shutdown(struct omap_hwmod
*oh
)
900 if (oh
->_state
!= _HWMOD_STATE_IDLE
&&
901 oh
->_state
!= _HWMOD_STATE_ENABLED
) {
902 WARN(1, "omap_hwmod: %s: disabled state can only be entered "
903 "from idle, or enabled state\n", oh
->name
);
907 pr_debug("omap_hwmod: %s: disabling\n", oh
->name
);
911 _del_initiator_dep(oh
, mpu_oh
);
912 /* XXX what about the other system initiators here? DMA, tesla, d2d */
914 /* XXX Should this code also force-disable the optional clocks? */
916 /* XXX mux any associated balls to safe mode */
918 oh
->_state
= _HWMOD_STATE_DISABLED
;
924 * _setup - do initial configuration of omap_hwmod
925 * @oh: struct omap_hwmod *
927 * Writes the CLOCKACTIVITY bits @clockact to the hwmod @oh
928 * OCP_SYSCONFIG register. Must be called with omap_hwmod_mutex
929 * held. Returns -EINVAL if the hwmod is in the wrong state or returns
932 static int _setup(struct omap_hwmod
*oh
)
934 struct omap_hwmod_ocp_if
*os
;
940 /* Set iclk autoidle mode */
941 if (oh
->slaves_cnt
> 0) {
942 for (i
= 0, os
= *oh
->slaves
; i
< oh
->slaves_cnt
; i
++, os
++) {
943 struct clk
*c
= os
->_clk
;
948 if (os
->flags
& OCPIF_SWSUP_IDLE
) {
949 /* XXX omap_iclk_deny_idle(c); */
951 /* XXX omap_iclk_allow_idle(c); */
957 oh
->_state
= _HWMOD_STATE_INITIALIZED
;
961 if (!(oh
->flags
& HWMOD_INIT_NO_RESET
)) {
963 * XXX Do the OCP_SYSCONFIG bits need to be
964 * reprogrammed after a reset? If not, then this can
965 * be removed. If they do, then probably the
966 * _enable() function should be split to avoid the
967 * rewrite of the OCP_SYSCONFIG register.
970 _update_sysc_cache(oh
);
975 if (!(oh
->flags
& HWMOD_INIT_NO_IDLE
))
983 /* Public functions */
985 u32
omap_hwmod_readl(struct omap_hwmod
*oh
, u16 reg_offs
)
987 return __raw_readl(oh
->_rt_va
+ reg_offs
);
990 void omap_hwmod_writel(u32 v
, struct omap_hwmod
*oh
, u16 reg_offs
)
992 __raw_writel(v
, oh
->_rt_va
+ reg_offs
);
996 * omap_hwmod_register - register a struct omap_hwmod
997 * @oh: struct omap_hwmod *
999 * Registers the omap_hwmod @oh. Returns -EEXIST if an omap_hwmod already
1000 * has been registered by the same name; -EINVAL if the omap_hwmod is in the
1001 * wrong state, or 0 on success.
1003 * XXX The data should be copied into bootmem, so the original data
1004 * should be marked __initdata and freed after init. This would allow
1005 * unneeded omap_hwmods to be freed on multi-OMAP configurations. Note
1006 * that the copy process would be relatively complex due to the large number
1009 int omap_hwmod_register(struct omap_hwmod
*oh
)
1013 if (!oh
|| (oh
->_state
!= _HWMOD_STATE_UNKNOWN
))
1016 mutex_lock(&omap_hwmod_mutex
);
1018 pr_debug("omap_hwmod: %s: registering\n", oh
->name
);
1020 if (_lookup(oh
->name
)) {
1025 ms_id
= _find_mpu_port_index(oh
);
1026 if (!IS_ERR_VALUE(ms_id
)) {
1027 oh
->_mpu_port_index
= ms_id
;
1028 oh
->_rt_va
= _find_mpu_rt_base(oh
, oh
->_mpu_port_index
);
1030 oh
->_int_flags
|= _HWMOD_NO_MPU_PORT
;
1033 list_add_tail(&oh
->node
, &omap_hwmod_list
);
1035 oh
->_state
= _HWMOD_STATE_REGISTERED
;
1040 mutex_unlock(&omap_hwmod_mutex
);
1045 * omap_hwmod_lookup - look up a registered omap_hwmod by name
1046 * @name: name of the omap_hwmod to look up
1048 * Given a @name of an omap_hwmod, return a pointer to the registered
1049 * struct omap_hwmod *, or NULL upon error.
1051 struct omap_hwmod
*omap_hwmod_lookup(const char *name
)
1053 struct omap_hwmod
*oh
;
1058 mutex_lock(&omap_hwmod_mutex
);
1060 mutex_unlock(&omap_hwmod_mutex
);
1066 * omap_hwmod_for_each - call function for each registered omap_hwmod
1067 * @fn: pointer to a callback function
1069 * Call @fn for each registered omap_hwmod, passing @data to each
1070 * function. @fn must return 0 for success or any other value for
1071 * failure. If @fn returns non-zero, the iteration across omap_hwmods
1072 * will stop and the non-zero return value will be passed to the
1073 * caller of omap_hwmod_for_each(). @fn is called with
1074 * omap_hwmod_for_each() held.
1076 int omap_hwmod_for_each(int (*fn
)(struct omap_hwmod
*oh
))
1078 struct omap_hwmod
*temp_oh
;
1084 mutex_lock(&omap_hwmod_mutex
);
1085 list_for_each_entry(temp_oh
, &omap_hwmod_list
, node
) {
1086 ret
= (*fn
)(temp_oh
);
1090 mutex_unlock(&omap_hwmod_mutex
);
1097 * omap_hwmod_init - init omap_hwmod code and register hwmods
1098 * @ohs: pointer to an array of omap_hwmods to register
1100 * Intended to be called early in boot before the clock framework is
1101 * initialized. If @ohs is not null, will register all omap_hwmods
1102 * listed in @ohs that are valid for this chip. Returns -EINVAL if
1103 * omap_hwmod_init() has already been called or 0 otherwise.
1105 int omap_hwmod_init(struct omap_hwmod
**ohs
)
1107 struct omap_hwmod
*oh
;
1120 if (omap_chip_is(oh
->omap_chip
)) {
1121 r
= omap_hwmod_register(oh
);
1122 WARN(r
, "omap_hwmod: %s: omap_hwmod_register returned "
1123 "%d\n", oh
->name
, r
);
1132 * omap_hwmod_late_init - do some post-clock framework initialization
1134 * Must be called after omap2_clk_init(). Resolves the struct clk names
1135 * to struct clk pointers for each registered omap_hwmod. Also calls
1136 * _setup() on each hwmod. Returns 0.
1138 int omap_hwmod_late_init(void)
1142 /* XXX check return value */
1143 r
= omap_hwmod_for_each(_init_clocks
);
1144 WARN(r
, "omap_hwmod: omap_hwmod_late_init(): _init_clocks failed\n");
1146 mpu_oh
= omap_hwmod_lookup(MPU_INITIATOR_NAME
);
1147 WARN(!mpu_oh
, "omap_hwmod: could not find MPU initiator hwmod %s\n",
1148 MPU_INITIATOR_NAME
);
1150 omap_hwmod_for_each(_setup
);
1156 * omap_hwmod_unregister - unregister an omap_hwmod
1157 * @oh: struct omap_hwmod *
1159 * Unregisters a previously-registered omap_hwmod @oh. There's probably
1160 * no use case for this, so it is likely to be removed in a later version.
1162 * XXX Free all of the bootmem-allocated structures here when that is
1163 * implemented. Make it clear that core code is the only code that is
1164 * expected to unregister modules.
1166 int omap_hwmod_unregister(struct omap_hwmod
*oh
)
1171 pr_debug("omap_hwmod: %s: unregistering\n", oh
->name
);
1173 mutex_lock(&omap_hwmod_mutex
);
1174 iounmap(oh
->_rt_va
);
1175 list_del(&oh
->node
);
1176 mutex_unlock(&omap_hwmod_mutex
);
1182 * omap_hwmod_enable - enable an omap_hwmod
1183 * @oh: struct omap_hwmod *
1185 * Enable an omap_hwomd @oh. Intended to be called by omap_device_enable().
1186 * Returns -EINVAL on error or passes along the return value from _enable().
1188 int omap_hwmod_enable(struct omap_hwmod
*oh
)
1195 mutex_lock(&omap_hwmod_mutex
);
1197 mutex_unlock(&omap_hwmod_mutex
);
1203 * omap_hwmod_idle - idle an omap_hwmod
1204 * @oh: struct omap_hwmod *
1206 * Idle an omap_hwomd @oh. Intended to be called by omap_device_idle().
1207 * Returns -EINVAL on error or passes along the return value from _idle().
1209 int omap_hwmod_idle(struct omap_hwmod
*oh
)
1214 mutex_lock(&omap_hwmod_mutex
);
1216 mutex_unlock(&omap_hwmod_mutex
);
1222 * omap_hwmod_shutdown - shutdown an omap_hwmod
1223 * @oh: struct omap_hwmod *
1225 * Shutdown an omap_hwomd @oh. Intended to be called by
1226 * omap_device_shutdown(). Returns -EINVAL on error or passes along
1227 * the return value from _shutdown().
1229 int omap_hwmod_shutdown(struct omap_hwmod
*oh
)
1234 mutex_lock(&omap_hwmod_mutex
);
1236 mutex_unlock(&omap_hwmod_mutex
);
1242 * omap_hwmod_enable_clocks - enable main_clk, all interface clocks
1243 * @oh: struct omap_hwmod *oh
1245 * Intended to be called by the omap_device code.
1247 int omap_hwmod_enable_clocks(struct omap_hwmod
*oh
)
1249 mutex_lock(&omap_hwmod_mutex
);
1251 mutex_unlock(&omap_hwmod_mutex
);
1257 * omap_hwmod_disable_clocks - disable main_clk, all interface clocks
1258 * @oh: struct omap_hwmod *oh
1260 * Intended to be called by the omap_device code.
1262 int omap_hwmod_disable_clocks(struct omap_hwmod
*oh
)
1264 mutex_lock(&omap_hwmod_mutex
);
1265 _disable_clocks(oh
);
1266 mutex_unlock(&omap_hwmod_mutex
);
1272 * omap_hwmod_ocp_barrier - wait for posted writes against the hwmod to complete
1273 * @oh: struct omap_hwmod *oh
1275 * Intended to be called by drivers and core code when all posted
1276 * writes to a device must complete before continuing further
1277 * execution (for example, after clearing some device IRQSTATUS
1280 * XXX what about targets with multiple OCP threads?
1282 void omap_hwmod_ocp_barrier(struct omap_hwmod
*oh
)
1286 if (!oh
->sysconfig
|| !oh
->sysconfig
->sysc_flags
) {
1287 WARN(1, "omap_device: %s: OCP barrier impossible due to "
1288 "device configuration\n", oh
->name
);
1293 * Forces posted writes to complete on the OCP thread handling
1296 omap_hwmod_readl(oh
, oh
->sysconfig
->sysc_offs
);
1300 * omap_hwmod_reset - reset the hwmod
1301 * @oh: struct omap_hwmod *
1303 * Under some conditions, a driver may wish to reset the entire device.
1304 * Called from omap_device code. Returns -EINVAL on error or passes along
1305 * the return value from _reset()/_enable().
1307 int omap_hwmod_reset(struct omap_hwmod
*oh
)
1311 if (!oh
|| !(oh
->_state
& _HWMOD_STATE_ENABLED
))
1314 mutex_lock(&omap_hwmod_mutex
);
1318 mutex_unlock(&omap_hwmod_mutex
);
1324 * omap_hwmod_count_resources - count number of struct resources needed by hwmod
1325 * @oh: struct omap_hwmod *
1326 * @res: pointer to the first element of an array of struct resource to fill
1328 * Count the number of struct resource array elements necessary to
1329 * contain omap_hwmod @oh resources. Intended to be called by code
1330 * that registers omap_devices. Intended to be used to determine the
1331 * size of a dynamically-allocated struct resource array, before
1332 * calling omap_hwmod_fill_resources(). Returns the number of struct
1333 * resource array elements needed.
1335 * XXX This code is not optimized. It could attempt to merge adjacent
1339 int omap_hwmod_count_resources(struct omap_hwmod
*oh
)
1343 ret
= oh
->mpu_irqs_cnt
+ oh
->sdma_chs_cnt
;
1345 for (i
= 0; i
< oh
->slaves_cnt
; i
++)
1346 ret
+= (*oh
->slaves
+ i
)->addr_cnt
;
1352 * omap_hwmod_fill_resources - fill struct resource array with hwmod data
1353 * @oh: struct omap_hwmod *
1354 * @res: pointer to the first element of an array of struct resource to fill
1356 * Fill the struct resource array @res with resource data from the
1357 * omap_hwmod @oh. Intended to be called by code that registers
1358 * omap_devices. See also omap_hwmod_count_resources(). Returns the
1359 * number of array elements filled.
1361 int omap_hwmod_fill_resources(struct omap_hwmod
*oh
, struct resource
*res
)
1366 /* For each IRQ, DMA, memory area, fill in array.*/
1368 for (i
= 0; i
< oh
->mpu_irqs_cnt
; i
++) {
1369 (res
+ r
)->name
= (oh
->mpu_irqs
+ i
)->name
;
1370 (res
+ r
)->start
= (oh
->mpu_irqs
+ i
)->irq
;
1371 (res
+ r
)->end
= (oh
->mpu_irqs
+ i
)->irq
;
1372 (res
+ r
)->flags
= IORESOURCE_IRQ
;
1376 for (i
= 0; i
< oh
->sdma_chs_cnt
; i
++) {
1377 (res
+ r
)->name
= (oh
->sdma_chs
+ i
)->name
;
1378 (res
+ r
)->start
= (oh
->sdma_chs
+ i
)->dma_ch
;
1379 (res
+ r
)->end
= (oh
->sdma_chs
+ i
)->dma_ch
;
1380 (res
+ r
)->flags
= IORESOURCE_DMA
;
1384 for (i
= 0; i
< oh
->slaves_cnt
; i
++) {
1385 struct omap_hwmod_ocp_if
*os
;
1387 os
= *oh
->slaves
+ i
;
1389 for (j
= 0; j
< os
->addr_cnt
; j
++) {
1390 (res
+ r
)->start
= (os
->addr
+ j
)->pa_start
;
1391 (res
+ r
)->end
= (os
->addr
+ j
)->pa_end
;
1392 (res
+ r
)->flags
= IORESOURCE_MEM
;
1401 * omap_hwmod_get_pwrdm - return pointer to this module's main powerdomain
1402 * @oh: struct omap_hwmod *
1404 * Return the powerdomain pointer associated with the OMAP module
1405 * @oh's main clock. If @oh does not have a main clk, return the
1406 * powerdomain associated with the interface clock associated with the
1407 * module's MPU port. (XXX Perhaps this should use the SDMA port
1408 * instead?) Returns NULL on error, or a struct powerdomain * on
1411 struct powerdomain
*omap_hwmod_get_pwrdm(struct omap_hwmod
*oh
)
1421 if (oh
->_int_flags
& _HWMOD_NO_MPU_PORT
)
1423 c
= oh
->slaves
[oh
->_mpu_port_index
]->_clk
;
1426 return c
->clkdm
->pwrdm
.ptr
;
1431 * omap_hwmod_add_initiator_dep - add sleepdep from @init_oh to @oh
1432 * @oh: struct omap_hwmod *
1433 * @init_oh: struct omap_hwmod * (initiator)
1435 * Add a sleep dependency between the initiator @init_oh and @oh.
1436 * Intended to be called by DSP/Bridge code via platform_data for the
1437 * DSP case; and by the DMA code in the sDMA case. DMA code, *Bridge
1438 * code needs to add/del initiator dependencies dynamically
1439 * before/after accessing a device. Returns the return value from
1440 * _add_initiator_dep().
1442 * XXX Keep a usecount in the clockdomain code
1444 int omap_hwmod_add_initiator_dep(struct omap_hwmod
*oh
,
1445 struct omap_hwmod
*init_oh
)
1447 return _add_initiator_dep(oh
, init_oh
);
1451 * XXX what about functions for drivers to save/restore ocp_sysconfig
1452 * for context save/restore operations?
1456 * omap_hwmod_del_initiator_dep - remove sleepdep from @init_oh to @oh
1457 * @oh: struct omap_hwmod *
1458 * @init_oh: struct omap_hwmod * (initiator)
1460 * Remove a sleep dependency between the initiator @init_oh and @oh.
1461 * Intended to be called by DSP/Bridge code via platform_data for the
1462 * DSP case; and by the DMA code in the sDMA case. DMA code, *Bridge
1463 * code needs to add/del initiator dependencies dynamically
1464 * before/after accessing a device. Returns the return value from
1465 * _del_initiator_dep().
1467 * XXX Keep a usecount in the clockdomain code
1469 int omap_hwmod_del_initiator_dep(struct omap_hwmod
*oh
,
1470 struct omap_hwmod
*init_oh
)
1472 return _del_initiator_dep(oh
, init_oh
);
1476 * omap_hwmod_enable_wakeup - allow device to wake up the system
1477 * @oh: struct omap_hwmod *
1479 * Sets the module OCP socket ENAWAKEUP bit to allow the module to
1480 * send wakeups to the PRCM. Eventually this should sets PRCM wakeup
1481 * registers to cause the PRCM to receive wakeup events from the
1482 * module. Does not set any wakeup routing registers beyond this
1483 * point - if the module is to wake up any other module or subsystem,
1484 * that must be set separately. Called by omap_device code. Returns
1485 * -EINVAL on error or 0 upon success.
1487 int omap_hwmod_enable_wakeup(struct omap_hwmod
*oh
)
1489 if (!oh
->sysconfig
||
1490 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_ENAWAKEUP
))
1493 mutex_lock(&omap_hwmod_mutex
);
1495 mutex_unlock(&omap_hwmod_mutex
);
1501 * omap_hwmod_disable_wakeup - prevent device from waking the system
1502 * @oh: struct omap_hwmod *
1504 * Clears the module OCP socket ENAWAKEUP bit to prevent the module
1505 * from sending wakeups to the PRCM. Eventually this should clear
1506 * PRCM wakeup registers to cause the PRCM to ignore wakeup events
1507 * from the module. Does not set any wakeup routing registers beyond
1508 * this point - if the module is to wake up any other module or
1509 * subsystem, that must be set separately. Called by omap_device
1510 * code. Returns -EINVAL on error or 0 upon success.
1512 int omap_hwmod_disable_wakeup(struct omap_hwmod
*oh
)
1514 if (!oh
->sysconfig
||
1515 !(oh
->sysconfig
->sysc_flags
& SYSC_HAS_ENAWAKEUP
))
1518 mutex_lock(&omap_hwmod_mutex
);
1519 _disable_wakeup(oh
);
1520 mutex_unlock(&omap_hwmod_mutex
);