4 files changed, 91 insertions, 53 deletions

diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 1ba4039777e8..b3df613ae4ec 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -284,39 +284,69 @@ EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
  *                          SYSFS INTERFACE                          *
  *********************************************************************/
 
+static struct cpufreq_governor *__find_governor(const char *str_governor)
+{
+        struct cpufreq_governor *t;
+
+        list_for_each_entry(t, &cpufreq_governor_list, governor_list)
+                if (!strnicmp(str_governor,t->name,CPUFREQ_NAME_LEN))
+                        return t;
+
+        return NULL;
+}
+
 /**
  * cpufreq_parse_governor - parse a governor string
  */
 static int cpufreq_parse_governor (char *str_governor, unsigned int *policy,
                                 struct cpufreq_governor **governor)
 {
+        int err = -EINVAL;
+
         if (!cpufreq_driver)
-                return -EINVAL;
+                goto out;
+
         if (cpufreq_driver->setpolicy) {
                 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
                         *policy = CPUFREQ_POLICY_PERFORMANCE;
-                        return 0;
+                        err = 0;
                 } else if (!strnicmp(str_governor, "powersave", CPUFREQ_NAME_LEN)) {
                         *policy = CPUFREQ_POLICY_POWERSAVE;
-                        return 0;
+                        err = 0;
                 }
-                return -EINVAL;
-        } else {
+        } else if (cpufreq_driver->target) {
                 struct cpufreq_governor *t;
+
                 mutex_lock(&cpufreq_governor_mutex);
-                if (!cpufreq_driver || !cpufreq_driver->target)
-                        goto out;
-                list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
-                        if (!strnicmp(str_governor,t->name,CPUFREQ_NAME_LEN)) {
-                                *governor = t;
+
+                t = __find_governor(str_governor);
+
+                if (t == NULL) {
+                        char *name = kasprintf(GFP_KERNEL, "cpufreq_%s", str_governor);
+
+                        if (name) {
+                                int ret;
+
                                 mutex_unlock(&cpufreq_governor_mutex);
-                                return 0;
+                                ret = request_module(name);
+                                mutex_lock(&cpufreq_governor_mutex);
+
+                                if (ret == 0)
+                                        t = __find_governor(str_governor);
                         }
+
+                        kfree(name);
                 }
-out:
+
+                if (t != NULL) {
+                        *governor = t;
+                        err = 0;
+                }
+
                 mutex_unlock(&cpufreq_governor_mutex);
         }
-        return -EINVAL;
+  out:
+        return err;
 }
 
 
@@ -364,10 +394,12 @@ static ssize_t store_##file_name					\
         if (ret != 1)                                                   \
                 return -EINVAL;                                         \
                                                                         \
+        lock_cpu_hotplug();                                             \
         mutex_lock(&policy->lock);                                      \
         ret = __cpufreq_set_policy(policy, &new_policy);                \
         policy->user_policy.object = policy->object;                    \
         mutex_unlock(&policy->lock);                                    \
+        unlock_cpu_hotplug();                                           \
                                                                         \
         return ret ? ret : count;                                       \
 }
@@ -423,6 +455,8 @@ static ssize_t store_scaling_governor (struct cpufreq_policy * policy,
         if (cpufreq_parse_governor(str_governor, &new_policy.policy, &new_policy.governor))
                 return -EINVAL;
 
+        lock_cpu_hotplug();
+
         /* Do not use cpufreq_set_policy here or the user_policy.max
            will be wrongly overridden */
         mutex_lock(&policy->lock);
@@ -432,6 +466,8 @@ static ssize_t store_scaling_governor (struct cpufreq_policy * policy,
         policy->user_policy.governor = policy->governor;
         mutex_unlock(&policy->lock);
 
+        unlock_cpu_hotplug();
+
         return ret ? ret : count;
 }
 
@@ -1193,20 +1229,18 @@ EXPORT_SYMBOL(cpufreq_unregister_notifier);
  *********************************************************************/
 
 
+/* Must be called with lock_cpu_hotplug held */
 int __cpufreq_driver_target(struct cpufreq_policy *policy,
                             unsigned int target_freq,
                             unsigned int relation)
 {
         int retval = -EINVAL;
 
-        lock_cpu_hotplug();
         dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
                 target_freq, relation);
         if (cpu_online(policy->cpu) && cpufreq_driver->target)
                 retval = cpufreq_driver->target(policy, target_freq, relation);
 
-        unlock_cpu_hotplug();
-
         return retval;
 }
 EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
