[CPUFREQ] use dynamic debug instead of custom infrastructure

With dynamic debug having gained the capability to report debug messages
also during the boot process, it offers a far superior interface for
debug messages than the custom cpufreq infrastructure. As a first step,
remove the old cpufreq_debug_printk() function and replace it with a call
to the generic pr_debug() function.

How can dynamic debug be used on cpufreq? You need a kernel which has
CONFIG_DYNAMIC_DEBUG enabled.

To enabled debugging during runtime, mount debugfs and

$ echo -n 'module cpufreq +p' > /sys/kernel/debug/dynamic_debug/control

for debugging the complete "cpufreq" module. To achieve the same goal during
boot, append

	ddebug_query="module cpufreq +p"

as a boot parameter to the kernel of your choice.

For more detailled instructions, please see
Documentation/dynamic-debug-howto.txt

Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Signed-off-by: Dave Jones <davej@redhat.com>

6 files changed, 52 insertions, 183 deletions

diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig
index ca8ee8093d6c..b78baa547ef5 100644
--- a/drivers/cpufreq/Kconfig
+++ b/drivers/cpufreq/Kconfig
@@ -18,19 +18,6 @@ if CPU_FREQ
 config CPU_FREQ_TABLE
         tristate
 
-config CPU_FREQ_DEBUG
-        bool "Enable CPUfreq debugging"
-        help
-          Say Y here to enable CPUfreq subsystem (including drivers)
-          debugging. You will need to activate it via the kernel
-          command line by passing
-             cpufreq.debug=<value>
-
-          To get <value>, add 
-               1 to activate CPUfreq core debugging,
-               2 to activate CPUfreq drivers debugging, and
-               4 to activate CPUfreq governor debugging
-
 config CPU_FREQ_STAT
         tristate "CPU frequency translation statistics"
         select CPU_FREQ_TABLE
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 7c10f96c5ae9..1e08af43ae72 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);
@@ -753,7 +663,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 +698,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 +734,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 +775,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 +851,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 +887,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 +895,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 +945,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 +971,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 +995,6 @@ err_free_policy:
 nomem_out:
         module_put(cpufreq_driver->owner);
 module_out:
-        cpufreq_debug_enable_ratelimit();
         return ret;
 }
 
@@ -1112,15 +1018,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 +1036,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 +1073,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,17 +1102,15 @@ 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);
 
-        cpufreq_debug_enable_ratelimit();
-
 #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
@@ -1255,7 +1156,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);
 }
 
@@ -1273,7 +1174,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;
@@ -1376,7 +1277,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);
@@ -1414,7 +1315,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);
@@ -1526,7 +1427,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);
@@ -1612,7 +1513,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);
 
@@ -1713,8 +1614,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,
@@ -1751,19 +1651,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)
@@ -1773,7 +1673,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;
@@ -1785,12 +1685,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;
 }
 
@@ -1817,7 +1716,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;
@@ -1829,7 +1728,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)
@@ -1905,7 +1804,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;
@@ -1936,15 +1835,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:
@@ -1971,14 +1869,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);
diff --git a/drivers/cpufreq/cpufreq_performance.c b/drivers/cpufreq/cpufreq_performance.c
index 7e2e515087f8..f13a8a9af6a1 100644
--- a/drivers/cpufreq/cpufreq_performance.c
+++ b/drivers/cpufreq/cpufreq_performance.c
@@ -15,9 +15,6 @@
 #include <linux/cpufreq.h>
 #include <linux/init.h>
 
-#define dprintk(msg...) \
-        cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "performance", msg)
-
 
 static int cpufreq_governor_performance(struct cpufreq_policy *policy,
                                         unsigned int event)
