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

TOMOYO Linux Cross Reference
Linux/arch/arm/mach-omap2/omap_hwmod.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * omap_hwmod implementation for OMAP2/3/4
  3  *
  4  * Copyright (C) 2009-2011 Nokia Corporation
  5  * Copyright (C) 2011-2012 Texas Instruments, Inc.
  6  *
  7  * Paul Walmsley, BenoƮt Cousson, Kevin Hilman
  8  *
  9  * Created in collaboration with (alphabetical order): Thara Gopinath,
 10  * Tony Lindgren, Rajendra Nayak, Vikram Pandita, Sakari Poussa, Anand
 11  * Sawant, Santosh Shilimkar, Richard Woodruff
 12  *
 13  * This program is free software; you can redistribute it and/or modify
 14  * it under the terms of the GNU General Public License version 2 as
 15  * published by the Free Software Foundation.
 16  *
 17  * Introduction
 18  * ------------
 19  * One way to view an OMAP SoC is as a collection of largely unrelated
 20  * IP blocks connected by interconnects.  The IP blocks include
 21  * devices such as ARM processors, audio serial interfaces, UARTs,
 22  * etc.  Some of these devices, like the DSP, are created by TI;
 23  * others, like the SGX, largely originate from external vendors.  In
 24  * TI's documentation, on-chip devices are referred to as "OMAP
 25  * modules."  Some of these IP blocks are identical across several
 26  * OMAP versions.  Others are revised frequently.
 27  *
 28  * These OMAP modules are tied together by various interconnects.
 29  * Most of the address and data flow between modules is via OCP-based
 30  * interconnects such as the L3 and L4 buses; but there are other
 31  * interconnects that distribute the hardware clock tree, handle idle
 32  * and reset signaling, supply power, and connect the modules to
 33  * various pads or balls on the OMAP package.
 34  *
 35  * OMAP hwmod provides a consistent way to describe the on-chip
 36  * hardware blocks and their integration into the rest of the chip.
 37  * This description can be automatically generated from the TI
 38  * hardware database.  OMAP hwmod provides a standard, consistent API
 39  * to reset, enable, idle, and disable these hardware blocks.  And
 40  * hwmod provides a way for other core code, such as the Linux device
 41  * code or the OMAP power management and address space mapping code,
 42  * to query the hardware database.
 43  *
 44  * Using hwmod
 45  * -----------
 46  * Drivers won't call hwmod functions directly.  That is done by the
 47  * omap_device code, and in rare occasions, by custom integration code
 48  * in arch/arm/ *omap*.  The omap_device code includes functions to
 49  * build a struct platform_device using omap_hwmod data, and that is
 50  * currently how hwmod data is communicated to drivers and to the
 51  * Linux driver model.  Most drivers will call omap_hwmod functions only
 52  * indirectly, via pm_runtime*() functions.
 53  *
 54  * From a layering perspective, here is where the OMAP hwmod code
 55  * fits into the kernel software stack:
 56  *
 57  *            +-------------------------------+
 58  *            |      Device driver code       |
 59  *            |      (e.g., drivers/)         |
 60  *            +-------------------------------+
 61  *            |      Linux driver model       |
 62  *            |     (platform_device /        |
 63  *            |  platform_driver data/code)   |
 64  *            +-------------------------------+
 65  *            | OMAP core-driver integration  |
 66  *            |(arch/arm/mach-omap2/devices.c)|
 67  *            +-------------------------------+
 68  *            |      omap_device code         |
 69  *            | (../plat-omap/omap_device.c)  |
 70  *            +-------------------------------+
 71  *   ---->    |    omap_hwmod code/data       |    <-----
 72  *            | (../mach-omap2/omap_hwmod*)   |
 73  *            +-------------------------------+
 74  *            | OMAP clock/PRCM/register fns  |
 75  *            | ({read,write}l_relaxed, clk*) |
 76  *            +-------------------------------+
 77  *
 78  * Device drivers should not contain any OMAP-specific code or data in
 79  * them.  They should only contain code to operate the IP block that
 80  * the driver is responsible for.  This is because these IP blocks can
 81  * also appear in other SoCs, either from TI (such as DaVinci) or from
 82  * other manufacturers; and drivers should be reusable across other
 83  * platforms.
 84  *
 85  * The OMAP hwmod code also will attempt to reset and idle all on-chip
 86  * devices upon boot.  The goal here is for the kernel to be
 87  * completely self-reliant and independent from bootloaders.  This is
 88  * to ensure a repeatable configuration, both to ensure consistent
 89  * runtime behavior, and to make it easier for others to reproduce
 90  * bugs.
 91  *
 92  * OMAP module activity states
 93  * ---------------------------
 94  * The hwmod code considers modules to be in one of several activity
 95  * states.  IP blocks start out in an UNKNOWN state, then once they
 96  * are registered via the hwmod code, proceed to the REGISTERED state.
 97  * Once their clock names are resolved to clock pointers, the module
 98  * enters the CLKS_INITED state; and finally, once the module has been
 99  * reset and the integration registers programmed, the INITIALIZED state
