1
2
3
4
5
6
7
8
9
10
11
12
13
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
48
49
50
51
52#define ALREADYACTIVE_SWITCH 0
53#define FORCEWAKEUP_SWITCH 1
54#define LOWPOWERSTATE_SWITCH 2
55
56
57static LIST_HEAD(pwrdm_list);
58
59static struct pwrdm_ops *arch_pwrdm;
60
61
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
81
82
83
84
85
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 voltdm = voltdm_lookup(pwrdm->voltdm.name);
106 if (!voltdm) {
107 pr_err("powerdomain: %s: voltagedomain %s does not exist\n",
108 pwrdm->name, pwrdm->voltdm.name);
109 return -EINVAL;
110 }
111 pwrdm->voltdm.ptr = voltdm;
112 INIT_LIST_HEAD(&pwrdm->voltdm_node);
113 voltdm_add_pwrdm(voltdm, pwrdm);
114 spin_lock_init(&pwrdm->_lock);
115
116 list_add(&pwrdm->node, &pwrdm_list);
117
118
119 for (i = 0; i < PWRDM_MAX_PWRSTS; i++)
120 pwrdm->state_counter[i] = 0;
121
122 pwrdm->ret_logic_off_counter = 0;
123 for (i = 0; i < pwrdm->banks; i++)
124 pwrdm->ret_mem_off_counter[i] = 0;
125
126 arch_pwrdm->pwrdm_wait_transition(pwrdm);
127 pwrdm->state = pwrdm_read_pwrst(pwrdm);
128 pwrdm->state_counter[pwrdm->state] = 1;
129
130 pr_debug("powerdomain: registered %s\n", pwrdm->name);
131
132 return 0;
133}
134
135static void _update_logic_membank_counters(struct powerdomain *pwrdm)
136{
137 int i;
138 u8 prev_logic_pwrst, prev_mem_pwrst;
139
140 prev_logic_pwrst = pwrdm_read_prev_logic_pwrst(pwrdm);
141 if ((pwrdm->pwrsts_logic_ret == PWRSTS_OFF_RET) &&
142 (prev_logic_pwrst == PWRDM_POWER_OFF))
143 pwrdm->ret_logic_off_counter++;
144
145 for (i = 0; i < pwrdm->banks; i++) {
146 prev_mem_pwrst = pwrdm_read_prev_mem_pwrst(pwrdm, i);
147
148 if ((pwrdm->pwrsts_mem_ret[i] == PWRSTS_OFF_RET) &&
149 (prev_mem_pwrst == PWRDM_POWER_OFF))
150 pwrdm->ret_mem_off_counter[i]++;
151 }
152}
153
154static int _pwrdm_state_switch(struct powerdomain *pwrdm, int flag)
155{
156
157 int prev, next, state, trace_state = 0;
158
159 if (pwrdm == NULL)
160 return -EINVAL;
161
162 state = pwrdm_read_pwrst(pwrdm);
163
164 switch (flag) {
165 case PWRDM_STATE_NOW:
166 prev = pwrdm->state;
167 break;
168 case PWRDM_STATE_PREV:
169 prev = pwrdm_read_prev_pwrst(pwrdm);
170 if (pwrdm->state != prev)
171 pwrdm->state_counter[prev]++;
172 if (prev == PWRDM_POWER_RET)
173 _update_logic_membank_counters(pwrdm);
174
175
176
177
178 next = pwrdm_read_next_pwrst(pwrdm);
179 if (next != prev) {
180 trace_state = (PWRDM_TRACE_STATES_FLAG |
181 ((next & OMAP_POWERSTATE_MASK) << 8) |
182 ((prev & OMAP_POWERSTATE_MASK) << 0));
183 trace_power_domain_target(pwrdm->name, trace_state,
184 smp_processor_id());
185 }
186 break;
187 default:
188 return -EINVAL;
189 }
190
191 if (state != prev)
192 pwrdm->state_counter[state]++;
193
194 pm_dbg_update_time(pwrdm, prev);
195
196 pwrdm->state = state;
197
198 return 0;
199}
200
201static int _pwrdm_pre_transition_cb(struct powerdomain *pwrdm, void *unused)
202{
203 pwrdm_clear_all_prev_pwrst(pwrdm);
204 _pwrdm_state_switch(pwrdm, PWRDM_STATE_NOW);
205 return 0;
206}
207
208static int _pwrdm_post_transition_cb(struct powerdomain *pwrdm, void *unused)
209{
210 _pwrdm_state_switch(pwrdm, PWRDM_STATE_PREV);
211 return 0;
212}
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229static u8 _pwrdm_save_clkdm_state_and_activate(struct powerdomain *pwrdm,
230 u8 curr_pwrst, u8 pwrst,
231 bool *hwsup)
232{
233 u8 sleep_switch;
234
235 if (curr_pwrst < PWRDM_POWER_ON) {
236 if (curr_pwrst > pwrst &&
237 pwrdm->flags & PWRDM_HAS_LOWPOWERSTATECHANGE &&
238 arch_pwrdm->pwrdm_set_lowpwrstchange) {
239 sleep_switch = LOWPOWERSTATE_SWITCH;
240 } else {
241 *hwsup = clkdm_in_hwsup(pwrdm->pwrdm_clkdms[0]);
242 clkdm_wakeup_nolock(pwrdm->pwrdm_clkdms[0]);
243 sleep_switch = FORCEWAKEUP_SWITCH;
244 }
245 } else {
246 sleep_switch = ALREADYACTIVE_SWITCH;
247 }
248
249 return sleep_switch;
250}
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266static void _pwrdm_restore_clkdm_state(struct powerdomain *pwrdm,
267 u8 sleep_switch, bool hwsup)
268{
269 switch (sleep_switch) {
270 case FORCEWAKEUP_SWITCH:
271 if (hwsup)
272 clkdm_allow_idle_nolock(pwrdm->pwrdm_clkdms[0]);
273 else
274 clkdm_sleep_nolock(pwrdm->pwrdm_clkdms[0]);
275 break;
276 case LOWPOWERSTATE_SWITCH:
277 if (pwrdm->flags & PWRDM_HAS_LOWPOWERSTATECHANGE &&
278 arch_pwrdm->pwrdm_set_lowpwrstchange)
279 arch_pwrdm->pwrdm_set_lowpwrstchange(pwrdm);
280 pwrdm_state_switch_nolock(pwrdm);
281 break;
282 }
283}
284
285
286
287
288
289
290
291
292
293
294
295
296
297int pwrdm_register_platform_funcs(struct pwrdm_ops *po)
298{
299 if (!po)
300 return -EINVAL;
301
302 if (arch_pwrdm)
303 return -EEXIST;
304
305 arch_pwrdm = po;
306
307 return 0;
308}
309
310
311
312
313
314
315
316
317
318
319
320int pwrdm_register_pwrdms(struct powerdomain **ps)
321{
322 struct powerdomain **p = NULL;
323
324 if (!arch_pwrdm)
325 return -EEXIST;
326
327 if (!ps)
328 return -EINVAL;
329
330 for (p = ps; *p; p++)
331 _pwrdm_register(*p);
332
333 return 0;
334}
335
336
337
338
339
340
341
342
343
344
345
346
347int pwrdm_complete_init(void)
348{
349 struct powerdomain *temp_p;
350
351 if (list_empty(&pwrdm_list))
352 return -EACCES;
353
354 list_for_each_entry(temp_p, &pwrdm_list, node)
355 pwrdm_set_next_pwrst(temp_p, PWRDM_POWER_ON);
356
357 return 0;
358}
359
360
361
362
363
364
365
366void pwrdm_lock(struct powerdomain *pwrdm)
367 __acquires(&pwrdm->_lock)
368{
369 spin_lock_irqsave(&pwrdm->_lock, pwrdm->_lock_flags);
370}
371
372
373
374
375
376
377
378void pwrdm_unlock(struct powerdomain *pwrdm)
379 __releases(&pwrdm->_lock)
380{
381 spin_unlock_irqrestore(&pwrdm->_lock, pwrdm->_lock_flags);
382}
383
384
385
386
387
388
389
390
391struct powerdomain *pwrdm_lookup(const char *name)
392{
393 struct powerdomain *pwrdm;
394
395 if (!name)
396 return NULL;
397
398 pwrdm = _pwrdm_lookup(name);
399
400 return pwrdm;
401}
402
403
404
405
406
407
408
409
410
411
412
413int pwrdm_for_each(int (*fn)(struct powerdomain *pwrdm, void *user),
414 void *user)
415{
416 struct powerdomain *temp_pwrdm;
417 int ret = 0;
418
419 if (!fn)
420 return -EINVAL;
421
422 list_for_each_entry(temp_pwrdm, &pwrdm_list, node) {
423 ret = (*fn)(temp_pwrdm, user);
424 if (ret)
425 break;
426 }
427
428 return ret;
429}
430
431
432
433
434
435
436
437
438
439
440
441int pwrdm_add_clkdm(struct powerdomain *pwrdm, struct clockdomain *clkdm)
442{
443 int i;
444 int ret = -EINVAL;
445
446 if (!pwrdm || !clkdm)
447 return -EINVAL;
448
449 pr_debug("powerdomain: %s: associating clockdomain %s\n",
450 pwrdm->name, clkdm->name);
451
452 for (i = 0; i < PWRDM_MAX_CLKDMS; i++) {
453 if (!pwrdm->pwrdm_clkdms[i])
454 break;
455#ifdef DEBUG
456 if (pwrdm->pwrdm_clkdms[i] == clkdm) {
457 ret = -EINVAL;
458 goto pac_exit;
459 }
460#endif
461 }
462
463 if (i == PWRDM_MAX_CLKDMS) {
464 pr_debug("powerdomain: %s: increase PWRDM_MAX_CLKDMS for clkdm %s\n",
465 pwrdm->name, clkdm->name);
466 WARN_ON(1);
467 ret = -ENOMEM;
468 goto pac_exit;
469 }
470
471 pwrdm->pwrdm_clkdms[i] = clkdm;
472
473 ret = 0;
474
475pac_exit:
476 return ret;
477}
478
479
480
481
482
483
484
485
486
487
488
489int pwrdm_del_clkdm(struct powerdomain *pwrdm, struct clockdomain *clkdm)
490{
491 int ret = -EINVAL;
492 int i;
493
494 if (!pwrdm || !clkdm)
495 return -EINVAL;
496
497 pr_debug("powerdomain: %s: dissociating clockdomain %s\n",
498 pwrdm->name, clkdm->name);
499
500 for (i = 0; i < PWRDM_MAX_CLKDMS; i++)
501 if (pwrdm->pwrdm_clkdms[i] == clkdm)
502 break;
503
504 if (i == PWRDM_MAX_CLKDMS) {
505 pr_debug("powerdomain: %s: clkdm %s not associated?!\n",
506 pwrdm->name, clkdm->name);
507 ret = -ENOENT;
508 goto pdc_exit;
509 }
510
511 pwrdm->pwrdm_clkdms[i] = NULL;
512
513 ret = 0;
514
515pdc_exit:
516 return ret;
517}
518
519
520
521
522
523
524
525
526
527
528
529
530
531int pwrdm_for_each_clkdm(struct powerdomain *pwrdm,
532 int (*fn)(struct powerdomain *pwrdm,
533 struct clockdomain *clkdm))
534{
535 int ret = 0;
536 int i;
537
538 if (!fn)
539 return -EINVAL;
540
541 for (i = 0; i < PWRDM_MAX_CLKDMS && !ret; i++)
542 ret = (*fn)(pwrdm, pwrdm->pwrdm_clkdms[i]);
543
544 return ret;
545}
546
547
548
549
550
551
552
553
554struct voltagedomain *pwrdm_get_voltdm(struct powerdomain *pwrdm)
555{
556 return pwrdm->voltdm.ptr;
557}
558
559
560
561
562
563
564
565
566int pwrdm_get_mem_bank_count(struct powerdomain *pwrdm)
567{
568 if (!pwrdm)
569 return -EINVAL;
570
571 return pwrdm->banks;
572}
573
574
575
576
577
578
579
580
581
582
583
584
585int pwrdm_set_next_pwrst(struct powerdomain *pwrdm, u8 pwrst)
586{
587 int ret = -EINVAL;
588
589 if (!pwrdm)
590 return -EINVAL;
591
592 if (!(pwrdm->pwrsts & (1 << pwrst)))
593 return -EINVAL;
594
595 pr_debug("powerdomain: %s: setting next powerstate to %0x\n",
596 pwrdm->name, pwrst);
597
598 if (arch_pwrdm && arch_pwrdm->pwrdm_set_next_pwrst) {
599
600 trace_power_domain_target(pwrdm->name, pwrst,
601 smp_processor_id());
602
603 ret = arch_pwrdm->pwrdm_set_next_pwrst(pwrdm, pwrst);
604 }
605
606 return ret;
607}
608
609
610
611
612
613
614
615
616
617int pwrdm_read_next_pwrst(struct powerdomain *pwrdm)
618{
619 int ret = -EINVAL;
620
621 if (!pwrdm)
622 return -EINVAL;
623
624 if (arch_pwrdm && arch_pwrdm->pwrdm_read_next_pwrst)
625 ret = arch_pwrdm->pwrdm_read_next_pwrst(pwrdm);
626
627 return ret;
628}
629
630
631
632
633
634
635
636
637
638
639int pwrdm_read_pwrst(struct powerdomain *pwrdm)
640{
641 int ret = -EINVAL;
642
643 if (!pwrdm)
644 return -EINVAL;
645
646 if (pwrdm->pwrsts == PWRSTS_ON)
647 return PWRDM_POWER_ON;
648
649 if (arch_pwrdm && arch_pwrdm->pwrdm_read_pwrst)
650 ret = arch_pwrdm->pwrdm_read_pwrst(pwrdm);
651
652 return ret;
653}
654
655
656
657
658
659
660
661
662
663int pwrdm_read_prev_pwrst(struct powerdomain *pwrdm)
664{
665 int ret = -EINVAL;
666
667 if (!pwrdm)
668 return -EINVAL;
669
670 if (arch_pwrdm && arch_pwrdm->pwrdm_read_prev_pwrst)
671 ret = arch_pwrdm->pwrdm_read_prev_pwrst(pwrdm);
672
673 return ret;
674}
675
676
677
678
679
680
681
682
683
684
685
686
687int pwrdm_set_logic_retst(struct powerdomain *pwrdm, u8 pwrst)
688{
689 int ret = -EINVAL;
690
691 if (!pwrdm)
692 return -EINVAL;
693
694 if (!(pwrdm->pwrsts_logic_ret & (1 << pwrst)))
695 return -EINVAL;
696
697 pr_debug("powerdomain: %s: setting next logic powerstate to %0x\n",
698 pwrdm->name, pwrst);
699
700 if (arch_pwrdm && arch_pwrdm->pwrdm_set_logic_retst)
701 ret = arch_pwrdm->pwrdm_set_logic_retst(pwrdm, pwrst);
702
703 return ret;
704}
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721int pwrdm_set_mem_onst(struct powerdomain *pwrdm, u8 bank, u8 pwrst)
722{
723 int ret = -EINVAL;
724
725 if (!pwrdm)
726 return -EINVAL;
727
728 if (pwrdm->banks < (bank + 1))
729 return -EEXIST;
730
731 if (!(pwrdm->pwrsts_mem_on[bank] & (1 << pwrst)))
732 return -EINVAL;
733
734 pr_debug("powerdomain: %s: setting next memory powerstate for bank %0x while pwrdm-ON to %0x\n",
735 pwrdm->name, bank, pwrst);
736
737 if (arch_pwrdm && arch_pwrdm->pwrdm_set_mem_onst)
738 ret = arch_pwrdm->pwrdm_set_mem_onst(pwrdm, bank, pwrst);
739
740 return ret;
741}
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759int pwrdm_set_mem_retst(struct powerdomain *pwrdm, u8 bank, u8 pwrst)
760{
761 int ret = -EINVAL;
762
763 if (!pwrdm)
764 return -EINVAL;
765
766 if (pwrdm->banks < (bank + 1))
767 return -EEXIST;
768
769 if (!(pwrdm->pwrsts_mem_ret[bank] & (1 << pwrst)))
770 return -EINVAL;
771
772 pr_debug("powerdomain: %s: setting next memory powerstate for bank %0x while pwrdm-RET to %0x\n",
773 pwrdm->name, bank, pwrst);
774
775 if (arch_pwrdm && arch_pwrdm->pwrdm_set_mem_retst)
776 ret = arch_pwrdm->pwrdm_set_mem_retst(pwrdm, bank, pwrst);
777
778 return ret;
779}
780
781
782
783
784
785
786
787
788
789
790int pwrdm_read_logic_pwrst(struct powerdomain *pwrdm)
791{
792 int ret = -EINVAL;
793
794 if (!pwrdm)
795 return -EINVAL;
796
797 if (arch_pwrdm && arch_pwrdm->pwrdm_read_logic_pwrst)
798 ret = arch_pwrdm->pwrdm_read_logic_pwrst(pwrdm);
799
800 return ret;
801}
802
803
804
805
806
807
808
809
810
811int pwrdm_read_prev_logic_pwrst(struct powerdomain *pwrdm)
812{
813 int ret = -EINVAL;
814
815 if (!pwrdm)
816 return -EINVAL;
817
818 if (arch_pwrdm && arch_pwrdm->pwrdm_read_prev_logic_pwrst)
819 ret = arch_pwrdm->pwrdm_read_prev_logic_pwrst(pwrdm);
820
821 return ret;
822}
823
824
825
826
827
828
829
830
831
832int pwrdm_read_logic_retst(struct powerdomain *pwrdm)
833{
834 int ret = -EINVAL;
835
836 if (!pwrdm)
837 return -EINVAL;
838
839 if (arch_pwrdm && arch_pwrdm->pwrdm_read_logic_retst)
840 ret = arch_pwrdm->pwrdm_read_logic_retst(pwrdm);
841
842 return ret;
843}
844
845
846
847
848
849
850
851
852
853
854
855int pwrdm_read_mem_pwrst(struct powerdomain *pwrdm, u8 bank)
856{
857 int ret = -EINVAL;
858
859 if (!pwrdm)
860 return ret;
861
862 if (pwrdm->banks < (bank + 1))
863 return ret;
864
865 if (pwrdm->flags & PWRDM_HAS_MPU_QUIRK)
866 bank = 1;
867
868 if (arch_pwrdm && arch_pwrdm->pwrdm_read_mem_pwrst)
869 ret = arch_pwrdm->pwrdm_read_mem_pwrst(pwrdm, bank);
870
871 return ret;
872}
873
874
875
876
877
878
879
880
881
882
883
884
885int pwrdm_read_prev_mem_pwrst(struct powerdomain *pwrdm, u8 bank)
886{
887 int ret = -EINVAL;
888
889 if (!pwrdm)
890 return ret;
891
892 if (pwrdm->banks < (bank + 1))
893 return ret;
894
895 if (pwrdm->flags & PWRDM_HAS_MPU_QUIRK)
896 bank = 1;
897
898 if (arch_pwrdm && arch_pwrdm->pwrdm_read_prev_mem_pwrst)
899 ret = arch_pwrdm->pwrdm_read_prev_mem_pwrst(pwrdm, bank);
900
901 return ret;
902}
903
904
905
906
907
908
909
910
911
912
913
914int pwrdm_read_mem_retst(struct powerdomain *pwrdm, u8 bank)
915{
916 int ret = -EINVAL;
917
918 if (!pwrdm)
919 return ret;
920
921 if (pwrdm->banks < (bank + 1))
922 return ret;
923
924 if (arch_pwrdm && arch_pwrdm->pwrdm_read_mem_retst)
925 ret = arch_pwrdm->pwrdm_read_mem_retst(pwrdm, bank);
926
927 return ret;
928}
929
930
931
932
933
934
935
936
937
938
939int pwrdm_clear_all_prev_pwrst(struct powerdomain *pwrdm)
940{
941 int ret = -EINVAL;
942
943 if (!pwrdm)
944 return ret;
945
946
947
948
949
950
951 pr_debug("powerdomain: %s: clearing previous power state reg\n",
952 pwrdm->name);
953
954 if (arch_pwrdm && arch_pwrdm->pwrdm_clear_all_prev_pwrst)
955 ret = arch_pwrdm->pwrdm_clear_all_prev_pwrst(pwrdm);
956
957 return ret;
958}
959
960
961
962
963
964
965
966
967
968
969
970
971int pwrdm_enable_hdwr_sar(struct powerdomain *pwrdm)
972{
973 int ret = -EINVAL;
974
975 if (!pwrdm)
976 return ret;
977
978 if (!(pwrdm->flags & PWRDM_HAS_HDWR_SAR))
979 return ret;
980
981 pr_debug("powerdomain: %s: setting SAVEANDRESTORE bit\n", pwrdm->name);
982
983 if (arch_pwrdm && arch_pwrdm->pwrdm_enable_hdwr_sar)
984 ret = arch_pwrdm->pwrdm_enable_hdwr_sar(pwrdm);
985
986 return ret;
987}
988
989
990
991
992
993
994
995
996
997
998
999
1000int pwrdm_disable_hdwr_sar(struct powerdomain *pwrdm)
1001{
1002 int ret = -EINVAL;
1003
1004 if (!pwrdm)
1005 return ret;
1006
1007 if (!(pwrdm->flags & PWRDM_HAS_HDWR_SAR))
1008 return ret;
1009
1010 pr_debug("powerdomain: %s: clearing SAVEANDRESTORE bit\n", pwrdm->name);
1011
1012 if (arch_pwrdm && arch_pwrdm->pwrdm_disable_hdwr_sar)
1013 ret = arch_pwrdm->pwrdm_disable_hdwr_sar(pwrdm);
1014
1015 return ret;
1016}
1017
1018
1019
1020
1021
1022
1023
1024
1025bool pwrdm_has_hdwr_sar(struct powerdomain *pwrdm)
1026{
1027 return (pwrdm && pwrdm->flags & PWRDM_HAS_HDWR_SAR) ? 1 : 0;
1028}
1029
1030int pwrdm_state_switch_nolock(struct powerdomain *pwrdm)
1031{
1032 int ret;
1033
1034 if (!pwrdm || !arch_pwrdm)
1035 return -EINVAL;
1036
1037 ret = arch_pwrdm->pwrdm_wait_transition(pwrdm);
1038 if (!ret)
1039 ret = _pwrdm_state_switch(pwrdm, PWRDM_STATE_NOW);
1040
1041 return ret;
1042}
1043
1044int __deprecated pwrdm_state_switch(struct powerdomain *pwrdm)
1045{
1046 int ret;
1047
1048 pwrdm_lock(pwrdm);
1049 ret = pwrdm_state_switch_nolock(pwrdm);
1050 pwrdm_unlock(pwrdm);
1051
1052 return ret;
1053}
1054
1055int pwrdm_pre_transition(struct powerdomain *pwrdm)
1056{
1057 if (pwrdm)
1058 _pwrdm_pre_transition_cb(pwrdm, NULL);
1059 else
1060 pwrdm_for_each(_pwrdm_pre_transition_cb, NULL);
1061
1062 return 0;
1063}
1064
1065int pwrdm_post_transition(struct powerdomain *pwrdm)
1066{
1067 if (pwrdm)
1068 _pwrdm_post_transition_cb(pwrdm, NULL);
1069 else
1070 pwrdm_for_each(_pwrdm_post_transition_cb, NULL);
1071
1072 return 0;
1073}
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088int omap_set_pwrdm_state(struct powerdomain *pwrdm, u8 pwrst)
1089{
1090 u8 next_pwrst, sleep_switch;
1091 int curr_pwrst;
1092 int ret = 0;
1093 bool hwsup = false;
1094
1095 if (!pwrdm || IS_ERR(pwrdm))
1096 return -EINVAL;
1097
1098 while (!(pwrdm->pwrsts & (1 << pwrst))) {
1099 if (pwrst == PWRDM_POWER_OFF)
1100 return ret;
1101 pwrst--;
1102 }
1103
1104 pwrdm_lock(pwrdm);
1105
1106 curr_pwrst = pwrdm_read_pwrst(pwrdm);
1107 if (curr_pwrst < 0) {
1108 ret = -EINVAL;
1109 goto osps_out;
1110 }
1111
1112 next_pwrst = pwrdm_read_next_pwrst(pwrdm);
1113 if (curr_pwrst == pwrst && next_pwrst == pwrst)
1114 goto osps_out;
1115
1116 sleep_switch = _pwrdm_save_clkdm_state_and_activate(pwrdm, curr_pwrst,
1117 pwrst, &hwsup);
1118
1119 ret = pwrdm_set_next_pwrst(pwrdm, pwrst);
1120 if (ret)
1121 pr_err("%s: unable to set power state of powerdomain: %s\n",
1122 __func__, pwrdm->name);
1123
1124 _pwrdm_restore_clkdm_state(pwrdm, sleep_switch, hwsup);
1125
1126osps_out:
1127 pwrdm_unlock(pwrdm);
1128
1129 return ret;
1130}
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140int pwrdm_get_context_loss_count(struct powerdomain *pwrdm)
1141{
1142 int i, count;
1143
1144 if (!pwrdm) {
1145 WARN(1, "powerdomain: %s: pwrdm is null\n", __func__);
1146 return -ENODEV;
1147 }
1148
1149 count = pwrdm->state_counter[PWRDM_POWER_OFF];
1150 count += pwrdm->ret_logic_off_counter;
1151
1152 for (i = 0; i < pwrdm->banks; i++)
1153 count += pwrdm->ret_mem_off_counter[i];
1154
1155
1156
1157
1158
1159 count &= INT_MAX;
1160
1161 pr_debug("powerdomain: %s: context loss count = %d\n",
1162 pwrdm->name, count);
1163
1164 return count;
1165}
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179bool pwrdm_can_ever_lose_context(struct powerdomain *pwrdm)
1180{
1181 int i;
1182
1183 if (!pwrdm) {
1184 pr_debug("powerdomain: %s: invalid powerdomain pointer\n",
1185 __func__);
1186 return 1;
1187 }
1188
1189 if (pwrdm->pwrsts & PWRSTS_OFF)
1190 return 1;
1191
1192 if (pwrdm->pwrsts & PWRSTS_RET) {
1193 if (pwrdm->pwrsts_logic_ret & PWRSTS_OFF)
1194 return 1;
1195
1196 for (i = 0; i < pwrdm->banks; i++)
1197 if (pwrdm->pwrsts_mem_ret[i] & PWRSTS_OFF)
1198 return 1;
1199 }
1200
1201 for (i = 0; i < pwrdm->banks; i++)
1202 if (pwrdm->pwrsts_mem_on[i] & PWRSTS_OFF)
1203 return 1;
1204
1205 return 0;
1206}
1207