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