@@ -25,7 +22,7 @@ static int cpufreq_governor_performance(struct cpufreq_policy *policy,
         switch (event) {
         case CPUFREQ_GOV_START:
         case CPUFREQ_GOV_LIMITS:
-                dprintk("setting to %u kHz because of event %u\n",
+                pr_debug("setting to %u kHz because of event %u\n",
                                                 policy->max, event);
                 __cpufreq_driver_target(policy, policy->max,
                                                 CPUFREQ_RELATION_H);
diff --git a/drivers/cpufreq/cpufreq_powersave.c b/drivers/cpufreq/cpufreq_powersave.c
index e6db5faf3eb1..4c2eb512f2bc 100644
--- a/drivers/cpufreq/cpufreq_powersave.c
+++ b/drivers/cpufreq/cpufreq_powersave.c
@@ -15,16 +15,13 @@
 #include <linux/cpufreq.h>
 #include <linux/init.h>
 
-#define dprintk(msg...) \
-        cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "powersave", msg)
-
 static int cpufreq_governor_powersave(struct cpufreq_policy *policy,
                                         unsigned int event)
 {
         switch (event) {
         case CPUFREQ_GOV_START:
         case CPUFREQ_GOV_LIMITS:
-                dprintk("setting to %u kHz because of event %u\n",
+                pr_debug("setting to %u kHz because of event %u\n",
                                                         policy->min, event);
                 __cpufreq_driver_target(policy, policy->min,
                                                 CPUFREQ_RELATION_L);
diff --git a/drivers/cpufreq/cpufreq_userspace.c b/drivers/cpufreq/cpufreq_userspace.c
index 66d2d1d6c80f..f231015904c0 100644
--- a/drivers/cpufreq/cpufreq_userspace.c
+++ b/drivers/cpufreq/cpufreq_userspace.c
@@ -37,9 +37,6 @@ static DEFINE_PER_CPU(unsigned int, cpu_is_managed);
 static DEFINE_MUTEX(userspace_mutex);
 static int cpus_using_userspace_governor;
 
-#define dprintk(msg...) \
-        cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "userspace", msg)
-
 /* keep track of frequency transitions */
 static int
 userspace_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
@@ -50,7 +47,7 @@ userspace_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
         if (!per_cpu(cpu_is_managed, freq->cpu))
                 return 0;
 
-        dprintk("saving cpu_cur_freq of cpu %u to be %u kHz\n",
+        pr_debug("saving cpu_cur_freq of cpu %u to be %u kHz\n",
                         freq->cpu, freq->new);
         per_cpu(cpu_cur_freq, freq->cpu) = freq->new;
 
@@ -73,7 +70,7 @@ static int cpufreq_set(struct cpufreq_policy *policy, unsigned int freq)
 {
         int ret = -EINVAL;
 
-        dprintk("cpufreq_set for cpu %u, freq %u kHz\n", policy->cpu, freq);
+        pr_debug("cpufreq_set for cpu %u, freq %u kHz\n", policy->cpu, freq);
 
         mutex_lock(&userspace_mutex);
         if (!per_cpu(cpu_is_managed, policy->cpu))
@@ -134,7 +131,7 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy,
                 per_cpu(cpu_max_freq, cpu) = policy->max;
                 per_cpu(cpu_cur_freq, cpu) = policy->cur;
                 per_cpu(cpu_set_freq, cpu) = policy->cur;
-                dprintk("managing cpu %u started "
+                pr_debug("managing cpu %u started "
                         "(%u - %u kHz, currently %u kHz)\n",
                                 cpu,
                                 per_cpu(cpu_min_freq, cpu),
@@ -156,12 +153,12 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy,
                 per_cpu(cpu_min_freq, cpu) = 0;
                 per_cpu(cpu_max_freq, cpu) = 0;
                 per_cpu(cpu_set_freq, cpu) = 0;
-                dprintk("managing cpu %u stopped\n", cpu);
+                pr_debug("managing cpu %u stopped\n", cpu);
                 mutex_unlock(&userspace_mutex);
                 break;
         case CPUFREQ_GOV_LIMITS:
                 mutex_lock(&userspace_mutex);
-                dprintk("limit event for cpu %u: %u - %u kHz, "
+                pr_debug("limit event for cpu %u: %u - %u kHz, "
                         "currently %u kHz, last set to %u kHz\n",
                         cpu, policy->min, policy->max,
                         per_cpu(cpu_cur_freq, cpu),
diff --git a/drivers/cpufreq/freq_table.c b/drivers/cpufreq/freq_table.c
index 05432216e224..90431cb92804 100644
--- a/drivers/cpufreq/freq_table.c
+++ b/drivers/cpufreq/freq_table.c
@@ -14,9 +14,6 @@
 #include <linux/init.h>
 #include <linux/cpufreq.h>
 
-#define dprintk(msg...) \
-        cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, "freq-table", msg)
-
 /*********************************************************************
  *                     FREQUENCY TABLE HELPERS                       *
  *********************************************************************/
@@ -31,11 +28,11 @@ int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
         for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
                 unsigned int freq = table[i].frequency;
                 if (freq == CPUFREQ_ENTRY_INVALID) {
-                        dprintk("table entry %u is invalid, skipping\n", i);
+                        pr_debug("table entry %u is invalid, skipping\n", i);
 
                         continue;
                 }
-                dprintk("table entry %u: %u kHz, %u index\n",
+                pr_debug("table entry %u: %u kHz, %u index\n",
                                         i, freq, table[i].index);
                 if (freq < min_freq)
                         min_freq = freq;
@@ -61,7 +58,7 @@ int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
         unsigned int i;
         unsigned int count = 0;
 
-        dprintk("request for verification of policy (%u - %u kHz) for cpu %u\n",
+        pr_debug("request for verification of policy (%u - %u kHz) for cpu %u\n",
                                         policy->min, policy->max, policy->cpu);
 
         if (!cpu_online(policy->cpu))
@@ -86,7 +83,7 @@ int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
         cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
                                      policy->cpuinfo.max_freq);
 
-        dprintk("verification lead to (%u - %u kHz) for cpu %u\n",
+        pr_debug("verification lead to (%u - %u kHz) for cpu %u\n",
                                 policy->min, policy->max, policy->cpu);
 
         return 0;
@@ -110,7 +107,7 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
         };
         unsigned int i;
 
-        dprintk("request for target %u kHz (relation: %u) for cpu %u\n",
+        pr_debug("request for target %u kHz (relation: %u) for cpu %u\n",
                                         target_freq, relation, policy->cpu);
 
         switch (relation) {
@@ -167,7 +164,7 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
         } else
                 *index = optimal.index;
 
-        dprintk("target is %u (%u kHz, %u)\n", *index, table[*index].frequency,
+        pr_debug("target is %u (%u kHz, %u)\n", *index, table[*index].frequency,
                 table[*index].index);
 
         return 0;
@@ -216,14 +213,14 @@ EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs);
 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
                                       unsigned int cpu)
 {
-        dprintk("setting show_table for cpu %u to %p\n", cpu, table);
+        pr_debug("setting show_table for cpu %u to %p\n", cpu, table);
         per_cpu(cpufreq_show_table, cpu) = table;
 }
 EXPORT_SYMBOL_GPL(cpufreq_frequency_table_get_attr);
 
 void cpufreq_frequency_table_put_attr(unsigned int cpu)
 {
-        dprintk("clearing show_table for cpu %u\n", cpu);
+        pr_debug("clearing show_table for cpu %u\n", cpu);
         per_cpu(cpufreq_show_table, cpu) = NULL;
 }
 EXPORT_SYMBOL_GPL(cpufreq_frequency_table_put_attr);