![Linus Torvalds](/assets/img/avatar_default.png)
- Device PM QoS support for latency tolerance constraints on systems with hardware interfaces allowing such constraints to be specified. That is necessary to prevent hardware-driven power management from becoming overly aggressive on some systems and to prevent power management features leading to excessive latencies from being used in some cases. - Consolidation of the handling of ACPI hotplug notifications for device objects. This causes all device hotplug notifications to go through the root notify handler (that was executed for all of them anyway before) that propagates them to individual subsystems, if necessary, by executing callbacks provided by those subsystems (those callbacks are associated with struct acpi_device objects during device enumeration). As a result, the code in question becomes both smaller in size and more straightforward and all of those changes should not affect users. - ACPICA update, including fixes related to the handling of _PRT in cases when it is broken and the addition of "Windows 2013" to the list of supported "features" for _OSI (which is necessary to support systems that work incorrectly or don't even boot without it). Changes from Bob Moore and Lv Zheng. - Consolidation of ACPI _OST handling from Jiang Liu. - ACPI battery and AC fixes allowing unusual system configurations to be handled by that code from Alexander Mezin. - New device IDs for the ACPI LPSS driver from Chiau Ee Chew. - ACPI fan and thermal optimizations related to system suspend and resume from Aaron Lu. - Cleanups related to ACPI video from Jean Delvare. - Assorted ACPI fixes and cleanups from Al Stone, Hanjun Guo, Lan Tianyu, Paul Bolle, Tomasz Nowicki. - Intel RAPL (Running Average Power Limits) driver cleanups from Jacob Pan. - intel_pstate fixes and cleanups from Dirk Brandewie. - cpufreq fixes related to system suspend/resume handling from Viresh Kumar. - cpufreq core fixes and cleanups from Viresh Kumar, Stratos Karafotis, Saravana Kannan, Rashika Kheria, Joe Perches. - cpufreq drivers updates from Viresh Kumar, Zhuoyu Zhang, Rob Herring. - cpuidle fixes related to the menu governor from Tuukka Tikkanen. - cpuidle fix related to coupled CPUs handling from Paul Burton. - Asynchronous execution of all device suspend and resume callbacks, except for ->prepare and ->complete, during system suspend and resume from Chuansheng Liu. - Delayed resuming of runtime-suspended devices during system suspend for the PCI bus type and ACPI PM domain. - New set of PM helper routines to allow device runtime PM callbacks to be used during system suspend and resume more easily from Ulf Hansson. - Assorted fixes and cleanups in the PM core from Geert Uytterhoeven, Prabhakar Lad, Philipp Zabel, Rashika Kheria, Sebastian Capella. - devfreq fix from Saravana Kannan. / -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.22 (GNU/Linux) iQIcBAABCAAGBQJTLgB1AAoJEILEb/54YlRxfs4P/35fIu9h8ClNWUPXqi3nlGIt yMyumKvF1VdsOKLbjTtFq6B3UOlhqDijYTCQd7Xt7X8ONTk/ND9ec2t/5xGkSdUI q46fa0qZXeqUn0Kt2t+kl6tgVQOkDj94aNlEh+7Ya3Uu6WYDDfmZtOBOFAMk6D8l ND4rHJpX+eUsRLBrcxaUxxdD8AW5guGcPKyeyzsXv1bY1BZnpLFrZ3PhuI5dn2CL L/zmk3A+wG6+ZlQxnwDdrKa3E6uhRSIDeF0vI4Byspa1wi5zXknJG2J7MoQ9JEE9 VQpBXlqach5wgXqJ8PAqAeaB6Ie26/F7PYG8r446zKw/5UUtdNUx+0dkjQ7Mz8Tu ajuVxfwrrPhZeQqmVBxlH5Gg7Ez2KBKEfDxTdRnzI7FoA7PE5XDcg3kO64bhj8LJ yugnV/ToU9wMztZnPC7CoGPwUgxMJvr9LwmxS4aeKcVUBES05eg0vS3lwdZMgqkV iO0QkWTmhZ952qZCqZxbh0JqaaX8Wgx2kpX2tf1G2GJqLMZco289bLh6njNT+8CH EzdQKYYyn6G6+Qg2M0f/6So3qU17x9XtE4ZBWQdGDpqYOGZhjZAOs/VnB1Ysw/K3 cDBzswlJd0CyyUps9B+qbf49OpbWVwl5kKeuHUuPxugEVryhpSp9AuG+tNil74Sj JuGTGR4fyFjDBX5cvAPm =ywR6 -----END PGP SIGNATURE----- Merge tag 'pm+acpi-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm Pull ACPI and power management updates from Rafael Wysocki: "The majority of this material spent some time in linux-next, some of it even several weeks. There are a few relatively fresh commits in it, but they are mostly fixes and simple cleanups. ACPI took the lead this time, both in terms of the number of commits and the number of modified lines of code, cpufreq follows and there are a few changes in the PM core and in cpuidle too. A new feature that already got some LWN.net's attention is the device PM QoS extension allowing latency tolerance requirements to be propagated from leaf devices to their ancestors with hardware interfaces for specifying latency tolerance. That should help systems with hardware-driven power management to avoid going too far with it in cases when there are latency tolerance constraints. There also are some significant changes in the ACPI core related to the way in which hotplug notifications are handled. They affect PCI hotplug (ACPIPHP) and the ACPI dock station code too. The bottom line is that all those notification now go through the root notify handler and are propagated to the interested subsystems by means of callbacks instead of having to install a notify handler for each device object that we can potentially get hotplug notifications for. In addition to that ACPICA will now advertise "Windows 2013" compatibility for _OSI, because some systems out there don't work correctly if that is not done (some of them don't even boot). On the system suspend side of things, all of the device suspend and resume callbacks, except for ->prepare() and ->complete(), are now going to be executed asynchronously as that turns out to speed up system suspend and resume on some platforms quite significantly and we have a few more optimizations in that area. Apart from that, there are some new device IDs and fixes and cleanups all over. In particular, the system suspend and resume handling by cpufreq should be improved and the cpuidle menu governor should be a bit more robust now. Specifics: - Device PM QoS support for latency tolerance constraints on systems with hardware interfaces allowing such constraints to be specified. That is necessary to prevent hardware-driven power management from becoming overly aggressive on some systems and to prevent power management features leading to excessive latencies from being used in some cases. - Consolidation of the handling of ACPI hotplug notifications for device objects. This causes all device hotplug notifications to go through the root notify handler (that was executed for all of them anyway before) that propagates them to individual subsystems, if necessary, by executing callbacks provided by those subsystems (those callbacks are associated with struct acpi_device objects during device enumeration). As a result, the code in question becomes both smaller in size and more straightforward and all of those changes should not affect users. - ACPICA update, including fixes related to the handling of _PRT in cases when it is broken and the addition of "Windows 2013" to the list of supported "features" for _OSI (which is necessary to support systems that work incorrectly or don't even boot without it). Changes from Bob Moore and Lv Zheng. - Consolidation of ACPI _OST handling from Jiang Liu. - ACPI battery and AC fixes allowing unusual system configurations to be handled by that code from Alexander Mezin. - New device IDs for the ACPI LPSS driver from Chiau Ee Chew. - ACPI fan and thermal optimizations related to system suspend and resume from Aaron Lu. - Cleanups related to ACPI video from Jean Delvare. - Assorted ACPI fixes and cleanups from Al Stone, Hanjun Guo, Lan Tianyu, Paul Bolle, Tomasz Nowicki. - Intel RAPL (Running Average Power Limits) driver cleanups from Jacob Pan. - intel_pstate fixes and cleanups from Dirk Brandewie. - cpufreq fixes related to system suspend/resume handling from Viresh Kumar. - cpufreq core fixes and cleanups from Viresh Kumar, Stratos Karafotis, Saravana Kannan, Rashika Kheria, Joe Perches. - cpufreq drivers updates from Viresh Kumar, Zhuoyu Zhang, Rob Herring. - cpuidle fixes related to the menu governor from Tuukka Tikkanen. - cpuidle fix related to coupled CPUs handling from Paul Burton. - Asynchronous execution of all device suspend and resume callbacks, except for ->prepare and ->complete, during system suspend and resume from Chuansheng Liu. - Delayed resuming of runtime-suspended devices during system suspend for the PCI bus type and ACPI PM domain. - New set of PM helper routines to allow device runtime PM callbacks to be used during system suspend and resume more easily from Ulf Hansson. - Assorted fixes and cleanups in the PM core from Geert Uytterhoeven, Prabhakar Lad, Philipp Zabel, Rashika Kheria, Sebastian Capella. - devfreq fix from Saravana Kannan" * tag 'pm+acpi-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (162 commits) PM / devfreq: Rewrite devfreq_update_status() to fix multiple bugs PM / sleep: Correct whitespace errors in <linux/pm.h> intel_pstate: Set core to min P state during core offline cpufreq: Add stop CPU callback to cpufreq_driver interface cpufreq: Remove unnecessary braces cpufreq: Fix checkpatch errors and warnings cpufreq: powerpc: add cpufreq transition latency for FSL e500mc SoCs MAINTAINERS: Reorder maintainer addresses for PM and ACPI PM / Runtime: Update runtime_idle() documentation for return value meaning video / output: Drop display output class support fujitsu-laptop: Drop unneeded include acer-wmi: Stop selecting VIDEO_OUTPUT_CONTROL ACPI / gpu / drm: Stop selecting VIDEO_OUTPUT_CONTROL ACPI / video: fix ACPI_VIDEO dependencies cpufreq: remove unused notifier: CPUFREQ_{SUSPENDCHANGE|RESUMECHANGE} cpufreq: Do not allow ->setpolicy drivers to provide ->target cpufreq: arm_big_little: set 'physical_cluster' for each CPU cpufreq: arm_big_little: make vexpress driver depend on bL core driver ACPI / button: Add ACPI Button event via netlink routine ACPI: Remove duplicate definitions of PREFIX ...
391 lines
9.4 KiB
C
391 lines
9.4 KiB
C
/*
|
|
* drivers/cpufreq/cpufreq_stats.c
|
|
*
|
|
* Copyright (C) 2003-2004 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
|
|
* (C) 2004 Zou Nan hai <nanhai.zou@intel.com>.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#include <linux/cpu.h>
|
|
#include <linux/cpufreq.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/cputime.h>
|
|
|
|
static spinlock_t cpufreq_stats_lock;
|
|
|
|
struct cpufreq_stats {
|
|
unsigned int cpu;
|
|
unsigned int total_trans;
|
|
unsigned long long last_time;
|
|
unsigned int max_state;
|
|
unsigned int state_num;
|
|
unsigned int last_index;
|
|
u64 *time_in_state;
|
|
unsigned int *freq_table;
|
|
#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
|
|
unsigned int *trans_table;
|
|
#endif
|
|
};
|
|
|
|
static DEFINE_PER_CPU(struct cpufreq_stats *, cpufreq_stats_table);
|
|
|
|
struct cpufreq_stats_attribute {
|
|
struct attribute attr;
|
|
ssize_t(*show) (struct cpufreq_stats *, char *);
|
|
};
|
|
|
|
static int cpufreq_stats_update(unsigned int cpu)
|
|
{
|
|
struct cpufreq_stats *stat;
|
|
unsigned long long cur_time;
|
|
|
|
cur_time = get_jiffies_64();
|
|
spin_lock(&cpufreq_stats_lock);
|
|
stat = per_cpu(cpufreq_stats_table, cpu);
|
|
if (stat->time_in_state)
|
|
stat->time_in_state[stat->last_index] +=
|
|
cur_time - stat->last_time;
|
|
stat->last_time = cur_time;
|
|
spin_unlock(&cpufreq_stats_lock);
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t show_total_trans(struct cpufreq_policy *policy, char *buf)
|
|
{
|
|
struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
|
|
if (!stat)
|
|
return 0;
|
|
return sprintf(buf, "%d\n",
|
|
per_cpu(cpufreq_stats_table, stat->cpu)->total_trans);
|
|
}
|
|
|
|
static ssize_t show_time_in_state(struct cpufreq_policy *policy, char *buf)
|
|
{
|
|
ssize_t len = 0;
|
|
int i;
|
|
struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
|
|
if (!stat)
|
|
return 0;
|
|
cpufreq_stats_update(stat->cpu);
|
|
for (i = 0; i < stat->state_num; i++) {
|
|
len += sprintf(buf + len, "%u %llu\n", stat->freq_table[i],
|
|
(unsigned long long)
|
|
jiffies_64_to_clock_t(stat->time_in_state[i]));
|
|
}
|
|
return len;
|
|
}
|
|
|
|
#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
|
|
static ssize_t show_trans_table(struct cpufreq_policy *policy, char *buf)
|
|
{
|
|
ssize_t len = 0;
|
|
int i, j;
|
|
|
|
struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
|
|
if (!stat)
|
|
return 0;
|
|
cpufreq_stats_update(stat->cpu);
|
|
len += snprintf(buf + len, PAGE_SIZE - len, " From : To\n");
|
|
len += snprintf(buf + len, PAGE_SIZE - len, " : ");
|
|
for (i = 0; i < stat->state_num; i++) {
|
|
if (len >= PAGE_SIZE)
|
|
break;
|
|
len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
|
|
stat->freq_table[i]);
|
|
}
|
|
if (len >= PAGE_SIZE)
|
|
return PAGE_SIZE;
|
|
|
|
len += snprintf(buf + len, PAGE_SIZE - len, "\n");
|
|
|
|
for (i = 0; i < stat->state_num; i++) {
|
|
if (len >= PAGE_SIZE)
|
|
break;
|
|
|
|
len += snprintf(buf + len, PAGE_SIZE - len, "%9u: ",
|
|
stat->freq_table[i]);
|
|
|
|
for (j = 0; j < stat->state_num; j++) {
|
|
if (len >= PAGE_SIZE)
|
|
break;
|
|
len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
|
|
stat->trans_table[i*stat->max_state+j]);
|
|
}
|
|
if (len >= PAGE_SIZE)
|
|
break;
|
|
len += snprintf(buf + len, PAGE_SIZE - len, "\n");
|
|
}
|
|
if (len >= PAGE_SIZE)
|
|
return PAGE_SIZE;
|
|
return len;
|
|
}
|
|
cpufreq_freq_attr_ro(trans_table);
|
|
#endif
|
|
|
|
cpufreq_freq_attr_ro(total_trans);
|
|
cpufreq_freq_attr_ro(time_in_state);
|
|
|
|
static struct attribute *default_attrs[] = {
|
|
&total_trans.attr,
|
|
&time_in_state.attr,
|
|
#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
|
|
&trans_table.attr,
|
|
#endif
|
|
NULL
|
|
};
|
|
static struct attribute_group stats_attr_group = {
|
|
.attrs = default_attrs,
|
|
.name = "stats"
|
|
};
|
|
|
|
static int freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq)
|
|
{
|
|
int index;
|
|
for (index = 0; index < stat->max_state; index++)
|
|
if (stat->freq_table[index] == freq)
|
|
return index;
|
|
return -1;
|
|
}
|
|
|
|
static void __cpufreq_stats_free_table(struct cpufreq_policy *policy)
|
|
{
|
|
struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
|
|
|
|
if (!stat)
|
|
return;
|
|
|
|
pr_debug("%s: Free stat table\n", __func__);
|
|
|
|
sysfs_remove_group(&policy->kobj, &stats_attr_group);
|
|
kfree(stat->time_in_state);
|
|
kfree(stat);
|
|
per_cpu(cpufreq_stats_table, policy->cpu) = NULL;
|
|
}
|
|
|
|
static void cpufreq_stats_free_table(unsigned int cpu)
|
|
{
|
|
struct cpufreq_policy *policy;
|
|
|
|
policy = cpufreq_cpu_get(cpu);
|
|
if (!policy)
|
|
return;
|
|
|
|
if (cpufreq_frequency_get_table(policy->cpu))
|
|
__cpufreq_stats_free_table(policy);
|
|
|
|
cpufreq_cpu_put(policy);
|
|
}
|
|
|
|
static int __cpufreq_stats_create_table(struct cpufreq_policy *policy)
|
|
{
|
|
unsigned int i, j, count = 0, ret = 0;
|
|
struct cpufreq_stats *stat;
|
|
unsigned int alloc_size;
|
|
unsigned int cpu = policy->cpu;
|
|
struct cpufreq_frequency_table *table;
|
|
|
|
table = cpufreq_frequency_get_table(cpu);
|
|
if (unlikely(!table))
|
|
return 0;
|
|
|
|
if (per_cpu(cpufreq_stats_table, cpu))
|
|
return -EBUSY;
|
|
stat = kzalloc(sizeof(*stat), GFP_KERNEL);
|
|
if ((stat) == NULL)
|
|
return -ENOMEM;
|
|
|
|
ret = sysfs_create_group(&policy->kobj, &stats_attr_group);
|
|
if (ret)
|
|
goto error_out;
|
|
|
|
stat->cpu = cpu;
|
|
per_cpu(cpufreq_stats_table, cpu) = stat;
|
|
|
|
for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
|
|
unsigned int freq = table[i].frequency;
|
|
if (freq == CPUFREQ_ENTRY_INVALID)
|
|
continue;
|
|
count++;
|
|
}
|
|
|
|
alloc_size = count * sizeof(int) + count * sizeof(u64);
|
|
|
|
#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
|
|
alloc_size += count * count * sizeof(int);
|
|
#endif
|
|
stat->max_state = count;
|
|
stat->time_in_state = kzalloc(alloc_size, GFP_KERNEL);
|
|
if (!stat->time_in_state) {
|
|
ret = -ENOMEM;
|
|
goto error_alloc;
|
|
}
|
|
stat->freq_table = (unsigned int *)(stat->time_in_state + count);
|
|
|
|
#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
|
|
stat->trans_table = stat->freq_table + count;
|
|
#endif
|
|
j = 0;
|
|
for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
|
|
unsigned int freq = table[i].frequency;
|
|
if (freq == CPUFREQ_ENTRY_INVALID)
|
|
continue;
|
|
if (freq_table_get_index(stat, freq) == -1)
|
|
stat->freq_table[j++] = freq;
|
|
}
|
|
stat->state_num = j;
|
|
spin_lock(&cpufreq_stats_lock);
|
|
stat->last_time = get_jiffies_64();
|
|
stat->last_index = freq_table_get_index(stat, policy->cur);
|
|
spin_unlock(&cpufreq_stats_lock);
|
|
return 0;
|
|
error_alloc:
|
|
sysfs_remove_group(&policy->kobj, &stats_attr_group);
|
|
error_out:
|
|
kfree(stat);
|
|
per_cpu(cpufreq_stats_table, cpu) = NULL;
|
|
return ret;
|
|
}
|
|
|
|
static void cpufreq_stats_create_table(unsigned int cpu)
|
|
{
|
|
struct cpufreq_policy *policy;
|
|
|
|
/*
|
|
* "likely(!policy)" because normally cpufreq_stats will be registered
|
|
* before cpufreq driver
|
|
*/
|
|
policy = cpufreq_cpu_get(cpu);
|
|
if (likely(!policy))
|
|
return;
|
|
|
|
__cpufreq_stats_create_table(policy);
|
|
|
|
cpufreq_cpu_put(policy);
|
|
}
|
|
|
|
static void cpufreq_stats_update_policy_cpu(struct cpufreq_policy *policy)
|
|
{
|
|
struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table,
|
|
policy->last_cpu);
|
|
|
|
pr_debug("Updating stats_table for new_cpu %u from last_cpu %u\n",
|
|
policy->cpu, policy->last_cpu);
|
|
per_cpu(cpufreq_stats_table, policy->cpu) = per_cpu(cpufreq_stats_table,
|
|
policy->last_cpu);
|
|
per_cpu(cpufreq_stats_table, policy->last_cpu) = NULL;
|
|
stat->cpu = policy->cpu;
|
|
}
|
|
|
|
static int cpufreq_stat_notifier_policy(struct notifier_block *nb,
|
|
unsigned long val, void *data)
|
|
{
|
|
int ret = 0;
|
|
struct cpufreq_policy *policy = data;
|
|
|
|
if (val == CPUFREQ_UPDATE_POLICY_CPU) {
|
|
cpufreq_stats_update_policy_cpu(policy);
|
|
return 0;
|
|
}
|
|
|
|
if (val == CPUFREQ_CREATE_POLICY)
|
|
ret = __cpufreq_stats_create_table(policy);
|
|
else if (val == CPUFREQ_REMOVE_POLICY)
|
|
__cpufreq_stats_free_table(policy);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int cpufreq_stat_notifier_trans(struct notifier_block *nb,
|
|
unsigned long val, void *data)
|
|
{
|
|
struct cpufreq_freqs *freq = data;
|
|
struct cpufreq_stats *stat;
|
|
int old_index, new_index;
|
|
|
|
if (val != CPUFREQ_POSTCHANGE)
|
|
return 0;
|
|
|
|
stat = per_cpu(cpufreq_stats_table, freq->cpu);
|
|
if (!stat)
|
|
return 0;
|
|
|
|
old_index = stat->last_index;
|
|
new_index = freq_table_get_index(stat, freq->new);
|
|
|
|
/* We can't do stat->time_in_state[-1]= .. */
|
|
if (old_index == -1 || new_index == -1)
|
|
return 0;
|
|
|
|
cpufreq_stats_update(freq->cpu);
|
|
|
|
if (old_index == new_index)
|
|
return 0;
|
|
|
|
spin_lock(&cpufreq_stats_lock);
|
|
stat->last_index = new_index;
|
|
#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
|
|
stat->trans_table[old_index * stat->max_state + new_index]++;
|
|
#endif
|
|
stat->total_trans++;
|
|
spin_unlock(&cpufreq_stats_lock);
|
|
return 0;
|
|
}
|
|
|
|
static struct notifier_block notifier_policy_block = {
|
|
.notifier_call = cpufreq_stat_notifier_policy
|
|
};
|
|
|
|
static struct notifier_block notifier_trans_block = {
|
|
.notifier_call = cpufreq_stat_notifier_trans
|
|
};
|
|
|
|
static int __init cpufreq_stats_init(void)
|
|
{
|
|
int ret;
|
|
unsigned int cpu;
|
|
|
|
spin_lock_init(&cpufreq_stats_lock);
|
|
ret = cpufreq_register_notifier(¬ifier_policy_block,
|
|
CPUFREQ_POLICY_NOTIFIER);
|
|
if (ret)
|
|
return ret;
|
|
|
|
for_each_online_cpu(cpu)
|
|
cpufreq_stats_create_table(cpu);
|
|
|
|
ret = cpufreq_register_notifier(¬ifier_trans_block,
|
|
CPUFREQ_TRANSITION_NOTIFIER);
|
|
if (ret) {
|
|
cpufreq_unregister_notifier(¬ifier_policy_block,
|
|
CPUFREQ_POLICY_NOTIFIER);
|
|
for_each_online_cpu(cpu)
|
|
cpufreq_stats_free_table(cpu);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
static void __exit cpufreq_stats_exit(void)
|
|
{
|
|
unsigned int cpu;
|
|
|
|
cpufreq_unregister_notifier(¬ifier_policy_block,
|
|
CPUFREQ_POLICY_NOTIFIER);
|
|
cpufreq_unregister_notifier(¬ifier_trans_block,
|
|
CPUFREQ_TRANSITION_NOTIFIER);
|
|
for_each_online_cpu(cpu)
|
|
cpufreq_stats_free_table(cpu);
|
|
}
|
|
|
|
MODULE_AUTHOR("Zou Nan hai <nanhai.zou@intel.com>");
|
|
MODULE_DESCRIPTION("'cpufreq_stats' - A driver to export cpufreq stats "
|
|
"through sysfs filesystem");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
module_init(cpufreq_stats_init);
|
|
module_exit(cpufreq_stats_exit);
|