Merge back earlier cpufreq changes for v4.8.

diff --combined drivers/cpufreq/cpufreq.c
index 9009295f5134247374cacf2a55717e07ff61a057,07c933c6c29a163410b568d2558fd88bde73c4ff..9ae58a18ccb951a04346d1c2897784e1189ca5b5
--- 1/drivers/cpufreq/cpufreq.c
--- 2/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@@ -74,19 -74,12 +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
@@@ -133,15 -126,6 +126,6 @@@ struct kobject *get_governor_parent_kob
  }
  EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
  
- struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu)
- {
-       struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
- 
-       return policy && !policy_is_inactive(policy) ?
-               policy->freq_table : NULL;
- }
- EXPORT_SYMBOL_GPL(cpufreq_frequency_get_table);
- 
  static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
  {
        u64 idle_time;
@@@ -354,6 -338,7 +338,7 @@@ static void __cpufreq_notify_transition
                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 -1100,7 +1100,7 @@@ static void cpufreq_policy_put_kobj(str
                                             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 -1251,12 +1251,12 @@@ static int cpufreq_online(unsigned int 
                }
        }
  
-       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 -1265,9 +1265,9 @@@
                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",
@@@ -1832,7 -1820,7 +1820,7 @@@ EXPORT_SYMBOL(cpufreq_unregister_notifi
  unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
                                        unsigned int target_freq)
  {
 -      clamp_val(target_freq, policy->min, policy->max);
 +      target_freq = clamp_val(target_freq, policy->min, policy->max);
  
        return cpufreq_driver->fast_switch(policy, target_freq);
  }
@@@ -1864,14 -1852,17 +1852,17 @@@ static int __target_intermediate(struc
        return ret;
  }
  
- static int __target_index(struct cpufreq_policy *policy,
-                         struct cpufreq_frequency_table *freq_table, int index)
+ static int __target_index(struct cpufreq_policy *policy, int index)
  {
        struct cpufreq_freqs freqs = {.old = policy->cur, .flags = 0};
        unsigned int intermediate_freq = 0;
+       unsigned int newfreq = policy->freq_table[index].frequency;
        int retval = -EINVAL;
        bool notify;
  
+       if (newfreq == policy->cur)
+               return 0;
+ 
        notify = !(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION);
        if (notify) {
                /* Handle switching to intermediate frequency */
@@@ -1886,7 -1877,7 +1877,7 @@@
                                freqs.old = freqs.new;
                }
  
-               freqs.new = freq_table[index].frequency;
+               freqs.new = newfreq;
                pr_debug("%s: cpu: %d, oldfreq: %u, new freq: %u\n",
                         __func__, policy->cpu, freqs.old, freqs.new);
  
@@@ -1923,17 -1914,13 +1914,13 @@@ int __cpufreq_driver_target(struct cpuf
                            unsigned int relation)
  {
        unsigned int old_target_freq = target_freq;
-       struct cpufreq_frequency_table *freq_table;
-       int index, retval;
+       int index;
  
        if (cpufreq_disabled())
                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);
@@@ -1956,23 -1943,9 +1943,9 @@@
        if (!cpufreq_driver->target_index)
                return -EINVAL;
  
-       freq_table = cpufreq_frequency_get_table(policy->cpu);
-       if (unlikely(!freq_table)) {
-               pr_err("%s: Unable to find freq_table\n", __func__);
-               return -EINVAL;
-       }
- 
-       retval = cpufreq_frequency_table_target(policy, freq_table, target_freq,
-                                               relation, &index);
-       if (unlikely(retval)) {
-               pr_err("%s: Unable to find matching freq\n", __func__);
-               return retval;
-       }
- 
-       if (freq_table[index].frequency == policy->cur)
-               return 0;
+       index = cpufreq_frequency_table_target(policy, target_freq, relation);
  
-       return __target_index(policy, freq_table, index);
+       return __target_index(policy, index);
  }
  EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
  
@@@ -1997,7 -1970,7 +1970,7 @@@ __weak struct cpufreq_governor *cpufreq
        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 -1998,82 +1998,82 @@@
                }
        }
  
-       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 -2088,6 +2088,6 @@@
  
        mutex_lock(&cpufreq_governor_mutex);
  
