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 <sys/acpi/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 } 209