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