ARM: OMAP2+: powerdomain/PM: convert to functional power states

From: Jean Pihet <[email protected]>

Introduce the functional states for power domains, which include the power states and the logic states.
This patch provides the API functions to set and read the power domains functional state and internal functions to convert between the functional (i.e. logical) and the internal (or registers) values.

In the new API only the functions pwrdm_set_next_fpwrst() and pwrdm_set_fpwrst() shall be used to change a power domain target state, along with the associated PWRDM_FUNC_* macros as the state parameters.

Note about the power domains allowed states:
Power domains have varied capabilities, as defined by the value of the pwrsts and pwrsts_logic_ret fields of the powerdomain struct. When reading or setting a low power state such as OFF/RET, a specific requested state may not be supported on the given power domain. In the states conversion functions a power or logic state is first looked for in the lower power states in order to maximize the power savings, then if not found in the higher power states. An iteration function is used, as suggested by Rajendra Nayak <[email protected]> This function is temporary and will be removed later in the series.

This functionality brings consistency in the functional power states core code and acts as a guard against hardware implementations discrepancies, e.g. some power domains only support the RET logic state although reading the logic state registers (previous, current and next) always returns OFF. The DSS power domain on OMAP3 is an example.

Signed-off-by Jean Pihet <[email protected]>

Cc Tero Kristo <[email protected]>

Cc Rajendra Nayak <[email protected]>

Cc Nishanth Menon <[email protected]>

[paul at pwsan.com: add offset for functional powerstates so it's not
possible to confuse them with the old API; use one fn to convert func pwrsts to low-level hardware bits; skip hardware reads when hardware logic retst and logic pwrst bits are missing; fix kerneldoc and commit message; remove unnecessary PWRDM_LOGIC_MEM_PWRST_* macros; combine spinlock patch into this patch; expand the number of operations which take the spinlock]

Signed-off-by Paul Walmsley <[email protected]>

---
 arch/arm/mach-omap2/powerdomain.c |  525
+++++++++++++++++++++++++++++++++++++
 arch/arm/mach-omap2/powerdomain.h |   33 ++
 2 files changed, 553 insertions(+), 5 deletions(-)

arch/arm/mach-omap2/powerdomain.c +0 -0

index 94b89a25..18f33de 100644

arch/arm/mach-omap2/powerdomain.c +82 -0

