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