Merge branch 'pm-assorted'

Two different PM QoS frameworks are available:

1. PM QoS classes for cpu_dma_latency, network_latency, network_throughput.

2. the per-device PM QoS framework provides the API to manage the per-device latency

constraints.

constraints and PM QoS flags.

Each parameters have defined units:

 * latency: usec

node.

2. PM QoS per-device latency framework

2. PM QoS per-device latency and flags framework

For each device, there are two lists of PM QoS requests. One is maintained

along with the aggregated target of latency value and the other is for PM QoS

flags. Values are updated in response to changes of the request list.

Target latency value is simply the minimum of the request values held in the

parameter list elements.  The PM QoS flags aggregate value is a gather (bitwise

OR) of all list elements' values. Two device PM QoS flags are defined currently:

PM_QOS_FLAG_NO_POWER_OFF and PM_QOS_FLAG_REMOTE_WAKEUP.

For each device a list of performance requests is maintained along with

an aggregated target value.  The aggregated target value is updated with

changes to the request list or elements of the list.  Typically the

aggregated target value is simply the max or min of the request values held

in the parameter list elements.

Note: the aggregated target value is implemented as an atomic variable so that

reading the aggregated value does not require any locking mechanism.

s32 dev_pm_qos_read_value(device):

Returns the aggregated value for a given device's constraints list.

enum pm_qos_flags_status dev_pm_qos_flags(device, mask)

Check PM QoS flags of the given device against the given mask of flags.

The meaning of the return values is as follows:

	PM_QOS_FLAGS_ALL: All flags from the mask are set

	PM_QOS_FLAGS_SOME: Some flags from the mask are set

	PM_QOS_FLAGS_NONE: No flags from the mask are set

	PM_QOS_FLAGS_UNDEFINED: The device's PM QoS structure has not been

			initialized or the list of requests is empty.

int dev_pm_qos_add_ancestor_request(dev, handle, value)

Add a PM QoS request for the first direct ancestor of the given device whose

power.ignore_children flag is unset.

int dev_pm_qos_expose_latency_limit(device, value)

Add a request to the device's PM QoS list of latency constraints and create

a sysfs attribute pm_qos_resume_latency_us under the device's power directory

allowing user space to manipulate that request.

void dev_pm_qos_hide_latency_limit(device)

Drop the request added by dev_pm_qos_expose_latency_limit() from the device's

PM QoS list of latency constraints and remove sysfs attribute pm_qos_resume_latency_us

from the device's power directory.

int dev_pm_qos_expose_flags(device, value)

Add a request to the device's PM QoS list of flags and create sysfs attributes

pm_qos_no_power_off and pm_qos_remote_wakeup under the device's power directory

allowing user space to change these flags' value.

void dev_pm_qos_hide_flags(device)

Drop the request added by dev_pm_qos_expose_flags() from the device's PM QoS list

of flags and remove sysfs attributes pm_qos_no_power_off and pm_qos_remote_wakeup

under the device's power directory.

Notification mechanisms:

The per-device PM QoS framework has 2 different and distinct notification trees:

(or driver) in question, but the expected and recommended action is to check

if the device can be suspended (i.e. if all of the conditions necessary for

suspending the device are satisfied) and to queue up a suspend request for the

device in that case.  The value returned by this callback is ignored by the PM

core.

device in that case.  If there is no idle callback, or if the callback returns

0, then the PM core will attempt to carry out a runtime suspend of the device;

in essence, it will call pm_runtime_suspend() directly.  To prevent this (for

example, if the callback routine has started a delayed suspend), the routine

should return a non-zero value.  Negative error return codes are ignored by the

PM core.

The helper functions provided by the PM core, described in Section 4, guarantee

that the following constraints are met with respect to runtime PM callbacks for

      removing the device from device hierarchy

  int pm_runtime_idle(struct device *dev);

    - execute the subsystem-level idle callback for the device; returns 0 on

      success or error code on failure, where -EINPROGRESS means that

      ->runtime_idle() is already being executed

    - execute the subsystem-level idle callback for the device; returns an

      error code on failure, where -EINPROGRESS means that ->runtime_idle() is

      already being executed; if there is no callback or the callback returns 0

      then run pm_runtime_suspend(dev) and return its result

  int pm_runtime_suspend(struct device *dev);

    - execute the subsystem-level suspend callback for the device; returns 0 on

management callbacks provided by the PM core, defined in

driver/base/power/generic_ops.c:

  int pm_generic_runtime_idle(struct device *dev);

    - invoke the ->runtime_idle() callback provided by the driver of this

      device, if defined, and call pm_runtime_suspend() for this device if the

      return value is 0 or the callback is not defined

  int pm_generic_runtime_suspend(struct device *dev);

    - invoke the ->runtime_suspend() callback provided by the driver of this

      device and return its result, or return -EINVAL if not defined

The first parameter gives the power domain name (e.g. "mpu_pwrdm").

The second parameter is the power domain target state.

4. PM QoS events

================

The PM QoS events are used for QoS add/update/remove request and for

target/flags update.

pm_qos_add_request                 "pm_qos_class=%s value=%d"

pm_qos_update_request              "pm_qos_class=%s value=%d"

pm_qos_remove_request              "pm_qos_class=%s value=%d"

pm_qos_update_request_timeout      "pm_qos_class=%s value=%d, timeout_us=%ld"

The first parameter gives the QoS class name (e.g. "CPU_DMA_LATENCY").

The second parameter is value to be added/updated/removed.

The third parameter is timeout value in usec.

pm_qos_update_target               "action=%s prev_value=%d curr_value=%d"

pm_qos_update_flags                "action=%s prev_value=0x%x curr_value=0x%x"

The first parameter gives the QoS action name (e.g. "ADD_REQ").

The second parameter is the previous QoS value.

The third parameter is the current QoS value to update.

And, there are also events used for device PM QoS add/update/remove request.

dev_pm_qos_add_request             "device=%s type=%s new_value=%d"

dev_pm_qos_update_request          "device=%s type=%s new_value=%d"

dev_pm_qos_remove_request          "device=%s type=%s new_value=%d"

The first parameter gives the device name which tries to add/update/remove

QoS requests.

The second parameter gives the request type (e.g. "DEV_PM_QOS_LATENCY").

The third parameter is value to be added/updated/removed.

	return ret;

}

static int _od_runtime_idle(struct device *dev)

{

	return pm_generic_runtime_idle(dev);

}

static int _od_runtime_resume(struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);

struct dev_pm_domain omap_device_pm_domain = {

	.ops = {

		SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume,

				   _od_runtime_idle)

				   NULL)

		USE_PLATFORM_PM_SLEEP_OPS

		.suspend_noirq = _od_suspend_noirq,

		.resume_noirq = _od_resume_noirq,

#ifdef CONFIG_PM_RUNTIME

		.runtime_suspend = acpi_subsys_runtime_suspend,

		.runtime_resume = acpi_subsys_runtime_resume,

		.runtime_idle = pm_generic_runtime_idle,

#endif

#ifdef CONFIG_PM_SLEEP

		.prepare = acpi_subsys_prepare,