PM QOS update

This patch changes the string based list management to a handle base
implementation to help with the hot path use of pm-qos, it also renames
much of the API to use "request" as opposed to "requirement" that was
used in the initial implementation.  I did this because request more
accurately represents what it actually does.

Also, I added a string based ABI for users wanting to use a string
interface.  So if the user writes 0xDDDDDDDD formatted hex it will be
accepted by the interface.  (someone asked me for it and I don't think
it hurts anything.)

This patch updates some documentation input I got from Randy.

Signed-off-by: markgross <mgross@linux.intel.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>

1 files changed, 103 insertions, 111 deletions

diff --git a/kernel/pm_qos_params.c b/kernel/pm_qos_params.c
index 3db49b9ca374..a1aea040eb57 100644
--- a/kernel/pm_qos_params.c
+++ b/kernel/pm_qos_params.c
@@ -2,7 +2,7 @@
  * This module exposes the interface to kernel space for specifying
  * QoS dependencies.  It provides infrastructure for registration of:
  *
- * Dependents on a QoS value : register requirements
+ * Dependents on a QoS value : register requests
  * Watchers of QoS value : get notified when target QoS value changes
  *
  * This QoS design is best effort based.  Dependents register their QoS needs.
@@ -14,19 +14,21 @@
  * timeout: usec <-- currently not used.
  * throughput: kbs (kilo byte / sec)
  *
- * There are lists of pm_qos_objects each one wrapping requirements, notifiers
+ * There are lists of pm_qos_objects each one wrapping requests, notifiers
  *
- * User mode requirements on a QOS parameter register themselves to the
+ * User mode requests on a QOS parameter register themselves to the
  * subsystem by opening the device node /dev/... and writing there request to
  * the node.  As long as the process holds a file handle open to the node the
  * client continues to be accounted for.  Upon file release the usermode
- * requirement is removed and a new qos target is computed.  This way when the
- * requirement that the application has is cleaned up when closes the file
+ * request is removed and a new qos target is computed.  This way when the
+ * request that the application has is cleaned up when closes the file
  * pointer or exits the pm_qos_object will get an opportunity to clean up.
  *
  * Mark Gross <mgross@linux.intel.com>
  */
 
+/*#define DEBUG*/
+
 #include <linux/pm_qos_params.h>
 #include <linux/sched.h>
 #include <linux/spinlock.h>
@@ -42,25 +44,25 @@
 #include <linux/uaccess.h>
 
 /*
- * locking rule: all changes to requirements or notifiers lists
+ * locking rule: all changes to requests or notifiers lists
  * or pm_qos_object list and pm_qos_objects need to happen with pm_qos_lock
  * held, taken with _irqsave.  One lock to rule them all
  */
-struct requirement_list {
+struct pm_qos_request_list {
         struct list_head list;
         union {
                 s32 value;
                 s32 usec;
                 s32 kbps;
         };
-        char *name;
+        int pm_qos_class;
 };
 
 static s32 max_compare(s32 v1, s32 v2);
 static s32 min_compare(s32 v1, s32 v2);
 
 struct pm_qos_object {
-        struct requirement_list requirements;
+        struct pm_qos_request_list requests;
         struct blocking_notifier_head *notifiers;
         struct miscdevice pm_qos_power_miscdev;
         char *name;
@@ -72,7 +74,7 @@ struct pm_qos_object {
 static struct pm_qos_object null_pm_qos;
 static BLOCKING_NOTIFIER_HEAD(cpu_dma_lat_notifier);
 static struct pm_qos_object cpu_dma_pm_qos = {
-        .requirements = {LIST_HEAD_INIT(cpu_dma_pm_qos.requirements.list)},
+        .requests = {LIST_HEAD_INIT(cpu_dma_pm_qos.requests.list)},
         .notifiers = &cpu_dma_lat_notifier,
         .name = "cpu_dma_latency",
         .default_value = 2000 * USEC_PER_SEC,
@@ -82,7 +84,7 @@ static struct pm_qos_object cpu_dma_pm_qos = {
 
 static BLOCKING_NOTIFIER_HEAD(network_lat_notifier);
 static struct pm_qos_object network_lat_pm_qos = {
-        .requirements = {LIST_HEAD_INIT(network_lat_pm_qos.requirements.list)},
+        .requests = {LIST_HEAD_INIT(network_lat_pm_qos.requests.list)},
         .notifiers = &network_lat_notifier,
         .name = "network_latency",
         .default_value = 2000 * USEC_PER_SEC,
@@ -93,8 +95,7 @@ static struct pm_qos_object network_lat_pm_qos = {
 
 static BLOCKING_NOTIFIER_HEAD(network_throughput_notifier);
 static struct pm_qos_object network_throughput_pm_qos = {
-        .requirements =
-                {LIST_HEAD_INIT(network_throughput_pm_qos.requirements.list)},
+        .requests = {LIST_HEAD_INIT(network_throughput_pm_qos.requests.list)},
         .notifiers = &network_throughput_notifier,
         .name = "network_throughput",
         .default_value = 0,
@@ -135,31 +136,34 @@ static s32 min_compare(s32 v1, s32 v2)
 }
 
 
-static void update_target(int target)
+static void update_target(int pm_qos_class)
 {
         s32 extreme_value;
-        struct requirement_list *node;
+        struct pm_qos_request_list *node;
         unsigned long flags;
         int call_notifier = 0;
 
         spin_lock_irqsave(&pm_qos_lock, flags);
-        extreme_value = pm_qos_array[target]->default_value;
+        extreme_value = pm_qos_array[pm_qos_class]->default_value;
         list_for_each_entry(node,
-                        &pm_qos_array[target]->requirements.list, list) {
-                extreme_value = pm_qos_array[target]->comparitor(
+                        &pm_qos_array[pm_qos_class]->requests.list, list) {
+                extreme_value = pm_qos_array[pm_qos_class]->comparitor(
                                 extreme_value, node->value);
         }
-        if (atomic_read(&pm_qos_array[target]->target_value) != extreme_value) {
+        if (atomic_read(&pm_qos_array[pm_qos_class]->target_value) !=
+                        extreme_value) {
                 call_notifier = 1;
-                atomic_set(&pm_qos_array[target]->target_value, extreme_value);
-                pr_debug(KERN_ERR "new target for qos %d is %d\n", target,
-                        atomic_read(&pm_qos_array[target]->target_value));
+                atomic_set(&pm_qos_array[pm_qos_class]->target_value,
+                                extreme_value);
+                pr_debug(KERN_ERR "new target for qos %d is %d\n", pm_qos_class,
+                        atomic_read(&pm_qos_array[pm_qos_class]->target_value));
         }
         spin_unlock_irqrestore(&pm_qos_lock, flags);
 
         if (call_notifier)
-                blocking_notifier_call_chain(pm_qos_array[target]->notifiers,
-                        (unsigned long) extreme_value, NULL);
+                blocking_notifier_call_chain(
+                                pm_qos_array[pm_qos_class]->notifiers,
+                                        (unsigned long) extreme_value, NULL);
 }
 
 static int register_pm_qos_misc(struct pm_qos_object *qos)
@@ -185,125 +189,110 @@ static int find_pm_qos_object_by_minor(int minor)
 }
 
 /**
- * pm_qos_requirement - returns current system wide qos expectation
+ * pm_qos_request - returns current system wide qos expectation
  * @pm_qos_class: identification of which qos value is requested
  *
  * This function returns the current target value in an atomic manner.
  */
-int pm_qos_requirement(int pm_qos_class)
+int pm_qos_request(int pm_qos_class)
 {