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), .mode = _mode, }, \ 29 .show = _show,\ 30 }; 31 32 struct cpufreq_stats { 33 unsigned int cpu; 34 unsigned int total_trans; 35 unsigned long long last_time; 36 unsigned int max_state; 37 unsigned int state_num; 38 unsigned int last_index; 39 cputime64_t *time_in_state; 40 unsigned int *freq_table; 41 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS 42 unsigned int *trans_table; 43 #endif 44 }; 45 46 static DEFINE_PER_CPU(struct cpufreq_stats *, cpufreq_stats_table); 47 48 struct cpufreq_stats_attribute { 49 struct attribute attr; 50 ssize_t(*show) (struct cpufreq_stats *, char *); 51 }; 52 53 static int 54 cpufreq_stats_update (unsigned int cpu) 55 { 56 struct cpufreq_stats *stat; 57 unsigned long long cur_time; 58 59 cur_time = get_jiffies_64(); 60 spin_lock(&cpufreq_stats_lock); 61 stat = per_cpu(cpufreq_stats_table, cpu); 62 if (stat->time_in_state) 63 stat->time_in_state[stat->last_index] = 64 cputime64_add(stat->time_in_state[stat->last_index], 65 cputime_sub(cur_time, stat->last_time)); 66 stat->last_time = cur_time; 67 spin_unlock(&cpufreq_stats_lock); 68 return 0; 69 } 70 71 static ssize_t 72 show_total_trans(struct cpufreq_policy *policy, char *buf) 73 { 74 struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu); 75 if (!stat) 76 return 0; 77 return sprintf(buf, "%d\n", 78 per_cpu(cpufreq_stats_table, stat->cpu)->total_trans); 79 } 80 81 static ssize_t 82 show_time_in_state(struct cpufreq_policy *policy, char *buf) 83 { 84 ssize_t len = 0; 85 int i; 86 struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu); 87 if (!stat) 88 return 0; 89 cpufreq_stats_update(stat->cpu); 90 for (i = 0; i < stat->state_num; i++) { 91 len += sprintf(buf + len, "%u %llu\n", stat->freq_table[i], 92 (unsigned long long)cputime64_to_clock_t(stat->time_in_state[i])); 93 } 94 return len; 95 } 96 97 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS 98 static ssize_t 99 show_trans_table(struct cpufreq_policy *policy, char *buf) 100 { 101 ssize_t len = 0; 102 int i, j; 103 104 struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu); 105 if (!stat) 106 return 0; 107 cpufreq_stats_update(stat->cpu); 108 len += snprintf(buf + len, PAGE_SIZE - len, " From : To\n"); 109 len += snprintf(buf + len, PAGE_SIZE - len, " : "); 110 for (i = 0; i < stat->state_num; i++) { 111 if (len >= PAGE_SIZE) 112 break; 113 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ", 114 stat->freq_table[i]); 115 } 116 if (len >= PAGE_SIZE) 117 return PAGE_SIZE; 118 119 len += snprintf(buf + len, PAGE_SIZE - len, "\n"); 120 121 for (i = 0; i < stat->state_num; i++) { 122 if (len >= PAGE_SIZE) 123 break; 124 125 len += snprintf(buf + len, PAGE_SIZE - len, "%9u: ", 126 stat->freq_table[i]); 127 128 for (j = 0; j < stat->state_num; j++) { 129 if (len >= PAGE_SIZE) 130 break; 131 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ", 132 stat->trans_table[i*stat->max_state+j]); 133 } 134 if (len >= PAGE_SIZE) 135 break; 136 len += snprintf(buf + len, PAGE_SIZE - len, "\n"); 137 } 138 if (len >= PAGE_SIZE) 139 return PAGE_SIZE; 140 return len; 141 } 142 CPUFREQ_STATDEVICE_ATTR(trans_table,0444,show_trans_table); 143 #endif 144 145 CPUFREQ_STATDEVICE_ATTR(total_trans,0444,show_total_trans); 146 CPUFREQ_STATDEVICE_ATTR(time_in_state,0444,show_time_in_state); 147 148 static struct attribute *default_attrs[] = { 149 &_attr_total_trans.attr, 150 &_attr_time_in_state.attr, 151 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS 152 &_attr_trans_table.attr, 153 #endif 154 NULL 155 }; 156 static struct attribute_group stats_attr_group = { 157 .attrs = default_attrs, 158 .name = "stats" 159 }; 160 161 static int 162 freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq) 163 { 164 int index; 165 for (index = 0; index < stat->max_state; index++) 166 if (stat->freq_table[index] == freq) 167 return index; 168 return -1; 169 } 170 171 static void cpufreq_stats_free_table(unsigned int cpu) 172 { 173 struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, cpu); 174 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu); 175 if (policy && policy->cpu == cpu) 176 sysfs_remove_group(&policy->kobj, &stats_attr_group); 177 if (stat) { 178 kfree(stat->time_in_state); 179 kfree(stat); 180 } 181 per_cpu(cpufreq_stats_table, cpu) = NULL; 182 if (policy) 183 cpufreq_cpu_put(policy); 184 } 185 186 static int 187 cpufreq_stats_create_table (struct cpufreq_policy *policy, 188 struct cpufreq_frequency_table *table) 189 { 190 unsigned int i, j, count = 0, ret = 0; 191 struct cpufreq_stats *stat; 192 struct cpufreq_policy *data; 193 unsigned int alloc_size; 194 unsigned int cpu = policy->cpu; 195 if (per_cpu(cpufreq_stats_table, cpu)) 196 return -EBUSY; 197 if ((stat = kzalloc(sizeof(struct cpufreq_stats), GFP_KERNEL)) == NULL) 198 return -ENOMEM; 199 200 data = cpufreq_cpu_get(cpu); 201 if (data == NULL) { 202 ret = -EINVAL; 203 goto error_get_fail; 204 } 205 206 if ((ret = sysfs_create_group(&data->kobj, &stats_attr_group))) 207 goto error_out; 208 209 stat->cpu = cpu; 210 per_cpu(cpufreq_stats_table, cpu) = stat; 211 212 for (i=0; table[i].frequency != CPUFREQ_TABLE_END; i++) { 213 unsigned int freq = table[i].frequency; 214 if (freq == CPUFREQ_ENTRY_INVALID) 215 continue; 216 count++; 217 } 218 219 alloc_size = count * sizeof(int) + count * sizeof(cputime64_t); 220 221 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS 222 alloc_size += count * count * sizeof(int); 223 #endif 224 stat->max_state = count; 225 stat->time_in_state = kzalloc(alloc_size, GFP_KERNEL); 226 if (!stat->time_in_state) { 227 ret = -ENOMEM; 228 goto error_out; 229 } 230 stat->freq_table = (unsigned int *)(stat->time_in_state + count); 231 232 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS 233 stat->trans_table = stat->freq_table + count; 234 #endif 235 j = 0; 236 for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) { 237 unsigned int freq = table[i].frequency; 238 if (freq == CPUFREQ_ENTRY_INVALID) 239 continue; 240 if (freq_table_get_index(stat, freq) == -1) 241 stat->freq_table[j++] = freq; 242 } 243 stat->state_num = j; 244 spin_lock(&cpufreq_stats_lock); 245 stat->last_time = get_jiffies_64(); 246 stat->last_index = freq_table_get_index(stat, policy->cur); 247 spin_unlock(&cpufreq_stats_lock); 248 cpufreq_cpu_put(data); 249 return 0; 250 error_out: 251 cpufreq_cpu_put(data); 252 error_get_fail: 253 kfree(stat); 254 per_cpu(cpufreq_stats_table, cpu) = NULL; 255 return ret; 256 } 257 258 static int 259 cpufreq_stat_notifier_policy (struct notifier_block *nb, unsigned long val, 260 void *data) 261 { 262 int ret; 263 struct cpufreq_policy *policy = data; 264 struct cpufreq_frequency_table *table; 265 unsigned int cpu = policy->cpu; 266 if (val != CPUFREQ_NOTIFY) 267 return 0; 268 table = cpufreq_frequency_get_table(cpu); 269 if (!table) 270 return 0; 271 if ((ret = cpufreq_stats_create_table(policy, table))) 272 return ret; 273 return 0; 274 } 275 276 static int 277 cpufreq_stat_notifier_trans (struct notifier_block *nb, unsigned long val, 278 void *data) 279 { 280 struct cpufreq_freqs *freq = data; 281 struct cpufreq_stats *stat; 282 int old_index, new_index; 283 284 if (val != CPUFREQ_POSTCHANGE) 285 return 0; 286 287 stat = per_cpu(cpufreq_stats_table, freq->cpu); 288 if (!stat) 289 return 0; 290 291 old_index = stat->last_index; 292 new_index = freq_table_get_index(stat, freq->new); 293 294 cpufreq_stats_update(freq->cpu); 295 if (old_index == new_index) 296 return 0; 297 298 if (old_index == -1 || new_index == -1) 299 return 0; 300 301 spin_lock(&cpufreq_stats_lock); 302 stat->last_index = new_index; 303 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS 304 stat->trans_table[old_index * stat->max_state + new_index]++; 305 #endif 306 stat->total_trans++; 307 spin_unlock(&cpufreq_stats_lock); 308 return 0; 309 } 310 311 static int __cpuinit cpufreq_stat_cpu_callback(struct notifier_block *nfb, 312 unsigned long action, 313 void *hcpu) 314 { 315 unsigned int cpu = (unsigned long)hcpu; 316 317 switch (action) { 318 case CPU_ONLINE: 319 case CPU_ONLINE_FROZEN: 320 cpufreq_update_policy(cpu); 321 break; 322 case CPU_DEAD: 323 case CPU_DEAD_FROZEN: 324 cpufreq_stats_free_table(cpu); 325 break; 326 } 327 return NOTIFY_OK; 328 } 329 330 static struct notifier_block cpufreq_stat_cpu_notifier __refdata = 331 { 332 .notifier_call = cpufreq_stat_cpu_callback, 333 }; 334 335 static struct notifier_block notifier_policy_block = { 336 .notifier_call = cpufreq_stat_notifier_policy 337 }; 338 339 static struct notifier_block notifier_trans_block = { 340 .notifier_call = cpufreq_stat_notifier_trans 341 }; 342 343 static int 344 __init cpufreq_stats_init(void) 345 { 346 int ret; 347 unsigned int cpu; 348 349 spin_lock_init(&cpufreq_stats_lock); 350 if ((ret = cpufreq_register_notifier(¬ifier_policy_block, 351 CPUFREQ_POLICY_NOTIFIER))) 352 return ret; 353 354 if ((ret = cpufreq_register_notifier(¬ifier_trans_block, 355 CPUFREQ_TRANSITION_NOTIFIER))) { 356 cpufreq_unregister_notifier(¬ifier_policy_block, 357 CPUFREQ_POLICY_NOTIFIER); 358 return ret; 359 } 360 361 register_hotcpu_notifier(&cpufreq_stat_cpu_notifier); 362 for_each_online_cpu(cpu) { 363 cpufreq_update_policy(cpu); 364 } 365 return 0; 366 } 367 static void 368 __exit cpufreq_stats_exit(void) 369 { 370 unsigned int cpu; 371 372 cpufreq_unregister_notifier(¬ifier_policy_block, 373 CPUFREQ_POLICY_NOTIFIER); 374 cpufreq_unregister_notifier(¬ifier_trans_block, 375 CPUFREQ_TRANSITION_NOTIFIER); 376 unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier); 377 for_each_online_cpu(cpu) { 378 cpufreq_stats_free_table(cpu); 379 } 380 } 381 382 MODULE_AUTHOR ("Zou Nan hai <nanhai.zou@intel.com>"); 383 MODULE_DESCRIPTION ("'cpufreq_stats' - A driver to export cpufreq stats " 384 "through sysfs filesystem"); 385 MODULE_LICENSE ("GPL"); 386 387 module_init(cpufreq_stats_init); 388 module_exit(cpufreq_stats_exit); 389