arch/arm/mach-omap2/powerdomain.c

   1 /*
   2  * OMAP powerdomain control
   3  *
   4  * Copyright (C) 2007-2008, 2011 Texas Instruments, Inc.
   5  * Copyright (C) 2007-2011 Nokia Corporation
   6  *
   7  * Written by Paul Walmsley
   8  * Added OMAP4 specific support by Abhijit Pagare <abhijitpagare@ti.com>
   9  * State counting code by Tero Kristo <tero.kristo@nokia.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  */
  15 #undef DEBUG
  16
  17 #include <linux/kernel.h>
  18 #include <linux/types.h>
  19 #include <linux/list.h>
  20 #include <linux/errno.h>
  21 #include <linux/string.h>
  22 #include <linux/spinlock.h>
  23 #include <trace/events/power.h>
  24
  25 #include "cm2xxx_3xxx.h"
  26 #include "prcm44xx.h"
  27 #include "cm44xx.h"
  28 #include "prm2xxx_3xxx.h"
  29 #include "prm44xx.h"
  30
  31 #include <asm/cpu.h>
  32
  33 #include "powerdomain.h"
  34 #include "clockdomain.h"
  35
  36 #include "soc.h"
  37 #include "pm.h"
  38
  39 #define PWRDM_TRACE_STATES_FLAG (1<<31)
  40
  41 enum {
  42         PWRDM_STATE_NOW = 0,
  43         PWRDM_STATE_PREV,
  44 };
  45
  46 /*
  47  * Types of sleep_switch used internally in omap_set_pwrdm_state()
  48  * and its associated static functions
  49  *
  50  * XXX Better documentation is needed here
  51  */
  52 #define ALREADYACTIVE_SWITCH            0
  53 #define FORCEWAKEUP_SWITCH              1
  54 #define LOWPOWERSTATE_SWITCH            2
  55
  56 /* pwrdm_list contains all registered struct powerdomains */
  57 static LIST_HEAD(pwrdm_list);
  58
  59 static struct pwrdm_ops *arch_pwrdm;
  60
  61 /* Private functions */
  62
  63 static struct powerdomain *_pwrdm_lookup(const char *name)
  64 {
  65         struct powerdomain *pwrdm, *temp_pwrdm;
  66
  67         pwrdm = NULL;
  68
  69         list_for_each_entry(temp_pwrdm, &pwrdm_list, node) {
  70                 if (!strcmp(name, temp_pwrdm->name)) {
  71                         pwrdm = temp_pwrdm;
  72                         break;
  73                 }
  74         }
  75
  76         return pwrdm;
  77 }
  78
  79 /**
  80  * _pwrdm_register - register a powerdomain
  81  * @pwrdm: struct powerdomain * to register
  82  *
  83  * Adds a powerdomain to the internal powerdomain list.  Returns
  84  * -EINVAL if given a null pointer, -EEXIST if a powerdomain is
  85  * already registered by the provided name, or 0 upon success.
  86  */
  87 static int _pwrdm_register(struct powerdomain *pwrdm)
  88 {
  89         int i;
  90         struct voltagedomain *voltdm;
  91
  92         if (!pwrdm || !pwrdm->name)
  93                 return -EINVAL;
  94
  95         if (cpu_is_omap44xx() &&
  96             pwrdm->prcm_partition == OMAP4430_INVALID_PRCM_PARTITION) {
  97                 pr_err("powerdomain: %s: missing OMAP4 PRCM partition ID\n",
  98                        pwrdm->name);
  99                 return -EINVAL;
 100         }
 101
 102         if (_pwrdm_lookup(pwrdm->name))
 103                 return -EEXIST;
 104
 105         if (arch_pwrdm && arch_pwrdm->pwrdm_has_voltdm)
 106                 if (!arch_pwrdm->pwrdm_has_voltdm())
 107                         goto skip_voltdm;
 108
 109         voltdm = voltdm_lookup(pwrdm->voltdm.name);
 110         if (!voltdm) {
 111                 pr_err("powerdomain: %s: voltagedomain %s does not exist\n",
 112                        pwrdm->name, pwrdm->voltdm.name);
 113                 return -EINVAL;
 114         }
 115         pwrdm->voltdm.ptr = voltdm;
 116         INIT_LIST_HEAD(&pwrdm->voltdm_node);
 117         voltdm_add_pwrdm(voltdm, pwrdm);
 118 skip_voltdm:
 119         spin_lock_init(&pwrdm->_lock);
 120
 121         list_add(&pwrdm->node, &pwrdm_list);
 122
 123         /* Initialize the powerdomain's state counter */
 124         for (i = 0; i < PWRDM_MAX_PWRSTS; i++)
 125                 pwrdm->state_counter[i] = 0;
 126
 127         pwrdm->ret_logic_off_counter = 0;
 128         for (i = 0; i < pwrdm->banks; i++)
 129                 pwrdm->ret_mem_off_counter[i] = 0;
 130
 131         arch_pwrdm->pwrdm_wait_transition(pwrdm);
 132         pwrdm->state = pwrdm_read_pwrst(pwrdm);
 133         pwrdm->state_counter[pwrdm->state] = 1;
 134
 135         pr_debug("powerdomain: registered %s\n", pwrdm->name);
 136
 137         return 0;
 138 }
 139
 140 static void _update_logic_membank_counters(struct powerdomain *pwrdm)
 141 {
 142         int i;
 143         u8 prev_logic_pwrst, prev_mem_pwrst;
 144
 145         prev_logic_pwrst = pwrdm_read_prev_logic_pwrst(pwrdm);
 146         if ((pwrdm->pwrsts_logic_ret == PWRSTS_OFF_RET) &&
 147             (prev_logic_pwrst == PWRDM_POWER_OFF))
 148                 pwrdm->ret_logic_off_counter++;
 149
 150         for (i = 0; i < pwrdm->banks; i++) {
 151                 prev_mem_pwrst = pwrdm_read_prev_mem_pwrst(pwrdm, i);
 152
 153                 if ((pwrdm->pwrsts_mem_ret[i] == PWRSTS_OFF_RET) &&
 154                     (prev_mem_pwrst == PWRDM_POWER_OFF))
 155                         pwrdm->ret_mem_off_counter[i]++;
 156         }
 157 }
 158
 159 static int _pwrdm_state_switch(struct powerdomain *pwrdm, int flag)
 160 {
 161
 162         int prev, next, state, trace_state = 0;
 163
 164         if (pwrdm == NULL)
 165                 return -EINVAL;
 166
 167         state = pwrdm_read_pwrst(pwrdm);
 168
 169         switch (flag) {
 170         case PWRDM_STATE_NOW:
 171                 prev = pwrdm->state;
 172                 break;
 173         case PWRDM_STATE_PREV:
 174                 prev = pwrdm_read_prev_pwrst(pwrdm);
 175                 if (pwrdm->state != prev)
 176                         pwrdm->state_counter[prev]++;
 177                 if (prev == PWRDM_POWER_RET)
 178                         _update_logic_membank_counters(pwrdm);
 179                 /*
 180                  * If the power domain did not hit the desired state,
 181                  * generate a trace event with both the desired and hit states
 182                  */
 183                 next = pwrdm_read_next_pwrst(pwrdm);
 184                 if (next != prev) {
 185                         trace_state = (PWRDM_TRACE_STATES_FLAG |
 186                                        ((next & OMAP_POWERSTATE_MASK) << 8) |
 187                                        ((prev & OMAP_POWERSTATE_MASK) << 0));
 188                         trace_power_domain_target(pwrdm->name, trace_state,
 189                                                   smp_processor_id());
 190                 }
 191                 break;
 192         default:
 193                 return -EINVAL;
 194         }
 195
 196         if (state != prev)
 197                 pwrdm->state_counter[state]++;
 198
 199         pm_dbg_update_time(pwrdm, prev);
 200
 201         pwrdm->state = state;
 202
 203         return 0;
 204 }
 205
 206 static int _pwrdm_pre_transition_cb(struct powerdomain *pwrdm, void *unused)
 207 {
 208         pwrdm_clear_all_prev_pwrst(pwrdm);
 209         _pwrdm_state_switch(pwrdm, PWRDM_STATE_NOW);
 210         return 0;
 211 }
 212
 213 static int _pwrdm_post_transition_cb(struct powerdomain *pwrdm, void *unused)
 214 {
 215         _pwrdm_state_switch(pwrdm, PWRDM_STATE_PREV);
 216         return 0;
 217 }
 218
 219 /**
 220  * _pwrdm_save_clkdm_state_and_activate - prepare for power state change
 221  * @pwrdm: struct powerdomain * to operate on
 222  * @curr_pwrst: current power state of @pwrdm
 223  * @pwrst: power state to switch to
 224  * @hwsup: ptr to a bool to return whether the clkdm is hardware-supervised
 225  *
 226  * Determine whether the powerdomain needs to be turned on before
 227  * attempting to switch power states.  Called by
 228  * omap_set_pwrdm_state().  NOTE that if the powerdomain contains
 229  * multiple clockdomains, this code assumes that the first clockdomain
 230  * supports software-supervised wakeup mode - potentially a problem.
 231  * Returns the power state switch mode currently in use (see the
 232  * "Types of sleep_switch" comment above).
 233  */
 234 static u8 _pwrdm_save_clkdm_state_and_activate(struct powerdomain *pwrdm,
 235                                                u8 curr_pwrst, u8 pwrst,
 236                                                bool *hwsup)
 237 {
 238         u8 sleep_switch;
 239
 240         if (curr_pwrst < PWRDM_POWER_ON) {
 241                 if (curr_pwrst > pwrst &&
 242                     pwrdm->flags & PWRDM_HAS_LOWPOWERSTATECHANGE &&
 243                     arch_pwrdm->pwrdm_set_lowpwrstchange) {
 244                         sleep_switch = LOWPOWERSTATE_SWITCH;
 245                 } else {
 246                         *hwsup = clkdm_in_hwsup(pwrdm->pwrdm_clkdms[0]);
 247                         clkdm_wakeup_nolock(pwrdm->pwrdm_clkdms[0]);
 248                         sleep_switch = FORCEWAKEUP_SWITCH;
 249                 }
 250         } else {
 251                 sleep_switch = ALREADYACTIVE_SWITCH;
 252         }
 253
 254         return sleep_switch;
 255 }
 256
 257 /**
 258  * _pwrdm_restore_clkdm_state - restore the clkdm hwsup state after pwrst change
 259  * @pwrdm: struct powerdomain * to operate on
 260  * @sleep_switch: return value from _pwrdm_save_clkdm_state_and_activate()
 261  * @hwsup: should @pwrdm's first clockdomain be set to hardware-supervised mode?
 262  *
 263  * Restore the clockdomain state perturbed by
 264  * _pwrdm_save_clkdm_state_and_activate(), and call the power state
 265  * bookkeeping code.  Called by omap_set_pwrdm_state().  NOTE that if
 266  * the powerdomain contains multiple clockdomains, this assumes that
 267  * the first associated clockdomain supports either
 268  * hardware-supervised idle control in the register, or
 269  * software-supervised sleep.  No return value.
 270  */
 271 static void _pwrdm_restore_clkdm_state(struct powerdomain *pwrdm,
 272                                        u8 sleep_switch, bool hwsup)
 273 {
 274         switch (sleep_switch) {
 275         case FORCEWAKEUP_SWITCH:
 276                 if (hwsup)
 277                         clkdm_allow_idle_nolock(pwrdm->pwrdm_clkdms[0]);
 278                 else
 279                         clkdm_sleep_nolock(pwrdm->pwrdm_clkdms[0]);
 280                 break;
 281         case LOWPOWERSTATE_SWITCH:
 282                 if (pwrdm->flags & PWRDM_HAS_LOWPOWERSTATECHANGE &&
 283                     arch_pwrdm->pwrdm_set_lowpwrstchange)
 284                         arch_pwrdm->pwrdm_set_lowpwrstchange(pwrdm);
 285                 pwrdm_state_switch_nolock(pwrdm);
 286                 break;
 287         }
 288 }
 289
 290 /* Public functions */
 291
 292 /**
 293  * pwrdm_register_platform_funcs - register powerdomain implementation fns
 294  * @po: func pointers for arch specific implementations
 295  *
 296  * Register the list of function pointers used to implement the
 297  * powerdomain functions on different OMAP SoCs.  Should be called
 298  * before any other pwrdm_register*() function.  Returns -EINVAL if
 299  * @po is null, -EEXIST if platform functions have already been
 300  * registered, or 0 upon success.
 301  */
 302 int pwrdm_register_platform_funcs(struct pwrdm_ops *po)
 303 {
 304         if (!po)
 305                 return -EINVAL;
 306
 307         if (arch_pwrdm)
 308                 return -EEXIST;
 309
 310         arch_pwrdm = po;
 311
 312         return 0;
 313 }
 314
 315 /**
 316  * pwrdm_register_pwrdms - register SoC powerdomains
 317  * @ps: pointer to an array of struct powerdomain to register
 318  *
 319  * Register the powerdomains available on a particular OMAP SoC.  Must
 320  * be called after pwrdm_register_platform_funcs().  May be called
 321  * multiple times.  Returns -EACCES if called before
 322  * pwrdm_register_platform_funcs(); -EINVAL if the argument @ps is
 323  * null; or 0 upon success.
 324  */
 325 int pwrdm_register_pwrdms(struct powerdomain **ps)
 326 {
 327         struct powerdomain **p = NULL;
 328
 329         if (!arch_pwrdm)
 330                 return -EEXIST;
 331
 332         if (!ps)
 333                 return -EINVAL;
 334
 335         for (p = ps; *p; p++)
 336                 _pwrdm_register(*p);
 337
 338         return 0;
 339 }
 340
 341 /**
 342  * pwrdm_complete_init - set up the powerdomain layer
 343  *
 344  * Do whatever is necessary to initialize registered powerdomains and
 345  * powerdomain code.  Currently, this programs the next power state
 346  * for each powerdomain to ON.  This prevents powerdomains from
 347  * unexpectedly losing context or entering high wakeup latency modes
 348  * with non-power-management-enabled kernels.  Must be called after
 349  * pwrdm_register_pwrdms().  Returns -EACCES if called before
 350  * pwrdm_register_pwrdms(), or 0 upon success.
 351  */
 352 int pwrdm_complete_init(void)
 353 {
 354         struct powerdomain *temp_p;
 355
 356         if (list_empty(&pwrdm_list))
 357                 return -EACCES;
 358
 359         list_for_each_entry(temp_p, &pwrdm_list, node)
 360                 pwrdm_set_next_pwrst(temp_p, PWRDM_POWER_ON);
 361
 362         return 0;
 363 }
 364
 365 /**
 366  * pwrdm_lock - acquire a Linux spinlock on a powerdomain
 367  * @pwrdm: struct powerdomain * to lock
 368  *
 369  * Acquire the powerdomain spinlock on @pwrdm.  No return value.
 370  */
 371 void pwrdm_lock(struct powerdomain *pwrdm)
 372         __acquires(&pwrdm->_lock)
 373 {
 374         spin_lock_irqsave(&pwrdm->_lock, pwrdm->_lock_flags);
 375 }
 376
 377 /**
 378  * pwrdm_unlock - release a Linux spinlock on a powerdomain
 379  * @pwrdm: struct powerdomain * to unlock
 380  *
 381  * Release the powerdomain spinlock on @pwrdm.  No return value.
 382  */
 383 void pwrdm_unlock(struct powerdomain *pwrdm)
 384         __releases(&pwrdm->_lock)
 385 {
 386         spin_unlock_irqrestore(&pwrdm->_lock, pwrdm->_lock_flags);
 387 }
 388
 389 /**
 390  * pwrdm_lookup - look up a powerdomain by name, return a pointer
 391  * @name: name of powerdomain
 392  *
 393  * Find a registered powerdomain by its name @name.  Returns a pointer
 394  * to the struct powerdomain if found, or NULL otherwise.
 395  */
 396 struct powerdomain *pwrdm_lookup(const char *name)
 397 {
 398         struct powerdomain *pwrdm;
 399
 400         if (!name)
 401                 return NULL;
 402
 403         pwrdm = _pwrdm_lookup(name);
 404
 405         return pwrdm;
 406 }
 407
 408 /**
 409  * pwrdm_for_each - call function on each registered clockdomain
 410  * @fn: callback function *
 411  *
 412  * Call the supplied function @fn for each registered powerdomain.
 413  * The callback function @fn can return anything but 0 to bail out
 414  * early from the iterator.  Returns the last return value of the
 415  * callback function, which should be 0 for success or anything else
 416  * to indicate failure; or -EINVAL if the function pointer is null.
 417  */
 418 int pwrdm_for_each(int (*fn)(struct powerdomain *pwrdm, void *user),
 419                    void *user)
 420 {
 421         struct powerdomain *temp_pwrdm;
 422         int ret = 0;
 423
 424         if (!fn)
 425                 return -EINVAL;
 426
 427         list_for_each_entry(temp_pwrdm, &pwrdm_list, node) {
 428                 ret = (*fn)(temp_pwrdm, user);
 429                 if (ret)
 430                         break;
 431         }
 432
 433         return ret;
 434 }
 435
 436 /**
 437  * pwrdm_add_clkdm - add a clockdomain to a powerdomain
 438  * @pwrdm: struct powerdomain * to add the clockdomain to
 439  * @clkdm: struct clockdomain * to associate with a powerdomain
 440  *
 441  * Associate the clockdomain @clkdm with a powerdomain @pwrdm.  This
 442  * enables the use of pwrdm_for_each_clkdm().  Returns -EINVAL if
 443  * presented with invalid pointers; -ENOMEM if memory could not be allocated;
 444  * or 0 upon success.
 445  */
 446 int pwrdm_add_clkdm(struct powerdomain *pwrdm, struct clockdomain *clkdm)
 447 {
 448         int i;
 449         int ret = -EINVAL;
 450
 451         if (!pwrdm || !clkdm)
 452                 return -EINVAL;
 453
 454         pr_debug("powerdomain: %s: associating clockdomain %s\n",
 455                  pwrdm->name, clkdm->name);
 456
 457         for (i = 0; i < PWRDM_MAX_CLKDMS; i++) {
 458                 if (!pwrdm->pwrdm_clkdms[i])
 459                         break;
 460 #ifdef DEBUG
 461                 if (pwrdm->pwrdm_clkdms[i] == clkdm) {
 462                         ret = -EINVAL;
 463                         goto pac_exit;
 464                 }
 465 #endif
 466         }
 467
 468         if (i == PWRDM_MAX_CLKDMS) {
 469                 pr_debug("powerdomain: %s: increase PWRDM_MAX_CLKDMS for clkdm %s\n",
 470                          pwrdm->name, clkdm->name);
 471                 WARN_ON(1);
 472                 ret = -ENOMEM;
 473                 goto pac_exit;
 474         }
 475
 476         pwrdm->pwrdm_clkdms[i] = clkdm;
 477
 478         ret = 0;
 479
 480 pac_exit:
 481         return ret;
 482 }
 483
 484 /**
 485  * pwrdm_del_clkdm - remove a clockdomain from a powerdomain
 486  * @pwrdm: struct powerdomain * to add the clockdomain to
 487  * @clkdm: struct clockdomain * to associate with a powerdomain
 488  *
 489  * Dissociate the clockdomain @clkdm from the powerdomain
 490  * @pwrdm. Returns -EINVAL if presented with invalid pointers; -ENOENT
 491  * if @clkdm was not associated with the powerdomain, or 0 upon
 492  * success.
 493  */
 494 int pwrdm_del_clkdm(struct powerdomain *pwrdm, struct clockdomain *clkdm)
 495 {
 496         int ret = -EINVAL;
 497         int i;
 498
 499         if (!pwrdm || !clkdm)
 500                 return -EINVAL;
 501
 502         pr_debug("powerdomain: %s: dissociating clockdomain %s\n",
 503                  pwrdm->name, clkdm->name);
 504
 505         for (i = 0; i < PWRDM_MAX_CLKDMS; i++)
 506                 if (pwrdm->pwrdm_clkdms[i] == clkdm)
 507                         break;
 508
 509         if (i == PWRDM_MAX_CLKDMS) {
 510                 pr_debug("powerdomain: %s: clkdm %s not associated?!\n",
 511                          pwrdm->name, clkdm->name);
 512                 ret = -ENOENT;
 513                 goto pdc_exit;
 514         }
 515
 516         pwrdm->pwrdm_clkdms[i] = NULL;
 517
 518         ret = 0;
 519
 520 pdc_exit:
 521         return ret;
 522 }
 523
 524 /**
 525  * pwrdm_for_each_clkdm - call function on each clkdm in a pwrdm
 526  * @pwrdm: struct powerdomain * to iterate over
 527  * @fn: callback function *
 528  *
 529  * Call the supplied function @fn for each clockdomain in the powerdomain
 530  * @pwrdm.  The callback function can return anything but 0 to bail
 531  * out early from the iterator.  Returns -EINVAL if presented with
 532  * invalid pointers; or passes along the last return value of the
 533  * callback function, which should be 0 for success or anything else
 534  * to indicate failure.
 535  */
 536 int pwrdm_for_each_clkdm(struct powerdomain *pwrdm,
 537                          int (*fn)(struct powerdomain *pwrdm,
 538                                    struct clockdomain *clkdm))
 539 {
 540         int ret = 0;
 541         int i;
 542
 543         if (!fn)
 544                 return -EINVAL;
 545
 546         for (i = 0; i < PWRDM_MAX_CLKDMS && !ret; i++)
 547                 ret = (*fn)(pwrdm, pwrdm->pwrdm_clkdms[i]);
 548
 549         return ret;
 550 }
 551
 552 /**
 553  * pwrdm_get_voltdm - return a ptr to the voltdm that this pwrdm resides in
 554  * @pwrdm: struct powerdomain *
 555  *
 556  * Return a pointer to the struct voltageomain that the specified powerdomain
 557  * @pwrdm exists in.
 558  */
 559 struct voltagedomain *pwrdm_get_voltdm(struct powerdomain *pwrdm)
 560 {
 561         return pwrdm->voltdm.ptr;
 562 }
 563
 564 /**
 565  * pwrdm_get_mem_bank_count - get number of memory banks in this powerdomain
 566  * @pwrdm: struct powerdomain *
 567  *
 568  * Return the number of controllable memory banks in powerdomain @pwrdm,
 569  * starting with 1.  Returns -EINVAL if the powerdomain pointer is null.
 570  */
 571 int pwrdm_get_mem_bank_count(struct powerdomain *pwrdm)
 572 {
 573         if (!pwrdm)
 574                 return -EINVAL;
 575
 576         return pwrdm->banks;
 577 }
 578
 579 /**
 580  * pwrdm_set_next_pwrst - set next powerdomain power state
 581  * @pwrdm: struct powerdomain * to set
 582  * @pwrst: one of the PWRDM_POWER_* macros
 583  *
 584  * Set the powerdomain @pwrdm's next power state to @pwrst.  The powerdomain
 585  * may not enter this state immediately if the preconditions for this state
 586  * have not been satisfied.  Returns -EINVAL if the powerdomain pointer is
 587  * null or if the power state is invalid for the powerdomin, or returns 0
 588  * upon success.
 589  */
 590 int pwrdm_set_next_pwrst(struct powerdomain *pwrdm, u8 pwrst)
 591 {
 592         int ret = -EINVAL;
 593
 594         if (!pwrdm)
 595                 return -EINVAL;
 596
 597         if (!(pwrdm->pwrsts & (1 << pwrst)))
 598                 return -EINVAL;
 599
 600         pr_debug("powerdomain: %s: setting next powerstate to %0x\n",
 601                  pwrdm->name, pwrst);
 602
 603         if (arch_pwrdm && arch_pwrdm->pwrdm_set_next_pwrst) {
 604                 /* Trace the pwrdm desired target state */
 605                 trace_power_domain_target(pwrdm->name, pwrst,
 606                                           smp_processor_id());
 607                 /* Program the pwrdm desired target state */
 608                 ret = arch_pwrdm->pwrdm_set_next_pwrst(pwrdm, pwrst);
 609         }
 610
 611         return ret;
 612 }
 613
 614 /**
 615  * pwrdm_read_next_pwrst - get next powerdomain power state
 616  * @pwrdm: struct powerdomain * to get power state
 617  *
 618  * Return the powerdomain @pwrdm's next power state.  Returns -EINVAL
 619  * if the powerdomain pointer is null or returns the next power state
 620  * upon success.
 621  */
 622 int pwrdm_read_next_pwrst(struct powerdomain *pwrdm)
 623 {
 624         int ret = -EINVAL;
 625
 626         if (!pwrdm)
 627                 return -EINVAL;
 628
 629         if (arch_pwrdm && arch_pwrdm->pwrdm_read_next_pwrst)
 630                 ret = arch_pwrdm->pwrdm_read_next_pwrst(pwrdm);
 631
 632         return ret;
 633 }
 634
 635 /**
 636  * pwrdm_read_pwrst - get current powerdomain power state
 637  * @pwrdm: struct powerdomain * to get power state
 638  *
 639  * Return the powerdomain @pwrdm's current power state. Returns -EINVAL
 640  * if the powerdomain pointer is null or returns the current power state
 641  * upon success. Note that if the power domain only supports the ON state
 642  * then just return ON as the current state.
 643  */
 644 int pwrdm_read_pwrst(struct powerdomain *pwrdm)
 645 {
 646         int ret = -EINVAL;
 647
 648         if (!pwrdm)
 649                 return -EINVAL;
 650
 651         if (pwrdm->pwrsts == PWRSTS_ON)
 652                 return PWRDM_POWER_ON;
 653
 654         if (arch_pwrdm && arch_pwrdm->pwrdm_read_pwrst)
 655                 ret = arch_pwrdm->pwrdm_read_pwrst(pwrdm);
 656
 657         return ret;
 658 }
 659
 660 /**
 661  * pwrdm_read_prev_pwrst - get previous powerdomain power state
 662  * @pwrdm: struct powerdomain * to get previous power state
 663  *
 664  * Return the powerdomain @pwrdm's previous power state.  Returns -EINVAL
 665  * if the powerdomain pointer is null or returns the previous power state
 666  * upon success.
 667  */
 668 int pwrdm_read_prev_pwrst(struct powerdomain *pwrdm)
 669 {
 670         int ret = -EINVAL;
 671
 672         if (!pwrdm)
 673                 return -EINVAL;
 674
 675         if (arch_pwrdm && arch_pwrdm->pwrdm_read_prev_pwrst)
 676                 ret = arch_pwrdm->pwrdm_read_prev_pwrst(pwrdm);
 677
 678         return ret;
 679 }
 680
 681 /**
 682  * pwrdm_set_logic_retst - set powerdomain logic power state upon retention
 683  * @pwrdm: struct powerdomain * to set
 684  * @pwrst: one of the PWRDM_POWER_* macros
 685  *
 686  * Set the next power state @pwrst that the logic portion of the
 687  * powerdomain @pwrdm will enter when the powerdomain enters retention.
 688  * This will be either RETENTION or OFF, if supported.  Returns
 689  * -EINVAL if the powerdomain pointer is null or the target power
 690  * state is not not supported, or returns 0 upon success.
 691  */
 692 int pwrdm_set_logic_retst(struct powerdomain *pwrdm, u8 pwrst)
 693 {
 694         int ret = -EINVAL;
 695
 696         if (!pwrdm)
 697                 return -EINVAL;
 698
 699         if (!(pwrdm->pwrsts_logic_ret & (1 << pwrst)))
 700                 return -EINVAL;
 701
 702         pr_debug("powerdomain: %s: setting next logic powerstate to %0x\n",
 703                  pwrdm->name, pwrst);
 704
 705         if (arch_pwrdm && arch_pwrdm->pwrdm_set_logic_retst)
 706                 ret = arch_pwrdm->pwrdm_set_logic_retst(pwrdm, pwrst);
 707
 708         return ret;
 709 }
 710
 711 /**
 712  * pwrdm_set_mem_onst - set memory power state while powerdomain ON
 713  * @pwrdm: struct powerdomain * to set
 714  * @bank: memory bank number to set (0-3)
 715  * @pwrst: one of the PWRDM_POWER_* macros
 716  *
 717  * Set the next power state @pwrst that memory bank @bank of the
 718  * powerdomain @pwrdm will enter when the powerdomain enters the ON
 719  * state.  @bank will be a number from 0 to 3, and represents different
 720  * types of memory, depending on the powerdomain.  Returns -EINVAL if
 721  * the powerdomain pointer is null or the target power state is not
 722  * not supported for this memory bank, -EEXIST if the target memory
 723  * bank does not exist or is not controllable, or returns 0 upon
 724  * success.
 725  */
 726 int pwrdm_set_mem_onst(struct powerdomain *pwrdm, u8 bank, u8 pwrst)
 727 {
 728         int ret = -EINVAL;
 729
 730         if (!pwrdm)
 731                 return -EINVAL;
 732
 733         if (pwrdm->banks < (bank + 1))
 734                 return -EEXIST;
 735
 736         if (!(pwrdm->pwrsts_mem_on[bank] & (1 << pwrst)))
 737                 return -EINVAL;
 738
 739         pr_debug("powerdomain: %s: setting next memory powerstate for bank %0x while pwrdm-ON to %0x\n",
 740                  pwrdm->name, bank, pwrst);
 741
 742         if (arch_pwrdm && arch_pwrdm->pwrdm_set_mem_onst)
 743                 ret = arch_pwrdm->pwrdm_set_mem_onst(pwrdm, bank, pwrst);
 744
 745         return ret;
 746 }
 747
 748 /**
 749  * pwrdm_set_mem_retst - set memory power state while powerdomain in RET
 750  * @pwrdm: struct powerdomain * to set
 751  * @bank: memory bank number to set (0-3)
 752  * @pwrst: one of the PWRDM_POWER_* macros
 753  *
 754  * Set the next power state @pwrst that memory bank @bank of the
 755  * powerdomain @pwrdm will enter when the powerdomain enters the
 756  * RETENTION state.  Bank will be a number from 0 to 3, and represents
 757  * different types of memory, depending on the powerdomain.  @pwrst
 758  * will be either RETENTION or OFF, if supported.  Returns -EINVAL if
 759  * the powerdomain pointer is null or the target power state is not
 760  * not supported for this memory bank, -EEXIST if the target memory
 761  * bank does not exist or is not controllable, or returns 0 upon
 762  * success.
 763  */
 764 int pwrdm_set_mem_retst(struct powerdomain *pwrdm, u8 bank, u8 pwrst)
 765 {
 766         int ret = -EINVAL;
 767
 768         if (!pwrdm)
 769                 return -EINVAL;
 770
 771         if (pwrdm->banks < (bank + 1))
 772                 return -EEXIST;
 773
 774         if (!(pwrdm->pwrsts_mem_ret[bank] & (1 << pwrst)))
 775                 return -EINVAL;
 776
 777         pr_debug("powerdomain: %s: setting next memory powerstate for bank %0x while pwrdm-RET to %0x\n",
 778                  pwrdm->name, bank, pwrst);
 779
 780         if (arch_pwrdm && arch_pwrdm->pwrdm_set_mem_retst)
 781                 ret = arch_pwrdm->pwrdm_set_mem_retst(pwrdm, bank, pwrst);
 782
 783         return ret;
 784 }
 785
 786 /**
 787  * pwrdm_read_logic_pwrst - get current powerdomain logic retention power state
 788  * @pwrdm: struct powerdomain * to get current logic retention power state
 789  *
 790  * Return the power state that the logic portion of powerdomain @pwrdm
 791  * will enter when the powerdomain enters retention.  Returns -EINVAL
 792  * if the powerdomain pointer is null or returns the logic retention
 793  * power state upon success.
 794  */
 795 int pwrdm_read_logic_pwrst(struct powerdomain *pwrdm)
 796 {
 797         int ret = -EINVAL;
 798
 799         if (!pwrdm)
 800                 return -EINVAL;
 801
 802         if (arch_pwrdm && arch_pwrdm->pwrdm_read_logic_pwrst)
 803                 ret = arch_pwrdm->pwrdm_read_logic_pwrst(pwrdm);
 804
 805         return ret;
 806 }
 807
 808 /**
 809  * pwrdm_read_prev_logic_pwrst - get previous powerdomain logic power state
 810  * @pwrdm: struct powerdomain * to get previous logic power state
 811  *
 812  * Return the powerdomain @pwrdm's previous logic power state.  Returns
 813  * -EINVAL if the powerdomain pointer is null or returns the previous
 814  * logic power state upon success.
 815  */
 816 int pwrdm_read_prev_logic_pwrst(struct powerdomain *pwrdm)
 817 {
 818         int ret = -EINVAL;
 819
 820         if (!pwrdm)
 821                 return -EINVAL;
 822
 823         if (arch_pwrdm && arch_pwrdm->pwrdm_read_prev_logic_pwrst)
 824                 ret = arch_pwrdm->pwrdm_read_prev_logic_pwrst(pwrdm);
 825
 826         return ret;
 827 }
 828
 829 /**
 830  * pwrdm_read_logic_retst - get next powerdomain logic power state
 831  * @pwrdm: struct powerdomain * to get next logic power state
 832  *
 833  * Return the powerdomain pwrdm's logic power state.  Returns -EINVAL
 834  * if the powerdomain pointer is null or returns the next logic
 835  * power state upon success.
 836  */
 837 int pwrdm_read_logic_retst(struct powerdomain *pwrdm)
 838 {
 839         int ret = -EINVAL;
 840
 841         if (!pwrdm)
 842                 return -EINVAL;
 843
 844         if (arch_pwrdm && arch_pwrdm->pwrdm_read_logic_retst)
 845                 ret = arch_pwrdm->pwrdm_read_logic_retst(pwrdm);
 846
 847         return ret;
 848 }
 849
 850 /**
 851  * pwrdm_read_mem_pwrst - get current memory bank power state
 852  * @pwrdm: struct powerdomain * to get current memory bank power state
 853  * @bank: memory bank number (0-3)
 854  *
 855  * Return the powerdomain @pwrdm's current memory power state for bank
 856  * @bank.  Returns -EINVAL if the powerdomain pointer is null, -EEXIST if
 857  * the target memory bank does not exist or is not controllable, or
 858  * returns the current memory power state upon success.
 859  */
 860 int pwrdm_read_mem_pwrst(struct powerdomain *pwrdm, u8 bank)
 861 {
 862         int ret = -EINVAL;
 863
 864         if (!pwrdm)
 865                 return ret;
 866
 867         if (pwrdm->banks < (bank + 1))
 868                 return ret;
 869
 870         if (pwrdm->flags & PWRDM_HAS_MPU_QUIRK)
 871                 bank = 1;
 872
 873         if (arch_pwrdm && arch_pwrdm->pwrdm_read_mem_pwrst)
 874                 ret = arch_pwrdm->pwrdm_read_mem_pwrst(pwrdm, bank);
 875
 876         return ret;
 877 }
 878
 879 /**
 880  * pwrdm_read_prev_mem_pwrst - get previous memory bank power state
 881  * @pwrdm: struct powerdomain * to get previous memory bank power state
 882  * @bank: memory bank number (0-3)
 883  *
 884  * Return the powerdomain @pwrdm's previous memory power state for
 885  * bank @bank.  Returns -EINVAL if the powerdomain pointer is null,
 886  * -EEXIST if the target memory bank does not exist or is not
 887  * controllable, or returns the previous memory power state upon
 888  * success.
 889  */
 890 int pwrdm_read_prev_mem_pwrst(struct powerdomain *pwrdm, u8 bank)
 891 {
 892         int ret = -EINVAL;
 893
 894         if (!pwrdm)
 895                 return ret;
 896
 897         if (pwrdm->banks < (bank + 1))
 898                 return ret;
 899
 900         if (pwrdm->flags & PWRDM_HAS_MPU_QUIRK)
 901                 bank = 1;
 902
 903         if (arch_pwrdm && arch_pwrdm->pwrdm_read_prev_mem_pwrst)
 904                 ret = arch_pwrdm->pwrdm_read_prev_mem_pwrst(pwrdm, bank);
 905
 906         return ret;
 907 }
 908
 909 /**
 910  * pwrdm_read_mem_retst - get next memory bank power state
 911  * @pwrdm: struct powerdomain * to get mext memory bank power state
 912  * @bank: memory bank number (0-3)
 913  *
 914  * Return the powerdomain pwrdm's next memory power state for bank
 915  * x.  Returns -EINVAL if the powerdomain pointer is null, -EEXIST if
 916  * the target memory bank does not exist or is not controllable, or
 917  * returns the next memory power state upon success.
 918  */
 919 int pwrdm_read_mem_retst(struct powerdomain *pwrdm, u8 bank)
 920 {
 921         int ret = -EINVAL;
 922
 923         if (!pwrdm)
 924                 return ret;
 925
 926         if (pwrdm->banks < (bank + 1))
 927                 return ret;
 928
 929         if (arch_pwrdm && arch_pwrdm->pwrdm_read_mem_retst)
 930                 ret = arch_pwrdm->pwrdm_read_mem_retst(pwrdm, bank);
 931
 932         return ret;
 933 }
 934
 935 /**
 936  * pwrdm_clear_all_prev_pwrst - clear previous powerstate register for a pwrdm
 937  * @pwrdm: struct powerdomain * to clear
 938  *
 939  * Clear the powerdomain's previous power state register @pwrdm.
 940  * Clears the entire register, including logic and memory bank
 941  * previous power states.  Returns -EINVAL if the powerdomain pointer
 942  * is null, or returns 0 upon success.
 943  */
 944 int pwrdm_clear_all_prev_pwrst(struct powerdomain *pwrdm)
 945 {
 946         int ret = -EINVAL;
 947
 948         if (!pwrdm)
 949                 return ret;
 950
 951         /*
 952          * XXX should get the powerdomain's current state here;
 953          * warn & fail if it is not ON.
 954          */
 955
 956         pr_debug("powerdomain: %s: clearing previous power state reg\n",
 957                  pwrdm->name);
 958
 959         if (arch_pwrdm && arch_pwrdm->pwrdm_clear_all_prev_pwrst)
 960                 ret = arch_pwrdm->pwrdm_clear_all_prev_pwrst(pwrdm);
 961
 962         return ret;
 963 }
 964
 965 /**
 966  * pwrdm_enable_hdwr_sar - enable automatic hardware SAR for a pwrdm
 967  * @pwrdm: struct powerdomain *
 968  *
 969  * Enable automatic context save-and-restore upon power state change
 970  * for some devices in the powerdomain @pwrdm.  Warning: this only
 971  * affects a subset of devices in a powerdomain; check the TRM
 972  * closely.  Returns -EINVAL if the powerdomain pointer is null or if
 973  * the powerdomain does not support automatic save-and-restore, or
 974  * returns 0 upon success.
 975  */
 976 int pwrdm_enable_hdwr_sar(struct powerdomain *pwrdm)
 977 {
 978         int ret = -EINVAL;
 979
 980         if (!pwrdm)
 981                 return ret;
 982
 983         if (!(pwrdm->flags & PWRDM_HAS_HDWR_SAR))
 984                 return ret;
 985
 986         pr_debug("powerdomain: %s: setting SAVEANDRESTORE bit\n", pwrdm->name);
 987
 988         if (arch_pwrdm && arch_pwrdm->pwrdm_enable_hdwr_sar)
 989                 ret = arch_pwrdm->pwrdm_enable_hdwr_sar(pwrdm);
 990
 991         return ret;
 992 }
 993
 994 /**
 995  * pwrdm_disable_hdwr_sar - disable automatic hardware SAR for a pwrdm
 996  * @pwrdm: struct powerdomain *
 997  *
 998  * Disable automatic context save-and-restore upon power state change
 999  * for some devices in the powerdomain @pwrdm.  Warning: this only
1000  * affects a subset of devices in a powerdomain; check the TRM
1001  * closely.  Returns -EINVAL if the powerdomain pointer is null or if
1002  * the powerdomain does not support automatic save-and-restore, or
1003  * returns 0 upon success.
1004  */
1005 int pwrdm_disable_hdwr_sar(struct powerdomain *pwrdm)
1006 {
1007         int ret = -EINVAL;
1008
1009         if (!pwrdm)
1010                 return ret;
1011
1012         if (!(pwrdm->flags & PWRDM_HAS_HDWR_SAR))
1013                 return ret;
1014
1015         pr_debug("powerdomain: %s: clearing SAVEANDRESTORE bit\n", pwrdm->name);
1016
1017         if (arch_pwrdm && arch_pwrdm->pwrdm_disable_hdwr_sar)
1018                 ret = arch_pwrdm->pwrdm_disable_hdwr_sar(pwrdm);
1019
1020         return ret;
1021 }
1022
1023 /**
1024  * pwrdm_has_hdwr_sar - test whether powerdomain supports hardware SAR
1025  * @pwrdm: struct powerdomain *
1026  *
1027  * Returns 1 if powerdomain @pwrdm supports hardware save-and-restore
1028  * for some devices, or 0 if it does not.
1029  */
1030 bool pwrdm_has_hdwr_sar(struct powerdomain *pwrdm)
1031 {
1032         return (pwrdm && pwrdm->flags & PWRDM_HAS_HDWR_SAR) ? 1 : 0;
1033 }
1034
1035 int pwrdm_state_switch_nolock(struct powerdomain *pwrdm)
1036 {
1037         int ret;
1038
1039         if (!pwrdm || !arch_pwrdm)
1040                 return -EINVAL;
1041
1042         ret = arch_pwrdm->pwrdm_wait_transition(pwrdm);
1043         if (!ret)
1044                 ret = _pwrdm_state_switch(pwrdm, PWRDM_STATE_NOW);
1045
1046         return ret;
1047 }
1048
1049 int __deprecated pwrdm_state_switch(struct powerdomain *pwrdm)
1050 {
1051         int ret;
1052
1053         pwrdm_lock(pwrdm);
1054         ret = pwrdm_state_switch_nolock(pwrdm);
1055         pwrdm_unlock(pwrdm);
1056
1057         return ret;
1058 }
1059
1060 int pwrdm_pre_transition(struct powerdomain *pwrdm)
1061 {
1062         if (pwrdm)
1063                 _pwrdm_pre_transition_cb(pwrdm, NULL);
1064         else
1065                 pwrdm_for_each(_pwrdm_pre_transition_cb, NULL);
1066
1067         return 0;
1068 }
1069
1070 int pwrdm_post_transition(struct powerdomain *pwrdm)
1071 {
1072         if (pwrdm)
1073                 _pwrdm_post_transition_cb(pwrdm, NULL);
1074         else
1075                 pwrdm_for_each(_pwrdm_post_transition_cb, NULL);
1076
1077         return 0;
1078 }
1079
1080 /**
1081  * omap_set_pwrdm_state - change a powerdomain's current power state
1082  * @pwrdm: struct powerdomain * to change the power state of
1083  * @pwrst: power state to change to
1084  *
1085  * Change the current hardware power state of the powerdomain
1086  * represented by @pwrdm to the power state represented by @pwrst.
1087  * Returns -EINVAL if @pwrdm is null or invalid or if the
1088  * powerdomain's current power state could not be read, or returns 0
1089  * upon success or if @pwrdm does not support @pwrst or any
1090  * lower-power state.  XXX Should not return 0 if the @pwrdm does not
1091  * support @pwrst or any lower-power state: this should be an error.
1092  */
1093 int omap_set_pwrdm_state(struct powerdomain *pwrdm, u8 pwrst)
1094 {
1095         u8 next_pwrst, sleep_switch;
1096         int curr_pwrst;
1097         int ret = 0;
1098         bool hwsup = false;
1099
1100         if (!pwrdm || IS_ERR(pwrdm))
1101                 return -EINVAL;
1102
1103         while (!(pwrdm->pwrsts & (1 << pwrst))) {
1104                 if (pwrst == PWRDM_POWER_OFF)
1105                         return ret;
1106                 pwrst--;
1107         }
1108
1109         pwrdm_lock(pwrdm);
1110
1111         curr_pwrst = pwrdm_read_pwrst(pwrdm);
1112         if (curr_pwrst < 0) {
1113                 ret = -EINVAL;
1114                 goto osps_out;
1115         }
1116
1117         next_pwrst = pwrdm_read_next_pwrst(pwrdm);
1118         if (curr_pwrst == pwrst && next_pwrst == pwrst)
1119                 goto osps_out;
1120
1121         sleep_switch = _pwrdm_save_clkdm_state_and_activate(pwrdm, curr_pwrst,
1122                                                             pwrst, &hwsup);
1123
1124         ret = pwrdm_set_next_pwrst(pwrdm, pwrst);
1125         if (ret)
1126                 pr_err("%s: unable to set power state of powerdomain: %s\n",
1127                        __func__, pwrdm->name);
1128
1129         _pwrdm_restore_clkdm_state(pwrdm, sleep_switch, hwsup);
1130
1131 osps_out:
1132         pwrdm_unlock(pwrdm);
1133
1134         return ret;
1135 }
1136
1137 /**
1138  * pwrdm_get_context_loss_count - get powerdomain's context loss count
1139  * @pwrdm: struct powerdomain * to wait for
1140  *
1141  * Context loss count is the sum of powerdomain off-mode counter, the
1142  * logic off counter and the per-bank memory off counter.  Returns negative
1143  * (and WARNs) upon error, otherwise, returns the context loss count.
1144  */
1145 int pwrdm_get_context_loss_count(struct powerdomain *pwrdm)
1146 {
1147         int i, count;
1148
1149         if (!pwrdm) {
1150                 WARN(1, "powerdomain: %s: pwrdm is null\n", __func__);
1151                 return -ENODEV;
1152         }
1153
1154         count = pwrdm->state_counter[PWRDM_POWER_OFF];
1155         count += pwrdm->ret_logic_off_counter;
1156
1157         for (i = 0; i < pwrdm->banks; i++)
1158                 count += pwrdm->ret_mem_off_counter[i];
1159
1160         /*
1161          * Context loss count has to be a non-negative value. Clear the sign
1162          * bit to get a value range from 0 to INT_MAX.
1163          */
1164         count &= INT_MAX;
1165
1166         pr_debug("powerdomain: %s: context loss count = %d\n",
1167                  pwrdm->name, count);
1168
1169         return count;
1170 }
1171
1172 /**
1173  * pwrdm_can_ever_lose_context - can this powerdomain ever lose context?
1174  * @pwrdm: struct powerdomain *
1175  *
1176  * Given a struct powerdomain * @pwrdm, returns 1 if the powerdomain
1177  * can lose either memory or logic context or if @pwrdm is invalid, or
1178  * returns 0 otherwise.  This function is not concerned with how the
1179  * powerdomain registers are programmed (i.e., to go off or not); it's
1180  * concerned with whether it's ever possible for this powerdomain to
1181  * go off while some other part of the chip is active.  This function
1182  * assumes that every powerdomain can go to either ON or INACTIVE.
1183  */
1184 bool pwrdm_can_ever_lose_context(struct powerdomain *pwrdm)
1185 {
1186         int i;
1187
1188         if (!pwrdm) {
1189                 pr_debug("powerdomain: %s: invalid powerdomain pointer\n",
1190                          __func__);
1191                 return 1;
1192         }
1193
1194         if (pwrdm->pwrsts & PWRSTS_OFF)
1195                 return 1;
1196
1197         if (pwrdm->pwrsts & PWRSTS_RET) {
1198                 if (pwrdm->pwrsts_logic_ret & PWRSTS_OFF)
1199                         return 1;
1200
1201                 for (i = 0; i < pwrdm->banks; i++)
1202                         if (pwrdm->pwrsts_mem_ret[i] & PWRSTS_OFF)
1203                                 return 1;
1204         }
1205
1206         for (i = 0; i < pwrdm->banks; i++)
1207                 if (pwrdm->pwrsts_mem_on[i] & PWRSTS_OFF)
1208                         return 1;
1209
1210         return 0;
1211 }