~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm/mach-omap2/powerdomain.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 skip_voltdm:
119         spin_lock_init(&pwrdm->_lock);
120 
121         list_add(&pwrdm->node, &pwrdm_list);
122 
123         /* Initialize the powerdomain's state counter */
124         for (i = 0; i < PWRDM_MAX_PWRSTS; i++)
125                 pwrdm->state_counter[i] = 0;
126 
127         pwrdm->ret_logic_off_counter = 0;
128         for (i = 0; i < pwrdm->banks; i++)
129                 pwrdm->ret_mem_off_counter[i] = 0;
130 
131         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 
141 static 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 
160 static 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 
207 static 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 
214 static 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  */
235 static 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  */
272 static 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  */
303 int 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  */
326 int 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  */
353 int 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  */
372 void 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  */
384 void 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  */
397 struct 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  */
419 int 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  */
447 int 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 
481 pac_exit:
482         return ret;
483 }
484 
485 /**
486  * pwrdm_get_mem_bank_count - get number of memory banks in this powerdomain
487  * @pwrdm: struct powerdomain *
488  *
489  * Return the number of controllable memory banks in powerdomain @pwrdm,
490  * starting with 1.  Returns -EINVAL if the powerdomain pointer is null.
491  */
492 int pwrdm_get_mem_bank_count(struct powerdomain *pwrdm)
493 {
494         if (!pwrdm)
495                 return -EINVAL;
496 
497         return pwrdm->banks;
498 }
499 
500 /**
501  * pwrdm_set_next_pwrst - set next powerdomain power state
502  * @pwrdm: struct powerdomain * to set
503  * @pwrst: one of the PWRDM_POWER_* macros
504  *
505  * Set the powerdomain @pwrdm's next power state to @pwrst.  The powerdomain
506  * may not enter this state immediately if the preconditions for this state
507  * have not been satisfied.  Returns -EINVAL if the powerdomain pointer is
508  * null or if the power state is invalid for the powerdomin, or returns 0
509  * upon success.
510  */
511 int pwrdm_set_next_pwrst(struct powerdomain *pwrdm, u8 pwrst)
512 {
513         int ret = -EINVAL;
514 
515         if (!pwrdm)
516                 return -EINVAL;
517 
518         if (!(pwrdm->pwrsts & (1 << pwrst)))
519                 return -EINVAL;
520 
521         pr_debug("powerdomain: %s: setting next powerstate to %0x\n",
522                  pwrdm->name, pwrst);
523 
524         if (arch_pwrdm && arch_pwrdm->pwrdm_set_next_pwrst) {
525                 /* Trace the pwrdm desired target state */
526                 trace_power_domain_target(pwrdm->name, pwrst,
527                                           smp_processor_id());
528                 /* Program the pwrdm desired target state */
529                 ret = arch_pwrdm->pwrdm_set_next_pwrst(pwrdm, pwrst);
530         }
531 
532         return ret;
533 }
534 
535 /**
536  * pwrdm_read_next_pwrst - get next powerdomain power state
537  * @pwrdm: struct powerdomain * to get power state
538  *
539  * Return the powerdomain @pwrdm's next power state.  Returns -EINVAL
540  * if the powerdomain pointer is null or returns the next power state
541  * upon success.
542  */
543 int pwrdm_read_next_pwrst(struct powerdomain *pwrdm)
544 {
545         int ret = -EINVAL;
546 
547         if (!pwrdm)
548                 return -EINVAL;
549 
550         if (arch_pwrdm && arch_pwrdm->pwrdm_read_next_pwrst)
551                 ret = arch_pwrdm->pwrdm_read_next_pwrst(pwrdm);
552 
553         return ret;
554 }
555 
556 /**
557  * pwrdm_read_pwrst - get current powerdomain power state
558  * @pwrdm: struct powerdomain * to get power state
559  *
560  * Return the powerdomain @pwrdm's current power state. Returns -EINVAL
561  * if the powerdomain pointer is null or returns the current power state
562  * upon success. Note that if the power domain only supports the ON state
563  * then just return ON as the current state.
564  */
565 int pwrdm_read_pwrst(struct powerdomain *pwrdm)
566 {
567         int ret = -EINVAL;
568 
569         if (!pwrdm)
570                 return -EINVAL;
571 
572         if (pwrdm->pwrsts == PWRSTS_ON)
573                 return PWRDM_POWER_ON;
574 
575         if (arch_pwrdm && arch_pwrdm->pwrdm_read_pwrst)
576                 ret = arch_pwrdm->pwrdm_read_pwrst(pwrdm);
577 
578         return ret;
579 }
580 
581 /**
582  * pwrdm_read_prev_pwrst - get previous powerdomain power state
583  * @pwrdm: struct powerdomain * to get previous power state
584  *
585  * Return the powerdomain @pwrdm's previous power state.  Returns -EINVAL
586  * if the powerdomain pointer is null or returns the previous power state
587  * upon success.
588  */
589 int pwrdm_read_prev_pwrst(struct powerdomain *pwrdm)
590 {
591         int ret = -EINVAL;
592 
593         if (!pwrdm)
594                 return -EINVAL;
595 
596         if (arch_pwrdm && arch_pwrdm->pwrdm_read_prev_pwrst)
597                 ret = arch_pwrdm->pwrdm_read_prev_pwrst(pwrdm);
598 
599         return ret;
600 }
601 
602 /**
603  * pwrdm_set_logic_retst - set powerdomain logic power state upon retention
604  * @pwrdm: struct powerdomain * to set
605  * @pwrst: one of the PWRDM_POWER_* macros
606  *
607  * Set the next power state @pwrst that the logic portion of the
608  * powerdomain @pwrdm will enter when the powerdomain enters retention.
609  * This will be either RETENTION or OFF, if supported.  Returns
610  * -EINVAL if the powerdomain pointer is null or the target power
611  * state is not not supported, or returns 0 upon success.
612  */
613 int pwrdm_set_logic_retst(struct powerdomain *pwrdm, u8 pwrst)
614 {
615         int ret = -EINVAL;
616 
617         if (!pwrdm)
618                 return -EINVAL;
619 
620         if (!(pwrdm->pwrsts_logic_ret & (1 << pwrst)))
621                 return -EINVAL;
622 
623         pr_debug("powerdomain: %s: setting next logic powerstate to %0x\n",
624                  pwrdm->name, pwrst);
625 
626         if (arch_pwrdm && arch_pwrdm->pwrdm_set_logic_retst)
627                 ret = arch_pwrdm->pwrdm_set_logic_retst(pwrdm, pwrst);
628 
629         return ret;
630 }
631 
632 /**
633  * pwrdm_set_mem_onst - set memory power state while powerdomain ON
634  * @pwrdm: struct powerdomain * to set
635  * @bank: memory bank number to set (0-3)
636  * @pwrst: one of the PWRDM_POWER_* macros
637  *
638  * Set the next power state @pwrst that memory bank @bank of the
639  * powerdomain @pwrdm will enter when the powerdomain enters the ON
640  * state.  @bank will be a number from 0 to 3, and represents different
641  * types of memory, depending on the powerdomain.  Returns -EINVAL if
642  * the powerdomain pointer is null or the target power state is not
643  * not supported for this memory bank, -EEXIST if the target memory
644  * bank does not exist or is not controllable, or returns 0 upon
645  * success.
646  */
647 int pwrdm_set_mem_onst(struct powerdomain *pwrdm, u8 bank, u8 pwrst)
648 {
649         int ret = -EINVAL;
650 
651         if (!pwrdm)
652                 return -EINVAL;
653 
654         if (pwrdm->banks < (bank + 1))
655                 return -EEXIST;
656 
657         if (!(pwrdm->pwrsts_mem_on[bank] & (1 << pwrst)))
658                 return -EINVAL;
659 
660         pr_debug("powerdomain: %s: setting next memory powerstate for bank %0x while pwrdm-ON to %0x\n",
661                  pwrdm->name, bank, pwrst);
662 
663         if (arch_pwrdm && arch_pwrdm->pwrdm_set_mem_onst)
664                 ret = arch_pwrdm->pwrdm_set_mem_onst(pwrdm, bank, pwrst);
665 
666         return ret;
667 }
668 
669 /**
670  * pwrdm_set_mem_retst - set memory power state while powerdomain in RET
671  * @pwrdm: struct powerdomain * to set
672  * @bank: memory bank number to set (0-3)
673  * @pwrst: one of the PWRDM_POWER_* macros
674  *
675  * Set the next power state @pwrst that memory bank @bank of the
676  * powerdomain @pwrdm will enter when the powerdomain enters the
677  * RETENTION state.  Bank will be a number from 0 to 3, and represents
678  * different types of memory, depending on the powerdomain.  @pwrst
679  * will be either RETENTION or OFF, if supported.  Returns -EINVAL if
680  * the powerdomain pointer is null or the target power state is not
681  * not supported for this memory bank, -EEXIST if the target memory
682  * bank does not exist or is not controllable, or returns 0 upon
683  * success.
684  */
685 int pwrdm_set_mem_retst(struct powerdomain *pwrdm, u8 bank, u8 pwrst)
686 {
687         int ret = -EINVAL;
688 
689         if (!pwrdm)
690                 return -EINVAL;
691 
692         if (pwrdm->banks < (bank + 1))
693                 return -EEXIST;
694 
695         if (!(pwrdm->pwrsts_mem_ret[bank] & (1 << pwrst)))
696                 return -EINVAL;
697 
698         pr_debug("powerdomain: %s: setting next memory powerstate for bank %0x while pwrdm-RET to %0x\n",
699                  pwrdm->name, bank, pwrst);
700 
701         if (arch_pwrdm && arch_pwrdm->pwrdm_set_mem_retst)
702                 ret = arch_pwrdm->pwrdm_set_mem_retst(pwrdm, bank, pwrst);
703 
704         return ret;
705 }
706 
707 /**
708  * pwrdm_read_logic_pwrst - get current powerdomain logic retention power state
709  * @pwrdm: struct powerdomain * to get current logic retention power state
710  *
711  * Return the power state that the logic portion of powerdomain @pwrdm
712  * will enter when the powerdomain enters retention.  Returns -EINVAL
713  * if the powerdomain pointer is null or returns the logic retention
714  * power state upon success.
715  */
716 int pwrdm_read_logic_pwrst(struct powerdomain *pwrdm)
717 {
718         int ret = -EINVAL;
719 
720         if (!pwrdm)
721                 return -EINVAL;
722 
723         if (arch_pwrdm && arch_pwrdm->pwrdm_read_logic_pwrst)
724                 ret = arch_pwrdm->pwrdm_read_logic_pwrst(pwrdm);
725 
726         return ret;
727 }
728 
729 /**
730  * pwrdm_read_prev_logic_pwrst - get previous powerdomain logic power state
731  * @pwrdm: struct powerdomain * to get previous logic power state
732  *
733  * Return the powerdomain @pwrdm's previous logic power state.  Returns
734  * -EINVAL if the powerdomain pointer is null or returns the previous
735  * logic power state upon success.
736  */
737 int pwrdm_read_prev_logic_pwrst(struct powerdomain *pwrdm)
738 {
739         int ret = -EINVAL;
740 
741         if (!pwrdm)
742                 return -EINVAL;
743 
744         if (arch_pwrdm && arch_pwrdm->pwrdm_read_prev_logic_pwrst)
745                 ret = arch_pwrdm->pwrdm_read_prev_logic_pwrst(pwrdm);
746 
747         return ret;
748 }
749 
750 /**
751  * pwrdm_read_logic_retst - get next powerdomain logic power state
752  * @pwrdm: struct powerdomain * to get next logic power state
753  *
754  * Return the powerdomain pwrdm's logic power state.  Returns -EINVAL
755  * if the powerdomain pointer is null or returns the next logic
756  * power state upon success.
757  */
758 int pwrdm_read_logic_retst(struct powerdomain *pwrdm)
759 {
760         int ret = -EINVAL;
761 
762         if (!pwrdm)
763                 return -EINVAL;
764 
765         if (arch_pwrdm && arch_pwrdm->pwrdm_read_logic_retst)
766                 ret = arch_pwrdm->pwrdm_read_logic_retst(pwrdm);
767 
768         return ret;
769 }
770 
771 /**
772  * pwrdm_read_mem_pwrst - get current memory bank power state
773  * @pwrdm: struct powerdomain * to get current memory bank power state
774  * @bank: memory bank number (0-3)
775  *
776  * Return the powerdomain @pwrdm's current memory power state for bank
777  * @bank.  Returns -EINVAL if the powerdomain pointer is null, -EEXIST if
778  * the target memory bank does not exist or is not controllable, or
779  * returns the current memory power state upon success.
780  */
781 int pwrdm_read_mem_pwrst(struct powerdomain *pwrdm, u8 bank)
782 {
783         int ret = -EINVAL;
784 
785         if (!pwrdm)
786                 return ret;
787 
788         if (pwrdm->banks < (bank + 1))
789                 return ret;
790 
791         if (pwrdm->flags & PWRDM_HAS_MPU_QUIRK)
792                 bank = 1;
793 
794         if (arch_pwrdm && arch_pwrdm->pwrdm_read_mem_pwrst)
795                 ret = arch_pwrdm->pwrdm_read_mem_pwrst(pwrdm, bank);
796 
797         return ret;
798 }
799 
800 /**
801  * pwrdm_read_prev_mem_pwrst - get previous memory bank power state
802  * @pwrdm: struct powerdomain * to get previous memory bank power state
803  * @bank: memory bank number (0-3)
804  *
805  * Return the powerdomain @pwrdm's previous memory power state for
806  * bank @bank.  Returns -EINVAL if the powerdomain pointer is null,
807  * -EEXIST if the target memory bank does not exist or is not
808  * controllable, or returns the previous memory power state upon
809  * success.
810  */
811 int pwrdm_read_prev_mem_pwrst(struct powerdomain *pwrdm, u8 bank)
812 {
813         int ret = -EINVAL;
814 
815         if (!pwrdm)
816                 return ret;
817 
818         if (pwrdm->banks < (bank + 1))
819                 return ret;
820 
821         if (pwrdm->flags & PWRDM_HAS_MPU_QUIRK)
822                 bank = 1;
823 
824         if (arch_pwrdm && arch_pwrdm->pwrdm_read_prev_mem_pwrst)
825                 ret = arch_pwrdm->pwrdm_read_prev_mem_pwrst(pwrdm, bank);
826 
827         return ret;
828 }
829 
830 /**
831  * pwrdm_read_mem_retst - get next memory bank power state
832  * @pwrdm: struct powerdomain * to get mext memory bank power state
833  * @bank: memory bank number (0-3)
834  *
835  * Return the powerdomain pwrdm's next memory power state for bank
836  * x.  Returns -EINVAL if the powerdomain pointer is null, -EEXIST if
837  * the target memory bank does not exist or is not controllable, or
838  * returns the next memory power state upon success.
839  */
840 int pwrdm_read_mem_retst(struct powerdomain *pwrdm, u8 bank)
841 {
842         int ret = -EINVAL;
843 
844         if (!pwrdm)
845                 return ret;
846 
847         if (pwrdm->banks < (bank + 1))
848                 return ret;
849 
850         if (arch_pwrdm && arch_pwrdm->pwrdm_read_mem_retst)
851                 ret = arch_pwrdm->pwrdm_read_mem_retst(pwrdm, bank);
852 
853         return ret;
854 }
855 
856 /**
857  * pwrdm_clear_all_prev_pwrst - clear previous powerstate register for a pwrdm
858  * @pwrdm: struct powerdomain * to clear
859  *
860  * Clear the powerdomain's previous power state register @pwrdm.
861  * Clears the entire register, including logic and memory bank
862  * previous power states.  Returns -EINVAL if the powerdomain pointer
863  * is null, or returns 0 upon success.
864  */
865 int pwrdm_clear_all_prev_pwrst(struct powerdomain *pwrdm)
866 {
867         int ret = -EINVAL;
868 
869         if (!pwrdm)
870                 return ret;
871 
872         /*
873          * XXX should get the powerdomain's current state here;
874          * warn & fail if it is not ON.
875          */
876 
877         pr_debug("powerdomain: %s: clearing previous power state reg\n",
878                  pwrdm->name);
879 
880         if (arch_pwrdm && arch_pwrdm->pwrdm_clear_all_prev_pwrst)
881                 ret = arch_pwrdm->pwrdm_clear_all_prev_pwrst(pwrdm);
882 
883         return ret;
884 }
885 
886 /**
887  * pwrdm_enable_hdwr_sar - enable automatic hardware SAR for a pwrdm
888  * @pwrdm: struct powerdomain *
889  *
890  * Enable automatic context save-and-restore upon power state change
891  * for some devices in the powerdomain @pwrdm.  Warning: this only
892  * affects a subset of devices in a powerdomain; check the TRM
893  * closely.  Returns -EINVAL if the powerdomain pointer is null or if
894  * the powerdomain does not support automatic save-and-restore, or
895  * returns 0 upon success.
896  */
897 int pwrdm_enable_hdwr_sar(struct powerdomain *pwrdm)
898 {
899         int ret = -EINVAL;
900 
901         if (!pwrdm)
902                 return ret;
903 
904         if (!(pwrdm->flags & PWRDM_HAS_HDWR_SAR))
905                 return ret;
906 
907         pr_debug("powerdomain: %s: setting SAVEANDRESTORE bit\n", pwrdm->name);
908 
909         if (arch_pwrdm && arch_pwrdm->pwrdm_enable_hdwr_sar)
910                 ret = arch_pwrdm->pwrdm_enable_hdwr_sar(pwrdm);
911 
912         return ret;
913 }
914 
915 /**
916  * pwrdm_disable_hdwr_sar - disable automatic hardware SAR for a pwrdm
917  * @pwrdm: struct powerdomain *
918  *
919  * Disable automatic context save-and-restore upon power state change
920  * for some devices in the powerdomain @pwrdm.  Warning: this only
921  * affects a subset of devices in a powerdomain; check the TRM
922  * closely.  Returns -EINVAL if the powerdomain pointer is null or if
923  * the powerdomain does not support automatic save-and-restore, or
924  * returns 0 upon success.
925  */
926 int pwrdm_disable_hdwr_sar(struct powerdomain *pwrdm)
927 {
928         int ret = -EINVAL;
929 
930         if (!pwrdm)
931                 return ret;
932 
933         if (!(pwrdm->flags & PWRDM_HAS_HDWR_SAR))
934                 return ret;
935 
936         pr_debug("powerdomain: %s: clearing SAVEANDRESTORE bit\n", pwrdm->name);
937 
938         if (arch_pwrdm && arch_pwrdm->pwrdm_disable_hdwr_sar)
939                 ret = arch_pwrdm->pwrdm_disable_hdwr_sar(pwrdm);
940 
941         return ret;
942 }
943 
944 /**
945  * pwrdm_has_hdwr_sar - test whether powerdomain supports hardware SAR
946  * @pwrdm: struct powerdomain *
947  *
948  * Returns 1 if powerdomain @pwrdm supports hardware save-and-restore
949  * for some devices, or 0 if it does not.
950  */
951 bool pwrdm_has_hdwr_sar(struct powerdomain *pwrdm)
952 {
953         return (pwrdm && pwrdm->flags & PWRDM_HAS_HDWR_SAR) ? 1 : 0;
954 }
955 
956 int pwrdm_state_switch_nolock(struct powerdomain *pwrdm)
957 {
958         int ret;
959 
960         if (!pwrdm || !arch_pwrdm)
961                 return -EINVAL;
962 
963         ret = arch_pwrdm->pwrdm_wait_transition(pwrdm);
964         if (!ret)
965                 ret = _pwrdm_state_switch(pwrdm, PWRDM_STATE_NOW);
966 
967         return ret;
968 }
969 
970 int __deprecated pwrdm_state_switch(struct powerdomain *pwrdm)
971 {
972         int ret;
973 
974         pwrdm_lock(pwrdm);
975         ret = pwrdm_state_switch_nolock(pwrdm);
976         pwrdm_unlock(pwrdm);
977 
978         return ret;
979 }
980 
981 int pwrdm_pre_transition(struct powerdomain *pwrdm)
982 {
983         if (pwrdm)
984                 _pwrdm_pre_transition_cb(pwrdm, NULL);
985         else
986                 pwrdm_for_each(_pwrdm_pre_transition_cb, NULL);
987 
988         return 0;
989 }
990 
991 int pwrdm_post_transition(struct powerdomain *pwrdm)
992 {
993         if (pwrdm)
994                 _pwrdm_post_transition_cb(pwrdm, NULL);
995         else
996                 pwrdm_for_each(_pwrdm_post_transition_cb, NULL);
997 
998         return 0;
999 }
1000 
1001 /**
1002  * pwrdm_get_valid_lp_state() - Find best match deep power state
1003  * @pwrdm:      power domain for which we want to find best match
1004  * @is_logic_state: Are we looking for logic state match here? Should
1005  *                  be one of PWRDM_xxx macro values
1006  * @req_state:  requested power state
1007  *
1008  * Returns: closest match for requested power state. default fallback
1009  * is RET for logic state and ON for power state.
1010  *
1011  * This does a search from the power domain data looking for the
1012  * closest valid power domain state that the hardware can achieve.
1013  * PRCM definitions for PWRSTCTRL allows us to program whatever
1014  * configuration we'd like, and PRCM will actually attempt such
1015  * a transition, however if the powerdomain does not actually support it,
1016  * we endup with a hung system. The valid power domain states are already
1017  * available in our powerdomain data files. So this function tries to do
1018  * the following:
1019  * a) find if we have an exact match to the request - no issues.
1020  * b) else find if a deeper power state is possible.
1021  * c) failing which, it tries to find closest higher power state for the
1022  * request.
1023  */
1024 u8 pwrdm_get_valid_lp_state(struct powerdomain *pwrdm,
1025                             bool is_logic_state, u8 req_state)
1026 {
1027         u8 pwrdm_states = is_logic_state ? pwrdm->pwrsts_logic_ret :
1028                         pwrdm->pwrsts;
1029         /* For logic, ret is highest and others, ON is highest */
1030         u8 default_pwrst = is_logic_state ? PWRDM_POWER_RET : PWRDM_POWER_ON;
1031         u8 new_pwrst;
1032         bool found;
1033 
1034         /* If it is already supported, nothing to search */
1035         if (pwrdm_states & BIT(req_state))
1036                 return req_state;
1037 
1038         if (!req_state)
1039                 goto up_search;
1040 
1041         /*
1042          * So, we dont have a exact match
1043          * Can we get a deeper power state match?
1044          */
1045         new_pwrst = req_state - 1;
1046         found = true;
1047         while (!(pwrdm_states & BIT(new_pwrst))) {
1048                 /* No match even at OFF? Not available */
1049                 if (new_pwrst == PWRDM_POWER_OFF) {
1050                         found = false;
1051                         break;
1052                 }
1053                 new_pwrst--;
1054         }
1055 
1056         if (found)
1057                 goto done;
1058 
1059 up_search:
1060         /* OK, no deeper ones, can we get a higher match? */
1061         new_pwrst = req_state + 1;
1062         while (!(pwrdm_states & BIT(new_pwrst))) {
1063                 if (new_pwrst > PWRDM_POWER_ON) {
1064                         WARN(1, "powerdomain: %s: Fix max powerstate to ON\n",
1065                              pwrdm->name);
1066                         return PWRDM_POWER_ON;
1067                 }
1068 
1069                 if (new_pwrst == default_pwrst)
1070                         break;
1071                 new_pwrst++;
1072         }
1073 done:
1074         return new_pwrst;
1075 }
1076 
1077 /**
1078  * omap_set_pwrdm_state - change a powerdomain's current power state
1079  * @pwrdm: struct powerdomain * to change the power state of
1080  * @pwrst: power state to change to
1081  *
1082  * Change the current hardware power state of the powerdomain
1083  * represented by @pwrdm to the power state represented by @pwrst.
1084  * Returns -EINVAL if @pwrdm is null or invalid or if the
1085  * powerdomain's current power state could not be read, or returns 0
1086  * upon success or if @pwrdm does not support @pwrst or any
1087  * lower-power state.  XXX Should not return 0 if the @pwrdm does not
1088  * support @pwrst or any lower-power state: this should be an error.
1089  */
1090 int omap_set_pwrdm_state(struct powerdomain *pwrdm, u8 pwrst)
1091 {
1092         u8 next_pwrst, sleep_switch;
1093         int curr_pwrst;
1094         int ret = 0;
1095         bool hwsup = false;
1096 
1097         if (!pwrdm || IS_ERR(pwrdm))
1098                 return -EINVAL;
1099 
1100         while (!(pwrdm->pwrsts & (1 << pwrst))) {
1101                 if (pwrst == PWRDM_POWER_OFF)
1102                         return ret;
1103                 pwrst--;
1104         }
1105 
1106         pwrdm_lock(pwrdm);
1107 
1108         curr_pwrst = pwrdm_read_pwrst(pwrdm);
1109         if (curr_pwrst < 0) {
1110                 ret = -EINVAL;
1111                 goto osps_out;
1112         }
1113 
1114         next_pwrst = pwrdm_read_next_pwrst(pwrdm);
1115         if (curr_pwrst == pwrst && next_pwrst == pwrst)
1116                 goto osps_out;
1117 
1118         sleep_switch = _pwrdm_save_clkdm_state_and_activate(pwrdm, curr_pwrst,
1119                                                             pwrst, &hwsup);
1120 
1121         ret = pwrdm_set_next_pwrst(pwrdm, pwrst);
1122         if (ret)
1123                 pr_err("%s: unable to set power state of powerdomain: %s\n",
1124                        __func__, pwrdm->name);
1125 
1126         _pwrdm_restore_clkdm_state(pwrdm, sleep_switch, hwsup);
1127 
1128 osps_out:
1129         pwrdm_unlock(pwrdm);
1130 
1131         return ret;
1132 }
1133 
1134 /**
1135  * pwrdm_get_context_loss_count - get powerdomain's context loss count
1136  * @pwrdm: struct powerdomain * to wait for
1137  *
1138  * Context loss count is the sum of powerdomain off-mode counter, the
1139  * logic off counter and the per-bank memory off counter.  Returns negative
1140  * (and WARNs) upon error, otherwise, returns the context loss count.
1141  */
1142 int pwrdm_get_context_loss_count(struct powerdomain *pwrdm)
1143 {
1144         int i, count;
1145 
1146         if (!pwrdm) {
1147                 WARN(1, "powerdomain: %s: pwrdm is null\n", __func__);
1148                 return -ENODEV;
1149         }
1150 
1151         count = pwrdm->state_counter[PWRDM_POWER_OFF];
1152         count += pwrdm->ret_logic_off_counter;
1153 
1154         for (i = 0; i < pwrdm->banks; i++)
1155                 count += pwrdm->ret_mem_off_counter[i];
1156 
1157         /*
1158          * Context loss count has to be a non-negative value. Clear the sign
1159          * bit to get a value range from 0 to INT_MAX.
1160          */
1161         count &= INT_MAX;
1162 
1163         pr_debug("powerdomain: %s: context loss count = %d\n",
1164                  pwrdm->name, count);
1165 
1166         return count;
1167 }
1168 
1169 /**
1170  * pwrdm_can_ever_lose_context - can this powerdomain ever lose context?
1171  * @pwrdm: struct powerdomain *
1172  *
1173  * Given a struct powerdomain * @pwrdm, returns 1 if the powerdomain
1174  * can lose either memory or logic context or if @pwrdm is invalid, or
1175  * returns 0 otherwise.  This function is not concerned with how the
1176  * powerdomain registers are programmed (i.e., to go off or not); it's
1177  * concerned with whether it's ever possible for this powerdomain to
1178  * go off while some other part of the chip is active.  This function
1179  * assumes that every powerdomain can go to either ON or INACTIVE.
1180  */
1181 bool pwrdm_can_ever_lose_context(struct powerdomain *pwrdm)
1182 {
1183         int i;
1184 
1185         if (!pwrdm) {
1186                 pr_debug("powerdomain: %s: invalid powerdomain pointer\n",
1187                          __func__);
1188                 return 1;
1189         }
1190 
1191         if (pwrdm->pwrsts & PWRSTS_OFF)
1192                 return 1;
1193 
1194         if (pwrdm->pwrsts & PWRSTS_RET) {
1195                 if (pwrdm->pwrsts_logic_ret & PWRSTS_OFF)
1196                         return 1;
1197 
1198                 for (i = 0; i < pwrdm->banks; i++)
1199                         if (pwrdm->pwrsts_mem_ret[i] & PWRSTS_OFF)
1200                                 return 1;
1201         }
1202 
1203         for (i = 0; i < pwrdm->banks; i++)
1204                 if (pwrdm->pwrsts_mem_on[i] & PWRSTS_OFF)
1205                         return 1;
1206 
1207         return 0;
1208 }
1209 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp