cpufreq: stats: Make the stats code non-modular

[cascardo/linux.git] / drivers / cpufreq / cpufreq.c

diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 36bc11a..c6a14ba 100644 (file)
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -74,19 +74,12 @@ static inline bool has_target(void)
 }
 
 /* internal prototypes */
-static int cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
 static unsigned int __cpufreq_get(struct cpufreq_policy *policy);
+static int cpufreq_init_governor(struct cpufreq_policy *policy);
+static void cpufreq_exit_governor(struct cpufreq_policy *policy);
 static int cpufreq_start_governor(struct cpufreq_policy *policy);
-
-static inline void cpufreq_exit_governor(struct cpufreq_policy *policy)
-{
-       (void)cpufreq_governor(policy, CPUFREQ_GOV_POLICY_EXIT);
-}
-
-static inline void cpufreq_stop_governor(struct cpufreq_policy *policy)
-{
-       (void)cpufreq_governor(policy, CPUFREQ_GOV_STOP);
-}
+static void cpufreq_stop_governor(struct cpufreq_policy *policy);
+static void cpufreq_governor_limits(struct cpufreq_policy *policy);
 
 /**
  * Two notifier lists: the "policy" list is involved in the
@@ -354,6 +347,7 @@ static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
                pr_debug("FREQ: %lu - CPU: %lu\n",
                         (unsigned long)freqs->new, (unsigned long)freqs->cpu);
                trace_cpu_frequency(freqs->new, freqs->cpu);
+               cpufreq_stats_record_transition(policy, freqs->new);
                srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
                                CPUFREQ_POSTCHANGE, freqs);
                if (likely(policy) && likely(policy->cpu == freqs->cpu))
@@ -1115,6 +1109,7 @@ static void cpufreq_policy_put_kobj(struct cpufreq_policy *policy, bool notify)
                                             CPUFREQ_REMOVE_POLICY, policy);
 
        down_write(&policy->rwsem);
+       cpufreq_stats_free_table(policy);
        cpufreq_remove_dev_symlink(policy);
        kobj = &policy->kobj;
        cmp = &policy->kobj_unregister;
@@ -1265,13 +1260,12 @@ static int cpufreq_online(unsigned int cpu)
                }
        }
 
-       blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
-                                    CPUFREQ_START, policy);
-
        if (new_policy) {
                ret = cpufreq_add_dev_interface(policy);
                if (ret)
                        goto out_exit_policy;
+
+               cpufreq_stats_create_table(policy);
                blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
                                CPUFREQ_CREATE_POLICY, policy);
 
@@ -1280,6 +1274,9 @@ static int cpufreq_online(unsigned int cpu)
                write_unlock_irqrestore(&cpufreq_driver_lock, flags);
        }
 
+       blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
+                                    CPUFREQ_START, policy);
+
        ret = cpufreq_init_policy(policy);
        if (ret) {
                pr_err("%s: Failed to initialize policy for cpu: %d (%d)\n",
@@ -1930,10 +1927,7 @@ int __cpufreq_driver_target(struct cpufreq_policy *policy,
                return -ENODEV;
 
        /* Make sure that target_freq is within supported range */
-       if (target_freq > policy->max)
-               target_freq = policy->max;
-       if (target_freq < policy->min)
-               target_freq = policy->min;
+       target_freq = clamp_val(target_freq, policy->min, policy->max);
 
        pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
                 policy->cpu, target_freq, relation, old_target_freq);
@@ -1997,7 +1991,7 @@ __weak struct cpufreq_governor *cpufreq_fallback_governor(void)
        return NULL;
 }
 
-static int cpufreq_governor(struct cpufreq_policy *policy, unsigned int event)
+static int cpufreq_init_governor(struct cpufreq_policy *policy)
 {
        int ret;
 
@@ -2025,36 +2019,82 @@ static int cpufreq_governor(struct cpufreq_policy *policy, unsigned int event)
                }
        }
 
