1 files changed, 59 insertions, 156 deletions

diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 2dafc5c38ae7..0a5bea9e3585 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -32,9 +32,6 @@
 
 #include <trace/events/power.h>
 
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
-                                                "cpufreq-core", msg)
-
 /**
  * The "cpufreq driver" - the arch- or hardware-dependent low
  * level driver of CPUFreq support, and its spinlock. This lock
@@ -181,93 +178,6 @@ EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
 
 
 /*********************************************************************
- *                     UNIFIED DEBUG HELPERS                         *
- *********************************************************************/
-#ifdef CONFIG_CPU_FREQ_DEBUG
-
-/* what part(s) of the CPUfreq subsystem are debugged? */
-static unsigned int debug;
-
-/* is the debug output ratelimit'ed using printk_ratelimit? User can
- * set or modify this value.
- */
-static unsigned int debug_ratelimit = 1;
-
-/* is the printk_ratelimit'ing enabled? It's enabled after a successful
- * loading of a cpufreq driver, temporarily disabled when a new policy
- * is set, and disabled upon cpufreq driver removal
- */
-static unsigned int disable_ratelimit = 1;
-static DEFINE_SPINLOCK(disable_ratelimit_lock);
-
-static void cpufreq_debug_enable_ratelimit(void)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&disable_ratelimit_lock, flags);
-        if (disable_ratelimit)
-                disable_ratelimit--;
-        spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
-}
-
-static void cpufreq_debug_disable_ratelimit(void)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&disable_ratelimit_lock, flags);
-        disable_ratelimit++;
-        spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
-}
-
-void cpufreq_debug_printk(unsigned int type, const char *prefix,
-                        const char *fmt, ...)
-{
-        char s[256];
-        va_list args;
-        unsigned int len;
-        unsigned long flags;
-
-        WARN_ON(!prefix);
-        if (type & debug) {
-                spin_lock_irqsave(&disable_ratelimit_lock, flags);
-                if (!disable_ratelimit && debug_ratelimit
-                                        && !printk_ratelimit()) {
-                        spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
-                        return;
-                }
-                spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
-
-                len = snprintf(s, 256, KERN_DEBUG "%s: ", prefix);
-
-                va_start(args, fmt);
-                len += vsnprintf(&s[len], (256 - len), fmt, args);
-                va_end(args);
-
-                printk(s);
-
-                WARN_ON(len < 5);
-        }
-}
-EXPORT_SYMBOL(cpufreq_debug_printk);
-
-
-module_param(debug, uint, 0644);
-MODULE_PARM_DESC(debug, "CPUfreq debugging: add 1 to debug core,"
-                        " 2 to debug drivers, and 4 to debug governors.");
-
-module_param(debug_ratelimit, uint, 0644);
-MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging:"
-                                        " set to 0 to disable ratelimiting.");
-
-#else /* !CONFIG_CPU_FREQ_DEBUG */
-
-static inline void cpufreq_debug_enable_ratelimit(void) { return; }
-static inline void cpufreq_debug_disable_ratelimit(void) { return; }
-
-#endif /* CONFIG_CPU_FREQ_DEBUG */
-
-
-/*********************************************************************
  *            EXTERNALLY AFFECTING FREQUENCY CHANGES                 *
  *********************************************************************/
 
