cpufreq: intel_pstate: Rearrange max frequency updates handling code

Rename __intel_pstate_update_max_freq() to intel_pstate_update_max_freq()
and move the cpufreq policy reference counting and locking into it (and
implement the locking with the recently introduced cpufreq policy "write"
locking guard).

No intentional functional impact.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
Acked-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
Link: https://patch.msgid.link/2315023.iZASKD2KPV@rjwysocki.net

diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index 4aad79d26c64f59f45e5aeb7c8bdc25094c6a07b..108e4c6a371ecacf010a5aa13af26d94859d20d8 100644 (file)
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -1353,9 +1353,16 @@ static void intel_pstate_update_policies(void)
                cpufreq_update_policy(cpu);
 }
 
-static void __intel_pstate_update_max_freq(struct cpudata *cpudata,
-                                          struct cpufreq_policy *policy)
+static bool intel_pstate_update_max_freq(struct cpudata *cpudata)
 {
+       struct cpufreq_policy *policy __free(put_cpufreq_policy);
+
+       policy = cpufreq_cpu_get(cpudata->cpu);
+       if (!policy)
+               return false;
+
+       guard(cpufreq_policy_write)(policy);
+
        if (hwp_active)
                intel_pstate_get_hwp_cap(cpudata);
 
@@ -1363,44 +1370,24 @@ static void __intel_pstate_update_max_freq(struct cpudata *cpudata,
                        cpudata->pstate.max_freq : cpudata->pstate.turbo_freq;
 
        refresh_frequency_limits(policy);
+
+       return true;
 }
 
 static void intel_pstate_update_limits(unsigned int cpu)
 {
-       struct cpufreq_policy *policy = cpufreq_cpu_acquire(cpu);
-       struct cpudata *cpudata;
-
-       if (!policy)
-               return;
-
-       cpudata = all_cpu_data[cpu];
-
-       __intel_pstate_update_max_freq(cpudata, policy);
-
-       /* Prevent the driver from being unregistered now. */
-       mutex_lock(&intel_pstate_driver_lock);
+       struct cpudata *cpudata = all_cpu_data[cpu];
 
-       cpufreq_cpu_release(policy);
-
-       hybrid_update_capacity(cpudata);
-
-       mutex_unlock(&intel_pstate_driver_lock);
+       if (intel_pstate_update_max_freq(cpudata))
+               hybrid_update_capacity(cpudata);
 }
 
 static void intel_pstate_update_limits_for_all(void)
 {
        int cpu;
 
-       for_each_possible_cpu(cpu) {
-               struct cpufreq_policy *policy = cpufreq_cpu_acquire(cpu);
-
-               if (!policy)
-                       continue;
-
-               __intel_pstate_update_max_freq(all_cpu_data[cpu], policy);
-
-               cpufreq_cpu_release(policy);
-       }
+       for_each_possible_cpu(cpu)
+               intel_pstate_update_max_freq(all_cpu_data[cpu]);
 
        mutex_lock(&hybrid_capacity_lock);
 
@@ -1840,13 +1827,8 @@ static void intel_pstate_notify_work(struct work_struct *work)
 {
        struct cpudata *cpudata =
                container_of(to_delayed_work(work), struct cpudata, hwp_notify_work);
-       struct cpufreq_policy *policy = cpufreq_cpu_acquire(cpudata->cpu);
-
-       if (policy) {
-               __intel_pstate_update_max_freq(cpudata, policy);
-
-               cpufreq_cpu_release(policy);
 
+       if (intel_pstate_update_max_freq(cpudata)) {
                /*
                 * The driver will not be unregistered while this function is
                 * running, so update the capacity without acquiring the driver