@@ -1221,17 +1255,23 @@ int cpufreq_driver_target(struct cpufreq_policy *policy,
         if (!policy)
                 return -EINVAL;
 
+        lock_cpu_hotplug();
         mutex_lock(&policy->lock);
 
         ret = __cpufreq_driver_target(policy, target_freq, relation);
 
         mutex_unlock(&policy->lock);
+        unlock_cpu_hotplug();
 
         cpufreq_cpu_put(policy);
         return ret;
 }
 EXPORT_SYMBOL_GPL(cpufreq_driver_target);
 
+/*
+ * Locking: Must be called with the lock_cpu_hotplug() lock held
+ * when "event" is CPUFREQ_GOV_LIMITS
+ */
 
 static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event)
 {
@@ -1253,43 +1293,23 @@ static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event)
 }
 
 
-int cpufreq_governor(unsigned int cpu, unsigned int event)
-{
-        int ret = 0;
-        struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
-
-        if (!policy)
-                return -EINVAL;
-
-        mutex_lock(&policy->lock);
-        ret = __cpufreq_governor(policy, event);
-        mutex_unlock(&policy->lock);
-
-        cpufreq_cpu_put(policy);
-        return ret;
-}
-EXPORT_SYMBOL_GPL(cpufreq_governor);
-
-
 int cpufreq_register_governor(struct cpufreq_governor *governor)
 {
-        struct cpufreq_governor *t;
+        int err;
 
         if (!governor)
                 return -EINVAL;
 
         mutex_lock(&cpufreq_governor_mutex);
 
-        list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
-                if (!strnicmp(governor->name,t->name,CPUFREQ_NAME_LEN)) {
-                        mutex_unlock(&cpufreq_governor_mutex);
-                        return -EBUSY;
-                }
+        err = -EBUSY;
+        if (__find_governor(governor->name) == NULL) {
+                err = 0;
+                list_add(&governor->governor_list, &cpufreq_governor_list);
         }
-        list_add(&governor->governor_list, &cpufreq_governor_list);
 
         mutex_unlock(&cpufreq_governor_mutex);
-        return 0;
+        return err;
 }
 EXPORT_SYMBOL_GPL(cpufreq_register_governor);
 
@@ -1338,6 +1358,9 @@ int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
 EXPORT_SYMBOL(cpufreq_get_policy);
 
 
+/*
+ * Locking: Must be called with the lock_cpu_hotplug() lock held
+ */
 static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_policy *policy)
 {
         int ret = 0;
@@ -1348,6 +1371,11 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_poli
 
         memcpy(&policy->cpuinfo, &data->cpuinfo, sizeof(struct cpufreq_cpuinfo));
 
+        if (policy->min > data->min && policy->min > policy->max) {
+                ret = -EINVAL;
+                goto error_out;
+        }
+
         /* verify the cpu speed can be set within this limit */
         ret = cpufreq_driver->verify(policy);
         if (ret)
@@ -1432,6 +1460,8 @@ int cpufreq_set_policy(struct cpufreq_policy *policy)
         if (!data)
                 return -EINVAL;
 
+        lock_cpu_hotplug();
+
         /* lock this CPU */
         mutex_lock(&data->lock);
 
@@ -1442,6 +1472,8 @@ int cpufreq_set_policy(struct cpufreq_policy *policy)
         data->user_policy.governor = data->governor;
 
         mutex_unlock(&data->lock);
+
+        unlock_cpu_hotplug();
         cpufreq_cpu_put(data);
 
         return ret;
@@ -1465,6 +1497,7 @@ int cpufreq_update_policy(unsigned int cpu)
         if (!data)
                 return -ENODEV;
 
+        lock_cpu_hotplug();
         mutex_lock(&data->lock);
 
         dprintk("updating policy for CPU %u\n", cpu);
@@ -1490,7 +1523,7 @@ int cpufreq_update_policy(unsigned int cpu)
         ret = __cpufreq_set_policy(data, &policy);
 
         mutex_unlock(&data->lock);
-
+        unlock_cpu_hotplug();
         cpufreq_cpu_put(data);
         return ret;
 }
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index b3ebc8f01975..c4c578defabf 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -525,7 +525,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 break;
 
         case CPUFREQ_GOV_LIMITS:
-                lock_cpu_hotplug();
                 mutex_lock(&dbs_mutex);
                 if (policy->max < this_dbs_info->cur_policy->cur)
                         __cpufreq_driver_target(
@@ -536,7 +535,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                                         this_dbs_info->cur_policy,
                                         policy->min, CPUFREQ_RELATION_L);
                 mutex_unlock(&dbs_mutex);
-                unlock_cpu_hotplug();
                 break;
         }
         return 0;
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 87299924e735..52cf1f021825 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -239,6 +239,8 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
         total_ticks = (unsigned int) cputime64_sub(cur_jiffies,
                         this_dbs_info->prev_cpu_wall);
         this_dbs_info->prev_cpu_wall = cur_jiffies;
+        if (!total_ticks)
+                return;
         /*
          * Every sampling_rate, we check, if current idle time is less
          * than 20% (default), then we try to increase frequency
@@ -304,7 +306,12 @@ static void do_dbs_timer(void *data)
         unsigned int cpu = smp_processor_id();
         struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, cpu);
 
+        if (!dbs_info->enable)
+                return;
+
+        lock_cpu_hotplug();
         dbs_check_cpu(dbs_info);
+        unlock_cpu_hotplug();
         queue_delayed_work_on(cpu, kondemand_wq, &dbs_info->work,
                         usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
 }
@@ -319,11 +326,11 @@ static inline void dbs_timer_init(unsigned int cpu)
         return;
 }
 
-static inline void dbs_timer_exit(unsigned int cpu)
+static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
 {
-        struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, cpu);
-
-        cancel_rearming_delayed_workqueue(kondemand_wq, &dbs_info->work);
+        dbs_info->enable = 0;
+        cancel_delayed_work(&dbs_info->work);
+        flush_workqueue(kondemand_wq);
 }
 
 static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
@@ -396,8 +403,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
 
         case CPUFREQ_GOV_STOP:
                 mutex_lock(&dbs_mutex);
-                dbs_timer_exit(policy->cpu);
-                this_dbs_info->enable = 0;
+                dbs_timer_exit(this_dbs_info);
                 sysfs_remove_group(&policy->kobj, &dbs_attr_group);
                 dbs_enable--;
                 if (dbs_enable == 0)
@@ -408,7 +414,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 break;
 
         case CPUFREQ_GOV_LIMITS:
-                lock_cpu_hotplug();
                 mutex_lock(&dbs_mutex);
                 if (policy->max < this_dbs_info->cur_policy->cur)
                         __cpufreq_driver_target(this_dbs_info->cur_policy,
@@ -419,7 +424,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                                                 policy->min,
                                                 CPUFREQ_RELATION_L);
                 mutex_unlock(&dbs_mutex);
-                unlock_cpu_hotplug();
                 break;
         }
         return 0;
diff --git a/drivers/cpufreq/cpufreq_userspace.c b/drivers/cpufreq/cpufreq_userspace.c
index 44ae5e5b94cf..a06c204589cd 100644
--- a/drivers/cpufreq/cpufreq_userspace.c
+++ b/drivers/cpufreq/cpufreq_userspace.c
@@ -18,6 +18,7 @@
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 #include <linux/cpufreq.h>
+#include <linux/cpu.h>
 #include <linux/types.h>
 #include <linux/fs.h>
 #include <linux/sysfs.h>
@@ -70,6 +71,7 @@ static int cpufreq_set(unsigned int freq, struct cpufreq_policy *policy)
 
         dprintk("cpufreq_set for cpu %u, freq %u kHz\n", policy->cpu, freq);
 
+        lock_cpu_hotplug();
         mutex_lock(&userspace_mutex);
         if (!cpu_is_managed[policy->cpu])
                 goto err;
@@ -92,6 +94,7 @@ static int cpufreq_set(unsigned int freq, struct cpufreq_policy *policy)
 
  err:
         mutex_unlock(&userspace_mutex);
+        unlock_cpu_hotplug();
         return ret;
 }