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