-       if (event == CPUFREQ_GOV_POLICY_INIT)
-               if (!try_module_get(policy->governor->owner))
-                       return -EINVAL;
-
-       pr_debug("%s: for CPU %u, event %u\n", __func__, policy->cpu, event);
+       if (!try_module_get(policy->governor->owner))
+               return -EINVAL;
 
-       ret = policy->governor->governor(policy, event);
+       pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
 
-       if (event == CPUFREQ_GOV_POLICY_INIT) {
-               if (ret)
+       if (policy->governor->init) {
+               ret = policy->governor->init(policy);
+               if (ret) {
                        module_put(policy->governor->owner);
-               else
-                       policy->governor->initialized++;
-       } else if (event == CPUFREQ_GOV_POLICY_EXIT) {
-               policy->governor->initialized--;
-               module_put(policy->governor->owner);
+                       return ret;
+               }
        }
 
-       return ret;
+       return 0;
+}
+
+static void cpufreq_exit_governor(struct cpufreq_policy *policy)
+{
+       if (cpufreq_suspended || !policy->governor)
+               return;
+
+       pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
+
+       if (policy->governor->exit)
+               policy->governor->exit(policy);
+
+       module_put(policy->governor->owner);
 }
 
 static int cpufreq_start_governor(struct cpufreq_policy *policy)
 {
        int ret;
 
+       if (cpufreq_suspended)
+               return 0;
+
+       if (!policy->governor)
+               return -EINVAL;
+
+       pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
+
        if (cpufreq_driver->get && !cpufreq_driver->setpolicy)
                cpufreq_update_current_freq(policy);
 
-       ret = cpufreq_governor(policy, CPUFREQ_GOV_START);
-       return ret ? ret : cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
+       if (policy->governor->start) {
+               ret = policy->governor->start(policy);
+               if (ret)
+                       return ret;
+       }
+
+       if (policy->governor->limits)
+               policy->governor->limits(policy);
+
+       return 0;
+}
+
+static void cpufreq_stop_governor(struct cpufreq_policy *policy)
+{
+       if (cpufreq_suspended || !policy->governor)
+               return;
+
+       pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
+
+       if (policy->governor->stop)
+               policy->governor->stop(policy);
+}
+
+static void cpufreq_governor_limits(struct cpufreq_policy *policy)
+{
+       if (cpufreq_suspended || !policy->governor)
+               return;
+
+       pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
+
+       if (policy->governor->limits)
+               policy->governor->limits(policy);
 }
 
 int cpufreq_register_governor(struct cpufreq_governor *governor)
@@ -2069,7 +2109,6 @@ int cpufreq_register_governor(struct cpufreq_governor *governor)
 
        mutex_lock(&cpufreq_governor_mutex);
 
-       governor->initialized = 0;
        err = -EBUSY;
        if (!find_governor(governor->name)) {
                err = 0;
@@ -2195,7 +2234,8 @@ static int cpufreq_set_policy(struct cpufreq_policy *policy,
 
        if (new_policy->governor == policy->governor) {
                pr_debug("cpufreq: governor limits update\n");
-               return cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
+               cpufreq_governor_limits(policy);
+               return 0;
        }
 
        pr_debug("governor switch\n");
@@ -2210,7 +2250,7 @@ static int cpufreq_set_policy(struct cpufreq_policy *policy,
 
        /* start new governor */
        policy->governor = new_policy->governor;
-       ret = cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT);
+       ret = cpufreq_init_governor(policy);
        if (!ret) {
                ret = cpufreq_start_governor(policy);
                if (!ret) {
@@ -2224,7 +2264,7 @@ static int cpufreq_set_policy(struct cpufreq_policy *policy,
        pr_debug("starting governor %s failed\n", policy->governor->name);
        if (old_gov) {
                policy->governor = old_gov;
-               if (cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT))
+               if (cpufreq_init_governor(policy))
                        policy->governor = NULL;
                else
                        cpufreq_start_governor(policy);
@@ -2322,7 +2362,7 @@ static int cpufreq_boost_set_sw(int state)
 
                        down_write(&policy->rwsem);
                        policy->user_policy.max = policy->max;
-                       cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
+                       cpufreq_governor_limits(policy);
                        up_write(&policy->rwsem);
                }
        }