blob: 741b6b191e6a2ca667b5ab6f36888279cb9823ce [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>.
5 * (C) 2004 Zou Nan hai <nanhai.zou@intel.com>.
6 *
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
12#include <linux/config.h>
13#include <linux/kernel.h>
14#include <linux/sysdev.h>
15#include <linux/cpu.h>
16#include <linux/sysfs.h>
17#include <linux/cpufreq.h>
18#include <linux/jiffies.h>
19#include <linux/percpu.h>
20#include <linux/kobject.h>
21#include <linux/spinlock.h>
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070022#include <asm/cputime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24static spinlock_t cpufreq_stats_lock;
25
26#define CPUFREQ_STATDEVICE_ATTR(_name,_mode,_show) \
27static struct freq_attr _attr_##_name = {\
28 .attr = {.name = __stringify(_name), .owner = THIS_MODULE, \
29 .mode = _mode, }, \
30 .show = _show,\
31};
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033struct cpufreq_stats {
34 unsigned int cpu;
35 unsigned int total_trans;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070036 unsigned long long last_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 unsigned int max_state;
38 unsigned int state_num;
39 unsigned int last_index;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070040 cputime64_t *time_in_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 unsigned int *freq_table;
42#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
43 unsigned int *trans_table;
44#endif
45};
46
47static struct cpufreq_stats *cpufreq_stats_table[NR_CPUS];
48
49struct cpufreq_stats_attribute {
50 struct attribute attr;
51 ssize_t(*show) (struct cpufreq_stats *, char *);
52};
53
54static int
55cpufreq_stats_update (unsigned int cpu)
56{
57 struct cpufreq_stats *stat;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070058 unsigned long long cur_time;
59
60 cur_time = get_jiffies_64();
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 spin_lock(&cpufreq_stats_lock);
62 stat = cpufreq_stats_table[cpu];
63 if (stat->time_in_state)
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070064 stat->time_in_state[stat->last_index] =
65 cputime64_add(stat->time_in_state[stat->last_index],
66 cputime_sub(cur_time, stat->last_time));
67 stat->last_time = cur_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 spin_unlock(&cpufreq_stats_lock);
69 return 0;
70}
71
72static ssize_t
73show_total_trans(struct cpufreq_policy *policy, char *buf)
74{
75 struct cpufreq_stats *stat = cpufreq_stats_table[policy->cpu];
76 if(!stat)
77 return 0;
78 return sprintf(buf, "%d\n",
79 cpufreq_stats_table[stat->cpu]->total_trans);
80}
81
82static ssize_t
83show_time_in_state(struct cpufreq_policy *policy, char *buf)
84{
85 ssize_t len = 0;
86 int i;
87 struct cpufreq_stats *stat = cpufreq_stats_table[policy->cpu];
88 if(!stat)
89 return 0;
90 cpufreq_stats_update(stat->cpu);
91 for (i = 0; i < stat->state_num; i++) {
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -070092 len += sprintf(buf + len, "%u %llu\n", stat->freq_table[i],
93 (unsigned long long)cputime64_to_clock_t(stat->time_in_state[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 }
95 return len;
96}
97
98#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
99static ssize_t
100show_trans_table(struct cpufreq_policy *policy, char *buf)
101{
102 ssize_t len = 0;
103 int i, j;
104
105 struct cpufreq_stats *stat = cpufreq_stats_table[policy->cpu];
106 if(!stat)
107 return 0;
108 cpufreq_stats_update(stat->cpu);
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -0700109 len += snprintf(buf + len, PAGE_SIZE - len, " From : To\n");
110 len += snprintf(buf + len, PAGE_SIZE - len, " : ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 for (i = 0; i < stat->state_num; i++) {
112 if (len >= PAGE_SIZE)
113 break;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -0700114 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
115 stat->freq_table[i]);
116 }
117 if (len >= PAGE_SIZE)
118 return len;
119
120 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
121
122 for (i = 0; i < stat->state_num; i++) {
123 if (len >= PAGE_SIZE)
124 break;
125
126 len += snprintf(buf + len, PAGE_SIZE - len, "%9u: ",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 stat->freq_table[i]);
128
129 for (j = 0; j < stat->state_num; j++) {
130 if (len >= PAGE_SIZE)
131 break;
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -0700132 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 stat->trans_table[i*stat->max_state+j]);
134 }
135 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
136 }
137 return len;
138}
139CPUFREQ_STATDEVICE_ATTR(trans_table,0444,show_trans_table);
140#endif
141
142CPUFREQ_STATDEVICE_ATTR(total_trans,0444,show_total_trans);
143CPUFREQ_STATDEVICE_ATTR(time_in_state,0444,show_time_in_state);
144
145static struct attribute *default_attrs[] = {
146 &_attr_total_trans.attr,
147 &_attr_time_in_state.attr,
148#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
149 &_attr_trans_table.attr,
150#endif
151 NULL
152};
153static struct attribute_group stats_attr_group = {
154 .attrs = default_attrs,
155 .name = "stats"
156};
157
158static int
159freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq)
160{
161 int index;
162 for (index = 0; index < stat->max_state; index++)
163 if (stat->freq_table[index] == freq)
164 return index;
165 return -1;
166}
167
168static void
169cpufreq_stats_free_table (unsigned int cpu)
170{
171 struct cpufreq_stats *stat = cpufreq_stats_table[cpu];
172 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
173 if (policy && policy->cpu == cpu)
174 sysfs_remove_group(&policy->kobj, &stats_attr_group);
175 if (stat) {
176 kfree(stat->time_in_state);
177 kfree(stat);
178 }
179 cpufreq_stats_table[cpu] = NULL;
180 if (policy)
181 cpufreq_cpu_put(policy);
182}
183
184static int
185cpufreq_stats_create_table (struct cpufreq_policy *policy,
186 struct cpufreq_frequency_table *table)
187{
188 unsigned int i, j, count = 0, ret = 0;
189 struct cpufreq_stats *stat;
190 struct cpufreq_policy *data;
191 unsigned int alloc_size;
192 unsigned int cpu = policy->cpu;
193 if (cpufreq_stats_table[cpu])
194 return -EBUSY;
195 if ((stat = kmalloc(sizeof(struct cpufreq_stats), GFP_KERNEL)) == NULL)
196 return -ENOMEM;
197 memset(stat, 0, sizeof (struct cpufreq_stats));
198
199 data = cpufreq_cpu_get(cpu);
200 if ((ret = sysfs_create_group(&data->kobj, &stats_attr_group)))
201 goto error_out;
202
203 stat->cpu = cpu;
204 cpufreq_stats_table[cpu] = stat;
205
206 for (i=0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
207 unsigned int freq = table[i].frequency;
208 if (freq == CPUFREQ_ENTRY_INVALID)
209 continue;
210 count++;
211 }
212
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -0700213 alloc_size = count * sizeof(int) + count * sizeof(cputime64_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
216 alloc_size += count * count * sizeof(int);
217#endif
218 stat->max_state = count;
219 stat->time_in_state = kmalloc(alloc_size, GFP_KERNEL);
220 if (!stat->time_in_state) {
221 ret = -ENOMEM;
222 goto error_out;
223 }
224 memset(stat->time_in_state, 0, alloc_size);
225 stat->freq_table = (unsigned int *)(stat->time_in_state + count);
226
227#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
228 stat->trans_table = stat->freq_table + count;
229#endif
230 j = 0;
231 for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
232 unsigned int freq = table[i].frequency;
233 if (freq == CPUFREQ_ENTRY_INVALID)
234 continue;
235 if (freq_table_get_index(stat, freq) == -1)
236 stat->freq_table[j++] = freq;
237 }
238 stat->state_num = j;
239 spin_lock(&cpufreq_stats_lock);
Venkatesh Pallipadi58f1df22005-05-25 14:46:50 -0700240 stat->last_time = get_jiffies_64();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 stat->last_index = freq_table_get_index(stat, policy->cur);
242 spin_unlock(&cpufreq_stats_lock);
243 cpufreq_cpu_put(data);
244 return 0;
245error_out:
246 cpufreq_cpu_put(data);
247 kfree(stat);
248 cpufreq_stats_table[cpu] = NULL;
249 return ret;
250}
251
252static int
253cpufreq_stat_notifier_policy (struct notifier_block *nb, unsigned long val,
254 void *data)
255{
256 int ret;
257 struct cpufreq_policy *policy = data;
258 struct cpufreq_frequency_table *table;
259 unsigned int cpu = policy->cpu;
260 if (val != CPUFREQ_NOTIFY)
261 return 0;
262 table = cpufreq_frequency_get_table(cpu);
263 if (!table)
264 return 0;
265 if ((ret = cpufreq_stats_create_table(policy, table)))
266 return ret;
267 return 0;
268}
269
270static int
271cpufreq_stat_notifier_trans (struct notifier_block *nb, unsigned long val,
272 void *data)
273{
274 struct cpufreq_freqs *freq = data;
275 struct cpufreq_stats *stat;
276 int old_index, new_index;
277
278 if (val != CPUFREQ_POSTCHANGE)
279 return 0;
280
281 stat = cpufreq_stats_table[freq->cpu];
282 if (!stat)
283 return 0;
284 old_index = freq_table_get_index(stat, freq->old);
285 new_index = freq_table_get_index(stat, freq->new);
286
287 cpufreq_stats_update(freq->cpu);
288 if (old_index == new_index)
289 return 0;
290
291 spin_lock(&cpufreq_stats_lock);
292 stat->last_index = new_index;
293#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
294 stat->trans_table[old_index * stat->max_state + new_index]++;
295#endif
296 stat->total_trans++;
297 spin_unlock(&cpufreq_stats_lock);
298 return 0;
299}
300
301static struct notifier_block notifier_policy_block = {
302 .notifier_call = cpufreq_stat_notifier_policy
303};
304
305static struct notifier_block notifier_trans_block = {
306 .notifier_call = cpufreq_stat_notifier_trans
307};
308
309static int
310__init cpufreq_stats_init(void)
311{
312 int ret;
313 unsigned int cpu;
314 spin_lock_init(&cpufreq_stats_lock);
315 if ((ret = cpufreq_register_notifier(&notifier_policy_block,
316 CPUFREQ_POLICY_NOTIFIER)))
317 return ret;
318
319 if ((ret = cpufreq_register_notifier(&notifier_trans_block,
320 CPUFREQ_TRANSITION_NOTIFIER))) {
321 cpufreq_unregister_notifier(&notifier_policy_block,
322 CPUFREQ_POLICY_NOTIFIER);
323 return ret;
324 }
325
326 for_each_cpu(cpu)
327 cpufreq_update_policy(cpu);
328 return 0;
329}
330static void
331__exit cpufreq_stats_exit(void)
332{
333 unsigned int cpu;
334 cpufreq_unregister_notifier(&notifier_policy_block,
335 CPUFREQ_POLICY_NOTIFIER);
336 cpufreq_unregister_notifier(&notifier_trans_block,
337 CPUFREQ_TRANSITION_NOTIFIER);
338 for_each_cpu(cpu)
339 cpufreq_stats_free_table(cpu);
340}
341
342MODULE_AUTHOR ("Zou Nan hai <nanhai.zou@intel.com>");
343MODULE_DESCRIPTION ("'cpufreq_stats' - A driver to export cpufreq stats through sysfs filesystem");
344MODULE_LICENSE ("GPL");
345
346module_init(cpufreq_stats_init);
347module_exit(cpufreq_stats_exit);