d362739a71f3701e42d55f2ef508023c4de96cb2
[sfrench/cifs-2.6.git] / drivers / cpufreq / cpufreq_stats.c
1 /*
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/cpu.h>
13 #include <linux/cpufreq.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16
17 static DEFINE_SPINLOCK(cpufreq_stats_lock);
18
19 struct cpufreq_stats {
20         unsigned int total_trans;
21         unsigned long long last_time;
22         unsigned int max_state;
23         unsigned int state_num;
24         unsigned int last_index;
25         u64 *time_in_state;
26         unsigned int *freq_table;
27         unsigned int *trans_table;
28 };
29
30 static int cpufreq_stats_update(struct cpufreq_stats *stats)
31 {
32         unsigned long long cur_time = get_jiffies_64();
33
34         spin_lock(&cpufreq_stats_lock);
35         stats->time_in_state[stats->last_index] += cur_time - stats->last_time;
36         stats->last_time = cur_time;
37         spin_unlock(&cpufreq_stats_lock);
38         return 0;
39 }
40
41 static void cpufreq_stats_clear_table(struct cpufreq_stats *stats)
42 {
43         unsigned int count = stats->max_state;
44
45         memset(stats->time_in_state, 0, count * sizeof(u64));
46         memset(stats->trans_table, 0, count * count * sizeof(int));
47         stats->last_time = get_jiffies_64();
48         stats->total_trans = 0;
49 }
50
51 static ssize_t show_total_trans(struct cpufreq_policy *policy, char *buf)
52 {
53         return sprintf(buf, "%d\n", policy->stats->total_trans);
54 }
55
56 static ssize_t show_time_in_state(struct cpufreq_policy *policy, char *buf)
57 {
58         struct cpufreq_stats *stats = policy->stats;
59         ssize_t len = 0;
60         int i;
61
62         if (policy->fast_switch_enabled)
63                 return 0;
64
65         cpufreq_stats_update(stats);
66         for (i = 0; i < stats->state_num; i++) {
67                 len += sprintf(buf + len, "%u %llu\n", stats->freq_table[i],
68                         (unsigned long long)
69                         jiffies_64_to_clock_t(stats->time_in_state[i]));
70         }
71         return len;
72 }
73
74 static ssize_t store_reset(struct cpufreq_policy *policy, const char *buf,
75                            size_t count)
76 {
77         /* We don't care what is written to the attribute. */
78         cpufreq_stats_clear_table(policy->stats);
79         return count;
80 }
81
82 static ssize_t show_trans_table(struct cpufreq_policy *policy, char *buf)
83 {
84         struct cpufreq_stats *stats = policy->stats;
85         ssize_t len = 0;
86         int i, j;
87
88         if (policy->fast_switch_enabled)
89                 return 0;
90
91         len += snprintf(buf + len, PAGE_SIZE - len, "   From  :    To\n");
92         len += snprintf(buf + len, PAGE_SIZE - len, "         : ");
93         for (i = 0; i < stats->state_num; i++) {
94                 if (len >= PAGE_SIZE)
95                         break;
96                 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
97                                 stats->freq_table[i]);
98         }
99         if (len >= PAGE_SIZE)
100                 return PAGE_SIZE;
101
102         len += snprintf(buf + len, PAGE_SIZE - len, "\n");
103
104         for (i = 0; i < stats->state_num; i++) {
105                 if (len >= PAGE_SIZE)
106                         break;
107
108                 len += snprintf(buf + len, PAGE_SIZE - len, "%9u: ",
109                                 stats->freq_table[i]);
110
111                 for (j = 0; j < stats->state_num; j++) {
112                         if (len >= PAGE_SIZE)
113                                 break;
114                         len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
115                                         stats->trans_table[i*stats->max_state+j]);
116                 }
117                 if (len >= PAGE_SIZE)
118                         break;
119                 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
120         }
121         if (len >= PAGE_SIZE)
122                 return PAGE_SIZE;
123         return len;
124 }
125 cpufreq_freq_attr_ro(trans_table);
126
127 cpufreq_freq_attr_ro(total_trans);
128 cpufreq_freq_attr_ro(time_in_state);
129 cpufreq_freq_attr_wo(reset);
130
131 static struct attribute *default_attrs[] = {
132         &total_trans.attr,
133         &time_in_state.attr,
134         &reset.attr,
135         &trans_table.attr,
136         NULL
137 };
138 static const struct attribute_group stats_attr_group = {
139         .attrs = default_attrs,
140         .name = "stats"
141 };
142
143 static int freq_table_get_index(struct cpufreq_stats *stats, unsigned int freq)
144 {
145         int index;
146         for (index = 0; index < stats->max_state; index++)
147                 if (stats->freq_table[index] == freq)
148                         return index;
149         return -1;
150 }
151
152 void cpufreq_stats_free_table(struct cpufreq_policy *policy)
153 {
154         struct cpufreq_stats *stats = policy->stats;
155
156         /* Already freed */
157         if (!stats)
158                 return;
159
160         pr_debug("%s: Free stats table\n", __func__);
161
162         sysfs_remove_group(&policy->kobj, &stats_attr_group);
163         kfree(stats->time_in_state);
164         kfree(stats);
165         policy->stats = NULL;
166 }
167
168 void cpufreq_stats_create_table(struct cpufreq_policy *policy)
169 {
170         unsigned int i = 0, count = 0, ret = -ENOMEM;
171         struct cpufreq_stats *stats;
172         unsigned int alloc_size;
173         struct cpufreq_frequency_table *pos, *table;
174
175         /* We need cpufreq table for creating stats table */
176         table = policy->freq_table;
177         if (unlikely(!table))
178                 return;
179
180         /* stats already initialized */
181         if (policy->stats)
182                 return;
183
184         stats = kzalloc(sizeof(*stats), GFP_KERNEL);
185         if (!stats)
186                 return;
187
188         /* Find total allocation size */
189         cpufreq_for_each_valid_entry(pos, table)
190                 count++;
191
192         alloc_size = count * sizeof(int) + count * sizeof(u64);
193
194         alloc_size += count * count * sizeof(int);
195
196         /* Allocate memory for time_in_state/freq_table/trans_table in one go */
197         stats->time_in_state = kzalloc(alloc_size, GFP_KERNEL);
198         if (!stats->time_in_state)
199                 goto free_stat;
200
201         stats->freq_table = (unsigned int *)(stats->time_in_state + count);
202
203         stats->trans_table = stats->freq_table + count;
204
205         stats->max_state = count;
206
207         /* Find valid-unique entries */
208         cpufreq_for_each_valid_entry(pos, table)
209                 if (freq_table_get_index(stats, pos->frequency) == -1)
210                         stats->freq_table[i++] = pos->frequency;
211
212         stats->state_num = i;
213         stats->last_time = get_jiffies_64();
214         stats->last_index = freq_table_get_index(stats, policy->cur);
215
216         policy->stats = stats;
217         ret = sysfs_create_group(&policy->kobj, &stats_attr_group);
218         if (!ret)
219                 return;
220
221         /* We failed, release resources */
222         policy->stats = NULL;
223         kfree(stats->time_in_state);
224 free_stat:
225         kfree(stats);
226 }
227
228 void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
229                                      unsigned int new_freq)
230 {
231         struct cpufreq_stats *stats = policy->stats;
232         int old_index, new_index;
233
234         if (!stats) {
235                 pr_debug("%s: No stats found\n", __func__);
236                 return;
237         }
238
239         old_index = stats->last_index;
240         new_index = freq_table_get_index(stats, new_freq);
241
242         /* We can't do stats->time_in_state[-1]= .. */
243         if (old_index == -1 || new_index == -1 || old_index == new_index)
244                 return;
245
246         cpufreq_stats_update(stats);
247
248         stats->last_index = new_index;
249         stats->trans_table[old_index * stats->max_state + new_index]++;
250         stats->total_trans++;
251 }