1 files changed, 52 insertions, 19 deletions

diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index ff57c40e9b8b..75d293eeb3ee 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -64,14 +64,14 @@ static DEFINE_SPINLOCK(cpufreq_driver_lock);
  * - Lock should not be held across
  *     __cpufreq_governor(data, CPUFREQ_GOV_STOP);
  */
-static DEFINE_PER_CPU(int, policy_cpu);
+static DEFINE_PER_CPU(int, cpufreq_policy_cpu);
 static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
 
 #define lock_policy_rwsem(mode, cpu)                                    \
 int lock_policy_rwsem_##mode                                            \
 (int cpu)                                                               \
 {                                                                       \
-        int policy_cpu = per_cpu(policy_cpu, cpu);                      \
+        int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);              \
         BUG_ON(policy_cpu == -1);                                       \
         down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu));            \
         if (unlikely(!cpu_online(cpu))) {                               \
@@ -90,7 +90,7 @@ EXPORT_SYMBOL_GPL(lock_policy_rwsem_write);
 
 void unlock_policy_rwsem_read(int cpu)
 {
-        int policy_cpu = per_cpu(policy_cpu, cpu);
+        int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);
         BUG_ON(policy_cpu == -1);
         up_read(&per_cpu(cpu_policy_rwsem, policy_cpu));
 }
@@ -98,7 +98,7 @@ EXPORT_SYMBOL_GPL(unlock_policy_rwsem_read);
 
 void unlock_policy_rwsem_write(int cpu)
 {
-        int policy_cpu = per_cpu(policy_cpu, cpu);
+        int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);
         BUG_ON(policy_cpu == -1);
         up_write(&per_cpu(cpu_policy_rwsem, policy_cpu));
 }
@@ -647,6 +647,21 @@ static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
         return policy->governor->show_setspeed(policy, buf);
 }
 
+/**
+ * show_scaling_driver - show the current cpufreq HW/BIOS limitation
+ */
+static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
+{
+        unsigned int limit;
+        int ret;
+        if (cpufreq_driver->bios_limit) {
+                ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
+                if (!ret)
+                        return sprintf(buf, "%u\n", limit);
+        }
+        return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
+}
+
 #define define_one_ro(_name) \
 static struct freq_attr _name = \
 __ATTR(_name, 0444, show_##_name, NULL)
@@ -666,6 +681,7 @@ define_one_ro(cpuinfo_transition_latency);
 define_one_ro(scaling_available_governors);
 define_one_ro(scaling_driver);
 define_one_ro(scaling_cur_freq);
+define_one_ro(bios_limit);
 define_one_ro(related_cpus);
 define_one_ro(affected_cpus);
 define_one_rw(scaling_min_freq);
@@ -750,7 +766,7 @@ static void cpufreq_sysfs_release(struct kobject *kobj)
         complete(&policy->kobj_unregister);
 }
 
