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/kernel.h> 13#include <linux/sysdev.h> 14#include <linux/cpu.h> 15#include <linux/sysfs.h> 16#include <linux/cpufreq.h> 17#include <linux/jiffies.h> 18#include <linux/percpu.h> 19#include <linux/kobject.h> 20#include <linux/spinlock.h> 21#include <linux/notifier.h> 22#include <asm/cputime.h> 23 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 33struct 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 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; 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 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++) { 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 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); 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} 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 = kzalloc(sizeof(struct cpufreq_stats), GFP_KERNEL)) == NULL) 196 return -ENOMEM; 197 198 data = cpufreq_cpu_get(cpu); 199 if (data == NULL) { 200 ret = -EINVAL; 201 goto error_get_fail; 202 } 203 204 if ((ret = sysfs_create_group(&data->kobj, &stats_attr_group))) 205 goto error_out; 206 207 stat->cpu = cpu; 208 cpufreq_stats_table[cpu] = stat; 209 210 for (i=0; table[i].frequency != CPUFREQ_TABLE_END; i++) { 211 unsigned int freq = table[i].frequency; 212 if (freq == CPUFREQ_ENTRY_INVALID) 213 continue; 214 count++; 215 } 216 217 alloc_size = count * sizeof(int) + count * sizeof(cputime64_t); 218 219#ifdef CONFIG_CPU_FREQ_STAT_DETAILS 220 alloc_size += count * count * sizeof(int); 221#endif 222 stat->max_state = count; 223 stat->time_in_state = kzalloc(alloc_size, GFP_KERNEL); 224 if (!stat->time_in_state) { 225 ret = -ENOMEM; 226 goto error_out; 227 } 228 stat->freq_table = (unsigned int *)(stat->time_in_state + count); 229 230#ifdef CONFIG_CPU_FREQ_STAT_DETAILS 231 stat->trans_table = stat->freq_table + count; 232#endif 233 j = 0; 234 for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) { 235 unsigned int freq = table[i].frequency; 236 if (freq == CPUFREQ_ENTRY_INVALID) 237 continue; 238 if (freq_table_get_index(stat, freq) == -1) 239 stat->freq_table[j++] = freq; 240 } 241 stat->state_num = j; 242 spin_lock(&cpufreq_stats_lock); 243 stat->last_time = get_jiffies_64(); 244 stat->last_index = freq_table_get_index(stat, policy->cur); 245 spin_unlock(&cpufreq_stats_lock); 246 cpufreq_cpu_put(data); 247 return 0; 248error_out: 249 cpufreq_cpu_put(data); 250error_get_fail: 251 kfree(stat); 252 cpufreq_stats_table[cpu] = NULL; 253 return ret; 254} 255 256static int 257cpufreq_stat_notifier_policy (struct notifier_block *nb, unsigned long val, 258 void *data) 259{ 260 int ret; 261 struct cpufreq_policy *policy = data; 262 struct cpufreq_frequency_table *table; 263 unsigned int cpu = policy->cpu; 264 if (val != CPUFREQ_NOTIFY) 265 return 0; 266 table = cpufreq_frequency_get_table(cpu); 267 if (!table) 268 return 0; 269 if ((ret = cpufreq_stats_create_table(policy, table))) 270 return ret; 271 return 0; 272} 273 274static int 275cpufreq_stat_notifier_trans (struct notifier_block *nb, unsigned long val, 276 void *data) 277{ 278 struct cpufreq_freqs *freq = data; 279 struct cpufreq_stats *stat; 280 int old_index, new_index; 281 282 if (val != CPUFREQ_POSTCHANGE) 283 return 0; 284 285 stat = cpufreq_stats_table[freq->cpu]; 286 if (!stat) 287 return 0; 288 289 old_index = freq_table_get_index(stat, freq->old); 290 new_index = freq_table_get_index(stat, freq->new); 291 292 cpufreq_stats_update(freq->cpu); 293 if (old_index == new_index) 294 return 0; 295 296 if (old_index == -1 || new_index == -1) 297 return 0; 298 299 spin_lock(&cpufreq_stats_lock); 300 stat->last_index = new_index; 301#ifdef CONFIG_CPU_FREQ_STAT_DETAILS 302 stat->trans_table[old_index * stat->max_state + new_index]++; 303#endif 304 stat->total_trans++; 305 spin_unlock(&cpufreq_stats_lock); 306 return 0; 307} 308 309static int cpufreq_stat_cpu_callback(struct notifier_block *nfb, 310 unsigned long action, void *hcpu) 311{ 312 unsigned int cpu = (unsigned long)hcpu; 313 314 switch (action) { 315 case CPU_ONLINE: 316 case CPU_ONLINE_FROZEN: 317 cpufreq_update_policy(cpu); 318 break; 319 case CPU_DEAD: 320 case CPU_DEAD_FROZEN: 321 cpufreq_stats_free_table(cpu); 322 break; 323 } 324 return NOTIFY_OK; 325} 326 327static struct notifier_block cpufreq_stat_cpu_notifier = 328{ 329 .notifier_call = cpufreq_stat_cpu_callback, 330}; 331 332static struct notifier_block notifier_policy_block = { 333 .notifier_call = cpufreq_stat_notifier_policy 334}; 335 336static struct notifier_block notifier_trans_block = { 337 .notifier_call = cpufreq_stat_notifier_trans 338}; 339 340static int 341__init cpufreq_stats_init(void) 342{ 343 int ret; 344 unsigned int cpu; 345 346 spin_lock_init(&cpufreq_stats_lock); 347 if ((ret = cpufreq_register_notifier(¬ifier_policy_block, 348 CPUFREQ_POLICY_NOTIFIER))) 349 return ret; 350 351 if ((ret = cpufreq_register_notifier(¬ifier_trans_block, 352 CPUFREQ_TRANSITION_NOTIFIER))) { 353 cpufreq_unregister_notifier(¬ifier_policy_block, 354 CPUFREQ_POLICY_NOTIFIER); 355 return ret; 356 } 357 358 register_hotcpu_notifier(&cpufreq_stat_cpu_notifier); 359 for_each_online_cpu(cpu) { 360 cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, 361 CPU_ONLINE, (void *)(long)cpu); 362 } 363 return 0; 364} 365static void 366__exit cpufreq_stats_exit(void) 367{ 368 unsigned int cpu; 369 370 cpufreq_unregister_notifier(¬ifier_policy_block, 371 CPUFREQ_POLICY_NOTIFIER); 372 cpufreq_unregister_notifier(¬ifier_trans_block, 373 CPUFREQ_TRANSITION_NOTIFIER); 374 unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier); 375 for_each_online_cpu(cpu) { 376 cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, 377 CPU_DEAD, (void *)(long)cpu); 378 } 379} 380 381MODULE_AUTHOR ("Zou Nan hai <nanhai.zou@intel.com>"); 382MODULE_DESCRIPTION ("'cpufreq_stats' - A driver to export cpufreq stats" 383 "through sysfs filesystem"); 384MODULE_LICENSE ("GPL"); 385 386module_init(cpufreq_stats_init); 387module_exit(cpufreq_stats_exit); 388