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/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> 22 #include <asm/cputime.h> 23 24 static spinlock_t cpufreq_stats_lock; 25 26 #define CPUFREQ_STATDEVICE_ATTR(_name,_mode,_show) \ 27 static struct freq_attr _attr_##_name = {\ 28 .attr = {.name = __stringify(_name), .owner = THIS_MODULE, \ 29 .mode = _mode, }, \ 30 .show = _show,\ 31 }; 32 33 struct cpufreq_stats { 34 unsigned int cpu; 35 unsigned int total_trans; 36 unsigned long long last_time; 37 unsigned int max_state; 38 unsigned int state_num; 39 unsigned int last_index; 40 cputime64_t *time_in_state; 41 unsigned int *freq_table; 42 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS 43 unsigned int *trans_table; 44 #endif 45 }; 46 47 static struct cpufreq_stats *cpufreq_stats_table[NR_CPUS]; 48 49 struct cpufreq_stats_attribute { 50 struct attribute attr; 51 ssize_t(*show) (struct cpufreq_stats *, char *); 52 }; 53 54 static int 55 cpufreq_stats_update (unsigned int cpu) 56 { 57 struct cpufreq_stats *stat; 58 unsigned long long cur_time; 59 60 cur_time = get_jiffies_64(); 61 spin_lock(&cpufreq_stats_lock); 62 stat = cpufreq_stats_table[cpu]; 63 if (stat->time_in_state) 64 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; 68 spin_unlock(&cpufreq_stats_lock); 69 return 0; 70 } 71 72 static ssize_t 73 show_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 82 static ssize_t 83 show_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++) { 92 len += sprintf(buf + len, "%u %llu\n", stat->freq_table[i], 93 (unsigned long long)cputime64_to_clock_t(stat->time_in_state[i])); 94 } 95 return len; 96 } 97 98 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS 99 static ssize_t 100 show_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); 109 len += snprintf(buf + len, PAGE_SIZE - len, " From : To\n"); 110 len += snprintf(buf + len, PAGE_SIZE - len, " : "); 111 for (i = 0; i < stat->state_num; i++) { 112 if (len >= PAGE_SIZE) 113 break; 114 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: ", 127 stat->freq_table[i]); 128 129 for (j = 0; j < stat->state_num; j++) { 130 if (len >= PAGE_SIZE) 131 break; 132 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ", 133 stat->trans_table[i*stat->max_state+j]); 134 } 135 len += snprintf(buf + len, PAGE_SIZE - len, "\n"); 136 } 137 return len; 138 } 139 CPUFREQ_STATDEVICE_ATTR(trans_table,0444,show_trans_table); 140 #endif 141 142 CPUFREQ_STATDEVICE_ATTR(total_trans,0444,show_total_trans); 143 CPUFREQ_STATDEVICE_ATTR(time_in_state,0444,show_time_in_state); 144 145 static 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 }; 153 static struct attribute_group stats_attr_group = { 154 .attrs = default_attrs, 155 .name = "stats" 156 }; 157 158 static int 159 freq_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 168 static void 169 cpufreq_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 184 static int 185 cpufreq_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 213 alloc_size = count * sizeof(int) + count * sizeof(cputime64_t); 214 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); 240 stat->last_time = get_jiffies_64(); 241 stat->last_index = freq_table_get_index(stat, policy->cur); 242 spin_unlock(&cpufreq_stats_lock); 243 cpufreq_cpu_put(data); 244 return 0; 245 error_out: 246 cpufreq_cpu_put(data); 247 kfree(stat); 248 cpufreq_stats_table[cpu] = NULL; 249 return ret; 250 } 251 252 static int 253 cpufreq_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 270 static int 271 cpufreq_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 301 static struct notifier_block notifier_policy_block = { 302 .notifier_call = cpufreq_stat_notifier_policy 303 }; 304 305 static struct notifier_block notifier_trans_block = { 306 .notifier_call = cpufreq_stat_notifier_trans 307 }; 308 309 static 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(¬ifier_policy_block, 316 CPUFREQ_POLICY_NOTIFIER))) 317 return ret; 318 319 if ((ret = cpufreq_register_notifier(¬ifier_trans_block, 320 CPUFREQ_TRANSITION_NOTIFIER))) { 321 cpufreq_unregister_notifier(¬ifier_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 } 330 static void 331 __exit cpufreq_stats_exit(void) 332 { 333 unsigned int cpu; 334 cpufreq_unregister_notifier(¬ifier_policy_block, 335 CPUFREQ_POLICY_NOTIFIER); 336 cpufreq_unregister_notifier(¬ifier_trans_block, 337 CPUFREQ_TRANSITION_NOTIFIER); 338 for_each_cpu(cpu) 339 cpufreq_stats_free_table(cpu); 340 } 341 342 MODULE_AUTHOR ("Zou Nan hai <nanhai.zou@intel.com>"); 343 MODULE_DESCRIPTION ("'cpufreq_stats' - A driver to export cpufreq stats through sysfs filesystem"); 344 MODULE_LICENSE ("GPL"); 345 346 module_init(cpufreq_stats_init); 347 module_exit(cpufreq_stats_exit); 348