1 /* 2 * omap_hwmod implementation for OMAP2/3/4 3 * 4 * Copyright (C) 2009 Nokia Corporation 5 * Paul Walmsley 6 * With fixes and testing from Kevin Hilman 7 * 8 * Created in collaboration with (alphabetical order): Benoit Cousson, 9 * Kevin Hilman, Tony Lindgren, Rajendra Nayak, Vikram Pandita, Sakari 10 * Poussa, Anand Sawant, Santosh Shilimkar, Richard Woodruff 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License version 2 as 14 * published by the Free Software Foundation. 15 * 16 * This code manages "OMAP modules" (on-chip devices) and their 17 * integration with Linux device driver and bus code. 18 * 19 * References: 20 * - OMAP2420 Multimedia Processor Silicon Revision 2.1.1, 2.2 (SWPU064) 21 * - OMAP2430 Multimedia Device POP Silicon Revision 2.1 (SWPU090) 22 * - OMAP34xx Multimedia Device Silicon Revision 3.1 (SWPU108) 23 * - OMAP4430 Multimedia Device Silicon Revision 1.0 (SWPU140) 24 * - Open Core Protocol Specification 2.2 25 * 26 * To do: 27 * - pin mux handling 28 * - handle IO mapping 29 * - bus throughput & module latency measurement code 30 * 31 * XXX add tests at the beginning of each function to ensure the hwmod is 32 * in the appropriate state 33 * XXX error return values should be checked to ensure that they are 34 * appropriate 35 */ 36 #undef DEBUG 37 38 #include <linux/kernel.h> 39 #include <linux/errno.h> 40 #include <linux/io.h> 41 #include <linux/clk.h> 42 #include <linux/delay.h> 43 #include <linux/err.h> 44 #include <linux/list.h> 45 #include <linux/mutex.h> 46 #include <linux/bootmem.h> 47 48 #include <plat/common.h> 49 #include <plat/cpu.h> 50 #include <plat/clockdomain.h> 51 #include <plat/powerdomain.h> 52 #include <plat/clock.h> 53 #include <plat/omap_hwmod.h> 54 55 #include "cm.h" 56 57 /* Maximum microseconds to wait for OMAP module to reset */ 58 #define MAX_MODULE_RESET_WAIT 10000 59 60 /* Name of the OMAP hwmod for the MPU */ 61 #define MPU_INITIATOR_NAME "mpu_hwmod" 62 63 /* omap_hwmod_list contains all registered struct omap_hwmods */ 64 static LIST_HEAD(omap_hwmod_list); 65 66 static DEFINE_MUTEX(omap_hwmod_mutex); 67 68 /* mpu_oh: used to add/remove MPU initiator from sleepdep list */ 69 static struct omap_hwmod *mpu_oh; 70 71 /* inited: 0 if omap_hwmod_init() has not yet been called; 1 otherwise */ 72 static u8 inited; 73 74 75 /* Private functions */ 76 77 /** 78 * _update_sysc_cache - return the module OCP_SYSCONFIG register, keep copy 79 * @oh: struct omap_hwmod * 80 * 81 * Load the current value of the hwmod OCP_SYSCONFIG register into the 82 * struct omap_hwmod for later use. Returns -EINVAL if the hwmod has no 83 * OCP_SYSCONFIG register or 0 upon success. 84 */ 85 static int _update_sysc_cache(struct omap_hwmod *oh) 86 { 87 if (!oh->sysconfig) { 88 WARN(!oh->sysconfig, "omap_hwmod: %s: cannot read " 89 "OCP_SYSCONFIG: not defined on hwmod\n", oh->name); 90 return -EINVAL; 91 } 92 93 /* XXX ensure module interface clock is up */ 94 95 oh->_sysc_cache = omap_hwmod_readl(oh, oh->sysconfig->sysc_offs); 96 97 oh->_int_flags |= _HWMOD_SYSCONFIG_LOADED; 98 99 return 0; 100 } 101 102 /** 103 * _write_sysconfig - write a value to the module's OCP_SYSCONFIG register 104 * @v: OCP_SYSCONFIG value to write 105 * @oh: struct omap_hwmod * 106 * 107 * Write @v into the module OCP_SYSCONFIG register, if it has one. No 108 * return value. 109 */ 110 static void _write_sysconfig(u32 v, struct omap_hwmod *oh) 111 { 112 if (!oh->sysconfig) { 113 WARN(!oh->sysconfig, "omap_hwmod: %s: cannot write " 114 "OCP_SYSCONFIG: not defined on hwmod\n", oh->name); 115 return; 116 } 117 118 /* XXX ensure module interface clock is up */ 119 120 if (oh->_sysc_cache != v) { 121 oh->_sysc_cache = v; 122 omap_hwmod_writel(v, oh, oh->sysconfig->sysc_offs); 123 } 124 } 125 126 /** 127 * _set_master_standbymode: set the OCP_SYSCONFIG MIDLEMODE field in @v 128 * @oh: struct omap_hwmod * 129 * @standbymode: MIDLEMODE field bits 130 * @v: pointer to register contents to modify 131 * 132 * Update the master standby mode bits in @v to be @standbymode for 133 * the @oh hwmod. Does not write to the hardware. Returns -EINVAL 134 * upon error or 0 upon success. 135 */ 136 static int _set_master_standbymode(struct omap_hwmod *oh, u8 standbymode, 137 u32 *v) 138 { 139 if (!oh->sysconfig || 140 !(oh->sysconfig->sysc_flags & SYSC_HAS_MIDLEMODE)) 141 return -EINVAL; 142 143 *v &= ~SYSC_MIDLEMODE_MASK; 144 *v |= __ffs(standbymode) << SYSC_MIDLEMODE_SHIFT; 145 146 return 0; 147 } 148 149 /** 150 * _set_slave_idlemode: set the OCP_SYSCONFIG SIDLEMODE field in @v 151 * @oh: struct omap_hwmod * 152 * @idlemode: SIDLEMODE field bits 153 * @v: pointer to register contents to modify 154 * 155 * Update the slave idle mode bits in @v to be @idlemode for the @oh 156 * hwmod. Does not write to the hardware. Returns -EINVAL upon error 157 * or 0 upon success. 158 */ 159 static int _set_slave_idlemode(struct omap_hwmod *oh, u8 idlemode, u32 *v) 160 { 161 if (!oh->sysconfig || 162 !(oh->sysconfig->sysc_flags & SYSC_HAS_SIDLEMODE)) 163 return -EINVAL; 164 165 *v &= ~SYSC_SIDLEMODE_MASK; 166 *v |= __ffs(idlemode) << SYSC_SIDLEMODE_SHIFT; 167 168 return 0; 169 } 170 171 /** 172 * _set_clockactivity: set OCP_SYSCONFIG.CLOCKACTIVITY bits in @v 173 * @oh: struct omap_hwmod * 174 * @clockact: CLOCKACTIVITY field bits 175 * @v: pointer to register contents to modify 176 * 177 * Update the clockactivity mode bits in @v to be @clockact for the 178 * @oh hwmod. Used for additional powersaving on some modules. Does 179 * not write to the hardware. Returns -EINVAL upon error or 0 upon 180 * success. 181 */ 182 static int _set_clockactivity(struct omap_hwmod *oh, u8 clockact, u32 *v) 183 { 184 if (!oh->sysconfig || 185 !(oh->sysconfig->sysc_flags & SYSC_HAS_CLOCKACTIVITY)) 186 return -EINVAL; 187 188 *v &= ~SYSC_CLOCKACTIVITY_MASK; 189 *v |= clockact << SYSC_CLOCKACTIVITY_SHIFT; 190 191 return 0; 192 } 193 194 /** 195 * _set_softreset: set OCP_SYSCONFIG.CLOCKACTIVITY bits in @v 196 * @oh: struct omap_hwmod * 197 * @v: pointer to register contents to modify 198 * 199 * Set the SOFTRESET bit in @v for hwmod @oh. Returns -EINVAL upon 200 * error or 0 upon success. 201 */ 202 static int _set_softreset(struct omap_hwmod *oh, u32 *v) 203 { 204 if (!oh->sysconfig || 205 !(oh->sysconfig->sysc_flags & SYSC_HAS_SOFTRESET)) 206 return -EINVAL; 207 208 *v |= SYSC_SOFTRESET_MASK; 209 210 return 0; 211 } 212 213 /** 214 * _set_module_autoidle: set the OCP_SYSCONFIG AUTOIDLE field in @v 215 * @oh: struct omap_hwmod * 216 * @autoidle: desired AUTOIDLE bitfield value (0 or 1) 217 * @v: pointer to register contents to modify 218 * 219 * Update the module autoidle bit in @v to be @autoidle for the @oh 220 * hwmod. The autoidle bit controls whether the module can gate 221 * internal clocks automatically when it isn't doing anything; the 222 * exact function of this bit varies on a per-module basis. This 223 * function does not write to the hardware. Returns -EINVAL upon 224 * error or 0 upon success. 225 */ 226 static int _set_module_autoidle(struct omap_hwmod *oh, u8 autoidle, 227 u32 *v) 228 { 229 if (!oh->sysconfig || 230 !(oh->sysconfig->sysc_flags & SYSC_HAS_AUTOIDLE)) 231 return -EINVAL; 232 233 *v &= ~SYSC_AUTOIDLE_MASK; 234 *v |= autoidle << SYSC_AUTOIDLE_SHIFT; 235 236 return 0; 237 } 238 239 /** 240 * _enable_wakeup: set OCP_SYSCONFIG.ENAWAKEUP bit in the hardware 241 * @oh: struct omap_hwmod * 242 * 243 * Allow the hardware module @oh to send wakeups. Returns -EINVAL 244 * upon error or 0 upon success. 245 */ 246 static int _enable_wakeup(struct omap_hwmod *oh) 247 { 248 u32 v; 249 250 if (!oh->sysconfig || 251 !(oh->sysconfig->sysc_flags & SYSC_HAS_ENAWAKEUP)) 252 return -EINVAL; 253 254 v = oh->_sysc_cache; 255 v |= SYSC_ENAWAKEUP_MASK; 256 _write_sysconfig(v, oh); 257 258 /* XXX test pwrdm_get_wken for this hwmod's subsystem */ 259 260 oh->_int_flags |= _HWMOD_WAKEUP_ENABLED; 261 262 return 0; 263 } 264 265 /** 266 * _disable_wakeup: clear OCP_SYSCONFIG.ENAWAKEUP bit in the hardware 267 * @oh: struct omap_hwmod * 268 * 269 * Prevent the hardware module @oh to send wakeups. Returns -EINVAL 270 * upon error or 0 upon success. 271 */ 272 static int _disable_wakeup(struct omap_hwmod *oh) 273 { 274 u32 v; 275 276 if (!oh->sysconfig || 277 !(oh->sysconfig->sysc_flags & SYSC_HAS_ENAWAKEUP)) 278 return -EINVAL; 279 280 v = oh->_sysc_cache; 281 v &= ~SYSC_ENAWAKEUP_MASK; 282 _write_sysconfig(v, oh); 283 284 /* XXX test pwrdm_get_wken for this hwmod's subsystem */ 285 286 oh->_int_flags &= ~_HWMOD_WAKEUP_ENABLED; 287 288 return 0; 289 } 290 291 /** 292 * _add_initiator_dep: prevent @oh from smart-idling while @init_oh is active 293 * @oh: struct omap_hwmod * 294 * 295 * Prevent the hardware module @oh from entering idle while the 296 * hardare module initiator @init_oh is active. Useful when a module 297 * will be accessed by a particular initiator (e.g., if a module will 298 * be accessed by the IVA, there should be a sleepdep between the IVA 299 * initiator and the module). Only applies to modules in smart-idle 300 * mode. Returns -EINVAL upon error or passes along 301 * pwrdm_add_sleepdep() value upon success. 302 */ 303 static int _add_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh) 304 { 305 if (!oh->_clk) 306 return -EINVAL; 307 308 return pwrdm_add_sleepdep(oh->_clk->clkdm->pwrdm.ptr, 309 init_oh->_clk->clkdm->pwrdm.ptr); 310 } 311 312 /** 313 * _del_initiator_dep: allow @oh to smart-idle even if @init_oh is active 314 * @oh: struct omap_hwmod * 315 * 316 * Allow the hardware module @oh to enter idle while the hardare 317 * module initiator @init_oh is active. Useful when a module will not 318 * be accessed by a particular initiator (e.g., if a module will not 319 * be accessed by the IVA, there should be no sleepdep between the IVA 320 * initiator and the module). Only applies to modules in smart-idle 321 * mode. Returns -EINVAL upon error or passes along 322 * pwrdm_add_sleepdep() value upon success. 323 */ 324 static int _del_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh) 325 { 326 if (!oh->_clk) 327 return -EINVAL; 328 329 return pwrdm_del_sleepdep(oh->_clk->clkdm->pwrdm.ptr, 330 init_oh->_clk->clkdm->pwrdm.ptr); 331 } 332 333 /** 334 * _init_main_clk - get a struct clk * for the the hwmod's main functional clk 335 * @oh: struct omap_hwmod * 336 * 337 * Called from _init_clocks(). Populates the @oh _clk (main 338 * functional clock pointer) if a main_clk is present. Returns 0 on 339 * success or -EINVAL on error. 340 */ 341 static int _init_main_clk(struct omap_hwmod *oh) 342 { 343 struct clk *c; 344 int ret = 0; 345 346 if (!oh->clkdev_con_id) 347 return 0; 348 349 c = clk_get_sys(oh->clkdev_dev_id, oh->clkdev_con_id); 350 WARN(IS_ERR(c), "omap_hwmod: %s: cannot clk_get main_clk %s.%s\n", 351 oh->name, oh->clkdev_dev_id, oh->clkdev_con_id); 352 if (IS_ERR(c)) 353 ret = -EINVAL; 354 oh->_clk = c; 355 356 WARN(!c->clkdm, "omap_hwmod: %s: missing clockdomain for %s.\n", 357 oh->clkdev_con_id, c->name); 358 359 return ret; 360 } 361 362 /** 363 * _init_interface_clk - get a struct clk * for the the hwmod's interface clks 364 * @oh: struct omap_hwmod * 365 * 366 * Called from _init_clocks(). Populates the @oh OCP slave interface 367 * clock pointers. Returns 0 on success or -EINVAL on error. 368 */ 369 static int _init_interface_clks(struct omap_hwmod *oh) 370 { 371 struct omap_hwmod_ocp_if *os; 372 struct clk *c; 373 int i; 374 int ret = 0; 375 376 if (oh->slaves_cnt == 0) 377 return 0; 378 379 for (i = 0, os = *oh->slaves; i < oh->slaves_cnt; i++, os++) { 380 if (!os->clkdev_con_id) 381 continue; 382 383 c = clk_get_sys(os->clkdev_dev_id, os->clkdev_con_id); 384 WARN(IS_ERR(c), "omap_hwmod: %s: cannot clk_get " 385 "interface_clk %s.%s\n", oh->name, 386 os->clkdev_dev_id, os->clkdev_con_id); 387 if (IS_ERR(c)) 388 ret = -EINVAL; 389 os->_clk = c; 390 } 391 392 return ret; 393 } 394 395 /** 396 * _init_opt_clk - get a struct clk * for the the hwmod's optional clocks 397 * @oh: struct omap_hwmod * 398 * 399 * Called from _init_clocks(). Populates the @oh omap_hwmod_opt_clk 400 * clock pointers. Returns 0 on success or -EINVAL on error. 401 */ 402 static int _init_opt_clks(struct omap_hwmod *oh) 403 { 404 struct omap_hwmod_opt_clk *oc; 405 struct clk *c; 406 int i; 407 int ret = 0; 408 409 for (i = oh->opt_clks_cnt, oc = oh->opt_clks; i > 0; i--, oc++) { 410 c = clk_get_sys(oc->clkdev_dev_id, oc->clkdev_con_id); 411 WARN(IS_ERR(c), "omap_hwmod: %s: cannot clk_get opt_clk " 412 "%s.%s\n", oh->name, oc->clkdev_dev_id, 413 oc->clkdev_con_id); 414 if (IS_ERR(c)) 415 ret = -EINVAL; 416 oc->_clk = c; 417 } 418 419 return ret; 420 } 421 422 /** 423 * _enable_clocks - enable hwmod main clock and interface clocks 424 * @oh: struct omap_hwmod * 425 * 426 * Enables all clocks necessary for register reads and writes to succeed 427 * on the hwmod @oh. Returns 0. 428 */ 429 static int _enable_clocks(struct omap_hwmod *oh) 430 { 431 struct omap_hwmod_ocp_if *os; 432 int i; 433 434 pr_debug("omap_hwmod: %s: enabling clocks\n", oh->name); 435 436 if (oh->_clk && !IS_ERR(oh->_clk)) 437 clk_enable(oh->_clk); 438 439 if (oh->slaves_cnt > 0) { 440 for (i = 0, os = *oh->slaves; i < oh->slaves_cnt; i++, os++) { 441 struct clk *c = os->_clk; 442 443 if (c && !IS_ERR(c) && (os->flags & OCPIF_SWSUP_IDLE)) 444 clk_enable(c); 445 } 446 } 447 448 /* The opt clocks are controlled by the device driver. */ 449 450 return 0; 451 } 452 453 /** 454 * _disable_clocks - disable hwmod main clock and interface clocks 455 * @oh: struct omap_hwmod * 456 * 457 * Disables the hwmod @oh main functional and interface clocks. Returns 0. 458 */ 459 static int _disable_clocks(struct omap_hwmod *oh) 460 { 461 struct omap_hwmod_ocp_if *os; 462 int i; 463 464 pr_debug("omap_hwmod: %s: disabling clocks\n", oh->name); 465 466 if (oh->_clk && !IS_ERR(oh->_clk)) 467 clk_disable(oh->_clk); 468 469 if (oh->slaves_cnt > 0) { 470 for (i = 0, os = *oh->slaves; i < oh->slaves_cnt; i++, os++) { 471 struct clk *c = os->_clk; 472 473 if (c && !IS_ERR(c) && (os->flags & OCPIF_SWSUP_IDLE)) 474 clk_disable(c); 475 } 476 } 477 478 /* The opt clocks are controlled by the device driver. */ 479 480 return 0; 481 } 482 483 /** 484 * _find_mpu_port_index - find hwmod OCP slave port ID intended for MPU use 485 * @oh: struct omap_hwmod * 486 * 487 * Returns the array index of the OCP slave port that the MPU 488 * addresses the device on, or -EINVAL upon error or not found. 489 */ 490 static int _find_mpu_port_index(struct omap_hwmod *oh) 491 { 492 struct omap_hwmod_ocp_if *os; 493 int i; 494 int found = 0; 495 496 if (!oh || oh->slaves_cnt == 0) 497 return -EINVAL; 498 499 for (i = 0, os = *oh->slaves; i < oh->slaves_cnt; i++, os++) { 500 if (os->user & OCP_USER_MPU) { 501 found = 1; 502 break; 503 } 504 } 505 506 if (found) 507 pr_debug("omap_hwmod: %s: MPU OCP slave port ID %d\n", 508 oh->name, i); 509 else 510 pr_debug("omap_hwmod: %s: no MPU OCP slave port found\n", 511 oh->name); 512 513 return (found) ? i : -EINVAL; 514 } 515 516 /** 517 * _find_mpu_rt_base - find hwmod register target base addr accessible by MPU 518 * @oh: struct omap_hwmod * 519 * 520 * Return the virtual address of the base of the register target of 521 * device @oh, or NULL on error. 522 */ 523 static void __iomem *_find_mpu_rt_base(struct omap_hwmod *oh, u8 index) 524 { 525 struct omap_hwmod_ocp_if *os; 526 struct omap_hwmod_addr_space *mem; 527 int i; 528 int found = 0; 529 void __iomem *va_start; 530 531 if (!oh || oh->slaves_cnt == 0) 532 return NULL; 533 534 os = *oh->slaves + index; 535 536 for (i = 0, mem = os->addr; i < os->addr_cnt; i++, mem++) { 537 if (mem->flags & ADDR_TYPE_RT) { 538 found = 1; 539 break; 540 } 541 } 542 543 if (found) { 544 va_start = ioremap(mem->pa_start, mem->pa_end - mem->pa_start); 545 if (!va_start) { 546 pr_err("omap_hwmod: %s: Could not ioremap\n", oh->name); 547 return NULL; 548 } 549 pr_debug("omap_hwmod: %s: MPU register target at va %p\n", 550 oh->name, va_start); 551 } else { 552 pr_debug("omap_hwmod: %s: no MPU register target found\n", 553 oh->name); 554 } 555 556 return (found) ? va_start : NULL; 557 } 558 559 /** 560 * _sysc_enable - try to bring a module out of idle via OCP_SYSCONFIG 561 * @oh: struct omap_hwmod * 562 * 563 * If module is marked as SWSUP_SIDLE, force the module out of slave 564 * idle; otherwise, configure it for smart-idle. If module is marked 565 * as SWSUP_MSUSPEND, force the module out of master standby; 566 * otherwise, configure it for smart-standby. No return value. 567 */ 568 static void _sysc_enable(struct omap_hwmod *oh) 569 { 570 u8 idlemode; 571 u32 v; 572 573 if (!oh->sysconfig) 574 return; 575 576 v = oh->_sysc_cache; 577 578 if (oh->sysconfig->sysc_flags & SYSC_HAS_SIDLEMODE) { 579 idlemode = (oh->flags & HWMOD_SWSUP_SIDLE) ? 580 HWMOD_IDLEMODE_NO : HWMOD_IDLEMODE_SMART; 581 _set_slave_idlemode(oh, idlemode, &v); 582 } 583 584 if (oh->sysconfig->sysc_flags & SYSC_HAS_MIDLEMODE) { 585 idlemode = (oh->flags & HWMOD_SWSUP_MSTANDBY) ? 586 HWMOD_IDLEMODE_NO : HWMOD_IDLEMODE_SMART; 587 _set_master_standbymode(oh, idlemode, &v); 588 } 589 590 if (oh->sysconfig->sysc_flags & SYSC_HAS_AUTOIDLE) { 591 idlemode = (oh->flags & HWMOD_NO_OCP_AUTOIDLE) ? 592 0 : 1; 593 _set_module_autoidle(oh, idlemode, &v); 594 } 595 596 /* XXX OCP ENAWAKEUP bit? */ 597 598 /* 599 * XXX The clock framework should handle this, by 600 * calling into this code. But this must wait until the 601 * clock structures are tagged with omap_hwmod entries 602 */ 603 if (oh->flags & HWMOD_SET_DEFAULT_CLOCKACT && 604 oh->sysconfig->sysc_flags & SYSC_HAS_CLOCKACTIVITY) 605 _set_clockactivity(oh, oh->sysconfig->clockact, &v); 606 607 _write_sysconfig(v, oh); 608 } 609 610 /** 611 * _sysc_idle - try to put a module into idle via OCP_SYSCONFIG 612 * @oh: struct omap_hwmod * 613 * 614 * If module is marked as SWSUP_SIDLE, force the module into slave 615 * idle; otherwise, configure it for smart-idle. If module is marked 616 * as SWSUP_MSUSPEND, force the module into master standby; otherwise, 617 * configure it for smart-standby. No return value. 618 */ 619 static void _sysc_idle(struct omap_hwmod *oh) 620 { 621 u8 idlemode; 622 u32 v; 623 624 if (!oh->sysconfig) 625 return; 626 627 v = oh->_sysc_cache; 628 629 if (oh->sysconfig->sysc_flags & SYSC_HAS_SIDLEMODE) { 630 idlemode = (oh->flags & HWMOD_SWSUP_SIDLE) ? 631 HWMOD_IDLEMODE_FORCE : HWMOD_IDLEMODE_SMART; 632 _set_slave_idlemode(oh, idlemode, &v); 633 } 634 635 if (oh->sysconfig->sysc_flags & SYSC_HAS_MIDLEMODE) { 636 idlemode = (oh->flags & HWMOD_SWSUP_MSTANDBY) ? 637 HWMOD_IDLEMODE_FORCE : HWMOD_IDLEMODE_SMART; 638 _set_master_standbymode(oh, idlemode, &v); 639 } 640 641 _write_sysconfig(v, oh); 642 } 643 644 /** 645 * _sysc_shutdown - force a module into idle via OCP_SYSCONFIG 646 * @oh: struct omap_hwmod * 647 * 648 * Force the module into slave idle and master suspend. No return 649 * value. 650 */ 651 static void _sysc_shutdown(struct omap_hwmod *oh) 652 { 653 u32 v; 654 655 if (!oh->sysconfig) 656 return; 657 658 v = oh->_sysc_cache; 659 660 if (oh->sysconfig->sysc_flags & SYSC_HAS_SIDLEMODE) 661 _set_slave_idlemode(oh, HWMOD_IDLEMODE_FORCE, &v); 662 663 if (oh->sysconfig->sysc_flags & SYSC_HAS_MIDLEMODE) 664 _set_master_standbymode(oh, HWMOD_IDLEMODE_FORCE, &v); 665 666 if (oh->sysconfig->sysc_flags & SYSC_HAS_AUTOIDLE) 667 _set_module_autoidle(oh, 1, &v); 668 669 _write_sysconfig(v, oh); 670 } 671 672 /** 673 * _lookup - find an omap_hwmod by name 674 * @name: find an omap_hwmod by name 675 * 676 * Return a pointer to an omap_hwmod by name, or NULL if not found. 677 * Caller must hold omap_hwmod_mutex. 678 */ 679 static struct omap_hwmod *_lookup(const char *name) 680 { 681 struct omap_hwmod *oh, *temp_oh; 682 683 oh = NULL; 684 685 list_for_each_entry(temp_oh, &omap_hwmod_list, node) { 686 if (!strcmp(name, temp_oh->name)) { 687 oh = temp_oh; 688 break; 689 } 690 } 691 692 return oh; 693 } 694 695 /** 696 * _init_clocks - clk_get() all clocks associated with this hwmod 697 * @oh: struct omap_hwmod * 698 * 699 * Called by omap_hwmod_late_init() (after omap2_clk_init()). 700 * Resolves all clock names embedded in the hwmod. Must be called 701 * with omap_hwmod_mutex held. Returns -EINVAL if the omap_hwmod 702 * has not yet been registered or if the clocks have already been 703 * initialized, 0 on success, or a non-zero error on failure. 704 */ 705 static int _init_clocks(struct omap_hwmod *oh) 706 { 707 int ret = 0; 708 709 if (!oh || (oh->_state != _HWMOD_STATE_REGISTERED)) 710 return -EINVAL; 711 712 pr_debug("omap_hwmod: %s: looking up clocks\n", oh->name); 713 714 ret |= _init_main_clk(oh); 715 ret |= _init_interface_clks(oh); 716 ret |= _init_opt_clks(oh); 717 718 oh->_state = _HWMOD_STATE_CLKS_INITED; 719 720 return ret; 721 } 722 723 /** 724 * _wait_target_ready - wait for a module to leave slave idle 725 * @oh: struct omap_hwmod * 726 * 727 * Wait for a module @oh to leave slave idle. Returns 0 if the module 728 * does not have an IDLEST bit or if the module successfully leaves 729 * slave idle; otherwise, pass along the return value of the 730 * appropriate *_cm_wait_module_ready() function. 731 */ 732 static int _wait_target_ready(struct omap_hwmod *oh) 733 { 734 struct omap_hwmod_ocp_if *os; 735 int ret; 736 737 if (!oh) 738 return -EINVAL; 739 740 if (oh->_int_flags & _HWMOD_NO_MPU_PORT) 741 return 0; 742 743 os = *oh->slaves + oh->_mpu_port_index; 744 745 if (!(os->flags & OCPIF_HAS_IDLEST)) 746 return 0; 747 748 /* XXX check module SIDLEMODE */ 749 750 /* XXX check clock enable states */ 751 752 if (cpu_is_omap24xx() || cpu_is_omap34xx()) { 753 ret = omap2_cm_wait_module_ready(oh->prcm.omap2.module_offs, 754 oh->prcm.omap2.idlest_reg_id, 755 oh->prcm.omap2.idlest_idle_bit); 756 #if 0 757 } else if (cpu_is_omap44xx()) { 758 ret = omap4_cm_wait_module_ready(oh->prcm.omap4.module_offs, 759 oh->prcm.omap4.device_offs); 760 #endif 761 } else { 762 BUG(); 763 }; 764 765 return ret; 766 } 767 768 /** 769 * _reset - reset an omap_hwmod 770 * @oh: struct omap_hwmod * 771 * 772 * Resets an omap_hwmod @oh via the OCP_SYSCONFIG bit. hwmod must be 773 * enabled for this to work. Must be called with omap_hwmod_mutex 774 * held. Returns -EINVAL if the hwmod cannot be reset this way or if 775 * the hwmod is in the wrong state, -ETIMEDOUT if the module did not 776 * reset in time, or 0 upon success. 777 */ 778 static int _reset(struct omap_hwmod *oh) 779 { 780 u32 r, v; 781 int c = 0; 782 783 if (!oh->sysconfig || 784 !(oh->sysconfig->sysc_flags & SYSC_HAS_SOFTRESET) || 785 (oh->sysconfig->sysc_flags & SYSS_MISSING)) 786 return -EINVAL; 787 788 /* clocks must be on for this operation */ 789 if (oh->_state != _HWMOD_STATE_ENABLED) { 790 WARN(1, "omap_hwmod: %s: reset can only be entered from " 791 "enabled state\n", oh->name); 792 return -EINVAL; 793 } 794 795 pr_debug("omap_hwmod: %s: resetting\n", oh->name); 796 797 v = oh->_sysc_cache; 798 r = _set_softreset(oh, &v); 799 if (r) 800 return r; 801 _write_sysconfig(v, oh); 802 803 omap_test_timeout((omap_hwmod_readl(oh, oh->sysconfig->syss_offs) & 804 SYSS_RESETDONE_MASK), 805 MAX_MODULE_RESET_WAIT, c); 806 807 if (c == MAX_MODULE_RESET_WAIT) 808 WARN(1, "omap_hwmod: %s: failed to reset in %d usec\n", 809 oh->name, MAX_MODULE_RESET_WAIT); 810 else 811 pr_debug("omap_hwmod: %s: reset in %d usec\n", oh->name, c); 812 813 /* 814 * XXX add _HWMOD_STATE_WEDGED for modules that don't come back from 815 * _wait_target_ready() or _reset() 816 */ 817 818 return (c == MAX_MODULE_RESET_WAIT) ? -ETIMEDOUT : 0; 819 } 820 821 /** 822 * _enable - enable an omap_hwmod 823 * @oh: struct omap_hwmod * 824 * 825 * Enables an omap_hwmod @oh such that the MPU can access the hwmod's 826 * register target. Must be called with omap_hwmod_mutex held. 827 * Returns -EINVAL if the hwmod is in the wrong state or passes along 828 * the return value of _wait_target_ready(). 829 */ 830 static int _enable(struct omap_hwmod *oh) 831 { 832 int r; 833 834 if (oh->_state != _HWMOD_STATE_INITIALIZED && 835 oh->_state != _HWMOD_STATE_IDLE && 836 oh->_state != _HWMOD_STATE_DISABLED) { 837 WARN(1, "omap_hwmod: %s: enabled state can only be entered " 838 "from initialized, idle, or disabled state\n", oh->name); 839 return -EINVAL; 840 } 841 842 pr_debug("omap_hwmod: %s: enabling\n", oh->name); 843 844 /* XXX mux balls */ 845 846 _add_initiator_dep(oh, mpu_oh); 847 _enable_clocks(oh); 848 849 if (oh->sysconfig) { 850 if (!(oh->_int_flags & _HWMOD_SYSCONFIG_LOADED)) 851 _update_sysc_cache(oh); 852 _sysc_enable(oh); 853 } 854 855 r = _wait_target_ready(oh); 856 if (!r) 857 oh->_state = _HWMOD_STATE_ENABLED; 858 859 return r; 860 } 861 862 /** 863 * _idle - idle an omap_hwmod 864 * @oh: struct omap_hwmod * 865 * 866 * Idles an omap_hwmod @oh. This should be called once the hwmod has 867 * no further work. Returns -EINVAL if the hwmod is in the wrong 868 * state or returns 0. 869 */ 870 static int _idle(struct omap_hwmod *oh) 871 { 872 if (oh->_state != _HWMOD_STATE_ENABLED) { 873 WARN(1, "omap_hwmod: %s: idle state can only be entered from " 874 "enabled state\n", oh->name); 875 return -EINVAL; 876 } 877 878 pr_debug("omap_hwmod: %s: idling\n", oh->name); 879 880 if (oh->sysconfig) 881 _sysc_idle(oh); 882 _del_initiator_dep(oh, mpu_oh); 883 _disable_clocks(oh); 884 885 oh->_state = _HWMOD_STATE_IDLE; 886 887 return 0; 888 } 889 890 /** 891 * _shutdown - shutdown an omap_hwmod 892 * @oh: struct omap_hwmod * 893 * 894 * Shut down an omap_hwmod @oh. This should be called when the driver 895 * used for the hwmod is removed or unloaded or if the driver is not 896 * used by the system. Returns -EINVAL if the hwmod is in the wrong 897 * state or returns 0. 898 */ 899 static int _shutdown(struct omap_hwmod *oh) 900 { 901 if (oh->_state != _HWMOD_STATE_IDLE && 902 oh->_state != _HWMOD_STATE_ENABLED) { 903 WARN(1, "omap_hwmod: %s: disabled state can only be entered " 904 "from idle, or enabled state\n", oh->name); 905 return -EINVAL; 906 } 907 908 pr_debug("omap_hwmod: %s: disabling\n", oh->name); 909 910 if (oh->sysconfig) 911 _sysc_shutdown(oh); 912 _del_initiator_dep(oh, mpu_oh); 913 /* XXX what about the other system initiators here? DMA, tesla, d2d */ 914 _disable_clocks(oh); 915 /* XXX Should this code also force-disable the optional clocks? */ 916 917 /* XXX mux any associated balls to safe mode */ 918 919 oh->_state = _HWMOD_STATE_DISABLED; 920 921 return 0; 922 } 923 924 /** 925 * _setup - do initial configuration of omap_hwmod 926 * @oh: struct omap_hwmod * 927 * 928 * Writes the CLOCKACTIVITY bits @clockact to the hwmod @oh 929 * OCP_SYSCONFIG register. Must be called with omap_hwmod_mutex 930 * held. Returns -EINVAL if the hwmod is in the wrong state or returns 931 * 0. 932 */ 933 static int _setup(struct omap_hwmod *oh) 934 { 935 struct omap_hwmod_ocp_if *os; 936 int i; 937 938 if (!oh) 939 return -EINVAL; 940 941 /* Set iclk autoidle mode */ 942 if (oh->slaves_cnt > 0) { 943 for (i = 0, os = *oh->slaves; i < oh->slaves_cnt; i++, os++) { 944 struct clk *c = os->_clk; 945 946 if (!c || IS_ERR(c)) 947 continue; 948 949 if (os->flags & OCPIF_SWSUP_IDLE) { 950 /* XXX omap_iclk_deny_idle(c); */ 951 } else { 952 /* XXX omap_iclk_allow_idle(c); */ 953 clk_enable(c); 954 } 955 } 956 } 957 958 oh->_state = _HWMOD_STATE_INITIALIZED; 959 960 _enable(oh); 961 962 if (!(oh->flags & HWMOD_INIT_NO_RESET)) { 963 /* 964 * XXX Do the OCP_SYSCONFIG bits need to be 965 * reprogrammed after a reset? If not, then this can 966 * be removed. If they do, then probably the 967 * _enable() function should be split to avoid the 968 * rewrite of the OCP_SYSCONFIG register. 969 */ 970 if (oh->sysconfig) { 971 _update_sysc_cache(oh); 972 _sysc_enable(oh); 973 } 974 } 975 976 if (!(oh->flags & HWMOD_INIT_NO_IDLE)) 977 _idle(oh); 978 979 return 0; 980 } 981 982 983 984 /* Public functions */ 985 986 u32 omap_hwmod_readl(struct omap_hwmod *oh, u16 reg_offs) 987 { 988 return __raw_readl(oh->_rt_va + reg_offs); 989 } 990 991 void omap_hwmod_writel(u32 v, struct omap_hwmod *oh, u16 reg_offs) 992 { 993 __raw_writel(v, oh->_rt_va + reg_offs); 994 } 995 996 /** 997 * omap_hwmod_register - register a struct omap_hwmod 998 * @oh: struct omap_hwmod * 999 * 1000 * Registers the omap_hwmod @oh. Returns -EEXIST if an omap_hwmod already 1001 * has been registered by the same name; -EINVAL if the omap_hwmod is in the 1002 * wrong state, or 0 on success. 1003 * 1004 * XXX The data should be copied into bootmem, so the original data 1005 * should be marked __initdata and freed after init. This would allow 1006 * unneeded omap_hwmods to be freed on multi-OMAP configurations. Note 1007 * that the copy process would be relatively complex due to the large number 1008 * of substructures. 1009 */ 1010 int omap_hwmod_register(struct omap_hwmod *oh) 1011 { 1012 int ret, ms_id; 1013 1014 if (!oh || (oh->_state != _HWMOD_STATE_UNKNOWN)) 1015 return -EINVAL; 1016 1017 mutex_lock(&omap_hwmod_mutex); 1018 1019 pr_debug("omap_hwmod: %s: registering\n", oh->name); 1020 1021 if (_lookup(oh->name)) { 1022 ret = -EEXIST; 1023 goto ohr_unlock; 1024 } 1025 1026 ms_id = _find_mpu_port_index(oh); 1027 if (!IS_ERR_VALUE(ms_id)) { 1028 oh->_mpu_port_index = ms_id; 1029 oh->_rt_va = _find_mpu_rt_base(oh, oh->_mpu_port_index); 1030 } else { 1031 oh->_int_flags |= _HWMOD_NO_MPU_PORT; 1032 } 1033 1034 list_add_tail(&oh->node, &omap_hwmod_list); 1035 1036 oh->_state = _HWMOD_STATE_REGISTERED; 1037 1038 ret = 0; 1039 1040 ohr_unlock: 1041 mutex_unlock(&omap_hwmod_mutex); 1042 return ret; 1043 } 1044 1045 /** 1046 * omap_hwmod_lookup - look up a registered omap_hwmod by name 1047 * @name: name of the omap_hwmod to look up 1048 * 1049 * Given a @name of an omap_hwmod, return a pointer to the registered 1050 * struct omap_hwmod *, or NULL upon error. 1051 */ 1052 struct omap_hwmod *omap_hwmod_lookup(const char *name) 1053 { 1054 struct omap_hwmod *oh; 1055 1056 if (!name) 1057 return NULL; 1058 1059 mutex_lock(&omap_hwmod_mutex); 1060 oh = _lookup(name); 1061 mutex_unlock(&omap_hwmod_mutex); 1062 1063 return oh; 1064 } 1065 1066 /** 1067 * omap_hwmod_for_each - call function for each registered omap_hwmod 1068 * @fn: pointer to a callback function 1069 * 1070 * Call @fn for each registered omap_hwmod, passing @data to each 1071 * function. @fn must return 0 for success or any other value for 1072 * failure. If @fn returns non-zero, the iteration across omap_hwmods 1073 * will stop and the non-zero return value will be passed to the 1074 * caller of omap_hwmod_for_each(). @fn is called with 1075 * omap_hwmod_for_each() held. 1076 */ 1077 int omap_hwmod_for_each(int (*fn)(struct omap_hwmod *oh)) 1078 { 1079 struct omap_hwmod *temp_oh; 1080 int ret; 1081 1082 if (!fn) 1083 return -EINVAL; 1084 1085 mutex_lock(&omap_hwmod_mutex); 1086 list_for_each_entry(temp_oh, &omap_hwmod_list, node) { 1087 ret = (*fn)(temp_oh); 1088 if (ret) 1089 break; 1090 } 1091 mutex_unlock(&omap_hwmod_mutex); 1092 1093 return ret; 1094 } 1095 1096 1097 /** 1098 * omap_hwmod_init - init omap_hwmod code and register hwmods 1099 * @ohs: pointer to an array of omap_hwmods to register 1100 * 1101 * Intended to be called early in boot before the clock framework is 1102 * initialized. If @ohs is not null, will register all omap_hwmods 1103 * listed in @ohs that are valid for this chip. Returns -EINVAL if 1104 * omap_hwmod_init() has already been called or 0 otherwise. 1105 */ 1106 int omap_hwmod_init(struct omap_hwmod **ohs) 1107 { 1108 struct omap_hwmod *oh; 1109 int r; 1110 1111 if (inited) 1112 return -EINVAL; 1113 1114 inited = 1; 1115 1116 if (!ohs) 1117 return 0; 1118 1119 oh = *ohs; 1120 while (oh) { 1121 if (omap_chip_is(oh->omap_chip)) { 1122 r = omap_hwmod_register(oh); 1123 WARN(r, "omap_hwmod: %s: omap_hwmod_register returned " 1124 "%d\n", oh->name, r); 1125 } 1126 oh = *++ohs; 1127 } 1128 1129 return 0; 1130 } 1131 1132 /** 1133 * omap_hwmod_late_init - do some post-clock framework initialization 1134 * 1135 * Must be called after omap2_clk_init(). Resolves the struct clk names 1136 * to struct clk pointers for each registered omap_hwmod. Also calls 1137 * _setup() on each hwmod. Returns 0. 1138 */ 1139 int omap_hwmod_late_init(void) 1140 { 1141 int r; 1142 1143 /* XXX check return value */ 1144 r = omap_hwmod_for_each(_init_clocks); 1145 WARN(r, "omap_hwmod: omap_hwmod_late_init(): _init_clocks failed\n"); 1146 1147 mpu_oh = omap_hwmod_lookup(MPU_INITIATOR_NAME); 1148 WARN(!mpu_oh, "omap_hwmod: could not find MPU initiator hwmod %s\n", 1149 MPU_INITIATOR_NAME); 1150 1151 omap_hwmod_for_each(_setup); 1152 1153 return 0; 1154 } 1155 1156 /** 1157 * omap_hwmod_unregister - unregister an omap_hwmod 1158 * @oh: struct omap_hwmod * 1159 * 1160 * Unregisters a previously-registered omap_hwmod @oh. There's probably 1161 * no use case for this, so it is likely to be removed in a later version. 1162 * 1163 * XXX Free all of the bootmem-allocated structures here when that is 1164 * implemented. Make it clear that core code is the only code that is 1165 * expected to unregister modules. 1166 */ 1167 int omap_hwmod_unregister(struct omap_hwmod *oh) 1168 { 1169 if (!oh) 1170 return -EINVAL; 1171 1172 pr_debug("omap_hwmod: %s: unregistering\n", oh->name); 1173 1174 mutex_lock(&omap_hwmod_mutex); 1175 iounmap(oh->_rt_va); 1176 list_del(&oh->node); 1177 mutex_unlock(&omap_hwmod_mutex); 1178 1179 return 0; 1180 } 1181 1182 /** 1183 * omap_hwmod_enable - enable an omap_hwmod 1184 * @oh: struct omap_hwmod * 1185 * 1186 * Enable an omap_hwomd @oh. Intended to be called by omap_device_enable(). 1187 * Returns -EINVAL on error or passes along the return value from _enable(). 1188 */ 1189 int omap_hwmod_enable(struct omap_hwmod *oh) 1190 { 1191 int r; 1192 1193 if (!oh) 1194 return -EINVAL; 1195 1196 mutex_lock(&omap_hwmod_mutex); 1197 r = _enable(oh); 1198 mutex_unlock(&omap_hwmod_mutex); 1199 1200 return r; 1201 } 1202 1203 /** 1204 * omap_hwmod_idle - idle an omap_hwmod 1205 * @oh: struct omap_hwmod * 1206 * 1207 * Idle an omap_hwomd @oh. Intended to be called by omap_device_idle(). 1208 * Returns -EINVAL on error or passes along the return value from _idle(). 1209 */ 1210 int omap_hwmod_idle(struct omap_hwmod *oh) 1211 { 1212 if (!oh) 1213 return -EINVAL; 1214 1215 mutex_lock(&omap_hwmod_mutex); 1216 _idle(oh); 1217 mutex_unlock(&omap_hwmod_mutex); 1218 1219 return 0; 1220 } 1221 1222 /** 1223 * omap_hwmod_shutdown - shutdown an omap_hwmod 1224 * @oh: struct omap_hwmod * 1225 * 1226 * Shutdown an omap_hwomd @oh. Intended to be called by 1227 * omap_device_shutdown(). Returns -EINVAL on error or passes along 1228 * the return value from _shutdown(). 1229 */ 1230 int omap_hwmod_shutdown(struct omap_hwmod *oh) 1231 { 1232 if (!oh) 1233 return -EINVAL; 1234 1235 mutex_lock(&omap_hwmod_mutex); 1236 _shutdown(oh); 1237 mutex_unlock(&omap_hwmod_mutex); 1238 1239 return 0; 1240 } 1241 1242 /** 1243 * omap_hwmod_enable_clocks - enable main_clk, all interface clocks 1244 * @oh: struct omap_hwmod *oh 1245 * 1246 * Intended to be called by the omap_device code. 1247 */ 1248 int omap_hwmod_enable_clocks(struct omap_hwmod *oh) 1249 { 1250 mutex_lock(&omap_hwmod_mutex); 1251 _enable_clocks(oh); 1252 mutex_unlock(&omap_hwmod_mutex); 1253 1254 return 0; 1255 } 1256 1257 /** 1258 * omap_hwmod_disable_clocks - disable main_clk, all interface clocks 1259 * @oh: struct omap_hwmod *oh 1260 * 1261 * Intended to be called by the omap_device code. 1262 */ 1263 int omap_hwmod_disable_clocks(struct omap_hwmod *oh) 1264 { 1265 mutex_lock(&omap_hwmod_mutex); 1266 _disable_clocks(oh); 1267 mutex_unlock(&omap_hwmod_mutex); 1268 1269 return 0; 1270 } 1271 1272 /** 1273 * omap_hwmod_ocp_barrier - wait for posted writes against the hwmod to complete 1274 * @oh: struct omap_hwmod *oh 1275 * 1276 * Intended to be called by drivers and core code when all posted 1277 * writes to a device must complete before continuing further 1278 * execution (for example, after clearing some device IRQSTATUS 1279 * register bits) 1280 * 1281 * XXX what about targets with multiple OCP threads? 1282 */ 1283 void omap_hwmod_ocp_barrier(struct omap_hwmod *oh) 1284 { 1285 BUG_ON(!oh); 1286 1287 if (!oh->sysconfig || !oh->sysconfig->sysc_flags) { 1288 WARN(1, "omap_device: %s: OCP barrier impossible due to " 1289 "device configuration\n", oh->name); 1290 return; 1291 } 1292 1293 /* 1294 * Forces posted writes to complete on the OCP thread handling 1295 * register writes 1296 */ 1297 omap_hwmod_readl(oh, oh->sysconfig->sysc_offs); 1298 } 1299 1300 /** 1301 * omap_hwmod_reset - reset the hwmod 1302 * @oh: struct omap_hwmod * 1303 * 1304 * Under some conditions, a driver may wish to reset the entire device. 1305 * Called from omap_device code. Returns -EINVAL on error or passes along 1306 * the return value from _reset()/_enable(). 1307 */ 1308 int omap_hwmod_reset(struct omap_hwmod *oh) 1309 { 1310 int r; 1311 1312 if (!oh || !(oh->_state & _HWMOD_STATE_ENABLED)) 1313 return -EINVAL; 1314 1315 mutex_lock(&omap_hwmod_mutex); 1316 r = _reset(oh); 1317 if (!r) 1318 r = _enable(oh); 1319 mutex_unlock(&omap_hwmod_mutex); 1320 1321 return r; 1322 } 1323 1324 /** 1325 * omap_hwmod_count_resources - count number of struct resources needed by hwmod 1326 * @oh: struct omap_hwmod * 1327 * @res: pointer to the first element of an array of struct resource to fill 1328 * 1329 * Count the number of struct resource array elements necessary to 1330 * contain omap_hwmod @oh resources. Intended to be called by code 1331 * that registers omap_devices. Intended to be used to determine the 1332 * size of a dynamically-allocated struct resource array, before 1333 * calling omap_hwmod_fill_resources(). Returns the number of struct 1334 * resource array elements needed. 1335 * 1336 * XXX This code is not optimized. It could attempt to merge adjacent 1337 * resource IDs. 1338 * 1339 */ 1340 int omap_hwmod_count_resources(struct omap_hwmod *oh) 1341 { 1342 int ret, i; 1343 1344 ret = oh->mpu_irqs_cnt + oh->sdma_chs_cnt; 1345 1346 for (i = 0; i < oh->slaves_cnt; i++) 1347 ret += (*oh->slaves + i)->addr_cnt; 1348 1349 return ret; 1350 } 1351 1352 /** 1353 * omap_hwmod_fill_resources - fill struct resource array with hwmod data 1354 * @oh: struct omap_hwmod * 1355 * @res: pointer to the first element of an array of struct resource to fill 1356 * 1357 * Fill the struct resource array @res with resource data from the 1358 * omap_hwmod @oh. Intended to be called by code that registers 1359 * omap_devices. See also omap_hwmod_count_resources(). Returns the 1360 * number of array elements filled. 1361 */ 1362 int omap_hwmod_fill_resources(struct omap_hwmod *oh, struct resource *res) 1363 { 1364 int i, j; 1365 int r = 0; 1366 1367 /* For each IRQ, DMA, memory area, fill in array.*/ 1368 1369 for (i = 0; i < oh->mpu_irqs_cnt; i++) { 1370 (res + r)->name = (oh->mpu_irqs + i)->name; 1371 (res + r)->start = (oh->mpu_irqs + i)->irq; 1372 (res + r)->end = (oh->mpu_irqs + i)->irq; 1373 (res + r)->flags = IORESOURCE_IRQ; 1374 r++; 1375 } 1376 1377 for (i = 0; i < oh->sdma_chs_cnt; i++) { 1378 (res + r)->name = (oh->sdma_chs + i)->name; 1379 (res + r)->start = (oh->sdma_chs + i)->dma_ch; 1380 (res + r)->end = (oh->sdma_chs + i)->dma_ch; 1381 (res + r)->flags = IORESOURCE_DMA; 1382 r++; 1383 } 1384 1385 for (i = 0; i < oh->slaves_cnt; i++) { 1386 struct omap_hwmod_ocp_if *os; 1387 1388 os = *oh->slaves + i; 1389 1390 for (j = 0; j < os->addr_cnt; j++) { 1391 (res + r)->start = (os->addr + j)->pa_start; 1392 (res + r)->end = (os->addr + j)->pa_end; 1393 (res + r)->flags = IORESOURCE_MEM; 1394 r++; 1395 } 1396 } 1397 1398 return r; 1399 } 1400 1401 /** 1402 * omap_hwmod_get_pwrdm - return pointer to this module's main powerdomain 1403 * @oh: struct omap_hwmod * 1404 * 1405 * Return the powerdomain pointer associated with the OMAP module 1406 * @oh's main clock. If @oh does not have a main clk, return the 1407 * powerdomain associated with the interface clock associated with the 1408 * module's MPU port. (XXX Perhaps this should use the SDMA port 1409 * instead?) Returns NULL on error, or a struct powerdomain * on 1410 * success. 1411 */ 1412 struct powerdomain *omap_hwmod_get_pwrdm(struct omap_hwmod *oh) 1413 { 1414 struct clk *c; 1415 1416 if (!oh) 1417 return NULL; 1418 1419 if (oh->_clk) { 1420 c = oh->_clk; 1421 } else { 1422 if (oh->_int_flags & _HWMOD_NO_MPU_PORT) 1423 return NULL; 1424 c = oh->slaves[oh->_mpu_port_index]->_clk; 1425 } 1426 1427 return c->clkdm->pwrdm.ptr; 1428 1429 } 1430 1431 /** 1432 * omap_hwmod_add_initiator_dep - add sleepdep from @init_oh to @oh 1433 * @oh: struct omap_hwmod * 1434 * @init_oh: struct omap_hwmod * (initiator) 1435 * 1436 * Add a sleep dependency between the initiator @init_oh and @oh. 1437 * Intended to be called by DSP/Bridge code via platform_data for the 1438 * DSP case; and by the DMA code in the sDMA case. DMA code, *Bridge 1439 * code needs to add/del initiator dependencies dynamically 1440 * before/after accessing a device. Returns the return value from 1441 * _add_initiator_dep(). 1442 * 1443 * XXX Keep a usecount in the clockdomain code 1444 */ 1445 int omap_hwmod_add_initiator_dep(struct omap_hwmod *oh, 1446 struct omap_hwmod *init_oh) 1447 { 1448 return _add_initiator_dep(oh, init_oh); 1449 } 1450 1451 /* 1452 * XXX what about functions for drivers to save/restore ocp_sysconfig 1453 * for context save/restore operations? 1454 */ 1455 1456 /** 1457 * omap_hwmod_del_initiator_dep - remove sleepdep from @init_oh to @oh 1458 * @oh: struct omap_hwmod * 1459 * @init_oh: struct omap_hwmod * (initiator) 1460 * 1461 * Remove a sleep dependency between the initiator @init_oh and @oh. 1462 * Intended to be called by DSP/Bridge code via platform_data for the 1463 * DSP case; and by the DMA code in the sDMA case. DMA code, *Bridge 1464 * code needs to add/del initiator dependencies dynamically 1465 * before/after accessing a device. Returns the return value from 1466 * _del_initiator_dep(). 1467 * 1468 * XXX Keep a usecount in the clockdomain code 1469 */ 1470 int omap_hwmod_del_initiator_dep(struct omap_hwmod *oh, 1471 struct omap_hwmod *init_oh) 1472 { 1473 return _del_initiator_dep(oh, init_oh); 1474 } 1475 1476 /** 1477 * omap_hwmod_enable_wakeup - allow device to wake up the system 1478 * @oh: struct omap_hwmod * 1479 * 1480 * Sets the module OCP socket ENAWAKEUP bit to allow the module to 1481 * send wakeups to the PRCM. Eventually this should sets PRCM wakeup 1482 * registers to cause the PRCM to receive wakeup events from the 1483 * module. Does not set any wakeup routing registers beyond this 1484 * point - if the module is to wake up any other module or subsystem, 1485 * that must be set separately. Called by omap_device code. Returns 1486 * -EINVAL on error or 0 upon success. 1487 */ 1488 int omap_hwmod_enable_wakeup(struct omap_hwmod *oh) 1489 { 1490 if (!oh->sysconfig || 1491 !(oh->sysconfig->sysc_flags & SYSC_HAS_ENAWAKEUP)) 1492 return -EINVAL; 1493 1494 mutex_lock(&omap_hwmod_mutex); 1495 _enable_wakeup(oh); 1496 mutex_unlock(&omap_hwmod_mutex); 1497 1498 return 0; 1499 } 1500 1501 /** 1502 * omap_hwmod_disable_wakeup - prevent device from waking the system 1503 * @oh: struct omap_hwmod * 1504 * 1505 * Clears the module OCP socket ENAWAKEUP bit to prevent the module 1506 * from sending wakeups to the PRCM. Eventually this should clear 1507 * PRCM wakeup registers to cause the PRCM to ignore wakeup events 1508 * from the module. Does not set any wakeup routing registers beyond 1509 * this point - if the module is to wake up any other module or 1510 * subsystem, that must be set separately. Called by omap_device 1511 * code. Returns -EINVAL on error or 0 upon success. 1512 */ 1513 int omap_hwmod_disable_wakeup(struct omap_hwmod *oh) 1514 { 1515 if (!oh->sysconfig || 1516 !(oh->sysconfig->sysc_flags & SYSC_HAS_ENAWAKEUP)) 1517 return -EINVAL; 1518 1519 mutex_lock(&omap_hwmod_mutex); 1520 _disable_wakeup(oh); 1521 mutex_unlock(&omap_hwmod_mutex); 1522 1523 return 0; 1524 } 1525