Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/davej/cpufreq

* 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/davej/cpufreq:
  [ACPI/CPUFREQ] Introduce bios_limit per cpu cpufreq sysfs interface
  [CPUFREQ] make internal cpufreq_add_dev_* static
  [CPUFREQ] use an enum for speedstep processor identification
  [CPUFREQ] Document units for transition latency
  [CPUFREQ] Use global sysfs cpufreq structure for conservative governor tunings
  [CPUFREQ] Documentation: ABI: /sys/devices/system/cpu/cpu#/cpufreq/
  [CPUFREQ] powernow-k6: set transition latency value so ondemand governor can be used
  [CPUFREQ] cpumask: don't put a cpumask on the stack in x86...cpufreq/powernow-k8.c

3 files changed, 152 insertions, 24 deletions

diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index 8ba0ed0b9ddb..01e366d2b6fb 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -167,6 +167,19 @@ int acpi_processor_ppc_has_changed(struct acpi_processor *pr)
                 return cpufreq_update_policy(pr->id);
 }
 
+int acpi_processor_get_bios_limit(int cpu, unsigned int *limit)
+{
+        struct acpi_processor *pr;
+
+        pr = per_cpu(processors, cpu);
+        if (!pr || !pr->performance || !pr->performance->state_count)
+                return -ENODEV;
+        *limit = pr->performance->states[pr->performance_platform_limit].
+                core_frequency * 1000;
+        return 0;
+}
+EXPORT_SYMBOL(acpi_processor_get_bios_limit);
+
 void acpi_processor_ppc_init(void)
 {
         if (!cpufreq_register_notifier
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index ff57c40e9b8b..f20668c09ce0 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -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);
@@ -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
@@ -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,6 +921,11 @@ 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) {
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index c7b081b839ff..599a40b25cb0 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -164,20 +164,22 @@ static struct notifier_block dbs_cpufreq_notifier_block = {
 };
 
 /************************** sysfs interface ************************/
-static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
+static ssize_t show_sampling_rate_max(struct kobject *kobj,
+                                      struct attribute *attr, char *buf)
 {
         printk_once(KERN_INFO "CPUFREQ: conservative sampling_rate_max "
                     "sysfs file is deprecated - used by: %s\n", current->comm);
         return sprintf(buf, "%u\n", -1U);
 }
 
-static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
+static ssize_t show_sampling_rate_min(struct kobject *kobj,
+                                      struct attribute *attr, char *buf)
 {
         return sprintf(buf, "%u\n", min_sampling_rate);
 }
 
 #define define_one_ro(_name)            \
-static struct freq_attr _name =         \
+static struct global_attr _name =       \
 __ATTR(_name, 0444, show_##_name, NULL)
 
 define_one_ro(sampling_rate_max);
@@ -186,7 +188,7 @@ define_one_ro(sampling_rate_min);
 /* cpufreq_conservative Governor Tunables */
 #define show_one(file_name, object)                                     \
 static ssize_t show_##file_name                                         \
-(struct cpufreq_policy *unused, char *buf)                              \
+(struct kobject *kobj, struct attribute *attr, char *buf)               \
 {                                                                       \
         return sprintf(buf, "%u\n", dbs_tuners_ins.object);             \
 }
@@ -197,8 +199,40 @@ show_one(down_threshold, down_threshold);
 show_one(ignore_nice_load, ignore_nice);
 show_one(freq_step, freq_step);
 
-static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
-                const char *buf, size_t count)
+/*** delete after deprecation time ***/
+#define DEPRECATION_MSG(file_name)                                      \
+        printk_once(KERN_INFO "CPUFREQ: Per core conservative sysfs "   \
+                "interface is deprecated - " #file_name "\n");
+
+#define show_one_old(file_name)                                         \
+static ssize_t show_##file_name##_old                                   \
+(struct cpufreq_policy *unused, char *buf)                              \
+{                                                                       \
+        printk_once(KERN_INFO "CPUFREQ: Per core conservative sysfs "   \
+                "interface is deprecated - " #file_name "\n");          \
+        return show_##file_name(NULL, NULL, buf);                       \
+}
+show_one_old(sampling_rate);
+show_one_old(sampling_down_factor);
+show_one_old(up_threshold);
+show_one_old(down_threshold);
+show_one_old(ignore_nice_load);
+show_one_old(freq_step);
+show_one_old(sampling_rate_min);
+show_one_old(sampling_rate_max);
+
+#define define_one_ro_old(object, _name)        \
+static struct freq_attr object =                \
+__ATTR(_name, 0444, show_##_name##_old, NULL)
+
+define_one_ro_old(sampling_rate_min_old, sampling_rate_min);
+define_one_ro_old(sampling_rate_max_old, sampling_rate_max);
+
+/*** delete after deprecation time ***/
+
+static ssize_t store_sampling_down_factor(struct kobject *a,
+                                          struct attribute *b,
+                                          const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -214,8 +248,8 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
         return count;
 }
 
-static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
-                const char *buf, size_t count)
+static ssize_t store_sampling_rate(struct kobject *a, struct attribute *b,
+                                   const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -231,8 +265,8 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
         return count;
 }
 
-static ssize_t store_up_threshold(struct cpufreq_policy *unused,
-                const char *buf, size_t count)
+static ssize_t store_up_threshold(struct kobject *a, struct attribute *b,
+                                  const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -251,8 +285,8 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
         return count;
 }
 
-static ssize_t store_down_threshold(struct cpufreq_policy *unused,
-                const char *buf, size_t count)
+static ssize_t store_down_threshold(struct kobject *a, struct attribute *b,
+                                    const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -272,8 +306,8 @@ static ssize_t store_down_threshold(struct cpufreq_policy *unused,
         return count;
 }
 
-static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
-                const char *buf, size_t count)
+static ssize_t store_ignore_nice_load(struct kobject *a, struct attribute *b,
+                                      const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -308,8 +342,8 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
         return count;
 }
 
-static ssize_t store_freq_step(struct cpufreq_policy *policy,
-                const char *buf, size_t count)
+static ssize_t store_freq_step(struct kobject *a, struct attribute *b,
+                               const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -331,7 +365,7 @@ static ssize_t store_freq_step(struct cpufreq_policy *policy,
 }
 
 #define define_one_rw(_name) \
-static struct freq_attr _name = \
+static struct global_attr _name = \
 __ATTR(_name, 0644, show_##_name, store_##_name)
 
 define_one_rw(sampling_rate);
@@ -358,6 +392,53 @@ static struct attribute_group dbs_attr_group = {
         .name = "conservative",
 };
 
+/*** delete after deprecation time ***/
+
+#define write_one_old(file_name)                                        \
+static ssize_t store_##file_name##_old                                  \
+(struct cpufreq_policy *unused, const char *buf, size_t count)          \
+{                                                                       \
+        printk_once(KERN_INFO "CPUFREQ: Per core conservative sysfs "   \
+                "interface is deprecated - " #file_name "\n");  \
+        return store_##file_name(NULL, NULL, buf, count);               \
+}
+write_one_old(sampling_rate);
+write_one_old(sampling_down_factor);
+write_one_old(up_threshold);
+write_one_old(down_threshold);
+write_one_old(ignore_nice_load);
+write_one_old(freq_step);
+
+#define define_one_rw_old(object, _name)        \
+static struct freq_attr object =                \
+__ATTR(_name, 0644, show_##_name##_old, store_##_name##_old)
+
+define_one_rw_old(sampling_rate_old, sampling_rate);
+define_one_rw_old(sampling_down_factor_old, sampling_down_factor);
+define_one_rw_old(up_threshold_old, up_threshold);
+define_one_rw_old(down_threshold_old, down_threshold);
+define_one_rw_old(ignore_nice_load_old, ignore_nice_load);
+define_one_rw_old(freq_step_old, freq_step);
+
+static struct attribute *dbs_attributes_old[] = {
+        &sampling_rate_max_old.attr,
+        &sampling_rate_min_old.attr,
+        &sampling_rate_old.attr,
+        &sampling_down_factor_old.attr,
+        &up_threshold_old.attr,
+        &down_threshold_old.attr,
+        &ignore_nice_load_old.attr,
+        &freq_step_old.attr,
+        NULL
+};
+
+static struct attribute_group dbs_attr_group_old = {
+        .attrs = dbs_attributes_old,
+        .name = "conservative",
+};
+
+/*** delete after deprecation time ***/
+
 /************************** sysfs end ************************/
 
 static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
@@ -530,7 +611,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
 
                 mutex_lock(&dbs_mutex);
 
-                rc = sysfs_create_group(&policy->kobj, &dbs_attr_group);
+                rc = sysfs_create_group(&policy->kobj, &dbs_attr_group_old);
                 if (rc) {
                         mutex_unlock(&dbs_mutex);
                         return rc;
@@ -564,6 +645,13 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                         if (latency == 0)
                                 latency = 1;
 
+                        rc = sysfs_create_group(cpufreq_global_kobject,
+                                                &dbs_attr_group);
+                        if (rc) {
+                                mutex_unlock(&dbs_mutex);
+                                return rc;
+                        }
+
                         /*
                          * conservative does not implement micro like ondemand
                          * governor, thus we are bound to jiffes/HZ
@@ -591,7 +679,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 dbs_timer_exit(this_dbs_info);
 
                 mutex_lock(&dbs_mutex);
-                sysfs_remove_group(&policy->kobj, &dbs_attr_group);
+                sysfs_remove_group(&policy->kobj, &dbs_attr_group_old);
                 dbs_enable--;
                 mutex_destroy(&this_dbs_info->timer_mutex);
 
@@ -605,6 +693,9 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                                         CPUFREQ_TRANSITION_NOTIFIER);
 
                 mutex_unlock(&dbs_mutex);
+                if (!dbs_enable)
+                        sysfs_remove_group(cpufreq_global_kobject,
+                                           &dbs_attr_group);
 
                 break;