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 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 = 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; 248 error_out: 249 cpufreq_cpu_put(data); 250 error_get_fail: 251 kfree(stat); 252 cpufreq_stats_table[cpu] = NULL; 253 return ret; 254 } 255 256 static int 257 cpufreq_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 274 static int 275 cpufreq_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 309 static 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 cpufreq_update_policy(cpu); 317 break; 318 case CPU_DEAD: 319 cpufreq_stats_free_table(cpu); 320 break; 321 } 322 return NOTIFY_OK; 323 } 324 325 static struct notifier_block cpufreq_stat_cpu_notifier = 326 { 327 .notifier_call = cpufreq_stat_cpu_callback, 328 }; 329 330 static struct notifier_block notifier_policy_block = { 331 .notifier_call = cpufreq_stat_notifier_policy 332 }; 333 334 static struct notifier_block notifier_trans_block = { 335 .notifier_call = cpufreq_stat_notifier_trans 336 }; 337 338 static int 339 __init cpufreq_stats_init(void) 340 { 341 int ret; 342 unsigned int cpu; 343 344 spin_lock_init(&cpufreq_stats_lock); 345 if ((ret = cpufreq_register_notifier(¬ifier_policy_block, 346 CPUFREQ_POLICY_NOTIFIER))) 347 return ret; 348 349 if ((ret = cpufreq_register_notifier(¬ifier_trans_block, 350 CPUFREQ_TRANSITION_NOTIFIER))) { 351 cpufreq_unregister_notifier(¬ifier_policy_block, 352 CPUFREQ_POLICY_NOTIFIER); 353 return ret; 354 } 355 356 register_hotcpu_notifier(&cpufreq_stat_cpu_notifier); 357 for_each_online_cpu(cpu) { 358 cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, 359 CPU_ONLINE, (void *)(long)cpu); 360 } 361 return 0; 362 } 363 static void 364 __exit cpufreq_stats_exit(void) 365 { 366 unsigned int cpu; 367 368 cpufreq_unregister_notifier(¬ifier_policy_block, 369 CPUFREQ_POLICY_NOTIFIER); 370 cpufreq_unregister_notifier(¬ifier_trans_block, 371 CPUFREQ_TRANSITION_NOTIFIER); 372 unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier); 373 for_each_online_cpu(cpu) { 374 cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, 375 CPU_DEAD, (void *)(long)cpu); 376 } 377 } 378 379 MODULE_AUTHOR ("Zou Nan hai <nanhai.zou@intel.com>"); 380 MODULE_DESCRIPTION ("'cpufreq_stats' - A driver to export cpufreq stats" 381 "through sysfs filesystem"); 382 MODULE_LICENSE ("GPL"); 383 384 module_init(cpufreq_stats_init); 385 module_exit(cpufreq_stats_exit); 386