100  * is entered.  The hwmod code will then place the module into either
101  * the IDLE state to save power, or in the case of a critical system
102  * module, the ENABLED state.
103  *
104  * OMAP core integration code can then call omap_hwmod*() functions
105  * directly to move the module between the IDLE, ENABLED, and DISABLED
106  * states, as needed.  This is done during both the PM idle loop, and
107  * in the OMAP core integration code's implementation of the PM runtime
108  * functions.
109  *
110  * References
111  * ----------
112  * This is a partial list.
113  * - OMAP2420 Multimedia Processor Silicon Revision 2.1.1, 2.2 (SWPU064)
114  * - OMAP2430 Multimedia Device POP Silicon Revision 2.1 (SWPU090)
115  * - OMAP34xx Multimedia Device Silicon Revision 3.1 (SWPU108)
116  * - OMAP4430 Multimedia Device Silicon Revision 1.0 (SWPU140)
117  * - Open Core Protocol Specification 2.2
118  *
119  * To do:
120  * - handle IO mapping
121  * - bus throughput & module latency measurement code
122  *
123  * XXX add tests at the beginning of each function to ensure the hwmod is
124  * in the appropriate state
125  * XXX error return values should be checked to ensure that they are
126  * appropriate
127  */
128 #undef DEBUG
129 
130 #include <linux/kernel.h>
131 #include <linux/errno.h>
132 #include <linux/io.h>
133 #include <linux/clk.h>
134 #include <linux/clk-provider.h>
135 #include <linux/delay.h>
136 #include <linux/err.h>
137 #include <linux/list.h>
138 #include <linux/mutex.h>
139 #include <linux/spinlock.h>
140 #include <linux/slab.h>
141 #include <linux/bootmem.h>
142 #include <linux/cpu.h>
143 #include <linux/of.h>
144 #include <linux/of_address.h>
145 
146 #include <asm/system_misc.h>
147 
148 #include "clock.h"
149 #include "omap_hwmod.h"
150 
151 #include "soc.h"
152 #include "common.h"
153 #include "clockdomain.h"
154 #include "powerdomain.h"
155 #include "cm2xxx.h"
156 #include "cm3xxx.h"
157 #include "cm33xx.h"
158 #include "prm.h"
159 #include "prm3xxx.h"
160 #include "prm44xx.h"
161 #include "prm33xx.h"
162 #include "prminst44xx.h"
163 #include "mux.h"
164 #include "pm.h"
165 
166 /* Name of the OMAP hwmod for the MPU */
167 #define MPU_INITIATOR_NAME              "mpu"
168 
169 /*
170  * Number of struct omap_hwmod_link records per struct
171  * omap_hwmod_ocp_if record (master->slave and slave->master)
172  */
173 #define LINKS_PER_OCP_IF                2
174 
175 /*
176  * Address offset (in bytes) between the reset control and the reset
177  * status registers: 4 bytes on OMAP4
178  */
179 #define OMAP4_RST_CTRL_ST_OFFSET        4
180 
181 /**
182  * struct omap_hwmod_soc_ops - fn ptrs for some SoC-specific operations
183  * @enable_module: function to enable a module (via MODULEMODE)
184  * @disable_module: function to disable a module (via MODULEMODE)
185  *
186  * XXX Eventually this functionality will be hidden inside the PRM/CM
187  * device drivers.  Until then, this should avoid huge blocks of cpu_is_*()
188  * conditionals in this code.
189  */
190 struct omap_hwmod_soc_ops {
191         void (*enable_module)(struct omap_hwmod *oh);
192         int (*disable_module)(struct omap_hwmod *oh);
193         int (*wait_target_ready)(struct omap_hwmod *oh);
194         int (*assert_hardreset)(struct omap_hwmod *oh,
195                                 struct omap_hwmod_rst_info *ohri);
196         int (*deassert_hardreset)(struct omap_hwmod *oh,
197                                   struct omap_hwmod_rst_info *ohri);
198         int (*is_hardreset_asserted)(struct omap_hwmod *oh,
199                                      struct omap_hwmod_rst_info *ohri);
200         int (*init_clkdm)(struct omap_hwmod *oh);
201         void (*update_context_lost)(struct omap_hwmod *oh);
202         int (*get_context_lost)(struct omap_hwmod *oh);
203 };
204 
205 /* soc_ops: adapts the omap_hwmod code to the currently-booted SoC */
206 static struct omap_hwmod_soc_ops soc_ops;
207 
208 /* omap_hwmod_list contains all registered struct omap_hwmods */
209 static LIST_HEAD(omap_hwmod_list);
210 
211 /* mpu_oh: used to add/remove MPU initiator from sleepdep list */
212 static struct omap_hwmod *mpu_oh;
213 
214 /* io_chain_lock: used to serialize reconfigurations of the I/O chain */
215 static DEFINE_SPINLOCK(io_chain_lock);
216 
217 /*
218  * linkspace: ptr to a buffer that struct omap_hwmod_link records are
219  * allocated from - used to reduce the number of small memory
220  * allocations, which has a significant impact on performance
221  */
222 static struct omap_hwmod_link *linkspace;
223 
224 /*
225  * free_ls, max_ls: array indexes into linkspace; representing the
226  * next free struct omap_hwmod_link index, and the maximum number of
227  * struct omap_hwmod_link records allocated (respectively)
228  */
229 static unsigned short free_ls, max_ls, ls_supp;
230 
231 /* inited: set to true once the hwmod code is initialized */
232 static bool inited;
233 
234 /* Private functions */
235 
236 /**
237  * _fetch_next_ocp_if - return the next OCP interface in a list
238  * @p: ptr to a ptr to the list_head inside the ocp_if to return
239  * @i: pointer to the index of the element pointed to by @p in the list
240  *
241  * Return a pointer to the struct omap_hwmod_ocp_if record
242  * containing the struct list_head pointed to by @p, and increment
243  * @p such that a future call to this routine will return the next
244  * record.
245  */
246 static struct omap_hwmod_ocp_if *_fetch_next_ocp_if(struct list_head **p,
247                                                     int *i)
248 {
249         struct omap_hwmod_ocp_if *oi;
250 
251         oi = list_entry(*p, struct omap_hwmod_link, node)->ocp_if;
252         *p = (*p)->next;
253 
254         *i = *i + 1;
255 
256         return oi;
257 }
258 
259 /**
260  * _update_sysc_cache - return the module OCP_SYSCONFIG register, keep copy
261  * @oh: struct omap_hwmod *
262  *
263  * Load the current value of the hwmod OCP_SYSCONFIG register into the
264  * struct omap_hwmod for later use.  Returns -EINVAL if the hwmod has no
265  * OCP_SYSCONFIG register or 0 upon success.
266  */
267 static int _update_sysc_cache(struct omap_hwmod *oh)
268 {
269         if (!oh->class->sysc) {
270                 WARN(1, "omap_hwmod: %s: cannot read OCP_SYSCONFIG: not defined on hwmod's class\n", oh->name);
271                 return -EINVAL;
272         }
273 
274         /* XXX ensure module interface clock is up */
275 
276         oh->_sysc_cache = omap_hwmod_read(oh, oh->class->sysc->sysc_offs);
277 
278         if (!(oh->class->sysc->sysc_flags & SYSC_NO_CACHE))
279                 oh->_int_flags |= _HWMOD_SYSCONFIG_LOADED;
280 
281         return 0;
282 }
283 
284 /**
285  * _write_sysconfig - write a value to the module's OCP_SYSCONFIG register
286  * @v: OCP_SYSCONFIG value to write
287  * @oh: struct omap_hwmod *
288  *
289  * Write @v into the module class' OCP_SYSCONFIG register, if it has
290  * one.  No return value.
291  */
292 static void _write_sysconfig(u32 v, struct omap_hwmod *oh)
293 {
294         if (!oh->class->sysc) {
295                 WARN(1, "omap_hwmod: %s: cannot write OCP_SYSCONFIG: not defined on hwmod's class\n", oh->name);
296                 return;
297         }
298 
299         /* XXX ensure module interface clock is up */
300 
301         /* Module might have lost context, always update cache and register */
302         oh->_sysc_cache = v;
303 
304         /*
305          * Some IP blocks (such as RTC) require unlocking of IP before
306          * accessing its registers. If a function pointer is present
307          * to unlock, then call it before accessing sysconfig and
308          * call lock after writing sysconfig.
309          */
310         if (oh->class->unlock)
311                 oh->class->unlock(oh);
312 
313         omap_hwmod_write(v, oh, oh->class->sysc->sysc_offs);
314 
315         if (oh->class->lock)
316                 oh->class->lock(oh);
317 }
318 
319 /**
320  * _set_master_standbymode: set the OCP_SYSCONFIG MIDLEMODE field in @v
321  * @oh: struct omap_hwmod *
322  * @standbymode: MIDLEMODE field bits
323  * @v: pointer to register contents to modify
324  *
325  * Update the master standby mode bits in @v to be @standbymode for
326  * the @oh hwmod.  Does not write to the hardware.  Returns -EINVAL
327  * upon error or 0 upon success.
328  */
329 static int _set_master_standbymode(struct omap_hwmod *oh, u8 standbymode,
330                                    u32 *v)
331 {
332         u32 mstandby_mask;
333         u8 mstandby_shift;
334 
335         if (!oh->class->sysc ||
336             !(oh->class->sysc->sysc_flags & SYSC_HAS_MIDLEMODE))
337                 return -EINVAL;
338 
339         if (!oh->class->sysc->sysc_fields) {
340                 WARN(1, "omap_hwmod: %s: offset struct for sysconfig not provided in class\n", oh->name);
341                 return -EINVAL;
342         }
343 
344         mstandby_shift = oh->class->sysc->sysc_fields->midle_shift;
345         mstandby_mask = (0x3 << mstandby_shift);
346 
347         *v &= ~mstandby_mask;
348         *v |= __ffs(standbymode) << mstandby_shift;
349 
350         return 0;
351 }
352 
353 /**
354  * _set_slave_idlemode: set the OCP_SYSCONFIG SIDLEMODE field in @v
355  * @oh: struct omap_hwmod *
356  * @idlemode: SIDLEMODE field bits
357  * @v: pointer to register contents to modify
358  *
359  * Update the slave idle mode bits in @v to be @idlemode for the @oh
360  * hwmod.  Does not write to the hardware.  Returns -EINVAL upon error
361  * or 0 upon success.
362  */
363 static int _set_slave_idlemode(struct omap_hwmod *oh, u8 idlemode, u32 *v)
364 {
365         u32 sidle_mask;
366         u8 sidle_shift;
367 
368         if (!oh->class->sysc ||
369             !(oh->class->sysc->sysc_flags & SYSC_HAS_SIDLEMODE))
370                 return -EINVAL;
371 
372         if (!oh->class->sysc->sysc_fields) {
373                 WARN(1, "omap_hwmod: %s: offset struct for sysconfig not provided in class\n", oh->name);
374                 return -EINVAL;
375         }
376 
377         sidle_shift = oh->class->sysc->sysc_fields->sidle_shift;
378         sidle_mask = (0x3 << sidle_shift);
379 
380         *v &= ~sidle_mask;
381         *v |= __ffs(idlemode) << sidle_shift;
382 
383         return 0;
384 }
385 
386 /**
387  * _set_clockactivity: set OCP_SYSCONFIG.CLOCKACTIVITY bits in @v
388  * @oh: struct omap_hwmod *
389  * @clockact: CLOCKACTIVITY field bits
390  * @v: pointer to register contents to modify
391  *
392  * Update the clockactivity mode bits in @v to be @clockact for the
393  * @oh hwmod.  Used for additional powersaving on some modules.  Does
394  * not write to the hardware.  Returns -EINVAL upon error or 0 upon
395  * success.
396  */
397 static int _set_clockactivity(struct omap_hwmod *oh, u8 clockact, u32 *v)
398 {
399         u32 clkact_mask;
400         u8  clkact_shift;
401 
402         if (!oh->class->sysc ||
403             !(oh->class->sysc->sysc_flags & SYSC_HAS_CLOCKACTIVITY))
404                 return -EINVAL;
405 
406         if (!oh->class->sysc->sysc_fields) {
407                 WARN(1, "omap_hwmod: %s: offset struct for sysconfig not provided in class\n", oh->name);
408                 return -EINVAL;
409         }
410 
411         clkact_shift = oh->class->sysc->sysc_fields->clkact_shift;
412         clkact_mask = (0x3 << clkact_shift);
413 
414         *v &= ~clkact_mask;
415         *v |= clockact << clkact_shift;
416 
417         return 0;
418 }
419 
420 /**
421  * _set_softreset: set OCP_SYSCONFIG.SOFTRESET bit in @v
422  * @oh: struct omap_hwmod *
423  * @v: pointer to register contents to modify
424  *
425  * Set the SOFTRESET bit in @v for hwmod @oh.  Returns -EINVAL upon
426  * error or 0 upon success.
427  */
428 static int _set_softreset(struct omap_hwmod *oh, u32 *v)
429 {
430         u32 softrst_mask;
431 
432         if (!oh->class->sysc ||
433             !(oh->class->sysc->sysc_flags & SYSC_HAS_SOFTRESET))
434                 return -EINVAL;
435 
436         if (!oh->class->sysc->sysc_fields) {
437                 WARN(1, "omap_hwmod: %s: offset struct for sysconfig not provided in class\n", oh->name);
438                 return -EINVAL;
439         }
440 
441         softrst_mask = (0x1 << oh->class->sysc->sysc_fields->srst_shift);
442 
443         *v |= softrst_mask;
444 
445         return 0;
446 }
447 
448 /**
449  * _clear_softreset: clear OCP_SYSCONFIG.SOFTRESET bit in @v
450  * @oh: struct omap_hwmod *
451  * @v: pointer to register contents to modify
452  *
453  * Clear the SOFTRESET bit in @v for hwmod @oh.  Returns -EINVAL upon
454  * error or 0 upon success.
455  */
456 static int _clear_softreset(struct omap_hwmod *oh, u32 *v)
457 {
458         u32 softrst_mask;
459 
460         if (!oh->class->sysc ||
461             !(oh->class->sysc->sysc_flags & SYSC_HAS_SOFTRESET))
462                 return -EINVAL;
463 
464         if (!oh->class->sysc->sysc_fields) {
465                 WARN(1,
466                      "omap_hwmod: %s: sysc_fields absent for sysconfig class\n",
467                      oh->name);
468                 return -EINVAL;
469         }
470 
471         softrst_mask = (0x1 << oh->class->sysc->sysc_fields->srst_shift);
472 
473         *v &= ~softrst_mask;
474 
475         return 0;
476 }
477 
478 /**
479  * _wait_softreset_complete - wait for an OCP softreset to complete
480  * @oh: struct omap_hwmod * to wait on
481  *
482  * Wait until the IP block represented by @oh reports that its OCP
483  * softreset is complete.  This can be triggered by software (see
484  * _ocp_softreset()) or by hardware upon returning from off-mode (one
485  * example is HSMMC).  Waits for up to MAX_MODULE_SOFTRESET_WAIT
486  * microseconds.  Returns the number of microseconds waited.
487  */
488 static int _wait_softreset_complete(struct omap_hwmod *oh)
489 {
490         struct omap_hwmod_class_sysconfig *sysc;
491         u32 softrst_mask;
492         int c = 0;
493 
494         sysc = oh->class->sysc;
495 
496         if (sysc->sysc_flags & SYSS_HAS_RESET_STATUS)
497                 omap_test_timeout((omap_hwmod_read(oh, sysc->syss_offs)
498                                    & SYSS_RESETDONE_MASK),
499                                   MAX_MODULE_SOFTRESET_WAIT, c);
500         else if (sysc->sysc_flags & SYSC_HAS_RESET_STATUS) {
501                 softrst_mask = (0x1 << sysc->sysc_fields->srst_shift);
502                 omap_test_timeout(!(omap_hwmod_read(oh, sysc->sysc_offs)
503                                     & softrst_mask),
504                                   MAX_MODULE_SOFTRESET_WAIT, c);
505         }
506 
507         return c;
508 }
509 
510 /**
511  * _set_dmadisable: set OCP_SYSCONFIG.DMADISABLE bit in @v
512  * @oh: struct omap_hwmod *
513  *
514  * The DMADISABLE bit is a semi-automatic bit present in sysconfig register
515  * of some modules. When the DMA must perform read/write accesses, the
516  * DMADISABLE bit is cleared by the hardware. But when the DMA must stop
517  * for power management, software must set the DMADISABLE bit back to 1.
518  *
519  * Set the DMADISABLE bit in @v for hwmod @oh.  Returns -EINVAL upon
520  * error or 0 upon success.
521  */
522 static int _set_dmadisable(struct omap_hwmod *oh)
523 {
524         u32 v;
525         u32 dmadisable_mask;
526 
527         if (!oh->class->sysc ||
528             !(oh->class->sysc->sysc_flags & SYSC_HAS_DMADISABLE))
529                 return -EINVAL;
530 
531         if (!oh->class->sysc->sysc_fields) {
532                 WARN(1, "omap_hwmod: %s: offset struct for sysconfig not provided in class\n", oh->name);
533                 return -EINVAL;
534         }
535 
536         /* clocks must be on for this operation */
537         if (oh->_state != _HWMOD_STATE_ENABLED) {
538                 pr_warn("omap_hwmod: %s: dma can be disabled only from enabled state\n", oh->name);
539                 return -EINVAL;
540         }
541 
542         pr_debug("omap_hwmod: %s: setting DMADISABLE\n", oh->name);
543 
544         v = oh->_sysc_cache;
545         dmadisable_mask =
546                 (0x1 << oh->class->sysc->sysc_fields->dmadisable_shift);
547         v |= dmadisable_mask;
548         _write_sysconfig(v, oh);
549 
550         return 0;
551 }
552 
553 /**
554  * _set_module_autoidle: set the OCP_SYSCONFIG AUTOIDLE field in @v
555  * @oh: struct omap_hwmod *
556  * @autoidle: desired AUTOIDLE bitfield value (0 or 1)
557  * @v: pointer to register contents to modify
558  *
559  * Update the module autoidle bit in @v to be @autoidle for the @oh
560  * hwmod.  The autoidle bit controls whether the module can gate
561  * internal clocks automatically when it isn't doing anything; the
562  * exact function of this bit varies on a per-module basis.  This
563  * function does not write to the hardware.  Returns -EINVAL upon
564  * error or 0 upon success.
565  */
566 static int _set_module_autoidle(struct omap_hwmod *oh, u8 autoidle,
567                                 u32 *v)
568 {
569         u32 autoidle_mask;
570         u8 autoidle_shift;
571 
572         if (!oh->class->sysc ||
573             !(oh->class->sysc->sysc_flags & SYSC_HAS_AUTOIDLE))
574                 return -EINVAL;
575 
576         if (!oh->class->sysc->sysc_fields) {
577                 WARN(1, "omap_hwmod: %s: offset struct for sysconfig not provided in class\n", oh->name);
578                 return -EINVAL;
579         }
580 
581         autoidle_shift = oh->class->sysc->sysc_fields->autoidle_shift;
582         autoidle_mask = (0x1 << autoidle_shift);
583 
584         *v &= ~autoidle_mask;
585         *v |= autoidle << autoidle_shift;
586 
587         return 0;
588 }
589 
590 /**
591  * _set_idle_ioring_wakeup - enable/disable IO pad wakeup on hwmod idle for mux
592  * @oh: struct omap_hwmod *
593  * @set_wake: bool value indicating to set (true) or clear (false) wakeup enable
594  *
595  * Set or clear the I/O pad wakeup flag in the mux entries for the
596  * hwmod @oh.  This function changes the @oh->mux->pads_dynamic array
597  * in memory.  If the hwmod is currently idled, and the new idle
598  * values don't match the previous ones, this function will also
599  * update the SCM PADCTRL registers.  Otherwise, if the hwmod is not
600  * currently idled, this function won't touch the hardware: the new
601  * mux settings are written to the SCM PADCTRL registers when the
602  * hwmod is idled.  No return value.
603  */
604 static void _set_idle_ioring_wakeup(struct omap_hwmod *oh, bool set_wake)
605 {
606         struct omap_device_pad *pad;
607         bool change = false;
608         u16 prev_idle;
609         int j;
610 
611         if (!oh->mux || !oh->mux->enabled)
612                 return;
613 
614         for (j = 0; j < oh->mux->nr_pads_dynamic; j++) {
615                 pad = oh->mux->pads_dynamic[j];
616 
617                 if (!(pad->flags & OMAP_DEVICE_PAD_WAKEUP))
618                         continue;
619 
620                 prev_idle = pad->idle;
621 
622                 if (set_wake)
623                         pad->idle |= OMAP_WAKEUP_EN;
624                 else
625                         pad->idle &= ~OMAP_WAKEUP_EN;
626 
627                 if (prev_idle != pad->idle)
628                         change = true;
629         }
630 
631         if (change && oh->_state == _HWMOD_STATE_IDLE)
632                 omap_hwmod_mux(oh->mux, _HWMOD_STATE_IDLE);
633 }
634 
635 /**
636  * _enable_wakeup: set OCP_SYSCONFIG.ENAWAKEUP bit in the hardware
637  * @oh: struct omap_hwmod *
638  *
639  * Allow the hardware module @oh to send wakeups.  Returns -EINVAL
640  * upon error or 0 upon success.
641  */
642 static int _enable_wakeup(struct omap_hwmod *oh, u32 *v)
643 {
644         if (!oh->class->sysc ||
645             !((oh->class->sysc->sysc_flags & SYSC_HAS_ENAWAKEUP) ||
646               (oh->class->sysc->idlemodes & SIDLE_SMART_WKUP) ||
647               (oh->class->sysc->idlemodes & MSTANDBY_SMART_WKUP)))
648                 return -EINVAL;
649 
650         if (!oh->class->sysc->sysc_fields) {
651                 WARN(1, "omap_hwmod: %s: offset struct for sysconfig not provided in class\n", oh->name);
652                 return -EINVAL;
653         }
654 
655         if (oh->class->sysc->sysc_flags & SYSC_HAS_ENAWAKEUP)
656                 *v |= 0x1 << oh->class->sysc->sysc_fields->enwkup_shift;
657 
658         if (oh->class->sysc->idlemodes & SIDLE_SMART_WKUP)
659                 _set_slave_idlemode(oh, HWMOD_IDLEMODE_SMART_WKUP, v);
660         if (oh->class->sysc->idlemodes & MSTANDBY_SMART_WKUP)
661                 _set_master_standbymode(oh, HWMOD_IDLEMODE_SMART_WKUP, v);
662 
663         /* XXX test pwrdm_get_wken for this hwmod's subsystem */
664 
665         return 0;
666 }
667 
668 /**
669  * _disable_wakeup: clear OCP_SYSCONFIG.ENAWAKEUP bit in the hardware
670  * @oh: struct omap_hwmod *
671  *
672  * Prevent the hardware module @oh to send wakeups.  Returns -EINVAL
673  * upon error or 0 upon success.
674  */
675 static int _disable_wakeup(struct omap_hwmod *oh, u32 *v)
676 {
677         if (!oh->class->sysc ||
678             !((oh->class->sysc->sysc_flags & SYSC_HAS_ENAWAKEUP) ||
679               (oh->class->sysc->idlemodes & SIDLE_SMART_WKUP) ||
680               (oh->class->sysc->idlemodes & MSTANDBY_SMART_WKUP)))
681                 return -EINVAL;
682 
683         if (!oh->class->sysc->sysc_fields) {
684                 WARN(1, "omap_hwmod: %s: offset struct for sysconfig not provided in class\n", oh->name);
685                 return -EINVAL;
686         }
687 
688         if (oh->class->sysc->sysc_flags & SYSC_HAS_ENAWAKEUP)
689                 *v &= ~(0x1 << oh->class->sysc->sysc_fields->enwkup_shift);
690 
691         if (oh->class->sysc->idlemodes & SIDLE_SMART_WKUP)
692                 _set_slave_idlemode(oh, HWMOD_IDLEMODE_SMART, v);
693         if (oh->class->sysc->idlemodes & MSTANDBY_SMART_WKUP)
694                 _set_master_standbymode(oh, HWMOD_IDLEMODE_SMART, v);
695 
696         /* XXX test pwrdm_get_wken for this hwmod's subsystem */
697 
698         return 0;
699 }
700 
701 static struct clockdomain *_get_clkdm(struct omap_hwmod *oh)
702 {
703         struct clk_hw_omap *clk;
704 
705         if (oh->clkdm) {
706                 return oh->clkdm;
707         } else if (oh->_clk) {
708                 if (__clk_get_flags(oh->_clk) & CLK_IS_BASIC)
709                         return NULL;
710                 clk = to_clk_hw_omap(__clk_get_hw(oh->_clk));
711                 return  clk->clkdm;
712         }
713         return NULL;
714 }
715 
716 /**
717  * _add_initiator_dep: prevent @oh from smart-idling while @init_oh is active
718  * @oh: struct omap_hwmod *
719  *
720  * Prevent the hardware module @oh from entering idle while the
721  * hardare module initiator @init_oh is active.  Useful when a module
722  * will be accessed by a particular initiator (e.g., if a module will
723  * be accessed by the IVA, there should be a sleepdep between the IVA
724  * initiator and the module).  Only applies to modules in smart-idle
725  * mode.  If the clockdomain is marked as not needing autodeps, return
726  * 0 without doing anything.  Otherwise, returns -EINVAL upon error or
727  * passes along clkdm_add_sleepdep() value upon success.
728  */
729 static int _add_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh)
730 {
731         struct clockdomain *clkdm, *init_clkdm;
732 
733         clkdm = _get_clkdm(oh);
734         init_clkdm = _get_clkdm(init_oh);
735 
736         if (!clkdm || !init_clkdm)
737                 return -EINVAL;
738 
739         if (clkdm && clkdm->flags & CLKDM_NO_AUTODEPS)
740                 return 0;
741 
742         return clkdm_add_sleepdep(clkdm, init_clkdm);
743 }
744 
745 /**
746  * _del_initiator_dep: allow @oh to smart-idle even if @init_oh is active
747  * @oh: struct omap_hwmod *
748  *
749  * Allow the hardware module @oh to enter idle while the hardare
750  * module initiator @init_oh is active.  Useful when a module will not
751  * be accessed by a particular initiator (e.g., if a module will not
752  * be accessed by the IVA, there should be no sleepdep between the IVA
753  * initiator and the module).  Only applies to modules in smart-idle
754  * mode.  If the clockdomain is marked as not needing autodeps, return
755  * 0 without doing anything.  Returns -EINVAL upon error or passes
756  * along clkdm_del_sleepdep() value upon success.
757  */
758 static int _del_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh)
759 {
760         struct clockdomain *clkdm, *init_clkdm;
761 
762         clkdm = _get_clkdm(oh);
763         init_clkdm = _get_clkdm(init_oh);
764 
765         if (!clkdm || !init_clkdm)
766                 return -EINVAL;
767 
768         if (clkdm && clkdm->flags & CLKDM_NO_AUTODEPS)
769                 return 0;
770 
771         return clkdm_del_sleepdep(clkdm, init_clkdm);
772 }
773 
774 /**
775  * _init_main_clk - get a struct clk * for the the hwmod's main functional clk
776  * @oh: struct omap_hwmod *
777  *
778  * Called from _init_clocks().  Populates the @oh _clk (main
779  * functional clock pointer) if a main_clk is present.  Returns 0 on
780  * success or -EINVAL on error.
781  */
782 static int _init_main_clk(struct omap_hwmod *oh)
783 {
784         int ret = 0;
785 
786         if (!oh->main_clk)
787                 return 0;
788 
789         oh->_clk = clk_get(NULL, oh->main_clk);
790         if (IS_ERR(oh->_clk)) {
791                 pr_warn("omap_hwmod: %s: cannot clk_get main_clk %s\n",
792                         oh->name, oh->main_clk);
793                 return -EINVAL;
794         }
795         /*
796          * HACK: This needs a re-visit once clk_prepare() is implemented
797          * to do something meaningful. Today its just a no-op.
798          * If clk_prepare() is used at some point to do things like
799          * voltage scaling etc, then this would have to be moved to
800          * some point where subsystems like i2c and pmic become
801          * available.
802          */
803         clk_prepare(oh->_clk);
804 
805         if (!_get_clkdm(oh))
806                 pr_debug("omap_hwmod: %s: missing clockdomain for %s.\n",
807                            oh->name, oh->main_clk);
808 
809         return ret;
810 }
811 
812 /**
813  * _init_interface_clks - get a struct clk * for the the hwmod's interface clks
814  * @oh: struct omap_hwmod *
815  *
816  * Called from _init_clocks().  Populates the @oh OCP slave interface
817  * clock pointers.  Returns 0 on success or -EINVAL on error.
818  */
819 static int _init_interface_clks(struct omap_hwmod *oh)
820 {
821         struct omap_hwmod_ocp_if *os;
822         struct list_head *p;
823         struct clk *c;
824         int i = 0;
825         int ret = 0;
826 
827         p = oh->slave_ports.next;
828 
829         while (i < oh->slaves_cnt) {
830                 os = _fetch_next_ocp_if(&p, &i);
831                 if (!os->clk)
832                         continue;
833 
834                 c = clk_get(NULL, os->clk);
835                 if (IS_ERR(c)) {
836                         pr_warn("omap_hwmod: %s: cannot clk_get interface_clk %s\n",
837                                 oh->name, os->clk);
838                         ret = -EINVAL;
839                         continue;
840                 }
841                 os->_clk = c;
842                 /*
843                  * HACK: This needs a re-visit once clk_prepare() is implemented
844                  * to do something meaningful. Today its just a no-op.
845                  * If clk_prepare() is used at some point to do things like
846                  * voltage scaling etc, then this would have to be moved to
847                  * some point where subsystems like i2c and pmic become
848                  * available.
849                  */
850                 clk_prepare(os->_clk);
851         }
852 
853         return ret;
854 }
855 
856 /**
857  * _init_opt_clk - get a struct clk * for the the hwmod's optional clocks
858  * @oh: struct omap_hwmod *
859  *
860  * Called from _init_clocks().  Populates the @oh omap_hwmod_opt_clk
861  * clock pointers.  Returns 0 on success or -EINVAL on error.
862  */
863 static int _init_opt_clks(struct omap_hwmod *oh)
864 {
865         struct omap_hwmod_opt_clk *oc;
866         struct clk *c;
867         int i;
868         int ret = 0;
869 
870         for (i = oh->opt_clks_cnt, oc = oh->opt_clks; i > 0; i--, oc++) {
871                 c = clk_get(NULL, oc->clk);
872                 if (IS_ERR(c)) {
873                         pr_warn("omap_hwmod: %s: cannot clk_get opt_clk %s\n",
874                                 oh->name, oc->clk);
875                         ret = -EINVAL;
876                         continue;
877                 }
878                 oc->_clk = c;
879                 /*
880                  * HACK: This needs a re-visit once clk_prepare() is implemented
881                  * to do something meaningful. Today its just a no-op.
882                  * If clk_prepare() is used at some point to do things like
883                  * voltage scaling etc, then this would have to be moved to
884                  * some point where subsystems like i2c and pmic become
885                  * available.
886                  */
887                 clk_prepare(oc->_clk);
888         }
889 
890         return ret;
891 }
892 
893 /**
894  * _enable_clocks - enable hwmod main clock and interface clocks
895  * @oh: struct omap_hwmod *
896  *
897  * Enables all clocks necessary for register reads and writes to succeed
898  * on the hwmod @oh.  Returns 0.
899  */
900 static int _enable_clocks(struct omap_hwmod *oh)
901 {
902         struct omap_hwmod_ocp_if *os;
903         struct list_head *p;
904         int i = 0;
905 
906         pr_debug("omap_hwmod: %s: enabling clocks\n", oh->name);
907 
908         if (oh->_clk)
909                 clk_enable(oh->_clk);
910 
911         p = oh->slave_ports.next;
912 
913         while (i < oh->slaves_cnt) {
914                 os = _fetch_next_ocp_if(&p, &i);
915 
916                 if (os->_clk && (os->flags & OCPIF_SWSUP_IDLE))
917                         clk_enable(os->_clk);
918         }
919 
920         /* The opt clocks are controlled by the device driver. */
921 
922         return 0;
923 }
924 
925 /**
926  * _disable_clocks - disable hwmod main clock and interface clocks
927  * @oh: struct omap_hwmod *
928  *
929  * Disables the hwmod @oh main functional and interface clocks.  Returns 0.
930  */
931 static int _disable_clocks(struct omap_hwmod *oh)
932 {
933         struct omap_hwmod_ocp_if *os;
934         struct list_head *p;
935         int i = 0;
936 
937         pr_debug("omap_hwmod: %s: disabling clocks\n", oh->name);
938 
939         if (oh->_clk)
940                 clk_disable(oh->_clk);
941 
942         p = oh->slave_ports.next;
943 
944         while (i < oh->slaves_cnt) {
945                 os = _fetch_next_ocp_if(&p, &i);
946 
947                 if (os->_clk && (os->flags & OCPIF_SWSUP_IDLE))
948                         clk_disable(os->_clk);
949         }
950 
951         /* The opt clocks are controlled by the device driver. */
952 
953         return 0;
954 }
955 
956 static void _enable_optional_clocks(struct omap_hwmod *oh)
957 {
958         struct omap_hwmod_opt_clk *oc;
959         int i;
960 
961         pr_debug("omap_hwmod: %s: enabling optional clocks\n", oh->name);
962 
963         for (i = oh->opt_clks_cnt, oc = oh->opt_clks; i > 0; i--, oc++)
964                 if (oc->_clk) {
965                         pr_debug("omap_hwmod: enable %s:%s\n", oc->role,
966                                  __clk_get_name(oc->_clk));
967                         clk_enable(oc->_clk);
968                 }
969 }
970 
971 static void _disable_optional_clocks(struct omap_hwmod *oh)
972 {
973         struct omap_hwmod_opt_clk *oc;
974         int i;
975 
976         pr_debug("omap_hwmod: %s: disabling optional clocks\n", oh->name);
977 
978         for (i = oh->opt_clks_cnt, oc = oh->opt_clks; i > 0; i--, oc++)
979                 if (oc->_clk) {
980                         pr_debug("omap_hwmod: disable %s:%s\n", oc->role,
981                                  __clk_get_name(oc->_clk));
982                         clk_disable(oc->_clk);
983                 }
984 }
985 
986 /**
987  * _omap4_enable_module - enable CLKCTRL modulemode on OMAP4
988  * @oh: struct omap_hwmod *
989  *
990  * Enables the PRCM module mode related to the hwmod @oh.
991  * No return value.
992  */
993 static void _omap4_enable_module(struct omap_hwmod *oh)
994 {
995         if (!oh->clkdm || !oh->prcm.omap4.modulemode)
996                 return;
997 
998         pr_debug("omap_hwmod: %s: %s: %d\n",
999                  oh->name, __func__, oh->prcm.omap4.modulemode);
1000 
1001         omap_cm_module_enable(oh->prcm.omap4.modulemode,
1002                               oh->clkdm->prcm_partition,
1003                               oh->clkdm->cm_inst, oh->prcm.omap4.clkctrl_offs);
1004 }
1005 
1006 /**
1007  * _omap4_wait_target_disable - wait for a module to be disabled on OMAP4
1008  * @oh: struct omap_hwmod *
1009  *
1010  * Wait for a module @oh to enter slave idle.  Returns 0 if the module
1011  * does not have an IDLEST bit or if the module successfully enters
1012  * slave idle; otherwise, pass along the return value of the
1013  * appropriate *_cm*_wait_module_idle() function.
1014  */
1015 static int _omap4_wait_target_disable(struct omap_hwmod *oh)
1016 {
1017         if (!oh)
1018                 return -EINVAL;
1019 
1020         if (oh->_int_flags & _HWMOD_NO_MPU_PORT || !oh->clkdm)
1021                 return 0;
1022 
1023         if (oh->flags & HWMOD_NO_IDLEST)
1024                 return 0;
1025 
1026         return omap_cm_wait_module_idle(oh->clkdm->prcm_partition,
1027                                         oh->clkdm->cm_inst,
1028                                         oh->prcm.omap4.clkctrl_offs, 0);
1029 }
1030 
1031 /**
1032  * _count_mpu_irqs - count the number of MPU IRQ lines associated with @oh
1033  * @oh: struct omap_hwmod *oh
1034  *
1035  * Count and return the number of MPU IRQs associated with the hwmod
1036  * @oh.  Used to allocate struct resource data.  Returns 0 if @oh is
1037  * NULL.
1038  */
1039 static int _count_mpu_irqs(struct omap_hwmod *oh)
1040 {
1041         struct omap_hwmod_irq_info *ohii;
1042         int i = 0;
1043 
1044         if (!oh || !oh->mpu_irqs)
1045                 return 0;
1046 
1047         do {
1048                 ohii = &oh->mpu_irqs[i++];
1049         } while (ohii->irq != -1);
1050 
1051         return i-1;
1052 }
1053 
1054 /**
1055  * _count_sdma_reqs - count the number of SDMA request lines associated with @oh
1056  * @oh: struct omap_hwmod *oh
1057  *
1058  * Count and return the number of SDMA request lines associated with
1059  * the hwmod @oh.  Used to allocate struct resource data.  Returns 0
1060  * if @oh is NULL.
1061  */
1062 static int _count_sdma_reqs(struct omap_hwmod *oh)
1063 {
1064         struct omap_hwmod_dma_info *ohdi;
1065         int i = 0;
1066 
1067         if (!oh || !oh->sdma_reqs)
1068                 return 0;
1069 
1070         do {
1071                 ohdi = &oh->sdma_reqs[i++];
1072         } while (ohdi->dma_req != -1);
1073 
1074         return i-1;
1075 }
1076 
1077 /**
1078  * _count_ocp_if_addr_spaces - count the number of address space entries for @oh
1079  * @oh: struct omap_hwmod *oh
1080  *
1081  * Count and return the number of address space ranges associated with
1082  * the hwmod @oh.  Used to allocate struct resource data.  Returns 0
1083  * if @oh is NULL.
1084  */
1085 static int _count_ocp_if_addr_spaces(struct omap_hwmod_ocp_if *os)
1086 {
1087         struct omap_hwmod_addr_space *mem;
1088         int i = 0;
1089 
1090         if (!os || !os->addr)
1091                 return 0;
1092 
1093         do {
1094                 mem = &os->addr[i++];
1095         } while (mem->pa_start != mem->pa_end);
1096 
1097         return i-1;
1098 }
1099 
1100 /**
1101  * _get_mpu_irq_by_name - fetch MPU interrupt line number by name
1102  * @oh: struct omap_hwmod * to operate on
1103  * @name: pointer to the name of the MPU interrupt number to fetch (optional)
1104  * @irq: pointer to an unsigned int to store the MPU IRQ number to
1105  *
1106  * Retrieve a MPU hardware IRQ line number named by @name associated
1107  * with the IP block pointed to by @oh.  The IRQ number will be filled
1108  * into the address pointed to by @dma.  When @name is non-null, the
1109  * IRQ line number associated with the named entry will be returned.
1110  * If @name is null, the first matching entry will be returned.  Data
1111  * order is not meaningful in hwmod data, so callers are strongly
1112  * encouraged to use a non-null @name whenever possible to avoid
1113  * unpredictable effects if hwmod data is later added that causes data
1114  * ordering to change.  Returns 0 upon success or a negative error
1115  * code upon error.
1116  */
1117 static int _get_mpu_irq_by_name(struct omap_hwmod *oh, const char *name,
1118                                 unsigned int *irq)
1119 {
1120         int i;
1121         bool found = false;
1122 
1123         if (!oh->mpu_irqs)
1124                 return -ENOENT;
1125 
1126         i = 0;
1127         while (oh->mpu_irqs[i].irq != -1) {
1128                 if (name == oh->mpu_irqs[i].name ||
1129                     !strcmp(name, oh->mpu_irqs[i].name)) {
1130                         found = true;
1131                         break;
1132                 }
1133                 i++;
1134         }
1135 
1136         if (!found)
1137                 return -ENOENT;
1138 
1139         *irq = oh->mpu_irqs[i].irq;
1140 
1141         return 0;
1142 }
1143 
1144 /**
1145  * _get_sdma_req_by_name - fetch SDMA request line ID by name
1146  * @oh: struct omap_hwmod * to operate on
1147  * @name: pointer to the name of the SDMA request line to fetch (optional)
1148  * @dma: pointer to an unsigned int to store the request line ID to
1149  *
1150  * Retrieve an SDMA request line ID named by @name on the IP block
1151  * pointed to by @oh.  The ID will be filled into the address pointed
1152  * to by @dma.  When @name is non-null, the request line ID associated
1153  * with the named entry will be returned.  If @name is null, the first
1154  * matching entry will be returned.  Data order is not meaningful in
1155  * hwmod data, so callers are strongly encouraged to use a non-null
1156  * @name whenever possible to avoid unpredictable effects if hwmod
1157  * data is later added that causes data ordering to change.  Returns 0
1158  * upon success or a negative error code upon error.
1159  */
1160 static int _get_sdma_req_by_name(struct omap_hwmod *oh, const char *name,
1161                                  unsigned int *dma)
1162 {
1163         int i;
1164         bool found = false;
1165 
1166         if (!oh->sdma_reqs)
1167                 return -ENOENT;
1168 
1169         i = 0;
1170         while (oh->sdma_reqs[i].dma_req != -1) {
1171                 if (name == oh->sdma_reqs[i].name ||
1172                     !strcmp(name, oh->sdma_reqs[i].name)) {
1173                         found = true;
1174                         break;
1175                 }
1176                 i++;
1177         }
1178 
1179         if (!found)
1180                 return -ENOENT;
1181 
1182         *dma = oh->sdma_reqs[i].dma_req;
1183 
1184         return 0;
1185 }
1186 
1187 /**
1188  * _get_addr_space_by_name - fetch address space start & end by name
1189  * @oh: struct omap_hwmod * to operate on
1190  * @name: pointer to the name of the address space to fetch (optional)
1191  * @pa_start: pointer to a u32 to store the starting address to
1192  * @pa_end: pointer to a u32 to store the ending address to
1193  *
1194  * Retrieve address space start and end addresses for the IP block
1195  * pointed to by @oh.  The data will be filled into the addresses
1196  * pointed to by @pa_start and @pa_end.  When @name is non-null, the
1197  * address space data associated with the named entry will be
1198  * returned.  If @name is null, the first matching entry will be
1199  * returned.  Data order is not meaningful in hwmod data, so callers
1200  * are strongly encouraged to use a non-null @name whenever possible
1201  * to avoid unpredictable effects if hwmod data is later added that
1202  * causes data ordering to change.  Returns 0 upon success or a
1203  * negative error code upon error.
1204  */
1205 static int _get_addr_space_by_name(struct omap_hwmod *oh, const char *name,
1206                                    u32 *pa_start, u32 *pa_end)
1207 {
1208         int i, j;
1209         struct omap_hwmod_ocp_if *os;
1210         struct list_head *p = NULL;
1211         bool found = false;
1212 
1213         p = oh->slave_ports.next;
1214 
1215         i = 0;
1216         while (i < oh->slaves_cnt) {
1217                 os = _fetch_next_ocp_if(&p, &i);
1218 
1219                 if (!os->addr)
1220                         return -ENOENT;
1221 
1222                 j = 0;
1223                 while (os->addr[j].pa_start != os->addr[j].pa_end) {
1224                         if (name == os->addr[j].name ||
1225                             !strcmp(name, os->addr[j].name)) {
1226                                 found = true;
1227                                 break;
1228                         }
1229                         j++;
1230                 }
1231 
1232                 if (found)
1233                         break;
1234         }
1235 
1236         if (!found)
1237                 return -ENOENT;
1238 
1239         *pa_start = os->addr[j].pa_start;
1240         *pa_end = os->addr[j].pa_end;
1241 
1242         return 0;
1243 }
1244 
1245 /**
1246  * _save_mpu_port_index - find and save the index to @oh's MPU port
1247  * @oh: struct omap_hwmod *
1248  *
1249  * Determines the array index of the OCP slave port that the MPU uses
1250  * to address the device, and saves it into the struct omap_hwmod.
1251  * Intended to be called during hwmod registration only. No return
1252  * value.
1253  */
1254 static void __init _save_mpu_port_index(struct omap_hwmod *oh)
1255 {
1256         struct omap_hwmod_ocp_if *os = NULL;
1257         struct list_head *p;
1258         int i = 0;
1259 
1260         if (!oh)
1261                 return;
1262 
1263         oh->_int_flags |= _HWMOD_NO_MPU_PORT;
1264 
1265         p = oh->slave_ports.next;
1266 
1267         while (i < oh->slaves_cnt) {
1268                 os = _fetch_next_ocp_if(&p, &i);
1269                 if (os->user & OCP_USER_MPU) {
1270                         oh->_mpu_port = os;
1271                         oh->_int_flags &= ~_HWMOD_NO_MPU_PORT;
1272                         break;
1273                 }
1274         }
1275 
1276         return;
1277 }
1278 
1279 /**
1280  * _find_mpu_rt_port - return omap_hwmod_ocp_if accessible by the MPU
1281  * @oh: struct omap_hwmod *
1282  *
1283  * Given a pointer to a struct omap_hwmod record @oh, return a pointer
1284  * to the struct omap_hwmod_ocp_if record that is used by the MPU to
1285  * communicate with the IP block.  This interface need not be directly
1286  * connected to the MPU (and almost certainly is not), but is directly
1287  * connected to the IP block represented by @oh.  Returns a pointer
1288  * to the struct omap_hwmod_ocp_if * upon success, or returns NULL upon
1289  * error or if there does not appear to be a path from the MPU to this
1290  * IP block.
1291  */
1292 static struct omap_hwmod_ocp_if *_find_mpu_rt_port(struct omap_hwmod *oh)
1293 {
1294         if (!oh || oh->_int_flags & _HWMOD_NO_MPU_PORT || oh->slaves_cnt == 0)
1295                 return NULL;
1296 
1297         return oh->_mpu_port;
1298 };
1299 
1300 /**
1301  * _find_mpu_rt_addr_space - return MPU register target address space for @oh
1302  * @oh: struct omap_hwmod *
1303  *
1304  * Returns a pointer to the struct omap_hwmod_addr_space record representing
1305  * the register target MPU address space; or returns NULL upon error.
1306  */
1307 static struct omap_hwmod_addr_space * __init _find_mpu_rt_addr_space(struct omap_hwmod *oh)
1308 {
1309         struct omap_hwmod_ocp_if *os;
1310         struct omap_hwmod_addr_space *mem;
1311         int found = 0, i = 0;
1312 
1313         os = _find_mpu_rt_port(oh);
1314         if (!os || !os->addr)
1315                 return NULL;
1316 
1317         do {
1318                 mem = &os->addr[i++];
1319                 if (mem->flags & ADDR_TYPE_RT)
1320                         found = 1;
1321         } while (!found && mem->pa_start != mem->pa_end);
1322 
1323         return (found) ? mem : NULL;
1324 }
1325 
1326 /**
1327  * _enable_sysc - try to bring a module out of idle via OCP_SYSCONFIG
1328  * @oh: struct omap_hwmod *
1329  *
1330  * Ensure that the OCP_SYSCONFIG register for the IP block represented
1331  * by @oh is set to indicate to the PRCM that the IP block is active.
1332  * Usually this means placing the module into smart-idle mode and
1333  * smart-standby, but if there is a bug in the automatic idle handling
1334  * for the IP block, it may need to be placed into the force-idle or
1335  * no-idle variants of these modes.  No return value.
1336  */
1337 static void _enable_sysc(struct omap_hwmod *oh)
1338 {
1339         u8 idlemode, sf;
1340         u32 v;
1341         bool clkdm_act;
1342         struct clockdomain *clkdm;
1343 
1344         if (!oh->class->sysc)
1345                 return;
1346 
1347         /*
1348          * Wait until reset has completed, this is needed as the IP
1349          * block is reset automatically by hardware in some cases
1350          * (off-mode for example), and the drivers require the
1351          * IP to be ready when they access it
1352          */
1353         if (oh->flags & HWMOD_CONTROL_OPT_CLKS_IN_RESET)
1354                 _enable_optional_clocks(oh);
1355         _wait_softreset_complete(oh);
1356         if (oh->flags & HWMOD_CONTROL_OPT_CLKS_IN_RESET)
1357                 _disable_optional_clocks(oh);
1358 
1359         v = oh->_sysc_cache;
1360         sf = oh->class->sysc->sysc_flags;
1361 
1362         clkdm = _get_clkdm(oh);
1363         if (sf & SYSC_HAS_SIDLEMODE) {
1364                 if (oh->flags & HWMOD_SWSUP_SIDLE ||
1365                     oh->flags & HWMOD_SWSUP_SIDLE_ACT) {
1366                         idlemode = HWMOD_IDLEMODE_NO;
1367                 } else {
1368                         if (sf & SYSC_HAS_ENAWAKEUP)
1369                                 _enable_wakeup(oh, &v);
1370                         if (oh->class->sysc->idlemodes & SIDLE_SMART_WKUP)
1371                                 idlemode = HWMOD_IDLEMODE_SMART_WKUP;
1372                         else
1373                                 idlemode = HWMOD_IDLEMODE_SMART;
1374                 }
1375 
1376                 /*
1377                  * This is special handling for some IPs like
1378                  * 32k sync timer. Force them to idle!
1379                  */
1380                 clkdm_act = (clkdm && clkdm->flags & CLKDM_ACTIVE_WITH_MPU);
1381                 if (clkdm_act && !(oh->class->sysc->idlemodes &
1382                                    (SIDLE_SMART | SIDLE_SMART_WKUP)))
1383                         idlemode = HWMOD_IDLEMODE_FORCE;
1384 
1385                 _set_slave_idlemode(oh, idlemode, &v);
1386         }
1387 
1388         if (sf & SYSC_HAS_MIDLEMODE) {
1389                 if (oh->flags & HWMOD_FORCE_MSTANDBY) {
1390                         idlemode = HWMOD_IDLEMODE_FORCE;
1391                 } else if (oh->flags & HWMOD_SWSUP_MSTANDBY) {
1392                         idlemode = HWMOD_IDLEMODE_NO;
1393                 } else {
1394                         if (sf & SYSC_HAS_ENAWAKEUP)
1395                                 _enable_wakeup(oh, &v);
1396                         if (oh->class->sysc->idlemodes & MSTANDBY_SMART_WKUP)
1397                                 idlemode = HWMOD_IDLEMODE_SMART_WKUP;
1398                         else
1399                                 idlemode = HWMOD_IDLEMODE_SMART;
1400                 }
1401                 _set_master_standbymode(oh, idlemode, &v);
1402         }
1403 
1404         /*
1405          * XXX The clock framework should handle this, by
1406          * calling into this code.  But this must wait until the
1407          * clock structures are tagged with omap_hwmod entries
1408          */
1409         if ((oh->flags & HWMOD_SET_DEFAULT_CLOCKACT) &&
1410             (sf & SYSC_HAS_CLOCKACTIVITY))
1411                 _set_clockactivity(oh, oh->class->sysc->clockact, &v);
1412 
1413         /* If the cached value is the same as the new value, skip the write */
1414         if (oh->_sysc_cache != v)
1415                 _write_sysconfig(v, oh);
1416 
1417         /*
1418          * Set the autoidle bit only after setting the smartidle bit
1419          * Setting this will not have any impact on the other modules.
1420          */
1421         if (sf & SYSC_HAS_AUTOIDLE) {
1422                 idlemode = (oh->flags & HWMOD_NO_OCP_AUTOIDLE) ?
1423                         0 : 1;
1424                 _set_module_autoidle(oh, idlemode, &v);
1425                 _write_sysconfig(v, oh);
1426         }
1427 }
1428 
1429 /**
1430  * _idle_sysc - try to put a module into idle via OCP_SYSCONFIG
1431  * @oh: struct omap_hwmod *
1432  *
1433  * If module is marked as SWSUP_SIDLE, force the module into slave
1434  * idle; otherwise, configure it for smart-idle.  If module is marked
1435  * as SWSUP_MSUSPEND, force the module into master standby; otherwise,
1436  * configure it for smart-standby.  No return value.
1437  */
1438 static void _idle_sysc(struct omap_hwmod *oh)
1439 {
1440         u8 idlemode, sf;
1441         u32 v;
1442 
1443         if (!oh->class->sysc)
1444                 return;
1445 
1446         v = oh->_sysc_cache;
1447         sf = oh->class->sysc->sysc_flags;
1448 
1449         if (sf & SYSC_HAS_SIDLEMODE) {
1450                 if (oh->flags & HWMOD_SWSUP_SIDLE) {
1451                         idlemode = HWMOD_IDLEMODE_FORCE;
1452                 } else {
1453                         if (sf & SYSC_HAS_ENAWAKEUP)
1454                                 _enable_wakeup(oh, &v);
1455                         if (oh->class->sysc->idlemodes & SIDLE_SMART_WKUP)
1456                                 idlemode = HWMOD_IDLEMODE_SMART_WKUP;
1457                         else
1458                                 idlemode = HWMOD_IDLEMODE_SMART;
1459                 }
1460                 _set_slave_idlemode(oh, idlemode, &v);
1461         }
1462 
1463         if (sf & SYSC_HAS_MIDLEMODE) {
1464                 if ((oh->flags & HWMOD_SWSUP_MSTANDBY) ||
1465                     (oh->flags & HWMOD_FORCE_MSTANDBY)) {
1466                         idlemode = HWMOD_IDLEMODE_FORCE;
1467                 } else {
1468                         if (sf & SYSC_HAS_ENAWAKEUP)
1469                                 _enable_wakeup(oh, &v);
1470                         if (oh->class->sysc->idlemodes & MSTANDBY_SMART_WKUP)
1471                                 idlemode = HWMOD_IDLEMODE_SMART_WKUP;
1472                         else
1473                                 idlemode = HWMOD_IDLEMODE_SMART;
1474                 }
1475                 _set_master_standbymode(oh, idlemode, &v);
1476         }
1477 
1478         _write_sysconfig(v, oh);
1479 }
1480 
1481 /**
1482  * _shutdown_sysc - force a module into idle via OCP_SYSCONFIG
1483  * @oh: struct omap_hwmod *
1484  *
1485  * Force the module into slave idle and master suspend. No return
1486  * value.
1487  */
1488 static void _shutdown_sysc(struct omap_hwmod *oh)
1489 {
1490         u32 v;
1491         u8 sf;
1492 
1493         if (!oh->class->sysc)
1494                 return;
1495 
1496         v = oh->_sysc_cache;
1497         sf = oh->class->sysc->sysc_flags;
1498 
1499         if (sf & SYSC_HAS_SIDLEMODE)
1500                 _set_slave_idlemode(oh, HWMOD_IDLEMODE_FORCE, &v);
1501 
1502         if (sf & SYSC_HAS_MIDLEMODE)
1503                 _set_master_standbymode(oh, HWMOD_IDLEMODE_FORCE, &v);
1504 
1505         if (sf & SYSC_HAS_AUTOIDLE)
1506                 _set_module_autoidle(oh, 1, &v);
1507 
1508         _write_sysconfig(v, oh);
1509 }
1510 
1511 /**
1512  * _lookup - find an omap_hwmod by name
1513  * @name: find an omap_hwmod by name
1514  *
1515  * Return a pointer to an omap_hwmod by name, or NULL if not found.
1516  */
1517 static struct omap_hwmod *_lookup(const char *name)
1518 {
1519         struct omap_hwmod *oh, *temp_oh;
1520 
1521         oh = NULL;
1522 
1523         list_for_each_entry(temp_oh, &omap_hwmod_list, node) {
1524                 if (!strcmp(name, temp_oh->name)) {
1525                         oh = temp_oh;
1526                         break;
1527                 }
1528         }
1529 
1530         return oh;
1531 }
1532 
1533 /**
1534  * _init_clkdm - look up a clockdomain name, store pointer in omap_hwmod
1535  * @oh: struct omap_hwmod *
1536  *
1537  * Convert a clockdomain name stored in a struct omap_hwmod into a
1538  * clockdomain pointer, and save it into the struct omap_hwmod.
1539  * Return -EINVAL if the clkdm_name lookup failed.
1540  */
1541 static int _init_clkdm(struct omap_hwmod *oh)
1542 {
1543         if (!oh->clkdm_name) {
1544                 pr_debug("omap_hwmod: %s: missing clockdomain\n", oh->name);
1545                 return 0;
1546         }
1547 
1548         oh->clkdm = clkdm_lookup(oh->clkdm_name);
1549         if (!oh->clkdm) {
1550                 pr_warn("omap_hwmod: %s: could not associate to clkdm %s\n",
1551                         oh->name, oh->clkdm_name);
1552                 return 0;
1553         }
1554 
1555         pr_debug("omap_hwmod: %s: associated to clkdm %s\n",
1556                 oh->name, oh->clkdm_name);
1557 
1558         return 0;
1559 }
1560 
1561 /**
1562  * _init_clocks - clk_get() all clocks associated with this hwmod. Retrieve as
1563  * well the clockdomain.
1564  * @oh: struct omap_hwmod *
1565  * @data: not used; pass NULL
1566  *
1567  * Called by omap_hwmod_setup_*() (after omap2_clk_init()).
1568  * Resolves all clock names embedded in the hwmod.  Returns 0 on
1569  * success, or a negative error code on failure.
1570  */
1571 static int _init_clocks(struct omap_hwmod *oh, void *data)
1572 {
1573         int ret = 0;
1574 
1575         if (oh->_state != _HWMOD_STATE_REGISTERED)
1576                 return 0;
1577 
1578         pr_debug("omap_hwmod: %s: looking up clocks\n", oh->name);
1579 
1580         if (soc_ops.init_clkdm)
1581                 ret |= soc_ops.init_clkdm(oh);
1582 
1583         ret |= _init_main_clk(oh);
1584         ret |= _init_interface_clks(oh);
1585         ret |= _init_opt_clks(oh);
1586 
1587         if (!ret)
1588                 oh->_state = _HWMOD_STATE_CLKS_INITED;
1589         else
1590                 pr_warn("omap_hwmod: %s: cannot _init_clocks\n", oh->name);
1591 
1592         return ret;
1593 }
1594 
1595 /**
1596  * _lookup_hardreset - fill register bit info for this hwmod/reset line
1597  * @oh: struct omap_hwmod *
1598  * @name: name of the reset line in the context of this hwmod
1599  * @ohri: struct omap_hwmod_rst_info * that this function will fill in
1600  *
1601  * Return the bit position of the reset line that match the
1602  * input name. Return -ENOENT if not found.
1603  */
1604 static int _lookup_hardreset(struct omap_hwmod *oh, const char *name,
1605                              struct omap_hwmod_rst_info *ohri)
1606 {
1607         int i;
1608 
1609         for (i = 0; i < oh->rst_lines_cnt; i++) {
1610                 const char *rst_line = oh->rst_lines[i].name;
1611                 if (!strcmp(rst_line, name)) {
1612                         ohri->rst_shift = oh->rst_lines[i].rst_shift;
1613                         ohri->st_shift = oh->rst_lines[i].st_shift;
1614                         pr_debug("omap_hwmod: %s: %s: %s: rst %d st %d\n",
1615                                  oh->name, __func__, rst_line, ohri->rst_shift,
1616                                  ohri->st_shift);
1617 
1618                         return 0;
1619                 }
1620         }
1621 
1622         return -ENOENT;
1623 }
1624 
1625 /**
1626  * _assert_hardreset - assert the HW reset line of submodules
1627  * contained in the hwmod module.
1628  * @oh: struct omap_hwmod *
1629  * @name: name of the reset line to lookup and assert
1630  *
1631  * Some IP like dsp, ipu or iva contain processor that require an HW
1632  * reset line to be assert / deassert in order to enable fully the IP.
1633  * Returns -EINVAL if @oh is null, -ENOSYS if we have no way of
1634  * asserting the hardreset line on the currently-booted SoC, or passes
1635  * along the return value from _lookup_hardreset() or the SoC's
1636  * assert_hardreset code.
1637  */
1638 static int _assert_hardreset(struct omap_hwmod *oh, const char *name)
1639 {
1640         struct omap_hwmod_rst_info ohri;
1641         int ret = -EINVAL;
1642 
1643         if (!oh)
1644                 return -EINVAL;
1645 
1646         if (!soc_ops.assert_hardreset)
1647                 return -ENOSYS;
1648 
1649         ret = _lookup_hardreset(oh, name, &ohri);
1650         if (ret < 0)
1651                 return ret;
1652 
1653         ret = soc_ops.assert_hardreset(oh, &ohri);
1654 
1655         return ret;
1656 }
1657 
1658 /**
1659  * _deassert_hardreset - deassert the HW reset line of submodules contained
1660  * in the hwmod module.
1661  * @oh: struct omap_hwmod *
1662  * @name: name of the reset line to look up and deassert
1663  *
1664  * Some IP like dsp, ipu or iva contain processor that require an HW
1665  * reset line to be assert / deassert in order to enable fully the IP.
1666  * Returns -EINVAL if @oh is null, -ENOSYS if we have no way of
1667  * deasserting the hardreset line on the currently-booted SoC, or passes
1668  * along the return value from _lookup_hardreset() or the SoC's
1669  * deassert_hardreset code.
1670  */
1671 static int _deassert_hardreset(struct omap_hwmod *oh, const char *name)
1672 {
1673         struct omap_hwmod_rst_info ohri;
1674         int ret = -EINVAL;
1675         int hwsup = 0;
1676 
1677         if (!oh)
1678                 return -EINVAL;
1679 
1680         if (!soc_ops.deassert_hardreset)
1681                 return -ENOSYS;
1682 
1683         ret = _lookup_hardreset(oh, name, &ohri);
1684         if (ret < 0)
1685                 return ret;
1686 
1687         if (oh->clkdm) {
1688                 /*
1689                  * A clockdomain must be in SW_SUP otherwise reset
1690                  * might not be completed. The clockdomain can be set
1691                  * in HW_AUTO only when the module become ready.
1692                  */
1693                 hwsup = clkdm_in_hwsup(oh->clkdm);
1694                 ret = clkdm_hwmod_enable(oh->clkdm, oh);
1695                 if (ret) {
1696                         WARN(1, "omap_hwmod: %s: could not enable clockdomain %s: %d\n",
1697                              oh->name, oh->clkdm->name, ret);
1698                         return ret;
1699                 }
1700         }
1701 
1702         _enable_clocks(oh);
1703         if (soc_ops.enable_module)
1704                 soc_ops.enable_module(oh);
1705 
1706         ret = soc_ops.deassert_hardreset(oh, &ohri);
1707 
1708         if (soc_ops.disable_module)
1709                 soc_ops.disable_module(oh);
1710         _disable_clocks(oh);
1711 
1712         if (ret == -EBUSY)
1713                 pr_warn("omap_hwmod: %s: failed to hardreset\n", oh->name);
1714 
1715         if (oh->clkdm) {
1716                 /*
1717                  * Set the clockdomain to HW_AUTO, assuming that the
1718                  * previous state was HW_AUTO.
1719                  */
1720                 if (hwsup)
1721                         clkdm_allow_idle(oh->clkdm);
1722 
1723                 clkdm_hwmod_disable(oh->clkdm, oh);
1724         }
1725 
1726         return ret;
1727 }
1728 
1729 /**
1730  * _read_hardreset - read the HW reset line state of submodules
1731  * contained in the hwmod module
1732  * @oh: struct omap_hwmod *
1733  * @name: name of the reset line to look up and read
1734  *
1735  * Return the state of the reset line.  Returns -EINVAL if @oh is
1736  * null, -ENOSYS if we have no way of reading the hardreset line
1737  * status on the currently-booted SoC, or passes along the return
1738  * value from _lookup_hardreset() or the SoC's is_hardreset_asserted
1739  * code.
1740  */
1741 static int _read_hardreset(struct omap_hwmod *oh, const char *name)
1742 {
1743         struct omap_hwmod_rst_info ohri;
1744         int ret = -EINVAL;
1745 
1746         if (!oh)
1747                 return -EINVAL;
1748 
1749         if (!soc_ops.is_hardreset_asserted)
1750                 return -ENOSYS;
1751 
1752         ret = _lookup_hardreset(oh, name, &ohri);
1753         if (ret < 0)
1754                 return ret;
1755 
1756         return soc_ops.is_hardreset_asserted(oh, &ohri);
1757 }
1758 
1759 /**
1760  * _are_all_hardreset_lines_asserted - return true if the @oh is hard-reset
1761  * @oh: struct omap_hwmod *
1762  *
1763  * If all hardreset lines associated with @oh are asserted, then return true.
1764  * Otherwise, if part of @oh is out hardreset or if no hardreset lines
1765  * associated with @oh are asserted, then return false.
1766  * This function is used to avoid executing some parts of the IP block
1767  * enable/disable sequence if its hardreset line is set.
1768  */
1769 static bool _are_all_hardreset_lines_asserted(struct omap_hwmod *oh)
1770 {
1771         int i, rst_cnt = 0;
1772 
1773         if (oh->rst_lines_cnt == 0)
1774                 return false;
1775 
1776         for (i = 0; i < oh->rst_lines_cnt; i++)
1777                 if (_read_hardreset(oh, oh->rst_lines[i].name) > 0)
1778                         rst_cnt++;
1779 
1780         if (oh->rst_lines_cnt == rst_cnt)
1781                 return true;
1782 
1783         return false;
1784 }
1785 
1786 /**
1787  * _are_any_hardreset_lines_asserted - return true if any part of @oh is
1788  * hard-reset
1789  * @oh: struct omap_hwmod *
1790  *
1791  * If any hardreset lines associated with @oh are asserted, then
1792  * return true.  Otherwise, if no hardreset lines associated with @oh
1793  * are asserted, or if @oh has no hardreset lines, then return false.
1794  * This function is used to avoid executing some parts of the IP block
1795  * enable/disable sequence if any hardreset line is set.
1796  */
1797 static bool _are_any_hardreset_lines_asserted(struct omap_hwmod *oh)
1798 {
1799         int rst_cnt = 0;
1800         int i;
1801 
1802         for (i = 0; i < oh->rst_lines_cnt && rst_cnt == 0; i++)
1803                 if (_read_hardreset(oh, oh->rst_lines[i].name) > 0)
1804                         rst_cnt++;
1805 
1806         return (rst_cnt) ? true : false;
1807 }
1808 
1809 /**
1810  * _omap4_disable_module - enable CLKCTRL modulemode on OMAP4
1811  * @oh: struct omap_hwmod *
1812  *
1813  * Disable the PRCM module mode related to the hwmod @oh.
1814  * Return EINVAL if the modulemode is not supported and 0 in case of success.
1815  */
1816 static int _omap4_disable_module(struct omap_hwmod *oh)
1817 {
1818         int v;
1819 
1820         if (!oh->clkdm || !oh->prcm.omap4.modulemode)
1821                 return -EINVAL;
1822 
1823         /*
1824          * Since integration code might still be doing something, only
1825          * disable if all lines are under hardreset.
1826          */
1827         if (_are_any_hardreset_lines_asserted(oh))
1828                 return 0;
1829 
1830         pr_debug("omap_hwmod: %s: %s\n", oh->name, __func__);
1831 
1832         omap_cm_module_disable(oh->clkdm->prcm_partition, oh->clkdm->cm_inst,
1833                                oh->prcm.omap4.clkctrl_offs);
1834 
1835         v = _omap4_wait_target_disable(oh);
1836         if (v)
1837                 pr_warn("omap_hwmod: %s: _wait_target_disable failed\n",
1838                         oh->name);
1839 
1840         return 0;
1841 }
1842 
1843 /**
1844  * _ocp_softreset - reset an omap_hwmod via the OCP_SYSCONFIG bit
1845  * @oh: struct omap_hwmod *
1846  *
1847  * Resets an omap_hwmod @oh via the OCP_SYSCONFIG bit.  hwmod must be
1848  * enabled for this to work.  Returns -ENOENT if the hwmod cannot be
1849  * reset this way, -EINVAL if the hwmod is in the wrong state,
1850  * -ETIMEDOUT if the module did not reset in time, or 0 upon success.
1851  *
1852  * In OMAP3 a specific SYSSTATUS register is used to get the reset status.
1853  * Starting in OMAP4, some IPs do not have SYSSTATUS registers and instead
1854  * use the SYSCONFIG softreset bit to provide the status.
1855  *
1856  * Note that some IP like McBSP do have reset control but don't have
1857  * reset status.
1858  */
1859 static int _ocp_softreset(struct omap_hwmod *oh)
1860 {
1861         u32 v;
1862         int c = 0;
1863         int ret = 0;
1864 
1865         if (!oh->class->sysc ||
1866             !(oh->class->sysc->sysc_flags & SYSC_HAS_SOFTRESET))
1867                 return -ENOENT;
1868 
1869         /* clocks must be on for this operation */
1870         if (oh->_state != _HWMOD_STATE_ENABLED) {
1871                 pr_warn("omap_hwmod: %s: reset can only be entered from enabled state\n",
1872                         oh->name);
1873                 return -EINVAL;
1874         }
1875 
1876         /* For some modules, all optionnal clocks need to be enabled as well */
1877         if (oh->flags & HWMOD_CONTROL_OPT_CLKS_IN_RESET)
1878                 _enable_optional_clocks(oh);
1879 
1880         pr_debug("omap_hwmod: %s: resetting via OCP SOFTRESET\n", oh->name);
1881 
1882         v = oh->_sysc_cache;
1883         ret = _set_softreset(oh, &v);
1884         if (ret)
1885                 goto dis_opt_clks;
1886 
1887         _write_sysconfig(v, oh);
1888 
1889         if (oh->class->sysc->srst_udelay)
1890                 udelay(oh->class->sysc->srst_udelay);
1891 
1892         c = _wait_softreset_complete(oh);
1893         if (c == MAX_MODULE_SOFTRESET_WAIT) {
1894                 pr_warn("omap_hwmod: %s: softreset failed (waited %d usec)\n",
1895                         oh->name, MAX_MODULE_SOFTRESET_WAIT);
1896                 ret = -ETIMEDOUT;
1897                 goto dis_opt_clks;
1898         } else {
1899                 pr_debug("omap_hwmod: %s: softreset in %d usec\n", oh->name, c);
1900         }
1901 
1902         ret = _clear_softreset(oh, &v);
1903         if (ret)
1904                 goto dis_opt_clks;
1905 
1906         _write_sysconfig(v, oh);
1907 
1908         /*
1909          * XXX add _HWMOD_STATE_WEDGED for modules that don't come back from
1910          * _wait_target_ready() or _reset()
1911          */
1912 
1913 dis_opt_clks:
1914         if (oh->flags & HWMOD_CONTROL_OPT_CLKS_IN_RESET)
1915                 _disable_optional_clocks(oh);
1916 
1917         return ret;
1918 }
1919 
1920 /**
1921  * _reset - reset an omap_hwmod
1922  * @oh: struct omap_hwmod *
1923  *
1924  * Resets an omap_hwmod @oh.  If the module has a custom reset
1925  * function pointer defined, then call it to reset the IP block, and
1926  * pass along its return value to the caller.  Otherwise, if the IP
1927  * block has an OCP_SYSCONFIG register with a SOFTRESET bitfield
1928  * associated with it, call a function to reset the IP block via that
1929  * method, and pass along the return value to the caller.  Finally, if
1930  * the IP block has some hardreset lines associated with it, assert
1931  * all of those, but do _not_ deassert them. (This is because driver
1932  * authors have expressed an apparent requirement to control the
1933  * deassertion of the hardreset lines themselves.)
1934  *
1935  * The default software reset mechanism for most OMAP IP blocks is
1936  * triggered via the OCP_SYSCONFIG.SOFTRESET bit.  However, some
1937  * hwmods cannot be reset via this method.  Some are not targets and
1938  * therefore have no OCP header registers to access.  Others (like the
1939  * IVA) have idiosyncratic reset sequences.  So for these relatively
1940  * rare cases, custom reset code can be supplied in the struct
1941  * omap_hwmod_class .reset function pointer.
1942  *
1943  * _set_dmadisable() is called to set the DMADISABLE bit so that it
1944  * does not prevent idling of the system. This is necessary for cases
1945  * where ROMCODE/BOOTLOADER uses dma and transfers control to the
1946  * kernel without disabling dma.
1947  *
1948  * Passes along the return value from either _ocp_softreset() or the
1949  * custom reset function - these must return -EINVAL if the hwmod
1950  * cannot be reset this way or if the hwmod is in the wrong state,
1951  * -ETIMEDOUT if the module did not reset in time, or 0 upon success.
1952  */
1953 static int _reset(struct omap_hwmod *oh)
1954 {
1955         int i, r;
1956 
1957         pr_debug("omap_hwmod: %s: resetting\n", oh->name);
1958 
1959         if (oh->class->reset) {
1960                 r = oh->class->reset(oh);
1961         } else {
1962                 if (oh->rst_lines_cnt > 0) {
1963                         for (i = 0; i < oh->rst_lines_cnt; i++)
1964                                 _assert_hardreset(oh, oh->rst_lines[i].name);
1965                         return 0;
1966                 } else {
1967                         r = _ocp_softreset(oh);
1968                         if (r == -ENOENT)
1969                                 r = 0;
1970                 }
1971         }
1972 
1973         _set_dmadisable(oh);
1974 
1975         /*
1976          * OCP_SYSCONFIG bits need to be reprogrammed after a
1977          * softreset.  The _enable() function should be split to avoid
1978          * the rewrite of the OCP_SYSCONFIG register.
1979          */
1980         if (oh->class->sysc) {
1981                 _update_sysc_cache(oh);
1982                 _enable_sysc(oh);
1983         }
1984 
1985         return r;
1986 }
1987 
1988 /**
1989  * _reconfigure_io_chain - clear any I/O chain wakeups and reconfigure chain
1990  *
1991  * Call the appropriate PRM function to clear any logged I/O chain
1992  * wakeups and to reconfigure the chain.  This apparently needs to be
1993  * done upon every mux change.  Since hwmods can be concurrently
1994  * enabled and idled, hold a spinlock around the I/O chain
1995  * reconfiguration sequence.  No return value.
1996  *
1997  * XXX When the PRM code is moved to drivers, this function can be removed,
1998  * as the PRM infrastructure should abstract this.
1999  */
2000 static void _reconfigure_io_chain(void)
2001 {
2002         unsigned long flags;
2003 
2004         spin_lock_irqsave(&io_chain_lock, flags);
2005 
2006         omap_prm_reconfigure_io_chain();
2007 
2008         spin_unlock_irqrestore(&io_chain_lock, flags);
2009 }
2010 
2011 /**
2012  * _omap4_update_context_lost - increment hwmod context loss counter if
2013  * hwmod context was lost, and clear hardware context loss reg
2014  * @oh: hwmod to check for context loss
2015  *
2016  * If the PRCM indicates that the hwmod @oh lost context, increment
2017  * our in-memory context loss counter, and clear the RM_*_CONTEXT
2018  * bits. No return value.
2019  */
2020 static void _omap4_update_context_lost(struct omap_hwmod *oh)
2021 {
2022         if (oh->prcm.omap4.flags & HWMOD_OMAP4_NO_CONTEXT_LOSS_BIT)
2023                 return;
2024 
2025         if (!prm_was_any_context_lost_old(oh->clkdm->pwrdm.ptr->prcm_partition,
2026                                           oh->clkdm->pwrdm.ptr->prcm_offs,
2027                                           oh->prcm.omap4.context_offs))
2028                 return;
2029 
2030         oh->prcm.omap4.context_lost_counter++;
2031         prm_clear_context_loss_flags_old(oh->clkdm->pwrdm.ptr->prcm_partition,
2032                                          oh->clkdm->pwrdm.ptr->prcm_offs,
2033                                          oh->prcm.omap4.context_offs);
2034 }
2035 
2036 /**
2037  * _omap4_get_context_lost - get context loss counter for a hwmod
2038  * @oh: hwmod to get context loss counter for
2039  *
2040  * Returns the in-memory context loss counter for a hwmod.
2041  */
2042 static int _omap4_get_context_lost(struct omap_hwmod *oh)
2043 {
2044         return oh->prcm.omap4.context_lost_counter;
2045 }
2046 
2047 /**
2048  * _enable_preprogram - Pre-program an IP block during the _enable() process
2049  * @oh: struct omap_hwmod *
2050  *
2051  * Some IP blocks (such as AESS) require some additional programming
2052  * after enable before they can enter idle.  If a function pointer to
2053  * do so is present in the hwmod data, then call it and pass along the
2054  * return value; otherwise, return 0.
2055  */
2056 static int _enable_preprogram(struct omap_hwmod *oh)
2057 {
2058         if (!oh->class->enable_preprogram)
2059                 return 0;
2060 
2061         return oh->class->enable_preprogram(oh);
2062 }
2063 
2064 /**
2065  * _enable - enable an omap_hwmod
2066  * @oh: struct omap_hwmod *
2067  *
2068  * Enables an omap_hwmod @oh such that the MPU can access the hwmod's
2069  * register target.  Returns -EINVAL if the hwmod is in the wrong
2070  * state or passes along the return value of _wait_target_ready().
2071  */
2072 static int _enable(struct omap_hwmod *oh)
2073 {
2074         int r;
2075         int hwsup = 0;
2076 
2077         pr_debug("omap_hwmod: %s: enabling\n", oh->name);
2078 
2079         /*
2080          * hwmods with HWMOD_INIT_NO_IDLE flag set are left in enabled
2081          * state at init.  Now that someone is really trying to enable
2082          * them, just ensure that the hwmod mux is set.
2083          */
2084         if (oh->_int_flags & _HWMOD_SKIP_ENABLE) {
2085                 /*
2086                  * If the caller has mux data populated, do the mux'ing
2087                  * which wouldn't have been done as part of the _enable()
2088                  * done during setup.
2089                  */
2090                 if (oh->mux)
2091                         omap_hwmod_mux(oh->mux, _HWMOD_STATE_ENABLED);
2092 
2093                 oh->_int_flags &= ~_HWMOD_SKIP_ENABLE;
2094                 return 0;
2095         }
2096 
2097         if (oh->_state != _HWMOD_STATE_INITIALIZED &&
2098             oh->_state != _HWMOD_STATE_IDLE &&
2099             oh->_state != _HWMOD_STATE_DISABLED) {
2100                 WARN(1, "omap_hwmod: %s: enabled state can only be entered from initialized, idle, or disabled state\n",
2101                         oh->name);
2102                 return -EINVAL;
2103         }
2104 
2105         /*
2106          * If an IP block contains HW reset lines and all of them are
2107          * asserted, we let integration code associated with that
2108          * block handle the enable.  We've received very little
2109          * information on what those driver authors need, and until
2110          * detailed information is provided and the driver code is
2111          * posted to the public lists, this is probably the best we
2112          * can do.
2113          */
2114         if (_are_all_hardreset_lines_asserted(oh))
2115                 return 0;
2116 
2117         /* Mux pins for device runtime if populated */
2118         if (oh->mux && (!oh->mux->enabled ||
2119                         ((oh->_state == _HWMOD_STATE_IDLE) &&
2120                          oh->mux->pads_dynamic))) {
2121                 omap_hwmod_mux(oh->mux, _HWMOD_STATE_ENABLED);
2122                 _reconfigure_io_chain();
2123         } else if (oh->flags & HWMOD_RECONFIG_IO_CHAIN) {
2124                 _reconfigure_io_chain();
2125         }
2126 
2127         _add_initiator_dep(oh, mpu_oh);
2128 
2129         if (oh->clkdm) {
2130                 /*
2131                  * A clockdomain must be in SW_SUP before enabling
2132                  * completely the module. The clockdomain can be set
2133                  * in HW_AUTO only when the module become ready.
2134                  */
2135                 hwsup = clkdm_in_hwsup(oh->clkdm) &&
2136                         !clkdm_missing_idle_reporting(oh->clkdm);
2137                 r = clkdm_hwmod_enable(oh->clkdm, oh);
2138                 if (r) {
2139                         WARN(1, "omap_hwmod: %s: could not enable clockdomain %s: %d\n",
2140                              oh->name, oh->clkdm->name, r);
2141                         return r;
2142                 }
2143         }
2144 
2145         _enable_clocks(oh);
2146         if (soc_ops.enable_module)
2147                 soc_ops.enable_module(oh);
2148         if (oh->flags & HWMOD_BLOCK_WFI)
2149                 cpu_idle_poll_ctrl(true);
2150 
2151         if (soc_ops.update_context_lost)
2152                 soc_ops.update_context_lost(oh);
2153 
2154         r = (soc_ops.wait_target_ready) ? soc_ops.wait_target_ready(oh) :
2155                 -EINVAL;
2156         if (!r) {
2157                 /*
2158                  * Set the clockdomain to HW_AUTO only if the target is ready,
2159                  * assuming that the previous state was HW_AUTO
2160                  */
2161                 if (oh->clkdm && hwsup)
2162                         clkdm_allow_idle(oh->clkdm);
2163 
2164                 oh->_state = _HWMOD_STATE_ENABLED;
2165 
2166                 /* Access the sysconfig only if the target is ready */
2167                 if (oh->class->sysc) {
2168                         if (!(oh->_int_flags & _HWMOD_SYSCONFIG_LOADED))
2169                                 _update_sysc_cache(oh);
2170                         _enable_sysc(oh);
2171                 }
2172                 r = _enable_preprogram(oh);
2173         } else {
2174                 if (soc_ops.disable_module)
2175                         soc_ops.disable_module(oh);
2176                 _disable_clocks(oh);
2177                 pr_err("omap_hwmod: %s: _wait_target_ready failed: %d\n",
2178                        oh->name, r);
2179 
2180                 if (oh->clkdm)
2181                         clkdm_hwmod_disable(oh->clkdm, oh);
2182         }
2183 
2184         return r;
2185 }
2186 
2187 /**
2188  * _idle - idle an omap_hwmod
2189  * @oh: struct omap_hwmod *
2190  *
2191  * Idles an omap_hwmod @oh.  This should be called once the hwmod has
2192  * no further work.  Returns -EINVAL if the hwmod is in the wrong
2193  * state or returns 0.
2194  */
2195 static int _idle(struct omap_hwmod *oh)
2196 {
2197         pr_debug("omap_hwmod: %s: idling\n", oh->name);
2198 
2199         if (oh->_state != _HWMOD_STATE_ENABLED) {
2200                 WARN(1, "omap_hwmod: %s: idle state can only be entered from enabled state\n",
2201                         oh->name);
2202                 return -EINVAL;
2203         }
2204 
2205         if (_are_all_hardreset_lines_asserted(oh))
2206                 return 0;
2207 
2208         if (oh->class->sysc)
2209                 _idle_sysc(oh);
2210         _del_initiator_dep(oh, mpu_oh);
2211 
2212         if (oh->flags & HWMOD_BLOCK_WFI)
2213                 cpu_idle_poll_ctrl(false);
2214         if (soc_ops.disable_module)
2215                 soc_ops.disable_module(oh);
2216 
2217         /*
2218          * The module must be in idle mode before disabling any parents
2219          * clocks. Otherwise, the parent clock might be disabled before
2220          * the module transition is done, and thus will prevent the
2221          * transition to complete properly.
2222          */
2223         _disable_clocks(oh);
2224         if (oh->clkdm)
2225                 clkdm_hwmod_disable(oh->clkdm, oh);
2226 
2227         /* Mux pins for device idle if populated */
2228         if (oh->mux && oh->mux->pads_dynamic) {
2229                 omap_hwmod_mux(oh->mux, _HWMOD_STATE_IDLE);
2230                 _reconfigure_io_chain();
2231         } else if (oh->flags & HWMOD_RECONFIG_IO_CHAIN) {
2232                 _reconfigure_io_chain();
2233         }
2234 
2235         oh->_state = _HWMOD_STATE_IDLE;
2236 
2237         return 0;
2238 }
2239 
2240 /**
2241  * _shutdown - shutdown an omap_hwmod
2242  * @oh: struct omap_hwmod *
2243  *
2244  * Shut down an omap_hwmod @oh.  This should be called when the driver
2245  * used for the hwmod is removed or unloaded or if the driver is not
2246  * used by the system.  Returns -EINVAL if the hwmod is in the wrong
2247  * state or returns 0.
2248  */
2249 static int _shutdown(struct omap_hwmod *oh)
2250 {
2251         int ret, i;
2252         u8 prev_state;
2253 
2254         if (oh->_state != _HWMOD_STATE_IDLE &&
2255             oh->_state != _HWMOD_STATE_ENABLED) {
2256                 WARN(1, "omap_hwmod: %s: disabled state can only be entered from idle, or enabled state\n",
2257                         oh->name);
2258                 return -EINVAL;
2259         }
2260 
2261         if (_are_all_hardreset_lines_asserted(oh))
2262                 return 0;
2263 
2264         pr_debug("omap_hwmod: %s: disabling\n", oh->name);
2265 
2266         if (oh->class->pre_shutdown) {
2267                 prev_state = oh->_state;
2268                 if (oh->_state == _HWMOD_STATE_IDLE)
2269                         _enable(oh);
2270                 ret = oh->class->pre_shutdown(oh);
2271                 if (ret) {
2272                         if (prev_state == _HWMOD_STATE_IDLE)
2273                                 _idle(oh);
2274                         return ret;
2275                 }
2276         }
2277 
2278         if (oh->class->sysc) {
2279                 if (oh->_state == _HWMOD_STATE_IDLE)
2280                         _enable(oh);
2281                 _shutdown_sysc(oh);
2282         }
2283 
2284         /* clocks and deps are already disabled in idle */
2285         if (oh->_state == _HWMOD_STATE_ENABLED) {
2286                 _del_initiator_dep(oh, mpu_oh);
2287                 /* XXX what about the other system initiators here? dma, dsp */
2288                 if (oh->flags & HWMOD_BLOCK_WFI)
2289                         cpu_idle_poll_ctrl(false);
2290                 if (soc_ops.disable_module)
2291                         soc_ops.disable_module(oh);
2292                 _disable_clocks(oh);
2293                 if (oh->clkdm)
2294                         clkdm_hwmod_disable(oh->clkdm, oh);
2295         }
2296         /* XXX Should this code also force-disable the optional clocks? */
2297 
2298         for (i = 0; i < oh->rst_lines_cnt; i++)
2299                 _assert_hardreset(oh, oh->rst_lines[i].name);
2300 
2301         /* Mux pins to safe mode or use populated off mode values */
2302         if (oh->mux)
2303                 omap_hwmod_mux(oh->mux, _HWMOD_STATE_DISABLED);
2304 
2305         oh->_state = _HWMOD_STATE_DISABLED;
2306 
2307         return 0;
2308 }
2309 
2310 static int of_dev_find_hwmod(struct device_node *np,
2311                              struct omap_hwmod *oh)
2312 {
2313         int count, i, res;
2314         const char *p;
2315 
2316         count = of_property_count_strings(np, "ti,hwmods");
2317         if (count < 1)
2318                 return -ENODEV;
2319 
2320         for (i = 0; i < count; i++) {
2321                 res = of_property_read_string_index(np, "ti,hwmods",
2322                                                     i, &p);
2323                 if (res)
2324                         continue;
2325                 if (!strcmp(p, oh->name)) {
2326                         pr_debug("omap_hwmod: dt %s[%i] uses hwmod %s\n",
2327                                  np->name, i, oh->name);
2328                         return i;
2329                 }
2330         }
2331 
2332         return -ENODEV;
2333 }
2334 
2335 /**
2336  * of_dev_hwmod_lookup - look up needed hwmod from dt blob
2337  * @np: struct device_node *
2338  * @oh: struct omap_hwmod *
2339  * @index: index of the entry found
2340  * @found: struct device_node * found or NULL
2341  *
2342  * Parse the dt blob and find out needed hwmod. Recursive function is
2343  * implemented to take care hierarchical dt blob parsing.
2344  * Return: Returns 0 on success, -ENODEV when not found.
2345  */
2346 static int of_dev_hwmod_lookup(struct device_node *np,
2347                                struct omap_hwmod *oh,
2348                                int *index,
2349                                struct device_node **found)
2350 {
2351         struct device_node *np0 = NULL;
2352         int res;
2353 
2354         res = of_dev_find_hwmod(np, oh);
2355         if (res >= 0) {
2356                 *found = np;
2357                 *index = res;
2358                 return 0;
2359         }
2360 
2361         for_each_child_of_node(np, np0) {
2362                 struct device_node *fc;
2363                 int i;
2364 
2365                 res = of_dev_hwmod_lookup(np0, oh, &i, &fc);
2366                 if (res == 0) {
2367                         *found = fc;
2368                         *index = i;
2369                         return 0;
2370                 }
2371         }
2372 
2373         *found = NULL;
2374         *index = 0;
2375 
2376         return -ENODEV;
2377 }
2378 
2379 /**
2380  * _init_mpu_rt_base - populate the virtual address for a hwmod
2381  * @oh: struct omap_hwmod * to locate the virtual address
2382  * @data: (unused, caller should pass NULL)
2383  * @index: index of the reg entry iospace in device tree
2384  * @np: struct device_node * of the IP block's device node in the DT data
2385  *
2386  * Cache the virtual address used by the MPU to access this IP block's
2387  * registers.  This address is needed early so the OCP registers that
2388  * are part of the device's address space can be ioremapped properly.
2389  *
2390  * If SYSC access is not needed, the registers will not be remapped
2391  * and non-availability of MPU access is not treated as an error.
2392  *
2393  * Returns 0 on success, -EINVAL if an invalid hwmod is passed, and
2394  * -ENXIO on absent or invalid register target address space.
2395  */
2396 static int __init _init_mpu_rt_base(struct omap_hwmod *oh, void *data,
2397                                     int index, struct device_node *np)
2398 {
2399         struct omap_hwmod_addr_space *mem;
2400         void __iomem *va_start = NULL;
2401 
2402         if (!oh)
2403                 return -EINVAL;
2404 
2405         _save_mpu_port_index(oh);
2406 
2407         /* if we don't need sysc access we don't need to ioremap */
2408         if (!oh->class->sysc)
2409                 return 0;
2410 
2411         /* we can't continue without MPU PORT if we need sysc access */
2412         if (oh->_int_flags & _HWMOD_NO_MPU_PORT)
2413                 return -ENXIO;
2414 
2415         mem = _find_mpu_rt_addr_space(oh);
2416         if (!mem) {
2417                 pr_debug("omap_hwmod: %s: no MPU register target found\n",
2418                          oh->name);
2419 
2420                 /* Extract the IO space from device tree blob */
2421                 if (!np) {
2422                         pr_err("omap_hwmod: %s: no dt node\n", oh->name);
2423                         return -ENXIO;
2424                 }
2425 
2426                 va_start = of_iomap(np, index + oh->mpu_rt_idx);
2427         } else {
2428                 va_start = ioremap(mem->pa_start, mem->pa_end - mem->pa_start);
2429         }
2430 
2431         if (!va_start) {
2432                 if (mem)
2433                         pr_err("omap_hwmod: %s: Could not ioremap\n", oh->name);
2434                 else
2435                         pr_err("omap_hwmod: %s: Missing dt reg%i for %s\n",
2436                                oh->name, index, np->full_name);
2437                 return -ENXIO;
2438         }
2439 
2440         pr_debug("omap_hwmod: %s: MPU register target at va %p\n",
2441                  oh->name, va_start);
2442 
2443         oh->_mpu_rt_va = va_start;
2444         return 0;
2445 }
2446 
2447 /**
2448  * _init - initialize internal data for the hwmod @oh
2449  * @oh: struct omap_hwmod *
2450  * @n: (unused)
2451  *
2452  * Look up the clocks and the address space used by the MPU to access
2453  * registers belonging to the hwmod @oh.  @oh must already be
2454  * registered at this point.  This is the first of two phases for
2455  * hwmod initialization.  Code called here does not touch any hardware
2456  * registers, it simply prepares internal data structures.  Returns 0
2457  * upon success or if the hwmod isn't registered or if the hwmod's
2458  * address space is not defined, or -EINVAL upon failure.
2459  */
2460 static int __init _init(struct omap_hwmod *oh, void *data)
2461 {
2462         int r, index;
2463         struct device_node *np = NULL;
2464 
2465         if (oh->_state != _HWMOD_STATE_REGISTERED)
2466                 return 0;
2467 
2468         if (of_have_populated_dt()) {
2469                 struct device_node *bus;
2470 
2471                 bus = of_find_node_by_name(NULL, "ocp");
2472                 if (!bus)
2473                         return -ENODEV;
2474 
2475                 r = of_dev_hwmod_lookup(bus, oh, &index, &np);
2476                 if (r)
2477                         pr_debug("omap_hwmod: %s missing dt data\n", oh->name);
2478                 else if (np && index)
2479                         pr_warn("omap_hwmod: %s using broken dt data from %s\n",
2480                                 oh->name, np->name);
2481         }
2482 
2483         r = _init_mpu_rt_base(oh, NULL, index, np);
2484         if (r < 0) {
2485                 WARN(1, "omap_hwmod: %s: doesn't have mpu register target base\n",
2486                      oh->name);
2487                 return 0;
2488         }
2489 
2490         r = _init_clocks(oh, NULL);
2491         if (r < 0) {
2492                 WARN(1, "omap_hwmod: %s: couldn't init clocks\n", oh->name);
2493                 return -EINVAL;
2494         }
2495 
2496         if (np) {
2497                 if (of_find_property(np, "ti,no-reset-on-init", NULL))
2498                         oh->flags |= HWMOD_INIT_NO_RESET;
2499                 if (of_find_property(np, "ti,no-idle-on-init", NULL))
2500                         oh->flags |= HWMOD_INIT_NO_IDLE;
2501         }
2502 
2503         oh->_state = _HWMOD_STATE_INITIALIZED;
2504 
2505         return 0;
2506 }
2507 
2508 /**
2509  * _setup_iclk_autoidle - configure an IP block's interface clocks
2510  * @oh: struct omap_hwmod *
2511  *
2512  * Set up the module's interface clocks.  XXX This function is still mostly
2513  * a stub; implementing this properly requires iclk autoidle usecounting in
2514  * the clock code.   No return value.
2515  */
2516 static void __init _setup_iclk_autoidle(struct omap_hwmod *oh)
2517 {
2518         struct omap_hwmod_ocp_if *os;
2519         struct list_head *p;
2520         int i = 0;
2521         if (oh->_state != _HWMOD_STATE_INITIALIZED)
2522                 return;
2523 
2524         p = oh->slave_ports.next;
2525 
2526         while (i < oh->slaves_cnt) {
2527                 os = _fetch_next_ocp_if(&p, &i);
2528                 if (!os->_clk)
2529                         continue;
2530 
2531                 if (os->flags & OCPIF_SWSUP_IDLE) {
2532                         /* XXX omap_iclk_deny_idle(c); */
2533                 } else {
2534                         /* XXX omap_iclk_allow_idle(c); */
2535                         clk_enable(os->_clk);
2536                 }
2537         }
2538 
2539         return;
2540 }
2541 
2542 /**
2543  * _setup_reset - reset an IP block during the setup process
2544  * @oh: struct omap_hwmod *
2545  *
2546  * Reset the IP block corresponding to the hwmod @oh during the setup
2547  * process.  The IP block is first enabled so it can be successfully
2548  * reset.  Returns 0 upon success or a negative error code upon
2549  * failure.
2550  */
2551 static int __init _setup_reset(struct omap_hwmod *oh)
2552 {
2553         int r;
2554 
2555         if (oh->_state != _HWMOD_STATE_INITIALIZED)
2556                 return -EINVAL;
2557 
2558         if (oh->flags & HWMOD_EXT_OPT_MAIN_CLK)
2559                 return -EPERM;
2560 
2561         if (oh->rst_lines_cnt == 0) {
2562                 r = _enable(oh);
2563                 if (r) {
2564                         pr_warn("omap_hwmod: %s: cannot be enabled for reset (%d)\n",
2565                                 oh->name, oh->_state);
2566                         return -EINVAL;
2567                 }
2568         }
2569 
2570         if (!(oh->flags & HWMOD_INIT_NO_RESET))
2571                 r = _reset(oh);
2572 
2573         return r;
2574 }
2575 
2576 /**
2577  * _setup_postsetup - transition to the appropriate state after _setup
2578  * @oh: struct omap_hwmod *
2579  *
2580  * Place an IP block represented by @oh into a "post-setup" state --
2581  * either IDLE, ENABLED, or DISABLED.  ("post-setup" simply means that
2582  * this function is called at the end of _setup().)  The postsetup
2583  * state for an IP block can be changed by calling
2584  * omap_hwmod_enter_postsetup_state() early in the boot process,
2585  * before one of the omap_hwmod_setup*() functions are called for the
2586  * IP block.
2587  *
2588  * The IP block stays in this state until a PM runtime-based driver is
2589  * loaded for that IP block.  A post-setup state of IDLE is
2590  * appropriate for almost all IP blocks with runtime PM-enabled
2591  * drivers, since those drivers are able to enable the IP block.  A
2592  * post-setup state of ENABLED is appropriate for kernels with PM
2593  * runtime disabled.  The DISABLED state is appropriate for unusual IP
2594  * blocks such as the MPU WDTIMER on kernels without WDTIMER drivers
2595  * included, since the WDTIMER starts running on reset and will reset
2596  * the MPU if left active.
2597  *
2598  * This post-setup mechanism is deprecated.  Once all of the OMAP
2599  * drivers have been converted to use PM runtime, and all of the IP
2600  * block data and interconnect data is available to the hwmod code, it
2601  * should be possible to replace this mechanism with a "lazy reset"
2602  * arrangement.  In a "lazy reset" setup, each IP block is enabled
2603  * when the driver first probes, then all remaining IP blocks without
2604  * drivers are either shut down or enabled after the drivers have
2605  * loaded.  However, this cannot take place until the above
2606  * preconditions have been met, since otherwise the late reset code
2607  * has no way of knowing which IP blocks are in use by drivers, and
2608  * which ones are unused.
2609  *
2610  * No return value.
2611  */
2612 static void __init _setup_postsetup(struct omap_hwmod *oh)
2613 {
2614         u8 postsetup_state;
2615 
2616         if (oh->rst_lines_cnt > 0)
2617                 return;
2618 
2619         postsetup_state = oh->_postsetup_state;
2620         if (postsetup_state == _HWMOD_STATE_UNKNOWN)
2621                 postsetup_state = _HWMOD_STATE_ENABLED;
2622 
2623         /*
2624          * XXX HWMOD_INIT_NO_IDLE does not belong in hwmod data -
2625          * it should be set by the core code as a runtime flag during startup
2626          */
2627         if ((oh->flags & HWMOD_INIT_NO_IDLE) &&
2628             (postsetup_state == _HWMOD_STATE_IDLE)) {
2629                 oh->_int_flags |= _HWMOD_SKIP_ENABLE;
2630                 postsetup_state = _HWMOD_STATE_ENABLED;
2631         }
2632 
2633         if (postsetup_state == _HWMOD_STATE_IDLE)
2634                 _idle(oh);
2635         else if (postsetup_state == _HWMOD_STATE_DISABLED)
2636                 _shutdown(oh);
2637         else if (postsetup_state != _HWMOD_STATE_ENABLED)
2638                 WARN(1, "hwmod: %s: unknown postsetup state %d! defaulting to enabled\n",
2639                      oh->name, postsetup_state);
2640 
2641         return;
2642 }
2643 
2644 /**
2645  * _setup - prepare IP block hardware for use
2646  * @oh: struct omap_hwmod *
2647  * @n: (unused, pass NULL)
2648  *
2649  * Configure the IP block represented by @oh.  This may include
2650  * enabling the IP block, resetting it, and placing it into a
2651  * post-setup state, depending on the type of IP block and applicable
2652  * flags.  IP blocks are reset to prevent any previous configuration
2653  * by the bootloader or previous operating system from interfering
2654  * with power management or other parts of the system.  The reset can
2655  * be avoided; see omap_hwmod_no_setup_reset().  This is the second of
2656  * two phases for hwmod initialization.  Code called here generally
2657  * affects the IP block hardware, or system integration hardware
2658  * associated with the IP block.  Returns 0.
2659  */
2660 static int __init _setup(struct omap_hwmod *oh, void *data)
2661 {
2662         if (oh->_state != _HWMOD_STATE_INITIALIZED)
2663                 return 0;
2664 
2665         if (oh->parent_hwmod) {
2666                 int r;
2667 
2668                 r = _enable(oh->parent_hwmod);
2669                 WARN(r, "hwmod: %s: setup: failed to enable parent hwmod %s\n",
2670                      oh->name, oh->parent_hwmod->name);
2671         }
2672 
2673         _setup_iclk_autoidle(oh);
2674 
2675         if (!_setup_reset(oh))
2676                 _setup_postsetup(oh);
2677 
2678         if (oh->parent_hwmod) {
2679                 u8 postsetup_state;
2680 
2681                 postsetup_state = oh->parent_hwmod->_postsetup_state;
2682 
2683                 if (postsetup_state == _HWMOD_STATE_IDLE)
2684                         _idle(oh->parent_hwmod);
2685                 else if (postsetup_state == _HWMOD_STATE_DISABLED)
2686                         _shutdown(oh->parent_hwmod);
2687                 else if (postsetup_state != _HWMOD_STATE_ENABLED)
2688                         WARN(1, "hwmod: %s: unknown postsetup state %d! defaulting to enabled\n",
2689                              oh->parent_hwmod->name, postsetup_state);
2690         }
2691 
2692         return 0;
2693 }
2694 
2695 /**
2696  * _register - register a struct omap_hwmod
2697  * @oh: struct omap_hwmod *
2698  *
2699  * Registers the omap_hwmod @oh.  Returns -EEXIST if an omap_hwmod
2700  * already has been registered by the same name; -EINVAL if the
2701  * omap_hwmod is in the wrong state, if @oh is NULL, if the
2702  * omap_hwmod's class field is NULL; if the omap_hwmod is missing a
2703  * name, or if the omap_hwmod's class is missing a name; or 0 upon
2704  * success.
2705  *
2706  * XXX The data should be copied into bootmem, so the original data
2707  * should be marked __initdata and freed after init.  This would allow
2708  * unneeded omap_hwmods to be freed on multi-OMAP configurations.  Note
2709  * that the copy process would be relatively complex due to the large number
2710  * of substructures.
2711  */
2712 static int __init _register(struct omap_hwmod *oh)
2713 {
2714         if (!oh || !oh->name || !oh->class || !oh->class->name ||
2715             (oh->_state != _HWMOD_STATE_UNKNOWN))
2716                 return -EINVAL;
2717 
2718         pr_debug("omap_hwmod: %s: registering\n", oh->name);
2719 
2720         if (_lookup(oh->name))
2721                 return -EEXIST;
2722 
2723         list_add_tail(&oh->node, &omap_hwmod_list);
2724 
2725         INIT_LIST_HEAD(&oh->master_ports);
2726         INIT_LIST_HEAD(&oh->slave_ports);
2727         spin_lock_init(&oh->_lock);
2728         lockdep_set_class(&oh->_lock, &oh->hwmod_key);
2729 
2730         oh->_state = _HWMOD_STATE_REGISTERED;
2731 
2732         /*
2733          * XXX Rather than doing a strcmp(), this should test a flag
2734          * set in the hwmod data, inserted by the autogenerator code.
2735          */
2736         if (!strcmp(oh->name, MPU_INITIATOR_NAME))
2737                 mpu_oh = oh;
2738 
2739         return 0;
2740 }
2741 
2742 /**
2743  * _alloc_links - return allocated memory for hwmod links
2744  * @ml: pointer to a struct omap_hwmod_link * for the master link
2745  * @sl: pointer to a struct omap_hwmod_link * for the slave link
2746  *
2747  * Return pointers to two struct omap_hwmod_link records, via the
2748  * addresses pointed to by @ml and @sl.  Will first attempt to return
2749  * memory allocated as part of a large initial block, but if that has
2750  * been exhausted, will allocate memory itself.  Since ideally this
2751  * second allocation path will never occur, the number of these
2752  * 'supplemental' allocations will be logged when debugging is
2753  * enabled.  Returns 0.
2754  */
2755 static int __init _alloc_links(struct omap_hwmod_link **ml,
2756                                struct omap_hwmod_link **sl)
2757 {
2758         unsigned int sz;
2759 
2760         if ((free_ls + LINKS_PER_OCP_IF) <= max_ls) {
2761                 *ml = &linkspace[free_ls++];
2762                 *sl = &linkspace[free_ls++];
2763                 return 0;
2764         }
2765 
2766         sz = sizeof(struct omap_hwmod_link) * LINKS_PER_OCP_IF;
2767 
2768         *sl = NULL;
2769         *ml = memblock_virt_alloc(sz, 0);
2770 
2771         *sl = (void *)(*ml) + sizeof(struct omap_hwmod_link);
2772 
2773         ls_supp++;
2774         pr_debug("omap_hwmod: supplemental link allocations needed: %d\n",
2775                  ls_supp * LINKS_PER_OCP_IF);
2776 
2777         return 0;
2778 };
2779 
2780 /**
2781  * _add_link - add an interconnect between two IP blocks
2782  * @oi: pointer to a struct omap_hwmod_ocp_if record
2783  *
2784  * Add struct omap_hwmod_link records connecting the master IP block
2785  * specified in @oi->master to @oi, and connecting the slave IP block
2786  * specified in @oi->slave to @oi.  This code is assumed to run before
2787  * preemption or SMP has been enabled, thus avoiding the need for
2788  * locking in this code.  Changes to this assumption will require
2789  * additional locking.  Returns 0.
2790  */
2791 static int __init _add_link(struct omap_hwmod_ocp_if *oi)
2792 {
2793         struct omap_hwmod_link *ml, *sl;
2794 
2795         pr_debug("omap_hwmod: %s -> %s: adding link\n", oi->master->name,
2796                  oi->slave->name);
2797 
2798         _alloc_links(&ml, &sl);
2799 
2800         ml->ocp_if = oi;
2801         list_add(&ml->node, &oi->master->master_ports);
2802         oi->master->masters_cnt++;
2803 
2804         sl->ocp_if = oi;
2805         list_add(&sl->node, &oi->slave->slave_ports);
2806         oi->slave->slaves_cnt++;
2807 
2808         return 0;
2809 }
2810 
2811 /**
2812  * _register_link - register a struct omap_hwmod_ocp_if
2813  * @oi: struct omap_hwmod_ocp_if *
2814  *
2815  * Registers the omap_hwmod_ocp_if record @oi.  Returns -EEXIST if it
2816  * has already been registered; -EINVAL if @oi is NULL or if the
2817  * record pointed to by @oi is missing required fields; or 0 upon
2818  * success.
2819  *
2820  * XXX The data should be copied into bootmem, so the original data
2821  * should be marked __initdata and freed after init.  This would allow
2822  * unneeded omap_hwmods to be freed on multi-OMAP configurations.
2823  */
2824 static int __init _register_link(struct omap_hwmod_ocp_if *oi)
2825 {
2826         if (!oi || !oi->master || !oi->slave || !oi->user)
2827                 return -EINVAL;
2828 
2829         if (oi->_int_flags & _OCPIF_INT_FLAGS_REGISTERED)
2830                 return -EEXIST;
2831 
2832         pr_debug("omap_hwmod: registering link from %s to %s\n",
2833                  oi->master->name, oi->slave->name);
2834 
2835         /*
2836          * Register the connected hwmods, if they haven't been
2837          * registered already
2838          */
2839         if (oi->master->_state != _HWMOD_STATE_REGISTERED)
2840                 _register(oi->master);
2841 
2842         if (oi->slave->_state != _HWMOD_STATE_REGISTERED)
2843                 _register(oi->slave);
2844 
2845         _add_link(oi);
2846 
2847         oi->_int_flags |= _OCPIF_INT_FLAGS_REGISTERED;
2848 
2849         return 0;
2850 }
2851 
2852 /**
2853  * _alloc_linkspace - allocate large block of hwmod links
2854  * @ois: pointer to an array of struct omap_hwmod_ocp_if records to count
2855  *
2856  * Allocate a large block of struct omap_hwmod_link records.  This
2857  * improves boot time significantly by avoiding the need to allocate
2858  * individual records one by one.  If the number of records to
2859  * allocate in the block hasn't been manually specified, this function
2860  * will count the number of struct omap_hwmod_ocp_if records in @ois
2861  * and use that to determine the allocation size.  For SoC families
2862  * that require multiple list registrations, such as OMAP3xxx, this
2863  * estimation process isn't optimal, so manual estimation is advised
2864  * in those cases.  Returns -EEXIST if the allocation has already occurred
2865  * or 0 upon success.
2866  */
2867 static int __init _alloc_linkspace(struct omap_hwmod_ocp_if **ois)
2868 {
2869         unsigned int i = 0;
2870         unsigned int sz;
2871 
2872         if (linkspace) {
2873                 WARN(1, "linkspace already allocated\n");
2874                 return -EEXIST;
2875         }
2876 
2877         if (max_ls == 0)
2878                 while (ois[i++])
2879                         max_ls += LINKS_PER_OCP_IF;
2880 
2881         sz = sizeof(struct omap_hwmod_link) * max_ls;
2882 
2883         pr_debug("omap_hwmod: %s: allocating %d byte linkspace (%d links)\n",
2884                  __func__, sz, max_ls);
2885 
2886         linkspace = memblock_virt_alloc(sz, 0);
2887 
2888         return 0;
2889 }
2890 
2891 /* Static functions intended only for use in soc_ops field function pointers */
2892 
2893 /**
2894  * _omap2xxx_3xxx_wait_target_ready - wait for a module to leave slave idle
2895  * @oh: struct omap_hwmod *
2896  *
2897  * Wait for a module @oh to leave slave idle.  Returns 0 if the module
2898  * does not have an IDLEST bit or if the module successfully leaves
2899  * slave idle; otherwise, pass along the return value of the
2900  * appropriate *_cm*_wait_module_ready() function.
2901  */
2902 static int _omap2xxx_3xxx_wait_target_ready(struct omap_hwmod *oh)
2903 {
2904         if (!oh)
2905                 return -EINVAL;
2906 
2907         if (oh->flags & HWMOD_NO_IDLEST)
2908                 return 0;
2909 
2910         if (!_find_mpu_rt_port(oh))
2911                 return 0;
2912 
2913         /* XXX check module SIDLEMODE, hardreset status, enabled clocks */
2914 
2915         return omap_cm_wait_module_ready(0, oh->prcm.omap2.module_offs,
2916                                          oh->prcm.omap2.idlest_reg_id,
2917                                          oh->prcm.omap2.idlest_idle_bit);
2918 }
2919 
2920 /**
2921  * _omap4_wait_target_ready - wait for a module to leave slave idle
2922  * @oh: struct omap_hwmod *
2923  *
2924  * Wait for a module @oh to leave slave idle.  Returns 0 if the module
2925  * does not have an IDLEST bit or if the module successfully leaves
2926  * slave idle; otherwise, pass along the return value of the
2927  * appropriate *_cm*_wait_module_ready() function.
2928  */
2929 static int _omap4_wait_target_ready(struct omap_hwmod *oh)
2930 {
2931         if (!oh)
2932                 return -EINVAL;
2933 
2934         if (oh->flags & HWMOD_NO_IDLEST || !oh->clkdm)
2935                 return 0;
2936 
2937         if (!_find_mpu_rt_port(oh))
2938                 return 0;
2939 
2940         /* XXX check module SIDLEMODE, hardreset status */
2941 
2942         return omap_cm_wait_module_ready(oh->clkdm->prcm_partition,
2943                                          oh->clkdm->cm_inst,
2944                                          oh->prcm.omap4.clkctrl_offs, 0);
2945 }
2946 
2947 /**
2948  * _omap2_assert_hardreset - call OMAP2 PRM hardreset fn with hwmod args
2949  * @oh: struct omap_hwmod * to assert hardreset
2950  * @ohri: hardreset line data
2951  *
2952  * Call omap2_prm_assert_hardreset() with parameters extracted from
2953  * the hwmod @oh and the hardreset line data @ohri.  Only intended for
2954  * use as an soc_ops function pointer.  Passes along the return value
2955  * from omap2_prm_assert_hardreset().  XXX This function is scheduled
2956  * for removal when the PRM code is moved into drivers/.
2957  */
2958 static int _omap2_assert_hardreset(struct omap_hwmod *oh,
2959                                    struct omap_hwmod_rst_info *ohri)
2960 {
2961         return omap_prm_assert_hardreset(ohri->rst_shift, 0,
2962                                          oh->prcm.omap2.module_offs, 0);
2963 }
2964 
2965 /**
2966  * _omap2_deassert_hardreset - call OMAP2 PRM hardreset fn with hwmod args
2967  * @oh: struct omap_hwmod * to deassert hardreset
2968  * @ohri: hardreset line data
2969  *
2970  * Call omap2_prm_deassert_hardreset() with parameters extracted from
2971  * the hwmod @oh and the hardreset line data @ohri.  Only intended for
2972  * use as an soc_ops function pointer.  Passes along the return value
2973  * from omap2_prm_deassert_hardreset().  XXX This function is
2974  * scheduled for removal when the PRM code is moved into drivers/.
2975  */
2976 static int _omap2_deassert_hardreset(struct omap_hwmod *oh,
2977                                      struct omap_hwmod_rst_info *ohri)
2978 {
2979         return omap_prm_deassert_hardreset(ohri->rst_shift, ohri->st_shift, 0,
2980                                            oh->prcm.omap2.module_offs, 0, 0);
2981 }
2982 
2983 /**
2984  * _omap2_is_hardreset_asserted - call OMAP2 PRM hardreset fn with hwmod args
2985  * @oh: struct omap_hwmod * to test hardreset
2986  * @ohri: hardreset line data
2987  *
2988  * Call omap2_prm_is_hardreset_asserted() with parameters extracted
2989  * from the hwmod @oh and the hardreset line data @ohri.  Only
2990  * intended for use as an soc_ops function pointer.  Passes along the
2991  * return value from omap2_prm_is_hardreset_asserted().  XXX This
2992  * function is scheduled for removal when the PRM code is moved into
2993  * drivers/.
2994  */
2995 static int _omap2_is_hardreset_asserted(struct omap_hwmod *oh,
2996                                         struct omap_hwmod_rst_info *ohri)
2997 {
2998         return omap_prm_is_hardreset_asserted(ohri->st_shift, 0,
2999                                               oh->prcm.omap2.module_offs, 0);
3000 }
3001 
3002 /**
3003  * _omap4_assert_hardreset - call OMAP4 PRM hardreset fn with hwmod args
3004  * @oh: struct omap_hwmod * to assert hardreset
3005  * @ohri: hardreset line data
3006  *
3007  * Call omap4_prminst_assert_hardreset() with parameters extracted
3008  * from the hwmod @oh and the hardreset line data @ohri.  Only
3009  * intended for use as an soc_ops function pointer.  Passes along the
3010  * return value from omap4_prminst_assert_hardreset().  XXX This
3011  * function is scheduled for removal when the PRM code is moved into
3012  * drivers/.
3013  */
3014 static int _omap4_assert_hardreset(struct omap_hwmod *oh,
3015                                    struct omap_hwmod_rst_info *ohri)
3016 {
3017         if (!oh->clkdm)
3018                 return -EINVAL;
3019 
3020         return omap_prm_assert_hardreset(ohri->rst_shift,
3021                                          oh->clkdm->pwrdm.ptr->prcm_partition,
3022                                          oh->clkdm->pwrdm.ptr->prcm_offs,
3023                                          oh->prcm.omap4.rstctrl_offs);
3024 }
3025 
3026 /**
3027  * _omap4_deassert_hardreset - call OMAP4 PRM hardreset fn with hwmod args
3028  * @oh: struct omap_hwmod * to deassert hardreset
3029  * @ohri: hardreset line data
3030  *
3031  * Call omap4_prminst_deassert_hardreset() with parameters extracted
3032  * from the hwmod @oh and the hardreset line data @ohri.  Only
3033  * intended for use as an soc_ops function pointer.  Passes along the
3034  * return value from omap4_prminst_deassert_hardreset().  XXX This
3035  * function is scheduled for removal when the PRM code is moved into
3036  * drivers/.
3037  */
3038 static int _omap4_deassert_hardreset(struct omap_hwmod *oh,
3039                                      struct omap_hwmod_rst_info *ohri)
3040 {
3041         if (!oh->clkdm)
3042                 return -EINVAL;
3043 
3044         if (ohri->st_shift)
3045                 pr_err("omap_hwmod: %s: %s: hwmod data error: OMAP4 does not support st_shift\n",
3046                        oh->name, ohri->name);
3047         return omap_prm_deassert_hardreset(ohri->rst_shift, ohri->rst_shift,
3048                                            oh->clkdm->pwrdm.ptr->prcm_partition,
3049                                            oh->clkdm->pwrdm.ptr->prcm_offs,
3050                                            oh->prcm.omap4.rstctrl_offs,
3051                                            oh->prcm.omap4.rstctrl_offs +
3052                                            OMAP4_RST_CTRL_ST_OFFSET);
3053 }
3054 
3055 /**
3056  * _omap4_is_hardreset_asserted - call OMAP4 PRM hardreset fn with hwmod args
3057  * @oh: struct omap_hwmod * to test hardreset
3058  * @ohri: hardreset line data
3059  *
3060  * Call omap4_prminst_is_hardreset_asserted() with parameters
3061  * extracted from the hwmod @oh and the hardreset line data @ohri.
3062  * Only intended for use as an soc_ops function pointer.  Passes along
3063  * the return value from omap4_prminst_is_hardreset_asserted().  XXX
3064  * This function is scheduled for removal when the PRM code is moved
3065  * into drivers/.
3066  */
3067 static int _omap4_is_hardreset_asserted(struct omap_hwmod *oh,
3068                                         struct omap_hwmod_rst_info *ohri)
3069 {
3070         if (!oh->clkdm)
3071                 return -EINVAL;
3072 
3073         return omap_prm_is_hardreset_asserted(ohri->rst_shift,
3074                                               oh->clkdm->pwrdm.ptr->
3075                                               prcm_partition,
3076                                               oh->clkdm->pwrdm.ptr->prcm_offs,
3077                                               oh->prcm.omap4.rstctrl_offs);
3078 }
3079 
3080 /**
3081  * _am33xx_deassert_hardreset - call AM33XX PRM hardreset fn with hwmod args
3082  * @oh: struct omap_hwmod * to deassert hardreset
3083  * @ohri: hardreset line data
3084  *
3085  * Call am33xx_prminst_deassert_hardreset() with parameters extracted
3086  * from the hwmod @oh and the hardreset line data @ohri.  Only
3087  * intended for use as an soc_ops function pointer.  Passes along the
3088  * return value from am33xx_prminst_deassert_hardreset().  XXX This
3089  * function is scheduled for removal when the PRM code is moved into
3090  * drivers/.
3091  */
3092 static int _am33xx_deassert_hardreset(struct omap_hwmod *oh,
3093                                      struct omap_hwmod_rst_info *ohri)
3094 {
3095         return omap_prm_deassert_hardreset(ohri->rst_shift, ohri->st_shift,
3096                                            oh->clkdm->pwrdm.ptr->prcm_partition,
3097                                            oh->clkdm->pwrdm.ptr->prcm_offs,
3098                                            oh->prcm.omap4.rstctrl_offs,
3099                                            oh->prcm.omap4.rstst_offs);
3100 }
3101 
3102 /* Public functions */
3103 
3104 u32 omap_hwmod_read(struct omap_hwmod *oh, u16 reg_offs)
3105 {
3106         if (oh->flags & HWMOD_16BIT_REG)
3107                 return readw_relaxed(oh->_mpu_rt_va + reg_offs);
3108         else
3109                 return readl_relaxed(oh->_mpu_rt_va + reg_offs);
3110 }
3111 
3112 void omap_hwmod_write(u32 v, struct omap_hwmod *oh, u16 reg_offs)
3113 {
3114         if (oh->flags & HWMOD_16BIT_REG)
3115                 writew_relaxed(v, oh->_mpu_rt_va + reg_offs);
3116         else
3117                 writel_relaxed(v, oh->_mpu_rt_va + reg_offs);
3118 }
3119 
3120 /**
3121  * omap_hwmod_softreset - reset a module via SYSCONFIG.SOFTRESET bit
3122  * @oh: struct omap_hwmod *
3123  *
3124  * This is a public function exposed to drivers. Some drivers may need to do
3125  * some settings before and after resetting the device.  Those drivers after
3126  * doing the necessary settings could use this function to start a reset by
3127  * setting the SYSCONFIG.SOFTRESET bit.
3128  */
3129 int omap_hwmod_softreset(struct omap_hwmod *oh)
3130 {
3131         u32 v;
3132         int ret;
3133 
3134         if (!oh || !(oh->_sysc_cache))
3135                 return -EINVAL;
3136 
3137         v = oh->_sysc_cache;
3138         ret = _set_softreset(oh, &v);
3139         if (ret)
3140                 goto error;
3141         _write_sysconfig(v, oh);
3142 
3143         ret = _clear_softreset(oh, &v);
3144         if (ret)
3145                 goto error;
3146         _write_sysconfig(v, oh);
3147 
3148 error:
3149         return ret;
3150 }
3151 
3152 /**
3153  * omap_hwmod_lookup - look up a registered omap_hwmod by name
3154  * @name: name of the omap_hwmod to look up
3155  *
3156  * Given a @name of an omap_hwmod, return a pointer to the registered
3157  * struct omap_hwmod *, or NULL upon error.
3158  */
3159 struct omap_hwmod *omap_hwmod_lookup(const char *name)
3160 {
3161         struct omap_hwmod *oh;
3162 
3163         if (!name)
3164                 return NULL;
3165 
3166         oh = _lookup(name);
3167 
3168         return oh;
3169 }
3170 
3171 /**
3172  * omap_hwmod_for_each - call function for each registered omap_hwmod
3173  * @fn: pointer to a callback function
3174  * @data: void * data to pass to callback function
3175  *
3176  * Call @fn for each registered omap_hwmod, passing @data to each
3177  * function.  @fn must return 0 for success or any other value for
3178  * failure.  If @fn returns non-zero, the iteration across omap_hwmods
3179  * will stop and the non-zero return value will be passed to the
3180  * caller of omap_hwmod_for_each().  @fn is called with
3181  * omap_hwmod_for_each() held.
3182  */
3183 int omap_hwmod_for_each(int (*fn)(struct omap_hwmod *oh, void *data),
3184                         void *data)
3185 {
3186         struct omap_hwmod *temp_oh;
3187         int ret = 0;
3188 
3189         if (!fn)
3190                 return -EINVAL;
3191 
3192         list_for_each_entry(temp_oh, &omap_hwmod_list, node) {
3193                 ret = (*fn)(temp_oh, data);
3194                 if (ret)
3195                         break;
3196         }
3197 
3198         return ret;
3199 }
3200 
3201 /**
3202  * omap_hwmod_register_links - register an array of hwmod links
3203  * @ois: pointer to an array of omap_hwmod_ocp_if to register
3204  *
3205  * Intended to be called early in boot before the clock framework is
3206  * initialized.  If @ois is not null, will register all omap_hwmods
3207  * listed in @ois that are valid for this chip.  Returns -EINVAL if
3208  * omap_hwmod_init() hasn't been called before calling this function,
3209  * -ENOMEM if the link memory area can't be allocated, or 0 upon
3210  * success.
3211  */
3212 int __init omap_hwmod_register_links(struct omap_hwmod_ocp_if **ois)
3213 {
3214         int r, i;
3215 
3216         if (!inited)
3217                 return -EINVAL;
3218 
3219         if (!ois)
3220                 return 0;
3221 
3222         if (ois[0] == NULL) /* Empty list */
3223                 return 0;
3224 
3225         if (!linkspace) {
3226                 if (_alloc_linkspace(ois)) {
3227                         pr_err("omap_hwmod: could not allocate link space\n");
3228                         return -ENOMEM;
3229                 }
3230         }
3231 
3232         i = 0;
3233         do {
3234                 r = _register_link(ois[i]);
3235                 WARN(r && r != -EEXIST,
3236                      "omap_hwmod: _register_link(%s -> %s) returned %d\n",
3237                      ois[i]->master->name, ois[i]->slave->name, r);
3238         } while (ois[++i]);
3239 
3240         return 0;
3241 }
3242 
3243 /**
3244  * _ensure_mpu_hwmod_is_setup - ensure the MPU SS hwmod is init'ed and set up
3245  * @oh: pointer to the hwmod currently being set up (usually not the MPU)
3246  *
3247  * If the hwmod data corresponding to the MPU subsystem IP block
3248  * hasn't been initialized and set up yet, do so now.  This must be
3249  * done first since sleep dependencies may be added from other hwmods
3250  * to the MPU.  Intended to be called only by omap_hwmod_setup*().  No
3251  * return value.
3252  */
3253 static void __init _ensure_mpu_hwmod_is_setup(struct omap_hwmod *oh)
3254 {
3255         if (!mpu_oh || mpu_oh->_state == _HWMOD_STATE_UNKNOWN)
3256                 pr_err("omap_hwmod: %s: MPU initiator hwmod %s not yet registered\n",
3257                        __func__, MPU_INITIATOR_NAME);
3258         else if (mpu_oh->_state == _HWMOD_STATE_REGISTERED && oh != mpu_oh)
3259                 omap_hwmod_setup_one(MPU_INITIATOR_NAME);
3260 }
3261 
3262 /**
3263  * omap_hwmod_setup_one - set up a single hwmod
3264  * @oh_name: const char * name of the already-registered hwmod to set up
3265  *
3266  * Initialize and set up a single hwmod.  Intended to be used for a
3267  * small number of early devices, such as the timer IP blocks used for
3268  * the scheduler clock.  Must be called after omap2_clk_init().
3269  * Resolves the struct clk names to struct clk pointers for each
3270  * registered omap_hwmod.  Also calls _setup() on each hwmod.  Returns
3271  * -EINVAL upon error or 0 upon success.
3272  */
3273 int __init omap_hwmod_setup_one(const char *oh_name)
3274 {
3275         struct omap_hwmod *oh;
3276 
3277         pr_debug("omap_hwmod: %s: %s\n", oh_name, __func__);
3278 
3279         oh = _lookup(oh_name);
3280         if (!oh) {
3281                 WARN(1, "omap_hwmod: %s: hwmod not yet registered\n", oh_name);
3282                 return -EINVAL;
3283         }
3284 
3285         _ensure_mpu_hwmod_is_setup(oh);
3286 
3287         _init(oh, NULL);
3288         _setup(oh, NULL);
3289 
3290         return 0;
3291 }
3292 
3293 /**
3294  * omap_hwmod_setup_all - set up all registered IP blocks
3295  *
3296  * Initialize and set up all IP blocks registered with the hwmod code.
3297  * Must be called after omap2_clk_init().  Resolves the struct clk
3298  * names to struct clk pointers for each registered omap_hwmod.  Also
3299  * calls _setup() on each hwmod.  Returns 0 upon success.
3300  */
3301 static int __init omap_hwmod_setup_all(void)
3302 {
3303         _ensure_mpu_hwmod_is_setup(NULL);
3304 
3305         omap_hwmod_for_each(_init, NULL);
3306         omap_hwmod_for_each(_setup, NULL);
3307 
3308         return 0;
3309 }
3310 omap_core_initcall(omap_hwmod_setup_all);
3311 
3312 /**
3313  * omap_hwmod_enable - enable an omap_hwmod
3314  * @oh: struct omap_hwmod *
3315  *
3316  * Enable an omap_hwmod @oh.  Intended to be called by omap_device_enable().
3317  * Returns -EINVAL on error or passes along the return value from _enable().
3318  */
3319 int omap_hwmod_enable(struct omap_hwmod *oh)
3320 {
3321         int r;
3322         unsigned long flags;
3323 
3324         if (!oh)
3325                 return -EINVAL;
3326 
3327         spin_lock_irqsave(&oh->_lock, flags);
3328         r = _enable(oh);
3329         spin_unlock_irqrestore(&oh->_lock, flags);
3330 
3331         return r;
3332 }
3333 
3334 /**
3335  * omap_hwmod_idle - idle an omap_hwmod
3336  * @oh: struct omap_hwmod *
3337  *
3338  * Idle an omap_hwmod @oh.  Intended to be called by omap_device_idle().
3339  * Returns -EINVAL on error or passes along the return value from _idle().
3340  */
3341 int omap_hwmod_idle(struct omap_hwmod *oh)
3342 {
3343         int r;
3344         unsigned long flags;
3345 
3346         if (!oh)
3347                 return -EINVAL;
3348 
3349         spin_lock_irqsave(&oh->_lock, flags);
3350         r = _idle(oh);
3351         spin_unlock_irqrestore(&oh->_lock, flags);
3352 
3353         return r;
3354 }
3355 
3356 /**
3357  * omap_hwmod_shutdown - shutdown an omap_hwmod
3358  * @oh: struct omap_hwmod *
3359  *
3360  * Shutdown an omap_hwmod @oh.  Intended to be called by
3361  * omap_device_shutdown().  Returns -EINVAL on error or passes along
3362  * the return value from _shutdown().
3363  */
3364 int omap_hwmod_shutdown(struct omap_hwmod *oh)
3365 {
3366         int r;
3367         unsigned long flags;
3368 
3369         if (!oh)
3370                 return -EINVAL;
3371 
3372         spin_lock_irqsave(&oh->_lock, flags);
3373         r = _shutdown(oh);
3374         spin_unlock_irqrestore(&oh->_lock, flags);
3375 
3376         return r;
3377 }
3378 
3379 /*
3380  * IP block data retrieval functions
3381  */
3382 
3383 /**
3384  * omap_hwmod_count_resources - count number of struct resources needed by hwmod
3385  * @oh: struct omap_hwmod *
3386  * @flags: Type of resources to include when counting (IRQ/DMA/MEM)
3387  *
3388  * Count the number of struct resource array elements necessary to
3389  * contain omap_hwmod @oh resources.  Intended to be called by code
3390  * that registers omap_devices.  Intended to be used to determine the
3391  * size of a dynamically-allocated struct resource array, before
3392  * calling omap_hwmod_fill_resources().  Returns the number of struct
3393  * resource array elements needed.
3394  *
3395  * XXX This code is not optimized.  It could attempt to merge adjacent
3396  * resource IDs.
3397  *
3398  */
3399 int omap_hwmod_count_resources(struct omap_hwmod *oh, unsigned long flags)
3400 {
3401         int ret = 0;
3402 
3403         if (flags & IORESOURCE_IRQ)
3404                 ret += _count_mpu_irqs(oh);
3405 
3406         if (flags & IORESOURCE_DMA)
3407                 ret += _count_sdma_reqs(oh);
3408 
3409         if (flags & IORESOURCE_MEM) {
3410                 int i = 0;
3411                 struct omap_hwmod_ocp_if *os;
3412                 struct list_head *p = oh->slave_ports.next;
3413 
3414                 while (i < oh->slaves_cnt) {
3415                         os = _fetch_next_ocp_if(&p, &i);
3416                         ret += _count_ocp_if_addr_spaces(os);
3417                 }
3418         }
3419 
3420         return ret;
3421 }
3422 
3423 /**
3424  * omap_hwmod_fill_resources - fill struct resource array with hwmod data
3425  * @oh: struct omap_hwmod *
3426  * @res: pointer to the first element of an array of struct resource to fill
3427  *
3428  * Fill the struct resource array @res with resource data from the
3429  * omap_hwmod @oh.  Intended to be called by code that registers
3430  * omap_devices.  See also omap_hwmod_count_resources().  Returns the
3431  * number of array elements filled.
3432  */
3433 int omap_hwmod_fill_resources(struct omap_hwmod *oh, struct resource *res)
3434 {
3435         struct omap_hwmod_ocp_if *os;
3436         struct list_head *p;
3437         int i, j, mpu_irqs_cnt, sdma_reqs_cnt, addr_cnt;
3438         int r = 0;
3439 
3440         /* For each IRQ, DMA, memory area, fill in array.*/
3441 
3442         mpu_irqs_cnt = _count_mpu_irqs(oh);
3443         for (i = 0; i < mpu_irqs_cnt; i++) {
3444                 unsigned int irq;
3445 
3446                 if (oh->xlate_irq)
3447                         irq = oh->xlate_irq((oh->mpu_irqs + i)->irq);
3448                 else
3449                         irq = (oh->mpu_irqs + i)->irq;
3450                 (res + r)->name = (oh->mpu_irqs + i)->name;
3451                 (res + r)->start = irq;
3452                 (res + r)->end = irq;
3453                 (res + r)->flags = IORESOURCE_IRQ;
3454                 r++;
3455         }
3456 
3457         sdma_reqs_cnt = _count_sdma_reqs(oh);
3458         for (i = 0; i < sdma_reqs_cnt; i++) {
3459                 (res + r)->name = (oh->sdma_reqs + i)->name;
3460                 (res + r)->start = (oh->sdma_reqs + i)->dma_req;
3461                 (res + r)->end = (oh->sdma_reqs + i)->dma_req;
3462                 (res + r)->flags = IORESOURCE_DMA;
3463                 r++;
3464         }
3465 
3466         p = oh->slave_ports.next;
3467 
3468         i = 0;
3469         while (i < oh->slaves_cnt) {
3470                 os = _fetch_next_ocp_if(&p, &i);
3471                 addr_cnt = _count_ocp_if_addr_spaces(os);
3472 
3473                 for (j = 0; j < addr_cnt; j++) {
3474                         (res + r)->name = (os->addr + j)->name;
3475                         (res + r)->start = (os->addr + j)->pa_start;
3476                         (res + r)->end = (os->addr + j)->pa_end;
3477                         (res + r)->flags = IORESOURCE_MEM;
3478                         r++;
3479                 }
3480         }
3481 
3482         return r;
3483 }
3484 
3485 /**
3486  * omap_hwmod_fill_dma_resources - fill struct resource array with dma data
3487  * @oh: struct omap_hwmod *
3488  * @res: pointer to the array of struct resource to fill
3489  *
3490  * Fill the struct resource array @res with dma resource data from the
3491  * omap_hwmod @oh.  Intended to be called by code that registers
3492  * omap_devices.  See also omap_hwmod_count_resources().  Returns the
3493  * number of array elements filled.
3494  */
3495 int omap_hwmod_fill_dma_resources(struct omap_hwmod *oh, struct resource *res)
3496 {
3497         int i, sdma_reqs_cnt;
3498         int r = 0;
3499 
3500         sdma_reqs_cnt = _count_sdma_reqs(oh);
3501         for (i = 0; i < sdma_reqs_cnt; i++) {
3502                 (res + r)->name = (oh->sdma_reqs + i)->name;
3503                 (res + r)->start = (oh->sdma_reqs + i)->dma_req;
3504                 (res + r)->end = (oh->sdma_reqs + i)->dma_req;
3505                 (res + r)->flags = IORESOURCE_DMA;
3506                 r++;
3507         }
3508 
3509         return r;
3510 }
3511 
3512 /**
3513  * omap_hwmod_get_resource_byname - fetch IP block integration data by name
3514  * @oh: struct omap_hwmod * to operate on
3515  * @type: one of the IORESOURCE_* constants from include/linux/ioport.h
3516  * @name: pointer to the name of the data to fetch (optional)
3517  * @rsrc: pointer to a struct resource, allocated by the caller
3518  *
3519  * Retrieve MPU IRQ, SDMA request line, or address space start/end
3520  * data for the IP block pointed to by @oh.  The data will be filled
3521  * into a struct resource record pointed to by @rsrc.  The struct
3522  * resource must be allocated by the caller.  When @name is non-null,
3523  * the data associated with the matching entry in the IRQ/SDMA/address
3524  * space hwmod data arrays will be returned.  If @name is null, the
3525  * first array entry will be returned.  Data order is not meaningful
3526  * in hwmod data, so callers are strongly encouraged to use a non-null
3527  * @name whenever possible to avoid unpredictable effects if hwmod
3528  * data is later added that causes data ordering to change.  This
3529  * function is only intended for use by OMAP core code.  Device
3530  * drivers should not call this function - the appropriate bus-related
3531  * data accessor functions should be used instead.  Returns 0 upon
3532  * success or a negative error code upon error.
3533  */
3534 int omap_hwmod_get_resource_byname(struct omap_hwmod *oh, unsigned int type,
3535                                    const char *name, struct resource *rsrc)
3536 {
3537         int r;
3538         unsigned int irq, dma;
3539         u32 pa_start, pa_end;
3540 
3541         if (!oh || !rsrc)
3542                 return -EINVAL;
3543 
3544         if (type == IORESOURCE_IRQ) {
3545                 r = _get_mpu_irq_by_name(oh, name, &irq);
3546                 if (r)
3547                         return r;
3548 
3549                 rsrc->start = irq;
3550                 rsrc->end = irq;
3551         } else if (type == IORESOURCE_DMA) {
3552                 r = _get_sdma_req_by_name(oh, name, &dma);
3553                 if (r)
3554                         return r;
3555 
3556                 rsrc->start = dma;
3557                 rsrc->end = dma;
3558         } else if (type == IORESOURCE_MEM) {
3559                 r = _get_addr_space_by_name(oh, name, &pa_start, &pa_end);
3560                 if (r)
3561                         return r;
3562 
3563                 rsrc->start = pa_start;
3564                 rsrc->end = pa_end;
3565         } else {
3566                 return -EINVAL;
3567         }
3568 
3569         rsrc->flags = type;
3570         rsrc->name = name;
3571 
3572         return 0;
3573 }
3574 
3575 /**
3576  * omap_hwmod_get_pwrdm - return pointer to this module's main powerdomain
3577  * @oh: struct omap_hwmod *
3578  *
3579  * Return the powerdomain pointer associated with the OMAP module
3580  * @oh's main clock.  If @oh does not have a main clk, return the
3581  * powerdomain associated with the interface clock associated with the
3582  * module's MPU port. (XXX Perhaps this should use the SDMA port
3583  * instead?)  Returns NULL on error, or a struct powerdomain * on
3584  * success.
3585  */
3586 struct powerdomain *omap_hwmod_get_pwrdm(struct omap_hwmod *oh)
3587 {
3588         struct clk *c;
3589         struct omap_hwmod_ocp_if *oi;
3590         struct clockdomain *clkdm;
3591         struct clk_hw_omap *clk;
3592 
3593         if (!oh)
3594                 return NULL;
3595 
3596         if (oh->clkdm)
3597                 return oh->clkdm->pwrdm.ptr;
3598 
3599         if (oh->_clk) {
3600                 c = oh->_clk;
3601         } else {
3602                 oi = _find_mpu_rt_port(oh);
3603                 if (!oi)
3604                         return NULL;
3605                 c = oi->_clk;
3606         }
3607 
3608         clk = to_clk_hw_omap(__clk_get_hw(c));
3609         clkdm = clk->clkdm;
3610         if (!clkdm)
3611                 return NULL;
3612 
3613         return clkdm->pwrdm.ptr;
3614 }
3615 
3616 /**
3617  * omap_hwmod_get_mpu_rt_va - return the module's base address (for the MPU)
3618  * @oh: struct omap_hwmod *
3619  *
3620  * Returns the virtual address corresponding to the beginning of the
3621  * module's register target, in the address range that is intended to
3622  * be used by the MPU.  Returns the virtual address upon success or NULL
3623  * upon error.
3624  */
3625 void __iomem *omap_hwmod_get_mpu_rt_va(struct omap_hwmod *oh)
3626 {
3627         if (!oh)
3628                 return NULL;
3629 
3630         if (oh->_int_flags & _HWMOD_NO_MPU_PORT)
3631                 return NULL;
3632 
3633         if (oh->_state == _HWMOD_STATE_UNKNOWN)
3634                 return NULL;
3635 
3636         return oh->_mpu_rt_va;
3637 }
3638 
3639 /*
3640  * XXX what about functions for drivers to save/restore ocp_sysconfig
3641  * for context save/restore operations?
3642  */
3643 
3644 /**
3645  * omap_hwmod_enable_wakeup - allow device to wake up the system
3646  * @oh: struct omap_hwmod *
3647  *
3648  * Sets the module OCP socket ENAWAKEUP bit to allow the module to
3649  * send wakeups to the PRCM, and enable I/O ring wakeup events for
3650  * this IP block if it has dynamic mux entries.  Eventually this
3651  * should set PRCM wakeup registers to cause the PRCM to receive
3652  * wakeup events from the module.  Does not set any wakeup routing
3653  * registers beyond this point - if the module is to wake up any other
3654  * module or subsystem, that must be set separately.  Called by
3655  * omap_device code.  Returns -EINVAL on error or 0 upon success.
3656  */
3657 int omap_hwmod_enable_wakeup(struct omap_hwmod *oh)
3658 {
3659         unsigned long flags;
3660         u32 v;
3661 
3662         spin_lock_irqsave(&oh->_lock, flags);
3663 
3664         if (oh->class->sysc &&
3665             (oh->class->sysc->sysc_flags & SYSC_HAS_ENAWAKEUP)) {
3666                 v = oh->_sysc_cache;
3667                 _enable_wakeup(oh, &v);
3668                 _write_sysconfig(v, oh);
3669         }
3670 
3671         _set_idle_ioring_wakeup(oh, true);
3672         spin_unlock_irqrestore(&oh->_lock, flags);
3673 
3674         return 0;
3675 }
3676 
3677 /**
3678  * omap_hwmod_disable_wakeup - prevent device from waking the system
3679  * @oh: struct omap_hwmod *
3680  *
3681  * Clears the module OCP socket ENAWAKEUP bit to prevent the module
3682  * from sending wakeups to the PRCM, and disable I/O ring wakeup
3683  * events for this IP block if it has dynamic mux entries.  Eventually
3684  * this should clear PRCM wakeup registers to cause the PRCM to ignore
3685  * wakeup events from the module.  Does not set any wakeup routing
3686  * registers beyond this point - if the module is to wake up any other
3687  * module or subsystem, that must be set separately.  Called by
3688  * omap_device code.  Returns -EINVAL on error or 0 upon success.
3689  */
3690 int omap_hwmod_disable_wakeup(struct omap_hwmod *oh)
3691 {
3692         unsigned long flags;
3693         u32 v;
3694 
3695         spin_lock_irqsave(&oh->_lock, flags);
3696 
3697         if (oh->class->sysc &&
3698             (oh->class->sysc->sysc_flags & SYSC_HAS_ENAWAKEUP)) {
3699                 v = oh->_sysc_cache;
3700                 _disable_wakeup(oh, &v);
3701                 _write_sysconfig(v, oh);
3702         }
3703 
3704         _set_idle_ioring_wakeup(oh, false);
3705         spin_unlock_irqrestore(&oh->_lock, flags);
3706 
3707         return 0;
3708 }
3709 
3710 /**
3711  * omap_hwmod_assert_hardreset - assert the HW reset line of submodules
3712  * contained in the hwmod module.
3713  * @oh: struct omap_hwmod *
3714  * @name: name of the reset line to lookup and assert
3715  *
3716  * Some IP like dsp, ipu or iva contain processor that require
3717  * an HW reset line to be assert / deassert in order to enable fully
3718  * the IP.  Returns -EINVAL if @oh is null or if the operation is not
3719  * yet supported on this OMAP; otherwise, passes along the return value
3720  * from _assert_hardreset().
3721  */
3722 int omap_hwmod_assert_hardreset(struct omap_hwmod *oh, const char *name)
3723 {
3724         int ret;
3725         unsigned long flags;
3726 
3727         if (!oh)
3728                 return -EINVAL;
3729 
3730         spin_lock_irqsave(&oh->_lock, flags);
3731         ret = _assert_hardreset(oh, name);
3732         spin_unlock_irqrestore(&oh->_lock, flags);
3733 
3734         return ret;
3735 }
3736 
3737 /**
3738  * omap_hwmod_deassert_hardreset - deassert the HW reset line of submodules
3739  * contained in the hwmod module.
3740  * @oh: struct omap_hwmod *
3741  * @name: name of the reset line to look up and deassert
3742  *
3743  * Some IP like dsp, ipu or iva contain processor that require
3744  * an HW reset line to be assert / deassert in order to enable fully
3745  * the IP.  Returns -EINVAL if @oh is null or if the operation is not
3746  * yet supported on this OMAP; otherwise, passes along the return value
3747  * from _deassert_hardreset().
3748  */
3749 int omap_hwmod_deassert_hardreset(struct omap_hwmod *oh, const char *name)
3750 {
3751         int ret;
3752         unsigned long flags;
3753 
3754         if (!oh)
3755                 return -EINVAL;
3756 
3757         spin_lock_irqsave(&oh->_lock, flags);
3758         ret = _deassert_hardreset(oh, name);
3759         spin_unlock_irqrestore(&oh->_lock, flags);
3760 
3761         return ret;
3762 }
3763 
3764 /**
3765  * omap_hwmod_for_each_by_class - call @fn for each hwmod of class @classname
3766  * @classname: struct omap_hwmod_class name to search for
3767  * @fn: callback function pointer to call for each hwmod in class @classname
3768  * @user: arbitrary context data to pass to the callback function
3769  *
3770  * For each omap_hwmod of class @classname, call @fn.
3771  * If the callback function returns something other than
3772  * zero, the iterator is terminated, and the callback function's return
3773  * value is passed back to the caller.  Returns 0 upon success, -EINVAL
3774  * if @classname or @fn are NULL, or passes back the error code from @fn.
3775  */
3776 int omap_hwmod_for_each_by_class(const char *classname,
3777                                  int (*fn)(struct omap_hwmod *oh,
3778                                            void *user),
3779                                  void *user)
3780 {
3781         struct omap_hwmod *temp_oh;
3782         int ret = 0;
3783 
3784         if (!classname || !fn)
3785                 return -EINVAL;
3786 
3787         pr_debug("omap_hwmod: %s: looking for modules of class %s\n",
3788                  __func__, classname);
3789 
3790         list_for_each_entry(temp_oh, &omap_hwmod_list, node) {
3791                 if (!strcmp(temp_oh->class->name, classname)) {
3792                         pr_debug("omap_hwmod: %s: %s: calling callback fn\n",
3793                                  __func__, temp_oh->name);
3794                         ret = (*fn)(temp_oh, user);
3795                         if (ret)
3796                                 break;
3797                 }
3798         }
3799 
3800         if (ret)
3801                 pr_debug("omap_hwmod: %s: iterator terminated early: %d\n",
3802                          __func__, ret);
3803 
3804         return ret;
3805 }
3806 
3807 /**
3808  * omap_hwmod_set_postsetup_state - set the post-_setup() state for this hwmod
3809  * @oh: struct omap_hwmod *
3810  * @state: state that _setup() should leave the hwmod in
3811  *
3812  * Sets the hwmod state that @oh will enter at the end of _setup()
3813  * (called by omap_hwmod_setup_*()).  See also the documentation
3814  * for _setup_postsetup(), above.  Returns 0 upon success or
3815  * -EINVAL if there is a problem with the arguments or if the hwmod is
3816  * in the wrong state.
3817  */
3818 int omap_hwmod_set_postsetup_state(struct omap_hwmod *oh, u8 state)
3819 {
3820         int ret;
3821         unsigned long flags;
3822 
3823         if (!oh)
3824                 return -EINVAL;
3825 
3826         if (state != _HWMOD_STATE_DISABLED &&
3827             state != _HWMOD_STATE_ENABLED &&
3828             state != _HWMOD_STATE_IDLE)
3829                 return -EINVAL;
3830 
3831         spin_lock_irqsave(&oh->_lock, flags);
3832 
3833         if (oh->_state != _HWMOD_STATE_REGISTERED) {
3834                 ret = -EINVAL;
3835                 goto ohsps_unlock;
3836         }
3837 
3838         oh->_postsetup_state = state;
3839         ret = 0;
3840 
3841 ohsps_unlock:
3842         spin_unlock_irqrestore(&oh->_lock, flags);
3843 
3844         return ret;
3845 }
3846 
3847 /**
3848  * omap_hwmod_get_context_loss_count - get lost context count
3849  * @oh: struct omap_hwmod *
3850  *
3851  * Returns the context loss count of associated @oh
3852  * upon success, or zero if no context loss data is available.
3853  *
3854  * On OMAP4, this queries the per-hwmod context loss register,
3855  * assuming one exists.  If not, or on OMAP2/3, this queries the
3856  * enclosing powerdomain context loss count.
3857  */
3858 int omap_hwmod_get_context_loss_count(struct omap_hwmod *oh)
3859 {
3860         struct powerdomain *pwrdm;
3861         int ret = 0;
3862 
3863         if (soc_ops.get_context_lost)
3864                 return soc_ops.get_context_lost(oh);
3865 
3866         pwrdm = omap_hwmod_get_pwrdm(oh);
3867         if (pwrdm)
3868                 ret = pwrdm_get_context_loss_count(pwrdm);
3869 
3870         return ret;
3871 }
3872 
3873 /**
3874  * omap_hwmod_init - initialize the hwmod code
3875  *
3876  * Sets up some function pointers needed by the hwmod code to operate on the
3877  * currently-booted SoC.  Intended to be called once during kernel init
3878  * before any hwmods are registered.  No return value.
3879  */
3880 void __init omap_hwmod_init(void)
3881 {
3882         if (cpu_is_omap24xx()) {
3883                 soc_ops.wait_target_ready = _omap2xxx_3xxx_wait_target_ready;
3884                 soc_ops.assert_hardreset = _omap2_assert_hardreset;
3885                 soc_ops.deassert_hardreset = _omap2_deassert_hardreset;
3886                 soc_ops.is_hardreset_asserted = _omap2_is_hardreset_asserted;
3887         } else if (cpu_is_omap34xx()) {
3888                 soc_ops.wait_target_ready = _omap2xxx_3xxx_wait_target_ready;
3889                 soc_ops.assert_hardreset = _omap2_assert_hardreset;
3890                 soc_ops.deassert_hardreset = _omap2_deassert_hardreset;
3891                 soc_ops.is_hardreset_asserted = _omap2_is_hardreset_asserted;
3892                 soc_ops.init_clkdm = _init_clkdm;
3893         } else if (cpu_is_omap44xx() || soc_is_omap54xx() || soc_is_dra7xx()) {
3894                 soc_ops.enable_module = _omap4_enable_module;
3895                 soc_ops.disable_module = _omap4_disable_module;
3896                 soc_ops.wait_target_ready = _omap4_wait_target_ready;
3897                 soc_ops.assert_hardreset = _omap4_assert_hardreset;
3898                 soc_ops.deassert_hardreset = _omap4_deassert_hardreset;
3899                 soc_ops.is_hardreset_asserted = _omap4_is_hardreset_asserted;
3900                 soc_ops.init_clkdm = _init_clkdm;
3901                 soc_ops.update_context_lost = _omap4_update_context_lost;
3902                 soc_ops.get_context_lost = _omap4_get_context_lost;
3903         } else if (cpu_is_ti814x() || cpu_is_ti816x() || soc_is_am33xx() ||
3904                    soc_is_am43xx()) {
3905                 soc_ops.enable_module = _omap4_enable_module;
3906                 soc_ops.disable_module = _omap4_disable_module;
3907                 soc_ops.wait_target_ready = _omap4_wait_target_ready;
3908                 soc_ops.assert_hardreset = _omap4_assert_hardreset;
3909                 soc_ops.deassert_hardreset = _am33xx_deassert_hardreset;
3910                 soc_ops.is_hardreset_asserted = _omap4_is_hardreset_asserted;
3911                 soc_ops.init_clkdm = _init_clkdm;
3912         } else {
3913                 WARN(1, "omap_hwmod: unknown SoC type\n");
3914         }
3915 
3916         inited = true;
3917 }
3918 
3919 /**
3920  * omap_hwmod_get_main_clk - get pointer to main clock name
3921  * @oh: struct omap_hwmod *
3922  *
3923  * Returns the main clock name assocated with @oh upon success,
3924  * or NULL if @oh is NULL.
3925  */
3926 const char *omap_hwmod_get_main_clk(struct omap_hwmod *oh)
3927 {
3928         if (!oh)
3929                 return NULL;
3930 
3931         return oh->main_clk;
3932 }
3933 

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

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp