arch/arm/mach-omap2/clockdomain.c

   1 /*
   2  * OMAP2/3/4 clockdomain framework functions
   3  *
   4  * Copyright (C) 2008-2010 Texas Instruments, Inc.
   5  * Copyright (C) 2008-2010 Nokia Corporation
   6  *
   7  * Written by Paul Walmsley and Jouni Högander
   8  * Added OMAP4 specific support by Abhijit Pagare <abhijitpagare@ti.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  */
  14 #undef DEBUG
  15
  16 #include <linux/kernel.h>
  17 #include <linux/device.h>
  18 #include <linux/list.h>
  19 #include <linux/errno.h>
  20 #include <linux/delay.h>
  21 #include <linux/clk.h>
  22 #include <linux/limits.h>
  23 #include <linux/err.h>
  24
  25 #include <linux/io.h>
  26
  27 #include <linux/bitops.h>
  28
  29 #include "prm2xxx_3xxx.h"
  30 #include "prm-regbits-24xx.h"
  31 #include "cm2xxx_3xxx.h"
  32 #include "cm-regbits-24xx.h"
  33 #include "cminst44xx.h"
  34 #include "prcm44xx.h"
  35
  36 #include <plat/clock.h>
  37 #include "powerdomain.h"
  38 #include "clockdomain.h"
  39 #include <plat/prcm.h>
  40
  41 /* clkdm_list contains all registered struct clockdomains */
  42 static LIST_HEAD(clkdm_list);
  43
  44 /* array of clockdomain deps to be added/removed when clkdm in hwsup mode */
  45 static struct clkdm_autodep *autodeps;
  46
  47
  48 /* Private functions */
  49
  50 static struct clockdomain *_clkdm_lookup(const char *name)
  51 {
  52         struct clockdomain *clkdm, *temp_clkdm;
  53
  54         if (!name)
  55                 return NULL;
  56
  57         clkdm = NULL;
  58
  59         list_for_each_entry(temp_clkdm, &clkdm_list, node) {
  60                 if (!strcmp(name, temp_clkdm->name)) {
  61                         clkdm = temp_clkdm;
  62                         break;
  63                 }
  64         }
  65
  66         return clkdm;
  67 }
  68
  69 /**
  70  * _clkdm_register - register a clockdomain
  71  * @clkdm: struct clockdomain * to register
  72  *
  73  * Adds a clockdomain to the internal clockdomain list.
  74  * Returns -EINVAL if given a null pointer, -EEXIST if a clockdomain is
  75  * already registered by the provided name, or 0 upon success.
  76  */
  77 static int _clkdm_register(struct clockdomain *clkdm)
  78 {
  79         struct powerdomain *pwrdm;
  80
  81         if (!clkdm || !clkdm->name)
  82                 return -EINVAL;
  83
  84         if (!omap_chip_is(clkdm->omap_chip))
  85                 return -EINVAL;
  86
  87         pwrdm = pwrdm_lookup(clkdm->pwrdm.name);
  88         if (!pwrdm) {
  89                 pr_err("clockdomain: %s: powerdomain %s does not exist\n",
  90                         clkdm->name, clkdm->pwrdm.name);
  91                 return -EINVAL;
  92         }
  93         clkdm->pwrdm.ptr = pwrdm;
  94
  95         /* Verify that the clockdomain is not already registered */
  96         if (_clkdm_lookup(clkdm->name))
  97                 return -EEXIST;
  98
  99         list_add(&clkdm->node, &clkdm_list);
 100
 101         pwrdm_add_clkdm(pwrdm, clkdm);
 102
 103         pr_debug("clockdomain: registered %s\n", clkdm->name);
 104
 105         return 0;
 106 }
 107
 108 /* _clkdm_deps_lookup - look up the specified clockdomain in a clkdm list */
 109 static struct clkdm_dep *_clkdm_deps_lookup(struct clockdomain *clkdm,
 110                                             struct clkdm_dep *deps)
 111 {
 112         struct clkdm_dep *cd;
 113
 114         if (!clkdm || !deps || !omap_chip_is(clkdm->omap_chip))
 115                 return ERR_PTR(-EINVAL);
 116
 117         for (cd = deps; cd->clkdm_name; cd++) {
 118                 if (!omap_chip_is(cd->omap_chip))
 119                         continue;
 120
 121                 if (!cd->clkdm && cd->clkdm_name)
 122                         cd->clkdm = _clkdm_lookup(cd->clkdm_name);
 123
 124                 if (cd->clkdm == clkdm)
 125                         break;
 126         }
 127
 128         if (!cd->clkdm_name)
 129                 return ERR_PTR(-ENOENT);
 130
 131         return cd;
 132 }
 133
 134 /*
 135  * _autodep_lookup - resolve autodep clkdm names to clkdm pointers; store
 136  * @autodep: struct clkdm_autodep * to resolve
 137  *
 138  * Resolve autodep clockdomain names to clockdomain pointers via
 139  * clkdm_lookup() and store the pointers in the autodep structure.  An
 140  * "autodep" is a clockdomain sleep/wakeup dependency that is
 141  * automatically added and removed whenever clocks in the associated
 142  * clockdomain are enabled or disabled (respectively) when the
 143  * clockdomain is in hardware-supervised mode.  Meant to be called
 144  * once at clockdomain layer initialization, since these should remain
 145  * fixed for a particular architecture.  No return value.
 146  *
 147  * XXX autodeps are deprecated and should be removed at the earliest
 148  * opportunity
 149  */
 150 static void _autodep_lookup(struct clkdm_autodep *autodep)
 151 {
 152         struct clockdomain *clkdm;
 153
 154         if (!autodep)
 155                 return;
 156
 157         if (!omap_chip_is(autodep->omap_chip))
 158                 return;
 159
 160         clkdm = clkdm_lookup(autodep->clkdm.name);
 161         if (!clkdm) {
 162                 pr_err("clockdomain: autodeps: clockdomain %s does not exist\n",
 163                          autodep->clkdm.name);
 164                 clkdm = ERR_PTR(-ENOENT);
 165         }
 166         autodep->clkdm.ptr = clkdm;
 167 }
 168
 169 /*
 170  * _clkdm_add_autodeps - add auto sleepdeps/wkdeps to clkdm upon clock enable
 171  * @clkdm: struct clockdomain *
 172  *
 173  * Add the "autodep" sleep & wakeup dependencies to clockdomain 'clkdm'
 174  * in hardware-supervised mode.  Meant to be called from clock framework
 175  * when a clock inside clockdomain 'clkdm' is enabled.  No return value.
 176  *
 177  * XXX autodeps are deprecated and should be removed at the earliest
 178  * opportunity
 179  */
 180 static void _clkdm_add_autodeps(struct clockdomain *clkdm)
 181 {
 182         struct clkdm_autodep *autodep;
 183
 184         if (!autodeps)
 185                 return;
 186
 187         for (autodep = autodeps; autodep->clkdm.ptr; autodep++) {
 188                 if (IS_ERR(autodep->clkdm.ptr))
 189                         continue;
 190
 191                 if (!omap_chip_is(autodep->omap_chip))
 192                         continue;
 193
 194                 pr_debug("clockdomain: adding %s sleepdep/wkdep for "
 195                          "clkdm %s\n", autodep->clkdm.ptr->name,
 196                          clkdm->name);
 197
 198                 clkdm_add_sleepdep(clkdm, autodep->clkdm.ptr);
 199                 clkdm_add_wkdep(clkdm, autodep->clkdm.ptr);
 200         }
 201 }
 202
 203 /*
 204  * _clkdm_add_autodeps - remove auto sleepdeps/wkdeps from clkdm
 205  * @clkdm: struct clockdomain *
 206  *
 207  * Remove the "autodep" sleep & wakeup dependencies from clockdomain 'clkdm'
 208  * in hardware-supervised mode.  Meant to be called from clock framework
 209  * when a clock inside clockdomain 'clkdm' is disabled.  No return value.
 210  *
 211  * XXX autodeps are deprecated and should be removed at the earliest
 212  * opportunity
 213  */
 214 static void _clkdm_del_autodeps(struct clockdomain *clkdm)
 215 {
 216         struct clkdm_autodep *autodep;
 217
 218         if (!autodeps)
 219                 return;
 220
 221         for (autodep = autodeps; autodep->clkdm.ptr; autodep++) {
 222                 if (IS_ERR(autodep->clkdm.ptr))
 223                         continue;
 224
 225                 if (!omap_chip_is(autodep->omap_chip))
 226                         continue;
 227
 228                 pr_debug("clockdomain: removing %s sleepdep/wkdep for "
 229                          "clkdm %s\n", autodep->clkdm.ptr->name,
 230                          clkdm->name);
 231
 232                 clkdm_del_sleepdep(clkdm, autodep->clkdm.ptr);
 233                 clkdm_del_wkdep(clkdm, autodep->clkdm.ptr);
 234         }
 235 }
 236
 237 /**
 238  * _enable_hwsup - place a clockdomain into hardware-supervised idle
 239  * @clkdm: struct clockdomain *
 240  *
 241  * Place the clockdomain into hardware-supervised idle mode.  No return
 242  * value.
 243  *
 244  * XXX Should this return an error if the clockdomain does not support
 245  * hardware-supervised idle mode?
 246  */
 247 static void _enable_hwsup(struct clockdomain *clkdm)
 248 {
 249         if (cpu_is_omap24xx())
 250                 omap2xxx_cm_clkdm_enable_hwsup(clkdm->pwrdm.ptr->prcm_offs,
 251                                                clkdm->clktrctrl_mask);
 252         else if (cpu_is_omap34xx())
 253                 omap3xxx_cm_clkdm_enable_hwsup(clkdm->pwrdm.ptr->prcm_offs,
 254                                                clkdm->clktrctrl_mask);
 255         else if (cpu_is_omap44xx())
 256                 return omap4_cminst_clkdm_enable_hwsup(clkdm->prcm_partition,
 257                                                        clkdm->cm_inst,
 258                                                        clkdm->clkdm_offs);
 259         else
 260                 BUG();
 261 }
 262
 263 /**
 264  * _disable_hwsup - place a clockdomain into software-supervised idle
 265  * @clkdm: struct clockdomain *
 266  *
 267  * Place the clockdomain @clkdm into software-supervised idle mode.
 268  * No return value.
 269  *
 270  * XXX Should this return an error if the clockdomain does not support
 271  * software-supervised idle mode?
 272  */
 273 static void _disable_hwsup(struct clockdomain *clkdm)
 274 {
 275         if (cpu_is_omap24xx())
 276                 omap2xxx_cm_clkdm_disable_hwsup(clkdm->pwrdm.ptr->prcm_offs,
 277                                                 clkdm->clktrctrl_mask);
 278         else if (cpu_is_omap34xx())
 279                 omap3xxx_cm_clkdm_disable_hwsup(clkdm->pwrdm.ptr->prcm_offs,
 280                                                 clkdm->clktrctrl_mask);
 281         else if (cpu_is_omap44xx())
 282                 return omap4_cminst_clkdm_disable_hwsup(clkdm->prcm_partition,
 283                                                         clkdm->cm_inst,
 284                                                         clkdm->clkdm_offs);
 285         else
 286                 BUG();
 287 }
 288
 289 /* Public functions */
 290
 291 /**
 292  * clkdm_init - set up the clockdomain layer
 293  * @clkdms: optional pointer to an array of clockdomains to register
 294  * @init_autodeps: optional pointer to an array of autodeps to register
 295  *
 296  * Set up internal state.  If a pointer to an array of clockdomains
 297  * @clkdms was supplied, loop through the list of clockdomains,
 298  * register all that are available on the current platform. Similarly,
 299  * if a pointer to an array of clockdomain autodependencies
 300  * @init_autodeps was provided, register those.  No return value.
 301  */
 302 void clkdm_init(struct clockdomain **clkdms,
 303                 struct clkdm_autodep *init_autodeps)
 304 {
 305         struct clockdomain **c = NULL;
 306         struct clockdomain *clkdm;
 307         struct clkdm_autodep *autodep = NULL;
 308
 309         if (clkdms)
 310                 for (c = clkdms; *c; c++)
 311                         _clkdm_register(*c);
 312
 313         autodeps = init_autodeps;
 314         if (autodeps)
 315                 for (autodep = autodeps; autodep->clkdm.ptr; autodep++)
 316                         _autodep_lookup(autodep);
 317
 318         /*
 319          * Put all clockdomains into software-supervised mode; PM code
 320          * should later enable hardware-supervised mode as appropriate
 321          */
 322         list_for_each_entry(clkdm, &clkdm_list, node) {
 323                 if (clkdm->flags & CLKDM_CAN_FORCE_WAKEUP)
 324                         omap2_clkdm_wakeup(clkdm);
 325                 else if (clkdm->flags & CLKDM_CAN_DISABLE_AUTO)
 326                         omap2_clkdm_deny_idle(clkdm);
 327
 328                 clkdm_clear_all_wkdeps(clkdm);
 329                 clkdm_clear_all_sleepdeps(clkdm);
 330         }
 331 }
 332
 333 /**
 334  * clkdm_lookup - look up a clockdomain by name, return a pointer
 335  * @name: name of clockdomain
 336  *
 337  * Find a registered clockdomain by its name @name.  Returns a pointer
 338  * to the struct clockdomain if found, or NULL otherwise.
 339  */
 340 struct clockdomain *clkdm_lookup(const char *name)
 341 {
 342         struct clockdomain *clkdm, *temp_clkdm;
 343
 344         if (!name)
 345                 return NULL;
 346
 347         clkdm = NULL;
 348
 349         list_for_each_entry(temp_clkdm, &clkdm_list, node) {
 350                 if (!strcmp(name, temp_clkdm->name)) {
 351                         clkdm = temp_clkdm;
 352                         break;
 353                 }
 354         }
 355
 356         return clkdm;
 357 }
 358
 359 /**
 360  * clkdm_for_each - call function on each registered clockdomain
 361  * @fn: callback function *
 362  *
 363  * Call the supplied function @fn for each registered clockdomain.
 364  * The callback function @fn can return anything but 0 to bail
 365  * out early from the iterator.  The callback function is called with
 366  * the clkdm_mutex held, so no clockdomain structure manipulation
 367  * functions should be called from the callback, although hardware
 368  * clockdomain control functions are fine.  Returns the last return
 369  * value of the callback function, which should be 0 for success or
 370  * anything else to indicate failure; or -EINVAL if the function pointer
 371  * is null.
 372  */
 373 int clkdm_for_each(int (*fn)(struct clockdomain *clkdm, void *user),
 374                         void *user)
 375 {
 376         struct clockdomain *clkdm;
 377         int ret = 0;
 378
 379         if (!fn)
 380                 return -EINVAL;
 381
 382         list_for_each_entry(clkdm, &clkdm_list, node) {
 383                 ret = (*fn)(clkdm, user);
 384                 if (ret)
 385                         break;
 386         }
 387
 388         return ret;
 389 }
 390
 391
 392 /**
 393  * clkdm_get_pwrdm - return a ptr to the pwrdm that this clkdm resides in
 394  * @clkdm: struct clockdomain *
 395  *
 396  * Return a pointer to the struct powerdomain that the specified clockdomain
 397  * @clkdm exists in, or returns NULL if @clkdm is NULL.
 398  */
 399 struct powerdomain *clkdm_get_pwrdm(struct clockdomain *clkdm)
 400 {
 401         if (!clkdm)
 402                 return NULL;
 403
 404         return clkdm->pwrdm.ptr;
 405 }
 406
 407
 408 /* Hardware clockdomain control */
 409
 410 /**
 411  * clkdm_add_wkdep - add a wakeup dependency from clkdm2 to clkdm1
 412  * @clkdm1: wake this struct clockdomain * up (dependent)
 413  * @clkdm2: when this struct clockdomain * wakes up (source)
 414  *
 415  * When the clockdomain represented by @clkdm2 wakes up, wake up
 416  * @clkdm1. Implemented in hardware on the OMAP, this feature is
 417  * designed to reduce wakeup latency of the dependent clockdomain @clkdm1.
 418  * Returns -EINVAL if presented with invalid clockdomain pointers,
 419  * -ENOENT if @clkdm2 cannot wake up clkdm1 in hardware, or 0 upon
 420  * success.
 421  */
 422 int clkdm_add_wkdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
 423 {
 424         struct clkdm_dep *cd;
 425
 426         if (!cpu_is_omap24xx() && !cpu_is_omap34xx()) {
 427                 pr_err("clockdomain: %s/%s: %s: not yet implemented\n",
 428                        clkdm1->name, clkdm2->name, __func__);
 429                 return -EINVAL;
 430         }
 431
 432         if (!clkdm1 || !clkdm2)
 433                 return -EINVAL;
 434
 435         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
 436         if (IS_ERR(cd)) {
 437                 pr_debug("clockdomain: hardware cannot set/clear wake up of "
 438                          "%s when %s wakes up\n", clkdm1->name, clkdm2->name);
 439                 return PTR_ERR(cd);
 440         }
 441
 442         if (atomic_inc_return(&cd->wkdep_usecount) == 1) {
 443                 pr_debug("clockdomain: hardware will wake up %s when %s wakes "
 444                          "up\n", clkdm1->name, clkdm2->name);
 445
 446                 omap2_prm_set_mod_reg_bits((1 << clkdm2->dep_bit),
 447                                      clkdm1->pwrdm.ptr->prcm_offs, PM_WKDEP);
 448         }
 449
 450         return 0;
 451 }
 452
 453 /**
 454  * clkdm_del_wkdep - remove a wakeup dependency from clkdm2 to clkdm1
 455  * @clkdm1: wake this struct clockdomain * up (dependent)
 456  * @clkdm2: when this struct clockdomain * wakes up (source)
 457  *
 458  * Remove a wakeup dependency causing @clkdm1 to wake up when @clkdm2
 459  * wakes up.  Returns -EINVAL if presented with invalid clockdomain
 460  * pointers, -ENOENT if @clkdm2 cannot wake up clkdm1 in hardware, or
 461  * 0 upon success.
 462  */
 463 int clkdm_del_wkdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
 464 {
 465         struct clkdm_dep *cd;
 466
 467         if (!cpu_is_omap24xx() && !cpu_is_omap34xx()) {
 468                 pr_err("clockdomain: %s/%s: %s: not yet implemented\n",
 469                        clkdm1->name, clkdm2->name, __func__);
 470                 return -EINVAL;
 471         }
 472
 473         if (!clkdm1 || !clkdm2)
 474                 return -EINVAL;
 475
 476         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
 477         if (IS_ERR(cd)) {
 478                 pr_debug("clockdomain: hardware cannot set/clear wake up of "
 479                          "%s when %s wakes up\n", clkdm1->name, clkdm2->name);
 480                 return PTR_ERR(cd);
 481         }
 482
 483         if (atomic_dec_return(&cd->wkdep_usecount) == 0) {
 484                 pr_debug("clockdomain: hardware will no longer wake up %s "
 485                          "after %s wakes up\n", clkdm1->name, clkdm2->name);
 486
 487                 omap2_prm_clear_mod_reg_bits((1 << clkdm2->dep_bit),
 488                                        clkdm1->pwrdm.ptr->prcm_offs, PM_WKDEP);
 489         }
 490
 491         return 0;
 492 }
 493
 494 /**
 495  * clkdm_read_wkdep - read wakeup dependency state from clkdm2 to clkdm1
 496  * @clkdm1: wake this struct clockdomain * up (dependent)
 497  * @clkdm2: when this struct clockdomain * wakes up (source)
 498  *
 499  * Return 1 if a hardware wakeup dependency exists wherein @clkdm1 will be
 500  * awoken when @clkdm2 wakes up; 0 if dependency is not set; -EINVAL
 501  * if either clockdomain pointer is invalid; or -ENOENT if the hardware
 502  * is incapable.
 503  *
 504  * REVISIT: Currently this function only represents software-controllable
 505  * wakeup dependencies.  Wakeup dependencies fixed in hardware are not
 506  * yet handled here.
 507  */
 508 int clkdm_read_wkdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
 509 {
 510         struct clkdm_dep *cd;
 511
 512         if (!clkdm1 || !clkdm2)
 513                 return -EINVAL;
 514
 515         if (!cpu_is_omap24xx() && !cpu_is_omap34xx()) {
 516                 pr_err("clockdomain: %s/%s: %s: not yet implemented\n",
 517                        clkdm1->name, clkdm2->name, __func__);
 518                 return -EINVAL;
 519         }
 520
 521         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
 522         if (IS_ERR(cd)) {
 523                 pr_debug("clockdomain: hardware cannot set/clear wake up of "
 524                          "%s when %s wakes up\n", clkdm1->name, clkdm2->name);
 525                 return PTR_ERR(cd);
 526         }
 527
 528         /* XXX It's faster to return the atomic wkdep_usecount */
 529         return omap2_prm_read_mod_bits_shift(clkdm1->pwrdm.ptr->prcm_offs, PM_WKDEP,
 530                                        (1 << clkdm2->dep_bit));
 531 }
 532
 533 /**
 534  * clkdm_clear_all_wkdeps - remove all wakeup dependencies from target clkdm
 535  * @clkdm: struct clockdomain * to remove all wakeup dependencies from
 536  *
 537  * Remove all inter-clockdomain wakeup dependencies that could cause
 538  * @clkdm to wake.  Intended to be used during boot to initialize the
 539  * PRCM to a known state, after all clockdomains are put into swsup idle
 540  * and woken up.  Returns -EINVAL if @clkdm pointer is invalid, or
 541  * 0 upon success.
 542  */
 543 int clkdm_clear_all_wkdeps(struct clockdomain *clkdm)
 544 {
 545         struct clkdm_dep *cd;
 546         u32 mask = 0;
 547
 548         if (!cpu_is_omap24xx() && !cpu_is_omap34xx()) {
 549                 pr_err("clockdomain: %s: %s: not yet implemented\n",
 550                        clkdm->name, __func__);
 551                 return -EINVAL;
 552         }
 553
 554         if (!clkdm)
 555                 return -EINVAL;
 556
 557         for (cd = clkdm->wkdep_srcs; cd && cd->clkdm_name; cd++) {
 558                 if (!omap_chip_is(cd->omap_chip))
 559                         continue;
 560
 561                 if (!cd->clkdm && cd->clkdm_name)
 562                         cd->clkdm = _clkdm_lookup(cd->clkdm_name);
 563
 564                 /* PRM accesses are slow, so minimize them */
 565                 mask |= 1 << cd->clkdm->dep_bit;
 566                 atomic_set(&cd->wkdep_usecount, 0);
 567         }
 568
 569         omap2_prm_clear_mod_reg_bits(mask, clkdm->pwrdm.ptr->prcm_offs, PM_WKDEP);
 570
 571         return 0;
 572 }
 573
 574 /**
 575  * clkdm_add_sleepdep - add a sleep dependency from clkdm2 to clkdm1
 576  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
 577  * @clkdm2: when this struct clockdomain * is active (source)
 578  *
 579  * Prevent @clkdm1 from automatically going inactive (and then to
 580  * retention or off) if @clkdm2 is active.  Returns -EINVAL if
 581  * presented with invalid clockdomain pointers or called on a machine
 582  * that does not support software-configurable hardware sleep
 583  * dependencies, -ENOENT if the specified dependency cannot be set in
 584  * hardware, or 0 upon success.
 585  */
 586 int clkdm_add_sleepdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
 587 {
 588         struct clkdm_dep *cd;
 589
 590         if (!cpu_is_omap34xx())
 591                 return -EINVAL;
 592
 593         if (!clkdm1 || !clkdm2)
 594                 return -EINVAL;
 595
 596         cd = _clkdm_deps_lookup(clkdm2, clkdm1->sleepdep_srcs);
 597         if (IS_ERR(cd)) {
 598                 pr_debug("clockdomain: hardware cannot set/clear sleep "
 599                          "dependency affecting %s from %s\n", clkdm1->name,
 600                          clkdm2->name);
 601                 return PTR_ERR(cd);
 602         }
 603
 604         if (atomic_inc_return(&cd->sleepdep_usecount) == 1) {
 605                 pr_debug("clockdomain: will prevent %s from sleeping if %s "
 606                          "is active\n", clkdm1->name, clkdm2->name);
 607
 608                 omap2_cm_set_mod_reg_bits((1 << clkdm2->dep_bit),
 609                                     clkdm1->pwrdm.ptr->prcm_offs,
 610                                     OMAP3430_CM_SLEEPDEP);
 611         }
 612
 613         return 0;
 614 }
 615
 616 /**
 617  * clkdm_del_sleepdep - remove a sleep dependency from clkdm2 to clkdm1
 618  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
 619  * @clkdm2: when this struct clockdomain * is active (source)
 620  *
 621  * Allow @clkdm1 to automatically go inactive (and then to retention or
 622  * off), independent of the activity state of @clkdm2.  Returns -EINVAL
 623  * if presented with invalid clockdomain pointers or called on a machine
 624  * that does not support software-configurable hardware sleep dependencies,
 625  * -ENOENT if the specified dependency cannot be cleared in hardware, or
 626  * 0 upon success.
 627  */
 628 int clkdm_del_sleepdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
 629 {
 630         struct clkdm_dep *cd;
 631
 632         if (!cpu_is_omap34xx())
 633                 return -EINVAL;
 634
 635         if (!clkdm1 || !clkdm2)
 636                 return -EINVAL;
 637
 638         cd = _clkdm_deps_lookup(clkdm2, clkdm1->sleepdep_srcs);
 639         if (IS_ERR(cd)) {
 640                 pr_debug("clockdomain: hardware cannot set/clear sleep "
 641                          "dependency affecting %s from %s\n", clkdm1->name,
 642                          clkdm2->name);
 643                 return PTR_ERR(cd);
 644         }
 645
 646         if (atomic_dec_return(&cd->sleepdep_usecount) == 0) {
 647                 pr_debug("clockdomain: will no longer prevent %s from "
 648                          "sleeping if %s is active\n", clkdm1->name,
 649                          clkdm2->name);
 650
 651                 omap2_cm_clear_mod_reg_bits((1 << clkdm2->dep_bit),
 652                                       clkdm1->pwrdm.ptr->prcm_offs,
 653                                       OMAP3430_CM_SLEEPDEP);
 654         }
 655
 656         return 0;
 657 }
 658
 659 /**
 660  * clkdm_read_sleepdep - read sleep dependency state from clkdm2 to clkdm1
 661  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
 662  * @clkdm2: when this struct clockdomain * is active (source)
 663  *
 664  * Return 1 if a hardware sleep dependency exists wherein @clkdm1 will
 665  * not be allowed to automatically go inactive if @clkdm2 is active;
 666  * 0 if @clkdm1's automatic power state inactivity transition is independent
 667  * of @clkdm2's; -EINVAL if either clockdomain pointer is invalid or called
 668  * on a machine that does not support software-configurable hardware sleep
 669  * dependencies; or -ENOENT if the hardware is incapable.
 670  *
 671  * REVISIT: Currently this function only represents software-controllable
 672  * sleep dependencies.  Sleep dependencies fixed in hardware are not
 673  * yet handled here.
 674  */
 675 int clkdm_read_sleepdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
 676 {
 677         struct clkdm_dep *cd;
 678
 679         if (!cpu_is_omap34xx())
 680                 return -EINVAL;
 681
 682         if (!clkdm1 || !clkdm2)
 683                 return -EINVAL;
 684
 685         cd = _clkdm_deps_lookup(clkdm2, clkdm1->sleepdep_srcs);
 686         if (IS_ERR(cd)) {
 687                 pr_debug("clockdomain: hardware cannot set/clear sleep "
 688                          "dependency affecting %s from %s\n", clkdm1->name,
 689                          clkdm2->name);
 690                 return PTR_ERR(cd);
 691         }
 692
 693         /* XXX It's faster to return the atomic sleepdep_usecount */
 694         return omap2_prm_read_mod_bits_shift(clkdm1->pwrdm.ptr->prcm_offs,
 695                                        OMAP3430_CM_SLEEPDEP,
 696                                        (1 << clkdm2->dep_bit));
 697 }
 698
 699 /**
 700  * clkdm_clear_all_sleepdeps - remove all sleep dependencies from target clkdm
 701  * @clkdm: struct clockdomain * to remove all sleep dependencies from
 702  *
 703  * Remove all inter-clockdomain sleep dependencies that could prevent
 704  * @clkdm from idling.  Intended to be used during boot to initialize the
 705  * PRCM to a known state, after all clockdomains are put into swsup idle
 706  * and woken up.  Returns -EINVAL if @clkdm pointer is invalid, or
 707  * 0 upon success.
 708  */
 709 int clkdm_clear_all_sleepdeps(struct clockdomain *clkdm)
 710 {
 711         struct clkdm_dep *cd;
 712         u32 mask = 0;
 713
 714         if (!cpu_is_omap34xx())
 715                 return -EINVAL;
 716
 717         if (!clkdm)
 718                 return -EINVAL;
 719
 720         for (cd = clkdm->sleepdep_srcs; cd && cd->clkdm_name; cd++) {
 721                 if (!omap_chip_is(cd->omap_chip))
 722                         continue;
 723
 724                 if (!cd->clkdm && cd->clkdm_name)
 725                         cd->clkdm = _clkdm_lookup(cd->clkdm_name);
 726
 727                 /* PRM accesses are slow, so minimize them */
 728                 mask |= 1 << cd->clkdm->dep_bit;
 729                 atomic_set(&cd->sleepdep_usecount, 0);
 730         }
 731
 732         omap2_prm_clear_mod_reg_bits(mask, clkdm->pwrdm.ptr->prcm_offs,
 733                                OMAP3430_CM_SLEEPDEP);
 734
 735         return 0;
 736 }
 737
 738 /**
 739  * omap2_clkdm_sleep - force clockdomain sleep transition
 740  * @clkdm: struct clockdomain *
 741  *
 742  * Instruct the CM to force a sleep transition on the specified
 743  * clockdomain @clkdm.  Returns -EINVAL if @clkdm is NULL or if
 744  * clockdomain does not support software-initiated sleep; 0 upon
 745  * success.
 746  */
 747 int omap2_clkdm_sleep(struct clockdomain *clkdm)
 748 {
 749         if (!clkdm)
 750                 return -EINVAL;
 751
 752         if (!(clkdm->flags & CLKDM_CAN_FORCE_SLEEP)) {
 753                 pr_debug("clockdomain: %s does not support forcing "
 754                          "sleep via software\n", clkdm->name);
 755                 return -EINVAL;
 756         }
 757
 758         pr_debug("clockdomain: forcing sleep on %s\n", clkdm->name);
 759
 760         if (cpu_is_omap24xx()) {
 761
 762                 omap2_cm_set_mod_reg_bits(OMAP24XX_FORCESTATE_MASK,
 763                             clkdm->pwrdm.ptr->prcm_offs, OMAP2_PM_PWSTCTRL);
 764
 765         } else if (cpu_is_omap34xx()) {
 766
 767                 omap3xxx_cm_clkdm_force_sleep(clkdm->pwrdm.ptr->prcm_offs,
 768                                               clkdm->clktrctrl_mask);
 769
 770         } else if (cpu_is_omap44xx()) {
 771
 772                 omap4_cminst_clkdm_force_sleep(clkdm->prcm_partition,
 773                                                clkdm->cm_inst,
 774                                                clkdm->clkdm_offs);
 775
 776         } else {
 777                 BUG();
 778         };
 779
 780         return 0;
 781 }
 782
 783 /**
 784  * omap2_clkdm_wakeup - force clockdomain wakeup transition
 785  * @clkdm: struct clockdomain *
 786  *
 787  * Instruct the CM to force a wakeup transition on the specified
 788  * clockdomain @clkdm.  Returns -EINVAL if @clkdm is NULL or if the
 789  * clockdomain does not support software-controlled wakeup; 0 upon
 790  * success.
 791  */
 792 int omap2_clkdm_wakeup(struct clockdomain *clkdm)
 793 {
 794         if (!clkdm)
 795                 return -EINVAL;
 796
 797         if (!(clkdm->flags & CLKDM_CAN_FORCE_WAKEUP)) {
 798                 pr_debug("clockdomain: %s does not support forcing "
 799                          "wakeup via software\n", clkdm->name);
 800                 return -EINVAL;
 801         }
 802
 803         pr_debug("clockdomain: forcing wakeup on %s\n", clkdm->name);
 804
 805         if (cpu_is_omap24xx()) {
 806
 807                 omap2_cm_clear_mod_reg_bits(OMAP24XX_FORCESTATE_MASK,
 808                               clkdm->pwrdm.ptr->prcm_offs, OMAP2_PM_PWSTCTRL);
 809
 810         } else if (cpu_is_omap34xx()) {
 811
 812                 omap3xxx_cm_clkdm_force_wakeup(clkdm->pwrdm.ptr->prcm_offs,
 813                                                clkdm->clktrctrl_mask);
 814
 815         } else if (cpu_is_omap44xx()) {
 816
 817                 omap4_cminst_clkdm_force_wakeup(clkdm->prcm_partition,
 818                                                 clkdm->cm_inst,
 819                                                 clkdm->clkdm_offs);
 820
 821         } else {
 822                 BUG();
 823         };
 824
 825         return 0;
 826 }
 827
 828 /**
 829  * omap2_clkdm_allow_idle - enable hwsup idle transitions for clkdm
 830  * @clkdm: struct clockdomain *
 831  *
 832  * Allow the hardware to automatically switch the clockdomain @clkdm into
 833  * active or idle states, as needed by downstream clocks.  If the
 834  * clockdomain has any downstream clocks enabled in the clock
 835  * framework, wkdep/sleepdep autodependencies are added; this is so
 836  * device drivers can read and write to the device.  No return value.
 837  */
 838 void omap2_clkdm_allow_idle(struct clockdomain *clkdm)
 839 {
 840         if (!clkdm)
 841                 return;
 842
 843         if (!(clkdm->flags & CLKDM_CAN_ENABLE_AUTO)) {
 844                 pr_debug("clock: automatic idle transitions cannot be enabled "
 845                          "on clockdomain %s\n", clkdm->name);
 846                 return;
 847         }
 848
 849         pr_debug("clockdomain: enabling automatic idle transitions for %s\n",
 850                  clkdm->name);
 851
 852         /*
 853          * XXX This should be removed once TI adds wakeup/sleep
 854          * dependency code and data for OMAP4.
 855          */
 856         if (cpu_is_omap44xx()) {
 857                 pr_err("clockdomain: %s: OMAP4 wakeup/sleep dependency support: not yet implemented\n", clkdm->name);
 858         } else {
 859                 if (atomic_read(&clkdm->usecount) > 0)
 860                         _clkdm_add_autodeps(clkdm);
 861         }
 862
 863         _enable_hwsup(clkdm);
 864
 865         pwrdm_clkdm_state_switch(clkdm);
 866 }
 867
 868 /**
 869  * omap2_clkdm_deny_idle - disable hwsup idle transitions for clkdm
 870  * @clkdm: struct clockdomain *
 871  *
 872  * Prevent the hardware from automatically switching the clockdomain
 873  * @clkdm into inactive or idle states.  If the clockdomain has
 874  * downstream clocks enabled in the clock framework, wkdep/sleepdep
 875  * autodependencies are removed.  No return value.
 876  */
 877 void omap2_clkdm_deny_idle(struct clockdomain *clkdm)
 878 {
 879         if (!clkdm)
 880                 return;
 881
 882         if (!(clkdm->flags & CLKDM_CAN_DISABLE_AUTO)) {
 883                 pr_debug("clockdomain: automatic idle transitions cannot be "
 884                          "disabled on %s\n", clkdm->name);
 885                 return;
 886         }
 887
 888         pr_debug("clockdomain: disabling automatic idle transitions for %s\n",
 889                  clkdm->name);
 890
 891         _disable_hwsup(clkdm);
 892
 893         /*
 894          * XXX This should be removed once TI adds wakeup/sleep
 895          * dependency code and data for OMAP4.
 896          */
 897         if (cpu_is_omap44xx()) {
 898                 pr_err("clockdomain: %s: OMAP4 wakeup/sleep dependency support: not yet implemented\n", clkdm->name);
 899         } else {
 900                 if (atomic_read(&clkdm->usecount) > 0)
 901                         _clkdm_del_autodeps(clkdm);
 902         }
 903 }
 904
 905
 906 /* Clockdomain-to-clock framework interface code */
 907
 908 /**
 909  * omap2_clkdm_clk_enable - add an enabled downstream clock to this clkdm
 910  * @clkdm: struct clockdomain *
 911  * @clk: struct clk * of the enabled downstream clock
 912  *
 913  * Increment the usecount of the clockdomain @clkdm and ensure that it
 914  * is awake before @clk is enabled.  Intended to be called by
 915  * clk_enable() code.  If the clockdomain is in software-supervised
 916  * idle mode, force the clockdomain to wake.  If the clockdomain is in
 917  * hardware-supervised idle mode, add clkdm-pwrdm autodependencies, to
 918  * ensure that devices in the clockdomain can be read from/written to
 919  * by on-chip processors.  Returns -EINVAL if passed null pointers;
 920  * returns 0 upon success or if the clockdomain is in hwsup idle mode.
 921  */
 922 int omap2_clkdm_clk_enable(struct clockdomain *clkdm, struct clk *clk)
 923 {
 924         bool hwsup = false;
 925
 926         /*
 927          * XXX Rewrite this code to maintain a list of enabled
 928          * downstream clocks for debugging purposes?
 929          */
 930
 931         if (!clkdm || !clk)
 932                 return -EINVAL;
 933
 934         if (atomic_inc_return(&clkdm->usecount) > 1)
 935                 return 0;
 936
 937         /* Clockdomain now has one enabled downstream clock */
 938
 939         pr_debug("clockdomain: clkdm %s: clk %s now enabled\n", clkdm->name,
 940                  clk->name);
 941
 942         if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
 943
 944                 if (!clkdm->clktrctrl_mask)
 945                         return 0;
 946
 947                 hwsup = omap2_cm_is_clkdm_in_hwsup(clkdm->pwrdm.ptr->prcm_offs,
 948                                                    clkdm->clktrctrl_mask);
 949
 950         } else if (cpu_is_omap44xx()) {
 951
 952                 hwsup = omap4_cminst_is_clkdm_in_hwsup(clkdm->prcm_partition,
 953                                                        clkdm->cm_inst,
 954                                                        clkdm->clkdm_offs);
 955
 956         }
 957
 958         if (hwsup) {
 959                 /* Disable HW transitions when we are changing deps */
 960                 _disable_hwsup(clkdm);
 961                 _clkdm_add_autodeps(clkdm);
 962                 _enable_hwsup(clkdm);
 963         } else {
 964                 omap2_clkdm_wakeup(clkdm);
 965         }
 966
 967         pwrdm_wait_transition(clkdm->pwrdm.ptr);
 968         pwrdm_clkdm_state_switch(clkdm);
 969
 970         return 0;
 971 }
 972
 973 /**
 974  * omap2_clkdm_clk_disable - remove an enabled downstream clock from this clkdm
 975  * @clkdm: struct clockdomain *
 976  * @clk: struct clk * of the disabled downstream clock
 977  *
 978  * Decrement the usecount of this clockdomain @clkdm when @clk is
 979  * disabled.  Intended to be called by clk_disable() code.  If the
 980  * clockdomain usecount goes to 0, put the clockdomain to sleep
 981  * (software-supervised mode) or remove the clkdm autodependencies
 982  * (hardware-supervised mode).  Returns -EINVAL if passed null
 983  * pointers; -ERANGE if the @clkdm usecount underflows and debugging
 984  * is enabled; or returns 0 upon success or if the clockdomain is in
 985  * hwsup idle mode.
 986  */
 987 int omap2_clkdm_clk_disable(struct clockdomain *clkdm, struct clk *clk)
 988 {
 989         bool hwsup = false;
 990
 991         /*
 992          * XXX Rewrite this code to maintain a list of enabled
 993          * downstream clocks for debugging purposes?
 994          */
 995
 996         if (!clkdm || !clk)
 997                 return -EINVAL;
 998
 999 #ifdef DEBUG
1000         if (atomic_read(&clkdm->usecount) == 0) {
1001                 WARN_ON(1); /* underflow */
1002                 return -ERANGE;
1003         }
1004 #endif
1005
1006         if (atomic_dec_return(&clkdm->usecount) > 0)
1007                 return 0;
1008
1009         /* All downstream clocks of this clockdomain are now disabled */
1010
1011         pr_debug("clockdomain: clkdm %s: clk %s now disabled\n", clkdm->name,
1012                  clk->name);
1013
1014         if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
1015
1016                 if (!clkdm->clktrctrl_mask)
1017                         return 0;
1018
1019                 hwsup = omap2_cm_is_clkdm_in_hwsup(clkdm->pwrdm.ptr->prcm_offs,
1020                                                    clkdm->clktrctrl_mask);
1021
1022         } else if (cpu_is_omap44xx()) {
1023
1024                 hwsup = omap4_cminst_is_clkdm_in_hwsup(clkdm->prcm_partition,
1025                                                        clkdm->cm_inst,
1026                                                        clkdm->clkdm_offs);
1027
1028         }
1029
1030         if (hwsup) {
1031                 /* Disable HW transitions when we are changing deps */
1032                 _disable_hwsup(clkdm);
1033                 _clkdm_del_autodeps(clkdm);
1034                 _enable_hwsup(clkdm);
1035         } else {
1036                 omap2_clkdm_sleep(clkdm);
1037         }
1038
1039         pwrdm_clkdm_state_switch(clkdm);
1040
1041         return 0;
1042 }
1043