[PATCH] maximum latency tracking infrastructure

Add infrastructure to track "maximum allowable latency" for power saving
policies.

The reason for adding this infrastructure is that power management in the
idle loop needs to make a tradeoff between latency and power savings
(deeper power save modes have a longer latency to running code again).  The
code that today makes this tradeoff just does a rather simple algorithm;
however this is not good enough: There are devices and use cases where a
lower latency is required than that the higher power saving states provide.
 An example would be audio playback, but another example is the ipw2100
wireless driver that right now has a very direct and ugly acpi hook to
disable some higher power states randomly when it gets certain types of
error.

The proposed solution is to have an interface where drivers can

* announce the maximum latency (in microseconds) that they can deal with
* modify this latency
* give up their constraint

and a function where the code that decides on power saving strategy can
query the current global desired maximum.

This patch has a user of each side: on the consumer side, ACPI is patched
to use this, on the producer side the ipw2100 driver is patched.

A generic maximum latency is also registered of 2 timer ticks (more and you
lose accurate time tracking after all).

While the existing users of the patch are x86 specific, the infrastructure
is not.  I'd like to ask the arch maintainers of other architectures if the
infrastructure is generic enough for their use (assuming the architecture
has such a tradeoff as concept at all), and the sound/multimedia driver
owners to look at the driver facing API to see if this is something they
can use.

[akpm@osdl.org: cleanups]
Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Acked-by: Jesse Barnes <jesse.barnes@intel.com>
Cc: "Brown, Len" <len.brown@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

2 files changed, 44 insertions, 4 deletions

diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 71066066d626..0a395fca843b 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -38,6 +38,7 @@
 #include <linux/dmi.h>
 #include <linux/moduleparam.h>
 #include <linux/sched.h>        /* need_resched() */
+#include <linux/latency.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -453,7 +454,8 @@ static void acpi_processor_idle(void)
          */
         if (cx->promotion.state &&
             ((cx->promotion.state - pr->power.states) <= max_cstate)) {
-                if (sleep_ticks > cx->promotion.threshold.ticks) {
+                if (sleep_ticks > cx->promotion.threshold.ticks &&
+                  cx->promotion.state->latency <= system_latency_constraint()) {
                         cx->promotion.count++;
                         cx->demotion.count = 0;
                         if (cx->promotion.count >=
@@ -494,8 +496,10 @@ static void acpi_processor_idle(void)
       end:
         /*
          * Demote if current state exceeds max_cstate
+         * or if the latency of the current state is unacceptable
          */
-        if ((pr->power.state - pr->power.states) > max_cstate) {
+        if ((pr->power.state - pr->power.states) > max_cstate ||
+                pr->power.state->latency > system_latency_constraint()) {
                 if (cx->demotion.state)
                         next_state = cx->demotion.state;
         }
@@ -1009,9 +1013,11 @@ static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
 
         seq_printf(seq, "active state:            C%zd\n"
                    "max_cstate:              C%d\n"
-                   "bus master activity:     %08x\n",
+                   "bus master activity:     %08x\n"
+                   "maximum allowed latency: %d usec\n",
                    pr->power.state ? pr->power.state - pr->power.states : 0,
-                   max_cstate, (unsigned)pr->power.bm_activity);
+                   max_cstate, (unsigned)pr->power.bm_activity,
+                   system_latency_constraint());
 
         seq_puts(seq, "states:\n");
 
@@ -1077,6 +1083,28 @@ static const struct file_operations acpi_processor_power_fops = {
         .release = single_release,
 };
 
+static void smp_callback(void *v)
+{
+        /* we already woke the CPU up, nothing more to do */
+}
+
+/*
+ * This function gets called when a part of the kernel has a new latency
+ * requirement.  This means we need to get all processors out of their C-state,
+ * and then recalculate a new suitable C-state. Just do a cross-cpu IPI; that
+ * wakes them all right up.
+ */
+static int acpi_processor_latency_notify(struct notifier_block *b,
+                unsigned long l, void *v)
+{
+        smp_call_function(smp_callback, NULL, 0, 1);
+        return NOTIFY_OK;
+}
+
+static struct notifier_block acpi_processor_latency_notifier = {
+        .notifier_call = acpi_processor_latency_notify,
+};
+
 int acpi_processor_power_init(struct acpi_processor *pr,
                               struct acpi_device *device)
 {
@@ -1093,6 +1121,7 @@ int acpi_processor_power_init(struct acpi_processor *pr,
                                "ACPI: processor limited to max C-state %d\n",
                                max_cstate);
                 first_run++;
+                register_latency_notifier(&acpi_processor_latency_notifier);
         }
 
         if (!pr)
@@ -1164,6 +1193,7 @@ int acpi_processor_power_exit(struct acpi_processor *pr,
                  * copies of pm_idle before proceeding.
                  */
                 cpu_idle_wait();
+                unregister_latency_notifier(&acpi_processor_latency_notifier);
         }
 
         return 0;
diff --git a/drivers/net/wireless/ipw2100.c b/drivers/net/wireless/ipw2100.c
index 6c5add701a6f..97937809de09 100644
--- a/drivers/net/wireless/ipw2100.c
+++ b/drivers/net/wireless/ipw2100.c
@@ -163,6 +163,7 @@ that only one external action is invoked at a time.
 #include <linux/firmware.h>
 #include <linux/acpi.h>
 #include <linux/ctype.h>
+#include <linux/latency.h>
 
 #include "ipw2100.h"
 
@@ -1697,6 +1698,11 @@ static int ipw2100_up(struct ipw2100_priv *priv, int deferred)
                 return 0;
         }
 
+        /* the ipw2100 hardware really doesn't want power management delays
+         * longer than 175usec
+         */
+        modify_acceptable_latency("ipw2100", 175);
+
         /* If the interrupt is enabled, turn it off... */
         spin_lock_irqsave(&priv->low_lock, flags);
         ipw2100_disable_interrupts(priv);
@@ -1849,6 +1855,8 @@ static void ipw2100_down(struct ipw2100_priv *priv)
         ipw2100_disable_interrupts(priv);
         spin_unlock_irqrestore(&priv->low_lock, flags);
 
+        modify_acceptable_latency("ipw2100", INFINITE_LATENCY);
+
 #ifdef ACPI_CSTATE_LIMIT_DEFINED
         if (priv->config & CFG_C3_DISABLED) {
                 IPW_DEBUG_INFO(": Resetting C3 transitions.\n");
@@ -6534,6 +6542,7 @@ static int __init ipw2100_init(void)
 
         ret = pci_register_driver(&ipw2100_pci_driver);
 
+        set_acceptable_latency("ipw2100", INFINITE_LATENCY);
 #ifdef CONFIG_IPW2100_DEBUG
         ipw2100_debug_level = debug;
         driver_create_file(&ipw2100_pci_driver.driver,
@@ -6554,6 +6563,7 @@ static void __exit ipw2100_exit(void)
                            &driver_attr_debug_level);
 #endif
         pci_unregister_driver(&ipw2100_pci_driver);
+        remove_acceptable_latency("ipw2100");
 }
 
 module_init(ipw2100_init);