1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * drivers/cpufreq/cpufreq_stats.c
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Copyright (C) 2003-2004 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
61da177e4SLinus Torvalds * (C) 2004 Zou Nan hai <nanhai.zou@intel.com>.
71da177e4SLinus Torvalds */
81da177e4SLinus Torvalds
91da177e4SLinus Torvalds #include <linux/cpu.h>
101da177e4SLinus Torvalds #include <linux/cpufreq.h>
115c720d37SPaul Gortmaker #include <linux/module.h>
127854c752SViresh Kumar #include <linux/sched/clock.h>
135ff0a268SViresh Kumar #include <linux/slab.h>
141da177e4SLinus Torvalds
151da177e4SLinus Torvalds struct cpufreq_stats {
161da177e4SLinus Torvalds unsigned int total_trans;
171da177e4SLinus Torvalds unsigned long long last_time;
181da177e4SLinus Torvalds unsigned int max_state;
191da177e4SLinus Torvalds unsigned int state_num;
201da177e4SLinus Torvalds unsigned int last_index;
211e7586a1SViresh Kumar u64 *time_in_state;
221da177e4SLinus Torvalds unsigned int *freq_table;
231da177e4SLinus Torvalds unsigned int *trans_table;
2440c3bd4cSViresh Kumar
2540c3bd4cSViresh Kumar /* Deferred reset */
2640c3bd4cSViresh Kumar unsigned int reset_pending;
2740c3bd4cSViresh Kumar unsigned long long reset_time;
281da177e4SLinus Torvalds };
291da177e4SLinus Torvalds
cpufreq_stats_update(struct cpufreq_stats * stats,unsigned long long time)3040c3bd4cSViresh Kumar static void cpufreq_stats_update(struct cpufreq_stats *stats,
3140c3bd4cSViresh Kumar unsigned long long time)
321da177e4SLinus Torvalds {
337854c752SViresh Kumar unsigned long long cur_time = local_clock();
3458f1df25SVenkatesh Pallipadi
3540c3bd4cSViresh Kumar stats->time_in_state[stats->last_index] += cur_time - time;
3650941607SViresh Kumar stats->last_time = cur_time;
371da177e4SLinus Torvalds }
381da177e4SLinus Torvalds
cpufreq_stats_reset_table(struct cpufreq_stats * stats)3940c3bd4cSViresh Kumar static void cpufreq_stats_reset_table(struct cpufreq_stats *stats)
40ee7930eeSMarkus Mayer {
41ee7930eeSMarkus Mayer unsigned int count = stats->max_state;
42ee7930eeSMarkus Mayer
43ee7930eeSMarkus Mayer memset(stats->time_in_state, 0, count * sizeof(u64));
44ee7930eeSMarkus Mayer memset(stats->trans_table, 0, count * count * sizeof(int));
457854c752SViresh Kumar stats->last_time = local_clock();
46ee7930eeSMarkus Mayer stats->total_trans = 0;
4740c3bd4cSViresh Kumar
4840c3bd4cSViresh Kumar /* Adjust for the time elapsed since reset was requested */
4940c3bd4cSViresh Kumar WRITE_ONCE(stats->reset_pending, 0);
50efad4240SRafael J. Wysocki /*
51efad4240SRafael J. Wysocki * Prevent the reset_time read from being reordered before the
52efad4240SRafael J. Wysocki * reset_pending accesses in cpufreq_stats_record_transition().
53efad4240SRafael J. Wysocki */
54efad4240SRafael J. Wysocki smp_rmb();
5540c3bd4cSViresh Kumar cpufreq_stats_update(stats, READ_ONCE(stats->reset_time));
56ee7930eeSMarkus Mayer }
57ee7930eeSMarkus Mayer
show_total_trans(struct cpufreq_policy * policy,char * buf)580a829c5aSDave Jones static ssize_t show_total_trans(struct cpufreq_policy *policy, char *buf)
591da177e4SLinus Torvalds {
6040c3bd4cSViresh Kumar struct cpufreq_stats *stats = policy->stats;
6140c3bd4cSViresh Kumar
6240c3bd4cSViresh Kumar if (READ_ONCE(stats->reset_pending))
6340c3bd4cSViresh Kumar return sprintf(buf, "%d\n", 0);
6440c3bd4cSViresh Kumar else
65b7af6080SViresh Kumar return sprintf(buf, "%u\n", stats->total_trans);
661da177e4SLinus Torvalds }
6710b81821SViresh Kumar cpufreq_freq_attr_ro(total_trans);
681da177e4SLinus Torvalds
show_time_in_state(struct cpufreq_policy * policy,char * buf)690a829c5aSDave Jones static ssize_t show_time_in_state(struct cpufreq_policy *policy, char *buf)
701da177e4SLinus Torvalds {
7150941607SViresh Kumar struct cpufreq_stats *stats = policy->stats;
7240c3bd4cSViresh Kumar bool pending = READ_ONCE(stats->reset_pending);
7340c3bd4cSViresh Kumar unsigned long long time;
741da177e4SLinus Torvalds ssize_t len = 0;
751da177e4SLinus Torvalds int i;
76a9aaf291SViresh Kumar
7750941607SViresh Kumar for (i = 0; i < stats->state_num; i++) {
7840c3bd4cSViresh Kumar if (pending) {
79efad4240SRafael J. Wysocki if (i == stats->last_index) {
80efad4240SRafael J. Wysocki /*
81efad4240SRafael J. Wysocki * Prevent the reset_time read from occurring
82efad4240SRafael J. Wysocki * before the reset_pending read above.
83efad4240SRafael J. Wysocki */
84efad4240SRafael J. Wysocki smp_rmb();
857854c752SViresh Kumar time = local_clock() - READ_ONCE(stats->reset_time);
86efad4240SRafael J. Wysocki } else {
8740c3bd4cSViresh Kumar time = 0;
88efad4240SRafael J. Wysocki }
8940c3bd4cSViresh Kumar } else {
9040c3bd4cSViresh Kumar time = stats->time_in_state[i];
9140c3bd4cSViresh Kumar if (i == stats->last_index)
927854c752SViresh Kumar time += local_clock() - stats->last_time;
9340c3bd4cSViresh Kumar }
9440c3bd4cSViresh Kumar
9550941607SViresh Kumar len += sprintf(buf + len, "%u %llu\n", stats->freq_table[i],
967854c752SViresh Kumar nsec_to_clock_t(time));
971da177e4SLinus Torvalds }
981da177e4SLinus Torvalds return len;
991da177e4SLinus Torvalds }
10010b81821SViresh Kumar cpufreq_freq_attr_ro(time_in_state);
1011da177e4SLinus Torvalds
10240c3bd4cSViresh Kumar /* We don't care what is written to the attribute */
store_reset(struct cpufreq_policy * policy,const char * buf,size_t count)103ee7930eeSMarkus Mayer static ssize_t store_reset(struct cpufreq_policy *policy, const char *buf,
104ee7930eeSMarkus Mayer size_t count)
105ee7930eeSMarkus Mayer {
10640c3bd4cSViresh Kumar struct cpufreq_stats *stats = policy->stats;
10740c3bd4cSViresh Kumar
10840c3bd4cSViresh Kumar /*
10940c3bd4cSViresh Kumar * Defer resetting of stats to cpufreq_stats_record_transition() to
11040c3bd4cSViresh Kumar * avoid races.
11140c3bd4cSViresh Kumar */
1127854c752SViresh Kumar WRITE_ONCE(stats->reset_time, local_clock());
113efad4240SRafael J. Wysocki /*
114efad4240SRafael J. Wysocki * The memory barrier below is to prevent the readers of reset_time from
115efad4240SRafael J. Wysocki * seeing a stale or partially updated value.
116efad4240SRafael J. Wysocki */
117efad4240SRafael J. Wysocki smp_wmb();
11840c3bd4cSViresh Kumar WRITE_ONCE(stats->reset_pending, 1);
11940c3bd4cSViresh Kumar
120ee7930eeSMarkus Mayer return count;
121ee7930eeSMarkus Mayer }
12210b81821SViresh Kumar cpufreq_freq_attr_wo(reset);
123ee7930eeSMarkus Mayer
show_trans_table(struct cpufreq_policy * policy,char * buf)1240a829c5aSDave Jones static ssize_t show_trans_table(struct cpufreq_policy *policy, char *buf)
1251da177e4SLinus Torvalds {
12650941607SViresh Kumar struct cpufreq_stats *stats = policy->stats;
12740c3bd4cSViresh Kumar bool pending = READ_ONCE(stats->reset_pending);
1281da177e4SLinus Torvalds ssize_t len = 0;
12940c3bd4cSViresh Kumar int i, j, count;
1301da177e4SLinus Torvalds
1317ed40bcfSye xingchen len += sysfs_emit_at(buf, len, " From : To\n");
1327ed40bcfSye xingchen len += sysfs_emit_at(buf, len, " : ");
13350941607SViresh Kumar for (i = 0; i < stats->state_num; i++) {
134*22d4c2a8SChristian Marangi if (len >= PAGE_SIZE - 1)
1351da177e4SLinus Torvalds break;
1367ed40bcfSye xingchen len += sysfs_emit_at(buf, len, "%9u ", stats->freq_table[i]);
13758f1df25SVenkatesh Pallipadi }
138*22d4c2a8SChristian Marangi if (len >= PAGE_SIZE - 1)
139*22d4c2a8SChristian Marangi return PAGE_SIZE - 1;
14058f1df25SVenkatesh Pallipadi
1417ed40bcfSye xingchen len += sysfs_emit_at(buf, len, "\n");
14258f1df25SVenkatesh Pallipadi
14350941607SViresh Kumar for (i = 0; i < stats->state_num; i++) {
144*22d4c2a8SChristian Marangi if (len >= PAGE_SIZE - 1)
14558f1df25SVenkatesh Pallipadi break;
14658f1df25SVenkatesh Pallipadi
1477ed40bcfSye xingchen len += sysfs_emit_at(buf, len, "%9u: ", stats->freq_table[i]);
1481da177e4SLinus Torvalds
14950941607SViresh Kumar for (j = 0; j < stats->state_num; j++) {
150*22d4c2a8SChristian Marangi if (len >= PAGE_SIZE - 1)
1511da177e4SLinus Torvalds break;
15240c3bd4cSViresh Kumar
15340c3bd4cSViresh Kumar if (pending)
15440c3bd4cSViresh Kumar count = 0;
15540c3bd4cSViresh Kumar else
15640c3bd4cSViresh Kumar count = stats->trans_table[i * stats->max_state + j];
15740c3bd4cSViresh Kumar
1587ed40bcfSye xingchen len += sysfs_emit_at(buf, len, "%9u ", count);
1591da177e4SLinus Torvalds }
160*22d4c2a8SChristian Marangi if (len >= PAGE_SIZE - 1)
16125aca347SCesar Eduardo Barros break;
1627ed40bcfSye xingchen len += sysfs_emit_at(buf, len, "\n");
1631da177e4SLinus Torvalds }
164f7bc9b20SGautham R. Shenoy
165*22d4c2a8SChristian Marangi if (len >= PAGE_SIZE - 1) {
166f7bc9b20SGautham R. Shenoy pr_warn_once("cpufreq transition table exceeds PAGE_SIZE. Disabling\n");
167f7bc9b20SGautham R. Shenoy return -EFBIG;
168f7bc9b20SGautham R. Shenoy }
1691da177e4SLinus Torvalds return len;
1701da177e4SLinus Torvalds }
171df18e504SViresh Kumar cpufreq_freq_attr_ro(trans_table);
1721da177e4SLinus Torvalds
1731da177e4SLinus Torvalds static struct attribute *default_attrs[] = {
174df18e504SViresh Kumar &total_trans.attr,
175df18e504SViresh Kumar &time_in_state.attr,
176ee7930eeSMarkus Mayer &reset.attr,
177df18e504SViresh Kumar &trans_table.attr,
1781da177e4SLinus Torvalds NULL
1791da177e4SLinus Torvalds };
180402202e8SArvind Yadav static const struct attribute_group stats_attr_group = {
1811da177e4SLinus Torvalds .attrs = default_attrs,
1821da177e4SLinus Torvalds .name = "stats"
1831da177e4SLinus Torvalds };
1841da177e4SLinus Torvalds
freq_table_get_index(struct cpufreq_stats * stats,unsigned int freq)18550941607SViresh Kumar static int freq_table_get_index(struct cpufreq_stats *stats, unsigned int freq)
1861da177e4SLinus Torvalds {
1871da177e4SLinus Torvalds int index;
18850941607SViresh Kumar for (index = 0; index < stats->max_state; index++)
18950941607SViresh Kumar if (stats->freq_table[index] == freq)
1901da177e4SLinus Torvalds return index;
1911da177e4SLinus Torvalds return -1;
1921da177e4SLinus Torvalds }
1931da177e4SLinus Torvalds
cpufreq_stats_free_table(struct cpufreq_policy * policy)1941aefc75bSRafael J. Wysocki void cpufreq_stats_free_table(struct cpufreq_policy *policy)
1951da177e4SLinus Torvalds {
19650941607SViresh Kumar struct cpufreq_stats *stats = policy->stats;
197b8eed8afSViresh Kumar
198a9aaf291SViresh Kumar /* Already freed */
19950941607SViresh Kumar if (!stats)
2002d13594dSViresh Kumar return;
2012d13594dSViresh Kumar
20250941607SViresh Kumar pr_debug("%s: Free stats table\n", __func__);
2032d13594dSViresh Kumar
2042d13594dSViresh Kumar sysfs_remove_group(&policy->kobj, &stats_attr_group);
20550941607SViresh Kumar kfree(stats->time_in_state);
20650941607SViresh Kumar kfree(stats);
207a9aaf291SViresh Kumar policy->stats = NULL;
208b8eed8afSViresh Kumar }
20998586ed8Ssteven finney
cpufreq_stats_create_table(struct cpufreq_policy * policy)2101aefc75bSRafael J. Wysocki void cpufreq_stats_create_table(struct cpufreq_policy *policy)
2111da177e4SLinus Torvalds {
2125de12625SShaokun Zhang unsigned int i = 0, count;
21350941607SViresh Kumar struct cpufreq_stats *stats;
2141da177e4SLinus Torvalds unsigned int alloc_size;
21555d85293SViresh Kumar struct cpufreq_frequency_table *pos;
216ad4c2302SSaravana Kannan
21755d85293SViresh Kumar count = cpufreq_table_count_valid_entries(policy);
21855d85293SViresh Kumar if (!count)
2191aefc75bSRafael J. Wysocki return;
220ad4c2302SSaravana Kannan
221b8c67448SViresh Kumar /* stats already initialized */
222a9aaf291SViresh Kumar if (policy->stats)
2231aefc75bSRafael J. Wysocki return;
224b8c67448SViresh Kumar
22550941607SViresh Kumar stats = kzalloc(sizeof(*stats), GFP_KERNEL);
226a685c6d0SViresh Kumar if (!stats)
2271aefc75bSRafael J. Wysocki return;
2281da177e4SLinus Torvalds
2291e7586a1SViresh Kumar alloc_size = count * sizeof(int) + count * sizeof(u64);
2301da177e4SLinus Torvalds
2311da177e4SLinus Torvalds alloc_size += count * count * sizeof(int);
232a685c6d0SViresh Kumar
233a685c6d0SViresh Kumar /* Allocate memory for time_in_state/freq_table/trans_table in one go */
23450941607SViresh Kumar stats->time_in_state = kzalloc(alloc_size, GFP_KERNEL);
235a685c6d0SViresh Kumar if (!stats->time_in_state)
236a685c6d0SViresh Kumar goto free_stat;
237a685c6d0SViresh Kumar
23850941607SViresh Kumar stats->freq_table = (unsigned int *)(stats->time_in_state + count);
2391da177e4SLinus Torvalds
24050941607SViresh Kumar stats->trans_table = stats->freq_table + count;
241a685c6d0SViresh Kumar
242a685c6d0SViresh Kumar stats->max_state = count;
243a685c6d0SViresh Kumar
244a685c6d0SViresh Kumar /* Find valid-unique entries */
24555d85293SViresh Kumar cpufreq_for_each_valid_entry(pos, policy->freq_table)
246ed957164SLiao Chang if (policy->freq_table_sorted != CPUFREQ_TABLE_UNSORTED ||
247ed957164SLiao Chang freq_table_get_index(stats, pos->frequency) == -1)
24850941607SViresh Kumar stats->freq_table[i++] = pos->frequency;
249a685c6d0SViresh Kumar
250490285c6SViresh Kumar stats->state_num = i;
2517854c752SViresh Kumar stats->last_time = local_clock();
25250941607SViresh Kumar stats->last_index = freq_table_get_index(stats, policy->cur);
253a685c6d0SViresh Kumar
254a685c6d0SViresh Kumar policy->stats = stats;
2555de12625SShaokun Zhang if (!sysfs_create_group(&policy->kobj, &stats_attr_group))
2561aefc75bSRafael J. Wysocki return;
257a685c6d0SViresh Kumar
258a685c6d0SViresh Kumar /* We failed, release resources */
259a9aaf291SViresh Kumar policy->stats = NULL;
260a685c6d0SViresh Kumar kfree(stats->time_in_state);
261a685c6d0SViresh Kumar free_stat:
262a685c6d0SViresh Kumar kfree(stats);
2631da177e4SLinus Torvalds }
2641da177e4SLinus Torvalds
cpufreq_stats_record_transition(struct cpufreq_policy * policy,unsigned int new_freq)2651aefc75bSRafael J. Wysocki void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
2661aefc75bSRafael J. Wysocki unsigned int new_freq)
267b3f9ff88SViresh Kumar {
2681aefc75bSRafael J. Wysocki struct cpufreq_stats *stats = policy->stats;
2691da177e4SLinus Torvalds int old_index, new_index;
2701da177e4SLinus Torvalds
2714958b46eSViresh Kumar if (unlikely(!stats))
2721aefc75bSRafael J. Wysocki return;
27340c3bd4cSViresh Kumar
27440c3bd4cSViresh Kumar if (unlikely(READ_ONCE(stats->reset_pending)))
27540c3bd4cSViresh Kumar cpufreq_stats_reset_table(stats);
276a9aaf291SViresh Kumar
27750941607SViresh Kumar old_index = stats->last_index;
2781aefc75bSRafael J. Wysocki new_index = freq_table_get_index(stats, new_freq);
2791da177e4SLinus Torvalds
28050941607SViresh Kumar /* We can't do stats->time_in_state[-1]= .. */
2814958b46eSViresh Kumar if (unlikely(old_index == -1 || new_index == -1 || old_index == new_index))
2821aefc75bSRafael J. Wysocki return;
2838edc59d9SVenkatesh Pallipadi
28440c3bd4cSViresh Kumar cpufreq_stats_update(stats, stats->last_time);
285e7347694SViresh Kumar
28650941607SViresh Kumar stats->last_index = new_index;
28750941607SViresh Kumar stats->trans_table[old_index * stats->max_state + new_index]++;
28850941607SViresh Kumar stats->total_trans++;
2891da177e4SLinus Torvalds }
290