1 files changed, 106 insertions, 112 deletions

diff --git a/kernel/pm_qos_params.c b/kernel/pm_qos_params.c
index 3db49b9ca37..f42d3f737a3 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,112 @@ 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)
 {
         return atomic_read(&pm_qos_array[pm_qos_class]->target_value);
 }
-EXPORT_SYMBOL_GPL(pm_qos_requirement);
+EXPORT_SYMBOL_GPL(pm_qos_request);
 
 /**
- * pm_qos_add_requirement - inserts new qos request into the list
+ * pm_qos_add_request - inserts new qos request into the list
  * @pm_qos_class: identifies which list of qos request to us
- * @name: identifies the request
  * @value: defines the qos request
  *
  * This function inserts a new entry in the pm_qos_class list of requested qos
  * performance characteristics.  It recomputes the aggregate QoS expectations
- * for the pm_qos_class of parameters.
+ * for the pm_qos_class of parameters, and returns the pm_qos_request list
+ * element as a handle for use in updating and removal.  Call needs to save
+ * this handle for later use.
  */
-int pm_qos_add_requirement(int pm_qos_class, char *name, s32 value)
+struct pm_qos_request_list *pm_qos_add_request(int pm_qos_class, s32 value)
 {
-        struct requirement_list *dep;
+        struct pm_qos_request_list *dep;
         unsigned long flags;
 
-        dep = kzalloc(sizeof(struct requirement_list), GFP_KERNEL);
+        dep = kzalloc(sizeof(struct pm_qos_request_list), GFP_KERNEL);
         if (dep) {
                 if (value == PM_QOS_DEFAULT_VALUE)
                         dep->value = pm_qos_array[pm_qos_class]->default_value;
                 else
                         dep->value = value;
-                dep->name = kstrdup(name, GFP_KERNEL);
-                if (!dep->name)
-                        goto cleanup;
+                dep->pm_qos_class = pm_qos_class;
 
                 spin_lock_irqsave(&pm_qos_lock, flags);
                 list_add(&dep->list,
-                        &pm_qos_array[pm_qos_class]->requirements.list);
+                        &pm_qos_array[pm_qos_class]->requests.list);
                 spin_unlock_irqrestore(&pm_qos_lock, flags);
                 update_target(pm_qos_class);
-
-                return 0;
         }
 
-cleanup:
-        kfree(dep);
-        return -ENOMEM;
+        return dep;
 }
-EXPORT_SYMBOL_GPL(pm_qos_add_requirement);
+EXPORT_SYMBOL_GPL(pm_qos_add_request);
 
 /**
- * pm_qos_update_requirement - modifies an existing qos request
- * @pm_qos_class: identifies which list of qos request to us
- * @name: identifies the request
+ * pm_qos_update_request - modifies an existing qos request
+ * @pm_qos_req : handle to list element holding a pm_qos request to use
  * @value: defines the qos request
  *
- * Updates an existing qos requirement for the pm_qos_class of parameters along
+ * Updates an existing qos request for the pm_qos_class of parameters along
  * with updating the target pm_qos_class value.
  *
- * If the named request isn't in the list then no change is made.
+ * Attempts are made to make this code callable on hot code paths.
  */
