blob: 4cf0d2805cb2a10baecfb7ba3e900e3a28d1a7bd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/cpufreq/cpufreq_stats.c
3 *
4 * Copyright (C) 2003-2004 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
Dave Jones0a829c52009-01-18 01:49:04 -05005 * (C) 2004 Zou Nan hai <nanhai.zou@intel.com>.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/cpu.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/cpufreq.h>
Paul Gortmaker5c720d372011-05-27 13:23:32 -040014#include <linux/module.h>
Viresh Kumar5ff0a262013-08-06 22:53:03 +053015#include <linux/slab.h>
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070016#include <asm/cputime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
18static spinlock_t cpufreq_stats_lock;
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020struct cpufreq_stats {
21 unsigned int cpu;
22 unsigned int total_trans;
Viresh Kumarbb176f72013-06-19 14:19:33 +053023 unsigned long long last_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 unsigned int max_state;
25 unsigned int state_num;
26 unsigned int last_index;
Viresh Kumar1e7586a2012-10-26 00:51:21 +020027 u64 *time_in_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 unsigned int *freq_table;
29#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
30 unsigned int *trans_table;
31#endif
32};
33
Mike Travis7a6aedf2008-03-25 15:06:53 -070034static DEFINE_PER_CPU(struct cpufreq_stats *, cpufreq_stats_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36struct cpufreq_stats_attribute {
37 struct attribute attr;
38 ssize_t(*show) (struct cpufreq_stats *, char *);
39};
40
Dave Jones0a829c52009-01-18 01:49:04 -050041static int cpufreq_stats_update(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070042{
43 struct cpufreq_stats *stat;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070044 unsigned long long cur_time;
45
46 cur_time = get_jiffies_64();
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 spin_lock(&cpufreq_stats_lock);
Mike Travis7a6aedf2008-03-25 15:06:53 -070048 stat = per_cpu(cpufreq_stats_table, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 if (stat->time_in_state)
Martin Schwidefsky64861632011-12-15 14:56:09 +010050 stat->time_in_state[stat->last_index] +=
51 cur_time - stat->last_time;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070052 stat->last_time = cur_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 spin_unlock(&cpufreq_stats_lock);
54 return 0;
55}
56
Dave Jones0a829c52009-01-18 01:49:04 -050057static ssize_t show_total_trans(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
Mike Travis7a6aedf2008-03-25 15:06:53 -070059 struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
Dave Jones511e9ee2006-05-30 17:57:14 -040060 if (!stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 return 0;
62 return sprintf(buf, "%d\n",
Mike Travis7a6aedf2008-03-25 15:06:53 -070063 per_cpu(cpufreq_stats_table, stat->cpu)->total_trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064}
65
Dave Jones0a829c52009-01-18 01:49:04 -050066static ssize_t show_time_in_state(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
68 ssize_t len = 0;
69 int i;
Mike Travis7a6aedf2008-03-25 15:06:53 -070070 struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
Dave Jones511e9ee2006-05-30 17:57:14 -040071 if (!stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 return 0;
73 cpufreq_stats_update(stat->cpu);
74 for (i = 0; i < stat->state_num; i++) {
Dave Jones32ee8c32006-02-28 00:43:23 -050075 len += sprintf(buf + len, "%u %llu\n", stat->freq_table[i],
Dave Jones0a829c52009-01-18 01:49:04 -050076 (unsigned long long)
Andreas Schwaba857c0b2013-09-07 18:35:08 +020077 jiffies_64_to_clock_t(stat->time_in_state[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 }
79 return len;
80}
81
82#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
Dave Jones0a829c52009-01-18 01:49:04 -050083static ssize_t show_trans_table(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
85 ssize_t len = 0;
86 int i, j;
87
Mike Travis7a6aedf2008-03-25 15:06:53 -070088 struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
Dave Jones511e9ee2006-05-30 17:57:14 -040089 if (!stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 return 0;
91 cpufreq_stats_update(stat->cpu);
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070092 len += snprintf(buf + len, PAGE_SIZE - len, " From : To\n");
93 len += snprintf(buf + len, PAGE_SIZE - len, " : ");
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 for (i = 0; i < stat->state_num; i++) {
95 if (len >= PAGE_SIZE)
96 break;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070097 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
98 stat->freq_table[i]);
99 }
100 if (len >= PAGE_SIZE)
Cesar Eduardo Barros25aca342008-02-16 08:41:25 -0200101 return PAGE_SIZE;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -0700102
103 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
104
105 for (i = 0; i < stat->state_num; i++) {
106 if (len >= PAGE_SIZE)
107 break;
108
109 len += snprintf(buf + len, PAGE_SIZE - len, "%9u: ",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 stat->freq_table[i]);
111
Viresh Kumarbb176f72013-06-19 14:19:33 +0530112 for (j = 0; j < stat->state_num; j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 if (len >= PAGE_SIZE)
114 break;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -0700115 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 stat->trans_table[i*stat->max_state+j]);
117 }
Cesar Eduardo Barros25aca342008-02-16 08:41:25 -0200118 if (len >= PAGE_SIZE)
119 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
121 }
Cesar Eduardo Barros25aca342008-02-16 08:41:25 -0200122 if (len >= PAGE_SIZE)
123 return PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 return len;
125}
Viresh Kumardf18e502013-02-04 11:38:52 +0000126cpufreq_freq_attr_ro(trans_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127#endif
128
Viresh Kumardf18e502013-02-04 11:38:52 +0000129cpufreq_freq_attr_ro(total_trans);
130cpufreq_freq_attr_ro(time_in_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132static struct attribute *default_attrs[] = {
Viresh Kumardf18e502013-02-04 11:38:52 +0000133 &total_trans.attr,
134 &time_in_state.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
Viresh Kumardf18e502013-02-04 11:38:52 +0000136 &trans_table.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137#endif
138 NULL
139};
140static struct attribute_group stats_attr_group = {
141 .attrs = default_attrs,
142 .name = "stats"
143};
144
Dave Jones0a829c52009-01-18 01:49:04 -0500145static int freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
147 int index;
148 for (index = 0; index < stat->max_state; index++)
149 if (stat->freq_table[index] == freq)
150 return index;
151 return -1;
152}
153
steven finney98586ed2011-05-02 11:29:17 -0700154/* should be called late in the CPU removal sequence so that the stats
155 * memory is still available in case someone tries to use it.
156 */
Adrian Bunka3323472007-12-17 16:20:03 -0800157static void cpufreq_stats_free_table(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158{
Mike Travis7a6aedf2008-03-25 15:06:53 -0700159 struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, cpu);
Viresh Kumarb8eed8a2013-01-14 13:23:03 +0000160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 if (stat) {
Viresh Kumarb8eed8a2013-01-14 13:23:03 +0000162 pr_debug("%s: Free stat table\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 kfree(stat->time_in_state);
164 kfree(stat);
Viresh Kumarb8eed8a2013-01-14 13:23:03 +0000165 per_cpu(cpufreq_stats_table, cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 }
steven finney98586ed2011-05-02 11:29:17 -0700167}
168
169/* must be called early in the CPU removal sequence (before
170 * cpufreq_remove_dev) so that policy is still valid.
171 */
172static void cpufreq_stats_free_sysfs(unsigned int cpu)
173{
174 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
Dirk Brandewie633d47d2013-02-06 09:02:12 -0800175
viresh kumar187da1d2013-03-22 10:13:52 +0000176 if (!policy)
Dirk Brandewie633d47d2013-02-06 09:02:12 -0800177 return;
178
viresh kumar187da1d2013-03-22 10:13:52 +0000179 if (!cpufreq_frequency_get_table(cpu))
180 goto put_ref;
181
182 if (!policy_is_shared(policy)) {
Viresh Kumarb8eed8a2013-01-14 13:23:03 +0000183 pr_debug("%s: Free sysfs stat\n", __func__);
steven finney98586ed2011-05-02 11:29:17 -0700184 sysfs_remove_group(&policy->kobj, &stats_attr_group);
Viresh Kumarb8eed8a2013-01-14 13:23:03 +0000185 }
viresh kumar187da1d2013-03-22 10:13:52 +0000186
187put_ref:
188 cpufreq_cpu_put(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189}
190
Dave Jones0a829c52009-01-18 01:49:04 -0500191static int cpufreq_stats_create_table(struct cpufreq_policy *policy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 struct cpufreq_frequency_table *table)
193{
194 unsigned int i, j, count = 0, ret = 0;
195 struct cpufreq_stats *stat;
Viresh Kumar3a3e9e02013-08-06 22:53:05 +0530196 struct cpufreq_policy *current_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 unsigned int alloc_size;
198 unsigned int cpu = policy->cpu;
Mike Travis7a6aedf2008-03-25 15:06:53 -0700199 if (per_cpu(cpufreq_stats_table, cpu))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 return -EBUSY;
Viresh Kumard5b73cd2013-08-06 22:53:06 +0530201 stat = kzalloc(sizeof(*stat), GFP_KERNEL);
Dave Jones0a829c52009-01-18 01:49:04 -0500202 if ((stat) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Viresh Kumar3a3e9e02013-08-06 22:53:05 +0530205 current_policy = cpufreq_cpu_get(cpu);
206 if (current_policy == NULL) {
Dave Jonesbc7b26f2005-10-27 16:02:06 -0700207 ret = -EINVAL;
208 goto error_get_fail;
209 }
210
Viresh Kumar3a3e9e02013-08-06 22:53:05 +0530211 ret = sysfs_create_group(&current_policy->kobj, &stats_attr_group);
Dave Jones0a829c52009-01-18 01:49:04 -0500212 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 goto error_out;
214
215 stat->cpu = cpu;
Mike Travis7a6aedf2008-03-25 15:06:53 -0700216 per_cpu(cpufreq_stats_table, cpu) = stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Dave Jones0a829c52009-01-18 01:49:04 -0500218 for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 unsigned int freq = table[i].frequency;
220 if (freq == CPUFREQ_ENTRY_INVALID)
221 continue;
222 count++;
223 }
224
Viresh Kumar1e7586a2012-10-26 00:51:21 +0200225 alloc_size = count * sizeof(int) + count * sizeof(u64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
227#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
228 alloc_size += count * count * sizeof(int);
229#endif
230 stat->max_state = count;
Dave Jonese98df502005-10-20 15:17:43 -0700231 stat->time_in_state = kzalloc(alloc_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 if (!stat->time_in_state) {
233 ret = -ENOMEM;
234 goto error_out;
235 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 stat->freq_table = (unsigned int *)(stat->time_in_state + count);
237
238#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
239 stat->trans_table = stat->freq_table + count;
240#endif
241 j = 0;
242 for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
243 unsigned int freq = table[i].frequency;
244 if (freq == CPUFREQ_ENTRY_INVALID)
245 continue;
246 if (freq_table_get_index(stat, freq) == -1)
247 stat->freq_table[j++] = freq;
248 }
249 stat->state_num = j;
250 spin_lock(&cpufreq_stats_lock);
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -0700251 stat->last_time = get_jiffies_64();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 stat->last_index = freq_table_get_index(stat, policy->cur);
253 spin_unlock(&cpufreq_stats_lock);
Viresh Kumar3a3e9e02013-08-06 22:53:05 +0530254 cpufreq_cpu_put(current_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 return 0;
256error_out:
Viresh Kumar3a3e9e02013-08-06 22:53:05 +0530257 cpufreq_cpu_put(current_policy);
Dave Jonesb7fb3582005-11-01 23:13:45 -0800258error_get_fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 kfree(stat);
Mike Travis7a6aedf2008-03-25 15:06:53 -0700260 per_cpu(cpufreq_stats_table, cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 return ret;
262}
263
Viresh Kumarb8eed8a2013-01-14 13:23:03 +0000264static void cpufreq_stats_update_policy_cpu(struct cpufreq_policy *policy)
265{
266 struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table,
267 policy->last_cpu);
268
269 pr_debug("Updating stats_table for new_cpu %u from last_cpu %u\n",
270 policy->cpu, policy->last_cpu);
271 per_cpu(cpufreq_stats_table, policy->cpu) = per_cpu(cpufreq_stats_table,
272 policy->last_cpu);
273 per_cpu(cpufreq_stats_table, policy->last_cpu) = NULL;
274 stat->cpu = policy->cpu;
275}
276
Dave Jones0a829c52009-01-18 01:49:04 -0500277static int cpufreq_stat_notifier_policy(struct notifier_block *nb,
278 unsigned long val, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
280 int ret;
281 struct cpufreq_policy *policy = data;
282 struct cpufreq_frequency_table *table;
283 unsigned int cpu = policy->cpu;
Viresh Kumarb8eed8a2013-01-14 13:23:03 +0000284
285 if (val == CPUFREQ_UPDATE_POLICY_CPU) {
286 cpufreq_stats_update_policy_cpu(policy);
287 return 0;
288 }
289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 if (val != CPUFREQ_NOTIFY)
291 return 0;
292 table = cpufreq_frequency_get_table(cpu);
293 if (!table)
294 return 0;
Dave Jones0a829c52009-01-18 01:49:04 -0500295 ret = cpufreq_stats_create_table(policy, table);
296 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 return ret;
298 return 0;
299}
300
Dave Jones0a829c52009-01-18 01:49:04 -0500301static int cpufreq_stat_notifier_trans(struct notifier_block *nb,
302 unsigned long val, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303{
304 struct cpufreq_freqs *freq = data;
305 struct cpufreq_stats *stat;
306 int old_index, new_index;
307
308 if (val != CPUFREQ_POSTCHANGE)
309 return 0;
310
Mike Travis7a6aedf2008-03-25 15:06:53 -0700311 stat = per_cpu(cpufreq_stats_table, freq->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 if (!stat)
313 return 0;
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800314
Shaohua Li6501faf2008-04-27 13:46:56 -0700315 old_index = stat->last_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 new_index = freq_table_get_index(stat, freq->new);
317
Konrad Rzeszutek Wilk46a310b2011-06-16 15:36:38 -0400318 /* We can't do stat->time_in_state[-1]= .. */
319 if (old_index == -1 || new_index == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 return 0;
321
Konrad Rzeszutek Wilk46a310b2011-06-16 15:36:38 -0400322 cpufreq_stats_update(freq->cpu);
323
324 if (old_index == new_index)
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800325 return 0;
326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 spin_lock(&cpufreq_stats_lock);
328 stat->last_index = new_index;
329#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
330 stat->trans_table[old_index * stat->max_state + new_index]++;
331#endif
332 stat->total_trans++;
333 spin_unlock(&cpufreq_stats_lock);
334 return 0;
335}
336
Paul Gortmaker27609842013-06-19 13:54:04 -0400337static int cpufreq_stat_cpu_callback(struct notifier_block *nfb,
Satyam Sharma55395ae2007-10-02 13:28:15 -0700338 unsigned long action,
339 void *hcpu)
Ashok Rajc32b6b82005-10-30 14:59:54 -0800340{
341 unsigned int cpu = (unsigned long)hcpu;
342
343 switch (action) {
steven finney98586ed2011-05-02 11:29:17 -0700344 case CPU_DOWN_PREPARE:
345 cpufreq_stats_free_sysfs(cpu);
346 break;
Ashok Rajc32b6b82005-10-30 14:59:54 -0800347 case CPU_DEAD:
348 cpufreq_stats_free_table(cpu);
349 break;
350 }
351 return NOTIFY_OK;
352}
353
steven finney98586ed2011-05-02 11:29:17 -0700354/* priority=1 so this will get called before cpufreq_remove_dev */
Karthigan Srinivasan469057d2011-04-01 17:34:47 -0500355static struct notifier_block cpufreq_stat_cpu_notifier __refdata = {
Ashok Rajc32b6b82005-10-30 14:59:54 -0800356 .notifier_call = cpufreq_stat_cpu_callback,
steven finney98586ed2011-05-02 11:29:17 -0700357 .priority = 1,
Ashok Rajc32b6b82005-10-30 14:59:54 -0800358};
359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360static struct notifier_block notifier_policy_block = {
361 .notifier_call = cpufreq_stat_notifier_policy
362};
363
364static struct notifier_block notifier_trans_block = {
365 .notifier_call = cpufreq_stat_notifier_trans
366};
367
Dave Jones0a829c52009-01-18 01:49:04 -0500368static int __init cpufreq_stats_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
370 int ret;
371 unsigned int cpu;
Ashok Rajc32b6b82005-10-30 14:59:54 -0800372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 spin_lock_init(&cpufreq_stats_lock);
Dave Jones0a829c52009-01-18 01:49:04 -0500374 ret = cpufreq_register_notifier(&notifier_policy_block,
375 CPUFREQ_POLICY_NOTIFIER);
376 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return ret;
378
Konstantin Khlebnikov56836fb2012-12-15 00:22:02 +0100379 register_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
Konstantin Khlebnikov56836fb2012-12-15 00:22:02 +0100380
Dave Jones0a829c52009-01-18 01:49:04 -0500381 ret = cpufreq_register_notifier(&notifier_trans_block,
382 CPUFREQ_TRANSITION_NOTIFIER);
383 if (ret) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 cpufreq_unregister_notifier(&notifier_policy_block,
385 CPUFREQ_POLICY_NOTIFIER);
Konstantin Khlebnikov56836fb2012-12-15 00:22:02 +0100386 unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
387 for_each_online_cpu(cpu)
388 cpufreq_stats_free_table(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 return ret;
390 }
391
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 return 0;
393}
Dave Jones0a829c52009-01-18 01:49:04 -0500394static void __exit cpufreq_stats_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
396 unsigned int cpu;
Ashok Rajc32b6b82005-10-30 14:59:54 -0800397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 cpufreq_unregister_notifier(&notifier_policy_block,
399 CPUFREQ_POLICY_NOTIFIER);
400 cpufreq_unregister_notifier(&notifier_trans_block,
401 CPUFREQ_TRANSITION_NOTIFIER);
Chandra Seetharaman65edc682006-06-27 02:54:08 -0700402 unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
Ashok Rajc32b6b82005-10-30 14:59:54 -0800403 for_each_online_cpu(cpu) {
Satyam Sharma55395ae2007-10-02 13:28:15 -0700404 cpufreq_stats_free_table(cpu);
Dave Jones13f06752011-06-12 16:35:28 -0400405 cpufreq_stats_free_sysfs(cpu);
Ashok Rajc32b6b82005-10-30 14:59:54 -0800406 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407}
408
Dave Jones0a829c52009-01-18 01:49:04 -0500409MODULE_AUTHOR("Zou Nan hai <nanhai.zou@intel.com>");
410MODULE_DESCRIPTION("'cpufreq_stats' - A driver to export cpufreq stats "
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530411 "through sysfs filesystem");
Dave Jones0a829c52009-01-18 01:49:04 -0500412MODULE_LICENSE("GPL");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414module_init(cpufreq_stats_init);
415module_exit(cpufreq_stats_exit);