@@ -291,7 +201,7 @@ static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
         if (!l_p_j_ref_freq) {
                 l_p_j_ref = loops_per_jiffy;
                 l_p_j_ref_freq = ci->old;
-                dprintk("saving %lu as reference value for loops_per_jiffy; "
+                pr_debug("saving %lu as reference value for loops_per_jiffy; "
                         "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
         }
         if ((val == CPUFREQ_PRECHANGE  && ci->old < ci->new) ||
@@ -299,7 +209,7 @@ static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
             (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
                 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
                                                                 ci->new);
-                dprintk("scaling loops_per_jiffy to %lu "
+                pr_debug("scaling loops_per_jiffy to %lu "
                         "for frequency %u kHz\n", loops_per_jiffy, ci->new);
         }
 }
@@ -326,7 +236,7 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
         BUG_ON(irqs_disabled());
 
         freqs->flags = cpufreq_driver->flags;
-        dprintk("notification %u of frequency transition to %u kHz\n",
+        pr_debug("notification %u of frequency transition to %u kHz\n",
                 state, freqs->new);
 
         policy = per_cpu(cpufreq_cpu_data, freqs->cpu);
@@ -340,7 +250,7 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
                 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
                         if ((policy) && (policy->cpu == freqs->cpu) &&
                             (policy->cur) && (policy->cur != freqs->old)) {
-                                dprintk("Warning: CPU frequency is"
+                                pr_debug("Warning: CPU frequency is"
                                         " %u, cpufreq assumed %u kHz.\n",
                                         freqs->old, policy->cur);
                                 freqs->old = policy->cur;
@@ -353,7 +263,7 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
 
         case CPUFREQ_POSTCHANGE:
                 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
-                dprintk("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
+                pr_debug("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
                         (unsigned long)freqs->cpu);
                 trace_power_frequency(POWER_PSTATE, freqs->new, freqs->cpu);
                 trace_cpu_frequency(freqs->new, freqs->cpu);
@@ -411,21 +321,14 @@ static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
                 t = __find_governor(str_governor);
 
                 if (t == NULL) {
-                        char *name = kasprintf(GFP_KERNEL, "cpufreq_%s",
-                                                                str_governor);
-
-                        if (name) {
-                                int ret;
+                        int ret;
 
-                                mutex_unlock(&cpufreq_governor_mutex);
-                                ret = request_module("%s", name);
-                                mutex_lock(&cpufreq_governor_mutex);
+                        mutex_unlock(&cpufreq_governor_mutex);
+                        ret = request_module("cpufreq_%s", str_governor);
+                        mutex_lock(&cpufreq_governor_mutex);
 
-                                if (ret == 0)
-                                        t = __find_governor(str_governor);
-                        }
-
-                        kfree(name);
+                        if (ret == 0)
+                                t = __find_governor(str_governor);
                 }
 
                 if (t != NULL) {
@@ -753,7 +656,7 @@ no_policy:
 static void cpufreq_sysfs_release(struct kobject *kobj)
 {
         struct cpufreq_policy *policy = to_policy(kobj);
-        dprintk("last reference is dropped\n");
+        pr_debug("last reference is dropped\n");
         complete(&policy->kobj_unregister);
 }
 
@@ -788,7 +691,7 @@ static int cpufreq_add_dev_policy(unsigned int cpu,
         gov = __find_governor(per_cpu(cpufreq_cpu_governor, cpu));
         if (gov) {
                 policy->governor = gov;
-                dprintk("Restoring governor %s for cpu %d\n",
+                pr_debug("Restoring governor %s for cpu %d\n",
                        policy->governor->name, cpu);
         }
 #endif
@@ -824,7 +727,7 @@ static int cpufreq_add_dev_policy(unsigned int cpu,
                         per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
                         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
-                        dprintk("CPU already managed, adding link\n");
+                        pr_debug("CPU already managed, adding link\n");
                         ret = sysfs_create_link(&sys_dev->kobj,
                                                 &managed_policy->kobj,
                                                 "cpufreq");
@@ -865,7 +768,7 @@ static int cpufreq_add_dev_symlink(unsigned int cpu,
                 if (!cpu_online(j))
                         continue;
 
-                dprintk("CPU %u already managed, adding link\n", j);
+                pr_debug("CPU %u already managed, adding link\n", j);
                 managed_policy = cpufreq_cpu_get(cpu);
                 cpu_sys_dev = get_cpu_sysdev(j);
                 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
@@ -941,7 +844,7 @@ static int cpufreq_add_dev_interface(unsigned int cpu,
         policy->user_policy.governor = policy->governor;
 
         if (ret) {
-                dprintk("setting policy failed\n");
+                pr_debug("setting policy failed\n");
                 if (cpufreq_driver->exit)
                         cpufreq_driver->exit(policy);
         }
@@ -977,8 +880,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
         if (cpu_is_offline(cpu))
                 return 0;
 
-        cpufreq_debug_disable_ratelimit();
-        dprintk("adding CPU %u\n", cpu);
+        pr_debug("adding CPU %u\n", cpu);
 
 #ifdef CONFIG_SMP
         /* check whether a different CPU already registered this
@@ -986,7 +888,6 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
         policy = cpufreq_cpu_get(cpu);
         if (unlikely(policy)) {
                 cpufreq_cpu_put(policy);
-                cpufreq_debug_enable_ratelimit();
                 return 0;
         }
 #endif
@@ -1037,7 +938,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
          */
         ret = cpufreq_driver->init(policy);
         if (ret) {
-                dprintk("initialization failed\n");
+                pr_debug("initialization failed\n");
                 goto err_unlock_policy;
         }
         policy->user_policy.min = policy->min;
@@ -1063,8 +964,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
 
         kobject_uevent(&policy->kobj, KOBJ_ADD);
         module_put(cpufreq_driver->owner);
-        dprintk("initialization complete\n");
-        cpufreq_debug_enable_ratelimit();
+        pr_debug("initialization complete\n");
 
         return 0;
 
@@ -1088,7 +988,6 @@ err_free_policy:
 nomem_out:
         module_put(cpufreq_driver->owner);
 module_out:
-        cpufreq_debug_enable_ratelimit();
         return ret;
 }
 
@@ -1112,15 +1011,13 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
         unsigned int j;
 #endif
 
-        cpufreq_debug_disable_ratelimit();
-        dprintk("unregistering CPU %u\n", cpu);
+        pr_debug("unregistering CPU %u\n", cpu);
 
         spin_lock_irqsave(&cpufreq_driver_lock, flags);
         data = per_cpu(cpufreq_cpu_data, cpu);
 
         if (!data) {
                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
-                cpufreq_debug_enable_ratelimit();
                 unlock_policy_rwsem_write(cpu);
                 return -EINVAL;
         }
@@ -1132,12 +1029,11 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
          * only need to unlink, put and exit
          */
         if (unlikely(cpu != data->cpu)) {
-                dprintk("removing link\n");
+                pr_debug("removing link\n");
                 cpumask_clear_cpu(cpu, data->cpus);
                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
                 kobj = &sys_dev->kobj;
                 cpufreq_cpu_put(data);
-                cpufreq_debug_enable_ratelimit();
                 unlock_policy_rwsem_write(cpu);
                 sysfs_remove_link(kobj, "cpufreq");
                 return 0;
@@ -1170,7 +1066,7 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
                 for_each_cpu(j, data->cpus) {
                         if (j == cpu)
                                 continue;
-                        dprintk("removing link for cpu %u\n", j);
+                        pr_debug("removing link for cpu %u\n", j);
 #ifdef CONFIG_HOTPLUG_CPU
                         strncpy(per_cpu(cpufreq_cpu_governor, j),
                                 data->governor->name, CPUFREQ_NAME_LEN);
@@ -1199,21 +1095,35 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
          * not referenced anymore by anybody before we proceed with
          * unloading.
          */
-        dprintk("waiting for dropping of refcount\n");
+        pr_debug("waiting for dropping of refcount\n");
         wait_for_completion(cmp);
-        dprintk("wait complete\n");
+        pr_debug("wait complete\n");
 
         lock_policy_rwsem_write(cpu);
         if (cpufreq_driver->exit)
                 cpufreq_driver->exit(data);
         unlock_policy_rwsem_write(cpu);
 
+#ifdef CONFIG_HOTPLUG_CPU
+        /* when the CPU which is the parent of the kobj is hotplugged
+         * offline, check for siblings, and create cpufreq sysfs interface
+         * and symlinks
+         */
+        if (unlikely(cpumask_weight(data->cpus) > 1)) {
+                /* first sibling now owns the new sysfs dir */
+                cpumask_clear_cpu(cpu, data->cpus);
+                cpufreq_add_dev(get_cpu_sysdev(cpumask_first(data->cpus)));
+
+                /* finally remove our own symlink */
+                lock_policy_rwsem_write(cpu);
+                __cpufreq_remove_dev(sys_dev);
+        }
+#endif
+
         free_cpumask_var(data->related_cpus);
         free_cpumask_var(data->cpus);
         kfree(data);
-        per_cpu(cpufreq_cpu_data, cpu) = NULL;
 
-        cpufreq_debug_enable_ratelimit();
         return 0;
 }
 
@@ -1239,7 +1149,7 @@ static void handle_update(struct work_struct *work)
         struct cpufreq_policy *policy =
                 container_of(work, struct cpufreq_policy, update);
         unsigned int cpu = policy->cpu;
-        dprintk("handle_update for cpu %u called\n", cpu);
+        pr_debug("handle_update for cpu %u called\n", cpu);
         cpufreq_update_policy(cpu);
 }
 
@@ -1257,7 +1167,7 @@ static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
 {
         struct cpufreq_freqs freqs;
 
-        dprintk("Warning: CPU frequency out of sync: cpufreq and timing "
+        pr_debug("Warning: CPU frequency out of sync: cpufreq and timing "
                "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
 
         freqs.cpu = cpu;
@@ -1360,7 +1270,7 @@ static int cpufreq_bp_suspend(void)
         int cpu = smp_processor_id();
         struct cpufreq_policy *cpu_policy;
 
-        dprintk("suspending cpu %u\n", cpu);
+        pr_debug("suspending cpu %u\n", cpu);
 
         /* If there's no policy for the boot CPU, we have nothing to do. */
         cpu_policy = cpufreq_cpu_get(cpu);
@@ -1398,7 +1308,7 @@ static void cpufreq_bp_resume(void)
         int cpu = smp_processor_id();
         struct cpufreq_policy *cpu_policy;
 
-        dprintk("resuming cpu %u\n", cpu);
+        pr_debug("resuming cpu %u\n", cpu);
 
         /* If there's no policy for the boot CPU, we have nothing to do. */
         cpu_policy = cpufreq_cpu_get(cpu);
@@ -1510,7 +1420,7 @@ int __cpufreq_driver_target(struct cpufreq_policy *policy,
 {
         int retval = -EINVAL;
 
-        dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
+        pr_debug("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
                 target_freq, relation);
         if (cpu_online(policy->cpu) && cpufreq_driver->target)
                 retval = cpufreq_driver->target(policy, target_freq, relation);
@@ -1596,7 +1506,7 @@ static int __cpufreq_governor(struct cpufreq_policy *policy,
         if (!try_module_get(policy->governor->owner))
                 return -EINVAL;
 
-        dprintk("__cpufreq_governor for CPU %u, event %u\n",
+        pr_debug("__cpufreq_governor for CPU %u, event %u\n",
                                                 policy->cpu, event);
         ret = policy->governor->governor(policy, event);
 
@@ -1697,8 +1607,7 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data,
 {
         int ret = 0;
 
-        cpufreq_debug_disable_ratelimit();
-        dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
+        pr_debug("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
                 policy->min, policy->max);
 
         memcpy(&policy->cpuinfo, &data->cpuinfo,
@@ -1735,19 +1644,19 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data,
         data->min = policy->min;
         data->max = policy->max;
 
-        dprintk("new min and max freqs are %u - %u kHz\n",
+        pr_debug("new min and max freqs are %u - %u kHz\n",
                                         data->min, data->max);
 
         if (cpufreq_driver->setpolicy) {
                 data->policy = policy->policy;
-                dprintk("setting range\n");
+                pr_debug("setting range\n");
                 ret = cpufreq_driver->setpolicy(policy);
         } else {
                 if (policy->governor != data->governor) {
                         /* save old, working values */
                         struct cpufreq_governor *old_gov = data->governor;
 
-                        dprintk("governor switch\n");
+                        pr_debug("governor switch\n");
 
                         /* end old governor */
                         if (data->governor)
@@ -1757,7 +1666,7 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data,
                         data->governor = policy->governor;
                         if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
                                 /* new governor failed, so re-start old one */
-                                dprintk("starting governor %s failed\n",
+                                pr_debug("starting governor %s failed\n",
                                                         data->governor->name);
                                 if (old_gov) {
                                         data->governor = old_gov;
@@ -1769,12 +1678,11 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data,
                         }
                         /* might be a policy change, too, so fall through */
                 }
-                dprintk("governor: change or update limits\n");
+                pr_debug("governor: change or update limits\n");
                 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
         }
 
 error_out:
-        cpufreq_debug_enable_ratelimit();
         return ret;
 }
 
@@ -1801,7 +1709,7 @@ int cpufreq_update_policy(unsigned int cpu)
                 goto fail;
         }
 
-        dprintk("updating policy for CPU %u\n", cpu);
+        pr_debug("updating policy for CPU %u\n", cpu);
         memcpy(&policy, data, sizeof(struct cpufreq_policy));
         policy.min = data->user_policy.min;
         policy.max = data->user_policy.max;
@@ -1813,7 +1721,7 @@ int cpufreq_update_policy(unsigned int cpu)
         if (cpufreq_driver->get) {
                 policy.cur = cpufreq_driver->get(cpu);
                 if (!data->cur) {
-                        dprintk("Driver did not initialize current freq");
+                        pr_debug("Driver did not initialize current freq");
                         data->cur = policy.cur;
                 } else {
                         if (data->cur != policy.cur)
@@ -1889,7 +1797,7 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data)
             ((!driver_data->setpolicy) && (!driver_data->target)))
                 return -EINVAL;
 
-        dprintk("trying to register driver %s\n", driver_data->name);
+        pr_debug("trying to register driver %s\n", driver_data->name);
 
         if (driver_data->setpolicy)
                 driver_data->flags |= CPUFREQ_CONST_LOOPS;
@@ -1920,15 +1828,14 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data)
 
                 /* if all ->init() calls failed, unregister */
                 if (ret) {
-                        dprintk("no CPU initialized for driver %s\n",
+                        pr_debug("no CPU initialized for driver %s\n",
                                                         driver_data->name);
                         goto err_sysdev_unreg;
                 }
         }
 
         register_hotcpu_notifier(&cpufreq_cpu_notifier);
-        dprintk("driver %s up and running\n", driver_data->name);
-        cpufreq_debug_enable_ratelimit();
+        pr_debug("driver %s up and running\n", driver_data->name);
 
         return 0;
 err_sysdev_unreg:
@@ -1955,14 +1862,10 @@ int cpufreq_unregister_driver(struct cpufreq_driver *driver)
 {
         unsigned long flags;
 
-        cpufreq_debug_disable_ratelimit();
-
-        if (!cpufreq_driver || (driver != cpufreq_driver)) {
-                cpufreq_debug_enable_ratelimit();
+        if (!cpufreq_driver || (driver != cpufreq_driver))
                 return -EINVAL;
-        }
 
-        dprintk("unregistering driver %s\n", driver->name);
+        pr_debug("unregistering driver %s\n", driver->name);
 
         sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
         unregister_hotcpu_notifier(&cpufreq_cpu_notifier);