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