-static struct sysfs_ops sysfs_ops = {
+static const struct sysfs_ops sysfs_ops = {
         .show   = show,
         .store  = store,
 };
@@ -767,8 +783,9 @@ static struct kobj_type ktype_cpufreq = {
  *   0:        Success
  *   Positive: When we have a managed CPU and the sysfs got symlinked
  */
-int cpufreq_add_dev_policy(unsigned int cpu, struct cpufreq_policy *policy,
-                struct sys_device *sys_dev)
+static int cpufreq_add_dev_policy(unsigned int cpu,
+                                  struct cpufreq_policy *policy,
+                                  struct sys_device *sys_dev)
 {
         int ret = 0;
 #ifdef CONFIG_SMP
@@ -801,7 +818,7 @@ int cpufreq_add_dev_policy(unsigned int cpu, struct cpufreq_policy *policy,
 
                         /* Set proper policy_cpu */
                         unlock_policy_rwsem_write(cpu);
-                        per_cpu(policy_cpu, cpu) = managed_policy->cpu;
+                        per_cpu(cpufreq_policy_cpu, cpu) = managed_policy->cpu;
 
                         if (lock_policy_rwsem_write(cpu) < 0) {
                                 /* Should not go through policy unlock path */
@@ -842,7 +859,8 @@ int cpufreq_add_dev_policy(unsigned int cpu, struct cpufreq_policy *policy,
 
 
 /* symlink affected CPUs */
-int cpufreq_add_dev_symlink(unsigned int cpu, struct cpufreq_policy *policy)
+static int cpufreq_add_dev_symlink(unsigned int cpu,
+                                   struct cpufreq_policy *policy)
 {
         unsigned int j;
         int ret = 0;
@@ -869,8 +887,9 @@ int cpufreq_add_dev_symlink(unsigned int cpu, struct cpufreq_policy *policy)
         return ret;
 }
 
-int cpufreq_add_dev_interface(unsigned int cpu, struct cpufreq_policy *policy,
-                struct sys_device *sys_dev)
+static int cpufreq_add_dev_interface(unsigned int cpu,
+                                     struct cpufreq_policy *policy,
+                                     struct sys_device *sys_dev)
 {
         struct cpufreq_policy new_policy;
         struct freq_attr **drv_attr;
@@ -902,13 +921,18 @@ int cpufreq_add_dev_interface(unsigned int cpu, struct cpufreq_policy *policy,
                 if (ret)
                         goto err_out_kobj_put;
         }
+        if (cpufreq_driver->bios_limit) {
+                ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
+                if (ret)
+                        goto err_out_kobj_put;
+        }
 
         spin_lock_irqsave(&cpufreq_driver_lock, flags);
         for_each_cpu(j, policy->cpus) {
         if (!cpu_online(j))
                 continue;
                 per_cpu(cpufreq_cpu_data, j) = policy;
-                per_cpu(policy_cpu, j) = policy->cpu;
+                per_cpu(cpufreq_policy_cpu, j) = policy->cpu;
         }
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
@@ -996,7 +1020,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
         cpumask_copy(policy->cpus, cpumask_of(cpu));
 
         /* Initially set CPU itself as the policy_cpu */
-        per_cpu(policy_cpu, cpu) = cpu;
+        per_cpu(cpufreq_policy_cpu, cpu) = cpu;
         ret = (lock_policy_rwsem_write(cpu) < 0);
         WARN_ON(ret);
 
@@ -1089,6 +1113,8 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
         unsigned int cpu = sys_dev->id;
         unsigned long flags;
         struct cpufreq_policy *data;
+        struct kobject *kobj;
+        struct completion *cmp;
 #ifdef CONFIG_SMP
         struct sys_device *cpu_sys_dev;
         unsigned int j;
@@ -1117,10 +1143,11 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
                 dprintk("removing link\n");
                 cpumask_clear_cpu(cpu, data->cpus);
                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
-                sysfs_remove_link(&sys_dev->kobj, "cpufreq");
+                kobj = &sys_dev->kobj;
                 cpufreq_cpu_put(data);
                 cpufreq_debug_enable_ratelimit();
                 unlock_policy_rwsem_write(cpu);
+                sysfs_remove_link(kobj, "cpufreq");
                 return 0;
         }
 #endif
@@ -1157,7 +1184,10 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
                                 data->governor->name, CPUFREQ_NAME_LEN);
 #endif
                         cpu_sys_dev = get_cpu_sysdev(j);
-                        sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq");
+                        kobj = &cpu_sys_dev->kobj;
+                        unlock_policy_rwsem_write(cpu);
+                        sysfs_remove_link(kobj, "cpufreq");
+                        lock_policy_rwsem_write(cpu);
                         cpufreq_cpu_put(data);
                 }
         }
@@ -1168,19 +1198,22 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
         if (cpufreq_driver->target)
                 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
 
-        kobject_put(&data->kobj);
+        kobj = &data->kobj;
+        cmp = &data->kobj_unregister;
+        unlock_policy_rwsem_write(cpu);
+        kobject_put(kobj);
 
         /* we need to make sure that the underlying kobj is actually
          * not referenced anymore by anybody before we proceed with
          * unloading.
          */
         dprintk("waiting for dropping of refcount\n");
-        wait_for_completion(&data->kobj_unregister);
+        wait_for_completion(cmp);
         dprintk("wait complete\n");
 
+        lock_policy_rwsem_write(cpu);
         if (cpufreq_driver->exit)
                 cpufreq_driver->exit(data);
-
         unlock_policy_rwsem_write(cpu);
 
         free_cpumask_var(data->related_cpus);
@@ -1978,7 +2011,7 @@ static int __init cpufreq_core_init(void)
         int cpu;
 
         for_each_possible_cpu(cpu) {
-                per_cpu(policy_cpu, cpu) = -1;
+                per_cpu(cpufreq_policy_cpu, cpu) = -1;
                 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
         }