1/*
2 *  (C) 2010,2011       Thomas Renninger <trenn@suse.de>, Novell Inc.
3 *
4 *  Licensed under the terms of the GNU GPL License version 2.
5 *
6 *  Based on Len Brown's <lenb@kernel.org> turbostat tool.
7 */
8
9#if defined(__i386__) || defined(__x86_64__)
10
11#include <stdio.h>
12#include <stdint.h>
13#include <stdlib.h>
14#include <string.h>
15
16#include "helpers/helpers.h"
17#include "idle_monitor/cpupower-monitor.h"
18
19#define MSR_PKG_C3_RESIDENCY	0x3F8
20#define MSR_PKG_C6_RESIDENCY	0x3F9
21#define MSR_CORE_C3_RESIDENCY	0x3FC
22#define MSR_CORE_C6_RESIDENCY	0x3FD
23
24#define MSR_TSC	0x10
25
26#define NHM_CSTATE_COUNT 4
27
28enum intel_nhm_id { C3 = 0, C6, PC3, PC6, TSC = 0xFFFF };
29
30static int nhm_get_count_percent(unsigned int self_id, double *percent,
31				 unsigned int cpu);
32
33static cstate_t nhm_cstates[NHM_CSTATE_COUNT] = {
34	{
35		.name			= "C3",
36		.desc			= N_("Processor Core C3"),
37		.id			= C3,
38		.range			= RANGE_CORE,
39		.get_count_percent	= nhm_get_count_percent,
40	},
41	{
42		.name			= "C6",
43		.desc			= N_("Processor Core C6"),
44		.id			= C6,
45		.range			= RANGE_CORE,
46		.get_count_percent	= nhm_get_count_percent,
47	},
48
49	{
50		.name			= "PC3",
51		.desc			= N_("Processor Package C3"),
52		.id			= PC3,
53		.range			= RANGE_PACKAGE,
54		.get_count_percent	= nhm_get_count_percent,
55	},
56	{
57		.name			= "PC6",
58		.desc			= N_("Processor Package C6"),
59		.id			= PC6,
60		.range			= RANGE_PACKAGE,
61		.get_count_percent	= nhm_get_count_percent,
62	},
63};
64
65static unsigned long long tsc_at_measure_start;
66static unsigned long long tsc_at_measure_end;
67static unsigned long long *previous_count[NHM_CSTATE_COUNT];
68static unsigned long long *current_count[NHM_CSTATE_COUNT];
69/* valid flag for all CPUs. If a MSR read failed it will be zero */
70static int *is_valid;
71
72static int nhm_get_count(enum intel_nhm_id id, unsigned long long *val,
73			unsigned int cpu)
74{
75	int msr;
76
77	switch (id) {
78	case C3:
79		msr = MSR_CORE_C3_RESIDENCY;
80		break;
81	case C6:
82		msr = MSR_CORE_C6_RESIDENCY;
83		break;
84	case PC3:
85		msr = MSR_PKG_C3_RESIDENCY;
86		break;
87	case PC6:
88		msr = MSR_PKG_C6_RESIDENCY;
89		break;
90	case TSC:
91		msr = MSR_TSC;
92		break;
93	default:
94		return -1;
95	};
96	if (read_msr(cpu, msr, val))
97		return -1;
98
99	return 0;
100}
101
102static int nhm_get_count_percent(unsigned int id, double *percent,
103				 unsigned int cpu)
104{
105	*percent = 0.0;
106
107	if (!is_valid[cpu])
108		return -1;
109
110	*percent = (100.0 *
111		(current_count[id][cpu] - previous_count[id][cpu])) /
112		(tsc_at_measure_end - tsc_at_measure_start);
113
114	dprint("%s: previous: %llu - current: %llu - (%u)\n",
115		nhm_cstates[id].name, previous_count[id][cpu],
116		current_count[id][cpu], cpu);
117
118	dprint("%s: tsc_diff: %llu - count_diff: %llu - percent: %2.f (%u)\n",
119	       nhm_cstates[id].name,
120	       (unsigned long long) tsc_at_measure_end - tsc_at_measure_start,
121	       current_count[id][cpu] - previous_count[id][cpu],
122	       *percent, cpu);
123
124	return 0;
125}
126
127static int nhm_start(void)
128{
129	int num, cpu;
130	unsigned long long dbg, val;
131
132	nhm_get_count(TSC, &tsc_at_measure_start, 0);
133
134	for (num = 0; num < NHM_CSTATE_COUNT; num++) {
135		for (cpu = 0; cpu < cpu_count; cpu++) {
136			is_valid[cpu] = !nhm_get_count(num, &val, cpu);
137			previous_count[num][cpu] = val;
138		}
139	}
140	nhm_get_count(TSC, &dbg, 0);
141	dprint("TSC diff: %llu\n", dbg - tsc_at_measure_start);
142	return 0;
143}
144
145static int nhm_stop(void)
146{
147	unsigned long long val;
148	unsigned long long dbg;
149	int num, cpu;
150
151	nhm_get_count(TSC, &tsc_at_measure_end, 0);
152
153	for (num = 0; num < NHM_CSTATE_COUNT; num++) {
154		for (cpu = 0; cpu < cpu_count; cpu++) {
155			is_valid[cpu] = !nhm_get_count(num, &val, cpu);
156			current_count[num][cpu] = val;
157		}
158	}
159	nhm_get_count(TSC, &dbg, 0);
160	dprint("TSC diff: %llu\n", dbg - tsc_at_measure_end);
161
162	return 0;
163}
164
165struct cpuidle_monitor intel_nhm_monitor;
166
167struct cpuidle_monitor *intel_nhm_register(void)
168{
169	int num;
170
171	if (cpupower_cpu_info.vendor != X86_VENDOR_INTEL)
172		return NULL;
173
174	if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_INV_TSC))
175		return NULL;
176
177	if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_APERF))
178		return NULL;
179
180	/* Free this at program termination */
181	is_valid = calloc(cpu_count, sizeof(int));
182	for (num = 0; num < NHM_CSTATE_COUNT; num++) {
183		previous_count[num] = calloc(cpu_count,
184					sizeof(unsigned long long));
185		current_count[num]  = calloc(cpu_count,
186					sizeof(unsigned long long));
187	}
188
189	intel_nhm_monitor.name_len = strlen(intel_nhm_monitor.name);
190	return &intel_nhm_monitor;
191}
192
193void intel_nhm_unregister(void)
194{
195	int num;
196
197	for (num = 0; num < NHM_CSTATE_COUNT; num++) {
198		free(previous_count[num]);
199		free(current_count[num]);
200	}
201	free(is_valid);
202}
203
204struct cpuidle_monitor intel_nhm_monitor = {
205	.name			= "Nehalem",
206	.hw_states_num		= NHM_CSTATE_COUNT,
207	.hw_states		= nhm_cstates,
208	.start			= nhm_start,
209	.stop			= nhm_stop,
210	.do_register		= intel_nhm_register,
211	.unregister		= intel_nhm_unregister,
212	.needs_root		= 1,
213	.overflow_s		= 922000000 /* 922337203 seconds TSC overflow
214					       at 20GHz */
215};
216#endif
217