-       governor->initialized = 0;
        err = -EBUSY;
        if (!find_governor(governor->name)) {
                err = 0;
@@@ -2195,7 -2213,8 +2213,8 @@@ static int cpufreq_set_policy(struct cp
  
        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 -2229,7 +2229,7 @@@
  
        /* 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 -2243,7 +2243,7 @@@
        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);
@@@ -2305,26 -2324,25 +2324,25 @@@ static struct notifier_block __refdata 
   *********************************************************************/
  static int cpufreq_boost_set_sw(int state)
  {
-       struct cpufreq_frequency_table *freq_table;
        struct cpufreq_policy *policy;
        int ret = -EINVAL;
  
        for_each_active_policy(policy) {
-               freq_table = cpufreq_frequency_get_table(policy->cpu);
-               if (freq_table) {
-                       ret = cpufreq_frequency_table_cpuinfo(policy,
-                                                       freq_table);
-                       if (ret) {
-                               pr_err("%s: Policy frequency update failed\n",
-                                      __func__);
-                               break;
-                       }
- 
-                       down_write(&policy->rwsem);
-                       policy->user_policy.max = policy->max;
-                       cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
-                       up_write(&policy->rwsem);
+               if (!policy->freq_table)
+                       continue;
+ 
+               ret = cpufreq_frequency_table_cpuinfo(policy,
+                                                     policy->freq_table);
+               if (ret) {
+                       pr_err("%s: Policy frequency update failed\n",
+                              __func__);
+                       break;
                }
+ 
+               down_write(&policy->rwsem);
+               policy->user_policy.max = policy->max;
+               cpufreq_governor_limits(policy);
+               up_write(&policy->rwsem);
        }
  
        return ret;

diff --combined drivers/thermal/cpu_cooling.c
index 5b4b47ed948ba2735870e78e50fe860c14e7d4a7,4d678cfc81b19a4b59a04822cbedab0a7dd921fc..3788ed74c9abe59eaed8e8ce4621cac7ecaffe35
--- 1/drivers/thermal/cpu_cooling.c
--- 2/drivers/thermal/cpu_cooling.c
+++ b/drivers/thermal/cpu_cooling.c
@@@ -787,22 -787,34 +787,34 @@@ __cpufreq_cooling_register(struct devic
                        const struct cpumask *clip_cpus, u32 capacitance,
                        get_static_t plat_static_func)
  {
+       struct cpufreq_policy *policy;
        struct thermal_cooling_device *cool_dev;
        struct cpufreq_cooling_device *cpufreq_dev;
        char dev_name[THERMAL_NAME_LENGTH];
        struct cpufreq_frequency_table *pos, *table;
+       struct cpumask temp_mask;
        unsigned int freq, i, num_cpus;
        int ret;
  
-       table = cpufreq_frequency_get_table(cpumask_first(clip_cpus));
+       cpumask_and(&temp_mask, clip_cpus, cpu_online_mask);
+       policy = cpufreq_cpu_get(cpumask_first(&temp_mask));
+       if (!policy) {
+               pr_debug("%s: CPUFreq policy not found\n", __func__);
+               return ERR_PTR(-EPROBE_DEFER);
+       }
+ 
+       table = policy->freq_table;
        if (!table) {
                pr_debug("%s: CPUFreq table not found\n", __func__);
-               return ERR_PTR(-EPROBE_DEFER);
+               cool_dev = ERR_PTR(-ENODEV);
+               goto put_policy;
        }
  
        cpufreq_dev = kzalloc(sizeof(*cpufreq_dev), GFP_KERNEL);
-       if (!cpufreq_dev)
-               return ERR_PTR(-ENOMEM);
+       if (!cpufreq_dev) {
+               cool_dev = ERR_PTR(-ENOMEM);
+               goto put_policy;
+       }
  
        num_cpus = cpumask_weight(clip_cpus);
        cpufreq_dev->time_in_idle = kcalloc(num_cpus,
@@@ -857,6 -869,14 +869,6 @@@
                goto free_power_table;
        }
  
 -      snprintf(dev_name, sizeof(dev_name), "thermal-cpufreq-%d",
 -               cpufreq_dev->id);
 -
 -      cool_dev = thermal_of_cooling_device_register(np, dev_name, cpufreq_dev,
 -                                                    &cpufreq_cooling_ops);
 -      if (IS_ERR(cool_dev))
 -              goto remove_idr;
 -
        /* Fill freq-table in descending order of frequencies */
        for (i = 0, freq = -1; i <= cpufreq_dev->max_level; i++) {
                freq = find_next_max(table, freq);
@@@ -869,14 -889,6 +881,14 @@@
                        pr_debug("%s: freq:%u KHz\n", __func__, freq);
        }
  
 +      snprintf(dev_name, sizeof(dev_name), "thermal-cpufreq-%d",
 +               cpufreq_dev->id);
 +
 +      cool_dev = thermal_of_cooling_device_register(np, dev_name, cpufreq_dev,
 +                                                    &cpufreq_cooling_ops);
 +      if (IS_ERR(cool_dev))
 +              goto remove_idr;
 +
        cpufreq_dev->clipped_freq = cpufreq_dev->freq_table[0];
        cpufreq_dev->cool_dev = cool_dev;
  
@@@ -892,7 -904,7 +904,7 @@@
                                          CPUFREQ_POLICY_NOTIFIER);
        mutex_unlock(&cooling_cpufreq_lock);
  
-       return cool_dev;
+       goto put_policy;
  
  remove_idr:
        release_idr(&cpufreq_idr, cpufreq_dev->id);
@@@ -906,6 -918,8 +918,8 @@@ free_time_in_idle
        kfree(cpufreq_dev->time_in_idle);
  free_cdev:
        kfree(cpufreq_dev);
+ put_policy:
+       cpufreq_cpu_put(policy);
  
        return cool_dev;
  }