1103a8feaSLen Brown /*
2103a8feaSLen Brown  * turbostat -- show CPU frequency and C-state residency
3103a8feaSLen Brown  * on modern Intel turbo-capable processors.
4103a8feaSLen Brown  *
5144b44b1SLen Brown  * Copyright (c) 2013 Intel Corporation.
6103a8feaSLen Brown  * Len Brown <len.brown@intel.com>
7103a8feaSLen Brown  *
8103a8feaSLen Brown  * This program is free software; you can redistribute it and/or modify it
9103a8feaSLen Brown  * under the terms and conditions of the GNU General Public License,
10103a8feaSLen Brown  * version 2, as published by the Free Software Foundation.
11103a8feaSLen Brown  *
12103a8feaSLen Brown  * This program is distributed in the hope it will be useful, but WITHOUT
13103a8feaSLen Brown  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14103a8feaSLen Brown  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15103a8feaSLen Brown  * more details.
16103a8feaSLen Brown  *
17103a8feaSLen Brown  * You should have received a copy of the GNU General Public License along with
18103a8feaSLen Brown  * this program; if not, write to the Free Software Foundation, Inc.,
19103a8feaSLen Brown  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
20103a8feaSLen Brown  */
21103a8feaSLen Brown 
2288c3281fSLen Brown #define _GNU_SOURCE
23b731f311SJosh Triplett #include MSRHEADER
24869ce69eSLen Brown #include INTEL_FAMILY_HEADER
2595aebc44SJosh Triplett #include <stdarg.h>
26103a8feaSLen Brown #include <stdio.h>
27b2c95d90SJosh Triplett #include <err.h>
28103a8feaSLen Brown #include <unistd.h>
29103a8feaSLen Brown #include <sys/types.h>
30103a8feaSLen Brown #include <sys/wait.h>
31103a8feaSLen Brown #include <sys/stat.h>
32103a8feaSLen Brown #include <sys/resource.h>
33103a8feaSLen Brown #include <fcntl.h>
34103a8feaSLen Brown #include <signal.h>
35103a8feaSLen Brown #include <sys/time.h>
36103a8feaSLen Brown #include <stdlib.h>
37d8af6f5fSLen Brown #include <getopt.h>
38103a8feaSLen Brown #include <dirent.h>
39103a8feaSLen Brown #include <string.h>
40103a8feaSLen Brown #include <ctype.h>
4188c3281fSLen Brown #include <sched.h>
422a0609c0SLen Brown #include <time.h>
432b92865eSJosh Triplett #include <cpuid.h>
4498481e79SLen Brown #include <linux/capability.h>
4598481e79SLen Brown #include <errno.h>
46103a8feaSLen Brown 
47103a8feaSLen Brown char *proc_stat = "/proc/stat";
48b7d8c148SLen Brown FILE *outf;
4936229897SLen Brown int *fd_percpu;
502a0609c0SLen Brown struct timespec interval_ts = {5, 0};
51d8af6f5fSLen Brown unsigned int debug;
52d8af6f5fSLen Brown unsigned int rapl_joules;
53d8af6f5fSLen Brown unsigned int summary_only;
54d8af6f5fSLen Brown unsigned int dump_only;
55103a8feaSLen Brown unsigned int do_snb_cstates;
56fb5d4327SDasaratharaman Chandramouli unsigned int do_knl_cstates;
57ee7e38e3SLen Brown unsigned int do_pc2;
58ee7e38e3SLen Brown unsigned int do_pc3;
59ee7e38e3SLen Brown unsigned int do_pc6;
60ee7e38e3SLen Brown unsigned int do_pc7;
61ca58710fSKristen Carlson Accardi unsigned int do_c8_c9_c10;
620b2bb692SLen Brown unsigned int do_skl_residency;
63144b44b1SLen Brown unsigned int do_slm_cstates;
64144b44b1SLen Brown unsigned int use_c1_residency_msr;
65103a8feaSLen Brown unsigned int has_aperf;
66889facbeSLen Brown unsigned int has_epb;
675a63426eSLen Brown unsigned int do_irtl_snb;
685a63426eSLen Brown unsigned int do_irtl_hsw;
69fc04cc67SLen Brown unsigned int units = 1000000;	/* MHz etc */
70103a8feaSLen Brown unsigned int genuine_intel;
71103a8feaSLen Brown unsigned int has_invariant_tsc;
72d7899447SLen Brown unsigned int do_nhm_platform_info;
73cf4cbe53SLen Brown unsigned int no_MSR_MISC_PWR_MGMT;
74b2b34dfeSHubert Chrzaniuk unsigned int aperf_mperf_multiplier = 1;
75103a8feaSLen Brown double bclk;
76a2b7b749SLen Brown double base_hz;
7721ed5574SLen Brown unsigned int has_base_hz;
78a2b7b749SLen Brown double tsc_tweak = 1.0;
79c98d5d94SLen Brown unsigned int show_pkg_only;
80c98d5d94SLen Brown unsigned int show_core_only;
81c98d5d94SLen Brown char *output_buffer, *outp;
82889facbeSLen Brown unsigned int do_rapl;
83889facbeSLen Brown unsigned int do_dts;
84889facbeSLen Brown unsigned int do_ptm;
85fdf676e5SLen Brown unsigned long long  gfx_cur_rc6_ms;
8627d47356SLen Brown unsigned int gfx_cur_mhz;
87889facbeSLen Brown unsigned int tcc_activation_temp;
88889facbeSLen Brown unsigned int tcc_activation_temp_override;
8940ee8e3bSAndrey Semin double rapl_power_units, rapl_time_units;
9040ee8e3bSAndrey Semin double rapl_dram_energy_units, rapl_energy_units;
91889facbeSLen Brown double rapl_joule_counter_range;
923a9a941dSLen Brown unsigned int do_core_perf_limit_reasons;
933a9a941dSLen Brown unsigned int do_gfx_perf_limit_reasons;
943a9a941dSLen Brown unsigned int do_ring_perf_limit_reasons;
958a5bdf41SLen Brown unsigned int crystal_hz;
968a5bdf41SLen Brown unsigned long long tsc_hz;
977ce7d5deSPrarit Bhargava int base_cpu;
9821ed5574SLen Brown double discover_bclk(unsigned int family, unsigned int model);
997f5c258eSLen Brown unsigned int has_hwp;	/* IA32_PM_ENABLE, IA32_HWP_CAPABILITIES */
1007f5c258eSLen Brown 			/* IA32_HWP_REQUEST, IA32_HWP_STATUS */
1017f5c258eSLen Brown unsigned int has_hwp_notify;		/* IA32_HWP_INTERRUPT */
1027f5c258eSLen Brown unsigned int has_hwp_activity_window;	/* IA32_HWP_REQUEST[bits 41:32] */
1037f5c258eSLen Brown unsigned int has_hwp_epp;		/* IA32_HWP_REQUEST[bits 31:24] */
1047f5c258eSLen Brown unsigned int has_hwp_pkg;		/* IA32_HWP_REQUEST_PKG */
105*33148d67SLen Brown unsigned int has_misc_feature_control;
106889facbeSLen Brown 
107889facbeSLen Brown #define RAPL_PKG		(1 << 0)
108e6f9bb3cSLen Brown 					/* 0x610 MSR_PKG_POWER_LIMIT */
109e6f9bb3cSLen Brown 					/* 0x611 MSR_PKG_ENERGY_STATUS */
110e6f9bb3cSLen Brown #define RAPL_PKG_PERF_STATUS	(1 << 1)
111e6f9bb3cSLen Brown 					/* 0x613 MSR_PKG_PERF_STATUS */
112e6f9bb3cSLen Brown #define RAPL_PKG_POWER_INFO	(1 << 2)
113e6f9bb3cSLen Brown 					/* 0x614 MSR_PKG_POWER_INFO */
114e6f9bb3cSLen Brown 
115889facbeSLen Brown #define RAPL_DRAM		(1 << 3)
116e6f9bb3cSLen Brown 					/* 0x618 MSR_DRAM_POWER_LIMIT */
117e6f9bb3cSLen Brown 					/* 0x619 MSR_DRAM_ENERGY_STATUS */
118e6f9bb3cSLen Brown #define RAPL_DRAM_PERF_STATUS	(1 << 4)
119e6f9bb3cSLen Brown 					/* 0x61b MSR_DRAM_PERF_STATUS */
1200b2bb692SLen Brown #define RAPL_DRAM_POWER_INFO	(1 << 5)
1210b2bb692SLen Brown 					/* 0x61c MSR_DRAM_POWER_INFO */
122e6f9bb3cSLen Brown 
1239148494cSJacob Pan #define RAPL_CORES_POWER_LIMIT	(1 << 6)
124e6f9bb3cSLen Brown 					/* 0x638 MSR_PP0_POWER_LIMIT */
1250b2bb692SLen Brown #define RAPL_CORE_POLICY	(1 << 7)
126e6f9bb3cSLen Brown 					/* 0x63a MSR_PP0_POLICY */
127e6f9bb3cSLen Brown 
1280b2bb692SLen Brown #define RAPL_GFX		(1 << 8)
129e6f9bb3cSLen Brown 					/* 0x640 MSR_PP1_POWER_LIMIT */
130e6f9bb3cSLen Brown 					/* 0x641 MSR_PP1_ENERGY_STATUS */
131e6f9bb3cSLen Brown 					/* 0x642 MSR_PP1_POLICY */
1329148494cSJacob Pan 
1339148494cSJacob Pan #define RAPL_CORES_ENERGY_STATUS	(1 << 9)
1349148494cSJacob Pan 					/* 0x639 MSR_PP0_ENERGY_STATUS */
1359148494cSJacob Pan #define RAPL_CORES (RAPL_CORES_ENERGY_STATUS | RAPL_CORES_POWER_LIMIT)
136889facbeSLen Brown #define	TJMAX_DEFAULT	100
137889facbeSLen Brown 
138889facbeSLen Brown #define MAX(a, b) ((a) > (b) ? (a) : (b))
139103a8feaSLen Brown 
140388e9c81SLen Brown /*
141388e9c81SLen Brown  * buffer size used by sscanf() for added column names
142388e9c81SLen Brown  * Usually truncated to 7 characters, but also handles 18 columns for raw 64-bit counters
143388e9c81SLen Brown  */
144388e9c81SLen Brown #define	NAME_BYTES 20
145388e9c81SLen Brown 
146103a8feaSLen Brown int backwards_count;
147103a8feaSLen Brown char *progname;
148103a8feaSLen Brown 
149c98d5d94SLen Brown cpu_set_t *cpu_present_set, *cpu_affinity_set;
150c98d5d94SLen Brown size_t cpu_present_setsize, cpu_affinity_setsize;
151678a3bd1SLen Brown #define MAX_ADDED_COUNTERS 16
152c98d5d94SLen Brown 
153c98d5d94SLen Brown struct thread_data {
154c98d5d94SLen Brown 	unsigned long long tsc;
155c98d5d94SLen Brown 	unsigned long long aperf;
156c98d5d94SLen Brown 	unsigned long long mperf;
157144b44b1SLen Brown 	unsigned long long c1;
158562a2d37SLen Brown 	unsigned int irq_count;
1591ed51011SLen Brown 	unsigned int smi_count;
160c98d5d94SLen Brown 	unsigned int cpu_id;
161c98d5d94SLen Brown 	unsigned int flags;
162c98d5d94SLen Brown #define CPU_IS_FIRST_THREAD_IN_CORE	0x2
163c98d5d94SLen Brown #define CPU_IS_FIRST_CORE_IN_PACKAGE	0x4
164678a3bd1SLen Brown 	unsigned long long counter[MAX_ADDED_COUNTERS];
165c98d5d94SLen Brown } *thread_even, *thread_odd;
166c98d5d94SLen Brown 
167c98d5d94SLen Brown struct core_data {
168c98d5d94SLen Brown 	unsigned long long c3;
169c98d5d94SLen Brown 	unsigned long long c6;
170c98d5d94SLen Brown 	unsigned long long c7;
1710539ba11SLen Brown 	unsigned long long mc6_us;	/* duplicate as per-core for now, even though per module */
172889facbeSLen Brown 	unsigned int core_temp_c;
173c98d5d94SLen Brown 	unsigned int core_id;
174678a3bd1SLen Brown 	unsigned long long counter[MAX_ADDED_COUNTERS];
175c98d5d94SLen Brown } *core_even, *core_odd;
176c98d5d94SLen Brown 
177c98d5d94SLen Brown struct pkg_data {
178c98d5d94SLen Brown 	unsigned long long pc2;
179c98d5d94SLen Brown 	unsigned long long pc3;
180c98d5d94SLen Brown 	unsigned long long pc6;
181c98d5d94SLen Brown 	unsigned long long pc7;
182ca58710fSKristen Carlson Accardi 	unsigned long long pc8;
183ca58710fSKristen Carlson Accardi 	unsigned long long pc9;
184ca58710fSKristen Carlson Accardi 	unsigned long long pc10;
1850b2bb692SLen Brown 	unsigned long long pkg_wtd_core_c0;
1860b2bb692SLen Brown 	unsigned long long pkg_any_core_c0;
1870b2bb692SLen Brown 	unsigned long long pkg_any_gfxe_c0;
1880b2bb692SLen Brown 	unsigned long long pkg_both_core_gfxe_c0;
1899185e988SLen Brown 	long long gfx_rc6_ms;
19027d47356SLen Brown 	unsigned int gfx_mhz;
191c98d5d94SLen Brown 	unsigned int package_id;
192889facbeSLen Brown 	unsigned int energy_pkg;	/* MSR_PKG_ENERGY_STATUS */
193889facbeSLen Brown 	unsigned int energy_dram;	/* MSR_DRAM_ENERGY_STATUS */
194889facbeSLen Brown 	unsigned int energy_cores;	/* MSR_PP0_ENERGY_STATUS */
195889facbeSLen Brown 	unsigned int energy_gfx;	/* MSR_PP1_ENERGY_STATUS */
196889facbeSLen Brown 	unsigned int rapl_pkg_perf_status;	/* MSR_PKG_PERF_STATUS */
197889facbeSLen Brown 	unsigned int rapl_dram_perf_status;	/* MSR_DRAM_PERF_STATUS */
198889facbeSLen Brown 	unsigned int pkg_temp_c;
199678a3bd1SLen Brown 	unsigned long long counter[MAX_ADDED_COUNTERS];
200c98d5d94SLen Brown } *package_even, *package_odd;
201c98d5d94SLen Brown 
202c98d5d94SLen Brown #define ODD_COUNTERS thread_odd, core_odd, package_odd
203c98d5d94SLen Brown #define EVEN_COUNTERS thread_even, core_even, package_even
204c98d5d94SLen Brown 
205c98d5d94SLen Brown #define GET_THREAD(thread_base, thread_no, core_no, pkg_no) \
206c98d5d94SLen Brown 	(thread_base + (pkg_no) * topo.num_cores_per_pkg * \
207c98d5d94SLen Brown 		topo.num_threads_per_core + \
208c98d5d94SLen Brown 		(core_no) * topo.num_threads_per_core + (thread_no))
209c98d5d94SLen Brown #define GET_CORE(core_base, core_no, pkg_no) \
210c98d5d94SLen Brown 	(core_base + (pkg_no) * topo.num_cores_per_pkg + (core_no))
211c98d5d94SLen Brown #define GET_PKG(pkg_base, pkg_no) (pkg_base + pkg_no)
212c98d5d94SLen Brown 
213388e9c81SLen Brown enum counter_scope {SCOPE_CPU, SCOPE_CORE, SCOPE_PACKAGE};
214388e9c81SLen Brown enum counter_type {COUNTER_CYCLES, COUNTER_SECONDS};
215388e9c81SLen Brown enum counter_format {FORMAT_RAW, FORMAT_DELTA, FORMAT_PERCENT};
216388e9c81SLen Brown 
217388e9c81SLen Brown struct msr_counter {
218388e9c81SLen Brown 	unsigned int msr_num;
219388e9c81SLen Brown 	char name[NAME_BYTES];
220388e9c81SLen Brown 	unsigned int width;
221388e9c81SLen Brown 	enum counter_type type;
222388e9c81SLen Brown 	enum counter_format format;
223388e9c81SLen Brown 	struct msr_counter *next;
224812db3f7SLen Brown 	unsigned int flags;
225812db3f7SLen Brown #define	FLAGS_HIDE	(1 << 0)
226812db3f7SLen Brown #define	FLAGS_SHOW	(1 << 1)
227388e9c81SLen Brown };
228388e9c81SLen Brown 
229388e9c81SLen Brown struct sys_counters {
230678a3bd1SLen Brown 	unsigned int added_thread_counters;
231678a3bd1SLen Brown 	unsigned int added_core_counters;
232678a3bd1SLen Brown 	unsigned int added_package_counters;
233388e9c81SLen Brown 	struct msr_counter *tp;
234388e9c81SLen Brown 	struct msr_counter *cp;
235388e9c81SLen Brown 	struct msr_counter *pp;
236388e9c81SLen Brown } sys;
237388e9c81SLen Brown 
238c98d5d94SLen Brown struct system_summary {
239c98d5d94SLen Brown 	struct thread_data threads;
240c98d5d94SLen Brown 	struct core_data cores;
241c98d5d94SLen Brown 	struct pkg_data packages;
242388e9c81SLen Brown } average;
243c98d5d94SLen Brown 
244c98d5d94SLen Brown 
245c98d5d94SLen Brown struct topo_params {
246c98d5d94SLen Brown 	int num_packages;
247103a8feaSLen Brown 	int num_cpus;
248c98d5d94SLen Brown 	int num_cores;
249c98d5d94SLen Brown 	int max_cpu_num;
250c98d5d94SLen Brown 	int num_cores_per_pkg;
251c98d5d94SLen Brown 	int num_threads_per_core;
252c98d5d94SLen Brown } topo;
253103a8feaSLen Brown 
254c98d5d94SLen Brown struct timeval tv_even, tv_odd, tv_delta;
255103a8feaSLen Brown 
256562a2d37SLen Brown int *irq_column_2_cpu;	/* /proc/interrupts column numbers */
257562a2d37SLen Brown int *irqs_per_cpu;		/* indexed by cpu_num */
258562a2d37SLen Brown 
259c98d5d94SLen Brown void setup_all_buffers(void);
260103a8feaSLen Brown 
261c98d5d94SLen Brown int cpu_is_not_present(int cpu)
262d15cf7c1SLen Brown {
263c98d5d94SLen Brown 	return !CPU_ISSET_S(cpu, cpu_present_setsize, cpu_present_set);
264c98d5d94SLen Brown }
265c98d5d94SLen Brown /*
266c98d5d94SLen Brown  * run func(thread, core, package) in topology order
267c98d5d94SLen Brown  * skip non-present cpus
268c98d5d94SLen Brown  */
269c98d5d94SLen Brown 
270c98d5d94SLen Brown int for_all_cpus(int (func)(struct thread_data *, struct core_data *, struct pkg_data *),
271c98d5d94SLen Brown 	struct thread_data *thread_base, struct core_data *core_base, struct pkg_data *pkg_base)
272c98d5d94SLen Brown {
273c98d5d94SLen Brown 	int retval, pkg_no, core_no, thread_no;
274c98d5d94SLen Brown 
275c98d5d94SLen Brown 	for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
276c98d5d94SLen Brown 		for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
277c98d5d94SLen Brown 			for (thread_no = 0; thread_no <
278c98d5d94SLen Brown 				topo.num_threads_per_core; ++thread_no) {
279c98d5d94SLen Brown 				struct thread_data *t;
280c98d5d94SLen Brown 				struct core_data *c;
281c98d5d94SLen Brown 				struct pkg_data *p;
282c98d5d94SLen Brown 
283c98d5d94SLen Brown 				t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
284c98d5d94SLen Brown 
285c98d5d94SLen Brown 				if (cpu_is_not_present(t->cpu_id))
286c98d5d94SLen Brown 					continue;
287c98d5d94SLen Brown 
288c98d5d94SLen Brown 				c = GET_CORE(core_base, core_no, pkg_no);
289c98d5d94SLen Brown 				p = GET_PKG(pkg_base, pkg_no);
290c98d5d94SLen Brown 
291c98d5d94SLen Brown 				retval = func(t, c, p);
292c98d5d94SLen Brown 				if (retval)
293c98d5d94SLen Brown 					return retval;
294c98d5d94SLen Brown 			}
295c98d5d94SLen Brown 		}
296c98d5d94SLen Brown 	}
297d15cf7c1SLen Brown 	return 0;
298d15cf7c1SLen Brown }
299d15cf7c1SLen Brown 
30088c3281fSLen Brown int cpu_migrate(int cpu)
30188c3281fSLen Brown {
302c98d5d94SLen Brown 	CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
303c98d5d94SLen Brown 	CPU_SET_S(cpu, cpu_affinity_setsize, cpu_affinity_set);
304c98d5d94SLen Brown 	if (sched_setaffinity(0, cpu_affinity_setsize, cpu_affinity_set) == -1)
30588c3281fSLen Brown 		return -1;
30688c3281fSLen Brown 	else
30788c3281fSLen Brown 		return 0;
30888c3281fSLen Brown }
30936229897SLen Brown int get_msr_fd(int cpu)
310103a8feaSLen Brown {
311103a8feaSLen Brown 	char pathname[32];
312103a8feaSLen Brown 	int fd;
313103a8feaSLen Brown 
31436229897SLen Brown 	fd = fd_percpu[cpu];
31536229897SLen Brown 
31636229897SLen Brown 	if (fd)
31736229897SLen Brown 		return fd;
31836229897SLen Brown 
319103a8feaSLen Brown 	sprintf(pathname, "/dev/cpu/%d/msr", cpu);
320103a8feaSLen Brown 	fd = open(pathname, O_RDONLY);
32115aaa346SLen Brown 	if (fd < 0)
32298481e79SLen Brown 		err(-1, "%s open failed, try chown or chmod +r /dev/cpu/*/msr, or run as root", pathname);
323103a8feaSLen Brown 
32436229897SLen Brown 	fd_percpu[cpu] = fd;
32536229897SLen Brown 
32636229897SLen Brown 	return fd;
32736229897SLen Brown }
32836229897SLen Brown 
32936229897SLen Brown int get_msr(int cpu, off_t offset, unsigned long long *msr)
33036229897SLen Brown {
33136229897SLen Brown 	ssize_t retval;
33236229897SLen Brown 
33336229897SLen Brown 	retval = pread(get_msr_fd(cpu), msr, sizeof(*msr), offset);
33415aaa346SLen Brown 
33598481e79SLen Brown 	if (retval != sizeof *msr)
336cf4cbe53SLen Brown 		err(-1, "cpu%d: msr offset 0x%llx read failed", cpu, (unsigned long long)offset);
33715aaa346SLen Brown 
33815aaa346SLen Brown 	return 0;
339103a8feaSLen Brown }
340103a8feaSLen Brown 
341fc04cc67SLen Brown /*
342812db3f7SLen Brown  * Each string in this array is compared in --show and --hide cmdline.
343812db3f7SLen Brown  * Thus, strings that are proper sub-sets must follow their more specific peers.
344fc04cc67SLen Brown  */
345812db3f7SLen Brown struct msr_counter bic[] = {
346812db3f7SLen Brown 	{ 0x0, "Package" },
347812db3f7SLen Brown 	{ 0x0, "Avg_MHz" },
348812db3f7SLen Brown 	{ 0x0, "Bzy_MHz" },
349812db3f7SLen Brown 	{ 0x0, "TSC_MHz" },
350812db3f7SLen Brown 	{ 0x0, "IRQ" },
351812db3f7SLen Brown 	{ 0x0, "SMI", 32, 0, FORMAT_DELTA, NULL},
352812db3f7SLen Brown 	{ 0x0, "Busy%" },
353812db3f7SLen Brown 	{ 0x0, "CPU%c1" },
354812db3f7SLen Brown 	{ 0x0, "CPU%c3" },
355812db3f7SLen Brown 	{ 0x0, "CPU%c6" },
356812db3f7SLen Brown 	{ 0x0, "CPU%c7" },
357812db3f7SLen Brown 	{ 0x0, "ThreadC" },
358812db3f7SLen Brown 	{ 0x0, "CoreTmp" },
359812db3f7SLen Brown 	{ 0x0, "CoreCnt" },
360812db3f7SLen Brown 	{ 0x0, "PkgTmp" },
361812db3f7SLen Brown 	{ 0x0, "GFX%rc6" },
362812db3f7SLen Brown 	{ 0x0, "GFXMHz" },
363812db3f7SLen Brown 	{ 0x0, "Pkg%pc2" },
364812db3f7SLen Brown 	{ 0x0, "Pkg%pc3" },
365812db3f7SLen Brown 	{ 0x0, "Pkg%pc6" },
366812db3f7SLen Brown 	{ 0x0, "Pkg%pc7" },
367812db3f7SLen Brown 	{ 0x0, "PkgWatt" },
368812db3f7SLen Brown 	{ 0x0, "CorWatt" },
369812db3f7SLen Brown 	{ 0x0, "GFXWatt" },
370812db3f7SLen Brown 	{ 0x0, "PkgCnt" },
371812db3f7SLen Brown 	{ 0x0, "RAMWatt" },
372812db3f7SLen Brown 	{ 0x0, "PKG_%" },
373812db3f7SLen Brown 	{ 0x0, "RAM_%" },
374812db3f7SLen Brown 	{ 0x0, "Pkg_J" },
375812db3f7SLen Brown 	{ 0x0, "Cor_J" },
376812db3f7SLen Brown 	{ 0x0, "GFX_J" },
377812db3f7SLen Brown 	{ 0x0, "RAM_J" },
378812db3f7SLen Brown 	{ 0x0, "Core" },
379812db3f7SLen Brown 	{ 0x0, "CPU" },
3800539ba11SLen Brown 	{ 0x0, "Mod%c6" },
381812db3f7SLen Brown };
382812db3f7SLen Brown 
383812db3f7SLen Brown #define MAX_BIC (sizeof(bic) / sizeof(struct msr_counter))
384812db3f7SLen Brown #define	BIC_Package	(1ULL << 0)
385812db3f7SLen Brown #define	BIC_Avg_MHz	(1ULL << 1)
386812db3f7SLen Brown #define	BIC_Bzy_MHz	(1ULL << 2)
387812db3f7SLen Brown #define	BIC_TSC_MHz	(1ULL << 3)
388812db3f7SLen Brown #define	BIC_IRQ		(1ULL << 4)
389812db3f7SLen Brown #define	BIC_SMI		(1ULL << 5)
390812db3f7SLen Brown #define	BIC_Busy	(1ULL << 6)
391812db3f7SLen Brown #define	BIC_CPU_c1	(1ULL << 7)
392812db3f7SLen Brown #define	BIC_CPU_c3	(1ULL << 8)
393812db3f7SLen Brown #define	BIC_CPU_c6	(1ULL << 9)
394812db3f7SLen Brown #define	BIC_CPU_c7	(1ULL << 10)
395812db3f7SLen Brown #define	BIC_ThreadC	(1ULL << 11)
396812db3f7SLen Brown #define	BIC_CoreTmp	(1ULL << 12)
397812db3f7SLen Brown #define	BIC_CoreCnt	(1ULL << 13)
398812db3f7SLen Brown #define	BIC_PkgTmp	(1ULL << 14)
399812db3f7SLen Brown #define	BIC_GFX_rc6	(1ULL << 15)
400812db3f7SLen Brown #define	BIC_GFXMHz	(1ULL << 16)
401812db3f7SLen Brown #define	BIC_Pkgpc2	(1ULL << 17)
402812db3f7SLen Brown #define	BIC_Pkgpc3	(1ULL << 18)
403812db3f7SLen Brown #define	BIC_Pkgpc6	(1ULL << 19)
404812db3f7SLen Brown #define	BIC_Pkgpc7	(1ULL << 20)
405812db3f7SLen Brown #define	BIC_PkgWatt	(1ULL << 21)
406812db3f7SLen Brown #define	BIC_CorWatt	(1ULL << 22)
407812db3f7SLen Brown #define	BIC_GFXWatt	(1ULL << 23)
408812db3f7SLen Brown #define	BIC_PkgCnt	(1ULL << 24)
409812db3f7SLen Brown #define	BIC_RAMWatt	(1ULL << 27)
410812db3f7SLen Brown #define	BIC_PKG__	(1ULL << 28)
411812db3f7SLen Brown #define	BIC_RAM__	(1ULL << 29)
412812db3f7SLen Brown #define	BIC_Pkg_J	(1ULL << 30)
413812db3f7SLen Brown #define	BIC_Cor_J	(1ULL << 31)
414812db3f7SLen Brown #define	BIC_GFX_J	(1ULL << 30)
415812db3f7SLen Brown #define	BIC_RAM_J	(1ULL << 31)
416812db3f7SLen Brown #define	BIC_Core	(1ULL << 32)
417812db3f7SLen Brown #define	BIC_CPU		(1ULL << 33)
4180539ba11SLen Brown #define	BIC_Mod_c6	(1ULL << 34)
419812db3f7SLen Brown 
420812db3f7SLen Brown unsigned long long bic_enabled = 0xFFFFFFFFFFFFFFFFULL;
421812db3f7SLen Brown unsigned long long bic_present;
422812db3f7SLen Brown 
423812db3f7SLen Brown #define DO_BIC(COUNTER_NAME) (bic_enabled & bic_present & COUNTER_NAME)
424812db3f7SLen Brown #define BIC_PRESENT(COUNTER_BIT) (bic_present |= COUNTER_BIT)
425812db3f7SLen Brown 
426812db3f7SLen Brown /*
427812db3f7SLen Brown  * bic_lookup
428812db3f7SLen Brown  * for all the strings in comma separate name_list,
429812db3f7SLen Brown  * set the approprate bit in return value.
430812db3f7SLen Brown  */
431812db3f7SLen Brown unsigned long long bic_lookup(char *name_list)
432812db3f7SLen Brown {
433812db3f7SLen Brown 	int i;
434812db3f7SLen Brown 	unsigned long long retval = 0;
435812db3f7SLen Brown 
436812db3f7SLen Brown 	while (name_list) {
437812db3f7SLen Brown 		char *comma;
438812db3f7SLen Brown 
439812db3f7SLen Brown 		comma = strchr(name_list, ',');
440812db3f7SLen Brown 
441812db3f7SLen Brown 		if (comma)
442812db3f7SLen Brown 			*comma = '\0';
443812db3f7SLen Brown 
444812db3f7SLen Brown 		for (i = 0; i < MAX_BIC; ++i) {
445812db3f7SLen Brown 			if (!strcmp(name_list, bic[i].name)) {
446812db3f7SLen Brown 				retval |= (1ULL << i);
447812db3f7SLen Brown 				break;
448812db3f7SLen Brown 			}
449812db3f7SLen Brown 		}
450812db3f7SLen Brown 		if (i == MAX_BIC) {
451812db3f7SLen Brown 			fprintf(stderr, "Invalid counter name: %s\n", name_list);
452812db3f7SLen Brown 			exit(-1);
453812db3f7SLen Brown 		}
454812db3f7SLen Brown 
455812db3f7SLen Brown 		name_list = comma;
456812db3f7SLen Brown 		if (name_list)
457812db3f7SLen Brown 			name_list++;
458812db3f7SLen Brown 
459812db3f7SLen Brown 	}
460812db3f7SLen Brown 	return retval;
461812db3f7SLen Brown }
462fc04cc67SLen Brown 
463a829eb4dSLen Brown void print_header(void)
464103a8feaSLen Brown {
465388e9c81SLen Brown 	struct msr_counter *mp;
466388e9c81SLen Brown 
467812db3f7SLen Brown 	if (DO_BIC(BIC_Package))
4683d109de2SLen Brown 		outp += sprintf(outp, "\tPackage");
469812db3f7SLen Brown 	if (DO_BIC(BIC_Core))
4703d109de2SLen Brown 		outp += sprintf(outp, "\tCore");
471812db3f7SLen Brown 	if (DO_BIC(BIC_CPU))
4723d109de2SLen Brown 		outp += sprintf(outp, "\tCPU");
473812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz))
4743d109de2SLen Brown 		outp += sprintf(outp, "\tAvg_MHz");
475812db3f7SLen Brown 	if (DO_BIC(BIC_Busy))
4763d109de2SLen Brown 		outp += sprintf(outp, "\tBusy%%");
477812db3f7SLen Brown 	if (DO_BIC(BIC_Bzy_MHz))
4783d109de2SLen Brown 		outp += sprintf(outp, "\tBzy_MHz");
479812db3f7SLen Brown 	if (DO_BIC(BIC_TSC_MHz))
4803d109de2SLen Brown 		outp += sprintf(outp, "\tTSC_MHz");
4811cc21f7bSLen Brown 
4821cc21f7bSLen Brown 	if (!debug)
4831cc21f7bSLen Brown 		goto done;
4841cc21f7bSLen Brown 
485812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
4863d109de2SLen Brown 		outp += sprintf(outp, "\tIRQ");
487812db3f7SLen Brown 	if (DO_BIC(BIC_SMI))
4883d109de2SLen Brown 		outp += sprintf(outp, "\tSMI");
4891cc21f7bSLen Brown 
490812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c1))
4913d109de2SLen Brown 		outp += sprintf(outp, "\tCPU%%c1");
492889facbeSLen Brown 
493388e9c81SLen Brown 	for (mp = sys.tp; mp; mp = mp->next) {
494388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
495388e9c81SLen Brown 			if (mp->width == 64)
496388e9c81SLen Brown 				outp += sprintf(outp, "\t%18.18s", mp->name);
497388e9c81SLen Brown 			else
498388e9c81SLen Brown 				outp += sprintf(outp, "\t%10.10s", mp->name);
499388e9c81SLen Brown 		} else {
500388e9c81SLen Brown 			outp += sprintf(outp, "\t%-7.7s", mp->name);
501388e9c81SLen Brown 		}
502388e9c81SLen Brown 	}
503388e9c81SLen Brown 
504812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates)
505678a3bd1SLen Brown 		outp += sprintf(outp, "\tCPU%%c3");
506812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c6))
507678a3bd1SLen Brown 		outp += sprintf(outp, "\tCPU%%c6");
508812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c7))
509678a3bd1SLen Brown 		outp += sprintf(outp, "\tCPU%%c7");
510678a3bd1SLen Brown 
5110539ba11SLen Brown 	if (DO_BIC(BIC_Mod_c6))
5120539ba11SLen Brown 		outp += sprintf(outp, "\tMod%%c6");
513678a3bd1SLen Brown 
514812db3f7SLen Brown 	if (DO_BIC(BIC_CoreTmp))
5153d109de2SLen Brown 		outp += sprintf(outp, "\tCoreTmp");
516388e9c81SLen Brown 
517388e9c81SLen Brown 	for (mp = sys.cp; mp; mp = mp->next) {
518388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
519388e9c81SLen Brown 			if (mp->width == 64)
520388e9c81SLen Brown 				outp += sprintf(outp, "\t%18.18s", mp->name);
521388e9c81SLen Brown 			else
522388e9c81SLen Brown 				outp += sprintf(outp, "\t%10.10s", mp->name);
523388e9c81SLen Brown 		} else {
524388e9c81SLen Brown 			outp += sprintf(outp, "\t%-7.7s", mp->name);
525388e9c81SLen Brown 		}
526388e9c81SLen Brown 	}
527388e9c81SLen Brown 
528812db3f7SLen Brown 	if (DO_BIC(BIC_PkgTmp))
5293d109de2SLen Brown 		outp += sprintf(outp, "\tPkgTmp");
530889facbeSLen Brown 
531812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6))
5323d109de2SLen Brown 		outp += sprintf(outp, "\tGFX%%rc6");
533fdf676e5SLen Brown 
534812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
5353d109de2SLen Brown 		outp += sprintf(outp, "\tGFXMHz");
53627d47356SLen Brown 
5370b2bb692SLen Brown 	if (do_skl_residency) {
5383d109de2SLen Brown 		outp += sprintf(outp, "\tTotl%%C0");
5393d109de2SLen Brown 		outp += sprintf(outp, "\tAny%%C0");
5403d109de2SLen Brown 		outp += sprintf(outp, "\tGFX%%C0");
5413d109de2SLen Brown 		outp += sprintf(outp, "\tCPUGFX%%");
5420b2bb692SLen Brown 	}
5430b2bb692SLen Brown 
544ee7e38e3SLen Brown 	if (do_pc2)
5453d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc2");
546ee7e38e3SLen Brown 	if (do_pc3)
5473d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc3");
548ee7e38e3SLen Brown 	if (do_pc6)
5493d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc6");
550ee7e38e3SLen Brown 	if (do_pc7)
5513d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc7");
552ca58710fSKristen Carlson Accardi 	if (do_c8_c9_c10) {
5533d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc8");
5543d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc9");
5553d109de2SLen Brown 		outp += sprintf(outp, "\tPk%%pc10");
556ca58710fSKristen Carlson Accardi 	}
557103a8feaSLen Brown 
5585c56be9aSDirk Brandewie 	if (do_rapl && !rapl_joules) {
559812db3f7SLen Brown 		if (DO_BIC(BIC_PkgWatt))
5603d109de2SLen Brown 			outp += sprintf(outp, "\tPkgWatt");
561812db3f7SLen Brown 		if (DO_BIC(BIC_CorWatt))
5623d109de2SLen Brown 			outp += sprintf(outp, "\tCorWatt");
563812db3f7SLen Brown 		if (DO_BIC(BIC_GFXWatt))
5643d109de2SLen Brown 			outp += sprintf(outp, "\tGFXWatt");
565812db3f7SLen Brown 		if (DO_BIC(BIC_RAMWatt))
5663d109de2SLen Brown 			outp += sprintf(outp, "\tRAMWatt");
567812db3f7SLen Brown 		if (DO_BIC(BIC_PKG__))
5683d109de2SLen Brown 			outp += sprintf(outp, "\tPKG_%%");
569812db3f7SLen Brown 		if (DO_BIC(BIC_RAM__))
5703d109de2SLen Brown 			outp += sprintf(outp, "\tRAM_%%");
571d7899447SLen Brown 	} else if (do_rapl && rapl_joules) {
572812db3f7SLen Brown 		if (DO_BIC(BIC_Pkg_J))
5733d109de2SLen Brown 			outp += sprintf(outp, "\tPkg_J");
574812db3f7SLen Brown 		if (DO_BIC(BIC_Cor_J))
5753d109de2SLen Brown 			outp += sprintf(outp, "\tCor_J");
576812db3f7SLen Brown 		if (DO_BIC(BIC_GFX_J))
5773d109de2SLen Brown 			outp += sprintf(outp, "\tGFX_J");
578812db3f7SLen Brown 		if (DO_BIC(BIC_RAM_J))
5793d109de2SLen Brown 			outp += sprintf(outp, "\tRAM_J");
580812db3f7SLen Brown 		if (DO_BIC(BIC_PKG__))
5813d109de2SLen Brown 			outp += sprintf(outp, "\tPKG_%%");
582812db3f7SLen Brown 		if (DO_BIC(BIC_RAM__))
5833d109de2SLen Brown 			outp += sprintf(outp, "\tRAM_%%");
5845c56be9aSDirk Brandewie 	}
585388e9c81SLen Brown 	for (mp = sys.pp; mp; mp = mp->next) {
586388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
587388e9c81SLen Brown 			if (mp->width == 64)
588388e9c81SLen Brown 				outp += sprintf(outp, "\t%18.18s", mp->name);
589388e9c81SLen Brown 			else
590388e9c81SLen Brown 				outp += sprintf(outp, "\t%10.10s", mp->name);
591388e9c81SLen Brown 		} else {
592388e9c81SLen Brown 			outp += sprintf(outp, "\t%-7.7s", mp->name);
593388e9c81SLen Brown 		}
594388e9c81SLen Brown 	}
595388e9c81SLen Brown 
5961cc21f7bSLen Brown done:
597c98d5d94SLen Brown 	outp += sprintf(outp, "\n");
598103a8feaSLen Brown }
599103a8feaSLen Brown 
600c98d5d94SLen Brown int dump_counters(struct thread_data *t, struct core_data *c,
601c98d5d94SLen Brown 	struct pkg_data *p)
602103a8feaSLen Brown {
603388e9c81SLen Brown 	int i;
604388e9c81SLen Brown 	struct msr_counter *mp;
605388e9c81SLen Brown 
6063b4d5c7fSAndy Shevchenko 	outp += sprintf(outp, "t %p, c %p, p %p\n", t, c, p);
607c98d5d94SLen Brown 
608c98d5d94SLen Brown 	if (t) {
6093b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "CPU: %d flags 0x%x\n",
6103b4d5c7fSAndy Shevchenko 			t->cpu_id, t->flags);
6113b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "TSC: %016llX\n", t->tsc);
6123b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "aperf: %016llX\n", t->aperf);
6133b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "mperf: %016llX\n", t->mperf);
6143b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c1: %016llX\n", t->c1);
6156886fee4SLen Brown 
616812db3f7SLen Brown 		if (DO_BIC(BIC_IRQ))
617562a2d37SLen Brown 			outp += sprintf(outp, "IRQ: %08X\n", t->irq_count);
618812db3f7SLen Brown 		if (DO_BIC(BIC_SMI))
6193b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "SMI: %08X\n", t->smi_count);
620388e9c81SLen Brown 
621388e9c81SLen Brown 		for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
622388e9c81SLen Brown 			outp += sprintf(outp, "tADDED [%d] msr0x%x: %08llX\n",
623388e9c81SLen Brown 				i, mp->msr_num, t->counter[i]);
624388e9c81SLen Brown 		}
625103a8feaSLen Brown 	}
626103a8feaSLen Brown 
627c98d5d94SLen Brown 	if (c) {
6283b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "core: %d\n", c->core_id);
6293b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c3: %016llX\n", c->c3);
6303b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c6: %016llX\n", c->c6);
6313b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c7: %016llX\n", c->c7);
6323b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "DTS: %dC\n", c->core_temp_c);
633388e9c81SLen Brown 
634388e9c81SLen Brown 		for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
635388e9c81SLen Brown 			outp += sprintf(outp, "cADDED [%d] msr0x%x: %08llX\n",
636388e9c81SLen Brown 				i, mp->msr_num, c->counter[i]);
637388e9c81SLen Brown 		}
6380539ba11SLen Brown 		outp += sprintf(outp, "mc6_us: %016llX\n", c->mc6_us);
639c98d5d94SLen Brown 	}
640103a8feaSLen Brown 
641c98d5d94SLen Brown 	if (p) {
6423b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "package: %d\n", p->package_id);
6430b2bb692SLen Brown 
6440b2bb692SLen Brown 		outp += sprintf(outp, "Weighted cores: %016llX\n", p->pkg_wtd_core_c0);
6450b2bb692SLen Brown 		outp += sprintf(outp, "Any cores: %016llX\n", p->pkg_any_core_c0);
6460b2bb692SLen Brown 		outp += sprintf(outp, "Any GFX: %016llX\n", p->pkg_any_gfxe_c0);
6470b2bb692SLen Brown 		outp += sprintf(outp, "CPU + GFX: %016llX\n", p->pkg_both_core_gfxe_c0);
6480b2bb692SLen Brown 
6493b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc2: %016llX\n", p->pc2);
650ee7e38e3SLen Brown 		if (do_pc3)
6513b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
652ee7e38e3SLen Brown 		if (do_pc6)
6533b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
654ee7e38e3SLen Brown 		if (do_pc7)
6553b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "pc7: %016llX\n", p->pc7);
6563b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc8: %016llX\n", p->pc8);
6573b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc9: %016llX\n", p->pc9);
6583b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc10: %016llX\n", p->pc10);
6593b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules PKG: %0X\n", p->energy_pkg);
6603b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules COR: %0X\n", p->energy_cores);
6613b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules GFX: %0X\n", p->energy_gfx);
6623b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules RAM: %0X\n", p->energy_dram);
6633b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Throttle PKG: %0X\n",
6643b4d5c7fSAndy Shevchenko 			p->rapl_pkg_perf_status);
6653b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Throttle RAM: %0X\n",
6663b4d5c7fSAndy Shevchenko 			p->rapl_dram_perf_status);
6673b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "PTM: %dC\n", p->pkg_temp_c);
668388e9c81SLen Brown 
669388e9c81SLen Brown 		for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
670388e9c81SLen Brown 			outp += sprintf(outp, "pADDED [%d] msr0x%x: %08llX\n",
671388e9c81SLen Brown 				i, mp->msr_num, p->counter[i]);
672388e9c81SLen Brown 		}
673c98d5d94SLen Brown 	}
6743b4d5c7fSAndy Shevchenko 
6753b4d5c7fSAndy Shevchenko 	outp += sprintf(outp, "\n");
6763b4d5c7fSAndy Shevchenko 
677c98d5d94SLen Brown 	return 0;
678103a8feaSLen Brown }
679103a8feaSLen Brown 
680e23da037SLen Brown /*
681e23da037SLen Brown  * column formatting convention & formats
682e23da037SLen Brown  */
683c98d5d94SLen Brown int format_counters(struct thread_data *t, struct core_data *c,
684c98d5d94SLen Brown 	struct pkg_data *p)
685103a8feaSLen Brown {
686103a8feaSLen Brown 	double interval_float;
687fc04cc67SLen Brown 	char *fmt8;
688388e9c81SLen Brown 	int i;
689388e9c81SLen Brown 	struct msr_counter *mp;
690103a8feaSLen Brown 
691c98d5d94SLen Brown 	 /* if showing only 1st thread in core and this isn't one, bail out */
692c98d5d94SLen Brown 	if (show_core_only && !(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
693c98d5d94SLen Brown 		return 0;
694c98d5d94SLen Brown 
695c98d5d94SLen Brown 	 /* if showing only 1st thread in pkg and this isn't one, bail out */
696c98d5d94SLen Brown 	if (show_pkg_only && !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
697c98d5d94SLen Brown 		return 0;
698c98d5d94SLen Brown 
699103a8feaSLen Brown 	interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.0;
700103a8feaSLen Brown 
701c98d5d94SLen Brown 	/* topo columns, print blanks on 1st (average) line */
702c98d5d94SLen Brown 	if (t == &average.threads) {
703812db3f7SLen Brown 		if (DO_BIC(BIC_Package))
7043d109de2SLen Brown 			outp += sprintf(outp, "\t-");
705812db3f7SLen Brown 		if (DO_BIC(BIC_Core))
7063d109de2SLen Brown 			outp += sprintf(outp, "\t-");
707812db3f7SLen Brown 		if (DO_BIC(BIC_CPU))
7083d109de2SLen Brown 			outp += sprintf(outp, "\t-");
709103a8feaSLen Brown 	} else {
710812db3f7SLen Brown 		if (DO_BIC(BIC_Package)) {
711c98d5d94SLen Brown 			if (p)
7123d109de2SLen Brown 				outp += sprintf(outp, "\t%d", p->package_id);
713c98d5d94SLen Brown 			else
7143d109de2SLen Brown 				outp += sprintf(outp, "\t-");
715c98d5d94SLen Brown 		}
716812db3f7SLen Brown 		if (DO_BIC(BIC_Core)) {
717c98d5d94SLen Brown 			if (c)
7183d109de2SLen Brown 				outp += sprintf(outp, "\t%d", c->core_id);
719c98d5d94SLen Brown 			else
7203d109de2SLen Brown 				outp += sprintf(outp, "\t-");
721c98d5d94SLen Brown 		}
722812db3f7SLen Brown 		if (DO_BIC(BIC_CPU))
7233d109de2SLen Brown 			outp += sprintf(outp, "\t%d", t->cpu_id);
724103a8feaSLen Brown 	}
725fc04cc67SLen Brown 
726812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz))
7273d109de2SLen Brown 		outp += sprintf(outp, "\t%.0f",
728fc04cc67SLen Brown 			1.0 / units * t->aperf / interval_float);
729fc04cc67SLen Brown 
730812db3f7SLen Brown 	if (DO_BIC(BIC_Busy))
7313d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * t->mperf/t->tsc/tsc_tweak);
732103a8feaSLen Brown 
733812db3f7SLen Brown 	if (DO_BIC(BIC_Bzy_MHz)) {
73421ed5574SLen Brown 		if (has_base_hz)
7353d109de2SLen Brown 			outp += sprintf(outp, "\t%.0f", base_hz / units * t->aperf / t->mperf);
73621ed5574SLen Brown 		else
7373d109de2SLen Brown 			outp += sprintf(outp, "\t%.0f",
73821ed5574SLen Brown 				1.0 * t->tsc / units * t->aperf / t->mperf / interval_float);
73921ed5574SLen Brown 	}
740103a8feaSLen Brown 
741812db3f7SLen Brown 	if (DO_BIC(BIC_TSC_MHz))
7423d109de2SLen Brown 		outp += sprintf(outp, "\t%.0f", 1.0 * t->tsc/units/interval_float);
743103a8feaSLen Brown 
7441cc21f7bSLen Brown 	if (!debug)
7451cc21f7bSLen Brown 		goto done;
7461cc21f7bSLen Brown 
747562a2d37SLen Brown 	/* IRQ */
748812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
7493d109de2SLen Brown 		outp += sprintf(outp, "\t%d", t->irq_count);
750562a2d37SLen Brown 
7511cc21f7bSLen Brown 	/* SMI */
752812db3f7SLen Brown 	if (DO_BIC(BIC_SMI))
7533d109de2SLen Brown 		outp += sprintf(outp, "\t%d", t->smi_count);
7541cc21f7bSLen Brown 
755678a3bd1SLen Brown 	/* C1 */
756812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c1))
7573d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * t->c1/t->tsc);
758c98d5d94SLen Brown 
759678a3bd1SLen Brown 	/* Added counters */
760678a3bd1SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
761678a3bd1SLen Brown 		if (mp->format == FORMAT_RAW) {
762678a3bd1SLen Brown 			if (mp->width == 32)
763678a3bd1SLen Brown 				outp += sprintf(outp, "\t0x%08lx", (unsigned long) t->counter[i]);
764678a3bd1SLen Brown 			else
765678a3bd1SLen Brown 				outp += sprintf(outp, "\t0x%016llx", t->counter[i]);
766678a3bd1SLen Brown 		} else if (mp->format == FORMAT_DELTA) {
767678a3bd1SLen Brown 			outp += sprintf(outp, "\t%lld", t->counter[i]);
768678a3bd1SLen Brown 		} else if (mp->format == FORMAT_PERCENT) {
769678a3bd1SLen Brown 			outp += sprintf(outp, "\t%.2f", 100.0 * t->counter[i]/t->tsc);
770678a3bd1SLen Brown 		}
771678a3bd1SLen Brown 	}
772678a3bd1SLen Brown 
773c98d5d94SLen Brown 	/* print per-core data only for 1st thread in core */
774c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
775c98d5d94SLen Brown 		goto done;
776c98d5d94SLen Brown 
777812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates)
7783d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->c3/t->tsc);
779812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c6))
7803d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->c6/t->tsc);
781812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c7))
7823d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->c7/t->tsc);
783c98d5d94SLen Brown 
7840539ba11SLen Brown 	/* Mod%c6 */
7850539ba11SLen Brown 	if (DO_BIC(BIC_Mod_c6))
7860539ba11SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->mc6_us / t->tsc);
7870539ba11SLen Brown 
788812db3f7SLen Brown 	if (DO_BIC(BIC_CoreTmp))
7893d109de2SLen Brown 		outp += sprintf(outp, "\t%d", c->core_temp_c);
790889facbeSLen Brown 
791388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
792388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
793388e9c81SLen Brown 			if (mp->width == 32)
794388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%08lx", (unsigned long) c->counter[i]);
795388e9c81SLen Brown 			else
796388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%016llx", c->counter[i]);
797388e9c81SLen Brown 		} else if (mp->format == FORMAT_DELTA) {
798678a3bd1SLen Brown 			outp += sprintf(outp, "\t%lld", c->counter[i]);
799388e9c81SLen Brown 		} else if (mp->format == FORMAT_PERCENT) {
800388e9c81SLen Brown 			outp += sprintf(outp, "\t%.2f", 100.0 * c->counter[i]/t->tsc);
801388e9c81SLen Brown 		}
802388e9c81SLen Brown 	}
803388e9c81SLen Brown 
804c98d5d94SLen Brown 	/* print per-package data only for 1st core in package */
805c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
806c98d5d94SLen Brown 		goto done;
807c98d5d94SLen Brown 
8080b2bb692SLen Brown 	/* PkgTmp */
809812db3f7SLen Brown 	if (DO_BIC(BIC_PkgTmp))
8103d109de2SLen Brown 		outp += sprintf(outp, "\t%d", p->pkg_temp_c);
811889facbeSLen Brown 
812fdf676e5SLen Brown 	/* GFXrc6 */
813812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6)) {
814ba3dec99SLen Brown 		if (p->gfx_rc6_ms == -1) {	/* detect GFX counter reset */
8153d109de2SLen Brown 			outp += sprintf(outp, "\t**.**");
8169185e988SLen Brown 		} else {
8173d109de2SLen Brown 			outp += sprintf(outp, "\t%.2f",
8189185e988SLen Brown 				p->gfx_rc6_ms / 10.0 / interval_float);
8199185e988SLen Brown 		}
8209185e988SLen Brown 	}
821fdf676e5SLen Brown 
82227d47356SLen Brown 	/* GFXMHz */
823812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
8243d109de2SLen Brown 		outp += sprintf(outp, "\t%d", p->gfx_mhz);
82527d47356SLen Brown 
8260b2bb692SLen Brown 	/* Totl%C0, Any%C0 GFX%C0 CPUGFX% */
8270b2bb692SLen Brown 	if (do_skl_residency) {
8283d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_wtd_core_c0/t->tsc);
8293d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_core_c0/t->tsc);
8303d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_gfxe_c0/t->tsc);
8313d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_both_core_gfxe_c0/t->tsc);
8320b2bb692SLen Brown 	}
8330b2bb692SLen Brown 
834ee7e38e3SLen Brown 	if (do_pc2)
8353d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc2/t->tsc);
836ee7e38e3SLen Brown 	if (do_pc3)
8373d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc3/t->tsc);
838ee7e38e3SLen Brown 	if (do_pc6)
8393d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc6/t->tsc);
840ee7e38e3SLen Brown 	if (do_pc7)
8413d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc7/t->tsc);
842ca58710fSKristen Carlson Accardi 	if (do_c8_c9_c10) {
8433d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc8/t->tsc);
8443d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc9/t->tsc);
8453d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc10/t->tsc);
846ca58710fSKristen Carlson Accardi 	}
847889facbeSLen Brown 
848889facbeSLen Brown 	/*
849889facbeSLen Brown  	 * If measurement interval exceeds minimum RAPL Joule Counter range,
850889facbeSLen Brown  	 * indicate that results are suspect by printing "**" in fraction place.
851889facbeSLen Brown  	 */
852fc04cc67SLen Brown 	if (interval_float < rapl_joule_counter_range)
8533d109de2SLen Brown 		fmt8 = "\t%.2f";
854fc04cc67SLen Brown 	else
855fc04cc67SLen Brown 		fmt8 = "%6.0f**";
856889facbeSLen Brown 
857812db3f7SLen Brown 	if (DO_BIC(BIC_PkgWatt))
858fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, p->energy_pkg * rapl_energy_units / interval_float);
859812db3f7SLen Brown 	if (DO_BIC(BIC_CorWatt))
860fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, p->energy_cores * rapl_energy_units / interval_float);
861812db3f7SLen Brown 	if (DO_BIC(BIC_GFXWatt))
862fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, p->energy_gfx * rapl_energy_units / interval_float);
863812db3f7SLen Brown 	if (DO_BIC(BIC_RAMWatt))
86440ee8e3bSAndrey Semin 		outp += sprintf(outp, fmt8, p->energy_dram * rapl_dram_energy_units / interval_float);
865812db3f7SLen Brown 	if (DO_BIC(BIC_Pkg_J))
866812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_pkg * rapl_energy_units);
867812db3f7SLen Brown 	if (DO_BIC(BIC_Cor_J))
868812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_cores * rapl_energy_units);
869812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_J))
870812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_gfx * rapl_energy_units);
871812db3f7SLen Brown 	if (DO_BIC(BIC_RAM_J))
872812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_dram * rapl_dram_energy_units);
873812db3f7SLen Brown 	if (DO_BIC(BIC_PKG__))
874fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
875812db3f7SLen Brown 	if (DO_BIC(BIC_RAM__))
876fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
877812db3f7SLen Brown 
878388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
879388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
880388e9c81SLen Brown 			if (mp->width == 32)
881388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%08lx", (unsigned long) p->counter[i]);
882388e9c81SLen Brown 			else
883388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%016llx", p->counter[i]);
884388e9c81SLen Brown 		} else if (mp->format == FORMAT_DELTA) {
885678a3bd1SLen Brown 			outp += sprintf(outp, "\t%lld", p->counter[i]);
886388e9c81SLen Brown 		} else if (mp->format == FORMAT_PERCENT) {
887388e9c81SLen Brown 			outp += sprintf(outp, "\t%.2f", 100.0 * p->counter[i]/t->tsc);
888388e9c81SLen Brown 		}
889388e9c81SLen Brown 	}
890388e9c81SLen Brown 
891c98d5d94SLen Brown done:
892c98d5d94SLen Brown 	outp += sprintf(outp, "\n");
893c98d5d94SLen Brown 
894c98d5d94SLen Brown 	return 0;
895103a8feaSLen Brown }
896103a8feaSLen Brown 
897b7d8c148SLen Brown void flush_output_stdout(void)
898103a8feaSLen Brown {
899b7d8c148SLen Brown 	FILE *filep;
900b7d8c148SLen Brown 
901b7d8c148SLen Brown 	if (outf == stderr)
902b7d8c148SLen Brown 		filep = stdout;
903b7d8c148SLen Brown 	else
904b7d8c148SLen Brown 		filep = outf;
905b7d8c148SLen Brown 
906b7d8c148SLen Brown 	fputs(output_buffer, filep);
907b7d8c148SLen Brown 	fflush(filep);
908b7d8c148SLen Brown 
909c98d5d94SLen Brown 	outp = output_buffer;
910c98d5d94SLen Brown }
911b7d8c148SLen Brown void flush_output_stderr(void)
912c98d5d94SLen Brown {
913b7d8c148SLen Brown 	fputs(output_buffer, outf);
914b7d8c148SLen Brown 	fflush(outf);
915c98d5d94SLen Brown 	outp = output_buffer;
916c98d5d94SLen Brown }
917c98d5d94SLen Brown void format_all_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
918c98d5d94SLen Brown {
919e23da037SLen Brown 	static int printed;
920103a8feaSLen Brown 
921e23da037SLen Brown 	if (!printed || !summary_only)
922103a8feaSLen Brown 		print_header();
923103a8feaSLen Brown 
924c98d5d94SLen Brown 	if (topo.num_cpus > 1)
925c98d5d94SLen Brown 		format_counters(&average.threads, &average.cores,
926c98d5d94SLen Brown 			&average.packages);
927103a8feaSLen Brown 
928e23da037SLen Brown 	printed = 1;
929e23da037SLen Brown 
930e23da037SLen Brown 	if (summary_only)
931e23da037SLen Brown 		return;
932e23da037SLen Brown 
933c98d5d94SLen Brown 	for_all_cpus(format_counters, t, c, p);
934103a8feaSLen Brown }
935103a8feaSLen Brown 
936889facbeSLen Brown #define DELTA_WRAP32(new, old)			\
937889facbeSLen Brown 	if (new > old) {			\
938889facbeSLen Brown 		old = new - old;		\
939889facbeSLen Brown 	} else {				\
940889facbeSLen Brown 		old = 0x100000000 + new - old;	\
941889facbeSLen Brown 	}
942889facbeSLen Brown 
943ba3dec99SLen Brown int
944c98d5d94SLen Brown delta_package(struct pkg_data *new, struct pkg_data *old)
945103a8feaSLen Brown {
946388e9c81SLen Brown 	int i;
947388e9c81SLen Brown 	struct msr_counter *mp;
9480b2bb692SLen Brown 
9490b2bb692SLen Brown 	if (do_skl_residency) {
9500b2bb692SLen Brown 		old->pkg_wtd_core_c0 = new->pkg_wtd_core_c0 - old->pkg_wtd_core_c0;
9510b2bb692SLen Brown 		old->pkg_any_core_c0 = new->pkg_any_core_c0 - old->pkg_any_core_c0;
9520b2bb692SLen Brown 		old->pkg_any_gfxe_c0 = new->pkg_any_gfxe_c0 - old->pkg_any_gfxe_c0;
9530b2bb692SLen Brown 		old->pkg_both_core_gfxe_c0 = new->pkg_both_core_gfxe_c0 - old->pkg_both_core_gfxe_c0;
9540b2bb692SLen Brown 	}
955c98d5d94SLen Brown 	old->pc2 = new->pc2 - old->pc2;
956ee7e38e3SLen Brown 	if (do_pc3)
957c98d5d94SLen Brown 		old->pc3 = new->pc3 - old->pc3;
958ee7e38e3SLen Brown 	if (do_pc6)
959c98d5d94SLen Brown 		old->pc6 = new->pc6 - old->pc6;
960ee7e38e3SLen Brown 	if (do_pc7)
961c98d5d94SLen Brown 		old->pc7 = new->pc7 - old->pc7;
962ca58710fSKristen Carlson Accardi 	old->pc8 = new->pc8 - old->pc8;
963ca58710fSKristen Carlson Accardi 	old->pc9 = new->pc9 - old->pc9;
964ca58710fSKristen Carlson Accardi 	old->pc10 = new->pc10 - old->pc10;
965889facbeSLen Brown 	old->pkg_temp_c = new->pkg_temp_c;
966889facbeSLen Brown 
9679185e988SLen Brown 	/* flag an error when rc6 counter resets/wraps */
9689185e988SLen Brown 	if (old->gfx_rc6_ms >  new->gfx_rc6_ms)
9699185e988SLen Brown 		old->gfx_rc6_ms = -1;
9709185e988SLen Brown 	else
971fdf676e5SLen Brown 		old->gfx_rc6_ms = new->gfx_rc6_ms - old->gfx_rc6_ms;
9729185e988SLen Brown 
97327d47356SLen Brown 	old->gfx_mhz = new->gfx_mhz;
97427d47356SLen Brown 
975889facbeSLen Brown 	DELTA_WRAP32(new->energy_pkg, old->energy_pkg);
976889facbeSLen Brown 	DELTA_WRAP32(new->energy_cores, old->energy_cores);
977889facbeSLen Brown 	DELTA_WRAP32(new->energy_gfx, old->energy_gfx);
978889facbeSLen Brown 	DELTA_WRAP32(new->energy_dram, old->energy_dram);
979889facbeSLen Brown 	DELTA_WRAP32(new->rapl_pkg_perf_status, old->rapl_pkg_perf_status);
980889facbeSLen Brown 	DELTA_WRAP32(new->rapl_dram_perf_status, old->rapl_dram_perf_status);
981ba3dec99SLen Brown 
982388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
983388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
984388e9c81SLen Brown 			old->counter[i] = new->counter[i];
985388e9c81SLen Brown 		else
986388e9c81SLen Brown 			old->counter[i] = new->counter[i] - old->counter[i];
987388e9c81SLen Brown 	}
988388e9c81SLen Brown 
989ba3dec99SLen Brown 	return 0;
990103a8feaSLen Brown }
991103a8feaSLen Brown 
992c98d5d94SLen Brown void
993c98d5d94SLen Brown delta_core(struct core_data *new, struct core_data *old)
994c98d5d94SLen Brown {
995388e9c81SLen Brown 	int i;
996388e9c81SLen Brown 	struct msr_counter *mp;
997388e9c81SLen Brown 
998c98d5d94SLen Brown 	old->c3 = new->c3 - old->c3;
999c98d5d94SLen Brown 	old->c6 = new->c6 - old->c6;
1000c98d5d94SLen Brown 	old->c7 = new->c7 - old->c7;
1001889facbeSLen Brown 	old->core_temp_c = new->core_temp_c;
10020539ba11SLen Brown 	old->mc6_us = new->mc6_us - old->mc6_us;
1003388e9c81SLen Brown 
1004388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1005388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1006388e9c81SLen Brown 			old->counter[i] = new->counter[i];
1007388e9c81SLen Brown 		else
1008388e9c81SLen Brown 			old->counter[i] = new->counter[i] - old->counter[i];
1009388e9c81SLen Brown 	}
1010103a8feaSLen Brown }
1011c98d5d94SLen Brown 
1012c3ae331dSLen Brown /*
1013c3ae331dSLen Brown  * old = new - old
1014c3ae331dSLen Brown  */
1015ba3dec99SLen Brown int
1016c98d5d94SLen Brown delta_thread(struct thread_data *new, struct thread_data *old,
1017c98d5d94SLen Brown 	struct core_data *core_delta)
1018c98d5d94SLen Brown {
1019388e9c81SLen Brown 	int i;
1020388e9c81SLen Brown 	struct msr_counter *mp;
1021388e9c81SLen Brown 
1022c98d5d94SLen Brown 	old->tsc = new->tsc - old->tsc;
1023c98d5d94SLen Brown 
1024103a8feaSLen Brown 	/* check for TSC < 1 Mcycles over interval */
1025b2c95d90SJosh Triplett 	if (old->tsc < (1000 * 1000))
1026b2c95d90SJosh Triplett 		errx(-3, "Insanely slow TSC rate, TSC stops in idle?\n"
1027b2c95d90SJosh Triplett 		     "You can disable all c-states by booting with \"idle=poll\"\n"
1028b2c95d90SJosh Triplett 		     "or just the deep ones with \"processor.max_cstate=1\"");
1029103a8feaSLen Brown 
1030c98d5d94SLen Brown 	old->c1 = new->c1 - old->c1;
1031c98d5d94SLen Brown 
1032812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz) || DO_BIC(BIC_Busy) || DO_BIC(BIC_Bzy_MHz)) {
1033c98d5d94SLen Brown 		if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
1034c98d5d94SLen Brown 			old->aperf = new->aperf - old->aperf;
1035c98d5d94SLen Brown 			old->mperf = new->mperf - old->mperf;
1036c98d5d94SLen Brown 		} else {
1037ba3dec99SLen Brown 			return -1;
1038103a8feaSLen Brown 		}
1039a729617cSLen Brown 	}
1040103a8feaSLen Brown 
1041c98d5d94SLen Brown 
1042144b44b1SLen Brown 	if (use_c1_residency_msr) {
1043144b44b1SLen Brown 		/*
1044144b44b1SLen Brown 		 * Some models have a dedicated C1 residency MSR,
1045144b44b1SLen Brown 		 * which should be more accurate than the derivation below.
1046144b44b1SLen Brown 		 */
1047144b44b1SLen Brown 	} else {
1048103a8feaSLen Brown 		/*
1049c3ae331dSLen Brown 		 * As counter collection is not atomic,
1050c3ae331dSLen Brown 		 * it is possible for mperf's non-halted cycles + idle states
1051103a8feaSLen Brown 		 * to exceed TSC's all cycles: show c1 = 0% in that case.
1052103a8feaSLen Brown 		 */
1053c3ae331dSLen Brown 		if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
1054c98d5d94SLen Brown 			old->c1 = 0;
1055c98d5d94SLen Brown 		else {
1056c98d5d94SLen Brown 			/* normal case, derive c1 */
1057c98d5d94SLen Brown 			old->c1 = old->tsc - old->mperf - core_delta->c3
1058c98d5d94SLen Brown 				- core_delta->c6 - core_delta->c7;
1059c98d5d94SLen Brown 		}
1060144b44b1SLen Brown 	}
1061c3ae331dSLen Brown 
1062c98d5d94SLen Brown 	if (old->mperf == 0) {
1063b7d8c148SLen Brown 		if (debug > 1)
1064b7d8c148SLen Brown 			fprintf(outf, "cpu%d MPERF 0!\n", old->cpu_id);
1065c98d5d94SLen Brown 		old->mperf = 1;	/* divide by 0 protection */
1066c98d5d94SLen Brown 	}
1067103a8feaSLen Brown 
1068812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
1069562a2d37SLen Brown 		old->irq_count = new->irq_count - old->irq_count;
1070562a2d37SLen Brown 
1071812db3f7SLen Brown 	if (DO_BIC(BIC_SMI))
10721ed51011SLen Brown 		old->smi_count = new->smi_count - old->smi_count;
1073ba3dec99SLen Brown 
1074388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1075388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1076388e9c81SLen Brown 			old->counter[i] = new->counter[i];
1077388e9c81SLen Brown 		else
1078388e9c81SLen Brown 			old->counter[i] = new->counter[i] - old->counter[i];
1079388e9c81SLen Brown 	}
1080ba3dec99SLen Brown 	return 0;
1081103a8feaSLen Brown }
1082c98d5d94SLen Brown 
1083c98d5d94SLen Brown int delta_cpu(struct thread_data *t, struct core_data *c,
1084c98d5d94SLen Brown 	struct pkg_data *p, struct thread_data *t2,
1085c98d5d94SLen Brown 	struct core_data *c2, struct pkg_data *p2)
1086c98d5d94SLen Brown {
1087ba3dec99SLen Brown 	int retval = 0;
1088ba3dec99SLen Brown 
1089c98d5d94SLen Brown 	/* calculate core delta only for 1st thread in core */
1090c98d5d94SLen Brown 	if (t->flags & CPU_IS_FIRST_THREAD_IN_CORE)
1091c98d5d94SLen Brown 		delta_core(c, c2);
1092c98d5d94SLen Brown 
1093c98d5d94SLen Brown 	/* always calculate thread delta */
1094ba3dec99SLen Brown 	retval = delta_thread(t, t2, c2);	/* c2 is core delta */
1095ba3dec99SLen Brown 	if (retval)
1096ba3dec99SLen Brown 		return retval;
1097c98d5d94SLen Brown 
1098c98d5d94SLen Brown 	/* calculate package delta only for 1st core in package */
1099c98d5d94SLen Brown 	if (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)
1100ba3dec99SLen Brown 		retval = delta_package(p, p2);
1101c98d5d94SLen Brown 
1102ba3dec99SLen Brown 	return retval;
1103103a8feaSLen Brown }
1104103a8feaSLen Brown 
1105c98d5d94SLen Brown void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
1106103a8feaSLen Brown {
1107388e9c81SLen Brown 	int i;
1108388e9c81SLen Brown 	struct msr_counter  *mp;
1109388e9c81SLen Brown 
1110c98d5d94SLen Brown 	t->tsc = 0;
1111c98d5d94SLen Brown 	t->aperf = 0;
1112c98d5d94SLen Brown 	t->mperf = 0;
1113c98d5d94SLen Brown 	t->c1 = 0;
1114103a8feaSLen Brown 
1115562a2d37SLen Brown 	t->irq_count = 0;
1116562a2d37SLen Brown 	t->smi_count = 0;
1117562a2d37SLen Brown 
1118c98d5d94SLen Brown 	/* tells format_counters to dump all fields from this set */
1119c98d5d94SLen Brown 	t->flags = CPU_IS_FIRST_THREAD_IN_CORE | CPU_IS_FIRST_CORE_IN_PACKAGE;
1120c98d5d94SLen Brown 
1121c98d5d94SLen Brown 	c->c3 = 0;
1122c98d5d94SLen Brown 	c->c6 = 0;
1123c98d5d94SLen Brown 	c->c7 = 0;
11240539ba11SLen Brown 	c->mc6_us = 0;
1125889facbeSLen Brown 	c->core_temp_c = 0;
1126c98d5d94SLen Brown 
11270b2bb692SLen Brown 	p->pkg_wtd_core_c0 = 0;
11280b2bb692SLen Brown 	p->pkg_any_core_c0 = 0;
11290b2bb692SLen Brown 	p->pkg_any_gfxe_c0 = 0;
11300b2bb692SLen Brown 	p->pkg_both_core_gfxe_c0 = 0;
11310b2bb692SLen Brown 
1132c98d5d94SLen Brown 	p->pc2 = 0;
1133ee7e38e3SLen Brown 	if (do_pc3)
1134c98d5d94SLen Brown 		p->pc3 = 0;
1135ee7e38e3SLen Brown 	if (do_pc6)
1136c98d5d94SLen Brown 		p->pc6 = 0;
1137ee7e38e3SLen Brown 	if (do_pc7)
1138c98d5d94SLen Brown 		p->pc7 = 0;
1139ca58710fSKristen Carlson Accardi 	p->pc8 = 0;
1140ca58710fSKristen Carlson Accardi 	p->pc9 = 0;
1141ca58710fSKristen Carlson Accardi 	p->pc10 = 0;
1142889facbeSLen Brown 
1143889facbeSLen Brown 	p->energy_pkg = 0;
1144889facbeSLen Brown 	p->energy_dram = 0;
1145889facbeSLen Brown 	p->energy_cores = 0;
1146889facbeSLen Brown 	p->energy_gfx = 0;
1147889facbeSLen Brown 	p->rapl_pkg_perf_status = 0;
1148889facbeSLen Brown 	p->rapl_dram_perf_status = 0;
1149889facbeSLen Brown 	p->pkg_temp_c = 0;
115027d47356SLen Brown 
1151fdf676e5SLen Brown 	p->gfx_rc6_ms = 0;
115227d47356SLen Brown 	p->gfx_mhz = 0;
1153388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next)
1154388e9c81SLen Brown 		t->counter[i] = 0;
1155388e9c81SLen Brown 
1156388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next)
1157388e9c81SLen Brown 		c->counter[i] = 0;
1158388e9c81SLen Brown 
1159388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next)
1160388e9c81SLen Brown 		p->counter[i] = 0;
1161103a8feaSLen Brown }
1162c98d5d94SLen Brown int sum_counters(struct thread_data *t, struct core_data *c,
1163c98d5d94SLen Brown 	struct pkg_data *p)
1164103a8feaSLen Brown {
1165388e9c81SLen Brown 	int i;
1166388e9c81SLen Brown 	struct msr_counter *mp;
1167388e9c81SLen Brown 
1168c98d5d94SLen Brown 	average.threads.tsc += t->tsc;
1169c98d5d94SLen Brown 	average.threads.aperf += t->aperf;
1170c98d5d94SLen Brown 	average.threads.mperf += t->mperf;
1171c98d5d94SLen Brown 	average.threads.c1 += t->c1;
117215aaa346SLen Brown 
1173562a2d37SLen Brown 	average.threads.irq_count += t->irq_count;
1174562a2d37SLen Brown 	average.threads.smi_count += t->smi_count;
1175562a2d37SLen Brown 
1176388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1177388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1178388e9c81SLen Brown 			continue;
1179388e9c81SLen Brown 		average.threads.counter[i] += t->counter[i];
1180388e9c81SLen Brown 	}
1181388e9c81SLen Brown 
1182c98d5d94SLen Brown 	/* sum per-core values only for 1st thread in core */
1183c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
1184c98d5d94SLen Brown 		return 0;
1185c98d5d94SLen Brown 
1186c98d5d94SLen Brown 	average.cores.c3 += c->c3;
1187c98d5d94SLen Brown 	average.cores.c6 += c->c6;
1188c98d5d94SLen Brown 	average.cores.c7 += c->c7;
11890539ba11SLen Brown 	average.cores.mc6_us += c->mc6_us;
1190c98d5d94SLen Brown 
1191889facbeSLen Brown 	average.cores.core_temp_c = MAX(average.cores.core_temp_c, c->core_temp_c);
1192889facbeSLen Brown 
1193388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1194388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1195388e9c81SLen Brown 			continue;
1196388e9c81SLen Brown 		average.cores.counter[i] += c->counter[i];
1197388e9c81SLen Brown 	}
1198388e9c81SLen Brown 
1199c98d5d94SLen Brown 	/* sum per-pkg values only for 1st core in pkg */
1200c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
1201c98d5d94SLen Brown 		return 0;
1202c98d5d94SLen Brown 
12030b2bb692SLen Brown 	if (do_skl_residency) {
12040b2bb692SLen Brown 		average.packages.pkg_wtd_core_c0 += p->pkg_wtd_core_c0;
12050b2bb692SLen Brown 		average.packages.pkg_any_core_c0 += p->pkg_any_core_c0;
12060b2bb692SLen Brown 		average.packages.pkg_any_gfxe_c0 += p->pkg_any_gfxe_c0;
12070b2bb692SLen Brown 		average.packages.pkg_both_core_gfxe_c0 += p->pkg_both_core_gfxe_c0;
12080b2bb692SLen Brown 	}
12090b2bb692SLen Brown 
1210c98d5d94SLen Brown 	average.packages.pc2 += p->pc2;
1211ee7e38e3SLen Brown 	if (do_pc3)
1212c98d5d94SLen Brown 		average.packages.pc3 += p->pc3;
1213ee7e38e3SLen Brown 	if (do_pc6)
1214c98d5d94SLen Brown 		average.packages.pc6 += p->pc6;
1215ee7e38e3SLen Brown 	if (do_pc7)
1216c98d5d94SLen Brown 		average.packages.pc7 += p->pc7;
1217ca58710fSKristen Carlson Accardi 	average.packages.pc8 += p->pc8;
1218ca58710fSKristen Carlson Accardi 	average.packages.pc9 += p->pc9;
1219ca58710fSKristen Carlson Accardi 	average.packages.pc10 += p->pc10;
1220c98d5d94SLen Brown 
1221889facbeSLen Brown 	average.packages.energy_pkg += p->energy_pkg;
1222889facbeSLen Brown 	average.packages.energy_dram += p->energy_dram;
1223889facbeSLen Brown 	average.packages.energy_cores += p->energy_cores;
1224889facbeSLen Brown 	average.packages.energy_gfx += p->energy_gfx;
1225889facbeSLen Brown 
1226fdf676e5SLen Brown 	average.packages.gfx_rc6_ms = p->gfx_rc6_ms;
122727d47356SLen Brown 	average.packages.gfx_mhz = p->gfx_mhz;
122827d47356SLen Brown 
1229889facbeSLen Brown 	average.packages.pkg_temp_c = MAX(average.packages.pkg_temp_c, p->pkg_temp_c);
1230889facbeSLen Brown 
1231889facbeSLen Brown 	average.packages.rapl_pkg_perf_status += p->rapl_pkg_perf_status;
1232889facbeSLen Brown 	average.packages.rapl_dram_perf_status += p->rapl_dram_perf_status;
1233388e9c81SLen Brown 
1234388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
1235388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1236388e9c81SLen Brown 			continue;
1237388e9c81SLen Brown 		average.packages.counter[i] += p->counter[i];
1238388e9c81SLen Brown 	}
1239c98d5d94SLen Brown 	return 0;
1240c98d5d94SLen Brown }
1241c98d5d94SLen Brown /*
1242c98d5d94SLen Brown  * sum the counters for all cpus in the system
1243c98d5d94SLen Brown  * compute the weighted average
1244c98d5d94SLen Brown  */
1245c98d5d94SLen Brown void compute_average(struct thread_data *t, struct core_data *c,
1246c98d5d94SLen Brown 	struct pkg_data *p)
1247c98d5d94SLen Brown {
1248388e9c81SLen Brown 	int i;
1249388e9c81SLen Brown 	struct msr_counter *mp;
1250388e9c81SLen Brown 
1251c98d5d94SLen Brown 	clear_counters(&average.threads, &average.cores, &average.packages);
1252c98d5d94SLen Brown 
1253c98d5d94SLen Brown 	for_all_cpus(sum_counters, t, c, p);
1254c98d5d94SLen Brown 
1255c98d5d94SLen Brown 	average.threads.tsc /= topo.num_cpus;
1256c98d5d94SLen Brown 	average.threads.aperf /= topo.num_cpus;
1257c98d5d94SLen Brown 	average.threads.mperf /= topo.num_cpus;
1258c98d5d94SLen Brown 	average.threads.c1 /= topo.num_cpus;
1259c98d5d94SLen Brown 
1260c98d5d94SLen Brown 	average.cores.c3 /= topo.num_cores;
1261c98d5d94SLen Brown 	average.cores.c6 /= topo.num_cores;
1262c98d5d94SLen Brown 	average.cores.c7 /= topo.num_cores;
12630539ba11SLen Brown 	average.cores.mc6_us /= topo.num_cores;
1264c98d5d94SLen Brown 
12650b2bb692SLen Brown 	if (do_skl_residency) {
12660b2bb692SLen Brown 		average.packages.pkg_wtd_core_c0 /= topo.num_packages;
12670b2bb692SLen Brown 		average.packages.pkg_any_core_c0 /= topo.num_packages;
12680b2bb692SLen Brown 		average.packages.pkg_any_gfxe_c0 /= topo.num_packages;
12690b2bb692SLen Brown 		average.packages.pkg_both_core_gfxe_c0 /= topo.num_packages;
12700b2bb692SLen Brown 	}
12710b2bb692SLen Brown 
1272c98d5d94SLen Brown 	average.packages.pc2 /= topo.num_packages;
1273ee7e38e3SLen Brown 	if (do_pc3)
1274c98d5d94SLen Brown 		average.packages.pc3 /= topo.num_packages;
1275ee7e38e3SLen Brown 	if (do_pc6)
1276c98d5d94SLen Brown 		average.packages.pc6 /= topo.num_packages;
1277ee7e38e3SLen Brown 	if (do_pc7)
1278c98d5d94SLen Brown 		average.packages.pc7 /= topo.num_packages;
1279ca58710fSKristen Carlson Accardi 
1280ca58710fSKristen Carlson Accardi 	average.packages.pc8 /= topo.num_packages;
1281ca58710fSKristen Carlson Accardi 	average.packages.pc9 /= topo.num_packages;
1282ca58710fSKristen Carlson Accardi 	average.packages.pc10 /= topo.num_packages;
1283388e9c81SLen Brown 
1284388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1285388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1286388e9c81SLen Brown 			continue;
1287388e9c81SLen Brown 		average.threads.counter[i] /= topo.num_cpus;
1288388e9c81SLen Brown 	}
1289388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1290388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1291388e9c81SLen Brown 			continue;
1292388e9c81SLen Brown 		average.cores.counter[i] /= topo.num_cores;
1293388e9c81SLen Brown 	}
1294388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
1295388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1296388e9c81SLen Brown 			continue;
1297388e9c81SLen Brown 		average.packages.counter[i] /= topo.num_packages;
1298388e9c81SLen Brown 	}
1299c98d5d94SLen Brown }
1300c98d5d94SLen Brown 
1301c98d5d94SLen Brown static unsigned long long rdtsc(void)
1302c98d5d94SLen Brown {
1303c98d5d94SLen Brown 	unsigned int low, high;
1304c98d5d94SLen Brown 
1305c98d5d94SLen Brown 	asm volatile("rdtsc" : "=a" (low), "=d" (high));
1306c98d5d94SLen Brown 
1307c98d5d94SLen Brown 	return low | ((unsigned long long)high) << 32;
1308c98d5d94SLen Brown }
1309c98d5d94SLen Brown 
1310c98d5d94SLen Brown /*
1311c98d5d94SLen Brown  * get_counters(...)
1312c98d5d94SLen Brown  * migrate to cpu
1313c98d5d94SLen Brown  * acquire and record local counters for that cpu
1314c98d5d94SLen Brown  */
1315c98d5d94SLen Brown int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
1316c98d5d94SLen Brown {
1317c98d5d94SLen Brown 	int cpu = t->cpu_id;
1318889facbeSLen Brown 	unsigned long long msr;
13190102b067SLen Brown 	int aperf_mperf_retry_count = 0;
1320388e9c81SLen Brown 	struct msr_counter *mp;
1321388e9c81SLen Brown 	int i;
1322c98d5d94SLen Brown 
1323e52966c0SLen Brown 	if (cpu_migrate(cpu)) {
1324b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
132515aaa346SLen Brown 		return -1;
1326e52966c0SLen Brown 	}
132715aaa346SLen Brown 
13280102b067SLen Brown retry:
1329c98d5d94SLen Brown 	t->tsc = rdtsc();	/* we are running on local CPU of interest */
133015aaa346SLen Brown 
1331812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz) || DO_BIC(BIC_Busy) || DO_BIC(BIC_Bzy_MHz)) {
13320102b067SLen Brown 		unsigned long long tsc_before, tsc_between, tsc_after, aperf_time, mperf_time;
13330102b067SLen Brown 
13340102b067SLen Brown 		/*
13350102b067SLen Brown 		 * The TSC, APERF and MPERF must be read together for
13360102b067SLen Brown 		 * APERF/MPERF and MPERF/TSC to give accurate results.
13370102b067SLen Brown 		 *
13380102b067SLen Brown 		 * Unfortunately, APERF and MPERF are read by
13390102b067SLen Brown 		 * individual system call, so delays may occur
13400102b067SLen Brown 		 * between them.  If the time to read them
13410102b067SLen Brown 		 * varies by a large amount, we re-read them.
13420102b067SLen Brown 		 */
13430102b067SLen Brown 
13440102b067SLen Brown 		/*
13450102b067SLen Brown 		 * This initial dummy APERF read has been seen to
13460102b067SLen Brown 		 * reduce jitter in the subsequent reads.
13470102b067SLen Brown 		 */
13480102b067SLen Brown 
13499c63a650SLen Brown 		if (get_msr(cpu, MSR_IA32_APERF, &t->aperf))
1350c98d5d94SLen Brown 			return -3;
13510102b067SLen Brown 
13520102b067SLen Brown 		t->tsc = rdtsc();	/* re-read close to APERF */
13530102b067SLen Brown 
13540102b067SLen Brown 		tsc_before = t->tsc;
13550102b067SLen Brown 
13560102b067SLen Brown 		if (get_msr(cpu, MSR_IA32_APERF, &t->aperf))
13570102b067SLen Brown 			return -3;
13580102b067SLen Brown 
13590102b067SLen Brown 		tsc_between = rdtsc();
13600102b067SLen Brown 
13619c63a650SLen Brown 		if (get_msr(cpu, MSR_IA32_MPERF, &t->mperf))
1362c98d5d94SLen Brown 			return -4;
13630102b067SLen Brown 
13640102b067SLen Brown 		tsc_after = rdtsc();
13650102b067SLen Brown 
13660102b067SLen Brown 		aperf_time = tsc_between - tsc_before;
13670102b067SLen Brown 		mperf_time = tsc_after - tsc_between;
13680102b067SLen Brown 
13690102b067SLen Brown 		/*
13700102b067SLen Brown 		 * If the system call latency to read APERF and MPERF
13710102b067SLen Brown 		 * differ by more than 2x, then try again.
13720102b067SLen Brown 		 */
13730102b067SLen Brown 		if ((aperf_time > (2 * mperf_time)) || (mperf_time > (2 * aperf_time))) {
13740102b067SLen Brown 			aperf_mperf_retry_count++;
13750102b067SLen Brown 			if (aperf_mperf_retry_count < 5)
13760102b067SLen Brown 				goto retry;
13770102b067SLen Brown 			else
13780102b067SLen Brown 				warnx("cpu%d jitter %lld %lld",
13790102b067SLen Brown 					cpu, aperf_time, mperf_time);
13800102b067SLen Brown 		}
13810102b067SLen Brown 		aperf_mperf_retry_count = 0;
13820102b067SLen Brown 
1383b2b34dfeSHubert Chrzaniuk 		t->aperf = t->aperf * aperf_mperf_multiplier;
1384b2b34dfeSHubert Chrzaniuk 		t->mperf = t->mperf * aperf_mperf_multiplier;
138588c3281fSLen Brown 	}
138688c3281fSLen Brown 
1387812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
1388562a2d37SLen Brown 		t->irq_count = irqs_per_cpu[cpu];
1389812db3f7SLen Brown 	if (DO_BIC(BIC_SMI)) {
13901ed51011SLen Brown 		if (get_msr(cpu, MSR_SMI_COUNT, &msr))
13911ed51011SLen Brown 			return -5;
13921ed51011SLen Brown 		t->smi_count = msr & 0xFFFFFFFF;
13931ed51011SLen Brown 	}
13940539ba11SLen Brown 	if (DO_BIC(BIC_CPU_c1) && use_c1_residency_msr) {
1395144b44b1SLen Brown 		if (get_msr(cpu, MSR_CORE_C1_RES, &t->c1))
1396144b44b1SLen Brown 			return -6;
1397144b44b1SLen Brown 	}
1398144b44b1SLen Brown 
1399388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1400388e9c81SLen Brown 		if (get_msr(cpu, mp->msr_num, &t->counter[i]))
1401388e9c81SLen Brown 			return -10;
1402388e9c81SLen Brown 	}
1403388e9c81SLen Brown 
1404388e9c81SLen Brown 
1405c98d5d94SLen Brown 	/* collect core counters only for 1st thread in core */
1406c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
1407c98d5d94SLen Brown 		return 0;
1408c98d5d94SLen Brown 
1409812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates) {
1410c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C3_RESIDENCY, &c->c3))
1411c98d5d94SLen Brown 			return -6;
1412144b44b1SLen Brown 	}
1413144b44b1SLen Brown 
1414812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c6) && !do_knl_cstates) {
1415c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C6_RESIDENCY, &c->c6))
1416c98d5d94SLen Brown 			return -7;
1417fb5d4327SDasaratharaman Chandramouli 	} else if (do_knl_cstates) {
1418fb5d4327SDasaratharaman Chandramouli 		if (get_msr(cpu, MSR_KNL_CORE_C6_RESIDENCY, &c->c6))
1419fb5d4327SDasaratharaman Chandramouli 			return -7;
1420103a8feaSLen Brown 	}
142115aaa346SLen Brown 
1422812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c7))
1423c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C7_RESIDENCY, &c->c7))
1424c98d5d94SLen Brown 			return -8;
1425c98d5d94SLen Brown 
14260539ba11SLen Brown 	if (DO_BIC(BIC_Mod_c6))
14270539ba11SLen Brown 		if (get_msr(cpu, MSR_MODULE_C6_RES_MS, &c->mc6_us))
14280539ba11SLen Brown 			return -8;
14290539ba11SLen Brown 
1430812db3f7SLen Brown 	if (DO_BIC(BIC_CoreTmp)) {
1431889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
1432889facbeSLen Brown 			return -9;
1433889facbeSLen Brown 		c->core_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
1434889facbeSLen Brown 	}
1435889facbeSLen Brown 
1436388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1437388e9c81SLen Brown 		if (get_msr(cpu, mp->msr_num, &c->counter[i]))
1438388e9c81SLen Brown 			return -10;
1439388e9c81SLen Brown 	}
1440889facbeSLen Brown 
1441c98d5d94SLen Brown 	/* collect package counters only for 1st core in package */
1442c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
1443c98d5d94SLen Brown 		return 0;
144415aaa346SLen Brown 
14450b2bb692SLen Brown 	if (do_skl_residency) {
14460b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_WEIGHTED_CORE_C0_RES, &p->pkg_wtd_core_c0))
14470b2bb692SLen Brown 			return -10;
14480b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_ANY_CORE_C0_RES, &p->pkg_any_core_c0))
14490b2bb692SLen Brown 			return -11;
14500b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_ANY_GFXE_C0_RES, &p->pkg_any_gfxe_c0))
14510b2bb692SLen Brown 			return -12;
14520b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_BOTH_CORE_GFXE_C0_RES, &p->pkg_both_core_gfxe_c0))
14530b2bb692SLen Brown 			return -13;
14540b2bb692SLen Brown 	}
1455ee7e38e3SLen Brown 	if (do_pc3)
1456c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
1457c98d5d94SLen Brown 			return -9;
14580539ba11SLen Brown 	if (do_pc6) {
14590539ba11SLen Brown 		if (do_slm_cstates) {
14600539ba11SLen Brown 			if (get_msr(cpu, MSR_ATOM_PKG_C6_RESIDENCY, &p->pc6))
14610539ba11SLen Brown 				return -10;
14620539ba11SLen Brown 		} else {
1463c98d5d94SLen Brown 			if (get_msr(cpu, MSR_PKG_C6_RESIDENCY, &p->pc6))
1464c98d5d94SLen Brown 				return -10;
14650539ba11SLen Brown 		}
14660539ba11SLen Brown 	}
14670539ba11SLen Brown 
1468ee7e38e3SLen Brown 	if (do_pc2)
1469c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C2_RESIDENCY, &p->pc2))
1470c98d5d94SLen Brown 			return -11;
1471ee7e38e3SLen Brown 	if (do_pc7)
1472c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C7_RESIDENCY, &p->pc7))
1473c98d5d94SLen Brown 			return -12;
1474ca58710fSKristen Carlson Accardi 	if (do_c8_c9_c10) {
1475ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C8_RESIDENCY, &p->pc8))
1476ca58710fSKristen Carlson Accardi 			return -13;
1477ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C9_RESIDENCY, &p->pc9))
1478ca58710fSKristen Carlson Accardi 			return -13;
1479ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C10_RESIDENCY, &p->pc10))
1480ca58710fSKristen Carlson Accardi 			return -13;
1481ca58710fSKristen Carlson Accardi 	}
1482889facbeSLen Brown 	if (do_rapl & RAPL_PKG) {
1483889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_ENERGY_STATUS, &msr))
1484889facbeSLen Brown 			return -13;
1485889facbeSLen Brown 		p->energy_pkg = msr & 0xFFFFFFFF;
1486889facbeSLen Brown 	}
14879148494cSJacob Pan 	if (do_rapl & RAPL_CORES_ENERGY_STATUS) {
1488889facbeSLen Brown 		if (get_msr(cpu, MSR_PP0_ENERGY_STATUS, &msr))
1489889facbeSLen Brown 			return -14;
1490889facbeSLen Brown 		p->energy_cores = msr & 0xFFFFFFFF;
1491889facbeSLen Brown 	}
1492889facbeSLen Brown 	if (do_rapl & RAPL_DRAM) {
1493889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_ENERGY_STATUS, &msr))
1494889facbeSLen Brown 			return -15;
1495889facbeSLen Brown 		p->energy_dram = msr & 0xFFFFFFFF;
1496889facbeSLen Brown 	}
1497889facbeSLen Brown 	if (do_rapl & RAPL_GFX) {
1498889facbeSLen Brown 		if (get_msr(cpu, MSR_PP1_ENERGY_STATUS, &msr))
1499889facbeSLen Brown 			return -16;
1500889facbeSLen Brown 		p->energy_gfx = msr & 0xFFFFFFFF;
1501889facbeSLen Brown 	}
1502889facbeSLen Brown 	if (do_rapl & RAPL_PKG_PERF_STATUS) {
1503889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_PERF_STATUS, &msr))
1504889facbeSLen Brown 			return -16;
1505889facbeSLen Brown 		p->rapl_pkg_perf_status = msr & 0xFFFFFFFF;
1506889facbeSLen Brown 	}
1507889facbeSLen Brown 	if (do_rapl & RAPL_DRAM_PERF_STATUS) {
1508889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_PERF_STATUS, &msr))
1509889facbeSLen Brown 			return -16;
1510889facbeSLen Brown 		p->rapl_dram_perf_status = msr & 0xFFFFFFFF;
1511889facbeSLen Brown 	}
1512812db3f7SLen Brown 	if (DO_BIC(BIC_PkgTmp)) {
1513889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
1514889facbeSLen Brown 			return -17;
1515889facbeSLen Brown 		p->pkg_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
1516889facbeSLen Brown 	}
1517fdf676e5SLen Brown 
1518812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6))
1519fdf676e5SLen Brown 		p->gfx_rc6_ms = gfx_cur_rc6_ms;
1520fdf676e5SLen Brown 
1521812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
152227d47356SLen Brown 		p->gfx_mhz = gfx_cur_mhz;
152327d47356SLen Brown 
1524388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
1525388e9c81SLen Brown 		if (get_msr(cpu, mp->msr_num, &p->counter[i]))
1526388e9c81SLen Brown 			return -10;
1527388e9c81SLen Brown 	}
1528388e9c81SLen Brown 
152915aaa346SLen Brown 	return 0;
1530103a8feaSLen Brown }
1531103a8feaSLen Brown 
1532ee7e38e3SLen Brown /*
1533ee7e38e3SLen Brown  * MSR_PKG_CST_CONFIG_CONTROL decoding for pkg_cstate_limit:
1534ee7e38e3SLen Brown  * If you change the values, note they are used both in comparisons
1535ee7e38e3SLen Brown  * (>= PCL__7) and to index pkg_cstate_limit_strings[].
1536ee7e38e3SLen Brown  */
1537ee7e38e3SLen Brown 
1538ee7e38e3SLen Brown #define PCLUKN 0 /* Unknown */
1539ee7e38e3SLen Brown #define PCLRSV 1 /* Reserved */
1540ee7e38e3SLen Brown #define PCL__0 2 /* PC0 */
1541ee7e38e3SLen Brown #define PCL__1 3 /* PC1 */
1542ee7e38e3SLen Brown #define PCL__2 4 /* PC2 */
1543ee7e38e3SLen Brown #define PCL__3 5 /* PC3 */
1544ee7e38e3SLen Brown #define PCL__4 6 /* PC4 */
1545ee7e38e3SLen Brown #define PCL__6 7 /* PC6 */
1546ee7e38e3SLen Brown #define PCL_6N 8 /* PC6 No Retention */
1547ee7e38e3SLen Brown #define PCL_6R 9 /* PC6 Retention */
1548ee7e38e3SLen Brown #define PCL__7 10 /* PC7 */
1549ee7e38e3SLen Brown #define PCL_7S 11 /* PC7 Shrink */
15500b2bb692SLen Brown #define PCL__8 12 /* PC8 */
15510b2bb692SLen Brown #define PCL__9 13 /* PC9 */
15520b2bb692SLen Brown #define PCLUNL 14 /* Unlimited */
1553ee7e38e3SLen Brown 
1554ee7e38e3SLen Brown int pkg_cstate_limit = PCLUKN;
1555ee7e38e3SLen Brown char *pkg_cstate_limit_strings[] = { "reserved", "unknown", "pc0", "pc1", "pc2",
15560b2bb692SLen Brown 	"pc3", "pc4", "pc6", "pc6n", "pc6r", "pc7", "pc7s", "pc8", "pc9", "unlimited"};
1557ee7e38e3SLen Brown 
1558e9257f5fSLen Brown int nhm_pkg_cstate_limits[16] = {PCL__0, PCL__1, PCL__3, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1559e9257f5fSLen Brown int snb_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCL__7, PCL_7S, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1560e9257f5fSLen Brown int hsw_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL__3, PCL__6, PCL__7, PCL_7S, PCL__8, PCL__9, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
15610539ba11SLen Brown int slv_pkg_cstate_limits[16] = {PCL__0, PCL__1, PCLRSV, PCLRSV, PCL__4, PCLRSV, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCL__6, PCL__7};
1562f2642888SLen Brown int amt_pkg_cstate_limits[16] = {PCLUNL, PCL__1, PCL__2, PCLRSV, PCLRSV, PCLRSV, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1563e9257f5fSLen Brown int phi_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCLRSV, PCLRSV, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1564e4085d54SLen Brown int bxt_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1565d8ebb442SLen Brown int skx_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1566ee7e38e3SLen Brown 
1567a2b7b749SLen Brown 
1568a2b7b749SLen Brown static void
1569a2b7b749SLen Brown calculate_tsc_tweak()
1570a2b7b749SLen Brown {
1571a2b7b749SLen Brown 	tsc_tweak = base_hz / tsc_hz;
1572a2b7b749SLen Brown }
1573a2b7b749SLen Brown 
1574fcd17211SLen Brown static void
1575fcd17211SLen Brown dump_nhm_platform_info(void)
1576103a8feaSLen Brown {
1577103a8feaSLen Brown 	unsigned long long msr;
1578103a8feaSLen Brown 	unsigned int ratio;
1579103a8feaSLen Brown 
1580ec0adc53SLen Brown 	get_msr(base_cpu, MSR_PLATFORM_INFO, &msr);
1581103a8feaSLen Brown 
1582b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_PLATFORM_INFO: 0x%08llx\n", base_cpu, msr);
15836574a5d5SLen Brown 
1584103a8feaSLen Brown 	ratio = (msr >> 40) & 0xFF;
1585710f273bSLen Brown 	fprintf(outf, "%d * %.1f = %.1f MHz max efficiency frequency\n",
1586103a8feaSLen Brown 		ratio, bclk, ratio * bclk);
1587103a8feaSLen Brown 
1588103a8feaSLen Brown 	ratio = (msr >> 8) & 0xFF;
1589710f273bSLen Brown 	fprintf(outf, "%d * %.1f = %.1f MHz base frequency\n",
1590103a8feaSLen Brown 		ratio, bclk, ratio * bclk);
1591103a8feaSLen Brown 
15927ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_IA32_POWER_CTL, &msr);
1593b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_IA32_POWER_CTL: 0x%08llx (C1E auto-promotion: %sabled)\n",
1594bfae2052SLen Brown 		base_cpu, msr, msr & 0x2 ? "EN" : "DIS");
159567920418SLen Brown 
1596fcd17211SLen Brown 	return;
1597fcd17211SLen Brown }
1598fcd17211SLen Brown 
1599fcd17211SLen Brown static void
1600fcd17211SLen Brown dump_hsw_turbo_ratio_limits(void)
1601fcd17211SLen Brown {
1602fcd17211SLen Brown 	unsigned long long msr;
1603fcd17211SLen Brown 	unsigned int ratio;
1604fcd17211SLen Brown 
16057ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT2, &msr);
1606fcd17211SLen Brown 
1607b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT2: 0x%08llx\n", base_cpu, msr);
1608fcd17211SLen Brown 
1609fcd17211SLen Brown 	ratio = (msr >> 8) & 0xFF;
1610fcd17211SLen Brown 	if (ratio)
1611710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 18 active cores\n",
1612fcd17211SLen Brown 			ratio, bclk, ratio * bclk);
1613fcd17211SLen Brown 
1614fcd17211SLen Brown 	ratio = (msr >> 0) & 0xFF;
1615fcd17211SLen Brown 	if (ratio)
1616710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 17 active cores\n",
1617fcd17211SLen Brown 			ratio, bclk, ratio * bclk);
1618fcd17211SLen Brown 	return;
1619fcd17211SLen Brown }
1620fcd17211SLen Brown 
1621fcd17211SLen Brown static void
1622fcd17211SLen Brown dump_ivt_turbo_ratio_limits(void)
1623fcd17211SLen Brown {
1624fcd17211SLen Brown 	unsigned long long msr;
1625fcd17211SLen Brown 	unsigned int ratio;
16266574a5d5SLen Brown 
16277ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT1, &msr);
16286574a5d5SLen Brown 
1629b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT1: 0x%08llx\n", base_cpu, msr);
16306574a5d5SLen Brown 
16316574a5d5SLen Brown 	ratio = (msr >> 56) & 0xFF;
16326574a5d5SLen Brown 	if (ratio)
1633710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 16 active cores\n",
16346574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16356574a5d5SLen Brown 
16366574a5d5SLen Brown 	ratio = (msr >> 48) & 0xFF;
16376574a5d5SLen Brown 	if (ratio)
1638710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 15 active cores\n",
16396574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16406574a5d5SLen Brown 
16416574a5d5SLen Brown 	ratio = (msr >> 40) & 0xFF;
16426574a5d5SLen Brown 	if (ratio)
1643710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 14 active cores\n",
16446574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16456574a5d5SLen Brown 
16466574a5d5SLen Brown 	ratio = (msr >> 32) & 0xFF;
16476574a5d5SLen Brown 	if (ratio)
1648710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 13 active cores\n",
16496574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16506574a5d5SLen Brown 
16516574a5d5SLen Brown 	ratio = (msr >> 24) & 0xFF;
16526574a5d5SLen Brown 	if (ratio)
1653710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 12 active cores\n",
16546574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16556574a5d5SLen Brown 
16566574a5d5SLen Brown 	ratio = (msr >> 16) & 0xFF;
16576574a5d5SLen Brown 	if (ratio)
1658710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 11 active cores\n",
16596574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16606574a5d5SLen Brown 
16616574a5d5SLen Brown 	ratio = (msr >> 8) & 0xFF;
16626574a5d5SLen Brown 	if (ratio)
1663710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 10 active cores\n",
16646574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16656574a5d5SLen Brown 
16666574a5d5SLen Brown 	ratio = (msr >> 0) & 0xFF;
16676574a5d5SLen Brown 	if (ratio)
1668710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 9 active cores\n",
16696574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
1670103a8feaSLen Brown 	return;
1671fcd17211SLen Brown }
1672fcd17211SLen Brown 
1673fcd17211SLen Brown static void
1674fcd17211SLen Brown dump_nhm_turbo_ratio_limits(void)
1675fcd17211SLen Brown {
1676fcd17211SLen Brown 	unsigned long long msr;
1677fcd17211SLen Brown 	unsigned int ratio;
1678103a8feaSLen Brown 
16797ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT, &msr);
1680103a8feaSLen Brown 
1681b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT: 0x%08llx\n", base_cpu, msr);
16826574a5d5SLen Brown 
16836574a5d5SLen Brown 	ratio = (msr >> 56) & 0xFF;
16846574a5d5SLen Brown 	if (ratio)
1685710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 8 active cores\n",
16866574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16876574a5d5SLen Brown 
16886574a5d5SLen Brown 	ratio = (msr >> 48) & 0xFF;
16896574a5d5SLen Brown 	if (ratio)
1690710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 7 active cores\n",
16916574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16926574a5d5SLen Brown 
16936574a5d5SLen Brown 	ratio = (msr >> 40) & 0xFF;
16946574a5d5SLen Brown 	if (ratio)
1695710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 6 active cores\n",
16966574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16976574a5d5SLen Brown 
16986574a5d5SLen Brown 	ratio = (msr >> 32) & 0xFF;
16996574a5d5SLen Brown 	if (ratio)
1700710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 5 active cores\n",
17016574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
17026574a5d5SLen Brown 
1703103a8feaSLen Brown 	ratio = (msr >> 24) & 0xFF;
1704103a8feaSLen Brown 	if (ratio)
1705710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 4 active cores\n",
1706103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1707103a8feaSLen Brown 
1708103a8feaSLen Brown 	ratio = (msr >> 16) & 0xFF;
1709103a8feaSLen Brown 	if (ratio)
1710710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 3 active cores\n",
1711103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1712103a8feaSLen Brown 
1713103a8feaSLen Brown 	ratio = (msr >> 8) & 0xFF;
1714103a8feaSLen Brown 	if (ratio)
1715710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 2 active cores\n",
1716103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1717103a8feaSLen Brown 
1718103a8feaSLen Brown 	ratio = (msr >> 0) & 0xFF;
1719103a8feaSLen Brown 	if (ratio)
1720710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 1 active cores\n",
1721103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1722fcd17211SLen Brown 	return;
1723fcd17211SLen Brown }
17243a9a941dSLen Brown 
1725fcd17211SLen Brown static void
17260f7887c4SLen Brown dump_atom_turbo_ratio_limits(void)
17270f7887c4SLen Brown {
17280f7887c4SLen Brown 	unsigned long long msr;
17290f7887c4SLen Brown 	unsigned int ratio;
17300f7887c4SLen Brown 
17310f7887c4SLen Brown 	get_msr(base_cpu, MSR_ATOM_CORE_RATIOS, &msr);
17320f7887c4SLen Brown 	fprintf(outf, "cpu%d: MSR_ATOM_CORE_RATIOS: 0x%08llx\n", base_cpu, msr & 0xFFFFFFFF);
17330f7887c4SLen Brown 
17340f7887c4SLen Brown 	ratio = (msr >> 0) & 0x3F;
17350f7887c4SLen Brown 	if (ratio)
17360f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz minimum operating frequency\n",
17370f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17380f7887c4SLen Brown 
17390f7887c4SLen Brown 	ratio = (msr >> 8) & 0x3F;
17400f7887c4SLen Brown 	if (ratio)
17410f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz low frequency mode (LFM)\n",
17420f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17430f7887c4SLen Brown 
17440f7887c4SLen Brown 	ratio = (msr >> 16) & 0x3F;
17450f7887c4SLen Brown 	if (ratio)
17460f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz base frequency\n",
17470f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17480f7887c4SLen Brown 
17490f7887c4SLen Brown 	get_msr(base_cpu, MSR_ATOM_CORE_TURBO_RATIOS, &msr);
17500f7887c4SLen Brown 	fprintf(outf, "cpu%d: MSR_ATOM_CORE_TURBO_RATIOS: 0x%08llx\n", base_cpu, msr & 0xFFFFFFFF);
17510f7887c4SLen Brown 
17520f7887c4SLen Brown 	ratio = (msr >> 24) & 0x3F;
17530f7887c4SLen Brown 	if (ratio)
17540f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 4 active cores\n",
17550f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17560f7887c4SLen Brown 
17570f7887c4SLen Brown 	ratio = (msr >> 16) & 0x3F;
17580f7887c4SLen Brown 	if (ratio)
17590f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 3 active cores\n",
17600f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17610f7887c4SLen Brown 
17620f7887c4SLen Brown 	ratio = (msr >> 8) & 0x3F;
17630f7887c4SLen Brown 	if (ratio)
17640f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 2 active cores\n",
17650f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17660f7887c4SLen Brown 
17670f7887c4SLen Brown 	ratio = (msr >> 0) & 0x3F;
17680f7887c4SLen Brown 	if (ratio)
17690f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 1 active core\n",
17700f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17710f7887c4SLen Brown }
17720f7887c4SLen Brown 
17730f7887c4SLen Brown static void
1774fb5d4327SDasaratharaman Chandramouli dump_knl_turbo_ratio_limits(void)
1775fb5d4327SDasaratharaman Chandramouli {
1776cbf97abaSHubert Chrzaniuk 	const unsigned int buckets_no = 7;
1777cbf97abaSHubert Chrzaniuk 
1778fb5d4327SDasaratharaman Chandramouli 	unsigned long long msr;
1779cbf97abaSHubert Chrzaniuk 	int delta_cores, delta_ratio;
1780cbf97abaSHubert Chrzaniuk 	int i, b_nr;
1781cbf97abaSHubert Chrzaniuk 	unsigned int cores[buckets_no];
1782cbf97abaSHubert Chrzaniuk 	unsigned int ratio[buckets_no];
1783fb5d4327SDasaratharaman Chandramouli 
1784ebf5926aSSrinivas Pandruvada 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT, &msr);
1785fb5d4327SDasaratharaman Chandramouli 
1786b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT: 0x%08llx\n",
1787bfae2052SLen Brown 		base_cpu, msr);
1788fb5d4327SDasaratharaman Chandramouli 
1789fb5d4327SDasaratharaman Chandramouli 	/**
1790fb5d4327SDasaratharaman Chandramouli 	 * Turbo encoding in KNL is as follows:
1791cbf97abaSHubert Chrzaniuk 	 * [0] -- Reserved
1792cbf97abaSHubert Chrzaniuk 	 * [7:1] -- Base value of number of active cores of bucket 1.
1793fb5d4327SDasaratharaman Chandramouli 	 * [15:8] -- Base value of freq ratio of bucket 1.
1794fb5d4327SDasaratharaman Chandramouli 	 * [20:16] -- +ve delta of number of active cores of bucket 2.
1795fb5d4327SDasaratharaman Chandramouli 	 * i.e. active cores of bucket 2 =
1796fb5d4327SDasaratharaman Chandramouli 	 * active cores of bucket 1 + delta
1797fb5d4327SDasaratharaman Chandramouli 	 * [23:21] -- Negative delta of freq ratio of bucket 2.
1798fb5d4327SDasaratharaman Chandramouli 	 * i.e. freq ratio of bucket 2 =
1799fb5d4327SDasaratharaman Chandramouli 	 * freq ratio of bucket 1 - delta
1800fb5d4327SDasaratharaman Chandramouli 	 * [28:24]-- +ve delta of number of active cores of bucket 3.
1801fb5d4327SDasaratharaman Chandramouli 	 * [31:29]-- -ve delta of freq ratio of bucket 3.
1802fb5d4327SDasaratharaman Chandramouli 	 * [36:32]-- +ve delta of number of active cores of bucket 4.
1803fb5d4327SDasaratharaman Chandramouli 	 * [39:37]-- -ve delta of freq ratio of bucket 4.
1804fb5d4327SDasaratharaman Chandramouli 	 * [44:40]-- +ve delta of number of active cores of bucket 5.
1805fb5d4327SDasaratharaman Chandramouli 	 * [47:45]-- -ve delta of freq ratio of bucket 5.
1806fb5d4327SDasaratharaman Chandramouli 	 * [52:48]-- +ve delta of number of active cores of bucket 6.
1807fb5d4327SDasaratharaman Chandramouli 	 * [55:53]-- -ve delta of freq ratio of bucket 6.
1808fb5d4327SDasaratharaman Chandramouli 	 * [60:56]-- +ve delta of number of active cores of bucket 7.
1809fb5d4327SDasaratharaman Chandramouli 	 * [63:61]-- -ve delta of freq ratio of bucket 7.
1810fb5d4327SDasaratharaman Chandramouli 	 */
1811fb5d4327SDasaratharaman Chandramouli 
1812cbf97abaSHubert Chrzaniuk 	b_nr = 0;
1813cbf97abaSHubert Chrzaniuk 	cores[b_nr] = (msr & 0xFF) >> 1;
1814cbf97abaSHubert Chrzaniuk 	ratio[b_nr] = (msr >> 8) & 0xFF;
1815cbf97abaSHubert Chrzaniuk 
1816cbf97abaSHubert Chrzaniuk 	for (i = 16; i < 64; i += 8) {
1817fb5d4327SDasaratharaman Chandramouli 		delta_cores = (msr >> i) & 0x1F;
1818cbf97abaSHubert Chrzaniuk 		delta_ratio = (msr >> (i + 5)) & 0x7;
1819fb5d4327SDasaratharaman Chandramouli 
1820cbf97abaSHubert Chrzaniuk 		cores[b_nr + 1] = cores[b_nr] + delta_cores;
1821cbf97abaSHubert Chrzaniuk 		ratio[b_nr + 1] = ratio[b_nr] - delta_ratio;
1822cbf97abaSHubert Chrzaniuk 		b_nr++;
1823fb5d4327SDasaratharaman Chandramouli 	}
1824cbf97abaSHubert Chrzaniuk 
1825cbf97abaSHubert Chrzaniuk 	for (i = buckets_no - 1; i >= 0; i--)
1826cbf97abaSHubert Chrzaniuk 		if (i > 0 ? ratio[i] != ratio[i - 1] : 1)
1827b7d8c148SLen Brown 			fprintf(outf,
1828710f273bSLen Brown 				"%d * %.1f = %.1f MHz max turbo %d active cores\n",
1829cbf97abaSHubert Chrzaniuk 				ratio[i], bclk, ratio[i] * bclk, cores[i]);
1830fb5d4327SDasaratharaman Chandramouli }
1831fb5d4327SDasaratharaman Chandramouli 
1832fb5d4327SDasaratharaman Chandramouli static void
1833fcd17211SLen Brown dump_nhm_cst_cfg(void)
1834fcd17211SLen Brown {
1835fcd17211SLen Brown 	unsigned long long msr;
1836fcd17211SLen Brown 
18371df2e55aSLen Brown 	get_msr(base_cpu, MSR_PKG_CST_CONFIG_CONTROL, &msr);
1838fcd17211SLen Brown 
1839fcd17211SLen Brown #define SNB_C1_AUTO_UNDEMOTE              (1UL << 27)
1840fcd17211SLen Brown #define SNB_C3_AUTO_UNDEMOTE              (1UL << 28)
1841fcd17211SLen Brown 
18421df2e55aSLen Brown 	fprintf(outf, "cpu%d: MSR_PKG_CST_CONFIG_CONTROL: 0x%08llx", base_cpu, msr);
1843fcd17211SLen Brown 
1844b7d8c148SLen Brown 	fprintf(outf, " (%s%s%s%s%slocked: pkg-cstate-limit=%d: %s)\n",
1845fcd17211SLen Brown 		(msr & SNB_C3_AUTO_UNDEMOTE) ? "UNdemote-C3, " : "",
1846fcd17211SLen Brown 		(msr & SNB_C1_AUTO_UNDEMOTE) ? "UNdemote-C1, " : "",
1847fcd17211SLen Brown 		(msr & NHM_C3_AUTO_DEMOTE) ? "demote-C3, " : "",
1848fcd17211SLen Brown 		(msr & NHM_C1_AUTO_DEMOTE) ? "demote-C1, " : "",
1849fcd17211SLen Brown 		(msr & (1 << 15)) ? "" : "UN",
18506c34f160SLen Brown 		(unsigned int)msr & 0xF,
1851fcd17211SLen Brown 		pkg_cstate_limit_strings[pkg_cstate_limit]);
1852fcd17211SLen Brown 	return;
1853103a8feaSLen Brown }
1854103a8feaSLen Brown 
18556fb3143bSLen Brown static void
18566fb3143bSLen Brown dump_config_tdp(void)
18576fb3143bSLen Brown {
18586fb3143bSLen Brown 	unsigned long long msr;
18596fb3143bSLen Brown 
18606fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_NOMINAL, &msr);
1861b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_NOMINAL: 0x%08llx", base_cpu, msr);
1862685b535bSChen Yu 	fprintf(outf, " (base_ratio=%d)\n", (unsigned int)msr & 0xFF);
18636fb3143bSLen Brown 
18646fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_LEVEL_1, &msr);
1865b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_LEVEL_1: 0x%08llx (", base_cpu, msr);
18666fb3143bSLen Brown 	if (msr) {
1867685b535bSChen Yu 		fprintf(outf, "PKG_MIN_PWR_LVL1=%d ", (unsigned int)(msr >> 48) & 0x7FFF);
1868685b535bSChen Yu 		fprintf(outf, "PKG_MAX_PWR_LVL1=%d ", (unsigned int)(msr >> 32) & 0x7FFF);
1869685b535bSChen Yu 		fprintf(outf, "LVL1_RATIO=%d ", (unsigned int)(msr >> 16) & 0xFF);
1870685b535bSChen Yu 		fprintf(outf, "PKG_TDP_LVL1=%d", (unsigned int)(msr) & 0x7FFF);
18716fb3143bSLen Brown 	}
1872b7d8c148SLen Brown 	fprintf(outf, ")\n");
18736fb3143bSLen Brown 
18746fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_LEVEL_2, &msr);
1875b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_LEVEL_2: 0x%08llx (", base_cpu, msr);
18766fb3143bSLen Brown 	if (msr) {
1877685b535bSChen Yu 		fprintf(outf, "PKG_MIN_PWR_LVL2=%d ", (unsigned int)(msr >> 48) & 0x7FFF);
1878685b535bSChen Yu 		fprintf(outf, "PKG_MAX_PWR_LVL2=%d ", (unsigned int)(msr >> 32) & 0x7FFF);
1879685b535bSChen Yu 		fprintf(outf, "LVL2_RATIO=%d ", (unsigned int)(msr >> 16) & 0xFF);
1880685b535bSChen Yu 		fprintf(outf, "PKG_TDP_LVL2=%d", (unsigned int)(msr) & 0x7FFF);
18816fb3143bSLen Brown 	}
1882b7d8c148SLen Brown 	fprintf(outf, ")\n");
18836fb3143bSLen Brown 
18846fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_CONTROL, &msr);
1885b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_CONTROL: 0x%08llx (", base_cpu, msr);
18866fb3143bSLen Brown 	if ((msr) & 0x3)
1887b7d8c148SLen Brown 		fprintf(outf, "TDP_LEVEL=%d ", (unsigned int)(msr) & 0x3);
1888b7d8c148SLen Brown 	fprintf(outf, " lock=%d", (unsigned int)(msr >> 31) & 1);
1889b7d8c148SLen Brown 	fprintf(outf, ")\n");
18906fb3143bSLen Brown 
18916fb3143bSLen Brown 	get_msr(base_cpu, MSR_TURBO_ACTIVATION_RATIO, &msr);
1892b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_ACTIVATION_RATIO: 0x%08llx (", base_cpu, msr);
1893685b535bSChen Yu 	fprintf(outf, "MAX_NON_TURBO_RATIO=%d", (unsigned int)(msr) & 0xFF);
1894b7d8c148SLen Brown 	fprintf(outf, " lock=%d", (unsigned int)(msr >> 31) & 1);
1895b7d8c148SLen Brown 	fprintf(outf, ")\n");
18966fb3143bSLen Brown }
18975a63426eSLen Brown 
18985a63426eSLen Brown unsigned int irtl_time_units[] = {1, 32, 1024, 32768, 1048576, 33554432, 0, 0 };
18995a63426eSLen Brown 
19005a63426eSLen Brown void print_irtl(void)
19015a63426eSLen Brown {
19025a63426eSLen Brown 	unsigned long long msr;
19035a63426eSLen Brown 
19045a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC3_IRTL, &msr);
19055a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC3_IRTL: 0x%08llx (", base_cpu, msr);
19065a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19075a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19085a63426eSLen Brown 
19095a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC6_IRTL, &msr);
19105a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC6_IRTL: 0x%08llx (", base_cpu, msr);
19115a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19125a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19135a63426eSLen Brown 
19145a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC7_IRTL, &msr);
19155a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC7_IRTL: 0x%08llx (", base_cpu, msr);
19165a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19175a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19185a63426eSLen Brown 
19195a63426eSLen Brown 	if (!do_irtl_hsw)
19205a63426eSLen Brown 		return;
19215a63426eSLen Brown 
19225a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC8_IRTL, &msr);
19235a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC8_IRTL: 0x%08llx (", base_cpu, msr);
19245a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19255a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19265a63426eSLen Brown 
19275a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC9_IRTL, &msr);
19285a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC9_IRTL: 0x%08llx (", base_cpu, msr);
19295a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19305a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19315a63426eSLen Brown 
19325a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC10_IRTL, &msr);
19335a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC10_IRTL: 0x%08llx (", base_cpu, msr);
19345a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19355a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19365a63426eSLen Brown 
19375a63426eSLen Brown }
193836229897SLen Brown void free_fd_percpu(void)
193936229897SLen Brown {
194036229897SLen Brown 	int i;
194136229897SLen Brown 
194201a67adfSMika Westerberg 	for (i = 0; i < topo.max_cpu_num + 1; ++i) {
194336229897SLen Brown 		if (fd_percpu[i] != 0)
194436229897SLen Brown 			close(fd_percpu[i]);
194536229897SLen Brown 	}
194636229897SLen Brown 
194736229897SLen Brown 	free(fd_percpu);
19486fb3143bSLen Brown }
19496fb3143bSLen Brown 
1950c98d5d94SLen Brown void free_all_buffers(void)
1951103a8feaSLen Brown {
1952c98d5d94SLen Brown 	CPU_FREE(cpu_present_set);
1953c98d5d94SLen Brown 	cpu_present_set = NULL;
195436229897SLen Brown 	cpu_present_setsize = 0;
1955103a8feaSLen Brown 
1956c98d5d94SLen Brown 	CPU_FREE(cpu_affinity_set);
1957c98d5d94SLen Brown 	cpu_affinity_set = NULL;
1958c98d5d94SLen Brown 	cpu_affinity_setsize = 0;
1959103a8feaSLen Brown 
1960c98d5d94SLen Brown 	free(thread_even);
1961c98d5d94SLen Brown 	free(core_even);
1962c98d5d94SLen Brown 	free(package_even);
1963103a8feaSLen Brown 
1964c98d5d94SLen Brown 	thread_even = NULL;
1965c98d5d94SLen Brown 	core_even = NULL;
1966c98d5d94SLen Brown 	package_even = NULL;
1967103a8feaSLen Brown 
1968c98d5d94SLen Brown 	free(thread_odd);
1969c98d5d94SLen Brown 	free(core_odd);
1970c98d5d94SLen Brown 	free(package_odd);
1971103a8feaSLen Brown 
1972c98d5d94SLen Brown 	thread_odd = NULL;
1973c98d5d94SLen Brown 	core_odd = NULL;
1974c98d5d94SLen Brown 	package_odd = NULL;
1975103a8feaSLen Brown 
1976c98d5d94SLen Brown 	free(output_buffer);
1977c98d5d94SLen Brown 	output_buffer = NULL;
1978c98d5d94SLen Brown 	outp = NULL;
197936229897SLen Brown 
198036229897SLen Brown 	free_fd_percpu();
1981562a2d37SLen Brown 
1982562a2d37SLen Brown 	free(irq_column_2_cpu);
1983562a2d37SLen Brown 	free(irqs_per_cpu);
1984103a8feaSLen Brown }
1985103a8feaSLen Brown 
1986103a8feaSLen Brown /*
198757a42a34SJosh Triplett  * Open a file, and exit on failure
198857a42a34SJosh Triplett  */
198957a42a34SJosh Triplett FILE *fopen_or_die(const char *path, const char *mode)
199057a42a34SJosh Triplett {
1991b7d8c148SLen Brown 	FILE *filep = fopen(path, mode);
1992b2c95d90SJosh Triplett 	if (!filep)
1993b2c95d90SJosh Triplett 		err(1, "%s: open failed", path);
199457a42a34SJosh Triplett 	return filep;
199557a42a34SJosh Triplett }
199657a42a34SJosh Triplett 
199757a42a34SJosh Triplett /*
199895aebc44SJosh Triplett  * Parse a file containing a single int.
199995aebc44SJosh Triplett  */
200095aebc44SJosh Triplett int parse_int_file(const char *fmt, ...)
200195aebc44SJosh Triplett {
200295aebc44SJosh Triplett 	va_list args;
200395aebc44SJosh Triplett 	char path[PATH_MAX];
200495aebc44SJosh Triplett 	FILE *filep;
200595aebc44SJosh Triplett 	int value;
200695aebc44SJosh Triplett 
200795aebc44SJosh Triplett 	va_start(args, fmt);
200895aebc44SJosh Triplett 	vsnprintf(path, sizeof(path), fmt, args);
200995aebc44SJosh Triplett 	va_end(args);
201057a42a34SJosh Triplett 	filep = fopen_or_die(path, "r");
2011b2c95d90SJosh Triplett 	if (fscanf(filep, "%d", &value) != 1)
2012b2c95d90SJosh Triplett 		err(1, "%s: failed to parse number from file", path);
201395aebc44SJosh Triplett 	fclose(filep);
201495aebc44SJosh Triplett 	return value;
201595aebc44SJosh Triplett }
201695aebc44SJosh Triplett 
201795aebc44SJosh Triplett /*
2018e275b388SDasaratharaman Chandramouli  * get_cpu_position_in_core(cpu)
2019e275b388SDasaratharaman Chandramouli  * return the position of the CPU among its HT siblings in the core
2020e275b388SDasaratharaman Chandramouli  * return -1 if the sibling is not in list
2021103a8feaSLen Brown  */
2022e275b388SDasaratharaman Chandramouli int get_cpu_position_in_core(int cpu)
2023103a8feaSLen Brown {
2024e275b388SDasaratharaman Chandramouli 	char path[64];
2025e275b388SDasaratharaman Chandramouli 	FILE *filep;
2026e275b388SDasaratharaman Chandramouli 	int this_cpu;
2027e275b388SDasaratharaman Chandramouli 	char character;
2028e275b388SDasaratharaman Chandramouli 	int i;
2029e275b388SDasaratharaman Chandramouli 
2030e275b388SDasaratharaman Chandramouli 	sprintf(path,
2031e275b388SDasaratharaman Chandramouli 		"/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list",
2032e275b388SDasaratharaman Chandramouli 		cpu);
2033e275b388SDasaratharaman Chandramouli 	filep = fopen(path, "r");
2034e275b388SDasaratharaman Chandramouli 	if (filep == NULL) {
2035e275b388SDasaratharaman Chandramouli 		perror(path);
2036e275b388SDasaratharaman Chandramouli 		exit(1);
2037e275b388SDasaratharaman Chandramouli 	}
2038e275b388SDasaratharaman Chandramouli 
2039e275b388SDasaratharaman Chandramouli 	for (i = 0; i < topo.num_threads_per_core; i++) {
2040e275b388SDasaratharaman Chandramouli 		fscanf(filep, "%d", &this_cpu);
2041e275b388SDasaratharaman Chandramouli 		if (this_cpu == cpu) {
2042e275b388SDasaratharaman Chandramouli 			fclose(filep);
2043e275b388SDasaratharaman Chandramouli 			return i;
2044e275b388SDasaratharaman Chandramouli 		}
2045e275b388SDasaratharaman Chandramouli 
2046e275b388SDasaratharaman Chandramouli 		/* Account for no separator after last thread*/
2047e275b388SDasaratharaman Chandramouli 		if (i != (topo.num_threads_per_core - 1))
2048e275b388SDasaratharaman Chandramouli 			fscanf(filep, "%c", &character);
2049e275b388SDasaratharaman Chandramouli 	}
2050e275b388SDasaratharaman Chandramouli 
2051e275b388SDasaratharaman Chandramouli 	fclose(filep);
2052e275b388SDasaratharaman Chandramouli 	return -1;
2053c98d5d94SLen Brown }
2054103a8feaSLen Brown 
2055c98d5d94SLen Brown /*
2056c98d5d94SLen Brown  * cpu_is_first_core_in_package(cpu)
2057c98d5d94SLen Brown  * return 1 if given CPU is 1st core in package
2058c98d5d94SLen Brown  */
2059c98d5d94SLen Brown int cpu_is_first_core_in_package(int cpu)
2060c98d5d94SLen Brown {
206195aebc44SJosh Triplett 	return cpu == parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_siblings_list", cpu);
2062103a8feaSLen Brown }
2063103a8feaSLen Brown 
2064103a8feaSLen Brown int get_physical_package_id(int cpu)
2065103a8feaSLen Brown {
206695aebc44SJosh Triplett 	return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu);
2067103a8feaSLen Brown }
2068103a8feaSLen Brown 
2069103a8feaSLen Brown int get_core_id(int cpu)
2070103a8feaSLen Brown {
207195aebc44SJosh Triplett 	return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_id", cpu);
2072103a8feaSLen Brown }
2073103a8feaSLen Brown 
2074c98d5d94SLen Brown int get_num_ht_siblings(int cpu)
2075c98d5d94SLen Brown {
2076c98d5d94SLen Brown 	char path[80];
2077c98d5d94SLen Brown 	FILE *filep;
2078e275b388SDasaratharaman Chandramouli 	int sib1;
2079e275b388SDasaratharaman Chandramouli 	int matches = 0;
2080c98d5d94SLen Brown 	char character;
2081e275b388SDasaratharaman Chandramouli 	char str[100];
2082e275b388SDasaratharaman Chandramouli 	char *ch;
2083c98d5d94SLen Brown 
2084c98d5d94SLen Brown 	sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
208557a42a34SJosh Triplett 	filep = fopen_or_die(path, "r");
2086e275b388SDasaratharaman Chandramouli 
2087103a8feaSLen Brown 	/*
2088c98d5d94SLen Brown 	 * file format:
2089e275b388SDasaratharaman Chandramouli 	 * A ',' separated or '-' separated set of numbers
2090e275b388SDasaratharaman Chandramouli 	 * (eg 1-2 or 1,3,4,5)
2091c98d5d94SLen Brown 	 */
2092e275b388SDasaratharaman Chandramouli 	fscanf(filep, "%d%c\n", &sib1, &character);
2093e275b388SDasaratharaman Chandramouli 	fseek(filep, 0, SEEK_SET);
2094e275b388SDasaratharaman Chandramouli 	fgets(str, 100, filep);
2095e275b388SDasaratharaman Chandramouli 	ch = strchr(str, character);
2096e275b388SDasaratharaman Chandramouli 	while (ch != NULL) {
2097e275b388SDasaratharaman Chandramouli 		matches++;
2098e275b388SDasaratharaman Chandramouli 		ch = strchr(ch+1, character);
2099e275b388SDasaratharaman Chandramouli 	}
2100c98d5d94SLen Brown 
2101c98d5d94SLen Brown 	fclose(filep);
2102e275b388SDasaratharaman Chandramouli 	return matches+1;
2103c98d5d94SLen Brown }
2104c98d5d94SLen Brown 
2105c98d5d94SLen Brown /*
2106c98d5d94SLen Brown  * run func(thread, core, package) in topology order
2107c98d5d94SLen Brown  * skip non-present cpus
2108103a8feaSLen Brown  */
2109103a8feaSLen Brown 
2110c98d5d94SLen Brown int for_all_cpus_2(int (func)(struct thread_data *, struct core_data *,
2111c98d5d94SLen Brown 	struct pkg_data *, struct thread_data *, struct core_data *,
2112c98d5d94SLen Brown 	struct pkg_data *), struct thread_data *thread_base,
2113c98d5d94SLen Brown 	struct core_data *core_base, struct pkg_data *pkg_base,
2114c98d5d94SLen Brown 	struct thread_data *thread_base2, struct core_data *core_base2,
2115c98d5d94SLen Brown 	struct pkg_data *pkg_base2)
2116c98d5d94SLen Brown {
2117c98d5d94SLen Brown 	int retval, pkg_no, core_no, thread_no;
2118c98d5d94SLen Brown 
2119c98d5d94SLen Brown 	for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
2120c98d5d94SLen Brown 		for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
2121c98d5d94SLen Brown 			for (thread_no = 0; thread_no <
2122c98d5d94SLen Brown 				topo.num_threads_per_core; ++thread_no) {
2123c98d5d94SLen Brown 				struct thread_data *t, *t2;
2124c98d5d94SLen Brown 				struct core_data *c, *c2;
2125c98d5d94SLen Brown 				struct pkg_data *p, *p2;
2126c98d5d94SLen Brown 
2127c98d5d94SLen Brown 				t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
2128c98d5d94SLen Brown 
2129c98d5d94SLen Brown 				if (cpu_is_not_present(t->cpu_id))
2130c98d5d94SLen Brown 					continue;
2131c98d5d94SLen Brown 
2132c98d5d94SLen Brown 				t2 = GET_THREAD(thread_base2, thread_no, core_no, pkg_no);
2133c98d5d94SLen Brown 
2134c98d5d94SLen Brown 				c = GET_CORE(core_base, core_no, pkg_no);
2135c98d5d94SLen Brown 				c2 = GET_CORE(core_base2, core_no, pkg_no);
2136c98d5d94SLen Brown 
2137c98d5d94SLen Brown 				p = GET_PKG(pkg_base, pkg_no);
2138c98d5d94SLen Brown 				p2 = GET_PKG(pkg_base2, pkg_no);
2139c98d5d94SLen Brown 
2140c98d5d94SLen Brown 				retval = func(t, c, p, t2, c2, p2);
2141c98d5d94SLen Brown 				if (retval)
2142c98d5d94SLen Brown 					return retval;
2143c98d5d94SLen Brown 			}
2144c98d5d94SLen Brown 		}
2145c98d5d94SLen Brown 	}
2146c98d5d94SLen Brown 	return 0;
2147c98d5d94SLen Brown }
2148c98d5d94SLen Brown 
2149c98d5d94SLen Brown /*
2150c98d5d94SLen Brown  * run func(cpu) on every cpu in /proc/stat
2151c98d5d94SLen Brown  * return max_cpu number
2152c98d5d94SLen Brown  */
2153c98d5d94SLen Brown int for_all_proc_cpus(int (func)(int))
2154103a8feaSLen Brown {
2155103a8feaSLen Brown 	FILE *fp;
2156c98d5d94SLen Brown 	int cpu_num;
2157103a8feaSLen Brown 	int retval;
2158103a8feaSLen Brown 
215957a42a34SJosh Triplett 	fp = fopen_or_die(proc_stat, "r");
2160103a8feaSLen Brown 
2161103a8feaSLen Brown 	retval = fscanf(fp, "cpu %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n");
2162b2c95d90SJosh Triplett 	if (retval != 0)
2163b2c95d90SJosh Triplett 		err(1, "%s: failed to parse format", proc_stat);
2164103a8feaSLen Brown 
2165c98d5d94SLen Brown 	while (1) {
2166c98d5d94SLen Brown 		retval = fscanf(fp, "cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n", &cpu_num);
2167103a8feaSLen Brown 		if (retval != 1)
2168103a8feaSLen Brown 			break;
2169103a8feaSLen Brown 
2170c98d5d94SLen Brown 		retval = func(cpu_num);
2171c98d5d94SLen Brown 		if (retval) {
2172c98d5d94SLen Brown 			fclose(fp);
2173c98d5d94SLen Brown 			return(retval);
2174c98d5d94SLen Brown 		}
2175103a8feaSLen Brown 	}
2176103a8feaSLen Brown 	fclose(fp);
2177c98d5d94SLen Brown 	return 0;
2178103a8feaSLen Brown }
2179103a8feaSLen Brown 
2180103a8feaSLen Brown void re_initialize(void)
2181103a8feaSLen Brown {
2182c98d5d94SLen Brown 	free_all_buffers();
2183c98d5d94SLen Brown 	setup_all_buffers();
2184c98d5d94SLen Brown 	printf("turbostat: re-initialized with num_cpus %d\n", topo.num_cpus);
2185103a8feaSLen Brown }
2186103a8feaSLen Brown 
2187c98d5d94SLen Brown 
2188103a8feaSLen Brown /*
2189c98d5d94SLen Brown  * count_cpus()
2190c98d5d94SLen Brown  * remember the last one seen, it will be the max
2191103a8feaSLen Brown  */
2192c98d5d94SLen Brown int count_cpus(int cpu)
2193103a8feaSLen Brown {
2194c98d5d94SLen Brown 	if (topo.max_cpu_num < cpu)
2195c98d5d94SLen Brown 		topo.max_cpu_num = cpu;
2196103a8feaSLen Brown 
2197c98d5d94SLen Brown 	topo.num_cpus += 1;
2198c98d5d94SLen Brown 	return 0;
2199103a8feaSLen Brown }
2200c98d5d94SLen Brown int mark_cpu_present(int cpu)
2201c98d5d94SLen Brown {
2202c98d5d94SLen Brown 	CPU_SET_S(cpu, cpu_present_setsize, cpu_present_set);
220315aaa346SLen Brown 	return 0;
2204103a8feaSLen Brown }
2205103a8feaSLen Brown 
2206562a2d37SLen Brown /*
2207562a2d37SLen Brown  * snapshot_proc_interrupts()
2208562a2d37SLen Brown  *
2209562a2d37SLen Brown  * read and record summary of /proc/interrupts
2210562a2d37SLen Brown  *
2211562a2d37SLen Brown  * return 1 if config change requires a restart, else return 0
2212562a2d37SLen Brown  */
2213562a2d37SLen Brown int snapshot_proc_interrupts(void)
2214562a2d37SLen Brown {
2215562a2d37SLen Brown 	static FILE *fp;
2216562a2d37SLen Brown 	int column, retval;
2217562a2d37SLen Brown 
2218562a2d37SLen Brown 	if (fp == NULL)
2219562a2d37SLen Brown 		fp = fopen_or_die("/proc/interrupts", "r");
2220562a2d37SLen Brown 	else
2221562a2d37SLen Brown 		rewind(fp);
2222562a2d37SLen Brown 
2223562a2d37SLen Brown 	/* read 1st line of /proc/interrupts to get cpu* name for each column */
2224562a2d37SLen Brown 	for (column = 0; column < topo.num_cpus; ++column) {
2225562a2d37SLen Brown 		int cpu_number;
2226562a2d37SLen Brown 
2227562a2d37SLen Brown 		retval = fscanf(fp, " CPU%d", &cpu_number);
2228562a2d37SLen Brown 		if (retval != 1)
2229562a2d37SLen Brown 			break;
2230562a2d37SLen Brown 
2231562a2d37SLen Brown 		if (cpu_number > topo.max_cpu_num) {
2232562a2d37SLen Brown 			warn("/proc/interrupts: cpu%d: > %d", cpu_number, topo.max_cpu_num);
2233562a2d37SLen Brown 			return 1;
2234562a2d37SLen Brown 		}
2235562a2d37SLen Brown 
2236562a2d37SLen Brown 		irq_column_2_cpu[column] = cpu_number;
2237562a2d37SLen Brown 		irqs_per_cpu[cpu_number] = 0;
2238562a2d37SLen Brown 	}
2239562a2d37SLen Brown 
2240562a2d37SLen Brown 	/* read /proc/interrupt count lines and sum up irqs per cpu */
2241562a2d37SLen Brown 	while (1) {
2242562a2d37SLen Brown 		int column;
2243562a2d37SLen Brown 		char buf[64];
2244562a2d37SLen Brown 
2245562a2d37SLen Brown 		retval = fscanf(fp, " %s:", buf);	/* flush irq# "N:" */
2246562a2d37SLen Brown 		if (retval != 1)
2247562a2d37SLen Brown 			break;
2248562a2d37SLen Brown 
2249562a2d37SLen Brown 		/* read the count per cpu */
2250562a2d37SLen Brown 		for (column = 0; column < topo.num_cpus; ++column) {
2251562a2d37SLen Brown 
2252562a2d37SLen Brown 			int cpu_number, irq_count;
2253562a2d37SLen Brown 
2254562a2d37SLen Brown 			retval = fscanf(fp, " %d", &irq_count);
2255562a2d37SLen Brown 			if (retval != 1)
2256562a2d37SLen Brown 				break;
2257562a2d37SLen Brown 
2258562a2d37SLen Brown 			cpu_number = irq_column_2_cpu[column];
2259562a2d37SLen Brown 			irqs_per_cpu[cpu_number] += irq_count;
2260562a2d37SLen Brown 
2261562a2d37SLen Brown 		}
2262562a2d37SLen Brown 
2263562a2d37SLen Brown 		while (getc(fp) != '\n')
2264562a2d37SLen Brown 			;	/* flush interrupt description */
2265562a2d37SLen Brown 
2266562a2d37SLen Brown 	}
2267562a2d37SLen Brown 	return 0;
2268562a2d37SLen Brown }
226927d47356SLen Brown /*
2270fdf676e5SLen Brown  * snapshot_gfx_rc6_ms()
2271fdf676e5SLen Brown  *
2272fdf676e5SLen Brown  * record snapshot of
2273fdf676e5SLen Brown  * /sys/class/drm/card0/power/rc6_residency_ms
2274fdf676e5SLen Brown  *
2275fdf676e5SLen Brown  * return 1 if config change requires a restart, else return 0
2276fdf676e5SLen Brown  */
2277fdf676e5SLen Brown int snapshot_gfx_rc6_ms(void)
2278fdf676e5SLen Brown {
2279fdf676e5SLen Brown 	FILE *fp;
2280fdf676e5SLen Brown 	int retval;
2281fdf676e5SLen Brown 
2282fdf676e5SLen Brown 	fp = fopen_or_die("/sys/class/drm/card0/power/rc6_residency_ms", "r");
2283fdf676e5SLen Brown 
2284fdf676e5SLen Brown 	retval = fscanf(fp, "%lld", &gfx_cur_rc6_ms);
2285fdf676e5SLen Brown 	if (retval != 1)
2286fdf676e5SLen Brown 		err(1, "GFX rc6");
2287fdf676e5SLen Brown 
2288fdf676e5SLen Brown 	fclose(fp);
2289fdf676e5SLen Brown 
2290fdf676e5SLen Brown 	return 0;
2291fdf676e5SLen Brown }
2292fdf676e5SLen Brown /*
229327d47356SLen Brown  * snapshot_gfx_mhz()
229427d47356SLen Brown  *
229527d47356SLen Brown  * record snapshot of
229627d47356SLen Brown  * /sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz
229727d47356SLen Brown  *
229827d47356SLen Brown  * return 1 if config change requires a restart, else return 0
229927d47356SLen Brown  */
230027d47356SLen Brown int snapshot_gfx_mhz(void)
230127d47356SLen Brown {
230227d47356SLen Brown 	static FILE *fp;
230327d47356SLen Brown 	int retval;
230427d47356SLen Brown 
230527d47356SLen Brown 	if (fp == NULL)
230627d47356SLen Brown 		fp = fopen_or_die("/sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz", "r");
230727d47356SLen Brown 	else
230827d47356SLen Brown 		rewind(fp);
230927d47356SLen Brown 
231027d47356SLen Brown 	retval = fscanf(fp, "%d", &gfx_cur_mhz);
231127d47356SLen Brown 	if (retval != 1)
231227d47356SLen Brown 		err(1, "GFX MHz");
231327d47356SLen Brown 
231427d47356SLen Brown 	return 0;
231527d47356SLen Brown }
2316562a2d37SLen Brown 
2317562a2d37SLen Brown /*
2318562a2d37SLen Brown  * snapshot /proc and /sys files
2319562a2d37SLen Brown  *
2320562a2d37SLen Brown  * return 1 if configuration restart needed, else return 0
2321562a2d37SLen Brown  */
2322562a2d37SLen Brown int snapshot_proc_sysfs_files(void)
2323562a2d37SLen Brown {
2324562a2d37SLen Brown 	if (snapshot_proc_interrupts())
2325562a2d37SLen Brown 		return 1;
2326562a2d37SLen Brown 
2327812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6))
2328fdf676e5SLen Brown 		snapshot_gfx_rc6_ms();
2329fdf676e5SLen Brown 
2330812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
233127d47356SLen Brown 		snapshot_gfx_mhz();
233227d47356SLen Brown 
2333562a2d37SLen Brown 	return 0;
2334562a2d37SLen Brown }
2335562a2d37SLen Brown 
2336103a8feaSLen Brown void turbostat_loop()
2337103a8feaSLen Brown {
2338c98d5d94SLen Brown 	int retval;
2339e52966c0SLen Brown 	int restarted = 0;
2340c98d5d94SLen Brown 
2341103a8feaSLen Brown restart:
2342e52966c0SLen Brown 	restarted++;
2343e52966c0SLen Brown 
2344562a2d37SLen Brown 	snapshot_proc_sysfs_files();
2345c98d5d94SLen Brown 	retval = for_all_cpus(get_counters, EVEN_COUNTERS);
2346d91bb17cSLen Brown 	if (retval < -1) {
2347d91bb17cSLen Brown 		exit(retval);
2348d91bb17cSLen Brown 	} else if (retval == -1) {
2349e52966c0SLen Brown 		if (restarted > 1) {
2350e52966c0SLen Brown 			exit(retval);
2351e52966c0SLen Brown 		}
2352c98d5d94SLen Brown 		re_initialize();
2353c98d5d94SLen Brown 		goto restart;
2354c98d5d94SLen Brown 	}
2355e52966c0SLen Brown 	restarted = 0;
2356103a8feaSLen Brown 	gettimeofday(&tv_even, (struct timezone *)NULL);
2357103a8feaSLen Brown 
2358103a8feaSLen Brown 	while (1) {
2359c98d5d94SLen Brown 		if (for_all_proc_cpus(cpu_is_not_present)) {
2360103a8feaSLen Brown 			re_initialize();
2361103a8feaSLen Brown 			goto restart;
2362103a8feaSLen Brown 		}
23632a0609c0SLen Brown 		nanosleep(&interval_ts, NULL);
2364562a2d37SLen Brown 		if (snapshot_proc_sysfs_files())
2365562a2d37SLen Brown 			goto restart;
2366c98d5d94SLen Brown 		retval = for_all_cpus(get_counters, ODD_COUNTERS);
2367d91bb17cSLen Brown 		if (retval < -1) {
2368d91bb17cSLen Brown 			exit(retval);
2369d91bb17cSLen Brown 		} else if (retval == -1) {
237015aaa346SLen Brown 			re_initialize();
237115aaa346SLen Brown 			goto restart;
237215aaa346SLen Brown 		}
2373103a8feaSLen Brown 		gettimeofday(&tv_odd, (struct timezone *)NULL);
2374103a8feaSLen Brown 		timersub(&tv_odd, &tv_even, &tv_delta);
2375ba3dec99SLen Brown 		if (for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS)) {
2376ba3dec99SLen Brown 			re_initialize();
2377ba3dec99SLen Brown 			goto restart;
2378ba3dec99SLen Brown 		}
2379c98d5d94SLen Brown 		compute_average(EVEN_COUNTERS);
2380c98d5d94SLen Brown 		format_all_counters(EVEN_COUNTERS);
2381b7d8c148SLen Brown 		flush_output_stdout();
23822a0609c0SLen Brown 		nanosleep(&interval_ts, NULL);
2383562a2d37SLen Brown 		if (snapshot_proc_sysfs_files())
2384562a2d37SLen Brown 			goto restart;
2385c98d5d94SLen Brown 		retval = for_all_cpus(get_counters, EVEN_COUNTERS);
2386d91bb17cSLen Brown 		if (retval < -1) {
2387d91bb17cSLen Brown 			exit(retval);
2388d91bb17cSLen Brown 		} else if (retval == -1) {
2389103a8feaSLen Brown 			re_initialize();
2390103a8feaSLen Brown 			goto restart;
2391103a8feaSLen Brown 		}
2392103a8feaSLen Brown 		gettimeofday(&tv_even, (struct timezone *)NULL);
2393103a8feaSLen Brown 		timersub(&tv_even, &tv_odd, &tv_delta);
2394ba3dec99SLen Brown 		if (for_all_cpus_2(delta_cpu, EVEN_COUNTERS, ODD_COUNTERS)) {
2395ba3dec99SLen Brown 			re_initialize();
2396ba3dec99SLen Brown 			goto restart;
2397ba3dec99SLen Brown 		}
2398c98d5d94SLen Brown 		compute_average(ODD_COUNTERS);
2399c98d5d94SLen Brown 		format_all_counters(ODD_COUNTERS);
2400b7d8c148SLen Brown 		flush_output_stdout();
2401103a8feaSLen Brown 	}
2402103a8feaSLen Brown }
2403103a8feaSLen Brown 
2404103a8feaSLen Brown void check_dev_msr()
2405103a8feaSLen Brown {
2406103a8feaSLen Brown 	struct stat sb;
24077ce7d5deSPrarit Bhargava 	char pathname[32];
2408103a8feaSLen Brown 
24097ce7d5deSPrarit Bhargava 	sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
24107ce7d5deSPrarit Bhargava 	if (stat(pathname, &sb))
2411a21d38c8SLen Brown  		if (system("/sbin/modprobe msr > /dev/null 2>&1"))
2412d7899447SLen Brown 			err(-5, "no /dev/cpu/0/msr, Try \"# modprobe msr\" ");
2413103a8feaSLen Brown }
2414103a8feaSLen Brown 
241598481e79SLen Brown void check_permissions()
2416103a8feaSLen Brown {
241798481e79SLen Brown 	struct __user_cap_header_struct cap_header_data;
241898481e79SLen Brown 	cap_user_header_t cap_header = &cap_header_data;
241998481e79SLen Brown 	struct __user_cap_data_struct cap_data_data;
242098481e79SLen Brown 	cap_user_data_t cap_data = &cap_data_data;
242198481e79SLen Brown 	extern int capget(cap_user_header_t hdrp, cap_user_data_t datap);
242298481e79SLen Brown 	int do_exit = 0;
24237ce7d5deSPrarit Bhargava 	char pathname[32];
242498481e79SLen Brown 
242598481e79SLen Brown 	/* check for CAP_SYS_RAWIO */
242698481e79SLen Brown 	cap_header->pid = getpid();
242798481e79SLen Brown 	cap_header->version = _LINUX_CAPABILITY_VERSION;
242898481e79SLen Brown 	if (capget(cap_header, cap_data) < 0)
242998481e79SLen Brown 		err(-6, "capget(2) failed");
243098481e79SLen Brown 
243198481e79SLen Brown 	if ((cap_data->effective & (1 << CAP_SYS_RAWIO)) == 0) {
243298481e79SLen Brown 		do_exit++;
243398481e79SLen Brown 		warnx("capget(CAP_SYS_RAWIO) failed,"
243498481e79SLen Brown 			" try \"# setcap cap_sys_rawio=ep %s\"", progname);
243598481e79SLen Brown 	}
243698481e79SLen Brown 
243798481e79SLen Brown 	/* test file permissions */
24387ce7d5deSPrarit Bhargava 	sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
24397ce7d5deSPrarit Bhargava 	if (euidaccess(pathname, R_OK)) {
244098481e79SLen Brown 		do_exit++;
244198481e79SLen Brown 		warn("/dev/cpu/0/msr open failed, try chown or chmod +r /dev/cpu/*/msr");
244298481e79SLen Brown 	}
244398481e79SLen Brown 
244498481e79SLen Brown 	/* if all else fails, thell them to be root */
244598481e79SLen Brown 	if (do_exit)
2446b2c95d90SJosh Triplett 		if (getuid() != 0)
2447d7899447SLen Brown 			warnx("... or simply run as root");
244898481e79SLen Brown 
244998481e79SLen Brown 	if (do_exit)
245098481e79SLen Brown 		exit(-6);
2451103a8feaSLen Brown }
2452103a8feaSLen Brown 
2453d7899447SLen Brown /*
2454d7899447SLen Brown  * NHM adds support for additional MSRs:
2455d7899447SLen Brown  *
2456d7899447SLen Brown  * MSR_SMI_COUNT                   0x00000034
2457d7899447SLen Brown  *
2458ec0adc53SLen Brown  * MSR_PLATFORM_INFO               0x000000ce
24591df2e55aSLen Brown  * MSR_PKG_CST_CONFIG_CONTROL     0x000000e2
2460d7899447SLen Brown  *
2461cf4cbe53SLen Brown  * MSR_MISC_PWR_MGMT               0x000001aa
2462cf4cbe53SLen Brown  *
2463d7899447SLen Brown  * MSR_PKG_C3_RESIDENCY            0x000003f8
2464d7899447SLen Brown  * MSR_PKG_C6_RESIDENCY            0x000003f9
2465d7899447SLen Brown  * MSR_CORE_C3_RESIDENCY           0x000003fc
2466d7899447SLen Brown  * MSR_CORE_C6_RESIDENCY           0x000003fd
2467d7899447SLen Brown  *
2468ee7e38e3SLen Brown  * Side effect:
24691df2e55aSLen Brown  * sets global pkg_cstate_limit to decode MSR_PKG_CST_CONFIG_CONTROL
2470*33148d67SLen Brown  * sets has_misc_feature_control
2471d7899447SLen Brown  */
2472ee7e38e3SLen Brown int probe_nhm_msrs(unsigned int family, unsigned int model)
2473103a8feaSLen Brown {
2474ee7e38e3SLen Brown 	unsigned long long msr;
247521ed5574SLen Brown 	unsigned int base_ratio;
2476ee7e38e3SLen Brown 	int *pkg_cstate_limits;
2477ee7e38e3SLen Brown 
2478103a8feaSLen Brown 	if (!genuine_intel)
2479103a8feaSLen Brown 		return 0;
2480103a8feaSLen Brown 
2481103a8feaSLen Brown 	if (family != 6)
2482103a8feaSLen Brown 		return 0;
2483103a8feaSLen Brown 
248421ed5574SLen Brown 	bclk = discover_bclk(family, model);
248521ed5574SLen Brown 
2486103a8feaSLen Brown 	switch (model) {
2487869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM_EP:	/* Core i7, Xeon 5500 series - Bloomfield, Gainstown NHM-EP */
2488869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM:	/* Core i7 and i5 Processor - Clarksfield, Lynnfield, Jasper Forest */
2489103a8feaSLen Brown 	case 0x1F:	/* Core i7 and i5 Processor - Nehalem */
2490869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE:	/* Westmere Client - Clarkdale, Arrandale */
2491869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE_EP:	/* Westmere EP - Gulftown */
2492869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM_EX:	/* Nehalem-EX Xeon - Beckton */
2493869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE_EX:	/* Westmere-EX Xeon - Eagleton */
2494ee7e38e3SLen Brown 		pkg_cstate_limits = nhm_pkg_cstate_limits;
2495ee7e38e3SLen Brown 		break;
2496869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE:	/* SNB */
2497869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE_X:	/* SNB Xeon */
2498869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:	/* IVB */
2499869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:	/* IVB Xeon */
2500ee7e38e3SLen Brown 		pkg_cstate_limits = snb_pkg_cstate_limits;
2501*33148d67SLen Brown 		has_misc_feature_control = 1;
2502ee7e38e3SLen Brown 		break;
2503869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
2504869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
2505869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
2506869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
2507869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
2508869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
2509869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
2510869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
2511869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
2512869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
2513869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
2514869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
2515ee7e38e3SLen Brown 		pkg_cstate_limits = hsw_pkg_cstate_limits;
2516*33148d67SLen Brown 		has_misc_feature_control = 1;
2517ee7e38e3SLen Brown 		break;
2518d8ebb442SLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
2519d8ebb442SLen Brown 		pkg_cstate_limits = skx_pkg_cstate_limits;
2520*33148d67SLen Brown 		has_misc_feature_control = 1;
2521d8ebb442SLen Brown 		break;
2522869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:	/* BYT */
2523cf4cbe53SLen Brown 		no_MSR_MISC_PWR_MGMT = 1;
2524869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:	/* AVN */
2525ee7e38e3SLen Brown 		pkg_cstate_limits = slv_pkg_cstate_limits;
2526ee7e38e3SLen Brown 		break;
2527869ce69eSLen Brown 	case INTEL_FAM6_ATOM_AIRMONT:	/* AMT */
2528ee7e38e3SLen Brown 		pkg_cstate_limits = amt_pkg_cstate_limits;
2529cf4cbe53SLen Brown 		no_MSR_MISC_PWR_MGMT = 1;
2530ee7e38e3SLen Brown 		break;
2531869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* PHI */
2532005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
2533ee7e38e3SLen Brown 		pkg_cstate_limits = phi_pkg_cstate_limits;
2534ee7e38e3SLen Brown 		break;
2535869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
2536869ce69eSLen Brown 	case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
2537e4085d54SLen Brown 		pkg_cstate_limits = bxt_pkg_cstate_limits;
2538e4085d54SLen Brown 		break;
2539103a8feaSLen Brown 	default:
2540103a8feaSLen Brown 		return 0;
2541103a8feaSLen Brown 	}
25421df2e55aSLen Brown 	get_msr(base_cpu, MSR_PKG_CST_CONFIG_CONTROL, &msr);
2543e9257f5fSLen Brown 	pkg_cstate_limit = pkg_cstate_limits[msr & 0xF];
2544ee7e38e3SLen Brown 
2545ec0adc53SLen Brown 	get_msr(base_cpu, MSR_PLATFORM_INFO, &msr);
254621ed5574SLen Brown 	base_ratio = (msr >> 8) & 0xFF;
254721ed5574SLen Brown 
254821ed5574SLen Brown 	base_hz = base_ratio * bclk * 1000000;
254921ed5574SLen Brown 	has_base_hz = 1;
2550ee7e38e3SLen Brown 	return 1;
2551103a8feaSLen Brown }
25520f7887c4SLen Brown /*
25530f7887c4SLen Brown  * SLV client has supporet for unique MSRs:
25540f7887c4SLen Brown  *
25550f7887c4SLen Brown  * MSR_CC6_DEMOTION_POLICY_CONFIG
25560f7887c4SLen Brown  * MSR_MC6_DEMOTION_POLICY_CONFIG
25570f7887c4SLen Brown  */
25580f7887c4SLen Brown 
25590f7887c4SLen Brown int has_slv_msrs(unsigned int family, unsigned int model)
25600f7887c4SLen Brown {
25610f7887c4SLen Brown 	if (!genuine_intel)
25620f7887c4SLen Brown 		return 0;
25630f7887c4SLen Brown 
25640f7887c4SLen Brown 	switch (model) {
25650f7887c4SLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:
25660f7887c4SLen Brown 	case INTEL_FAM6_ATOM_MERRIFIELD:
25670f7887c4SLen Brown 	case INTEL_FAM6_ATOM_MOOREFIELD:
25680f7887c4SLen Brown 		return 1;
25690f7887c4SLen Brown 	}
25700f7887c4SLen Brown 	return 0;
25710f7887c4SLen Brown }
25720f7887c4SLen Brown 
2573d7899447SLen Brown int has_nhm_turbo_ratio_limit(unsigned int family, unsigned int model)
2574d7899447SLen Brown {
25750f7887c4SLen Brown 	if (has_slv_msrs(family, model))
25760f7887c4SLen Brown 		return 0;
25770f7887c4SLen Brown 
2578d7899447SLen Brown 	switch (model) {
2579d7899447SLen Brown 	/* Nehalem compatible, but do not include turbo-ratio limit support */
2580869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM_EX:	/* Nehalem-EX Xeon - Beckton */
2581869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE_EX:	/* Westmere-EX Xeon - Eagleton */
2582869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* PHI - Knights Landing (different MSR definition) */
2583005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
2584d7899447SLen Brown 		return 0;
2585d7899447SLen Brown 	default:
2586d7899447SLen Brown 		return 1;
2587d7899447SLen Brown 	}
2588d7899447SLen Brown }
25890f7887c4SLen Brown int has_atom_turbo_ratio_limit(unsigned int family, unsigned int model)
25900f7887c4SLen Brown {
25910f7887c4SLen Brown 	if (has_slv_msrs(family, model))
25920f7887c4SLen Brown 		return 1;
25930f7887c4SLen Brown 
25940f7887c4SLen Brown 	return 0;
25950f7887c4SLen Brown }
25966574a5d5SLen Brown int has_ivt_turbo_ratio_limit(unsigned int family, unsigned int model)
25976574a5d5SLen Brown {
25986574a5d5SLen Brown 	if (!genuine_intel)
25996574a5d5SLen Brown 		return 0;
26006574a5d5SLen Brown 
26016574a5d5SLen Brown 	if (family != 6)
26026574a5d5SLen Brown 		return 0;
26036574a5d5SLen Brown 
26046574a5d5SLen Brown 	switch (model) {
2605869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:	/* IVB Xeon */
2606869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSW Xeon */
26076574a5d5SLen Brown 		return 1;
26086574a5d5SLen Brown 	default:
26096574a5d5SLen Brown 		return 0;
26106574a5d5SLen Brown 	}
26116574a5d5SLen Brown }
2612fcd17211SLen Brown int has_hsw_turbo_ratio_limit(unsigned int family, unsigned int model)
2613fcd17211SLen Brown {
2614fcd17211SLen Brown 	if (!genuine_intel)
2615fcd17211SLen Brown 		return 0;
2616fcd17211SLen Brown 
2617fcd17211SLen Brown 	if (family != 6)
2618fcd17211SLen Brown 		return 0;
2619fcd17211SLen Brown 
2620fcd17211SLen Brown 	switch (model) {
2621869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSW Xeon */
2622fcd17211SLen Brown 		return 1;
2623fcd17211SLen Brown 	default:
2624fcd17211SLen Brown 		return 0;
2625fcd17211SLen Brown 	}
2626fcd17211SLen Brown }
2627fcd17211SLen Brown 
2628fb5d4327SDasaratharaman Chandramouli int has_knl_turbo_ratio_limit(unsigned int family, unsigned int model)
2629fb5d4327SDasaratharaman Chandramouli {
2630fb5d4327SDasaratharaman Chandramouli 	if (!genuine_intel)
2631fb5d4327SDasaratharaman Chandramouli 		return 0;
2632fb5d4327SDasaratharaman Chandramouli 
2633fb5d4327SDasaratharaman Chandramouli 	if (family != 6)
2634fb5d4327SDasaratharaman Chandramouli 		return 0;
2635fb5d4327SDasaratharaman Chandramouli 
2636fb5d4327SDasaratharaman Chandramouli 	switch (model) {
2637869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* Knights Landing */
2638005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
2639fb5d4327SDasaratharaman Chandramouli 		return 1;
2640fb5d4327SDasaratharaman Chandramouli 	default:
2641fb5d4327SDasaratharaman Chandramouli 		return 0;
2642fb5d4327SDasaratharaman Chandramouli 	}
2643fb5d4327SDasaratharaman Chandramouli }
26446fb3143bSLen Brown int has_config_tdp(unsigned int family, unsigned int model)
26456fb3143bSLen Brown {
26466fb3143bSLen Brown 	if (!genuine_intel)
26476fb3143bSLen Brown 		return 0;
26486fb3143bSLen Brown 
26496fb3143bSLen Brown 	if (family != 6)
26506fb3143bSLen Brown 		return 0;
26516fb3143bSLen Brown 
26526fb3143bSLen Brown 	switch (model) {
2653869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:	/* IVB */
2654869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
2655869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
2656869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
2657869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
2658869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
2659869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
2660869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
2661869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
2662869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
2663869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
2664869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
2665869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
2666869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
26676fb3143bSLen Brown 
2668869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* Knights Landing */
2669005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
26706fb3143bSLen Brown 		return 1;
26716fb3143bSLen Brown 	default:
26726fb3143bSLen Brown 		return 0;
26736fb3143bSLen Brown 	}
26746fb3143bSLen Brown }
26756fb3143bSLen Brown 
2676fcd17211SLen Brown static void
26771b69317dSColin Ian King dump_cstate_pstate_config_info(unsigned int family, unsigned int model)
2678fcd17211SLen Brown {
2679fcd17211SLen Brown 	if (!do_nhm_platform_info)
2680fcd17211SLen Brown 		return;
2681fcd17211SLen Brown 
2682fcd17211SLen Brown 	dump_nhm_platform_info();
2683fcd17211SLen Brown 
2684fcd17211SLen Brown 	if (has_hsw_turbo_ratio_limit(family, model))
2685fcd17211SLen Brown 		dump_hsw_turbo_ratio_limits();
2686fcd17211SLen Brown 
2687fcd17211SLen Brown 	if (has_ivt_turbo_ratio_limit(family, model))
2688fcd17211SLen Brown 		dump_ivt_turbo_ratio_limits();
2689fcd17211SLen Brown 
2690fcd17211SLen Brown 	if (has_nhm_turbo_ratio_limit(family, model))
2691fcd17211SLen Brown 		dump_nhm_turbo_ratio_limits();
2692fcd17211SLen Brown 
26930f7887c4SLen Brown 	if (has_atom_turbo_ratio_limit(family, model))
26940f7887c4SLen Brown 		dump_atom_turbo_ratio_limits();
26950f7887c4SLen Brown 
2696fb5d4327SDasaratharaman Chandramouli 	if (has_knl_turbo_ratio_limit(family, model))
2697fb5d4327SDasaratharaman Chandramouli 		dump_knl_turbo_ratio_limits();
2698fb5d4327SDasaratharaman Chandramouli 
26996fb3143bSLen Brown 	if (has_config_tdp(family, model))
27006fb3143bSLen Brown 		dump_config_tdp();
27016fb3143bSLen Brown 
2702fcd17211SLen Brown 	dump_nhm_cst_cfg();
2703fcd17211SLen Brown }
2704fcd17211SLen Brown 
27056574a5d5SLen Brown 
2706889facbeSLen Brown /*
2707889facbeSLen Brown  * print_epb()
2708889facbeSLen Brown  * Decode the ENERGY_PERF_BIAS MSR
2709889facbeSLen Brown  */
2710889facbeSLen Brown int print_epb(struct thread_data *t, struct core_data *c, struct pkg_data *p)
2711889facbeSLen Brown {
2712889facbeSLen Brown 	unsigned long long msr;
2713889facbeSLen Brown 	char *epb_string;
2714889facbeSLen Brown 	int cpu;
2715889facbeSLen Brown 
2716889facbeSLen Brown 	if (!has_epb)
2717889facbeSLen Brown 		return 0;
2718889facbeSLen Brown 
2719889facbeSLen Brown 	cpu = t->cpu_id;
2720889facbeSLen Brown 
2721889facbeSLen Brown 	/* EPB is per-package */
2722889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
2723889facbeSLen Brown 		return 0;
2724889facbeSLen Brown 
2725889facbeSLen Brown 	if (cpu_migrate(cpu)) {
2726b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
2727889facbeSLen Brown 		return -1;
2728889facbeSLen Brown 	}
2729889facbeSLen Brown 
2730889facbeSLen Brown 	if (get_msr(cpu, MSR_IA32_ENERGY_PERF_BIAS, &msr))
2731889facbeSLen Brown 		return 0;
2732889facbeSLen Brown 
2733e9be7dd6SLen Brown 	switch (msr & 0xF) {
2734889facbeSLen Brown 	case ENERGY_PERF_BIAS_PERFORMANCE:
2735889facbeSLen Brown 		epb_string = "performance";
2736889facbeSLen Brown 		break;
2737889facbeSLen Brown 	case ENERGY_PERF_BIAS_NORMAL:
2738889facbeSLen Brown 		epb_string = "balanced";
2739889facbeSLen Brown 		break;
2740889facbeSLen Brown 	case ENERGY_PERF_BIAS_POWERSAVE:
2741889facbeSLen Brown 		epb_string = "powersave";
2742889facbeSLen Brown 		break;
2743889facbeSLen Brown 	default:
2744889facbeSLen Brown 		epb_string = "custom";
2745889facbeSLen Brown 		break;
2746889facbeSLen Brown 	}
2747b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_IA32_ENERGY_PERF_BIAS: 0x%08llx (%s)\n", cpu, msr, epb_string);
2748889facbeSLen Brown 
2749889facbeSLen Brown 	return 0;
2750889facbeSLen Brown }
27517f5c258eSLen Brown /*
27527f5c258eSLen Brown  * print_hwp()
27537f5c258eSLen Brown  * Decode the MSR_HWP_CAPABILITIES
27547f5c258eSLen Brown  */
27557f5c258eSLen Brown int print_hwp(struct thread_data *t, struct core_data *c, struct pkg_data *p)
27567f5c258eSLen Brown {
27577f5c258eSLen Brown 	unsigned long long msr;
27587f5c258eSLen Brown 	int cpu;
27597f5c258eSLen Brown 
27607f5c258eSLen Brown 	if (!has_hwp)
27617f5c258eSLen Brown 		return 0;
27627f5c258eSLen Brown 
27637f5c258eSLen Brown 	cpu = t->cpu_id;
27647f5c258eSLen Brown 
27657f5c258eSLen Brown 	/* MSR_HWP_CAPABILITIES is per-package */
27667f5c258eSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
27677f5c258eSLen Brown 		return 0;
27687f5c258eSLen Brown 
27697f5c258eSLen Brown 	if (cpu_migrate(cpu)) {
2770b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
27717f5c258eSLen Brown 		return -1;
27727f5c258eSLen Brown 	}
27737f5c258eSLen Brown 
27747f5c258eSLen Brown 	if (get_msr(cpu, MSR_PM_ENABLE, &msr))
27757f5c258eSLen Brown 		return 0;
27767f5c258eSLen Brown 
2777b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_PM_ENABLE: 0x%08llx (%sHWP)\n",
27787f5c258eSLen Brown 		cpu, msr, (msr & (1 << 0)) ? "" : "No-");
27797f5c258eSLen Brown 
27807f5c258eSLen Brown 	/* MSR_PM_ENABLE[1] == 1 if HWP is enabled and MSRs visible */
27817f5c258eSLen Brown 	if ((msr & (1 << 0)) == 0)
27827f5c258eSLen Brown 		return 0;
27837f5c258eSLen Brown 
27847f5c258eSLen Brown 	if (get_msr(cpu, MSR_HWP_CAPABILITIES, &msr))
27857f5c258eSLen Brown 		return 0;
27867f5c258eSLen Brown 
2787b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_HWP_CAPABILITIES: 0x%08llx "
27887f5c258eSLen Brown 			"(high 0x%x guar 0x%x eff 0x%x low 0x%x)\n",
27897f5c258eSLen Brown 			cpu, msr,
27907f5c258eSLen Brown 			(unsigned int)HWP_HIGHEST_PERF(msr),
27917f5c258eSLen Brown 			(unsigned int)HWP_GUARANTEED_PERF(msr),
27927f5c258eSLen Brown 			(unsigned int)HWP_MOSTEFFICIENT_PERF(msr),
27937f5c258eSLen Brown 			(unsigned int)HWP_LOWEST_PERF(msr));
27947f5c258eSLen Brown 
27957f5c258eSLen Brown 	if (get_msr(cpu, MSR_HWP_REQUEST, &msr))
27967f5c258eSLen Brown 		return 0;
27977f5c258eSLen Brown 
2798b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_HWP_REQUEST: 0x%08llx "
27997f5c258eSLen Brown 			"(min 0x%x max 0x%x des 0x%x epp 0x%x window 0x%x pkg 0x%x)\n",
28007f5c258eSLen Brown 			cpu, msr,
28017f5c258eSLen Brown 			(unsigned int)(((msr) >> 0) & 0xff),
28027f5c258eSLen Brown 			(unsigned int)(((msr) >> 8) & 0xff),
28037f5c258eSLen Brown 			(unsigned int)(((msr) >> 16) & 0xff),
28047f5c258eSLen Brown 			(unsigned int)(((msr) >> 24) & 0xff),
28057f5c258eSLen Brown 			(unsigned int)(((msr) >> 32) & 0xff3),
28067f5c258eSLen Brown 			(unsigned int)(((msr) >> 42) & 0x1));
28077f5c258eSLen Brown 
28087f5c258eSLen Brown 	if (has_hwp_pkg) {
28097f5c258eSLen Brown 		if (get_msr(cpu, MSR_HWP_REQUEST_PKG, &msr))
28107f5c258eSLen Brown 			return 0;
28117f5c258eSLen Brown 
2812b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_HWP_REQUEST_PKG: 0x%08llx "
28137f5c258eSLen Brown 			"(min 0x%x max 0x%x des 0x%x epp 0x%x window 0x%x)\n",
28147f5c258eSLen Brown 			cpu, msr,
28157f5c258eSLen Brown 			(unsigned int)(((msr) >> 0) & 0xff),
28167f5c258eSLen Brown 			(unsigned int)(((msr) >> 8) & 0xff),
28177f5c258eSLen Brown 			(unsigned int)(((msr) >> 16) & 0xff),
28187f5c258eSLen Brown 			(unsigned int)(((msr) >> 24) & 0xff),
28197f5c258eSLen Brown 			(unsigned int)(((msr) >> 32) & 0xff3));
28207f5c258eSLen Brown 	}
28217f5c258eSLen Brown 	if (has_hwp_notify) {
28227f5c258eSLen Brown 		if (get_msr(cpu, MSR_HWP_INTERRUPT, &msr))
28237f5c258eSLen Brown 			return 0;
28247f5c258eSLen Brown 
2825b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_HWP_INTERRUPT: 0x%08llx "
28267f5c258eSLen Brown 			"(%s_Guaranteed_Perf_Change, %s_Excursion_Min)\n",
28277f5c258eSLen Brown 			cpu, msr,
28287f5c258eSLen Brown 			((msr) & 0x1) ? "EN" : "Dis",
28297f5c258eSLen Brown 			((msr) & 0x2) ? "EN" : "Dis");
28307f5c258eSLen Brown 	}
28317f5c258eSLen Brown 	if (get_msr(cpu, MSR_HWP_STATUS, &msr))
28327f5c258eSLen Brown 		return 0;
28337f5c258eSLen Brown 
2834b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_HWP_STATUS: 0x%08llx "
28357f5c258eSLen Brown 			"(%sGuaranteed_Perf_Change, %sExcursion_Min)\n",
28367f5c258eSLen Brown 			cpu, msr,
28377f5c258eSLen Brown 			((msr) & 0x1) ? "" : "No-",
28387f5c258eSLen Brown 			((msr) & 0x2) ? "" : "No-");
2839889facbeSLen Brown 
2840889facbeSLen Brown 	return 0;
2841889facbeSLen Brown }
2842889facbeSLen Brown 
28433a9a941dSLen Brown /*
28443a9a941dSLen Brown  * print_perf_limit()
28453a9a941dSLen Brown  */
28463a9a941dSLen Brown int print_perf_limit(struct thread_data *t, struct core_data *c, struct pkg_data *p)
28473a9a941dSLen Brown {
28483a9a941dSLen Brown 	unsigned long long msr;
28493a9a941dSLen Brown 	int cpu;
28503a9a941dSLen Brown 
28513a9a941dSLen Brown 	cpu = t->cpu_id;
28523a9a941dSLen Brown 
28533a9a941dSLen Brown 	/* per-package */
28543a9a941dSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
28553a9a941dSLen Brown 		return 0;
28563a9a941dSLen Brown 
28573a9a941dSLen Brown 	if (cpu_migrate(cpu)) {
2858b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
28593a9a941dSLen Brown 		return -1;
28603a9a941dSLen Brown 	}
28613a9a941dSLen Brown 
28623a9a941dSLen Brown 	if (do_core_perf_limit_reasons) {
28633a9a941dSLen Brown 		get_msr(cpu, MSR_CORE_PERF_LIMIT_REASONS, &msr);
2864b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_CORE_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
2865b7d8c148SLen Brown 		fprintf(outf, " (Active: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)",
2866e33cbe85SLen Brown 			(msr & 1 << 15) ? "bit15, " : "",
28673a9a941dSLen Brown 			(msr & 1 << 14) ? "bit14, " : "",
2868e33cbe85SLen Brown 			(msr & 1 << 13) ? "Transitions, " : "",
2869e33cbe85SLen Brown 			(msr & 1 << 12) ? "MultiCoreTurbo, " : "",
2870e33cbe85SLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "",
2871e33cbe85SLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
2872e33cbe85SLen Brown 			(msr & 1 << 9) ? "CorePwr, " : "",
2873e33cbe85SLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
2874e33cbe85SLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
2875e33cbe85SLen Brown 			(msr & 1 << 5) ? "Auto-HWP, " : "",
2876e33cbe85SLen Brown 			(msr & 1 << 4) ? "Graphics, " : "",
2877e33cbe85SLen Brown 			(msr & 1 << 2) ? "bit2, " : "",
2878e33cbe85SLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
2879e33cbe85SLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "");
2880b7d8c148SLen Brown 		fprintf(outf, " (Logged: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2881e33cbe85SLen Brown 			(msr & 1 << 31) ? "bit31, " : "",
28823a9a941dSLen Brown 			(msr & 1 << 30) ? "bit30, " : "",
2883e33cbe85SLen Brown 			(msr & 1 << 29) ? "Transitions, " : "",
2884e33cbe85SLen Brown 			(msr & 1 << 28) ? "MultiCoreTurbo, " : "",
2885e33cbe85SLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "",
2886e33cbe85SLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
2887e33cbe85SLen Brown 			(msr & 1 << 25) ? "CorePwr, " : "",
2888e33cbe85SLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
2889e33cbe85SLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
2890e33cbe85SLen Brown 			(msr & 1 << 21) ? "Auto-HWP, " : "",
2891e33cbe85SLen Brown 			(msr & 1 << 20) ? "Graphics, " : "",
2892e33cbe85SLen Brown 			(msr & 1 << 18) ? "bit18, " : "",
2893e33cbe85SLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
2894e33cbe85SLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "");
28953a9a941dSLen Brown 
28963a9a941dSLen Brown 	}
28973a9a941dSLen Brown 	if (do_gfx_perf_limit_reasons) {
28983a9a941dSLen Brown 		get_msr(cpu, MSR_GFX_PERF_LIMIT_REASONS, &msr);
2899b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_GFX_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
2900b7d8c148SLen Brown 		fprintf(outf, " (Active: %s%s%s%s%s%s%s%s)",
29013a9a941dSLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "",
29023a9a941dSLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
29033a9a941dSLen Brown 			(msr & 1 << 4) ? "Graphics, " : "",
29043a9a941dSLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
29053a9a941dSLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
29063a9a941dSLen Brown 			(msr & 1 << 9) ? "GFXPwr, " : "",
29073a9a941dSLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
29083a9a941dSLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "");
2909b7d8c148SLen Brown 		fprintf(outf, " (Logged: %s%s%s%s%s%s%s%s)\n",
29103a9a941dSLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "",
29113a9a941dSLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
29123a9a941dSLen Brown 			(msr & 1 << 20) ? "Graphics, " : "",
29133a9a941dSLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
29143a9a941dSLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
29153a9a941dSLen Brown 			(msr & 1 << 25) ? "GFXPwr, " : "",
29163a9a941dSLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
29173a9a941dSLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "");
29183a9a941dSLen Brown 	}
29193a9a941dSLen Brown 	if (do_ring_perf_limit_reasons) {
29203a9a941dSLen Brown 		get_msr(cpu, MSR_RING_PERF_LIMIT_REASONS, &msr);
2921b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_RING_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
2922b7d8c148SLen Brown 		fprintf(outf, " (Active: %s%s%s%s%s%s)",
29233a9a941dSLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "",
29243a9a941dSLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
29253a9a941dSLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
29263a9a941dSLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
29273a9a941dSLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
29283a9a941dSLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "");
2929b7d8c148SLen Brown 		fprintf(outf, " (Logged: %s%s%s%s%s%s)\n",
29303a9a941dSLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "",
29313a9a941dSLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
29323a9a941dSLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
29333a9a941dSLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
29343a9a941dSLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
29353a9a941dSLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "");
29363a9a941dSLen Brown 	}
29373a9a941dSLen Brown 	return 0;
29383a9a941dSLen Brown }
29393a9a941dSLen Brown 
2940889facbeSLen Brown #define	RAPL_POWER_GRANULARITY	0x7FFF	/* 15 bit power granularity */
2941889facbeSLen Brown #define	RAPL_TIME_GRANULARITY	0x3F /* 6 bit time granularity */
2942889facbeSLen Brown 
29431b69317dSColin Ian King double get_tdp(unsigned int model)
2944144b44b1SLen Brown {
2945144b44b1SLen Brown 	unsigned long long msr;
2946144b44b1SLen Brown 
2947144b44b1SLen Brown 	if (do_rapl & RAPL_PKG_POWER_INFO)
29487ce7d5deSPrarit Bhargava 		if (!get_msr(base_cpu, MSR_PKG_POWER_INFO, &msr))
2949144b44b1SLen Brown 			return ((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units;
2950144b44b1SLen Brown 
2951144b44b1SLen Brown 	switch (model) {
2952869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:
2953869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:
2954144b44b1SLen Brown 		return 30.0;
2955144b44b1SLen Brown 	default:
2956144b44b1SLen Brown 		return 135.0;
2957144b44b1SLen Brown 	}
2958144b44b1SLen Brown }
2959144b44b1SLen Brown 
296040ee8e3bSAndrey Semin /*
296140ee8e3bSAndrey Semin  * rapl_dram_energy_units_probe()
296240ee8e3bSAndrey Semin  * Energy units are either hard-coded, or come from RAPL Energy Unit MSR.
296340ee8e3bSAndrey Semin  */
296440ee8e3bSAndrey Semin static double
296540ee8e3bSAndrey Semin rapl_dram_energy_units_probe(int  model, double rapl_energy_units)
296640ee8e3bSAndrey Semin {
296740ee8e3bSAndrey Semin 	/* only called for genuine_intel, family 6 */
296840ee8e3bSAndrey Semin 
296940ee8e3bSAndrey Semin 	switch (model) {
2970869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
2971869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
2972869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
2973869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* KNL */
2974005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
297540ee8e3bSAndrey Semin 		return (rapl_dram_energy_units = 15.3 / 1000000);
297640ee8e3bSAndrey Semin 	default:
297740ee8e3bSAndrey Semin 		return (rapl_energy_units);
297840ee8e3bSAndrey Semin 	}
297940ee8e3bSAndrey Semin }
298040ee8e3bSAndrey Semin 
2981144b44b1SLen Brown 
2982889facbeSLen Brown /*
2983889facbeSLen Brown  * rapl_probe()
2984889facbeSLen Brown  *
2985144b44b1SLen Brown  * sets do_rapl, rapl_power_units, rapl_energy_units, rapl_time_units
2986889facbeSLen Brown  */
2987889facbeSLen Brown void rapl_probe(unsigned int family, unsigned int model)
2988889facbeSLen Brown {
2989889facbeSLen Brown 	unsigned long long msr;
2990144b44b1SLen Brown 	unsigned int time_unit;
2991889facbeSLen Brown 	double tdp;
2992889facbeSLen Brown 
2993889facbeSLen Brown 	if (!genuine_intel)
2994889facbeSLen Brown 		return;
2995889facbeSLen Brown 
2996889facbeSLen Brown 	if (family != 6)
2997889facbeSLen Brown 		return;
2998889facbeSLen Brown 
2999889facbeSLen Brown 	switch (model) {
3000869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE:
3001869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:
3002869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
3003869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3004869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
3005869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
3006869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
3007144b44b1SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_GFX | RAPL_PKG_POWER_INFO;
3008812db3f7SLen Brown 		if (rapl_joules) {
3009812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3010812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3011812db3f7SLen Brown 			BIC_PRESENT(BIC_GFX_J);
3012812db3f7SLen Brown 		} else {
3013812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3014812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3015812db3f7SLen Brown 			BIC_PRESENT(BIC_GFXWatt);
3016812db3f7SLen Brown 		}
3017889facbeSLen Brown 		break;
3018869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3019e4085d54SLen Brown 		do_rapl = RAPL_PKG | RAPL_PKG_POWER_INFO;
3020812db3f7SLen Brown 		if (rapl_joules)
3021812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3022812db3f7SLen Brown 		else
3023812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3024e4085d54SLen Brown 		break;
3025869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3026869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3027869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3028869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
30290b2bb692SLen Brown 		do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
3030812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3031812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3032812db3f7SLen Brown 		if (rapl_joules) {
3033812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3034812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3035812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3036812db3f7SLen Brown 		} else {
3037812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3038812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3039812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3040812db3f7SLen Brown 		}
30410b2bb692SLen Brown 		break;
3042869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
3043869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
3044869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
3045869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
3046869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* KNL */
3047005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
30480b2bb692SLen Brown 		do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
3049812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3050812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3051812db3f7SLen Brown 		if (rapl_joules) {
3052812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3053812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3054812db3f7SLen Brown 		} else {
3055812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3056812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3057812db3f7SLen Brown 		}
3058e6f9bb3cSLen Brown 		break;
3059869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE_X:
3060869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:
30610b2bb692SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_PKG_PERF_STATUS | RAPL_DRAM_PERF_STATUS | RAPL_PKG_POWER_INFO;
3062812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3063812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3064812db3f7SLen Brown 		if (rapl_joules) {
3065812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3066812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3067812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3068812db3f7SLen Brown 		} else {
3069812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3070812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3071812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3072812db3f7SLen Brown 		}
3073144b44b1SLen Brown 		break;
3074869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:	/* BYT */
3075869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:	/* AVN */
3076144b44b1SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES;
3077812db3f7SLen Brown 		if (rapl_joules) {
3078812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3079812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3080812db3f7SLen Brown 		} else {
3081812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3082812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3083812db3f7SLen Brown 		}
3084889facbeSLen Brown 		break;
3085869ce69eSLen Brown 	case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
30860f644909SJacob Pan 		do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO | RAPL_CORES_ENERGY_STATUS;
3087812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3088812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3089812db3f7SLen Brown 		if (rapl_joules) {
3090812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3091812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3092812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3093812db3f7SLen Brown 		} else {
3094812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3095812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3096812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3097812db3f7SLen Brown 		}
30980f644909SJacob Pan 		break;
3099889facbeSLen Brown 	default:
3100889facbeSLen Brown 		return;
3101889facbeSLen Brown 	}
3102889facbeSLen Brown 
3103889facbeSLen Brown 	/* units on package 0, verify later other packages match */
31047ce7d5deSPrarit Bhargava 	if (get_msr(base_cpu, MSR_RAPL_POWER_UNIT, &msr))
3105889facbeSLen Brown 		return;
3106889facbeSLen Brown 
3107889facbeSLen Brown 	rapl_power_units = 1.0 / (1 << (msr & 0xF));
3108869ce69eSLen Brown 	if (model == INTEL_FAM6_ATOM_SILVERMONT1)
3109144b44b1SLen Brown 		rapl_energy_units = 1.0 * (1 << (msr >> 8 & 0x1F)) / 1000000;
3110144b44b1SLen Brown 	else
3111889facbeSLen Brown 		rapl_energy_units = 1.0 / (1 << (msr >> 8 & 0x1F));
3112889facbeSLen Brown 
311340ee8e3bSAndrey Semin 	rapl_dram_energy_units = rapl_dram_energy_units_probe(model, rapl_energy_units);
311440ee8e3bSAndrey Semin 
3115144b44b1SLen Brown 	time_unit = msr >> 16 & 0xF;
3116144b44b1SLen Brown 	if (time_unit == 0)
3117144b44b1SLen Brown 		time_unit = 0xA;
3118889facbeSLen Brown 
3119144b44b1SLen Brown 	rapl_time_units = 1.0 / (1 << (time_unit));
3120144b44b1SLen Brown 
3121144b44b1SLen Brown 	tdp = get_tdp(model);
3122889facbeSLen Brown 
3123889facbeSLen Brown 	rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp;
3124d8af6f5fSLen Brown 	if (debug)
3125b7d8c148SLen Brown 		fprintf(outf, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp);
3126889facbeSLen Brown 
3127889facbeSLen Brown 	return;
3128889facbeSLen Brown }
3129889facbeSLen Brown 
31301b69317dSColin Ian King void perf_limit_reasons_probe(unsigned int family, unsigned int model)
31313a9a941dSLen Brown {
31323a9a941dSLen Brown 	if (!genuine_intel)
31333a9a941dSLen Brown 		return;
31343a9a941dSLen Brown 
31353a9a941dSLen Brown 	if (family != 6)
31363a9a941dSLen Brown 		return;
31373a9a941dSLen Brown 
31383a9a941dSLen Brown 	switch (model) {
3139869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
3140869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3141869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
31423a9a941dSLen Brown 		do_gfx_perf_limit_reasons = 1;
3143869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
31443a9a941dSLen Brown 		do_core_perf_limit_reasons = 1;
31453a9a941dSLen Brown 		do_ring_perf_limit_reasons = 1;
31463a9a941dSLen Brown 	default:
31473a9a941dSLen Brown 		return;
31483a9a941dSLen Brown 	}
31493a9a941dSLen Brown }
31503a9a941dSLen Brown 
3151889facbeSLen Brown int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p)
3152889facbeSLen Brown {
3153889facbeSLen Brown 	unsigned long long msr;
3154889facbeSLen Brown 	unsigned int dts;
3155889facbeSLen Brown 	int cpu;
3156889facbeSLen Brown 
3157889facbeSLen Brown 	if (!(do_dts || do_ptm))
3158889facbeSLen Brown 		return 0;
3159889facbeSLen Brown 
3160889facbeSLen Brown 	cpu = t->cpu_id;
3161889facbeSLen Brown 
3162889facbeSLen Brown 	/* DTS is per-core, no need to print for each thread */
3163889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
3164889facbeSLen Brown 		return 0;
3165889facbeSLen Brown 
3166889facbeSLen Brown 	if (cpu_migrate(cpu)) {
3167b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
3168889facbeSLen Brown 		return -1;
3169889facbeSLen Brown 	}
3170889facbeSLen Brown 
3171889facbeSLen Brown 	if (do_ptm && (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)) {
3172889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
3173889facbeSLen Brown 			return 0;
3174889facbeSLen Brown 
3175889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3176b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_STATUS: 0x%08llx (%d C)\n",
3177889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts);
3178889facbeSLen Brown 
3179889facbeSLen Brown #ifdef	THERM_DEBUG
3180889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT, &msr))
3181889facbeSLen Brown 			return 0;
3182889facbeSLen Brown 
3183889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3184889facbeSLen Brown 		dts2 = (msr >> 8) & 0x7F;
3185b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
3186889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
3187889facbeSLen Brown #endif
3188889facbeSLen Brown 	}
3189889facbeSLen Brown 
3190889facbeSLen Brown 
3191889facbeSLen Brown 	if (do_dts) {
3192889facbeSLen Brown 		unsigned int resolution;
3193889facbeSLen Brown 
3194889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
3195889facbeSLen Brown 			return 0;
3196889facbeSLen Brown 
3197889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3198889facbeSLen Brown 		resolution = (msr >> 27) & 0xF;
3199b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_THERM_STATUS: 0x%08llx (%d C +/- %d)\n",
3200889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, resolution);
3201889facbeSLen Brown 
3202889facbeSLen Brown #ifdef THERM_DEBUG
3203889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_INTERRUPT, &msr))
3204889facbeSLen Brown 			return 0;
3205889facbeSLen Brown 
3206889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3207889facbeSLen Brown 		dts2 = (msr >> 8) & 0x7F;
3208b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
3209889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
3210889facbeSLen Brown #endif
3211889facbeSLen Brown 	}
3212889facbeSLen Brown 
3213889facbeSLen Brown 	return 0;
3214889facbeSLen Brown }
3215889facbeSLen Brown 
3216889facbeSLen Brown void print_power_limit_msr(int cpu, unsigned long long msr, char *label)
3217889facbeSLen Brown {
3218b7d8c148SLen Brown 	fprintf(outf, "cpu%d: %s: %sabled (%f Watts, %f sec, clamp %sabled)\n",
3219889facbeSLen Brown 		cpu, label,
3220889facbeSLen Brown 		((msr >> 15) & 1) ? "EN" : "DIS",
3221889facbeSLen Brown 		((msr >> 0) & 0x7FFF) * rapl_power_units,
3222889facbeSLen Brown 		(1.0 + (((msr >> 22) & 0x3)/4.0)) * (1 << ((msr >> 17) & 0x1F)) * rapl_time_units,
3223889facbeSLen Brown 		(((msr >> 16) & 1) ? "EN" : "DIS"));
3224889facbeSLen Brown 
3225889facbeSLen Brown 	return;
3226889facbeSLen Brown }
3227889facbeSLen Brown 
3228889facbeSLen Brown int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
3229889facbeSLen Brown {
3230889facbeSLen Brown 	unsigned long long msr;
3231889facbeSLen Brown 	int cpu;
3232889facbeSLen Brown 
3233889facbeSLen Brown 	if (!do_rapl)
3234889facbeSLen Brown 		return 0;
3235889facbeSLen Brown 
3236889facbeSLen Brown 	/* RAPL counters are per package, so print only for 1st thread/package */
3237889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
3238889facbeSLen Brown 		return 0;
3239889facbeSLen Brown 
3240889facbeSLen Brown 	cpu = t->cpu_id;
3241889facbeSLen Brown 	if (cpu_migrate(cpu)) {
3242b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
3243889facbeSLen Brown 		return -1;
3244889facbeSLen Brown 	}
3245889facbeSLen Brown 
3246889facbeSLen Brown 	if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr))
3247889facbeSLen Brown 		return -1;
3248889facbeSLen Brown 
3249d8af6f5fSLen Brown 	if (debug) {
3250b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_RAPL_POWER_UNIT: 0x%08llx "
3251889facbeSLen Brown 			"(%f Watts, %f Joules, %f sec.)\n", cpu, msr,
3252144b44b1SLen Brown 			rapl_power_units, rapl_energy_units, rapl_time_units);
3253889facbeSLen Brown 	}
3254144b44b1SLen Brown 	if (do_rapl & RAPL_PKG_POWER_INFO) {
3255144b44b1SLen Brown 
3256889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_POWER_INFO, &msr))
3257889facbeSLen Brown                 	return -5;
3258889facbeSLen Brown 
3259889facbeSLen Brown 
3260b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PKG_POWER_INFO: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
3261889facbeSLen Brown 			cpu, msr,
3262889facbeSLen Brown 			((msr >>  0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3263889facbeSLen Brown 			((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3264889facbeSLen Brown 			((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3265889facbeSLen Brown 			((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
3266889facbeSLen Brown 
3267144b44b1SLen Brown 	}
3268144b44b1SLen Brown 	if (do_rapl & RAPL_PKG) {
3269144b44b1SLen Brown 
3270889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_POWER_LIMIT, &msr))
3271889facbeSLen Brown 			return -9;
3272889facbeSLen Brown 
3273b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PKG_POWER_LIMIT: 0x%08llx (%slocked)\n",
3274889facbeSLen Brown 			cpu, msr, (msr >> 63) & 1 ? "": "UN");
3275889facbeSLen Brown 
3276889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "PKG Limit #1");
3277b7d8c148SLen Brown 		fprintf(outf, "cpu%d: PKG Limit #2: %sabled (%f Watts, %f* sec, clamp %sabled)\n",
3278889facbeSLen Brown 			cpu,
3279889facbeSLen Brown 			((msr >> 47) & 1) ? "EN" : "DIS",
3280889facbeSLen Brown 			((msr >> 32) & 0x7FFF) * rapl_power_units,
3281889facbeSLen Brown 			(1.0 + (((msr >> 54) & 0x3)/4.0)) * (1 << ((msr >> 49) & 0x1F)) * rapl_time_units,
3282889facbeSLen Brown 			((msr >> 48) & 1) ? "EN" : "DIS");
3283889facbeSLen Brown 	}
3284889facbeSLen Brown 
32850b2bb692SLen Brown 	if (do_rapl & RAPL_DRAM_POWER_INFO) {
3286889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_POWER_INFO, &msr))
3287889facbeSLen Brown                 	return -6;
3288889facbeSLen Brown 
3289b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_DRAM_POWER_INFO,: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
3290889facbeSLen Brown 			cpu, msr,
3291889facbeSLen Brown 			((msr >>  0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3292889facbeSLen Brown 			((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3293889facbeSLen Brown 			((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3294889facbeSLen Brown 			((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
32950b2bb692SLen Brown 	}
32960b2bb692SLen Brown 	if (do_rapl & RAPL_DRAM) {
3297889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_POWER_LIMIT, &msr))
3298889facbeSLen Brown 			return -9;
3299b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_DRAM_POWER_LIMIT: 0x%08llx (%slocked)\n",
3300889facbeSLen Brown 				cpu, msr, (msr >> 31) & 1 ? "": "UN");
3301889facbeSLen Brown 
3302889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "DRAM Limit");
3303889facbeSLen Brown 	}
3304144b44b1SLen Brown 	if (do_rapl & RAPL_CORE_POLICY) {
3305d8af6f5fSLen Brown 		if (debug) {
3306889facbeSLen Brown 			if (get_msr(cpu, MSR_PP0_POLICY, &msr))
3307889facbeSLen Brown 				return -7;
3308889facbeSLen Brown 
3309b7d8c148SLen Brown 			fprintf(outf, "cpu%d: MSR_PP0_POLICY: %lld\n", cpu, msr & 0xF);
3310144b44b1SLen Brown 		}
3311144b44b1SLen Brown 	}
33129148494cSJacob Pan 	if (do_rapl & RAPL_CORES_POWER_LIMIT) {
3313d8af6f5fSLen Brown 		if (debug) {
3314889facbeSLen Brown 			if (get_msr(cpu, MSR_PP0_POWER_LIMIT, &msr))
3315889facbeSLen Brown 				return -9;
3316b7d8c148SLen Brown 			fprintf(outf, "cpu%d: MSR_PP0_POWER_LIMIT: 0x%08llx (%slocked)\n",
3317889facbeSLen Brown 					cpu, msr, (msr >> 31) & 1 ? "": "UN");
3318889facbeSLen Brown 			print_power_limit_msr(cpu, msr, "Cores Limit");
3319889facbeSLen Brown 		}
3320889facbeSLen Brown 	}
3321889facbeSLen Brown 	if (do_rapl & RAPL_GFX) {
3322d8af6f5fSLen Brown 		if (debug) {
3323889facbeSLen Brown 			if (get_msr(cpu, MSR_PP1_POLICY, &msr))
3324889facbeSLen Brown 				return -8;
3325889facbeSLen Brown 
3326b7d8c148SLen Brown 			fprintf(outf, "cpu%d: MSR_PP1_POLICY: %lld\n", cpu, msr & 0xF);
3327889facbeSLen Brown 
3328889facbeSLen Brown 			if (get_msr(cpu, MSR_PP1_POWER_LIMIT, &msr))
3329889facbeSLen Brown 				return -9;
3330b7d8c148SLen Brown 			fprintf(outf, "cpu%d: MSR_PP1_POWER_LIMIT: 0x%08llx (%slocked)\n",
3331889facbeSLen Brown 					cpu, msr, (msr >> 31) & 1 ? "": "UN");
3332889facbeSLen Brown 			print_power_limit_msr(cpu, msr, "GFX Limit");
3333889facbeSLen Brown 		}
3334889facbeSLen Brown 	}
3335889facbeSLen Brown 	return 0;
3336889facbeSLen Brown }
3337889facbeSLen Brown 
3338d7899447SLen Brown /*
3339d7899447SLen Brown  * SNB adds support for additional MSRs:
3340d7899447SLen Brown  *
3341d7899447SLen Brown  * MSR_PKG_C7_RESIDENCY            0x000003fa
3342d7899447SLen Brown  * MSR_CORE_C7_RESIDENCY           0x000003fe
3343d7899447SLen Brown  * MSR_PKG_C2_RESIDENCY            0x0000060d
3344d7899447SLen Brown  */
3345103a8feaSLen Brown 
3346d7899447SLen Brown int has_snb_msrs(unsigned int family, unsigned int model)
3347103a8feaSLen Brown {
3348103a8feaSLen Brown 	if (!genuine_intel)
3349103a8feaSLen Brown 		return 0;
3350103a8feaSLen Brown 
3351103a8feaSLen Brown 	switch (model) {
3352869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE:
3353869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE_X:
3354869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:	/* IVB */
3355869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:	/* IVB Xeon */
3356869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
3357869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSW */
3358869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3359869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
3360869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
3361869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
3362869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
3363869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
3364869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3365869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3366869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3367869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
3368869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
3369869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
33705bbac26eSXiaolong Wang 	case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
3371103a8feaSLen Brown 		return 1;
3372103a8feaSLen Brown 	}
3373103a8feaSLen Brown 	return 0;
3374103a8feaSLen Brown }
3375103a8feaSLen Brown 
3376d7899447SLen Brown /*
3377d7899447SLen Brown  * HSW adds support for additional MSRs:
3378d7899447SLen Brown  *
3379d7899447SLen Brown  * MSR_PKG_C8_RESIDENCY		0x00000630
3380d7899447SLen Brown  * MSR_PKG_C9_RESIDENCY		0x00000631
3381d7899447SLen Brown  * MSR_PKG_C10_RESIDENCY	0x00000632
33825a63426eSLen Brown  *
33835a63426eSLen Brown  * MSR_PKGC8_IRTL		0x00000633
33845a63426eSLen Brown  * MSR_PKGC9_IRTL		0x00000634
33855a63426eSLen Brown  * MSR_PKGC10_IRTL		0x00000635
33865a63426eSLen Brown  *
3387d7899447SLen Brown  */
3388d7899447SLen Brown int has_hsw_msrs(unsigned int family, unsigned int model)
3389ca58710fSKristen Carlson Accardi {
3390ca58710fSKristen Carlson Accardi 	if (!genuine_intel)
3391ca58710fSKristen Carlson Accardi 		return 0;
3392ca58710fSKristen Carlson Accardi 
3393ca58710fSKristen Carlson Accardi 	switch (model) {
3394869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3395869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
3396869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3397869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3398869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3399869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
3400869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3401ca58710fSKristen Carlson Accardi 		return 1;
3402ca58710fSKristen Carlson Accardi 	}
3403ca58710fSKristen Carlson Accardi 	return 0;
3404ca58710fSKristen Carlson Accardi }
3405ca58710fSKristen Carlson Accardi 
34060b2bb692SLen Brown /*
34070b2bb692SLen Brown  * SKL adds support for additional MSRS:
34080b2bb692SLen Brown  *
34090b2bb692SLen Brown  * MSR_PKG_WEIGHTED_CORE_C0_RES    0x00000658
34100b2bb692SLen Brown  * MSR_PKG_ANY_CORE_C0_RES         0x00000659
34110b2bb692SLen Brown  * MSR_PKG_ANY_GFXE_C0_RES         0x0000065A
34120b2bb692SLen Brown  * MSR_PKG_BOTH_CORE_GFXE_C0_RES   0x0000065B
34130b2bb692SLen Brown  */
34140b2bb692SLen Brown int has_skl_msrs(unsigned int family, unsigned int model)
34150b2bb692SLen Brown {
34160b2bb692SLen Brown 	if (!genuine_intel)
34170b2bb692SLen Brown 		return 0;
34180b2bb692SLen Brown 
34190b2bb692SLen Brown 	switch (model) {
3420869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3421869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3422869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3423869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
34240b2bb692SLen Brown 		return 1;
34250b2bb692SLen Brown 	}
34260b2bb692SLen Brown 	return 0;
34270b2bb692SLen Brown }
34280b2bb692SLen Brown 
3429144b44b1SLen Brown int is_slm(unsigned int family, unsigned int model)
3430144b44b1SLen Brown {
3431144b44b1SLen Brown 	if (!genuine_intel)
3432144b44b1SLen Brown 		return 0;
3433144b44b1SLen Brown 	switch (model) {
3434869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:	/* BYT */
3435869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:	/* AVN */
3436144b44b1SLen Brown 		return 1;
3437144b44b1SLen Brown 	}
3438144b44b1SLen Brown 	return 0;
3439144b44b1SLen Brown }
3440144b44b1SLen Brown 
3441fb5d4327SDasaratharaman Chandramouli int is_knl(unsigned int family, unsigned int model)
3442fb5d4327SDasaratharaman Chandramouli {
3443fb5d4327SDasaratharaman Chandramouli 	if (!genuine_intel)
3444fb5d4327SDasaratharaman Chandramouli 		return 0;
3445fb5d4327SDasaratharaman Chandramouli 	switch (model) {
3446869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* KNL */
3447005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
3448fb5d4327SDasaratharaman Chandramouli 		return 1;
3449fb5d4327SDasaratharaman Chandramouli 	}
3450fb5d4327SDasaratharaman Chandramouli 	return 0;
3451fb5d4327SDasaratharaman Chandramouli }
3452fb5d4327SDasaratharaman Chandramouli 
3453b2b34dfeSHubert Chrzaniuk unsigned int get_aperf_mperf_multiplier(unsigned int family, unsigned int model)
3454b2b34dfeSHubert Chrzaniuk {
3455b2b34dfeSHubert Chrzaniuk 	if (is_knl(family, model))
3456b2b34dfeSHubert Chrzaniuk 		return 1024;
3457b2b34dfeSHubert Chrzaniuk 	return 1;
3458b2b34dfeSHubert Chrzaniuk }
3459b2b34dfeSHubert Chrzaniuk 
3460144b44b1SLen Brown #define SLM_BCLK_FREQS 5
3461144b44b1SLen Brown double slm_freq_table[SLM_BCLK_FREQS] = { 83.3, 100.0, 133.3, 116.7, 80.0};
3462144b44b1SLen Brown 
3463144b44b1SLen Brown double slm_bclk(void)
3464144b44b1SLen Brown {
3465144b44b1SLen Brown 	unsigned long long msr = 3;
3466144b44b1SLen Brown 	unsigned int i;
3467144b44b1SLen Brown 	double freq;
3468144b44b1SLen Brown 
34697ce7d5deSPrarit Bhargava 	if (get_msr(base_cpu, MSR_FSB_FREQ, &msr))
3470b7d8c148SLen Brown 		fprintf(outf, "SLM BCLK: unknown\n");
3471144b44b1SLen Brown 
3472144b44b1SLen Brown 	i = msr & 0xf;
3473144b44b1SLen Brown 	if (i >= SLM_BCLK_FREQS) {
3474b7d8c148SLen Brown 		fprintf(outf, "SLM BCLK[%d] invalid\n", i);
34750a91e551SColin Ian King 		i = 3;
3476144b44b1SLen Brown 	}
3477144b44b1SLen Brown 	freq = slm_freq_table[i];
3478144b44b1SLen Brown 
34798f6196c1SLen Brown 	if (debug)
3480b7d8c148SLen Brown 		fprintf(outf, "SLM BCLK: %.1f Mhz\n", freq);
3481144b44b1SLen Brown 
3482144b44b1SLen Brown 	return freq;
3483144b44b1SLen Brown }
3484144b44b1SLen Brown 
3485103a8feaSLen Brown double discover_bclk(unsigned int family, unsigned int model)
3486103a8feaSLen Brown {
3487121b48bbSChrzaniuk, Hubert 	if (has_snb_msrs(family, model) || is_knl(family, model))
3488103a8feaSLen Brown 		return 100.00;
3489144b44b1SLen Brown 	else if (is_slm(family, model))
3490144b44b1SLen Brown 		return slm_bclk();
3491103a8feaSLen Brown 	else
3492103a8feaSLen Brown 		return 133.33;
3493103a8feaSLen Brown }
3494103a8feaSLen Brown 
3495889facbeSLen Brown /*
3496889facbeSLen Brown  * MSR_IA32_TEMPERATURE_TARGET indicates the temperature where
3497889facbeSLen Brown  * the Thermal Control Circuit (TCC) activates.
3498889facbeSLen Brown  * This is usually equal to tjMax.
3499889facbeSLen Brown  *
3500889facbeSLen Brown  * Older processors do not have this MSR, so there we guess,
3501889facbeSLen Brown  * but also allow cmdline over-ride with -T.
3502889facbeSLen Brown  *
3503889facbeSLen Brown  * Several MSR temperature values are in units of degrees-C
3504889facbeSLen Brown  * below this value, including the Digital Thermal Sensor (DTS),
3505889facbeSLen Brown  * Package Thermal Management Sensor (PTM), and thermal event thresholds.
3506889facbeSLen Brown  */
3507889facbeSLen Brown int set_temperature_target(struct thread_data *t, struct core_data *c, struct pkg_data *p)
3508889facbeSLen Brown {
3509889facbeSLen Brown 	unsigned long long msr;
3510889facbeSLen Brown 	unsigned int target_c_local;
3511889facbeSLen Brown 	int cpu;
3512889facbeSLen Brown 
3513889facbeSLen Brown 	/* tcc_activation_temp is used only for dts or ptm */
3514889facbeSLen Brown 	if (!(do_dts || do_ptm))
3515889facbeSLen Brown 		return 0;
3516889facbeSLen Brown 
3517889facbeSLen Brown 	/* this is a per-package concept */
3518889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
3519889facbeSLen Brown 		return 0;
3520889facbeSLen Brown 
3521889facbeSLen Brown 	cpu = t->cpu_id;
3522889facbeSLen Brown 	if (cpu_migrate(cpu)) {
3523b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
3524889facbeSLen Brown 		return -1;
3525889facbeSLen Brown 	}
3526889facbeSLen Brown 
3527889facbeSLen Brown 	if (tcc_activation_temp_override != 0) {
3528889facbeSLen Brown 		tcc_activation_temp = tcc_activation_temp_override;
3529b7d8c148SLen Brown 		fprintf(outf, "cpu%d: Using cmdline TCC Target (%d C)\n",
3530889facbeSLen Brown 			cpu, tcc_activation_temp);
3531889facbeSLen Brown 		return 0;
3532889facbeSLen Brown 	}
3533889facbeSLen Brown 
3534889facbeSLen Brown 	/* Temperature Target MSR is Nehalem and newer only */
3535d7899447SLen Brown 	if (!do_nhm_platform_info)
3536889facbeSLen Brown 		goto guess;
3537889facbeSLen Brown 
35387ce7d5deSPrarit Bhargava 	if (get_msr(base_cpu, MSR_IA32_TEMPERATURE_TARGET, &msr))
3539889facbeSLen Brown 		goto guess;
3540889facbeSLen Brown 
35413482124aSJean Delvare 	target_c_local = (msr >> 16) & 0xFF;
3542889facbeSLen Brown 
3543d8af6f5fSLen Brown 	if (debug)
3544b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_TEMPERATURE_TARGET: 0x%08llx (%d C)\n",
3545889facbeSLen Brown 			cpu, msr, target_c_local);
3546889facbeSLen Brown 
35473482124aSJean Delvare 	if (!target_c_local)
3548889facbeSLen Brown 		goto guess;
3549889facbeSLen Brown 
3550889facbeSLen Brown 	tcc_activation_temp = target_c_local;
3551889facbeSLen Brown 
3552889facbeSLen Brown 	return 0;
3553889facbeSLen Brown 
3554889facbeSLen Brown guess:
3555889facbeSLen Brown 	tcc_activation_temp = TJMAX_DEFAULT;
3556b7d8c148SLen Brown 	fprintf(outf, "cpu%d: Guessing tjMax %d C, Please use -T to specify\n",
3557889facbeSLen Brown 		cpu, tcc_activation_temp);
3558889facbeSLen Brown 
3559889facbeSLen Brown 	return 0;
3560889facbeSLen Brown }
356169807a63SLen Brown 
3562aa8d8cc7SLen Brown void decode_feature_control_msr(void)
3563aa8d8cc7SLen Brown {
3564aa8d8cc7SLen Brown 	unsigned long long msr;
3565aa8d8cc7SLen Brown 
3566aa8d8cc7SLen Brown 	if (!get_msr(base_cpu, MSR_IA32_FEATURE_CONTROL, &msr))
3567aa8d8cc7SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_FEATURE_CONTROL: 0x%08llx (%sLocked %s)\n",
3568aa8d8cc7SLen Brown 			base_cpu, msr,
3569aa8d8cc7SLen Brown 			msr & FEATURE_CONTROL_LOCKED ? "" : "UN-",
3570aa8d8cc7SLen Brown 			msr & (1 << 18) ? "SGX" : "");
3571aa8d8cc7SLen Brown }
3572aa8d8cc7SLen Brown 
357369807a63SLen Brown void decode_misc_enable_msr(void)
357469807a63SLen Brown {
357569807a63SLen Brown 	unsigned long long msr;
357669807a63SLen Brown 
357769807a63SLen Brown 	if (!get_msr(base_cpu, MSR_IA32_MISC_ENABLE, &msr))
3578e6512624SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_MISC_ENABLE: 0x%08llx (%sTCC %sEIST %sMWAIT %sPREFETCH %sTURBO)\n",
357969807a63SLen Brown 			base_cpu, msr,
3580e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_TM1 ? "" : "No-",
3581e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP ? "" : "No-",
3582e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_MWAIT ? "No-" : "",
3583e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_PREFETCH_DISABLE ? "No-" : "",
3584e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE ? "No-" : "");
358569807a63SLen Brown }
358669807a63SLen Brown 
3587*33148d67SLen Brown void decode_misc_feature_control(void)
3588*33148d67SLen Brown {
3589*33148d67SLen Brown 	unsigned long long msr;
3590*33148d67SLen Brown 
3591*33148d67SLen Brown 	if (!has_misc_feature_control)
3592*33148d67SLen Brown 		return;
3593*33148d67SLen Brown 
3594*33148d67SLen Brown 	if (!get_msr(base_cpu, MSR_MISC_FEATURE_CONTROL, &msr))
3595*33148d67SLen Brown 		fprintf(outf, "cpu%d: MSR_MISC_FEATURE_CONTROL: 0x%08llx (%sL2-Prefetch %sL2-Prefetch-pair %sL1-Prefetch %sL1-IP-Prefetch)\n",
3596*33148d67SLen Brown 			base_cpu, msr,
3597*33148d67SLen Brown 			msr & (0 << 0) ? "No-" : "",
3598*33148d67SLen Brown 			msr & (1 << 0) ? "No-" : "",
3599*33148d67SLen Brown 			msr & (2 << 0) ? "No-" : "",
3600*33148d67SLen Brown 			msr & (3 << 0) ? "No-" : "");
3601*33148d67SLen Brown }
3602f0057310SLen Brown /*
3603f0057310SLen Brown  * Decode MSR_MISC_PWR_MGMT
3604f0057310SLen Brown  *
3605f0057310SLen Brown  * Decode the bits according to the Nehalem documentation
3606f0057310SLen Brown  * bit[0] seems to continue to have same meaning going forward
3607f0057310SLen Brown  * bit[1] less so...
3608f0057310SLen Brown  */
3609f0057310SLen Brown void decode_misc_pwr_mgmt_msr(void)
3610f0057310SLen Brown {
3611f0057310SLen Brown 	unsigned long long msr;
3612f0057310SLen Brown 
3613f0057310SLen Brown 	if (!do_nhm_platform_info)
3614f0057310SLen Brown 		return;
3615f0057310SLen Brown 
3616cf4cbe53SLen Brown 	if (no_MSR_MISC_PWR_MGMT)
3617cf4cbe53SLen Brown 		return;
3618cf4cbe53SLen Brown 
3619f0057310SLen Brown 	if (!get_msr(base_cpu, MSR_MISC_PWR_MGMT, &msr))
3620ddadb8adSSrinivas Pandruvada 		fprintf(outf, "cpu%d: MSR_MISC_PWR_MGMT: 0x%08llx (%sable-EIST_Coordination %sable-EPB %sable-OOB)\n",
3621f0057310SLen Brown 			base_cpu, msr,
3622f0057310SLen Brown 			msr & (1 << 0) ? "DIS" : "EN",
3623ddadb8adSSrinivas Pandruvada 			msr & (1 << 1) ? "EN" : "DIS",
3624ddadb8adSSrinivas Pandruvada 			msr & (1 << 8) ? "EN" : "DIS");
3625f0057310SLen Brown }
362671616c8eSLen Brown /*
362771616c8eSLen Brown  * Decode MSR_CC6_DEMOTION_POLICY_CONFIG, MSR_MC6_DEMOTION_POLICY_CONFIG
362871616c8eSLen Brown  *
362971616c8eSLen Brown  * This MSRs are present on Silvermont processors,
363071616c8eSLen Brown  * Intel Atom processor E3000 series (Baytrail), and friends.
363171616c8eSLen Brown  */
363271616c8eSLen Brown void decode_c6_demotion_policy_msr(void)
363371616c8eSLen Brown {
363471616c8eSLen Brown 	unsigned long long msr;
363571616c8eSLen Brown 
363671616c8eSLen Brown 	if (!get_msr(base_cpu, MSR_CC6_DEMOTION_POLICY_CONFIG, &msr))
363771616c8eSLen Brown 		fprintf(outf, "cpu%d: MSR_CC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-CC6-Demotion)\n",
363871616c8eSLen Brown 			base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
363971616c8eSLen Brown 
364071616c8eSLen Brown 	if (!get_msr(base_cpu, MSR_MC6_DEMOTION_POLICY_CONFIG, &msr))
364171616c8eSLen Brown 		fprintf(outf, "cpu%d: MSR_MC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-MC6-Demotion)\n",
364271616c8eSLen Brown 			base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
364371616c8eSLen Brown }
36447f5c258eSLen Brown 
3645fcd17211SLen Brown void process_cpuid()
3646103a8feaSLen Brown {
364761a87ba7SLen Brown 	unsigned int eax, ebx, ecx, edx, max_level, max_extended_level;
3648103a8feaSLen Brown 	unsigned int fms, family, model, stepping;
3649b3a34e93SLen Brown 	unsigned int has_turbo;
3650103a8feaSLen Brown 
3651103a8feaSLen Brown 	eax = ebx = ecx = edx = 0;
3652103a8feaSLen Brown 
36535aea2f7fSLen Brown 	__cpuid(0, max_level, ebx, ecx, edx);
3654103a8feaSLen Brown 
3655103a8feaSLen Brown 	if (ebx == 0x756e6547 && edx == 0x49656e69 && ecx == 0x6c65746e)
3656103a8feaSLen Brown 		genuine_intel = 1;
3657103a8feaSLen Brown 
3658d8af6f5fSLen Brown 	if (debug)
3659b7d8c148SLen Brown 		fprintf(outf, "CPUID(0): %.4s%.4s%.4s ",
3660103a8feaSLen Brown 			(char *)&ebx, (char *)&edx, (char *)&ecx);
3661103a8feaSLen Brown 
36625aea2f7fSLen Brown 	__cpuid(1, fms, ebx, ecx, edx);
3663103a8feaSLen Brown 	family = (fms >> 8) & 0xf;
3664103a8feaSLen Brown 	model = (fms >> 4) & 0xf;
3665103a8feaSLen Brown 	stepping = fms & 0xf;
3666103a8feaSLen Brown 	if (family == 6 || family == 0xf)
3667103a8feaSLen Brown 		model += ((fms >> 16) & 0xf) << 4;
3668103a8feaSLen Brown 
366969807a63SLen Brown 	if (debug) {
3670b7d8c148SLen Brown 		fprintf(outf, "%d CPUID levels; family:model:stepping 0x%x:%x:%x (%d:%d:%d)\n",
3671103a8feaSLen Brown 			max_level, family, model, stepping, family, model, stepping);
3672aa8d8cc7SLen Brown 		fprintf(outf, "CPUID(1): %s %s %s %s %s %s %s %s %s\n",
367369807a63SLen Brown 			ecx & (1 << 0) ? "SSE3" : "-",
367469807a63SLen Brown 			ecx & (1 << 3) ? "MONITOR" : "-",
3675aa8d8cc7SLen Brown 			ecx & (1 << 6) ? "SMX" : "-",
367669807a63SLen Brown 			ecx & (1 << 7) ? "EIST" : "-",
367769807a63SLen Brown 			ecx & (1 << 8) ? "TM2" : "-",
367869807a63SLen Brown 			edx & (1 << 4) ? "TSC" : "-",
367969807a63SLen Brown 			edx & (1 << 5) ? "MSR" : "-",
368069807a63SLen Brown 			edx & (1 << 22) ? "ACPI-TM" : "-",
368169807a63SLen Brown 			edx & (1 << 29) ? "TM" : "-");
368269807a63SLen Brown 	}
3683103a8feaSLen Brown 
3684b2c95d90SJosh Triplett 	if (!(edx & (1 << 5)))
3685b2c95d90SJosh Triplett 		errx(1, "CPUID: no MSR");
3686103a8feaSLen Brown 
3687103a8feaSLen Brown 	/*
3688103a8feaSLen Brown 	 * check max extended function levels of CPUID.
3689103a8feaSLen Brown 	 * This is needed to check for invariant TSC.
3690103a8feaSLen Brown 	 * This check is valid for both Intel and AMD.
3691103a8feaSLen Brown 	 */
3692103a8feaSLen Brown 	ebx = ecx = edx = 0;
36935aea2f7fSLen Brown 	__cpuid(0x80000000, max_extended_level, ebx, ecx, edx);
3694103a8feaSLen Brown 
369561a87ba7SLen Brown 	if (max_extended_level >= 0x80000007) {
3696103a8feaSLen Brown 
3697103a8feaSLen Brown 		/*
3698103a8feaSLen Brown 		 * Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8
3699103a8feaSLen Brown 		 * this check is valid for both Intel and AMD
3700103a8feaSLen Brown 		 */
37015aea2f7fSLen Brown 		__cpuid(0x80000007, eax, ebx, ecx, edx);
37028209e054SThomas Renninger 		has_invariant_tsc = edx & (1 << 8);
3703d7899447SLen Brown 	}
3704103a8feaSLen Brown 
3705103a8feaSLen Brown 	/*
3706103a8feaSLen Brown 	 * APERF/MPERF is advertised by CPUID.EAX=0x6: ECX.bit0
3707103a8feaSLen Brown 	 * this check is valid for both Intel and AMD
3708103a8feaSLen Brown 	 */
3709103a8feaSLen Brown 
37105aea2f7fSLen Brown 	__cpuid(0x6, eax, ebx, ecx, edx);
37118209e054SThomas Renninger 	has_aperf = ecx & (1 << 0);
3712812db3f7SLen Brown 	if (has_aperf) {
3713812db3f7SLen Brown 		BIC_PRESENT(BIC_Avg_MHz);
3714812db3f7SLen Brown 		BIC_PRESENT(BIC_Busy);
3715812db3f7SLen Brown 		BIC_PRESENT(BIC_Bzy_MHz);
3716812db3f7SLen Brown 	}
3717889facbeSLen Brown 	do_dts = eax & (1 << 0);
3718812db3f7SLen Brown 	if (do_dts)
3719812db3f7SLen Brown 		BIC_PRESENT(BIC_CoreTmp);
3720b3a34e93SLen Brown 	has_turbo = eax & (1 << 1);
3721889facbeSLen Brown 	do_ptm = eax & (1 << 6);
3722812db3f7SLen Brown 	if (do_ptm)
3723812db3f7SLen Brown 		BIC_PRESENT(BIC_PkgTmp);
37247f5c258eSLen Brown 	has_hwp = eax & (1 << 7);
37257f5c258eSLen Brown 	has_hwp_notify = eax & (1 << 8);
37267f5c258eSLen Brown 	has_hwp_activity_window = eax & (1 << 9);
37277f5c258eSLen Brown 	has_hwp_epp = eax & (1 << 10);
37287f5c258eSLen Brown 	has_hwp_pkg = eax & (1 << 11);
3729889facbeSLen Brown 	has_epb = ecx & (1 << 3);
3730889facbeSLen Brown 
3731d8af6f5fSLen Brown 	if (debug)
3732b3a34e93SLen Brown 		fprintf(outf, "CPUID(6): %sAPERF, %sTURBO, %sDTS, %sPTM, %sHWP, "
37337f5c258eSLen Brown 			"%sHWPnotify, %sHWPwindow, %sHWPepp, %sHWPpkg, %sEPB\n",
37347f5c258eSLen Brown 			has_aperf ? "" : "No-",
3735b3a34e93SLen Brown 			has_turbo ? "" : "No-",
37367f5c258eSLen Brown 			do_dts ? "" : "No-",
37377f5c258eSLen Brown 			do_ptm ? "" : "No-",
37387f5c258eSLen Brown 			has_hwp ? "" : "No-",
37397f5c258eSLen Brown 			has_hwp_notify ? "" : "No-",
37407f5c258eSLen Brown 			has_hwp_activity_window ? "" : "No-",
37417f5c258eSLen Brown 			has_hwp_epp ? "" : "No-",
37427f5c258eSLen Brown 			has_hwp_pkg ? "" : "No-",
37437f5c258eSLen Brown 			has_epb ? "" : "No-");
3744103a8feaSLen Brown 
374569807a63SLen Brown 	if (debug)
374669807a63SLen Brown 		decode_misc_enable_msr();
374769807a63SLen Brown 
3748*33148d67SLen Brown 
37498ae72255SLen Brown 	if (max_level >= 0x7 && debug) {
3750aa8d8cc7SLen Brown 		int has_sgx;
3751aa8d8cc7SLen Brown 
3752aa8d8cc7SLen Brown 		ecx = 0;
3753aa8d8cc7SLen Brown 
3754aa8d8cc7SLen Brown 		__cpuid_count(0x7, 0, eax, ebx, ecx, edx);
3755aa8d8cc7SLen Brown 
3756aa8d8cc7SLen Brown 		has_sgx = ebx & (1 << 2);
3757aa8d8cc7SLen Brown 		fprintf(outf, "CPUID(7): %sSGX\n", has_sgx ? "" : "No-");
3758aa8d8cc7SLen Brown 
3759aa8d8cc7SLen Brown 		if (has_sgx)
3760aa8d8cc7SLen Brown 			decode_feature_control_msr();
3761aa8d8cc7SLen Brown 	}
3762aa8d8cc7SLen Brown 
376361a87ba7SLen Brown 	if (max_level >= 0x15) {
37648a5bdf41SLen Brown 		unsigned int eax_crystal;
37658a5bdf41SLen Brown 		unsigned int ebx_tsc;
37668a5bdf41SLen Brown 
37678a5bdf41SLen Brown 		/*
37688a5bdf41SLen Brown 		 * CPUID 15H TSC/Crystal ratio, possibly Crystal Hz
37698a5bdf41SLen Brown 		 */
37708a5bdf41SLen Brown 		eax_crystal = ebx_tsc = crystal_hz = edx = 0;
37715aea2f7fSLen Brown 		__cpuid(0x15, eax_crystal, ebx_tsc, crystal_hz, edx);
37728a5bdf41SLen Brown 
37738a5bdf41SLen Brown 		if (ebx_tsc != 0) {
37748a5bdf41SLen Brown 
37758a5bdf41SLen Brown 			if (debug && (ebx != 0))
3776b7d8c148SLen Brown 				fprintf(outf, "CPUID(0x15): eax_crystal: %d ebx_tsc: %d ecx_crystal_hz: %d\n",
37778a5bdf41SLen Brown 					eax_crystal, ebx_tsc, crystal_hz);
37788a5bdf41SLen Brown 
37798a5bdf41SLen Brown 			if (crystal_hz == 0)
37808a5bdf41SLen Brown 				switch(model) {
3781869ce69eSLen Brown 				case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3782869ce69eSLen Brown 				case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3783869ce69eSLen Brown 				case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3784869ce69eSLen Brown 				case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
3785e8efbc80SLen Brown 					crystal_hz = 24000000;	/* 24.0 MHz */
3786e8efbc80SLen Brown 					break;
3787869ce69eSLen Brown 				case INTEL_FAM6_SKYLAKE_X:	/* SKX */
37887268d407SLen Brown 				case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
3789ec53e594SLen Brown 					crystal_hz = 25000000;	/* 25.0 MHz */
3790ec53e594SLen Brown 					break;
3791869ce69eSLen Brown 				case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3792e8efbc80SLen Brown 					crystal_hz = 19200000;	/* 19.2 MHz */
37938a5bdf41SLen Brown 					break;
37948a5bdf41SLen Brown 				default:
37958a5bdf41SLen Brown 					crystal_hz = 0;
37968a5bdf41SLen Brown 			}
37978a5bdf41SLen Brown 
37988a5bdf41SLen Brown 			if (crystal_hz) {
37998a5bdf41SLen Brown 				tsc_hz =  (unsigned long long) crystal_hz * ebx_tsc / eax_crystal;
38008a5bdf41SLen Brown 				if (debug)
3801b7d8c148SLen Brown 					fprintf(outf, "TSC: %lld MHz (%d Hz * %d / %d / 1000000)\n",
38028a5bdf41SLen Brown 						tsc_hz / 1000000, crystal_hz, ebx_tsc,  eax_crystal);
38038a5bdf41SLen Brown 			}
38048a5bdf41SLen Brown 		}
38058a5bdf41SLen Brown 	}
380661a87ba7SLen Brown 	if (max_level >= 0x16) {
380761a87ba7SLen Brown 		unsigned int base_mhz, max_mhz, bus_mhz, edx;
380861a87ba7SLen Brown 
380961a87ba7SLen Brown 		/*
381061a87ba7SLen Brown 		 * CPUID 16H Base MHz, Max MHz, Bus MHz
381161a87ba7SLen Brown 		 */
381261a87ba7SLen Brown 		base_mhz = max_mhz = bus_mhz = edx = 0;
381361a87ba7SLen Brown 
38145aea2f7fSLen Brown 		__cpuid(0x16, base_mhz, max_mhz, bus_mhz, edx);
381561a87ba7SLen Brown 		if (debug)
3816b7d8c148SLen Brown 			fprintf(outf, "CPUID(0x16): base_mhz: %d max_mhz: %d bus_mhz: %d\n",
381761a87ba7SLen Brown 				base_mhz, max_mhz, bus_mhz);
381861a87ba7SLen Brown 	}
38198a5bdf41SLen Brown 
3820b2b34dfeSHubert Chrzaniuk 	if (has_aperf)
3821b2b34dfeSHubert Chrzaniuk 		aperf_mperf_multiplier = get_aperf_mperf_multiplier(family, model);
3822b2b34dfeSHubert Chrzaniuk 
3823812db3f7SLen Brown 	BIC_PRESENT(BIC_IRQ);
3824812db3f7SLen Brown 	BIC_PRESENT(BIC_TSC_MHz);
3825812db3f7SLen Brown 
3826812db3f7SLen Brown 	if (probe_nhm_msrs(family, model)) {
3827812db3f7SLen Brown 		do_nhm_platform_info = 1;
3828812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c1);
3829812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c3);
3830812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c6);
3831812db3f7SLen Brown 		BIC_PRESENT(BIC_SMI);
3832812db3f7SLen Brown 	}
3833d7899447SLen Brown 	do_snb_cstates = has_snb_msrs(family, model);
3834812db3f7SLen Brown 
3835812db3f7SLen Brown 	if (do_snb_cstates)
3836812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c7);
3837812db3f7SLen Brown 
38385a63426eSLen Brown 	do_irtl_snb = has_snb_msrs(family, model);
3839ee7e38e3SLen Brown 	do_pc2 = do_snb_cstates && (pkg_cstate_limit >= PCL__2);
3840ee7e38e3SLen Brown 	do_pc3 = (pkg_cstate_limit >= PCL__3);
3841ee7e38e3SLen Brown 	do_pc6 = (pkg_cstate_limit >= PCL__6);
3842ee7e38e3SLen Brown 	do_pc7 = do_snb_cstates && (pkg_cstate_limit >= PCL__7);
38430539ba11SLen Brown 	if (has_slv_msrs(family, model)) {
38440539ba11SLen Brown 		do_pc2 = do_pc3 = do_pc7 = 0;
38450539ba11SLen Brown 		do_pc6 = 1;
38460539ba11SLen Brown 		BIC_PRESENT(BIC_Mod_c6);
38470539ba11SLen Brown 		use_c1_residency_msr = 1;
38480539ba11SLen Brown 	}
3849d7899447SLen Brown 	do_c8_c9_c10 = has_hsw_msrs(family, model);
38505a63426eSLen Brown 	do_irtl_hsw = has_hsw_msrs(family, model);
38510b2bb692SLen Brown 	do_skl_residency = has_skl_msrs(family, model);
3852144b44b1SLen Brown 	do_slm_cstates = is_slm(family, model);
3853fb5d4327SDasaratharaman Chandramouli 	do_knl_cstates  = is_knl(family, model);
3854103a8feaSLen Brown 
3855f0057310SLen Brown 	if (debug)
3856f0057310SLen Brown 		decode_misc_pwr_mgmt_msr();
3857f0057310SLen Brown 
385871616c8eSLen Brown 	if (debug && has_slv_msrs(family, model))
385971616c8eSLen Brown 		decode_c6_demotion_policy_msr();
386071616c8eSLen Brown 
3861889facbeSLen Brown 	rapl_probe(family, model);
38623a9a941dSLen Brown 	perf_limit_reasons_probe(family, model);
3863889facbeSLen Brown 
3864fcd17211SLen Brown 	if (debug)
38651b69317dSColin Ian King 		dump_cstate_pstate_config_info(family, model);
3866fcd17211SLen Brown 
3867a2b7b749SLen Brown 	if (has_skl_msrs(family, model))
3868a2b7b749SLen Brown 		calculate_tsc_tweak();
3869a2b7b749SLen Brown 
3870812db3f7SLen Brown 	if (!access("/sys/class/drm/card0/power/rc6_residency_ms", R_OK))
3871812db3f7SLen Brown 		BIC_PRESENT(BIC_GFX_rc6);
3872fdf676e5SLen Brown 
3873812db3f7SLen Brown 	if (!access("/sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz", R_OK))
3874812db3f7SLen Brown 		BIC_PRESENT(BIC_GFXMHz);
387527d47356SLen Brown 
3876*33148d67SLen Brown 	if (debug)
3877*33148d67SLen Brown 		decode_misc_feature_control();
3878*33148d67SLen Brown 
3879889facbeSLen Brown 	return;
3880103a8feaSLen Brown }
3881103a8feaSLen Brown 
3882d8af6f5fSLen Brown void help()
3883103a8feaSLen Brown {
3884b7d8c148SLen Brown 	fprintf(outf,
3885d8af6f5fSLen Brown 	"Usage: turbostat [OPTIONS][(--interval seconds) | COMMAND ...]\n"
3886d8af6f5fSLen Brown 	"\n"
3887d8af6f5fSLen Brown 	"Turbostat forks the specified COMMAND and prints statistics\n"
3888d8af6f5fSLen Brown 	"when COMMAND completes.\n"
3889d8af6f5fSLen Brown 	"If no COMMAND is specified, turbostat wakes every 5-seconds\n"
3890d8af6f5fSLen Brown 	"to print statistics, until interrupted.\n"
3891388e9c81SLen Brown 	"--add		add a counter\n"
3892388e9c81SLen Brown 	"		eg. --add msr0x10,u64,cpu,delta,MY_TSC\n"
3893d8af6f5fSLen Brown 	"--debug	run in \"debug\" mode\n"
3894d8af6f5fSLen Brown 	"--interval sec	Override default 5-second measurement interval\n"
3895d8af6f5fSLen Brown 	"--help		print this help message\n"
3896b7d8c148SLen Brown 	"--out file	create or truncate \"file\" for all output\n"
3897d8af6f5fSLen Brown 	"--version	print version information\n"
3898d8af6f5fSLen Brown 	"\n"
3899d8af6f5fSLen Brown 	"For more help, run \"man turbostat\"\n");
3900103a8feaSLen Brown }
3901103a8feaSLen Brown 
3902103a8feaSLen Brown 
3903103a8feaSLen Brown /*
3904103a8feaSLen Brown  * in /dev/cpu/ return success for names that are numbers
3905103a8feaSLen Brown  * ie. filter out ".", "..", "microcode".
3906103a8feaSLen Brown  */
3907103a8feaSLen Brown int dir_filter(const struct dirent *dirp)
3908103a8feaSLen Brown {
3909103a8feaSLen Brown 	if (isdigit(dirp->d_name[0]))
3910103a8feaSLen Brown 		return 1;
3911103a8feaSLen Brown 	else
3912103a8feaSLen Brown 		return 0;
3913103a8feaSLen Brown }
3914103a8feaSLen Brown 
3915103a8feaSLen Brown int open_dev_cpu_msr(int dummy1)
3916103a8feaSLen Brown {
3917103a8feaSLen Brown 	return 0;
3918103a8feaSLen Brown }
3919103a8feaSLen Brown 
3920c98d5d94SLen Brown void topology_probe()
3921c98d5d94SLen Brown {
3922c98d5d94SLen Brown 	int i;
3923c98d5d94SLen Brown 	int max_core_id = 0;
3924c98d5d94SLen Brown 	int max_package_id = 0;
3925c98d5d94SLen Brown 	int max_siblings = 0;
3926c98d5d94SLen Brown 	struct cpu_topology {
3927c98d5d94SLen Brown 		int core_id;
3928c98d5d94SLen Brown 		int physical_package_id;
3929c98d5d94SLen Brown 	} *cpus;
3930c98d5d94SLen Brown 
3931c98d5d94SLen Brown 	/* Initialize num_cpus, max_cpu_num */
3932c98d5d94SLen Brown 	topo.num_cpus = 0;
3933c98d5d94SLen Brown 	topo.max_cpu_num = 0;
3934c98d5d94SLen Brown 	for_all_proc_cpus(count_cpus);
3935c98d5d94SLen Brown 	if (!summary_only && topo.num_cpus > 1)
3936812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU);
3937c98d5d94SLen Brown 
3938d8af6f5fSLen Brown 	if (debug > 1)
3939b7d8c148SLen Brown 		fprintf(outf, "num_cpus %d max_cpu_num %d\n", topo.num_cpus, topo.max_cpu_num);
3940c98d5d94SLen Brown 
3941c98d5d94SLen Brown 	cpus = calloc(1, (topo.max_cpu_num  + 1) * sizeof(struct cpu_topology));
3942b2c95d90SJosh Triplett 	if (cpus == NULL)
3943b2c95d90SJosh Triplett 		err(1, "calloc cpus");
3944c98d5d94SLen Brown 
3945c98d5d94SLen Brown 	/*
3946c98d5d94SLen Brown 	 * Allocate and initialize cpu_present_set
3947c98d5d94SLen Brown 	 */
3948c98d5d94SLen Brown 	cpu_present_set = CPU_ALLOC((topo.max_cpu_num + 1));
3949b2c95d90SJosh Triplett 	if (cpu_present_set == NULL)
3950b2c95d90SJosh Triplett 		err(3, "CPU_ALLOC");
3951c98d5d94SLen Brown 	cpu_present_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
3952c98d5d94SLen Brown 	CPU_ZERO_S(cpu_present_setsize, cpu_present_set);
3953c98d5d94SLen Brown 	for_all_proc_cpus(mark_cpu_present);
3954c98d5d94SLen Brown 
3955c98d5d94SLen Brown 	/*
3956c98d5d94SLen Brown 	 * Allocate and initialize cpu_affinity_set
3957c98d5d94SLen Brown 	 */
3958c98d5d94SLen Brown 	cpu_affinity_set = CPU_ALLOC((topo.max_cpu_num + 1));
3959b2c95d90SJosh Triplett 	if (cpu_affinity_set == NULL)
3960b2c95d90SJosh Triplett 		err(3, "CPU_ALLOC");
3961c98d5d94SLen Brown 	cpu_affinity_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
3962c98d5d94SLen Brown 	CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
3963c98d5d94SLen Brown 
3964c98d5d94SLen Brown 
3965c98d5d94SLen Brown 	/*
3966c98d5d94SLen Brown 	 * For online cpus
3967c98d5d94SLen Brown 	 * find max_core_id, max_package_id
3968c98d5d94SLen Brown 	 */
3969c98d5d94SLen Brown 	for (i = 0; i <= topo.max_cpu_num; ++i) {
3970c98d5d94SLen Brown 		int siblings;
3971c98d5d94SLen Brown 
3972c98d5d94SLen Brown 		if (cpu_is_not_present(i)) {
3973d8af6f5fSLen Brown 			if (debug > 1)
3974b7d8c148SLen Brown 				fprintf(outf, "cpu%d NOT PRESENT\n", i);
3975c98d5d94SLen Brown 			continue;
3976c98d5d94SLen Brown 		}
3977c98d5d94SLen Brown 		cpus[i].core_id = get_core_id(i);
3978c98d5d94SLen Brown 		if (cpus[i].core_id > max_core_id)
3979c98d5d94SLen Brown 			max_core_id = cpus[i].core_id;
3980c98d5d94SLen Brown 
3981c98d5d94SLen Brown 		cpus[i].physical_package_id = get_physical_package_id(i);
3982c98d5d94SLen Brown 		if (cpus[i].physical_package_id > max_package_id)
3983c98d5d94SLen Brown 			max_package_id = cpus[i].physical_package_id;
3984c98d5d94SLen Brown 
3985c98d5d94SLen Brown 		siblings = get_num_ht_siblings(i);
3986c98d5d94SLen Brown 		if (siblings > max_siblings)
3987c98d5d94SLen Brown 			max_siblings = siblings;
3988d8af6f5fSLen Brown 		if (debug > 1)
3989b7d8c148SLen Brown 			fprintf(outf, "cpu %d pkg %d core %d\n",
3990c98d5d94SLen Brown 				i, cpus[i].physical_package_id, cpus[i].core_id);
3991c98d5d94SLen Brown 	}
3992c98d5d94SLen Brown 	topo.num_cores_per_pkg = max_core_id + 1;
3993d8af6f5fSLen Brown 	if (debug > 1)
3994b7d8c148SLen Brown 		fprintf(outf, "max_core_id %d, sizing for %d cores per package\n",
3995c98d5d94SLen Brown 			max_core_id, topo.num_cores_per_pkg);
39961cc21f7bSLen Brown 	if (debug && !summary_only && topo.num_cores_per_pkg > 1)
3997812db3f7SLen Brown 		BIC_PRESENT(BIC_Core);
3998c98d5d94SLen Brown 
3999c98d5d94SLen Brown 	topo.num_packages = max_package_id + 1;
4000d8af6f5fSLen Brown 	if (debug > 1)
4001b7d8c148SLen Brown 		fprintf(outf, "max_package_id %d, sizing for %d packages\n",
4002c98d5d94SLen Brown 			max_package_id, topo.num_packages);
40031cc21f7bSLen Brown 	if (debug && !summary_only && topo.num_packages > 1)
4004812db3f7SLen Brown 		BIC_PRESENT(BIC_Package);
4005c98d5d94SLen Brown 
4006c98d5d94SLen Brown 	topo.num_threads_per_core = max_siblings;
4007d8af6f5fSLen Brown 	if (debug > 1)
4008b7d8c148SLen Brown 		fprintf(outf, "max_siblings %d\n", max_siblings);
4009c98d5d94SLen Brown 
4010c98d5d94SLen Brown 	free(cpus);
4011c98d5d94SLen Brown }
4012c98d5d94SLen Brown 
4013c98d5d94SLen Brown void
4014c98d5d94SLen Brown allocate_counters(struct thread_data **t, struct core_data **c, struct pkg_data **p)
4015c98d5d94SLen Brown {
4016c98d5d94SLen Brown 	int i;
4017c98d5d94SLen Brown 
4018c98d5d94SLen Brown 	*t = calloc(topo.num_threads_per_core * topo.num_cores_per_pkg *
4019678a3bd1SLen Brown 		topo.num_packages, sizeof(struct thread_data));
4020c98d5d94SLen Brown 	if (*t == NULL)
4021c98d5d94SLen Brown 		goto error;
4022c98d5d94SLen Brown 
4023c98d5d94SLen Brown 	for (i = 0; i < topo.num_threads_per_core *
4024c98d5d94SLen Brown 		topo.num_cores_per_pkg * topo.num_packages; i++)
4025c98d5d94SLen Brown 		(*t)[i].cpu_id = -1;
4026c98d5d94SLen Brown 
4027c98d5d94SLen Brown 	*c = calloc(topo.num_cores_per_pkg * topo.num_packages,
4028678a3bd1SLen Brown 		sizeof(struct core_data));
4029c98d5d94SLen Brown 	if (*c == NULL)
4030c98d5d94SLen Brown 		goto error;
4031c98d5d94SLen Brown 
4032c98d5d94SLen Brown 	for (i = 0; i < topo.num_cores_per_pkg * topo.num_packages; i++)
4033c98d5d94SLen Brown 		(*c)[i].core_id = -1;
4034c98d5d94SLen Brown 
4035678a3bd1SLen Brown 	*p = calloc(topo.num_packages, sizeof(struct pkg_data));
4036c98d5d94SLen Brown 	if (*p == NULL)
4037c98d5d94SLen Brown 		goto error;
4038c98d5d94SLen Brown 
4039c98d5d94SLen Brown 	for (i = 0; i < topo.num_packages; i++)
4040c98d5d94SLen Brown 		(*p)[i].package_id = i;
4041c98d5d94SLen Brown 
4042c98d5d94SLen Brown 	return;
4043c98d5d94SLen Brown error:
4044b2c95d90SJosh Triplett 	err(1, "calloc counters");
4045c98d5d94SLen Brown }
4046c98d5d94SLen Brown /*
4047c98d5d94SLen Brown  * init_counter()
4048c98d5d94SLen Brown  *
4049c98d5d94SLen Brown  * set cpu_id, core_num, pkg_num
4050c98d5d94SLen Brown  * set FIRST_THREAD_IN_CORE and FIRST_CORE_IN_PACKAGE
4051c98d5d94SLen Brown  *
4052c98d5d94SLen Brown  * increment topo.num_cores when 1st core in pkg seen
4053c98d5d94SLen Brown  */
4054c98d5d94SLen Brown void init_counter(struct thread_data *thread_base, struct core_data *core_base,
4055c98d5d94SLen Brown 	struct pkg_data *pkg_base, int thread_num, int core_num,
4056c98d5d94SLen Brown 	int pkg_num, int cpu_id)
4057c98d5d94SLen Brown {
4058c98d5d94SLen Brown 	struct thread_data *t;
4059c98d5d94SLen Brown 	struct core_data *c;
4060c98d5d94SLen Brown 	struct pkg_data *p;
4061c98d5d94SLen Brown 
4062c98d5d94SLen Brown 	t = GET_THREAD(thread_base, thread_num, core_num, pkg_num);
4063c98d5d94SLen Brown 	c = GET_CORE(core_base, core_num, pkg_num);
4064c98d5d94SLen Brown 	p = GET_PKG(pkg_base, pkg_num);
4065c98d5d94SLen Brown 
4066c98d5d94SLen Brown 	t->cpu_id = cpu_id;
4067c98d5d94SLen Brown 	if (thread_num == 0) {
4068c98d5d94SLen Brown 		t->flags |= CPU_IS_FIRST_THREAD_IN_CORE;
4069c98d5d94SLen Brown 		if (cpu_is_first_core_in_package(cpu_id))
4070c98d5d94SLen Brown 			t->flags |= CPU_IS_FIRST_CORE_IN_PACKAGE;
4071c98d5d94SLen Brown 	}
4072c98d5d94SLen Brown 
4073c98d5d94SLen Brown 	c->core_id = core_num;
4074c98d5d94SLen Brown 	p->package_id = pkg_num;
4075c98d5d94SLen Brown }
4076c98d5d94SLen Brown 
4077c98d5d94SLen Brown 
4078c98d5d94SLen Brown int initialize_counters(int cpu_id)
4079c98d5d94SLen Brown {
4080c98d5d94SLen Brown 	int my_thread_id, my_core_id, my_package_id;
4081c98d5d94SLen Brown 
4082c98d5d94SLen Brown 	my_package_id = get_physical_package_id(cpu_id);
4083c98d5d94SLen Brown 	my_core_id = get_core_id(cpu_id);
4084e275b388SDasaratharaman Chandramouli 	my_thread_id = get_cpu_position_in_core(cpu_id);
4085e275b388SDasaratharaman Chandramouli 	if (!my_thread_id)
4086c98d5d94SLen Brown 		topo.num_cores++;
4087c98d5d94SLen Brown 
4088c98d5d94SLen Brown 	init_counter(EVEN_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
4089c98d5d94SLen Brown 	init_counter(ODD_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
4090c98d5d94SLen Brown 	return 0;
4091c98d5d94SLen Brown }
4092c98d5d94SLen Brown 
4093c98d5d94SLen Brown void allocate_output_buffer()
4094c98d5d94SLen Brown {
40953b4d5c7fSAndy Shevchenko 	output_buffer = calloc(1, (1 + topo.num_cpus) * 1024);
4096c98d5d94SLen Brown 	outp = output_buffer;
4097b2c95d90SJosh Triplett 	if (outp == NULL)
4098b2c95d90SJosh Triplett 		err(-1, "calloc output buffer");
4099c98d5d94SLen Brown }
410036229897SLen Brown void allocate_fd_percpu(void)
410136229897SLen Brown {
410201a67adfSMika Westerberg 	fd_percpu = calloc(topo.max_cpu_num + 1, sizeof(int));
410336229897SLen Brown 	if (fd_percpu == NULL)
410436229897SLen Brown 		err(-1, "calloc fd_percpu");
410536229897SLen Brown }
4106562a2d37SLen Brown void allocate_irq_buffers(void)
4107562a2d37SLen Brown {
4108562a2d37SLen Brown 	irq_column_2_cpu = calloc(topo.num_cpus, sizeof(int));
4109562a2d37SLen Brown 	if (irq_column_2_cpu == NULL)
4110562a2d37SLen Brown 		err(-1, "calloc %d", topo.num_cpus);
4111c98d5d94SLen Brown 
411201a67adfSMika Westerberg 	irqs_per_cpu = calloc(topo.max_cpu_num + 1, sizeof(int));
4113562a2d37SLen Brown 	if (irqs_per_cpu == NULL)
411401a67adfSMika Westerberg 		err(-1, "calloc %d", topo.max_cpu_num + 1);
4115562a2d37SLen Brown }
4116c98d5d94SLen Brown void setup_all_buffers(void)
4117c98d5d94SLen Brown {
4118c98d5d94SLen Brown 	topology_probe();
4119562a2d37SLen Brown 	allocate_irq_buffers();
412036229897SLen Brown 	allocate_fd_percpu();
4121c98d5d94SLen Brown 	allocate_counters(&thread_even, &core_even, &package_even);
4122c98d5d94SLen Brown 	allocate_counters(&thread_odd, &core_odd, &package_odd);
4123c98d5d94SLen Brown 	allocate_output_buffer();
4124c98d5d94SLen Brown 	for_all_proc_cpus(initialize_counters);
4125c98d5d94SLen Brown }
41263b4d5c7fSAndy Shevchenko 
41277ce7d5deSPrarit Bhargava void set_base_cpu(void)
41287ce7d5deSPrarit Bhargava {
41297ce7d5deSPrarit Bhargava 	base_cpu = sched_getcpu();
41307ce7d5deSPrarit Bhargava 	if (base_cpu < 0)
41317ce7d5deSPrarit Bhargava 		err(-ENODEV, "No valid cpus found");
41327ce7d5deSPrarit Bhargava 
41337ce7d5deSPrarit Bhargava 	if (debug > 1)
4134b7d8c148SLen Brown 		fprintf(outf, "base_cpu = %d\n", base_cpu);
41357ce7d5deSPrarit Bhargava }
41367ce7d5deSPrarit Bhargava 
4137103a8feaSLen Brown void turbostat_init()
4138103a8feaSLen Brown {
41397ce7d5deSPrarit Bhargava 	setup_all_buffers();
41407ce7d5deSPrarit Bhargava 	set_base_cpu();
4141103a8feaSLen Brown 	check_dev_msr();
414298481e79SLen Brown 	check_permissions();
4143fcd17211SLen Brown 	process_cpuid();
4144103a8feaSLen Brown 
4145103a8feaSLen Brown 
4146d8af6f5fSLen Brown 	if (debug)
41477f5c258eSLen Brown 		for_all_cpus(print_hwp, ODD_COUNTERS);
41487f5c258eSLen Brown 
41497f5c258eSLen Brown 	if (debug)
4150889facbeSLen Brown 		for_all_cpus(print_epb, ODD_COUNTERS);
4151889facbeSLen Brown 
4152d8af6f5fSLen Brown 	if (debug)
41533a9a941dSLen Brown 		for_all_cpus(print_perf_limit, ODD_COUNTERS);
41543a9a941dSLen Brown 
4155d8af6f5fSLen Brown 	if (debug)
4156889facbeSLen Brown 		for_all_cpus(print_rapl, ODD_COUNTERS);
4157889facbeSLen Brown 
4158889facbeSLen Brown 	for_all_cpus(set_temperature_target, ODD_COUNTERS);
4159889facbeSLen Brown 
4160d8af6f5fSLen Brown 	if (debug)
4161889facbeSLen Brown 		for_all_cpus(print_thermal, ODD_COUNTERS);
41625a63426eSLen Brown 
41635a63426eSLen Brown 	if (debug && do_irtl_snb)
41645a63426eSLen Brown 		print_irtl();
4165103a8feaSLen Brown }
4166103a8feaSLen Brown 
4167103a8feaSLen Brown int fork_it(char **argv)
4168103a8feaSLen Brown {
4169103a8feaSLen Brown 	pid_t child_pid;
4170d91bb17cSLen Brown 	int status;
4171d15cf7c1SLen Brown 
4172d91bb17cSLen Brown 	status = for_all_cpus(get_counters, EVEN_COUNTERS);
4173d91bb17cSLen Brown 	if (status)
4174d91bb17cSLen Brown 		exit(status);
4175d15cf7c1SLen Brown 	/* clear affinity side-effect of get_counters() */
4176d15cf7c1SLen Brown 	sched_setaffinity(0, cpu_present_setsize, cpu_present_set);
4177103a8feaSLen Brown 	gettimeofday(&tv_even, (struct timezone *)NULL);
4178103a8feaSLen Brown 
4179103a8feaSLen Brown 	child_pid = fork();
4180103a8feaSLen Brown 	if (!child_pid) {
4181103a8feaSLen Brown 		/* child */
4182103a8feaSLen Brown 		execvp(argv[0], argv);
4183103a8feaSLen Brown 	} else {
4184103a8feaSLen Brown 
4185103a8feaSLen Brown 		/* parent */
4186b2c95d90SJosh Triplett 		if (child_pid == -1)
4187b2c95d90SJosh Triplett 			err(1, "fork");
4188103a8feaSLen Brown 
4189103a8feaSLen Brown 		signal(SIGINT, SIG_IGN);
4190103a8feaSLen Brown 		signal(SIGQUIT, SIG_IGN);
4191b2c95d90SJosh Triplett 		if (waitpid(child_pid, &status, 0) == -1)
4192b2c95d90SJosh Triplett 			err(status, "waitpid");
4193103a8feaSLen Brown 	}
4194c98d5d94SLen Brown 	/*
4195c98d5d94SLen Brown 	 * n.b. fork_it() does not check for errors from for_all_cpus()
4196c98d5d94SLen Brown 	 * because re-starting is problematic when forking
4197c98d5d94SLen Brown 	 */
4198c98d5d94SLen Brown 	for_all_cpus(get_counters, ODD_COUNTERS);
4199103a8feaSLen Brown 	gettimeofday(&tv_odd, (struct timezone *)NULL);
4200103a8feaSLen Brown 	timersub(&tv_odd, &tv_even, &tv_delta);
4201ba3dec99SLen Brown 	if (for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS))
4202ba3dec99SLen Brown 		fprintf(outf, "%s: Counter reset detected\n", progname);
4203ba3dec99SLen Brown 	else {
4204c98d5d94SLen Brown 		compute_average(EVEN_COUNTERS);
4205c98d5d94SLen Brown 		format_all_counters(EVEN_COUNTERS);
4206ba3dec99SLen Brown 	}
4207103a8feaSLen Brown 
4208b7d8c148SLen Brown 	fprintf(outf, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0);
4209b7d8c148SLen Brown 
4210b7d8c148SLen Brown 	flush_output_stderr();
4211103a8feaSLen Brown 
4212d91bb17cSLen Brown 	return status;
4213103a8feaSLen Brown }
4214103a8feaSLen Brown 
42153b4d5c7fSAndy Shevchenko int get_and_dump_counters(void)
42163b4d5c7fSAndy Shevchenko {
42173b4d5c7fSAndy Shevchenko 	int status;
42183b4d5c7fSAndy Shevchenko 
42193b4d5c7fSAndy Shevchenko 	status = for_all_cpus(get_counters, ODD_COUNTERS);
42203b4d5c7fSAndy Shevchenko 	if (status)
42213b4d5c7fSAndy Shevchenko 		return status;
42223b4d5c7fSAndy Shevchenko 
42233b4d5c7fSAndy Shevchenko 	status = for_all_cpus(dump_counters, ODD_COUNTERS);
42243b4d5c7fSAndy Shevchenko 	if (status)
42253b4d5c7fSAndy Shevchenko 		return status;
42263b4d5c7fSAndy Shevchenko 
4227b7d8c148SLen Brown 	flush_output_stdout();
42283b4d5c7fSAndy Shevchenko 
42293b4d5c7fSAndy Shevchenko 	return status;
42303b4d5c7fSAndy Shevchenko }
42313b4d5c7fSAndy Shevchenko 
4232d8af6f5fSLen Brown void print_version() {
42330539ba11SLen Brown 	fprintf(outf, "turbostat version 4.17 10 Jan 2017"
4234d8af6f5fSLen Brown 		" - Len Brown <lenb@kernel.org>\n");
4235d8af6f5fSLen Brown }
4236d8af6f5fSLen Brown 
4237388e9c81SLen Brown int add_counter(unsigned int msr_num, char *name, unsigned int width,
4238388e9c81SLen Brown 	enum counter_scope scope, enum counter_type type,
4239388e9c81SLen Brown 	enum counter_format format)
4240388e9c81SLen Brown {
4241388e9c81SLen Brown 	struct msr_counter *msrp;
4242388e9c81SLen Brown 
4243388e9c81SLen Brown 	msrp = calloc(1, sizeof(struct msr_counter));
4244388e9c81SLen Brown 	if (msrp == NULL) {
4245388e9c81SLen Brown 		perror("calloc");
4246388e9c81SLen Brown 		exit(1);
4247388e9c81SLen Brown 	}
4248388e9c81SLen Brown 
4249388e9c81SLen Brown 	msrp->msr_num = msr_num;
4250388e9c81SLen Brown 	strncpy(msrp->name, name, NAME_BYTES);
4251388e9c81SLen Brown 	msrp->width = width;
4252388e9c81SLen Brown 	msrp->type = type;
4253388e9c81SLen Brown 	msrp->format = format;
4254388e9c81SLen Brown 
4255388e9c81SLen Brown 	switch (scope) {
4256388e9c81SLen Brown 
4257388e9c81SLen Brown 	case SCOPE_CPU:
4258388e9c81SLen Brown 		msrp->next = sys.tp;
4259388e9c81SLen Brown 		sys.tp = msrp;
4260678a3bd1SLen Brown 		sys.added_thread_counters++;
4261678a3bd1SLen Brown 		if (sys.added_thread_counters > MAX_ADDED_COUNTERS) {
4262678a3bd1SLen Brown 			fprintf(stderr, "exceeded max %d added thread counters\n",
4263678a3bd1SLen Brown 				MAX_ADDED_COUNTERS);
4264678a3bd1SLen Brown 			exit(-1);
4265678a3bd1SLen Brown 		}
4266388e9c81SLen Brown 		break;
4267388e9c81SLen Brown 
4268388e9c81SLen Brown 	case SCOPE_CORE:
4269388e9c81SLen Brown 		msrp->next = sys.cp;
4270388e9c81SLen Brown 		sys.cp = msrp;
4271678a3bd1SLen Brown 		sys.added_core_counters++;
4272678a3bd1SLen Brown 		if (sys.added_core_counters > MAX_ADDED_COUNTERS) {
4273678a3bd1SLen Brown 			fprintf(stderr, "exceeded max %d added core counters\n",
4274678a3bd1SLen Brown 				MAX_ADDED_COUNTERS);
4275678a3bd1SLen Brown 			exit(-1);
4276678a3bd1SLen Brown 		}
4277388e9c81SLen Brown 		break;
4278388e9c81SLen Brown 
4279388e9c81SLen Brown 	case SCOPE_PACKAGE:
4280388e9c81SLen Brown 		msrp->next = sys.pp;
4281388e9c81SLen Brown 		sys.pp = msrp;
4282678a3bd1SLen Brown 		sys.added_package_counters++;
4283678a3bd1SLen Brown 		if (sys.added_package_counters > MAX_ADDED_COUNTERS) {
4284678a3bd1SLen Brown 			fprintf(stderr, "exceeded max %d added package counters\n",
4285678a3bd1SLen Brown 				MAX_ADDED_COUNTERS);
4286678a3bd1SLen Brown 			exit(-1);
4287678a3bd1SLen Brown 		}
4288388e9c81SLen Brown 		break;
4289388e9c81SLen Brown 	}
4290388e9c81SLen Brown 
4291388e9c81SLen Brown 	return 0;
4292388e9c81SLen Brown }
4293388e9c81SLen Brown 
4294388e9c81SLen Brown void parse_add_command(char *add_command)
4295388e9c81SLen Brown {
4296388e9c81SLen Brown 	int msr_num = 0;
4297388e9c81SLen Brown 	char name_buffer[NAME_BYTES];
4298388e9c81SLen Brown 	int width = 64;
4299388e9c81SLen Brown 	int fail = 0;
4300388e9c81SLen Brown 	enum counter_scope scope = SCOPE_CPU;
4301388e9c81SLen Brown 	enum counter_type type = COUNTER_CYCLES;
4302388e9c81SLen Brown 	enum counter_format format = FORMAT_DELTA;
4303388e9c81SLen Brown 
4304388e9c81SLen Brown 	while (add_command) {
4305388e9c81SLen Brown 
4306388e9c81SLen Brown 		if (sscanf(add_command, "msr0x%x", &msr_num) == 1)
4307388e9c81SLen Brown 			goto next;
4308388e9c81SLen Brown 
4309388e9c81SLen Brown 		if (sscanf(add_command, "msr%d", &msr_num) == 1)
4310388e9c81SLen Brown 			goto next;
4311388e9c81SLen Brown 
4312388e9c81SLen Brown 		if (sscanf(add_command, "u%d", &width) == 1) {
4313388e9c81SLen Brown 			if ((width == 32) || (width == 64))
4314388e9c81SLen Brown 				goto next;
4315388e9c81SLen Brown 			width = 64;
4316388e9c81SLen Brown 		}
4317388e9c81SLen Brown 		if (!strncmp(add_command, "cpu", strlen("cpu"))) {
4318388e9c81SLen Brown 			scope = SCOPE_CPU;
4319388e9c81SLen Brown 			goto next;
4320388e9c81SLen Brown 		}
4321388e9c81SLen Brown 		if (!strncmp(add_command, "core", strlen("core"))) {
4322388e9c81SLen Brown 			scope = SCOPE_CORE;
4323388e9c81SLen Brown 			goto next;
4324388e9c81SLen Brown 		}
4325388e9c81SLen Brown 		if (!strncmp(add_command, "package", strlen("package"))) {
4326388e9c81SLen Brown 			scope = SCOPE_PACKAGE;
4327388e9c81SLen Brown 			goto next;
4328388e9c81SLen Brown 		}
4329388e9c81SLen Brown 		if (!strncmp(add_command, "cycles", strlen("cycles"))) {
4330388e9c81SLen Brown 			type = COUNTER_CYCLES;
4331388e9c81SLen Brown 			goto next;
4332388e9c81SLen Brown 		}
4333388e9c81SLen Brown 		if (!strncmp(add_command, "seconds", strlen("seconds"))) {
4334388e9c81SLen Brown 			type = COUNTER_SECONDS;
4335388e9c81SLen Brown 			goto next;
4336388e9c81SLen Brown 		}
4337388e9c81SLen Brown 		if (!strncmp(add_command, "raw", strlen("raw"))) {
4338388e9c81SLen Brown 			format = FORMAT_RAW;
4339388e9c81SLen Brown 			goto next;
4340388e9c81SLen Brown 		}
4341388e9c81SLen Brown 		if (!strncmp(add_command, "delta", strlen("delta"))) {
4342388e9c81SLen Brown 			format = FORMAT_DELTA;
4343388e9c81SLen Brown 			goto next;
4344388e9c81SLen Brown 		}
4345388e9c81SLen Brown 		if (!strncmp(add_command, "percent", strlen("percent"))) {
4346388e9c81SLen Brown 			format = FORMAT_PERCENT;
4347388e9c81SLen Brown 			goto next;
4348388e9c81SLen Brown 		}
4349388e9c81SLen Brown 
4350388e9c81SLen Brown 		if (sscanf(add_command, "%18s,%*s", name_buffer) == 1) {	/* 18 < NAME_BYTES */
4351388e9c81SLen Brown 			char *eos;
4352388e9c81SLen Brown 
4353388e9c81SLen Brown 			eos = strchr(name_buffer, ',');
4354388e9c81SLen Brown 			if (eos)
4355388e9c81SLen Brown 				*eos = '\0';
4356388e9c81SLen Brown 			goto next;
4357388e9c81SLen Brown 		}
4358388e9c81SLen Brown 
4359388e9c81SLen Brown next:
4360388e9c81SLen Brown 		add_command = strchr(add_command, ',');
4361388e9c81SLen Brown 		if (add_command)
4362388e9c81SLen Brown 			add_command++;
4363388e9c81SLen Brown 
4364388e9c81SLen Brown 	}
4365388e9c81SLen Brown 	if (msr_num == 0) {
4366388e9c81SLen Brown 		fprintf(stderr, "--add: (msrDDD | msr0xXXX) required\n");
4367388e9c81SLen Brown 		fail++;
4368388e9c81SLen Brown 	}
4369388e9c81SLen Brown 
4370388e9c81SLen Brown 	/* generate default column header */
4371388e9c81SLen Brown 	if (*name_buffer == '\0') {
4372388e9c81SLen Brown 		if (format == FORMAT_RAW) {
4373388e9c81SLen Brown 			if (width == 32)
4374388e9c81SLen Brown 				sprintf(name_buffer, "msr%d", msr_num);
4375388e9c81SLen Brown 			else
4376388e9c81SLen Brown 				sprintf(name_buffer, "MSR%d", msr_num);
4377388e9c81SLen Brown 		} else if (format == FORMAT_DELTA) {
4378388e9c81SLen Brown 			if (width == 32)
4379388e9c81SLen Brown 				sprintf(name_buffer, "cnt%d", msr_num);
4380388e9c81SLen Brown 			else
4381388e9c81SLen Brown 				sprintf(name_buffer, "CNT%d", msr_num);
4382388e9c81SLen Brown 		} else if (format == FORMAT_PERCENT) {
4383388e9c81SLen Brown 			if (width == 32)
4384388e9c81SLen Brown 				sprintf(name_buffer, "msr%d%%", msr_num);
4385388e9c81SLen Brown 			else
4386388e9c81SLen Brown 				sprintf(name_buffer, "MSR%d%%", msr_num);
4387388e9c81SLen Brown 		}
4388388e9c81SLen Brown 	}
4389388e9c81SLen Brown 
4390388e9c81SLen Brown 	if (add_counter(msr_num, name_buffer, width, scope, type, format))
4391388e9c81SLen Brown 		fail++;
4392388e9c81SLen Brown 
4393388e9c81SLen Brown 	if (fail) {
4394388e9c81SLen Brown 		help();
4395388e9c81SLen Brown 		exit(1);
4396388e9c81SLen Brown 	}
4397388e9c81SLen Brown }
4398812db3f7SLen Brown /*
4399812db3f7SLen Brown  * HIDE_LIST - hide this list of counters, show the rest [default]
4400812db3f7SLen Brown  * SHOW_LIST - show this list of counters, hide the rest
4401812db3f7SLen Brown  */
4402812db3f7SLen Brown enum show_hide_mode { SHOW_LIST, HIDE_LIST } global_show_hide_mode = HIDE_LIST;
4403812db3f7SLen Brown 
4404812db3f7SLen Brown int shown;
4405812db3f7SLen Brown /*
4406812db3f7SLen Brown  * parse_show_hide() - process cmdline to set default counter action
4407812db3f7SLen Brown  */
4408812db3f7SLen Brown void parse_show_hide(char *optarg, enum show_hide_mode new_mode)
4409812db3f7SLen Brown {
4410812db3f7SLen Brown 	/*
4411812db3f7SLen Brown 	 * --show: show only those specified
4412812db3f7SLen Brown 	 *  The 1st invocation will clear and replace the enabled mask
4413812db3f7SLen Brown 	 *  subsequent invocations can add to it.
4414812db3f7SLen Brown 	 */
4415812db3f7SLen Brown 	if (new_mode == SHOW_LIST) {
4416812db3f7SLen Brown 		if (shown == 0)
4417812db3f7SLen Brown 			bic_enabled = bic_lookup(optarg);
4418812db3f7SLen Brown 		else
4419812db3f7SLen Brown 			bic_enabled |= bic_lookup(optarg);
4420812db3f7SLen Brown 		shown = 1;
4421812db3f7SLen Brown 
4422812db3f7SLen Brown 		return;
4423812db3f7SLen Brown 	}
4424812db3f7SLen Brown 
4425812db3f7SLen Brown 	/*
4426812db3f7SLen Brown 	 * --hide: do not show those specified
4427812db3f7SLen Brown 	 *  multiple invocations simply clear more bits in enabled mask
4428812db3f7SLen Brown 	 */
4429812db3f7SLen Brown 	bic_enabled &= ~bic_lookup(optarg);
4430812db3f7SLen Brown }
4431812db3f7SLen Brown 
4432103a8feaSLen Brown void cmdline(int argc, char **argv)
4433103a8feaSLen Brown {
4434103a8feaSLen Brown 	int opt;
4435d8af6f5fSLen Brown 	int option_index = 0;
4436d8af6f5fSLen Brown 	static struct option long_options[] = {
4437388e9c81SLen Brown 		{"add",		required_argument,	0, 'a'},
4438d8af6f5fSLen Brown 		{"Dump",	no_argument,		0, 'D'},
4439d8af6f5fSLen Brown 		{"debug",	no_argument,		0, 'd'},
4440d8af6f5fSLen Brown 		{"interval",	required_argument,	0, 'i'},
4441d8af6f5fSLen Brown 		{"help",	no_argument,		0, 'h'},
4442812db3f7SLen Brown 		{"hide",	required_argument,	0, 'H'},	// meh, -h taken by --help
4443d8af6f5fSLen Brown 		{"Joules",	no_argument,		0, 'J'},
4444b7d8c148SLen Brown 		{"out",		required_argument,	0, 'o'},
4445d8af6f5fSLen Brown 		{"Package",	no_argument,		0, 'p'},
4446d8af6f5fSLen Brown 		{"processor",	no_argument,		0, 'p'},
4447812db3f7SLen Brown 		{"show",	required_argument,	0, 's'},
4448d8af6f5fSLen Brown 		{"Summary",	no_argument,		0, 'S'},
4449d8af6f5fSLen Brown 		{"TCC",		required_argument,	0, 'T'},
4450d8af6f5fSLen Brown 		{"version",	no_argument,		0, 'v' },
4451d8af6f5fSLen Brown 		{0,		0,			0,  0 }
4452d8af6f5fSLen Brown 	};
4453103a8feaSLen Brown 
4454103a8feaSLen Brown 	progname = argv[0];
4455103a8feaSLen Brown 
4456b7d8c148SLen Brown 	while ((opt = getopt_long_only(argc, argv, "+C:c:Ddhi:JM:m:o:PpST:v",
4457d8af6f5fSLen Brown 				long_options, &option_index)) != -1) {
4458103a8feaSLen Brown 		switch (opt) {
4459388e9c81SLen Brown 		case 'a':
4460388e9c81SLen Brown 			parse_add_command(optarg);
4461388e9c81SLen Brown 			break;
4462d8af6f5fSLen Brown 		case 'D':
4463d8af6f5fSLen Brown 			dump_only++;
44648e180f3cSLen Brown 			break;
4465d8af6f5fSLen Brown 		case 'd':
4466d8af6f5fSLen Brown 			debug++;
44672f32edf1SLen Brown 			break;
4468812db3f7SLen Brown 		case 'H':
4469812db3f7SLen Brown 			parse_show_hide(optarg, HIDE_LIST);
4470812db3f7SLen Brown 			break;
4471d8af6f5fSLen Brown 		case 'h':
4472d8af6f5fSLen Brown 		default:
4473d8af6f5fSLen Brown 			help();
4474d8af6f5fSLen Brown 			exit(1);
4475d8af6f5fSLen Brown 		case 'i':
44762a0609c0SLen Brown 			{
44772a0609c0SLen Brown 				double interval = strtod(optarg, NULL);
44782a0609c0SLen Brown 
44792a0609c0SLen Brown 				if (interval < 0.001) {
4480b7d8c148SLen Brown 					fprintf(outf, "interval %f seconds is too small\n",
44812a0609c0SLen Brown 						interval);
44822a0609c0SLen Brown 					exit(2);
44832a0609c0SLen Brown 				}
44842a0609c0SLen Brown 
44852a0609c0SLen Brown 				interval_ts.tv_sec = interval;
44862a0609c0SLen Brown 				interval_ts.tv_nsec = (interval - interval_ts.tv_sec) * 1000000000;
44872a0609c0SLen Brown 			}
4488889facbeSLen Brown 			break;
44895c56be9aSDirk Brandewie 		case 'J':
44905c56be9aSDirk Brandewie 			rapl_joules++;
44915c56be9aSDirk Brandewie 			break;
4492b7d8c148SLen Brown 		case 'o':
4493b7d8c148SLen Brown 			outf = fopen_or_die(optarg, "w");
4494b7d8c148SLen Brown 			break;
4495d8af6f5fSLen Brown 		case 'P':
4496d8af6f5fSLen Brown 			show_pkg_only++;
4497d8af6f5fSLen Brown 			break;
4498d8af6f5fSLen Brown 		case 'p':
4499d8af6f5fSLen Brown 			show_core_only++;
4500d8af6f5fSLen Brown 			break;
4501812db3f7SLen Brown 		case 's':
4502812db3f7SLen Brown 			parse_show_hide(optarg, SHOW_LIST);
4503812db3f7SLen Brown 			break;
4504d8af6f5fSLen Brown 		case 'S':
4505d8af6f5fSLen Brown 			summary_only++;
4506d8af6f5fSLen Brown 			break;
4507d8af6f5fSLen Brown 		case 'T':
4508d8af6f5fSLen Brown 			tcc_activation_temp_override = atoi(optarg);
4509d8af6f5fSLen Brown 			break;
4510d8af6f5fSLen Brown 		case 'v':
4511d8af6f5fSLen Brown 			print_version();
4512d8af6f5fSLen Brown 			exit(0);
4513d8af6f5fSLen Brown 			break;
4514103a8feaSLen Brown 		}
4515103a8feaSLen Brown 	}
4516103a8feaSLen Brown }
4517103a8feaSLen Brown 
4518103a8feaSLen Brown int main(int argc, char **argv)
4519103a8feaSLen Brown {
4520b7d8c148SLen Brown 	outf = stderr;
4521b7d8c148SLen Brown 
4522103a8feaSLen Brown 	cmdline(argc, argv);
4523103a8feaSLen Brown 
4524d8af6f5fSLen Brown 	if (debug)
4525d8af6f5fSLen Brown 		print_version();
4526103a8feaSLen Brown 
4527103a8feaSLen Brown 	turbostat_init();
4528103a8feaSLen Brown 
45293b4d5c7fSAndy Shevchenko 	/* dump counters and exit */
45303b4d5c7fSAndy Shevchenko 	if (dump_only)
45313b4d5c7fSAndy Shevchenko 		return get_and_dump_counters();
45323b4d5c7fSAndy Shevchenko 
4533103a8feaSLen Brown 	/*
4534103a8feaSLen Brown 	 * if any params left, it must be a command to fork
4535103a8feaSLen Brown 	 */
4536103a8feaSLen Brown 	if (argc - optind)
4537103a8feaSLen Brown 		return fork_it(argv + optind);
4538103a8feaSLen Brown 	else
4539103a8feaSLen Brown 		turbostat_loop();
4540103a8feaSLen Brown 
4541103a8feaSLen Brown 	return 0;
4542103a8feaSLen Brown }
4543