1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24 /*
25 * Copyright (c) 2009, Intel Corporation.
26 * All Rights Reserved.
27 */
28
29 #include <sys/x86_archext.h>
30 #include <sys/machsystm.h>
31 #include <sys/archsystm.h>
32 #include <sys/x_call.h>
33 #include <acpica/include/acpi.h>
34 #include <sys/acpica.h>
35 #include <sys/speedstep.h>
36 #include <sys/cpu_acpi.h>
37 #include <sys/cpupm.h>
38 #include <sys/dtrace.h>
39 #include <sys/sdt.h>
40
41 typedef struct turbo_kstat_s {
42 struct kstat_named turbo_supported; /* turbo flag */
43 struct kstat_named t_mcnt; /* IA32_MPERF_MSR */
44 struct kstat_named t_acnt; /* IA32_APERF_MSR */
45 } turbo_kstat_t;
46
47 static int turbo_kstat_update(kstat_t *, int);
48 static void get_turbo_info(cpupm_mach_turbo_info_t *);
49 static void reset_turbo_info(void);
50 static void record_turbo_info(cpupm_mach_turbo_info_t *, uint32_t, uint32_t);
51 static void update_turbo_info(cpupm_mach_turbo_info_t *);
52
53 static kmutex_t turbo_mutex;
54
55 turbo_kstat_t turbo_kstat = {
56 { "turbo_supported", KSTAT_DATA_UINT32 },
57 { "turbo_mcnt", KSTAT_DATA_UINT64 },
58 { "turbo_acnt", KSTAT_DATA_UINT64 },
59 };
60
61 #define CPU_ACPI_P0 0
62 #define CPU_IN_TURBO 1
63
64 /*
65 * MSR for hardware coordination feedback mechanism
66 * - IA32_MPERF: increments in proportion to a fixed frequency
67 * - IA32_APERF: increments in proportion to actual performance
68 */
69 #define IA32_MPERF_MSR 0xE7
70 #define IA32_APERF_MSR 0xE8
71
72 /*
73 * kstat update function of the turbo mode info
74 */
75 static int
76 turbo_kstat_update(kstat_t *ksp, int flag)
77 {
78 cpupm_mach_turbo_info_t *turbo_info = ksp->ks_private;
79
80 if (flag == KSTAT_WRITE) {
81 return (EACCES);
82 }
83
84 /*
85 * update the count in case CPU is in the turbo
86 * mode for a long time
87 */
88 if (turbo_info->in_turbo == CPU_IN_TURBO)
89 update_turbo_info(turbo_info);
90
91 turbo_kstat.turbo_supported.value.ui32 =
92 turbo_info->turbo_supported;
93 turbo_kstat.t_mcnt.value.ui64 = turbo_info->t_mcnt;
94 turbo_kstat.t_acnt.value.ui64 = turbo_info->t_acnt;
95
96 return (0);
97 }
98
99 /*
100 * update the sum of counts and clear MSRs
101 */
102 static void
103 update_turbo_info(cpupm_mach_turbo_info_t *turbo_info)
104 {
105 ulong_t iflag;
106 uint64_t mcnt, acnt;
107
108 iflag = intr_clear();
109 mcnt = rdmsr(IA32_MPERF_MSR);
110 acnt = rdmsr(IA32_APERF_MSR);
111 wrmsr(IA32_MPERF_MSR, 0);
112 wrmsr(IA32_APERF_MSR, 0);
113 turbo_info->t_mcnt += mcnt;
114 turbo_info->t_acnt += acnt;
115 intr_restore(iflag);
116 }
117
118 /*
119 * Get count of MPERF/APERF MSR
120 */
121 static void
122 get_turbo_info(cpupm_mach_turbo_info_t *turbo_info)
123 {
124 ulong_t iflag;
125 uint64_t mcnt, acnt;
126
127 iflag = intr_clear();
128 mcnt = rdmsr(IA32_MPERF_MSR);
129 acnt = rdmsr(IA32_APERF_MSR);
130 turbo_info->t_mcnt += mcnt;
131 turbo_info->t_acnt += acnt;
132 intr_restore(iflag);
133 }
134
135 /*
136 * Clear MPERF/APERF MSR
137 */
138 static void
139 reset_turbo_info(void)
140 {
141 ulong_t iflag;
142
143 iflag = intr_clear();
144 wrmsr(IA32_MPERF_MSR, 0);
145 wrmsr(IA32_APERF_MSR, 0);
146 intr_restore(iflag);
147 }
148
149 /*
150 * sum up the count of one CPU_ACPI_P0 transition
151 */
152 void
153 cpupm_record_turbo_info(cpupm_mach_turbo_info_t *turbo_info,
154 uint32_t cur_state, uint32_t req_state)
155 {
156 if (!turbo_info->turbo_supported)
157 return;
158 /*
159 * enter P0 state
160 */
161 if (req_state == CPU_ACPI_P0) {
162 reset_turbo_info();
163 turbo_info->in_turbo = CPU_IN_TURBO;
164 }
165 /*
166 * Leave P0 state
167 */
168 else if (cur_state == CPU_ACPI_P0) {
169 turbo_info->in_turbo = 0;
170 get_turbo_info(turbo_info);
171 }
172 }
173
174 cpupm_mach_turbo_info_t *
175 cpupm_turbo_init(cpu_t *cp)
176 {
177 cpupm_mach_turbo_info_t *turbo_info;
178
179 turbo_info = kmem_zalloc(sizeof (cpupm_mach_turbo_info_t), KM_SLEEP);
180
181 turbo_info->turbo_supported = 1;
182 turbo_info->turbo_ksp = kstat_create("turbo", cp->cpu_id,
183 "turbo", "misc", KSTAT_TYPE_NAMED,
184 sizeof (turbo_kstat) / sizeof (kstat_named_t),
185 KSTAT_FLAG_VIRTUAL);
186
187 if (turbo_info->turbo_ksp == NULL) {
188 cmn_err(CE_NOTE, "kstat_create(turbo) fail");
189 } else {
190 turbo_info->turbo_ksp->ks_data = &turbo_kstat;
191 turbo_info->turbo_ksp->ks_lock = &turbo_mutex;
192 turbo_info->turbo_ksp->ks_update = turbo_kstat_update;
193 turbo_info->turbo_ksp->ks_data_size += MAXNAMELEN;
194 turbo_info->turbo_ksp->ks_private = turbo_info;
195
196 kstat_install(turbo_info->turbo_ksp);
197 }
198
199 return (turbo_info);
200 }
201
202 void
203 cpupm_turbo_fini(cpupm_mach_turbo_info_t *turbo_info)
204 {
205 if (turbo_info->turbo_ksp != NULL)
206 kstat_delete(turbo_info->turbo_ksp);
207 kmem_free(turbo_info, sizeof (cpupm_mach_turbo_info_t));
208 }