-int pm_qos_update_requirement(int pm_qos_class, char *name, s32 new_value)
+void pm_qos_update_request(struct pm_qos_request_list *pm_qos_req,
+                s32 new_value)
 {
         unsigned long flags;
-        struct requirement_list *node;
         int pending_update = 0;
+        s32 temp;
 
-        spin_lock_irqsave(&pm_qos_lock, flags);
-        list_for_each_entry(node,
-                &pm_qos_array[pm_qos_class]->requirements.list, list) {
-                if (strcmp(node->name, name) == 0) {
-                        if (new_value == PM_QOS_DEFAULT_VALUE)
-                                node->value =
-                                pm_qos_array[pm_qos_class]->default_value;
-                        else
-                                node->value = new_value;
+        if (pm_qos_req) { /*guard against callers passing in null */
+                spin_lock_irqsave(&pm_qos_lock, flags);
+                if (new_value == PM_QOS_DEFAULT_VALUE)
+                        temp = pm_qos_array[pm_qos_req->pm_qos_class]->default_value;
+                else
+                        temp = new_value;
+
+                if (temp != pm_qos_req->value) {
                         pending_update = 1;
-                        break;
+                        pm_qos_req->value = temp;
                 }
+                spin_unlock_irqrestore(&pm_qos_lock, flags);
+                if (pending_update)
+                        update_target(pm_qos_req->pm_qos_class);
         }
-        spin_unlock_irqrestore(&pm_qos_lock, flags);
-        if (pending_update)
-                update_target(pm_qos_class);
-
-        return 0;
 }
-EXPORT_SYMBOL_GPL(pm_qos_update_requirement);
+EXPORT_SYMBOL_GPL(pm_qos_update_request);
 
 /**
- * pm_qos_remove_requirement - modifies an existing qos request
- * @pm_qos_class: identifies which list of qos request to us
- * @name: identifies the request
+ * pm_qos_remove_request - modifies an existing qos request
+ * @pm_qos_req: handle to request list element
  *
- * Will remove named qos request from pm_qos_class list of parameters and
- * recompute the current target value for the pm_qos_class.
+ * Will remove pm qos request from the list of requests and
+ * recompute the current target value for the pm_qos_class.  Call this
+ * on slow code paths.
  */
-void pm_qos_remove_requirement(int pm_qos_class, char *name)
+void pm_qos_remove_request(struct pm_qos_request_list *pm_qos_req)
 {
         unsigned long flags;
-        struct requirement_list *node;
-        int pending_update = 0;
+        int qos_class;
 
+        if (pm_qos_req == NULL)
+                return;
+                /* silent return to keep pcm code cleaner */
+
+        qos_class = pm_qos_req->pm_qos_class;
         spin_lock_irqsave(&pm_qos_lock, flags);
-        list_for_each_entry(node,
-                &pm_qos_array[pm_qos_class]->requirements.list, list) {
-                if (strcmp(node->name, name) == 0) {
-                        kfree(node->name);
-                        list_del(&node->list);
-                        kfree(node);
-                        pending_update = 1;
-                        break;
-                }
-        }
+        list_del(&pm_qos_req->list);
+        kfree(pm_qos_req);
         spin_unlock_irqrestore(&pm_qos_lock, flags);
-        if (pending_update)
-                update_target(pm_qos_class);
+        update_target(qos_class);
 }
-EXPORT_SYMBOL_GPL(pm_qos_remove_requirement);
+EXPORT_SYMBOL_GPL(pm_qos_remove_request);
 
 /**
  * pm_qos_add_notifier - sets notification entry for changes to target value
@@ -313,7 +304,7 @@ EXPORT_SYMBOL_GPL(pm_qos_remove_requirement);
  * will register the notifier into a notification chain that gets called
  * upon changes to the pm_qos_class target value.
  */
- int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier)
+int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier)
 {
         int retval;
 
@@ -343,21 +334,16 @@ int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier)
 }
 EXPORT_SYMBOL_GPL(pm_qos_remove_notifier);
 
-#define PID_NAME_LEN 32
-
 static int pm_qos_power_open(struct inode *inode, struct file *filp)
 {
-        int ret;
         long pm_qos_class;
-        char name[PID_NAME_LEN];
 
         pm_qos_class = find_pm_qos_object_by_minor(iminor(inode));
         if (pm_qos_class >= 0) {
-                filp->private_data = (void *)pm_qos_class;
-                snprintf(name, PID_NAME_LEN, "process_%d", current->pid);
-                ret = pm_qos_add_requirement(pm_qos_class, name,
-                                        PM_QOS_DEFAULT_VALUE);
-                if (ret >= 0)
+                filp->private_data = (void *) pm_qos_add_request(pm_qos_class,
+                                PM_QOS_DEFAULT_VALUE);
+
+                if (filp->private_data)
                         return 0;
         }
         return -EPERM;
@@ -365,32 +351,40 @@ static int pm_qos_power_open(struct inode *inode, struct file *filp)
 
 static int pm_qos_power_release(struct inode *inode, struct file *filp)
 {
-        int pm_qos_class;
-        char name[PID_NAME_LEN];
+        struct pm_qos_request_list *req;
 
-        pm_qos_class = (long)filp->private_data;
-        snprintf(name, PID_NAME_LEN, "process_%d", current->pid);
-        pm_qos_remove_requirement(pm_qos_class, name);
+        req = (struct pm_qos_request_list *)filp->private_data;
+        pm_qos_remove_request(req);
 
         return 0;
 }
 
+
 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf,
                 size_t count, loff_t *f_pos)
 {
         s32 value;
-        int pm_qos_class;
-        char name[PID_NAME_LEN];
-
-        pm_qos_class = (long)filp->private_data;
-        if (count != sizeof(s32))
+        int x;
+        char ascii_value[11];
+        struct pm_qos_request_list *pm_qos_req;
+
+        if (count == sizeof(s32)) {
+                if (copy_from_user(&value, buf, sizeof(s32)))
+                        return -EFAULT;
+        } else if (count == 11) { /* len('0x12345678/0') */
+                if (copy_from_user(ascii_value, buf, 11))
+                        return -EFAULT;
+                x = sscanf(ascii_value, "%x", &value);
+                if (x != 1)
+                        return -EINVAL;
+                pr_debug(KERN_ERR "%s, %d, 0x%x\n", ascii_value, x, value);
+        } else
                 return -EINVAL;
-        if (copy_from_user(&value, buf, sizeof(s32)))
-                return -EFAULT;
-        snprintf(name, PID_NAME_LEN, "process_%d", current->pid);
-        pm_qos_update_requirement(pm_qos_class, name, value);
 
-        return  sizeof(s32);
+        pm_qos_req = (struct pm_qos_request_list *)filp->private_data;
+        pm_qos_update_request(pm_qos_req, value);
+
+        return count;
 }