23 files changed, 119 insertions, 153 deletions

diff --git a/arch/arm/mach-davinci/cpufreq.c b/arch/arm/mach-davinci/cpufreq.c
index 4729eaab0f40..55eb8703043d 100644
--- a/arch/arm/mach-davinci/cpufreq.c
+++ b/arch/arm/mach-davinci/cpufreq.c
@@ -90,7 +90,6 @@ static int davinci_target(struct cpufreq_policy *policy,
 
         freqs.old = davinci_getspeed(0);
         freqs.new = clk_round_rate(armclk, target_freq * 1000) / 1000;
-        freqs.cpu = 0;
 
         if (freqs.old == freqs.new)
                 return ret;
@@ -102,7 +101,7 @@ static int davinci_target(struct cpufreq_policy *policy,
         if (ret)
                 return -EINVAL;
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         /* if moving to higher frequency, up the voltage beforehand */
         if (pdata->set_voltage && freqs.new > freqs.old) {
@@ -126,7 +125,7 @@ static int davinci_target(struct cpufreq_policy *policy,
                 pdata->set_voltage(idx);
 
 out:
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         return ret;
 }
diff --git a/arch/arm/mach-imx/cpufreq.c b/arch/arm/mach-imx/cpufreq.c
index d8c75c3c925d..cfce5e3f67f5 100644
--- a/arch/arm/mach-imx/cpufreq.c
+++ b/arch/arm/mach-imx/cpufreq.c
@@ -87,13 +87,12 @@ static int mxc_set_target(struct cpufreq_policy *policy,
 
         freqs.old = clk_get_rate(cpu_clk) / 1000;
         freqs.new = freq_Hz / 1000;
-        freqs.cpu = 0;
         freqs.flags = 0;
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         ret = set_cpu_freq(freq_Hz);
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         return ret;
 }
diff --git a/arch/arm/mach-integrator/cpu.c b/arch/arm/mach-integrator/cpu.c
index 590c192cdf4d..df863c30771c 100644
--- a/arch/arm/mach-integrator/cpu.c
+++ b/arch/arm/mach-integrator/cpu.c
@@ -123,14 +123,12 @@ static int integrator_set_target(struct cpufreq_policy *policy,
         vco = icst_hz_to_vco(&cclk_params, target_freq * 1000);
         freqs.new = icst_hz(&cclk_params, vco) / 1000;
 
-        freqs.cpu = policy->cpu;
-
         if (freqs.old == freqs.new) {
                 set_cpus_allowed(current, cpus_allowed);
                 return 0;
         }
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         cm_osc = __raw_readl(CM_OSC);
 
@@ -151,7 +149,7 @@ static int integrator_set_target(struct cpufreq_policy *policy,
          */
         set_cpus_allowed(current, cpus_allowed);
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         return 0;
 }
diff --git a/arch/arm/mach-pxa/cpufreq-pxa2xx.c b/arch/arm/mach-pxa/cpufreq-pxa2xx.c
index 6a7aeab42f6c..f1ca4daa1ad6 100644
--- a/arch/arm/mach-pxa/cpufreq-pxa2xx.c
+++ b/arch/arm/mach-pxa/cpufreq-pxa2xx.c
@@ -311,7 +311,6 @@ static int pxa_set_target(struct cpufreq_policy *policy,
         new_freq_mem = pxa_freq_settings[idx].membus;
         freqs.old = policy->cur;
         freqs.new = new_freq_cpu;
-        freqs.cpu = policy->cpu;
 
         if (freq_debug)
                 pr_debug("Changing CPU frequency to %d Mhz, (SDRAM %d Mhz)\n",
@@ -327,7 +326,7 @@ static int pxa_set_target(struct cpufreq_policy *policy,
          * you should add a notify client with any platform specific
          * Vcc changing capability
          */
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         /* Calculate the next MDREFR.  If we're slowing down the SDRAM clock
          * we need to preset the smaller DRI before the change.  If we're
@@ -382,7 +381,7 @@ static int pxa_set_target(struct cpufreq_policy *policy,
          * you should add a notify client with any platform specific
          * SDRAM refresh timer adjustments
          */
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         /*
          * Even if voltage setting fails, we don't report it, as the frequency
diff --git a/arch/arm/mach-pxa/cpufreq-pxa3xx.c b/arch/arm/mach-pxa/cpufreq-pxa3xx.c
index b85b4ab7aac6..8c45b2b926a7 100644
--- a/arch/arm/mach-pxa/cpufreq-pxa3xx.c
+++ b/arch/arm/mach-pxa/cpufreq-pxa3xx.c
@@ -184,7 +184,6 @@ static int pxa3xx_cpufreq_set(struct cpufreq_policy *policy,
 
         freqs.old = policy->cur;
         freqs.new = next->cpufreq_mhz * 1000;
-        freqs.cpu = policy->cpu;
 
         pr_debug("CPU frequency from %d MHz to %d MHz%s\n",
                         freqs.old / 1000, freqs.new / 1000,
@@ -193,14 +192,14 @@ static int pxa3xx_cpufreq_set(struct cpufreq_policy *policy,
         if (freqs.old == target_freq)
                 return 0;
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         local_irq_save(flags);
         __update_core_freq(next);
         __update_bus_freq(next);
         local_irq_restore(flags);
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         return 0;
 }
diff --git a/arch/arm/mach-s3c24xx/cpufreq.c b/arch/arm/mach-s3c24xx/cpufreq.c
index 5f181e733eee..3c0e78ede0da 100644
--- a/arch/arm/mach-s3c24xx/cpufreq.c
+++ b/arch/arm/mach-s3c24xx/cpufreq.c
@@ -204,7 +204,6 @@ static int s3c_cpufreq_settarget(struct cpufreq_policy *policy,
         freqs.old = cpu_cur.freq;
         freqs.new = cpu_new.freq;
 
-        freqs.freqs.cpu = 0;
         freqs.freqs.old = cpu_cur.freq.armclk / 1000;
         freqs.freqs.new = cpu_new.freq.armclk / 1000;
 
@@ -218,9 +217,7 @@ static int s3c_cpufreq_settarget(struct cpufreq_policy *policy,
         s3c_cpufreq_updateclk(clk_pclk, cpu_new.freq.pclk);
 
         /* start the frequency change */
-
-        if (policy)
-                cpufreq_notify_transition(&freqs.freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs.freqs, CPUFREQ_PRECHANGE);
 
         /* If hclk is staying the same, then we do not need to
          * re-write the IO or the refresh timings whilst we are changing
@@ -264,8 +261,7 @@ static int s3c_cpufreq_settarget(struct cpufreq_policy *policy,
         local_irq_restore(flags);
 
         /* notify everyone we've done this */
-        if (policy)
-                cpufreq_notify_transition(&freqs.freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs.freqs, CPUFREQ_POSTCHANGE);
 
         s3c_freq_dbg("%s: finished\n", __func__);
         return 0;
diff --git a/arch/arm/mach-sa1100/cpu-sa1100.c b/arch/arm/mach-sa1100/cpu-sa1100.c
index e8f4d1e19233..32687617c7a5 100644
--- a/arch/arm/mach-sa1100/cpu-sa1100.c
+++ b/arch/arm/mach-sa1100/cpu-sa1100.c
@@ -201,9 +201,8 @@ static int sa1100_target(struct cpufreq_policy *policy,
 
         freqs.old = cur;
         freqs.new = sa11x0_ppcr_to_freq(new_ppcr);
-        freqs.cpu = 0;
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         if (freqs.new > cur)
                 sa1100_update_dram_timings(cur, freqs.new);
@@ -213,7 +212,7 @@ static int sa1100_target(struct cpufreq_policy *policy,
         if (freqs.new < cur)
                 sa1100_update_dram_timings(cur, freqs.new);
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         return 0;
 }
diff --git a/arch/arm/mach-sa1100/cpu-sa1110.c b/arch/arm/mach-sa1100/cpu-sa1110.c
index 48c45b0c92bb..38a77330dc16 100644
--- a/arch/arm/mach-sa1100/cpu-sa1110.c
+++ b/arch/arm/mach-sa1100/cpu-sa1110.c
@@ -258,7 +258,6 @@ static int sa1110_target(struct cpufreq_policy *policy,
 
         freqs.old = sa11x0_getspeed(0);
         freqs.new = sa11x0_ppcr_to_freq(ppcr);
-        freqs.cpu = 0;
 
         sdram_calculate_timing(&sd, freqs.new, sdram);
 
@@ -279,7 +278,7 @@ static int sa1110_target(struct cpufreq_policy *policy,
         sd.mdcas[2] = 0xaaaaaaaa;
 #endif
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         /*
          * The clock could be going away for some time.  Set the SDRAMs
@@ -327,7 +326,7 @@ static int sa1110_target(struct cpufreq_policy *policy,
          */
         sdram_update_refresh(freqs.new, sdram);
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         return 0;
 }
diff --git a/arch/arm/mach-tegra/cpu-tegra.c b/arch/arm/mach-tegra/cpu-tegra.c
index e3d6e15ff188..11ca730970f8 100644
--- a/arch/arm/mach-tegra/cpu-tegra.c
+++ b/arch/arm/mach-tegra/cpu-tegra.c
@@ -106,7 +106,8 @@ out:
         return ret;
 }
 
-static int tegra_update_cpu_speed(unsigned long rate)
+static int tegra_update_cpu_speed(struct cpufreq_policy *policy,
+                unsigned long rate)
 {
         int ret = 0;
         struct cpufreq_freqs freqs;
@@ -128,8 +129,7 @@ static int tegra_update_cpu_speed(unsigned long rate)
         else
                 clk_set_rate(emc_clk, 100000000);  /* emc 50Mhz */
 
-        for_each_online_cpu(freqs.cpu)
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
 #ifdef CONFIG_CPU_FREQ_DEBUG
         printk(KERN_DEBUG "cpufreq-tegra: transition: %u --> %u\n",
@@ -143,8 +143,7 @@ static int tegra_update_cpu_speed(unsigned long rate)
                 return ret;
         }
 
-        for_each_online_cpu(freqs.cpu)
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         return 0;
 }
@@ -181,7 +180,7 @@ static int tegra_target(struct cpufreq_policy *policy,
 
         target_cpu_speed[policy->cpu] = freq;
 
-        ret = tegra_update_cpu_speed(tegra_cpu_highest_speed());
+        ret = tegra_update_cpu_speed(policy, tegra_cpu_highest_speed());
 
 out:
         mutex_unlock(&tegra_cpu_lock);
@@ -193,10 +192,12 @@ static int tegra_pm_notify(struct notifier_block *nb, unsigned long event,
 {
         mutex_lock(&tegra_cpu_lock);
         if (event == PM_SUSPEND_PREPARE) {
+                struct cpufreq_policy *policy = cpufreq_cpu_get(0);
                 is_suspended = true;
                 pr_info("Tegra cpufreq suspend: setting frequency to %d kHz\n",
                         freq_table[0].frequency);
-                tegra_update_cpu_speed(freq_table[0].frequency);
+                tegra_update_cpu_speed(policy, freq_table[0].frequency);
+                cpufreq_cpu_put(policy);
         } else if (event == PM_POST_SUSPEND) {
                 is_suspended = false;
         }
diff --git a/arch/avr32/mach-at32ap/cpufreq.c b/arch/avr32/mach-at32ap/cpufreq.c
index 18b765629a0c..654488723cb5 100644
--- a/arch/avr32/mach-at32ap/cpufreq.c
+++ b/arch/avr32/mach-at32ap/cpufreq.c
@@ -61,7 +61,6 @@ static int at32_set_target(struct cpufreq_policy *policy,
 
         freqs.old = at32_get_speed(0);
         freqs.new = (freq + 500) / 1000;
-        freqs.cpu = 0;
         freqs.flags = 0;
 
         if (!ref_freq) {
@@ -69,7 +68,7 @@ static int at32_set_target(struct cpufreq_policy *policy,
                 loops_per_jiffy_ref = boot_cpu_data.loops_per_jiffy;
         }
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
         if (freqs.old < freqs.new)
                 boot_cpu_data.loops_per_jiffy = cpufreq_scale(
                                 loops_per_jiffy_ref, ref_freq, freqs.new);
@@ -77,7 +76,7 @@ static int at32_set_target(struct cpufreq_policy *policy,
         if (freqs.new < freqs.old)
                 boot_cpu_data.loops_per_jiffy = cpufreq_scale(
                                 loops_per_jiffy_ref, ref_freq, freqs.new);
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         pr_debug("cpufreq: set frequency %lu Hz\n", freq);
 
diff --git a/arch/blackfin/mach-common/cpufreq.c b/arch/blackfin/mach-common/cpufreq.c
index d88bd31319e6..995511e80bef 100644
--- a/arch/blackfin/mach-common/cpufreq.c
+++ b/arch/blackfin/mach-common/cpufreq.c
@@ -127,13 +127,13 @@ unsigned long cpu_set_cclk(int cpu, unsigned long new)
 }
 #endif
 
-static int bfin_target(struct cpufreq_policy *poli,
+static int bfin_target(struct cpufreq_policy *policy,
                         unsigned int target_freq, unsigned int relation)
 {
 #ifndef CONFIG_BF60x
         unsigned int plldiv;
 #endif
-        unsigned int index, cpu;
+        unsigned int index;
         unsigned long cclk_hz;
         struct cpufreq_freqs freqs;
         static unsigned long lpj_ref;
@@ -144,59 +144,48 @@ static int bfin_target(struct cpufreq_policy *poli,
         cycles_t cycles;
 #endif
 
-        for_each_online_cpu(cpu) {
-                struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
+        if (cpufreq_frequency_table_target(policy, bfin_freq_table, target_freq,
+                                relation, &index))
+                return -EINVAL;
 
-                if (!policy)
-                        continue;
+        cclk_hz = bfin_freq_table[index].frequency;
 
-                if (cpufreq_frequency_table_target(policy, bfin_freq_table,
-                                 target_freq, relation, &index))
-                        return -EINVAL;
+        freqs.old = bfin_getfreq_khz(0);
+        freqs.new = cclk_hz;
 
-                cclk_hz = bfin_freq_table[index].frequency;
+        pr_debug("cpufreq: changing cclk to %lu; target = %u, oldfreq = %u\n",
+                        cclk_hz, target_freq, freqs.old);
 
-                freqs.old = bfin_getfreq_khz(0);
-                freqs.new = cclk_hz;
-                freqs.cpu = cpu;
-
-                pr_debug("cpufreq: changing cclk to %lu; target = %u, oldfreq = %u\n",
-                         cclk_hz, target_freq, freqs.old);
-
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-                if (cpu == CPUFREQ_CPU) {
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 #ifndef CONFIG_BF60x
-                        plldiv = (bfin_read_PLL_DIV() & SSEL) |
-                                                dpm_state_table[index].csel;
-                        bfin_write_PLL_DIV(plldiv);
+        plldiv = (bfin_read_PLL_DIV() & SSEL) | dpm_state_table[index].csel;
+        bfin_write_PLL_DIV(plldiv);
 #else
-                        ret = cpu_set_cclk(cpu, freqs.new * 1000);
-                        if (ret != 0) {
-                                WARN_ONCE(ret, "cpufreq set freq failed %d\n", ret);
-                                break;
-                        }
+        ret = cpu_set_cclk(policy->cpu, freqs.new * 1000);
+        if (ret != 0) {
+                WARN_ONCE(ret, "cpufreq set freq failed %d\n", ret);
+                return ret;
+        }
 #endif
-                        on_each_cpu(bfin_adjust_core_timer, &index, 1);
+        on_each_cpu(bfin_adjust_core_timer, &index, 1);
 #if defined(CONFIG_CYCLES_CLOCKSOURCE)
-                        cycles = get_cycles();
-                        SSYNC();
-                        cycles += 10; /* ~10 cycles we lose after get_cycles() */
-                        __bfin_cycles_off +=
-                            (cycles << __bfin_cycles_mod) - (cycles << index);
-                        __bfin_cycles_mod = index;
+        cycles = get_cycles();
+        SSYNC();
+        cycles += 10; /* ~10 cycles we lose after get_cycles() */
+        __bfin_cycles_off += (cycles << __bfin_cycles_mod) - (cycles << index);
+        __bfin_cycles_mod = index;
 #endif
-                        if (!lpj_ref_freq) {
-                                lpj_ref = loops_per_jiffy;
-                                lpj_ref_freq = freqs.old;
-                        }
-                        if (freqs.new != freqs.old) {
-                                loops_per_jiffy = cpufreq_scale(lpj_ref,
-                                                lpj_ref_freq, freqs.new);
-                        }
-                }
-                /* TODO: just test case for cycles clock source, remove later */
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        if (!lpj_ref_freq) {
+                lpj_ref = loops_per_jiffy;
+                lpj_ref_freq = freqs.old;
         }
+        if (freqs.new != freqs.old) {
+                loops_per_jiffy = cpufreq_scale(lpj_ref,
+                                lpj_ref_freq, freqs.new);
+        }
+
+        /* TODO: just test case for cycles clock source, remove later */
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         pr_debug("cpufreq: done\n");
         return ret;
diff --git a/arch/cris/arch-v32/mach-a3/cpufreq.c b/arch/cris/arch-v32/mach-a3/cpufreq.c
index ee391ecb5bc9..ee142c490575 100644
--- a/arch/cris/arch-v32/mach-a3/cpufreq.c
+++ b/arch/cris/arch-v32/mach-a3/cpufreq.c
@@ -27,23 +27,17 @@ static unsigned int cris_freq_get_cpu_frequency(unsigned int cpu)
         return clk_ctrl.pll ? 200000 : 6000;
 }
 
-static void cris_freq_set_cpu_state(unsigned int state)
+static void cris_freq_set_cpu_state(struct cpufreq_policy *policy,
+                unsigned int state)
 {
-        int i = 0;
         struct cpufreq_freqs freqs;
         reg_clkgen_rw_clk_ctrl clk_ctrl;
         clk_ctrl = REG_RD(clkgen, regi_clkgen, rw_clk_ctrl);
 
-#ifdef CONFIG_SMP
-        for_each_present_cpu(i)
-#endif
-        {
-                freqs.old = cris_freq_get_cpu_frequency(i);
-                freqs.new = cris_freq_table[state].frequency;
-                freqs.cpu = i;
-        }
+        freqs.old = cris_freq_get_cpu_frequency(policy->cpu);
+        freqs.new = cris_freq_table[state].frequency;
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         local_irq_disable();
 
@@ -57,7 +51,7 @@ static void cris_freq_set_cpu_state(unsigned int state)
 
         local_irq_enable();
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 };
 
 static int cris_freq_verify(struct cpufreq_policy *policy)
@@ -75,7 +69,7 @@ static int cris_freq_target(struct cpufreq_policy *policy,
                         target_freq, relation, &newstate))
                 return -EINVAL;
 
-        cris_freq_set_cpu_state(newstate);
+        cris_freq_set_cpu_state(policy, newstate);
 
         return 0;
 }
diff --git a/arch/cris/arch-v32/mach-fs/cpufreq.c b/arch/cris/arch-v32/mach-fs/cpufreq.c
index d92cf70d1cbe..12952235d5db 100644
--- a/arch/cris/arch-v32/mach-fs/cpufreq.c
+++ b/arch/cris/arch-v32/mach-fs/cpufreq.c
@@ -27,20 +27,17 @@ static unsigned int cris_freq_get_cpu_frequency(unsigned int cpu)
         return clk_ctrl.pll ? 200000 : 6000;
 }
 
-static void cris_freq_set_cpu_state(unsigned int state)
+static void cris_freq_set_cpu_state(struct cpufreq_policy *policy,
+                unsigned int state)
 {
-        int i;
         struct cpufreq_freqs freqs;
         reg_config_rw_clk_ctrl clk_ctrl;
         clk_ctrl = REG_RD(config, regi_config, rw_clk_ctrl);
 
-        for_each_possible_cpu(i) {
-                freqs.old = cris_freq_get_cpu_frequency(i);
-                freqs.new = cris_freq_table[state].frequency;
-                freqs.cpu = i;
-        }
+        freqs.old = cris_freq_get_cpu_frequency(policy->cpu);
+        freqs.new = cris_freq_table[state].frequency;
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         local_irq_disable();
 
@@ -54,7 +51,7 @@ static void cris_freq_set_cpu_state(unsigned int state)
 
         local_irq_enable();
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 };
 
 static int cris_freq_verify(struct cpufreq_policy *policy)
@@ -71,7 +68,7 @@ static int cris_freq_target(struct cpufreq_policy *policy,
             (policy, cris_freq_table, target_freq, relation, &newstate))
                 return -EINVAL;
 
-        cris_freq_set_cpu_state(newstate);
+        cris_freq_set_cpu_state(policy, newstate);
 
         return 0;
 }
diff --git a/arch/ia64/kernel/cpufreq/acpi-cpufreq.c b/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
index f09b174244d5..4700fef8d1fa 100644
--- a/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
+++ b/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
@@ -137,7 +137,7 @@ migrate_end:
 static int
 processor_set_freq (
         struct cpufreq_acpi_io  *data,
-        unsigned int            cpu,
+        struct cpufreq_policy   *policy,
         int                     state)
 {
         int                     ret = 0;
@@ -149,8 +149,8 @@ processor_set_freq (
         pr_debug("processor_set_freq\n");
 
         saved_mask = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, cpumask_of(cpu));
-        if (smp_processor_id() != cpu) {
+        set_cpus_allowed_ptr(current, cpumask_of(policy->cpu));
+        if (smp_processor_id() != policy->cpu) {
                 retval = -EAGAIN;
                 goto migrate_end;
         }
@@ -170,12 +170,11 @@ processor_set_freq (
                 data->acpi_data.state, state);
 
         /* cpufreq frequency struct */
-        cpufreq_freqs.cpu = cpu;
         cpufreq_freqs.old = data->freq_table[data->acpi_data.state].frequency;
         cpufreq_freqs.new = data->freq_table[state].frequency;
 
         /* notify cpufreq */
-        cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &cpufreq_freqs, CPUFREQ_PRECHANGE);
 
         /*
          * First we write the target state's 'control' value to the
@@ -189,17 +188,20 @@ processor_set_freq (
         ret = processor_set_pstate(value);
         if (ret) {
                 unsigned int tmp = cpufreq_freqs.new;
-                cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
+                cpufreq_notify_transition(policy, &cpufreq_freqs,
+                                CPUFREQ_POSTCHANGE);
                 cpufreq_freqs.new = cpufreq_freqs.old;
                 cpufreq_freqs.old = tmp;
-                cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_PRECHANGE);
-                cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
+                cpufreq_notify_transition(policy, &cpufreq_freqs,
+                                CPUFREQ_PRECHANGE);
+                cpufreq_notify_transition(policy, &cpufreq_freqs,
+                                CPUFREQ_POSTCHANGE);
                 printk(KERN_WARNING "Transition failed with error %d\n", ret);
                 retval = -ENODEV;
                 goto migrate_end;
         }
 
-        cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &cpufreq_freqs, CPUFREQ_POSTCHANGE);
 
         data->acpi_data.state = state;
 
@@ -240,7 +242,7 @@ acpi_cpufreq_target (
         if (result)
                 return (result);
 
-        result = processor_set_freq(data, policy->cpu, next_state);
+        result = processor_set_freq(data, policy, next_state);
 
         return (result);
 }
diff --git a/arch/mips/kernel/cpufreq/loongson2_cpufreq.c b/arch/mips/kernel/cpufreq/loongson2_cpufreq.c
index 3237c5235f9c..bafda7063f03 100644
--- a/arch/mips/kernel/cpufreq/loongson2_cpufreq.c
+++ b/arch/mips/kernel/cpufreq/loongson2_cpufreq.c
@@ -80,7 +80,6 @@ static int loongson2_cpufreq_target(struct cpufreq_policy *policy,
 
         pr_debug("cpufreq: requested frequency %u Hz\n", target_freq * 1000);
 
-        freqs.cpu = cpu;
         freqs.old = loongson2_cpufreq_get(cpu);
         freqs.new = freq;
         freqs.flags = 0;
@@ -89,7 +88,7 @@ static int loongson2_cpufreq_target(struct cpufreq_policy *policy,
                 return 0;
 
         /* notifiers */
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         set_cpus_allowed_ptr(current, &cpus_allowed);
 
@@ -97,7 +96,7 @@ static int loongson2_cpufreq_target(struct cpufreq_policy *policy,
         clk_set_rate(cpuclk, freq);
 
         /* notifiers */
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         pr_debug("cpufreq: set frequency %u kHz\n", freq);
 
diff --git a/arch/powerpc/platforms/cell/cbe_cpufreq.c b/arch/powerpc/platforms/cell/cbe_cpufreq.c
index d4c39e32f147..718c6a33023d 100644
--- a/arch/powerpc/platforms/cell/cbe_cpufreq.c
+++ b/arch/powerpc/platforms/cell/cbe_cpufreq.c
@@ -156,10 +156,9 @@ static int cbe_cpufreq_target(struct cpufreq_policy *policy,
 
         freqs.old = policy->cur;
         freqs.new = cbe_freqs[cbe_pmode_new].frequency;
-        freqs.cpu = policy->cpu;
 
         mutex_lock(&cbe_switch_mutex);
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         pr_debug("setting frequency for cpu %d to %d kHz, " \
                  "1/%d of max frequency\n",
@@ -169,7 +168,7 @@ static int cbe_cpufreq_target(struct cpufreq_policy *policy,
 
         rc = set_pmode(policy->cpu, cbe_pmode_new);
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
         mutex_unlock(&cbe_switch_mutex);
 
         return rc;
diff --git a/arch/powerpc/platforms/pasemi/cpufreq.c b/arch/powerpc/platforms/pasemi/cpufreq.c
index 890f30e70f98..be1e7958909e 100644
--- a/arch/powerpc/platforms/pasemi/cpufreq.c
+++ b/arch/powerpc/platforms/pasemi/cpufreq.c
@@ -273,10 +273,9 @@ static int pas_cpufreq_target(struct cpufreq_policy *policy,
 
         freqs.old = policy->cur;
         freqs.new = pas_freqs[pas_astate_new].frequency;
-        freqs.cpu = policy->cpu;
 
         mutex_lock(&pas_switch_mutex);
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         pr_debug("setting frequency for cpu %d to %d kHz, 1/%d of max frequency\n",
                  policy->cpu,
@@ -288,7 +287,7 @@ static int pas_cpufreq_target(struct cpufreq_policy *policy,
         for_each_online_cpu(i)
                 set_astate(i, pas_astate_new);
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
         mutex_unlock(&pas_switch_mutex);
 
         ppc_proc_freq = freqs.new * 1000ul;
diff --git a/arch/powerpc/platforms/powermac/cpufreq_32.c b/arch/powerpc/platforms/powermac/cpufreq_32.c
index 311b804353b1..3104fad82480 100644
--- a/arch/powerpc/platforms/powermac/cpufreq_32.c
+++ b/arch/powerpc/platforms/powermac/cpufreq_32.c
@@ -335,7 +335,8 @@ static int pmu_set_cpu_speed(int low_speed)
         return 0;
 }
 
-static int do_set_cpu_speed(int speed_mode, int notify)
+static int do_set_cpu_speed(struct cpufreq_policy *policy, int speed_mode,
+                int notify)
 {
         struct cpufreq_freqs freqs;
         unsigned long l3cr;
@@ -343,13 +344,12 @@ static int do_set_cpu_speed(int speed_mode, int notify)
 
         freqs.old = cur_freq;
         freqs.new = (speed_mode == CPUFREQ_HIGH) ? hi_freq : low_freq;
-        freqs.cpu = smp_processor_id();
 
         if (freqs.old == freqs.new)
                 return 0;
 
         if (notify)
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+                cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
         if (speed_mode == CPUFREQ_LOW &&
             cpu_has_feature(CPU_FTR_L3CR)) {
                 l3cr = _get_L3CR();
@@ -366,7 +366,7 @@ static int do_set_cpu_speed(int speed_mode, int notify)
                         _set_L3CR(prev_l3cr);
         }
         if (notify)
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+                cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
         cur_freq = (speed_mode == CPUFREQ_HIGH) ? hi_freq : low_freq;
 
         return 0;
@@ -393,7 +393,7 @@ static int pmac_cpufreq_target(	struct cpufreq_policy *policy,
                         target_freq, relation, &newstate))
                 return -EINVAL;
 
-        rc = do_set_cpu_speed(newstate, 1);
+        rc = do_set_cpu_speed(policy, newstate, 1);
 
         ppc_proc_freq = cur_freq * 1000ul;
         return rc;
@@ -442,7 +442,7 @@ static int pmac_cpufreq_suspend(struct cpufreq_policy *policy)
         no_schedule = 1;
         sleep_freq = cur_freq;
         if (cur_freq == low_freq && !is_pmu_based)
-                do_set_cpu_speed(CPUFREQ_HIGH, 0);
+                do_set_cpu_speed(policy, CPUFREQ_HIGH, 0);
         return 0;
 }
 
@@ -458,7 +458,7 @@ static int pmac_cpufreq_resume(struct cpufreq_policy *policy)
          * is that we force a switch to whatever it was, which is
          * probably high speed due to our suspend() routine
          */
-        do_set_cpu_speed(sleep_freq == low_freq ?
+        do_set_cpu_speed(policy, sleep_freq == low_freq ?
                          CPUFREQ_LOW : CPUFREQ_HIGH, 0);
 
         ppc_proc_freq = cur_freq * 1000ul;
diff --git a/arch/powerpc/platforms/powermac/cpufreq_64.c b/arch/powerpc/platforms/powermac/cpufreq_64.c
index 9650c6029c82..7ba423431cfe 100644
--- a/arch/powerpc/platforms/powermac/cpufreq_64.c
+++ b/arch/powerpc/platforms/powermac/cpufreq_64.c
@@ -339,11 +339,10 @@ static int g5_cpufreq_target(struct cpufreq_policy *policy,
 
         freqs.old = g5_cpu_freqs[g5_pmode_cur].frequency;
         freqs.new = g5_cpu_freqs[newstate].frequency;
-        freqs.cpu = 0;
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
         rc = g5_switch_freq(newstate);
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         mutex_unlock(&g5_switch_mutex);
 
diff --git a/arch/sh/kernel/cpufreq.c b/arch/sh/kernel/cpufreq.c
index e68b45b6f3f9..2c7bd94f95ee 100644
--- a/arch/sh/kernel/cpufreq.c
+++ b/arch/sh/kernel/cpufreq.c
@@ -69,15 +69,14 @@ static int sh_cpufreq_target(struct cpufreq_policy *policy,
 
         dev_dbg(dev, "requested frequency %u Hz\n", target_freq * 1000);
 
-        freqs.cpu       = cpu;
         freqs.old       = sh_cpufreq_get(cpu);
         freqs.new       = (freq + 500) / 1000;
         freqs.flags     = 0;
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
         set_cpus_allowed_ptr(current, &cpus_allowed);
         clk_set_rate(cpuclk, freq);
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         dev_dbg(dev, "set frequency %lu Hz\n", freq);
 
diff --git a/arch/sparc/kernel/us2e_cpufreq.c b/arch/sparc/kernel/us2e_cpufreq.c
index 489fc15f3194..abe963d7b87c 100644
--- a/arch/sparc/kernel/us2e_cpufreq.c
+++ b/arch/sparc/kernel/us2e_cpufreq.c
@@ -248,8 +248,10 @@ static unsigned int us2e_freq_get(unsigned int cpu)
         return clock_tick / estar_to_divisor(estar);
 }
 
-static void us2e_set_cpu_divider_index(unsigned int cpu, unsigned int index)
+static void us2e_set_cpu_divider_index(struct cpufreq_policy *policy,
+                unsigned int index)
 {
+        unsigned int cpu = policy->cpu;
         unsigned long new_bits, new_freq;
         unsigned long clock_tick, divisor, old_divisor, estar;
         cpumask_t cpus_allowed;
@@ -272,14 +274,13 @@ static void us2e_set_cpu_divider_index(unsigned int cpu, unsigned int index)
 
         freqs.old = clock_tick / old_divisor;
         freqs.new = new_freq;
-        freqs.cpu = cpu;
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         if (old_divisor != divisor)
                 us2e_transition(estar, new_bits, clock_tick * 1000,
                                 old_divisor, divisor);
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         set_cpus_allowed_ptr(current, &cpus_allowed);
 }
@@ -295,7 +296,7 @@ static int us2e_freq_target(struct cpufreq_policy *policy,
                                            target_freq, relation, &new_index))
                 return -EINVAL;
 
-        us2e_set_cpu_divider_index(policy->cpu, new_index);
+        us2e_set_cpu_divider_index(policy, new_index);
 
         return 0;
 }
@@ -335,7 +336,7 @@ static int __init us2e_freq_cpu_init(struct cpufreq_policy *policy)
 static int us2e_freq_cpu_exit(struct cpufreq_policy *policy)
 {
         if (cpufreq_us2e_driver)
-                us2e_set_cpu_divider_index(policy->cpu, 0);
+                us2e_set_cpu_divider_index(policy, 0);
 
         return 0;
 }
diff --git a/arch/sparc/kernel/us3_cpufreq.c b/arch/sparc/kernel/us3_cpufreq.c
index eb1624b931d9..7ceb9c8458f0 100644
--- a/arch/sparc/kernel/us3_cpufreq.c
+++ b/arch/sparc/kernel/us3_cpufreq.c
@@ -96,8 +96,10 @@ static unsigned int us3_freq_get(unsigned int cpu)
         return ret;
 }
 
-static void us3_set_cpu_divider_index(unsigned int cpu, unsigned int index)
+static void us3_set_cpu_divider_index(struct cpufreq_policy *policy,
+                unsigned int index)
 {
+        unsigned int cpu = policy->cpu;
         unsigned long new_bits, new_freq, reg;
         cpumask_t cpus_allowed;
         struct cpufreq_freqs freqs;
@@ -131,14 +133,13 @@ static void us3_set_cpu_divider_index(unsigned int cpu, unsigned int index)
 
         freqs.old = get_current_freq(cpu, reg);
         freqs.new = new_freq;
-        freqs.cpu = cpu;
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         reg &= ~SAFARI_CFG_DIV_MASK;
         reg |= new_bits;
         write_safari_cfg(reg);
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         set_cpus_allowed_ptr(current, &cpus_allowed);
 }
@@ -156,7 +157,7 @@ static int us3_freq_target(struct cpufreq_policy *policy,
                                            &new_index))
                 return -EINVAL;
 
-        us3_set_cpu_divider_index(policy->cpu, new_index);
+        us3_set_cpu_divider_index(policy, new_index);
 
         return 0;
 }
@@ -192,7 +193,7 @@ static int __init us3_freq_cpu_init(struct cpufreq_policy *policy)
 static int us3_freq_cpu_exit(struct cpufreq_policy *policy)
 {
         if (cpufreq_us3_driver)
-                us3_set_cpu_divider_index(policy->cpu, 0);
+                us3_set_cpu_divider_index(policy, 0);
 
         return 0;
 }
diff --git a/arch/unicore32/kernel/cpu-ucv2.c b/arch/unicore32/kernel/cpu-ucv2.c
index 4a99f62584c7..ba5a71ce2d71 100644
--- a/arch/unicore32/kernel/cpu-ucv2.c
+++ b/arch/unicore32/kernel/cpu-ucv2.c
@@ -52,15 +52,14 @@ static int ucv2_target(struct cpufreq_policy *policy,
         struct cpufreq_freqs freqs;
         struct clk *mclk = clk_get(NULL, "MAIN_CLK");
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 
         if (!clk_set_rate(mclk, target_freq * 1000)) {
                 freqs.old = cur;
                 freqs.new = target_freq;
-                freqs.cpu = 0;
         }
 
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 
         return 0;
 }