5 files changed, 50 insertions, 47 deletions

diff --git a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
index a962dcb9c408..e2d870de837c 100644
--- a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -192,9 +192,9 @@ static void drv_read(struct drv_cmd *cmd)
         cpumask_t saved_mask = current->cpus_allowed;
         cmd->val = 0;
 
-        set_cpus_allowed(current, cmd->mask);
+        set_cpus_allowed_ptr(current, &cmd->mask);
         do_drv_read(cmd);
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
 }
 
 static void drv_write(struct drv_cmd *cmd)
@@ -203,30 +203,30 @@ static void drv_write(struct drv_cmd *cmd)
         unsigned int i;
 
         for_each_cpu_mask(i, cmd->mask) {
-                set_cpus_allowed(current, cpumask_of_cpu(i));
+                set_cpus_allowed_ptr(current, &cpumask_of_cpu(i));
                 do_drv_write(cmd);
         }
 
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return;
 }
 
-static u32 get_cur_val(cpumask_t mask)
+static u32 get_cur_val(const cpumask_t *mask)
 {
         struct acpi_processor_performance *perf;
         struct drv_cmd cmd;
 
-        if (unlikely(cpus_empty(mask)))
+        if (unlikely(cpus_empty(*mask)))
                 return 0;
 
-        switch (per_cpu(drv_data, first_cpu(mask))->cpu_feature) {
+        switch (per_cpu(drv_data, first_cpu(*mask))->cpu_feature) {
         case SYSTEM_INTEL_MSR_CAPABLE:
                 cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
                 cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;
                 break;
         case SYSTEM_IO_CAPABLE:
                 cmd.type = SYSTEM_IO_CAPABLE;
-                perf = per_cpu(drv_data, first_cpu(mask))->acpi_data;
+                perf = per_cpu(drv_data, first_cpu(*mask))->acpi_data;
                 cmd.addr.io.port = perf->control_register.address;
                 cmd.addr.io.bit_width = perf->control_register.bit_width;
                 break;
@@ -234,7 +234,7 @@ static u32 get_cur_val(cpumask_t mask)
                 return 0;
         }
 
-        cmd.mask = mask;
+        cmd.mask = *mask;
 
         drv_read(&cmd);
 
@@ -271,7 +271,7 @@ static unsigned int get_measured_perf(unsigned int cpu)
         unsigned int retval;
 
         saved_mask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
         if (get_cpu() != cpu) {
                 /* We were not able to run on requested processor */
                 put_cpu();
@@ -329,7 +329,7 @@ static unsigned int get_measured_perf(unsigned int cpu)
         retval = per_cpu(drv_data, cpu)->max_freq * perf_percent / 100;
 
         put_cpu();
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
 
         dprintk("cpu %d: performance percent %d\n", cpu, perf_percent);
         return retval;
@@ -347,13 +347,13 @@ static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
                 return 0;
         }
 
-        freq = extract_freq(get_cur_val(cpumask_of_cpu(cpu)), data);
+        freq = extract_freq(get_cur_val(&cpumask_of_cpu(cpu)), data);
         dprintk("cur freq = %u\n", freq);
 
         return freq;
 }
 
-static unsigned int check_freqs(cpumask_t mask, unsigned int freq,
+static unsigned int check_freqs(const cpumask_t *mask, unsigned int freq,
                                 struct acpi_cpufreq_data *data)
 {
         unsigned int cur_freq;
@@ -449,7 +449,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
         drv_write(&cmd);
 
         if (acpi_pstate_strict) {
-                if (!check_freqs(cmd.mask, freqs.new, data)) {
+                if (!check_freqs(&cmd.mask, freqs.new, data)) {
                         dprintk("acpi_cpufreq_target failed (%d)\n",
                                 policy->cpu);
                         return -EAGAIN;
diff --git a/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c b/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
index 14791ec55cfd..199e4e05e5dc 100644
--- a/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
+++ b/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
@@ -289,8 +289,8 @@ static int __init cpufreq_p4_init(void)
         if (c->x86_vendor != X86_VENDOR_INTEL)
                 return -ENODEV;
 
-        if (!test_bit(X86_FEATURE_ACPI, c->x86_capability) ||
-                !test_bit(X86_FEATURE_ACC, c->x86_capability))
+        if (!test_cpu_cap(c, X86_FEATURE_ACPI) ||
+                                !test_cpu_cap(c, X86_FEATURE_ACC))
                 return -ENODEV;
 
         ret = cpufreq_register_driver(&p4clockmod_driver);
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
index c99d59d8ef2e..46d4034d9f37 100644
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
@@ -478,12 +478,12 @@ static int core_voltage_post_transition(struct powernow_k8_data *data, u32 reqvi
 
 static int check_supported_cpu(unsigned int cpu)
 {
-        cpumask_t oldmask = CPU_MASK_ALL;
+        cpumask_t oldmask;
         u32 eax, ebx, ecx, edx;
         unsigned int rc = 0;
 
         oldmask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
 
         if (smp_processor_id() != cpu) {
                 printk(KERN_ERR PFX "limiting to cpu %u failed\n", cpu);
@@ -528,7 +528,7 @@ static int check_supported_cpu(unsigned int cpu)
         rc = 1;
 
 out:
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         return rc;
 }
 
@@ -1015,7 +1015,7 @@ static int transition_frequency_pstate(struct powernow_k8_data *data, unsigned i
 /* Driver entry point to switch to the target frequency */
 static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsigned relation)
 {
-        cpumask_t oldmask = CPU_MASK_ALL;
+        cpumask_t oldmask;
         struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
         u32 checkfid;
         u32 checkvid;
@@ -1030,7 +1030,7 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi
 
         /* only run on specific CPU from here on */
         oldmask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(pol->cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(pol->cpu));
 
         if (smp_processor_id() != pol->cpu) {
                 printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu);
@@ -1085,7 +1085,7 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi
         ret = 0;
 
 err_out:
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         return ret;
 }
 
@@ -1104,7 +1104,7 @@ static int powernowk8_verify(struct cpufreq_policy *pol)
 static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
 {
         struct powernow_k8_data *data;
-        cpumask_t oldmask = CPU_MASK_ALL;
+        cpumask_t oldmask;
         int rc;
 
         if (!cpu_online(pol->cpu))
@@ -1145,7 +1145,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
 
         /* only run on specific CPU from here on */
         oldmask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(pol->cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(pol->cpu));
 
         if (smp_processor_id() != pol->cpu) {
                 printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu);
@@ -1164,7 +1164,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
                 fidvid_msr_init();
 
         /* run on any CPU again */
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
 
         if (cpu_family == CPU_HW_PSTATE)
                 pol->cpus = cpumask_of_cpu(pol->cpu);
@@ -1205,7 +1205,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
         return 0;
 
 err_out:
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         powernow_k8_cpu_exit_acpi(data);
 
         kfree(data);
@@ -1242,10 +1242,11 @@ static unsigned int powernowk8_get (unsigned int cpu)
         if (!data)
                 return -EINVAL;
 
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
         if (smp_processor_id() != cpu) {
-                printk(KERN_ERR PFX "limiting to CPU %d failed in powernowk8_get\n", cpu);
-                set_cpus_allowed(current, oldmask);
+                printk(KERN_ERR PFX
+                        "limiting to CPU %d failed in powernowk8_get\n", cpu);
+                set_cpus_allowed_ptr(current, &oldmask);
                 return 0;
         }
 
@@ -1253,13 +1254,14 @@ static unsigned int powernowk8_get (unsigned int cpu)
                 goto out;
 
         if (cpu_family == CPU_HW_PSTATE)
-                khz = find_khz_freq_from_pstate(data->powernow_table, data->currpstate);
+                khz = find_khz_freq_from_pstate(data->powernow_table,
+                                                data->currpstate);
         else
                 khz = find_khz_freq_from_fid(data->currfid);
 
 
 out:
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         return khz;
 }
 
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
index 3031f1196192..908dd347c67e 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -315,7 +315,7 @@ static unsigned int get_cur_freq(unsigned int cpu)
         cpumask_t saved_mask;
 
         saved_mask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
         if (smp_processor_id() != cpu)
                 return 0;
 
@@ -333,7 +333,7 @@ static unsigned int get_cur_freq(unsigned int cpu)
                 clock_freq = extract_clock(l, cpu, 1);
         }
 
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return clock_freq;
 }
 
@@ -487,7 +487,7 @@ static int centrino_target (struct cpufreq_policy *policy,
                 else
                         cpu_set(j, set_mask);
 
-                set_cpus_allowed(current, set_mask);
+                set_cpus_allowed_ptr(current, &set_mask);
                 preempt_disable();
                 if (unlikely(!cpu_isset(smp_processor_id(), set_mask))) {
                         dprintk("couldn't limit to CPUs in this domain\n");
@@ -555,7 +555,8 @@ static int centrino_target (struct cpufreq_policy *policy,
 
                 if (!cpus_empty(covered_cpus)) {
                         for_each_cpu_mask(j, covered_cpus) {
-                                set_cpus_allowed(current, cpumask_of_cpu(j));
+                                set_cpus_allowed_ptr(current,
+                                                     &cpumask_of_cpu(j));
                                 wrmsr(MSR_IA32_PERF_CTL, oldmsr, h);
                         }
                 }
@@ -569,12 +570,12 @@ static int centrino_target (struct cpufreq_policy *policy,
                         cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
                 }
         }
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return 0;
 
 migrate_end:
         preempt_enable();
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return 0;
 }
 
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
index 14d68aa301ee..1b50244b1fdf 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
@@ -229,22 +229,22 @@ static unsigned int speedstep_detect_chipset (void)
         return 0;
 }
 
-static unsigned int _speedstep_get(cpumask_t cpus)
+static unsigned int _speedstep_get(const cpumask_t *cpus)
 {
         unsigned int speed;
         cpumask_t cpus_allowed;
 
         cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed(current, cpus);
+        set_cpus_allowed_ptr(current, cpus);
         speed = speedstep_get_processor_frequency(speedstep_processor);
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
         dprintk("detected %u kHz as current frequency\n", speed);
         return speed;
 }
 
 static unsigned int speedstep_get(unsigned int cpu)
 {
-        return _speedstep_get(cpumask_of_cpu(cpu));
+        return _speedstep_get(&cpumask_of_cpu(cpu));
 }
 
 /**
@@ -267,7 +267,7 @@ static int speedstep_target (struct cpufreq_policy *policy,
         if (cpufreq_frequency_table_target(policy, &speedstep_freqs[0], target_freq, relation, &newstate))
                 return -EINVAL;
 
-        freqs.old = _speedstep_get(policy->cpus);
+        freqs.old = _speedstep_get(&policy->cpus);
         freqs.new = speedstep_freqs[newstate].frequency;
         freqs.cpu = policy->cpu;
 
@@ -285,12 +285,12 @@ static int speedstep_target (struct cpufreq_policy *policy,
         }
 
         /* switch to physical CPU where state is to be changed */
-        set_cpus_allowed(current, policy->cpus);
+        set_cpus_allowed_ptr(current, &policy->cpus);
 
         speedstep_set_state(newstate);
 
         /* allow to be run on all CPUs */
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
 
         for_each_cpu_mask(i, policy->cpus) {
                 freqs.cpu = i;
@@ -326,7 +326,7 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy)
 #endif
 
         cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed(current, policy->cpus);
+        set_cpus_allowed_ptr(current, &policy->cpus);
 
         /* detect low and high frequency and transition latency */
         result = speedstep_get_freqs(speedstep_processor,
@@ -334,12 +334,12 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy)
                                      &speedstep_freqs[SPEEDSTEP_HIGH].frequency,
                                      &policy->cpuinfo.transition_latency,
                                      &speedstep_set_state);
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
         if (result)
                 return result;
 
         /* get current speed setting */
-        speed = _speedstep_get(policy->cpus);
+        speed = _speedstep_get(&policy->cpus);
         if (!speed)
                 return -EIO;