+static int _match_pwrst(u32 pwrsts, int pwrst, int min, int max)
+{
+       int found = 1, new_pwrst = pwrst;
+
+       /*
+        * If the power domain does not allow any state programmation
+        * return the max state which is always allowed
+        */
+       if (!pwrsts)
+               return max;
+
+       /*
+        * Search lower: if the requested state is not supported
+        * try the lower states, stopping at the minimum allowed
+        * state
+        */
+       while (!(pwrsts & (1 << new_pwrst))) {
+               if (new_pwrst <= min) {
+                       found = 0;
+                       break;
+               }
+               new_pwrst--;
+       }
+
+       /*
+        * Search higher: if no lower state found fallback to the higher
+        * states, stopping at the maximum allowed state
+        */
+       if (!found) {
+               new_pwrst = pwrst;
+               while (!(pwrsts & (1 << new_pwrst))) {
+                       if (new_pwrst >= max) {
+                               new_pwrst = max;
+                               break;
+                       }
+                       new_pwrst++;
+               }
+       }
+
+       return new_pwrst;
+}
+
+/**
+ * _pwrdm_fpwrst_to_pwrst - Convert functional (i.e. logical) to
+ * internal (i.e. registers) values for the power domains states.
+ * @pwrdm: struct powerdomain * to convert the values for
+ * @fpwrst: functional power state
+ * @pwrdm_pwrst: ptr to u8 to return the power state in
+ * @logic_retst: ptr to u8 to return the logic retention state in
+ *
+ * Returns the internal power state value for the power domain, or
+ * -EINVAL in case of invalid parameters passed in.
+ */
+static int _pwrdm_fpwrst_to_pwrst(struct powerdomain *pwrdm, u8 fpwrst,
+                                 u8 *pwrdm_pwrst, u8 *logic_retst)
+{
+       if (!pwrdm || !pwrdm_pwrst || !logic_retst)
+               return -EINVAL;
+
+       switch (fpwrst) {
+       case PWRDM_FUNC_PWRST_ON:
+               *pwrdm_pwrst = PWRDM_POWER_ON;
+               *logic_retst = PWRDM_POWER_RET;
+               break;
+       case PWRDM_FUNC_PWRST_INACTIVE:
+               *pwrdm_pwrst = PWRDM_POWER_INACTIVE;
+               *logic_retst = PWRDM_POWER_RET;
+               break;
+       case PWRDM_FUNC_PWRST_CSWR:
+               *pwrdm_pwrst = PWRDM_POWER_RET;
+               *logic_retst = PWRDM_POWER_RET;
+               break;
+       case PWRDM_FUNC_PWRST_OSWR:
+               *pwrdm_pwrst = PWRDM_POWER_RET;
+               *logic_retst = PWRDM_POWER_OFF;
+               break;
+       case PWRDM_FUNC_PWRST_OFF:
+               *pwrdm_pwrst = PWRDM_POWER_OFF;
+               /*
+                * logic_retst is set to PWRDM_POWER_RET in this case
+                * since the actual value does not matter, and because
+                * some powerdomains don't support a logic_retst of

On Sun, Dec 9, 2012 at 6:53 PM, Paul Walmsley <[email protected]> wrote:

+/**

Quoted 12 lines

+ * _match_pwrst: determine the closest supported power state
+ * @pwrsts: list of allowed states, defined as a bitmask
+ * @pwrst: initial state to be used as a starting point
+ * @min: minimum (i.e. lowest consumption) allowed state
+ * @max: maximum (i.e. highest consumption) allowed state
+ *
+ * Search down then up for a valid state from a list of allowed
+ * states. Used by states conversion functions (_pwrdm_fpwrst_to_*)
+ * to look for allowed power and logic states for a powerdomain.
+ * Returns the matching allowed state. XXX Deprecated. The software
+ * should not try to program unsupported powerstates.

Why is this new code already deprecated? Does this require a rewrite?

From: Jean Pihet <[email protected]>

Introduce the functional states for power domains, which include the power states and the logic states.
This patch provides the API functions to set and read the power domains functional state and internal functions to convert between the functional (i.e. logical) and the internal (or registers) values.

In the new API only the functions pwrdm_set_next_fpwrst() and pwrdm_set_fpwrst() shall be used to change a power domain target state, along with the associated PWRDM_FUNC_* macros as the state parameters.

Note about the power domains allowed states:
Power domains have varied capabilities, as defined by the value of the pwrsts and pwrsts_logic_ret fields of the powerdomain struct. When reading or setting a low power state such as OFF/RET, a specific requested state may not be supported on the given power domain. In the states conversion functions a power or logic state is first looked for in the lower power states in order to maximize the power savings, then if not found in the higher power states. An iteration function is used, as suggested by Rajendra Nayak <[email protected]> This function is temporary and will be removed later in the series.

This functionality brings consistency in the functional power states core code and acts as a guard against hardware implementations discrepancies, e.g. some power domains only support the RET logic state although reading the logic state registers (previous, current and next) always returns OFF. The DSS power domain on OMAP3 is an example.

Signed-off-by Jean Pihet <[email protected]>

Cc Tero Kristo <[email protected]>

Cc Rajendra Nayak <[email protected]>

Cc Nishanth Menon <[email protected]>

[paul at pwsan.com: add offset for functional powerstates so it's not
possible to confuse them with the old API; use one fn to convert func pwrsts to low-level hardware bits; skip hardware reads when hardware logic retst and logic pwrst bits are missing; fix kerneldoc and commit message; remove unnecessary PWRDM_LOGIC_MEM_PWRST_* macros; combine spinlock patch into this patch; expand the number of operations which take the spinlock]

Signed-off-by Paul Walmsley <[email protected]>

---
 arch/arm/mach-omap2/powerdomain.c |  525 +++++++++++++++++++++++++++++++++++++
 arch/arm/mach-omap2/powerdomain.h |   33 ++
 2 files changed, 553 insertions(+), 5 deletions(-)

arch/arm/mach-omap2/powerdomain.c +62 -3

index 94b89a25..18f33de 100644
@@ -1,7 +1,7 @@
 /*
  * OMAP powerdomain control
  *
- * Copyright (C) 2007-2008, 2011 Texas Instruments, Inc.
+ * Copyright (C) 2007-2008, 2011-2012 Texas Instruments, Inc.
  * Copyright (C) 2007-2011 Nokia Corporation
  *
  * Written by Paul Walmsley

@@ -44,12 +44,19 @@ enum {
 	PWRDM_STATE_PREV,
 };
 
-
 /* pwrdm_list contains all registered struct powerdomains */
 static LIST_HEAD(pwrdm_list);
 
 static struct pwrdm_ops *arch_pwrdm;
 
+/*
+ * _fpwrst_names: human-readable functional powerstate names - should match
+ *    the enum pwrdm_func_state order and names
+ */
+static const char * const _fpwrst_names[] = {
+	"OFF", "OSWR", "CSWR", "INACTIVE", "ON"
+};
+
 /* Private functions */
 
 static struct powerdomain *_pwrdm_lookup(const char *name)

@@ -145,7 +152,6 @@ static void _update_logic_membank_counters(struct powerdomain *pwrdm)
 
 static int _pwrdm_state_switch(struct powerdomain *pwrdm, int flag)
 {
-
 	int prev, next, state, trace_state = 0;
 
 	if (pwrdm == NULL)

@@ -259,6 +265,309 @@ static bool _pwrdm_logic_retst_can_change(struct powerdomain *pwrdm)
 	return _pwrdm_logic_retst_is_controllable(pwrdm);
 }
 
+/**
+ * _match_pwrst: determine the closest supported power state
+ * @pwrsts: list of allowed states, defined as a bitmask
+ * @pwrst: initial state to be used as a starting point
+ * @min: minimum (i.e. lowest consumption) allowed state
+ * @max: maximum (i.e. highest consumption) allowed state
+ *
+ * Search down then up for a valid state from a list of allowed
+ * states.  Used by states conversion functions (_pwrdm_fpwrst_to_*)
+ * to look for allowed power and logic states for a powerdomain.
+ * Returns the matching allowed state.  XXX Deprecated.  The software
+ * should not try to program unsupported powerstates.
+ */
+static int _match_pwrst(u32 pwrsts, int pwrst, int min, int max)
+{
+	int found = 1, new_pwrst = pwrst;
+
+	/*
+	 * If the power domain does not allow any state programmation
+	 * return the max state which is always allowed
+	 */
+	if (!pwrsts)
+		return max;
+
+	/*
+	 * Search lower: if the requested state is not supported
+	 * try the lower states, stopping at the minimum allowed
+	 * state
+	 */
+	while (!(pwrsts & (1 << new_pwrst))) {
+		if (new_pwrst <= min) {
+			found = 0;
+			break;
+		}
+		new_pwrst--;
+	}
+
+	/*
+	 * Search higher: if no lower state found fallback to the higher
+	 * states, stopping at the maximum allowed state
+	 */
+	if (!found) {
+		new_pwrst = pwrst;
+		while (!(pwrsts & (1 << new_pwrst))) {
+			if (new_pwrst >= max) {
+				new_pwrst = max;
+				break;
+			}
+			new_pwrst++;
+		}
+	}
+
+	return new_pwrst;

or
+ * -EINVAL in case of invalid parameters passed in.
+ */

arch/arm/mach-omap2/powerdomain.c +51 -0

+static int _pwrdm_fpwrst_to_pwrst(struct powerdomain *pwrdm, u8 fpwrst,
+				  u8 *pwrdm_pwrst, u8 *logic_retst)
+{
+	if (!pwrdm || !pwrdm_pwrst || !logic_retst)
+		return -EINVAL;
+
+	switch (fpwrst) {
+	case PWRDM_FUNC_PWRST_ON:
+		*pwrdm_pwrst = PWRDM_POWER_ON;
+		*logic_retst = PWRDM_POWER_RET;
+		break;
+	case PWRDM_FUNC_PWRST_INACTIVE:
+		*pwrdm_pwrst = PWRDM_POWER_INACTIVE;
+		*logic_retst = PWRDM_POWER_RET;
+		break;
+	case PWRDM_FUNC_PWRST_CSWR:
+		*pwrdm_pwrst = PWRDM_POWER_RET;
+		*logic_retst = PWRDM_POWER_RET;
+		break;
+	case PWRDM_FUNC_PWRST_OSWR:
+		*pwrdm_pwrst = PWRDM_POWER_RET;
+		*logic_retst = PWRDM_POWER_OFF;
+		break;
+	case PWRDM_FUNC_PWRST_OFF:
+		*pwrdm_pwrst = PWRDM_POWER_OFF;
+		/*
+		 * logic_retst is set to PWRDM_POWER_RET in this case
+		 * since the actual value does not matter, and because
+		 * some powerdomains don't support a logic_retst of
+		 * OFF.  XXX Maybe there's some way to indicate a
+		 * 'don't care' value here?
+		 */
+		*logic_retst = PWRDM_POWER_RET;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	/* XXX deprecated */
+	*pwrdm_pwrst = _match_pwrst(pwrdm->pwrsts, *pwrdm_pwrst,
+				    PWRDM_POWER_OFF, PWRDM_POWER_ON);
+
+	*logic_retst = _match_pwrst(pwrdm->pwrsts_logic_ret, *logic_retst,
+				    PWRDM_POWER_OFF, PWRDM_POWER_RET);
+
+	pr_debug("powerdomain %s: convert fpwrst %0x to pwrst %0x\n",
+		 pwrdm->name, fpwrst, *pwrdm_pwrst);
+
+	return 0;
+}
+

@pwrdm, @logic, and @pwrst
+ * are passed in, along with a pointer to the location to store the fpwrst to
+ * in @fpwrst.
+ */

arch/arm/mach-omap2/powerdomain.c +201 -1

+static int _pwrdm_pwrst_to_fpwrst(struct powerdomain *pwrdm, u8 pwrst, u8 logic,
+				  u8 *fpwrst)
+{
+	if (!pwrdm || !fpwrst)
+		return -EINVAL;
+
+	switch (pwrst) {
+	case PWRDM_POWER_ON:
+		*fpwrst = PWRDM_FUNC_PWRST_ON;
+		break;
+	case PWRDM_POWER_INACTIVE:
+		*fpwrst = PWRDM_FUNC_PWRST_INACTIVE;
+		break;
+	case PWRDM_POWER_RET:
+		if (logic == PWRDM_POWER_OFF)
+			*fpwrst = PWRDM_FUNC_PWRST_OSWR;
+		else if (logic == PWRDM_POWER_RET)
+			*fpwrst = PWRDM_FUNC_PWRST_CSWR;
+		else
+			return -EINVAL;
+		break;
+	case PWRDM_POWER_OFF:
+		*fpwrst = PWRDM_FUNC_PWRST_OFF;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	pr_debug("powerdomain: convert pwrst (%0x,%0x) to fpwrst %0x\n",
+		 pwrst, logic, *fpwrst);
+
+	return 0;
+}
+
+/**
+ * _set_logic_retst_and_pwrdm_pwrst - program logic retst and pwrdm next pwrst
+ * @pwrdm: struct powerdomain * to program
+ * @logic: logic retention state to attempt to program
+ * @pwrst: powerdomain next-power-state to program
+ *
+ * Program the next-power-state and logic retention power state of the
+ * powerdomain represented by @pwrdm to @pwrst and @logic,
+ * respectively.  If the powerdomain next-power-state is not
+ * software-controllable, returns 0; otherwise, passes along the
+ * return value from pwrdm_set_logic_retst() if there is an error
+ * returned by that function, otherwise, passes along the return value
+ * from pwrdm_set_next_pwrst()
+ */
+static int _set_logic_retst_and_pwrdm_pwrst(struct powerdomain *pwrdm,
+					    u8 logic, u8 pwrst)
+{
+	int ret;
+
+	if (!_pwrdm_pwrst_is_controllable(pwrdm))
+		return 0;
+
+	if (pwrdm->pwrsts_logic_ret && pwrst == PWRDM_POWER_RET) {
+		ret = pwrdm_set_logic_retst(pwrdm, logic);
+		if (ret) {
+			pr_err("%s: unable to set logic state %0x of powerdomain: %s\n",
+			       __func__, logic, pwrdm->name);
+			return ret;
+		}
+	}
+
+	ret = pwrdm_set_next_pwrst(pwrdm, pwrst);
+	if (ret)
+		pr_err("%s: unable to set power state %0x of powerdomain: %s\n",
+		       __func__, pwrst, pwrdm->name);
+
+	return ret;
+}
+
+/**
+ * _pwrdm_read_next_fpwrst - get next powerdomain func power state (lockless)
+ * @pwrdm: struct powerdomain * to get power state
+ *
+ * Return the powerdomain @pwrdm's next functional power state.
+ * Caller must hold @pwrdm->_lock.  Returns -EINVAL if the powerdomain
+ * pointer is null or returns the next power state upon success.
+ */
+static int _pwrdm_read_next_fpwrst(struct powerdomain *pwrdm)
+{
+	int next_pwrst, next_logic, ret;
+	u8 fpwrst;
+
+	if (!arch_pwrdm || !arch_pwrdm->pwrdm_read_next_pwrst)
+		return -EINVAL;
+
+	next_pwrst = arch_pwrdm->pwrdm_read_next_pwrst(pwrdm);
+	if (next_pwrst < 0)
+		return next_pwrst;
+
+	next_logic = next_pwrst;
+	if (_pwrdm_logic_retst_can_change(pwrdm) &&
+	    arch_pwrdm->pwrdm_read_logic_pwrst) {
+		next_logic = arch_pwrdm->pwrdm_read_logic_pwrst(pwrdm);
+		if (next_logic < 0)
+			return next_logic;
+	}
+
+	ret = _pwrdm_pwrst_to_fpwrst(pwrdm, next_pwrst, next_logic, &fpwrst);
+
+	return (ret) ? ret : fpwrst;
+}
+
+/**
+ * _pwrdm_read_fpwrst - get current func powerdomain power state (lockless)
+ * @pwrdm: struct powerdomain * to get current functional power state
+ *
+ * Return the powerdomain @pwrdm's current functional power state.
+ * Returns -EINVAL if the powerdomain pointer is null or returns the
+ * current power state upon success.
+ */
+static int _pwrdm_read_fpwrst(struct powerdomain *pwrdm)
+{
+	int pwrst, logic_pwrst, ret;
+	u8 fpwrst;
+
+	if (!_pwrdm_pwrst_can_change(pwrdm))
+		return PWRDM_FUNC_PWRST_ON;
+
+	pwrst = arch_pwrdm->pwrdm_read_pwrst(pwrdm);
+	if (pwrst < 0)
+		return pwrst;
+
+	logic_pwrst = pwrst;
+	if (_pwrdm_logic_retst_can_change(pwrdm) &&
+	    arch_pwrdm->pwrdm_read_logic_pwrst) {
+		logic_pwrst = arch_pwrdm->pwrdm_read_logic_pwrst(pwrdm);
+		if (logic_pwrst < 0)
+			return logic_pwrst;
+	}
+
+	ret = _pwrdm_pwrst_to_fpwrst(pwrdm, pwrst, logic_pwrst, &fpwrst);
+
+	return (ret) ? ret : fpwrst;
+}
+
+/**
+ * _pwrdm_read_prev_fpwrst - get previous powerdomain func pwr state (lockless)
+ * @pwrdm: struct powerdomain * to get previous functional power state
+ *
+ * Return the powerdomain @pwrdm's previous functional power state.
+ * Returns -EINVAL if the powerdomain pointer is null or returns the
+ * previous functional power state upon success.
+ */
+static int _pwrdm_read_prev_fpwrst(struct powerdomain *pwrdm)
+{
+	int ret = -EINVAL;
+	int pwrst, logic_pwrst;
+	u8 fpwrst;
+
+	if (!_pwrdm_pwrst_can_change(pwrdm))
+		return PWRDM_FUNC_PWRST_ON;
+
+	pwrst = arch_pwrdm->pwrdm_read_prev_pwrst(pwrdm);
+	if (pwrst < 0)
+		return pwrst;
+
+	logic_pwrst = pwrst;
+	if (_pwrdm_logic_retst_can_change(pwrdm) &&
+	    arch_pwrdm->pwrdm_read_prev_logic_pwrst) {
+		logic_pwrst = arch_pwrdm->pwrdm_read_prev_logic_pwrst(pwrdm);
+		if (logic_pwrst < 0)
+			return logic_pwrst;
+	}
+
+	ret = _pwrdm_pwrst_to_fpwrst(pwrdm, pwrst, logic_pwrst, &fpwrst);
+
+	return (ret) ? ret : fpwrst;
+}
+
 /* Public functions */
 
 /**

@@ -620,7 +929,7 @@ int pwrdm_read_pwrst(struct powerdomain *pwrdm)
 	if (!pwrdm)
 		return -EINVAL;
 
-	if (pwrdm->pwrsts == PWRSTS_ON)
+	if (!_pwrdm_pwrst_can_change(pwrdm))
 		return PWRDM_POWER_ON;
 
 	if (arch_pwrdm && arch_pwrdm->pwrdm_read_pwrst)

@@ -1213,3 +1522,211 @@ bool pwrdm_can_ever_lose_context(struct powerdomain *pwrdm)
 
 	return 0;
 }
+
+/* Public functions for functional power state handling */
+
+/**
+ * pwrdm_convert_fpwrst_to_name - return the name of a functional power state
+ * @fpwrst: functional power state to return the name of
+ *
+ * Return a pointer to a string with the human-readable name of the
+ * functional power state (e.g., "ON", "CSWR", etc.)  Intended for use
+ * in debugging.  Returns NULL if @fpwrst is outside the range of the
+ * known functional power states.
+ */
+const char *pwrdm_convert_fpwrst_to_name(u8 fpwrst)
+{
+	if (fpwrst < PWRDM_FPWRST_OFFSET || fpwrst >= PWRDM_MAX_FUNC_PWRSTS)
+		return NULL;
+
+	return _fpwrst_names[fpwrst - PWRDM_FPWRST_OFFSET];
+}
+
+/**
+ * pwrdm_set_next_fpwrst - set next powerdomain functional power state
+ * @pwrdm: struct powerdomain * to set
+ * @fpwrst: one of the PWRDM_POWER_* macros
+ *
+ * Set the powerdomain @pwrdm's next power state to @fpwrst.  The
+ * powerdomain may not enter this state immediately if the

arch/arm/mach-omap2/powerdomain.c +145 -0

+		return -EINVAL;
+
+	if (!_pwrdm_pwrst_is_controllable(pwrdm))
+		return 0;
+
+	ret = _pwrdm_fpwrst_to_pwrst(pwrdm, fpwrst, &pwrst, &logic);
+	if (ret)
+		return ret;
+
+	pr_debug("%s: set fpwrst %0x to pwrdm %s\n", __func__, fpwrst,
+		 pwrdm->name);
+
+	pwrdm_lock(pwrdm);
+	ret = _set_logic_retst_and_pwrdm_pwrst(pwrdm, logic, pwrst);
+	pwrdm_unlock(pwrdm);
+
+	return ret;
+}
+
+/**
+ * pwrdm_read_next_fpwrst - get next powerdomain functional power state
+ * @pwrdm: struct powerdomain * to get power state
+ *
+ * Return the powerdomain @pwrdm's next functional power state.
+ * Returns -EINVAL if the powerdomain pointer is null or returns
+ * the next power state upon success.
+ */
+int pwrdm_read_next_fpwrst(struct powerdomain *pwrdm)
+{
+	int next_pwrst, next_logic, ret;
+	u8 fpwrst;
+
+	if (!arch_pwrdm || !arch_pwrdm->pwrdm_read_next_pwrst)
+		return -EINVAL;
+
+	pwrdm_lock(pwrdm);
+
+	next_pwrst = arch_pwrdm->pwrdm_read_next_pwrst(pwrdm);
+	if (next_pwrst < 0) {
+		ret = next_pwrst;
+		goto prnf_out;
+	}
+
+	next_logic = next_pwrst;
+	if (_pwrdm_logic_retst_can_change(pwrdm) &&
+	    arch_pwrdm->pwrdm_read_logic_pwrst) {
+		next_logic = arch_pwrdm->pwrdm_read_logic_pwrst(pwrdm);
+		if (next_logic < 0) {
+			ret = next_logic;
+			goto prnf_out;
+		}
+	}
+
+	ret = _pwrdm_pwrst_to_fpwrst(pwrdm, next_pwrst, next_logic, &fpwrst);
+
+prnf_out:
+	pwrdm_unlock(pwrdm);
+
+	return (ret) ? ret : fpwrst;
+}
+
+/**
+ * pwrdm_set_fpwrst - program next powerdomain functional power state
+ * @pwrdm: struct powerdomain * to set
+ * @fpwrst: power domain functional state, one of the PWRDM_FUNC_* macros
+ *
+ * This programs the pwrdm next functional state, sets the dependencies
+ * and waits for the state to be applied.
+ */
+int pwrdm_set_fpwrst(struct powerdomain *pwrdm, enum pwrdm_func_state fpwrst)
+{
+	u8 next_fpwrst, pwrst, logic, sleep_switch;
+	int ret = 0;
+	bool hwsup;
+
+	if (!pwrdm || IS_ERR(pwrdm) || !arch_pwrdm ||
+	    !arch_pwrdm->pwrdm_read_pwrst)
+		return -EINVAL;
+
+	if (!_pwrdm_pwrst_is_controllable(pwrdm))
+		return 0;
+
+	ret = _pwrdm_fpwrst_to_pwrst(pwrdm, fpwrst, &pwrst, &logic);
+	if (ret)
+		return -EINVAL;
+
+	pr_debug("%s: pwrdm %s: set fpwrst %0x\n", __func__, pwrdm->name,
+		 fpwrst);
+
+	pwrdm_lock(pwrdm);
+
+	/*
+	 * XXX quite heavyweight for what this is intended to do; the
+	 * next fpwrst should simply be cached
+	 */
+	next_fpwrst = _pwrdm_read_next_fpwrst(pwrdm);
+	if (next_fpwrst == fpwrst)
+		goto psf_out;
+
+	sleep_switch = _pwrdm_save_clkdm_state_and_activate(pwrdm, pwrst,
+							    &hwsup);
+
+	ret = _set_logic_retst_and_pwrdm_pwrst(pwrdm, logic, pwrst);
+	if (ret)
+		pr_err("%s: unable to set power state of powerdomain: %s\n",
+		       __func__, pwrdm->name);
+
+	_pwrdm_restore_clkdm_state(pwrdm, sleep_switch, hwsup);
+
+psf_out:
+	pwrdm_unlock(pwrdm);
+
+	return ret;
+}
+
+/**
+ * pwrdm_read_fpwrst - get current functional powerdomain power state
+ * @pwrdm: struct powerdomain * to get current functional power state
+ *
+ * Return the powerdomain @pwrdm's current functional power state.
+ * Returns -EINVAL if the powerdomain pointer is null or returns the
+ * current power state upon success.
+ */
+int pwrdm_read_fpwrst(struct powerdomain *pwrdm)
+{
+	int ret;
+
+	if (!pwrdm || !arch_pwrdm)
+		return -EINVAL;
+
+	if (!_pwrdm_pwrst_can_change(pwrdm))
+		return PWRDM_FUNC_PWRST_ON;
+
+	if (!arch_pwrdm->pwrdm_read_pwrst)
+		return -EINVAL;
+
+	pwrdm_lock(pwrdm);
+	ret = _pwrdm_read_fpwrst(pwrdm);
+	pwrdm_unlock(pwrdm);
+
+	return ret;
+}
+
+/**
+ * pwrdm_read_prev_fpwrst - get previous powerdomain functional power state

arch/arm/mach-omap2/powerdomain.c +16 -0

+	if (!pwrdm || !arch_pwrdm)
+		return -EINVAL;
+
+	if (!_pwrdm_pwrst_can_change(pwrdm))
+		return PWRDM_FUNC_PWRST_ON;
+
+	if (!arch_pwrdm->pwrdm_read_prev_pwrst)
+		return -EINVAL;
+
+	pwrdm_lock(pwrdm);
+	ret = _pwrdm_read_prev_fpwrst(pwrdm);
+	pwrdm_unlock(pwrdm);
+
+	return ret;
+}
+

arch/arm/mach-omap2/powerdomain.h +32 -1

index 842ba46..be835ff 100644
@@ -1,7 +1,7 @@
 /*
  * OMAP2/3/4 powerdomain control
  *
- * Copyright (C) 2007-2008, 2010 Texas Instruments, Inc.
+ * Copyright (C) 2007-2008, 2010-2012 Texas Instruments, Inc.
  * Copyright (C) 2007-2011 Nokia Corporation
  *
  * Paul Walmsley

@@ -23,6 +23,29 @@
 
 #include "voltage.h"
 
+/*
+ * PWRDM_FPWRST_OFFSET: offset of the first functional power state
+ * from 0.  This offset can be subtracted from the functional power
+ * state macros to produce offsets suitable for array indices, for
+ * example.  The intention behind the addition of this offset is to
+ * prevent functional power states from accidentally being confused
+ * with the low-level, hardware power states.
+ */
+#define PWRDM_FPWRST_OFFSET		0x80
+
+/*
+ * Powerdomain functional power states, used by the external API functions
+ * These must match the order and names in _fpwrst_names[]
+ */
+enum pwrdm_func_state {
+	PWRDM_FUNC_PWRST_OFF		= PWRDM_FPWRST_OFFSET,
+	PWRDM_FUNC_PWRST_OSWR,
+	PWRDM_FUNC_PWRST_CSWR,
+	PWRDM_FUNC_PWRST_INACTIVE,
+	PWRDM_FUNC_PWRST_ON,
+	PWRDM_MAX_FUNC_PWRSTS		/* Last value, used as the max value */
+};
+
 /* Powerdomain basic power states */
 #define PWRDM_POWER_OFF		0x0
 #define PWRDM_POWER_RET		0x1

@@ -238,6 +261,14 @@ bool pwrdm_can_ever_lose_context(struct powerdomain *pwrdm);
 
 extern int omap_set_pwrdm_state(struct powerdomain *pwrdm, u8 state);
 
+extern const char *pwrdm_convert_fpwrst_to_name(u8 fpwrst);
+extern int pwrdm_set_next_fpwrst(struct powerdomain *pwrdm, u8 fpwrst);
+extern int pwrdm_read_next_fpwrst(struct powerdomain *pwrdm);
+extern int pwrdm_set_fpwrst(struct powerdomain *pwrdm,
+			    enum pwrdm_func_state fpwrst);
+extern int pwrdm_read_fpwrst(struct powerdomain *pwrdm);
+extern int pwrdm_read_prev_fpwrst(struct powerdomain *pwrdm);
+
 extern void omap242x_powerdomains_init(void);
 extern void omap243x_powerdomains_init(void);
 extern void omap3xxx_powerdomains_init(void);

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

From: Jean Pihet <[email protected]>

Introduce the functional states for power domains, which include the power states and the logic states.
This patch provides the API functions to set and read the power domains functional state and internal functions to convert between the functional (i.e. logical) and the internal (or registers) values.

In the new API only the functions pwrdm_set_next_fpwrst() and pwrdm_set_fpwrst() shall be used to change a power domain target state, along with the associated PWRDM_FUNC_* macros as the state parameters.

Note about the power domains allowed states:
Power domains have varied capabilities, as defined by the value of the pwrsts and pwrsts_logic_ret fields of the powerdomain struct. When reading or setting a low power state such as OFF/RET, a specific requested state may not be supported on the given power domain. In the states conversion functions a power or logic state is first looked for in the lower power states in order to maximize the power savings, then if not found in the higher power states. An iteration function is used, as suggested by Rajendra Nayak <[email protected]> This function is temporary and will be removed later in the series.

This functionality brings consistency in the functional power states core code and acts as a guard against hardware implementations discrepancies, e.g. some power domains only support the RET logic state although reading the logic state registers (previous, current and next) always returns OFF. The DSS power domain on OMAP3 is an example.

Signed-off-by Jean Pihet <[email protected]>

Cc Tero Kristo <[email protected]>

Cc Rajendra Nayak <[email protected]>

Cc Nishanth Menon <[email protected]>

[paul at pwsan.com: add offset for functional powerstates so it's not
possible to confuse them with the old API; use one fn to convert func pwrsts to low-level hardware bits; skip hardware reads when hardware logic retst and logic pwrst bits are missing; fix kerneldoc and commit message; remove unnecessary PWRDM_LOGIC_MEM_PWRST_* macros; combine spinlock patch into this patch; expand the number of operations which take the spinlock]

Signed-off-by Paul Walmsley <[email protected]>

---
 arch/arm/mach-omap2/powerdomain.c |  525 +++++++++++++++++++++++++++++++++++++
 arch/arm/mach-omap2/powerdomain.h |   33 ++
 2 files changed, 553 insertions(+), 5 deletions(-)

arch/arm/mach-omap2/powerdomain.c +0 -0

index 94b89a25..18f33de 100644
@@ -1,7 +1,7 @@

+/**
+ * _match_pwrst: determine the closest supported power state
+ * @pwrsts: list of allowed states, defined as a bitmask
+ * @pwrst: initial state to be used as a starting point

+ * @min: minimum (i.e. lowest consumption) allowed state
+ * @max: maximum (i.e. highest consumption) allowed state
+ *
+ * Search down then up for a valid state from a list of allowed
+ * states. Used by states conversion functions (_pwrdm_fpwrst_to_*)
+ * to look for allowed power and logic states for a powerdomain.
+ * Returns the matching allowed state. XXX Deprecated. The software
+ * should not try to program unsupported powerstates.

+ */

arch/arm/mach-omap2/powerdomain.c +82 -0

+static int _match_pwrst(u32 pwrsts, int pwrst, int min, int max)
+{
+       int found = 1, new_pwrst = pwrst;
+
+       /*
+        * If the power domain does not allow any state programmation
+        * return the max state which is always allowed
+        */
+       if (!pwrsts)
+               return max;
+
+       /*
+        * Search lower: if the requested state is not supported
+        * try the lower states, stopping at the minimum allowed
+        * state
+        */
+       while (!(pwrsts & (1 << new_pwrst))) {
+               if (new_pwrst <= min) {
+                       found = 0;
+                       break;
+               }
+               new_pwrst--;
+       }
+
+       /*
+        * Search higher: if no lower state found fallback to the higher
+        * states, stopping at the maximum allowed state
+        */
+       if (!found) {
+               new_pwrst = pwrst;
+               while (!(pwrsts & (1 << new_pwrst))) {
+                       if (new_pwrst >= max) {
+                               new_pwrst = max;
+                               break;
+                       }
+                       new_pwrst++;
+               }
+       }
+
+       return new_pwrst;
+}
+
+/**
+ * _pwrdm_fpwrst_to_pwrst - Convert functional (i.e. logical) to
+ * internal (i.e. registers) values for the power domains states.
+ * @pwrdm: struct powerdomain * to convert the values for
+ * @fpwrst: functional power state
+ * @pwrdm_pwrst: ptr to u8 to return the power state in
+ * @logic_retst: ptr to u8 to return the logic retention state in
+ *
+ * Returns the internal power state value for the power domain, or
+ * -EINVAL in case of invalid parameters passed in.
+ */
+static int _pwrdm_fpwrst_to_pwrst(struct powerdomain *pwrdm, u8 fpwrst,
+                                 u8 *pwrdm_pwrst, u8 *logic_retst)
+{
+       if (!pwrdm || !pwrdm_pwrst || !logic_retst)
+               return -EINVAL;
+
+       switch (fpwrst) {
+       case PWRDM_FUNC_PWRST_ON:
+               *pwrdm_pwrst = PWRDM_POWER_ON;
+               *logic_retst = PWRDM_POWER_RET;
+               break;
+       case PWRDM_FUNC_PWRST_INACTIVE:
+               *pwrdm_pwrst = PWRDM_POWER_INACTIVE;
+               *logic_retst = PWRDM_POWER_RET;
+               break;
+       case PWRDM_FUNC_PWRST_CSWR:
+               *pwrdm_pwrst = PWRDM_POWER_RET;
+               *logic_retst = PWRDM_POWER_RET;
+               break;
+       case PWRDM_FUNC_PWRST_OSWR:
+               *pwrdm_pwrst = PWRDM_POWER_RET;
+               *logic_retst = PWRDM_POWER_OFF;
+               break;
+       case PWRDM_FUNC_PWRST_OFF:
+               *pwrdm_pwrst = PWRDM_POWER_OFF;
+               /*
+                * logic_retst is set to PWRDM_POWER_RET in this case
+                * since the actual value does not matter, and because
+                * some powerdomains don't support a logic_retst of

Quoted 4 lines

+/**
+ * _match_pwrst: determine the closest supported power state
+ * @pwrsts: list of allowed states, defined as a bitmask
+ * @pwrst: initial state to be used as a starting point

Quoted 8 lines

+ * @min: minimum (i.e. lowest consumption) allowed state
+ * @max: maximum (i.e. highest consumption) allowed state
+ *
+ * Search down then up for a valid state from a list of allowed
+ * states. Used by states conversion functions (_pwrdm_fpwrst_to_*)
+ * to look for allowed power and logic states for a powerdomain.
+ * Returns the matching allowed state. XXX Deprecated. The software
+ * should not try to program unsupported powerstates.

Why is this new code already deprecated? Does this require a rewrite?

arch/arm/mach-omap2/powerdomain.c static bool _pwrdm_logic_retst_can_change(struct powerdomain *pwrdm) · line 372

Quoted 3 lines

arch/arm/mach-omap2/powerdomain.c +3 -0

+       }
+
+       /* XXX deprecated */

Same here

From: Jean Pihet <[email protected]>

Use the functional power states as the API to control power domains:

- use the PWRDM_FUNC_PWRST_* macros for the power states and logic settings,

- the function pwrdm_set_next_fpwrst(), which controls the power domains next power and logic settings, shall be used instead of pwrdm_set_next_pwrst() to program the power domains next states,

- the function pwrdm_set_fpwrst(), which programs the power domains power and logic settings, shall be used instead of omap_set_pwrdm_state().

Signed-off-by Jean Pihet <[email protected]>

[paul at pwsan.com: split the original patch into OMAP2/3/4 variants;
clean up omap3_save_secure_ram_context(); fix commit message; warn if sets fail; various other changes]

Signed-off-by Paul Walmsley <[email protected]>

---
 arch/arm/mach-omap2/cpuidle34xx.c |   95 ++++++++++++-----------
 arch/arm/mach-omap2/pm.h          |    2
 arch/arm/mach-omap2/pm34xx.c      |  156
+++++++++++++++++++------------------
 3 files changed, 130 insertions(+), 123 deletions(-)

From: Jean Pihet <[email protected]>

Use the functional power states as the API to control power domains:

- use the PWRDM_FUNC_PWRST_* macros for the power states and logic settings,

- the function pwrdm_set_next_fpwrst(), which controls the power domains next power and logic settings, shall be used instead of pwrdm_set_next_pwrst() to program the power domains next states,

- the function pwrdm_set_fpwrst(), which programs the power domains power and logic settings, shall be used instead of omap_set_pwrdm_state().

Signed-off-by Jean Pihet <[email protected]>

[paul at pwsan.com: split the original patch into OMAP2/3/4 variants;
clean up omap3_save_secure_ram_context(); fix commit message; warn if sets fail; various other changes]

arch/arm/mach-omap2/pm34xx.c +9 -17

@@ -112,24 +112,26 @@ static void omap3_core_restore_context(void)
 static void omap3_save_secure_ram_context(void)
 {
 	u32 ret;
-	int mpu_next_state = pwrdm_read_next_pwrst(mpu_pwrdm);
+	int mpu_next_fpwrst;
 
-	if (omap_type() != OMAP2_DEVICE_TYPE_GP) {
-		/*
-		 * MPU next state must be set to POWER_ON temporarily,
-		 * otherwise the WFI executed inside the ROM code
-		 * will hang the system.
-		 */
-		pwrdm_set_next_pwrst(mpu_pwrdm, PWRDM_POWER_ON);
-		ret = _omap_save_secure_sram((u32 *)
-				__pa(omap3_secure_ram_storage));
-		pwrdm_set_next_pwrst(mpu_pwrdm, mpu_next_state);
-		/* Following is for error tracking, it should not happen */
-		if (ret) {
-			pr_err("save_secure_sram() returns %08x\n", ret);
-			while (1)
-				;
-		}
+	if (omap_type() == OMAP2_DEVICE_TYPE_GP)
+		return;
+
+	/*
+	 * MPU next state must be set to POWER_ON temporarily,
+	 * otherwise the WFI executed inside the ROM code will hang
+	 * the system.
+	 */

From: Jean Pihet <[email protected]>

Use the functional power states as the API to control power domains:
- use the PWRDM_FUNC_PWRST_* and PWRDM_LOGIC_MEM_PWRST_* macros for the power states and logic settings,
- the function pwrdm_set_next_fpwrst, which controls the power domains next power and logic settings, shall be used instead of pwrdm_set_next_pwrst to program the power domains next states,
- the function pwrdm_set_fpwrst, which programs the power domains power and logic settings, shall be used instead of omap_set_pwrdm_state.

Signed-off-by Jean Pihet <[email protected]>

[paul at pwsan.com: split the original patch into OMAP2/3/4 variants;
warn if sets fail; various other changes]

Signed-off-by Paul Walmsley <[email protected]>

---
 arch/arm/mach-omap2/common.h              |    7 +--
 arch/arm/mach-omap2/cpuidle44xx.c         |   32 +++++--------
 arch/arm/mach-omap2/omap-hotplug.c        |    2 -
 arch/arm/mach-omap2/omap-mpuss-lowpower.c |   69 +++++++++++++++++------------
 arch/arm/mach-omap2/pm44xx.c              |   42 +++++++++---------
 5 files changed, 79 insertions(+), 73 deletions(-)

arch/arm/mach-omap2/common.h +3 -4

index c57eeea..5ad846a 100644
@@ -235,14 +235,13 @@ extern void omap5_secondary_startup(void);
 
 #if defined(CONFIG_SMP) && defined(CONFIG_PM)
 extern int omap4_mpuss_init(void);
-extern int omap4_enter_lowpower(unsigned int cpu, unsigned int power_state);
+extern int omap4_mpuss_enter_lowpower(unsigned int cpu, u8 fpwrst);
 extern int omap4_finish_suspend(unsigned long cpu_state);
 extern void omap4_cpu_resume(void);
-extern int omap4_hotplug_cpu(unsigned int cpu, unsigned int power_state);
+extern int omap4_mpuss_hotplug_cpu(unsigned int cpu, u8 fpwrst);
 extern u32 omap4_mpuss_read_prev_context_state(void);
 #else
-static inline int omap4_enter_lowpower(unsigned int cpu,
-                                       unsigned int power_state)
+static inline int omap4_mpuss_enter_lowpower(unsigned int cpu, u8 fpwrst)
 {
        cpu_do_idle();
        return 0;

arch/arm/mach-omap2/cpuidle44xx.c +0 -0

index d639aef..2cb5332 100644

arch/arm/mach-omap2/cpuidle44xx.c +11 -16

 };
 
 static struct omap4_idle_statedata omap4_idle_data[] = {
        {
-               .cpu_state = PWRDM_POWER_ON,
-               .mpu_state = PWRDM_POWER_ON,
-               .mpu_logic_state = PWRDM_POWER_RET,
+               .cpu_pwrst = PWRDM_FUNC_PWRST_ON,
+               .mpu_pwrst = PWRDM_FUNC_PWRST_ON,
        },
        {
-               .cpu_state = PWRDM_POWER_OFF,
-               .mpu_state = PWRDM_POWER_RET,
-               .mpu_logic_state = PWRDM_POWER_RET,
+               .cpu_pwrst = PWRDM_FUNC_PWRST_OFF,
+               .mpu_pwrst = PWRDM_FUNC_PWRST_CSWR,
        },
        {
-               .cpu_state = PWRDM_POWER_OFF,
-               .mpu_state = PWRDM_POWER_RET,
-               .mpu_logic_state = PWRDM_POWER_OFF,
+               .cpu_pwrst = PWRDM_FUNC_PWRST_OFF,
+               .mpu_pwrst = PWRDM_FUNC_PWRST_OSWR,
        },
 };
 

@@ -93,7 +89,7 @@ static int omap4_enter_idle_coupled(struct cpuidle_device *dev,
         * out of coherency and in OFF mode.
         */
        if (dev->cpu == 0 && cpumask_test_cpu(1, cpu_online_mask)) {
-               while (pwrdm_read_pwrst(cpu_pd[1]) != PWRDM_POWER_OFF) {
+               while (pwrdm_read_fpwrst(cpu_pd[1]) != PWRDM_FUNC_PWRST_OFF) {
                        cpu_relax();
 
                        /*

@@ -118,19 +114,17 @@ static int omap4_enter_idle_coupled(struct cpuidle_device *dev,
        cpu_pm_enter();
 
        if (dev->cpu == 0) {
-               pwrdm_set_logic_retst(mpu_pd, cx->mpu_logic_state);
-               omap_set_pwrdm_state(mpu_pd, cx->mpu_state);
+               WARN_ON(pwrdm_set_fpwrst(mpu_pd, cx->mpu_pwrst));
 
                /*
                 * Call idle CPU cluster PM enter notifier chain
                 * to save GIC and wakeupgen context.
                 */
-               if ((cx->mpu_state == PWRDM_POWER_RET) &&
-                       (cx->mpu_logic_state == PWRDM_POWER_OFF))
-                               cpu_cluster_pm_enter();
+               if (cx->mpu_pwrst == PWRDM_FUNC_PWRST_OSWR)
+                       cpu_cluster_pm_enter();
        }
 
-       omap4_enter_lowpower(dev->cpu, cx->cpu_state);
+       omap4_mpuss_enter_lowpower(dev->cpu, cx->cpu_pwrst);
        cpu_done[dev->cpu] = true;
 
        /* Wakeup CPU1 only if it is not offlined */

arch/arm/mach-omap2/omap-hotplug.c +1 -1

index e712d17..d38b12d 100644
@@ -53,7 +53,7 @@ void __ref omap4_cpu_die(unsigned int cpu)
                /*
                 * Enter into low power state
                 */
-               omap4_hotplug_cpu(cpu, PWRDM_POWER_OFF);
+               omap4_mpuss_hotplug_cpu(cpu, PWRDM_FUNC_PWRST_OFF);
 
                if (omap_secure_apis_support())
                        boot_cpu = omap_read_auxcoreboot0();

arch/arm/mach-omap2/omap-mpuss-lowpower.c +41 -28

index 80d4742..4dcebda 100644
@@ -82,31 +82,40 @@ static inline void set_cpu_wakeup_addr(unsigned int cpu_id, u32 addr)
 {
        struct omap4_cpu_pm_info *pm_info = &per_cpu(omap4_pm_info, cpu_id);
 
+       /*
+        * XXX should not be writing directly into another IP block's
+        * address space!
+        */
        __raw_writel(addr, pm_info->wkup_sar_addr);
 }
 
 /*
  * Store the SCU power status value to scratchpad memory
  */
-static void scu_pwrst_prepare(unsigned int cpu_id, unsigned int cpu_state)
+static void scu_pwrst_prepare(unsigned int cpu_id, u8 fpwrst)
 {
        struct omap4_cpu_pm_info *pm_info = &per_cpu(omap4_pm_info, cpu_id);
        u32 scu_pwr_st;
 
-       switch (cpu_state) {
-       case PWRDM_POWER_RET:
+       switch (fpwrst) {
+       case PWRDM_FUNC_PWRST_CSWR:
+       case PWRDM_FUNC_PWRST_OSWR: /* XXX is this accurate? */
                scu_pwr_st = SCU_PM_DORMANT;
                break;
-       case PWRDM_POWER_OFF:
+       case PWRDM_FUNC_PWRST_OFF:
                scu_pwr_st = SCU_PM_POWEROFF;
                break;
-       case PWRDM_POWER_ON:
-       case PWRDM_POWER_INACTIVE:
+       case PWRDM_FUNC_PWRST_ON:
+       case PWRDM_FUNC_PWRST_INACTIVE:
        default:
                scu_pwr_st = SCU_PM_NORMAL;
                break;
        }
 
+       /*
+        * XXX should not be writing directly into another IP block's
+        * address space!
+        */
        __raw_writel(scu_pwr_st, pm_info->scu_sar_addr);
 }
 

@@ -159,6 +168,10 @@ static void l2x0_pwrst_prepare(unsigned int cpu_id, unsigned int save_state)
 {
        struct omap4_cpu_pm_info *pm_info = &per_cpu(omap4_pm_info, cpu_id);
 
+       /*
+        * XXX should not be writing directly into another IP block's
+        * address space!
+        */
        __raw_writel(save_state, pm_info->l2x0_sar_addr);
 }
 

@@ -183,11 +196,11 @@ static void save_l2x0_context(void)
 #endif
 
 /**
- * omap4_enter_lowpower: OMAP4 MPUSS Low Power Entry Function
+ * omap4_mpuss_enter_lowpower: OMAP4 MPUSS Low Power Entry Function
  * The purpose of this function is to manage low power programming
  * of OMAP4 MPUSS subsystem
  * @cpu : CPU ID
- * @power_state: Low power state.
+ * @fpwrst: functional powerstate for the MPUSS to enter
  *
  * MPUSS states for the context save:
  * save_state =

@@ -196,7 +209,7 @@ static void save_l2x0_context(void)
  *     2 - CPUx L1 and logic lost + GIC lost: MPUSS OSWR
  *     3 - CPUx L1 and logic lost + GIC + L2 lost: DEVICE OFF
  */
-int omap4_enter_lowpower(unsigned int cpu, unsigned int power_state)
+int omap4_mpuss_enter_lowpower(unsigned int cpu, u8 fpwrst)
 {
        struct omap4_cpu_pm_info *pm_info = &per_cpu(omap4_pm_info, cpu);
        unsigned int save_state = 0;

@@ -205,15 +218,16 @@ int omap4_enter_lowpower(unsigned int cpu, unsigned int power_state)
        if (omap_rev() == OMAP4430_REV_ES1_0)
                return -ENXIO;
 
-       switch (power_state) {
-       case PWRDM_POWER_ON:
-       case PWRDM_POWER_INACTIVE:
+       switch (fpwrst) {
+       case PWRDM_FUNC_PWRST_ON:
+       case PWRDM_FUNC_PWRST_INACTIVE:
                save_state = 0;
                break;
-       case PWRDM_POWER_OFF:
+       case PWRDM_FUNC_PWRST_OFF:
                save_state = 1;
                break;
-       case PWRDM_POWER_RET:
+       case PWRDM_FUNC_PWRST_CSWR:
+       case PWRDM_FUNC_PWRST_OSWR:
        default:
                /*
                 * CPUx CSWR is invalid hardware state. Also CPUx OSWR

@@ -229,17 +243,16 @@ int omap4_enter_lowpower(unsigned int cpu, unsigned int power_state)
 
        /*
         * Check MPUSS next state and save interrupt controller if needed.
-        * In MPUSS OSWR or device OFF, interrupt controller  contest is lost.
+        * In MPUSS OSWR or device OFF, interrupt controller context is lost.
         */
        mpuss_clear_prev_logic_pwrst();
-       if ((pwrdm_read_next_pwrst(mpuss_pd) == PWRDM_POWER_RET) &&
-               (pwrdm_read_logic_retst(mpuss_pd) == PWRDM_POWER_OFF))
+       if (pwrdm_read_next_fpwrst(mpuss_pd) == PWRDM_FUNC_PWRST_OSWR)
                save_state = 2;
 
        cpu_clear_prev_logic_pwrst(cpu);
-       pwrdm_set_next_pwrst(pm_info->pwrdm, power_state);
+       WARN_ON(pwrdm_set_next_fpwrst(pm_info->pwrdm, fpwrst));
        set_cpu_wakeup_addr(cpu, virt_to_phys(omap4_cpu_resume));
-       scu_pwrst_prepare(cpu, power_state);
+       scu_pwrst_prepare(cpu, fpwrst);
        l2x0_pwrst_prepare(cpu, save_state);
 
        /*

@@ -255,7 +268,7 @@ int omap4_enter_lowpower(unsigned int cpu, unsigned int power_state)
         * domain transition
         */
        wakeup_cpu = smp_processor_id();
-       pwrdm_set_next_pwrst(pm_info->pwrdm, PWRDM_POWER_ON);
+       WARN_ON(pwrdm_set_next_fpwrst(pm_info->pwrdm, PWRDM_FUNC_PWRST_ON));
 
        pwrdm_post_transition(NULL);
 

@@ -265,9 +278,9 @@ int omap4_enter_lowpower(unsigned int cpu, unsigned int power_state)
 /**
  * omap4_hotplug_cpu: OMAP4 CPU hotplug entry
  * @cpu : CPU ID
- * @power_state: CPU low power state.
+ * @fpwrst: functional power state to program the CPU powerdomain to enter
  */
-int __cpuinit omap4_hotplug_cpu(unsigned int cpu, unsigned int power_state)
+int __cpuinit omap4_mpuss_hotplug_cpu(unsigned int cpu, u8 fpwrst)
 {
        struct omap4_cpu_pm_info *pm_info = &per_cpu(omap4_pm_info, cpu);
        unsigned int cpu_state = 0;

@@ -275,13 +288,13 @@ int __cpuinit omap4_hotplug_cpu(unsigned int cpu, unsigned int power_state)
        if (omap_rev() == OMAP4430_REV_ES1_0)
                return -ENXIO;
 
-       if (power_state == PWRDM_POWER_OFF)
+       if (fpwrst == PWRDM_FUNC_PWRST_OFF || fpwrst == PWRDM_FUNC_PWRST_OSWR)
                cpu_state = 1;
 
        pwrdm_clear_all_prev_pwrst(pm_info->pwrdm);
-       pwrdm_set_next_pwrst(pm_info->pwrdm, power_state);
+       WARN_ON(pwrdm_set_next_fpwrst(pm_info->pwrdm, fpwrst));
        set_cpu_wakeup_addr(cpu, virt_to_phys(omap_secondary_startup));
-       scu_pwrst_prepare(cpu, power_state);
+       scu_pwrst_prepare(cpu, fpwrst);
 
        /*
         * CPU never retuns back if targeted power state is OFF mode.

@@ -290,7 +303,7 @@ int __cpuinit omap4_hotplug_cpu(unsigned int cpu, unsigned int power_state)
         */
        omap4_finish_suspend(cpu_state);
 
-       pwrdm_set_next_pwrst(pm_info->pwrdm, PWRDM_POWER_ON);
+       WARN_ON(pwrdm_set_next_fpwrst(pm_info->pwrdm, PWRDM_FUNC_PWRST_ON));
        return 0;
 }
 

@@ -325,7 +338,7 @@ int __init omap4_mpuss_init(void)
        cpu_clear_prev_logic_pwrst(0);
 
        /* Initialise CPU0 power domain state to ON */
-       pwrdm_set_next_pwrst(pm_info->pwrdm, PWRDM_POWER_ON);
+       WARN_ON(pwrdm_set_next_fpwrst(pm_info->pwrdm, PWRDM_FUNC_PWRST_ON));
 
        pm_info = &per_cpu(omap4_pm_info, 0x1);
        pm_info->scu_sar_addr = sar_base + SCU_OFFSET1;

@@ -342,7 +355,7 @@ int __init omap4_mpuss_init(void)
        cpu_clear_prev_logic_pwrst(1);
 
        /* Initialise CPU1 power domain state to ON */
-       pwrdm_set_next_pwrst(pm_info->pwrdm, PWRDM_POWER_ON);
+       WARN_ON(pwrdm_set_next_fpwrst(pm_info->pwrdm, PWRDM_FUNC_PWRST_ON));
 
        mpuss_pd = pwrdm_lookup("mpu_pwrdm");
        if (!mpuss_pd) {

arch/arm/mach-omap2/pm44xx.c +10 -13

index 7da75ae..595f84e 100644
@@ -26,10 +26,9 @@
 
 struct power_state {
        struct powerdomain *pwrdm;
-       u32 next_state;
+       u8 next_fpwrst;
 #ifdef CONFIG_SUSPEND
-       u32 saved_state;
-       u32 saved_logic_state;
+       u8 saved_fpwrst;
 #endif
        struct list_head node;
 };

@@ -40,20 +39,19 @@ static LIST_HEAD(pwrst_list);
 static int omap4_pm_suspend(void)
 {
        struct power_state *pwrst;
-       int state, ret = 0;
+       int prev_fpwrst;
+       int ret = 0;
        u32 cpu_id = smp_processor_id();
 
+       /* XXX Seems like these two loops could be combined into one loop? */
+
        /* Save current powerdomain state */
-       list_for_each_entry(pwrst, &pwrst_list, node) {
-               pwrst->saved_state = pwrdm_read_next_pwrst(pwrst->pwrdm);
-               pwrst->saved_logic_state = pwrdm_read_logic_retst(pwrst->pwrdm);
-       }
+       list_for_each_entry(pwrst, &pwrst_list, node)
+               pwrst->saved_fpwrst = pwrdm_read_next_fpwrst(pwrst->pwrdm);
 
        /* Set targeted power domain states by suspend */
-       list_for_each_entry(pwrst, &pwrst_list, node) {
-               omap_set_pwrdm_state(pwrst->pwrdm, pwrst->next_state);
-               pwrdm_set_logic_retst(pwrst->pwrdm, PWRDM_POWER_OFF);
-       }
+       list_for_each_entry(pwrst, &pwrst_list, node)
+               WARN_ON(pwrdm_set_fpwrst(pwrst->pwrdm, pwrst->next_fpwrst));
 
        /*
         * For MPUSS to hit power domain retention(CSWR or OSWR),

@@ -64,18 +62,20 @@ static int omap4_pm_suspend(void)
         * domain CSWR is not supported by hardware.
         * More details can be found in OMAP4430 TRM section 4.3.4.2.
         */
-       omap4_enter_lowpower(cpu_id, PWRDM_POWER_OFF);

arch/arm/mach-omap2/pm44xx.c +8 -5

+               if (prev_fpwrst > pwrst->next_fpwrst) {
+                       pr_info("Powerdomain (%s) didn't enter target state %s - entered state %s instead\n",
+                               pwrst->pwrdm->name,
+                               pwrdm_convert_fpwrst_to_name(pwrst->next_fpwrst),
+                               pwrdm_convert_fpwrst_to_name(prev_fpwrst));
                        ret = -1;
                }
-               omap_set_pwrdm_state(pwrst->pwrdm, pwrst->saved_state);
-               pwrdm_set_logic_retst(pwrst->pwrdm, pwrst->saved_logic_state);
+               WARN_ON(pwrdm_set_fpwrst(pwrst->pwrdm, pwrst->saved_fpwrst));
        }
        if (ret)
                pr_crit("Could not enter target state in pm_suspend\n");

@@ -113,10 +113,10 @@ static int __init pwrdms_setup(struct powerdomain *pwrdm, void *unused)
                return -ENOMEM;
 
        pwrst->pwrdm = pwrdm;
-       pwrst->next_state = PWRDM_POWER_RET;
+       pwrst->next_fpwrst = PWRDM_FUNC_PWRST_CSWR;
        list_add(&pwrst->node, &pwrst_list);
 
-       return omap_set_pwrdm_state(pwrst->pwrdm, pwrst->next_state);
+       return WARN_ON(pwrdm_set_fpwrst(pwrst->pwrdm, pwrst->next_fpwrst));
 }
 
 /**
 
 
--

To unsubscribe from this list: send the line "unsubscribe linux-omap" in the body of a message to majordomo at vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html

From: Jean Pihet <[email protected]>

The PM code uses some counters to keep track of the power domains transitions, in order to provide the information to drivers (in pwrdm_get_context_loss_count) and to expose the information to sysfs for debug purpose.

This patch provides the information for each functional state.

Signed-off-by Jean Pihet <[email protected]>

[paul at pwsan.com: use PWRDM_FPWRSTS_COUNT due to functional power state offset;
use powerdomain.c fn to convert func pwrsts to names; rename 'state' to 'fpwrst' to indicate use of func pwrsts; convert remaining users of the non-func pwrst API; add some kerneldoc]

Signed-off-by Paul Walmsley <[email protected]>

---
 arch/arm/mach-omap2/pm-debug.c    |   42 ++++-----
 arch/arm/mach-omap2/powerdomain.c |  167 ++++++++++++++++++-------------------
 arch/arm/mach-omap2/powerdomain.h |   17 ++--
 3 files changed, 108 insertions(+), 118 deletions(-)

arch/arm/mach-omap2/pm-debug.c +20 -22

index 806a06b..72cf9e0 100644
@@ -53,13 +53,6 @@ enum {
        DEBUG_FILE_TIMERS,
 };
 
-static const char pwrdm_state_names[][PWRDM_MAX_PWRSTS] = {
-       "OFF",
-       "RET",
-       "INA",
-       "ON"
-};
-
 void pm_dbg_update_time(struct powerdomain *pwrdm, int prev)
 {
        s64 t;

@@ -70,7 +63,7 @@ void pm_dbg_update_time(struct powerdomain *pwrdm, int prev)
        /* Update timer for previous state */
        t = sched_clock();
 
-       pwrdm->state_timer[prev] += t - pwrdm->timer;
+       pwrdm->fpwrst_timer[prev - PWRDM_FPWRST_OFFSET] += t - pwrdm->timer;
 
        pwrdm->timer = t;
 }

@@ -79,6 +72,7 @@ static int clkdm_dbg_show_counter(struct clockdomain *clkdm, void *user)
 {
        struct seq_file *s = (struct seq_file *)user;
 
+       /* XXX This needs to be implemented in a better way */
        if (strcmp(clkdm->name, "emu_clkdm") == 0 ||
                strcmp(clkdm->name, "wkup_clkdm") == 0 ||
                strncmp(clkdm->name, "dpll", 4) == 0)

@@ -94,23 +88,26 @@ static int pwrdm_dbg_show_counter(struct powerdomain *pwrdm, void *user)
 {
        struct seq_file *s = (struct seq_file *)user;
        int i;
+       int curr_fpwrst;
 
        if (strcmp(pwrdm->name, "emu_pwrdm") == 0 ||
                strcmp(pwrdm->name, "wkup_pwrdm") == 0 ||
                strncmp(pwrdm->name, "dpll", 4) == 0)
                return 0;
 
-       if (pwrdm->state != pwrdm_read_pwrst(pwrdm))
-               printk(KERN_ERR "pwrdm state mismatch(%s) %d != %d\n",
-                       pwrdm->name, pwrdm->state, pwrdm_read_pwrst(pwrdm));
+       curr_fpwrst = pwrdm_read_fpwrst(pwrdm);
+       if (pwrdm->fpwrst != curr_fpwrst)
+               pr_err("pwrdm state mismatch(%s) %s != %s\n",
+                      pwrdm->name,
+                      pwrdm_convert_fpwrst_to_name(pwrdm->fpwrst),
+                      pwrdm_convert_fpwrst_to_name(curr_fpwrst));
 
        seq_printf(s, "%s (%s)", pwrdm->name,
-                       pwrdm_state_names[pwrdm->state]);
-       for (i = 0; i < PWRDM_MAX_PWRSTS; i++)
-               seq_printf(s, ",%s:%d", pwrdm_state_names[i],
-                       pwrdm->state_counter[i]);
+                  pwrdm_convert_fpwrst_to_name(pwrdm->fpwrst));
+       for (i = PWRDM_FPWRST_OFFSET; i < PWRDM_MAX_FUNC_PWRSTS; i++)
+               seq_printf(s, ",%s:%d", pwrdm_convert_fpwrst_to_name(i),
+                          pwrdm->fpwrst_counter[i - PWRDM_FPWRST_OFFSET]);
 
-       seq_printf(s, ",RET-LOGIC-OFF:%d", pwrdm->ret_logic_off_counter);
        for (i = 0; i < pwrdm->banks; i++)
                seq_printf(s, ",RET-MEMBANK%d-OFF:%d", i + 1,
                                pwrdm->ret_mem_off_counter[i]);

@@ -133,11 +130,12 @@ static int pwrdm_dbg_show_timer(struct powerdomain *pwrdm, void *user)
        pwrdm_state_switch(pwrdm);
 
        seq_printf(s, "%s (%s)", pwrdm->name,
-               pwrdm_state_names[pwrdm->state]);
+                  pwrdm_convert_fpwrst_to_name(pwrdm->fpwrst));
 
-       for (i = 0; i < 4; i++)
-               seq_printf(s, ",%s:%lld", pwrdm_state_names[i],
-                       pwrdm->state_timer[i]);
+       for (i = 0; i < PWRDM_FPWRSTS_COUNT; i++)
+               seq_printf(s, ",%s:%lld",
+                          pwrdm_convert_fpwrst_to_name(i + PWRDM_FPWRST_OFFSET),
+                          pwrdm->fpwrst_timer[i]);
 
        seq_printf(s, "\n");
        return 0;

@@ -209,8 +207,8 @@ static int __init pwrdms_setup(struct powerdomain *pwrdm, void *dir)
 
        t = sched_clock();
 
-       for (i = 0; i < 4; i++)
-               pwrdm->state_timer[i] = 0;
+       for (i = 0; i < PWRDM_FPWRSTS_COUNT; i++)
+               pwrdm->fpwrst_timer[i] = 0;
 
        pwrdm->timer = t;
 

arch/arm/mach-omap2/powerdomain.c +4 -85

index 2c732b6..3e2e263 100644
@@ -115,97 +115,16 @@ static int _pwrdm_register(struct powerdomain *pwrdm)
        list_add(&pwrdm->node, &pwrdm_list);
 
        /* Initialize the powerdomain's state counter */
-       for (i = 0; i < PWRDM_MAX_PWRSTS; i++)
-               pwrdm->state_counter[i] = 0;
+       for (i = 0; i < PWRDM_FPWRSTS_COUNT; i++)
+               pwrdm->fpwrst_counter[i] = 0;
 
-       pwrdm->ret_logic_off_counter = 0;
        for (i = 0; i < pwrdm->banks; i++)
                pwrdm->ret_mem_off_counter[i] = 0;
 
        arch_pwrdm->pwrdm_wait_transition(pwrdm);
-       pwrdm->state = pwrdm_read_pwrst(pwrdm);
-       pwrdm->state_counter[pwrdm->state] = 1;
+       pwrdm->fpwrst = pwrdm_read_fpwrst(pwrdm);
+       pwrdm->fpwrst_counter[pwrdm->fpwrst - PWRDM_FPWRST_OFFSET] = 1;
 
-       pr_debug("powerdomain: registered %s\n", pwrdm->name);
-
-       return 0;
-}
-
-static void _update_logic_membank_counters(struct powerdomain *pwrdm)
-{
-       int i;
-       u8 prev_logic_pwrst, prev_mem_pwrst;
-
-       prev_logic_pwrst = pwrdm_read_prev_logic_pwrst(pwrdm);
-       if ((pwrdm->pwrsts_logic_ret == PWRSTS_OFF_RET) &&
-           (prev_logic_pwrst == PWRDM_POWER_OFF))
-               pwrdm->ret_logic_off_counter++;
-
-       for (i = 0; i < pwrdm->banks; i++) {
-               prev_mem_pwrst = pwrdm_read_prev_mem_pwrst(pwrdm, i);
-
-               if ((pwrdm->pwrsts_mem_ret[i] == PWRSTS_OFF_RET) &&
-                   (prev_mem_pwrst == PWRDM_POWER_OFF))
-                       pwrdm->ret_mem_off_counter[i]++;
-       }
-}
-
-static int _pwrdm_state_switch(struct powerdomain *pwrdm, int flag)
-{
-       int prev, next, state, trace_state = 0;
-
-       if (pwrdm == NULL)
-               return -EINVAL;
-
-       state = pwrdm_read_pwrst(pwrdm);
-
-       switch (flag) {
-       case PWRDM_STATE_NOW:
-               prev = pwrdm->state;
-               break;
-       case PWRDM_STATE_PREV:
-               prev = pwrdm_read_prev_pwrst(pwrdm);
-               if (pwrdm->state != prev)
-                       pwrdm->state_counter[prev]++;
-               if (prev == PWRDM_POWER_RET)
-                       _update_logic_membank_counters(pwrdm);
-               /*
-                * If the power domain did not hit the desired state,
-                * generate a trace event with both the desired and hit states
-                */
-               next = pwrdm_read_next_pwrst(pwrdm);
-               if (next != prev) {
-                       trace_state = (PWRDM_TRACE_STATES_FLAG |
-                                      ((next & OMAP_POWERSTATE_MASK) << 8) |
-                                      ((prev & OMAP_POWERSTATE_MASK) << 0));
-                       trace_power_domain_target(pwrdm->name, trace_state,
-                                                 smp_processor_id());
-               }
-               break;
-       default:
-               return -EINVAL;
-       }
-
-       if (state != prev)
-               pwrdm->state_counter[state]++;
-
-       pm_dbg_update_time(pwrdm, prev);
-
-       pwrdm->state = state;
-
-       return 0;
-}
-
-static int _pwrdm_pre_transition_cb(struct powerdomain *pwrdm, void *unused)
-{
-       pwrdm_clear_all_prev_pwrst(pwrdm);
-       _pwrdm_state_switch(pwrdm, PWRDM_STATE_NOW);
-       return 0;
-}
-
-static int _pwrdm_post_transition_cb(struct powerdomain *pwrdm, void *unused)
-{
-       _pwrdm_state_switch(pwrdm, PWRDM_STATE_PREV);
        return 0;
 }
 

arch/arm/mach-omap2/powerdomain.c +74 -3

+static int _pwrdm_state_switch(struct powerdomain *pwrdm, int flag)
+{
+       int prev, next, fpwrst, trace_state = 0;
+       int i;
+       u8 prev_mem_pwrst;
+
+       if (pwrdm == NULL)
+               return -EINVAL;
+
+       fpwrst = _pwrdm_read_fpwrst(pwrdm);
+
+       switch (flag) {
+       case PWRDM_STATE_NOW:
+               prev = pwrdm->fpwrst;
+               break;
+       case PWRDM_STATE_PREV:
+               prev = _pwrdm_read_prev_fpwrst(pwrdm);
+               if (pwrdm->fpwrst != prev)
+                       pwrdm->fpwrst_counter[prev - PWRDM_FPWRST_OFFSET]++;
+               if (prev == PWRDM_FUNC_PWRST_CSWR ||
+                   prev == PWRDM_FUNC_PWRST_OSWR) {
+                       for (i = 0; i < pwrdm->banks; i++) {
+                               prev_mem_pwrst =
+                                       pwrdm_read_prev_mem_pwrst(pwrdm, i);
+                               if ((pwrdm->pwrsts_mem_ret[i] ==
+                                    PWRSTS_OFF_RET) &&
+                                   (prev_mem_pwrst == PWRDM_POWER_OFF))
+                                       pwrdm->ret_mem_off_counter[i]++;
+                       }
+               }
+               /*
+                * If the power domain did not hit the desired state,
+                * generate a trace event with both the desired and hit states
+                */
+               next = _pwrdm_read_next_fpwrst(pwrdm);
+               if (next != prev) {
+                       trace_state = (PWRDM_TRACE_STATES_FLAG | next << 8 |
+                                      prev);
+                       trace_power_domain_target(pwrdm->name, trace_state,
+                                                 smp_processor_id());
+               }
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       if (fpwrst != prev)
+               pwrdm->fpwrst_counter[fpwrst - PWRDM_FPWRST_OFFSET]++;
+
+       pm_dbg_update_time(pwrdm, prev);
+
+       pwrdm->fpwrst = fpwrst;
+
+       return 0;
+}
+
+static int _pwrdm_pre_transition_cb(struct powerdomain *pwrdm, void *unused)
+{
+       pwrdm_clear_all_prev_pwrst(pwrdm);
+       _pwrdm_state_switch(pwrdm, PWRDM_STATE_NOW);
+       return 0;
+}
+
+static int _pwrdm_post_transition_cb(struct powerdomain *pwrdm, void *unused)
+{
+       _pwrdm_state_switch(pwrdm, PWRDM_STATE_PREV);
+       return 0;
+}
+
 /* Public functions */
 
 /**

@@ -638,7 +627,7 @@ int pwrdm_complete_init(void)
                return -EACCES;
 
        list_for_each_entry(temp_p, &pwrdm_list, node)
-               pwrdm_set_next_pwrst(temp_p, PWRDM_POWER_ON);
+               pwrdm_set_next_fpwrst(temp_p, PWRDM_FUNC_PWRST_ON);
 
        return 0;
 }

@@ -1459,8 +1448,10 @@ int pwrdm_get_context_loss_count(struct powerdomain *pwrdm)
                return -ENODEV;
        }
 
-       count = pwrdm->state_counter[PWRDM_POWER_OFF];
-       count += pwrdm->ret_logic_off_counter;
+       count = pwrdm->fpwrst_counter[PWRDM_FUNC_PWRST_OFF -
+                                     PWRDM_FPWRST_OFFSET];
+       count += pwrdm->fpwrst_counter[PWRDM_FUNC_PWRST_OSWR -
+                                      PWRDM_FPWRST_OFFSET];
 
        for (i = 0; i < pwrdm->banks; i++)
                count += pwrdm->ret_mem_off_counter[i];

arch/arm/mach-omap2/powerdomain.h +9 -9

index be835ff..849bc55 100644
@@ -46,6 +46,8 @@ enum pwrdm_func_state {
        PWRDM_MAX_FUNC_PWRSTS           /* Last value, used as the max value */
 };
 
+#define PWRDM_FPWRSTS_COUNT    (PWRDM_MAX_FUNC_PWRSTS - PWRDM_FPWRST_OFFSET)
+
 /* Powerdomain basic power states */
 #define PWRDM_POWER_OFF                0x0
 #define PWRDM_POWER_RET                0x1

@@ -123,10 +125,10 @@ struct powerdomain;
  * @mem_pwrst_mask: (AM33XX only) mask for mem state bitfield in @pwrstst_offs
  * @mem_retst_mask: (AM33XX only) mask for mem retention state bitfield
  *     in @pwrstctrl_offs
- * @state:
- * @state_counter:
- * @timer:
- * @state_timer:
+ * @fpwrst: current func power state (set during pwrdm_(pre|post)_transition())
+ * @fpwrst_counter: estimated number of times the pwrdm entered the power states
+ * @timer: sched_clock() timestamp of last pwrdm_state_switch()
+ * @fpwrst_timer: estimated nanoseconds of residency in the various power states
  * @_lock: spinlock used to serialize powerdomain and some clockdomain ops
  * @_lock_flags: stored flags when @_lock is taken
  *

@@ -146,12 +148,11 @@ struct powerdomain {
        const u8 pwrsts_mem_ret[PWRDM_MAX_MEM_BANKS];
        const u8 pwrsts_mem_on[PWRDM_MAX_MEM_BANKS];
        const u8 prcm_partition;
+       u8 fpwrst;
        struct clockdomain *pwrdm_clkdms[PWRDM_MAX_CLKDMS];
        struct list_head node;
        struct list_head voltdm_node;
-       int state;
-       unsigned state_counter[PWRDM_MAX_PWRSTS];
-       unsigned ret_logic_off_counter;
+       unsigned fpwrst_counter[PWRDM_FPWRSTS_COUNT];
        unsigned ret_mem_off_counter[PWRDM_MAX_MEM_BANKS];
        spinlock_t _lock;
        unsigned long _lock_flags;

@@ -165,7 +166,7 @@ struct powerdomain {
 
 #ifdef CONFIG_PM_DEBUG
        s64 timer;
-       s64 state_timer[PWRDM_MAX_PWRSTS];
+       s64 fpwrst_timer[PWRDM_FPWRSTS_COUNT];
 #endif
 };
 
 
 
--

To unsubscribe from this list: send the line "unsubscribe linux-omap" in the body of a message to majordomo at vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html

From: Jean Pihet <[email protected]>

The PM code uses some counters to keep track of the power domains transitions, in order to provide the information to drivers (in pwrdm_get_context_loss_count) and to expose the information to sysfs for debug purpose.

This patch provides the information for each functional state.

Signed-off-by Jean Pihet <[email protected]>

[paul at pwsan.com: use PWRDM_FPWRSTS_COUNT due to functional power state offset;
use powerdomain.c fn to convert func pwrsts to names; rename 'state' to 'fpwrst' to indicate use of func pwrsts; convert remaining users of the non-func pwrst API; add some kerneldoc]

Signed-off-by Paul Walmsley <[email protected]>

---
 arch/arm/mach-omap2/pm-debug.c    |   42 ++++-----
 arch/arm/mach-omap2/powerdomain.c |  167 ++++++++++++++++++-------------------
 arch/arm/mach-omap2/powerdomain.h |   17 ++--
 3 files changed, 108 insertions(+), 118 deletions(-)

arch/arm/mach-omap2/pm-debug.c +1 -8

index 806a06b..72cf9e0 100644
@@ -53,13 +53,6 @@ enum {
 	DEBUG_FILE_TIMERS,
 };
 
-static const char pwrdm_state_names[][PWRDM_MAX_PWRSTS] = {
-	"OFF",
-	"RET",
-	"INA",
-	"ON"
-};
-
 void pm_dbg_update_time(struct powerdomain *pwrdm, int prev)
 {
 	s64 t;

@@ -70,7 +63,7 @@ void pm_dbg_update_time(struct powerdomain *pwrdm, int prev)
 	/* Update timer for previous state */
 	t = sched_clock();
 
-	pwrdm->state_timer[prev] += t - pwrdm->timer;
+	pwrdm->fpwrst_timer[prev - PWRDM_FPWRST_OFFSET] += t - pwrdm->timer;
 
 	pwrdm->timer = t;
 }