arch/arm/mach-omap2/omap_hwmod.c

   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 }