1 /* 2 * Based on documentation provided by Dave Jones. Thanks! 3 * 4 * Licensed under the terms of the GNU GPL License version 2. 5 * 6 * BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous* 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/init.h> 14 #include <linux/cpufreq.h> 15 #include <linux/ioport.h> 16 #include <linux/slab.h> 17 #include <linux/timex.h> 18 #include <linux/io.h> 19 #include <linux/delay.h> 20 21 #include <asm/cpu_device_id.h> 22 #include <asm/msr.h> 23 #include <asm/tsc.h> 24 25 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR) 26 #include <linux/acpi.h> 27 #include <acpi/processor.h> 28 #endif 29 30 #define EPS_BRAND_C7M 0 31 #define EPS_BRAND_C7 1 32 #define EPS_BRAND_EDEN 2 33 #define EPS_BRAND_C3 3 34 #define EPS_BRAND_C7D 4 35 36 struct eps_cpu_data { 37 u32 fsb; 38 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR) 39 u32 bios_limit; 40 #endif 41 struct cpufreq_frequency_table freq_table[]; 42 }; 43 44 static struct eps_cpu_data *eps_cpu[NR_CPUS]; 45 46 /* Module parameters */ 47 static int freq_failsafe_off; 48 static int voltage_failsafe_off; 49 static int set_max_voltage; 50 51 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR) 52 static int ignore_acpi_limit; 53 54 static struct acpi_processor_performance *eps_acpi_cpu_perf; 55 56 /* Minimum necessary to get acpi_processor_get_bios_limit() working */ 57 static int eps_acpi_init(void) 58 { 59 eps_acpi_cpu_perf = kzalloc(sizeof(*eps_acpi_cpu_perf), 60 GFP_KERNEL); 61 if (!eps_acpi_cpu_perf) 62 return -ENOMEM; 63 64 if (!zalloc_cpumask_var(&eps_acpi_cpu_perf->shared_cpu_map, 65 GFP_KERNEL)) { 66 kfree(eps_acpi_cpu_perf); 67 eps_acpi_cpu_perf = NULL; 68 return -ENOMEM; 69 } 70 71 if (acpi_processor_register_performance(eps_acpi_cpu_perf, 0)) { 72 free_cpumask_var(eps_acpi_cpu_perf->shared_cpu_map); 73 kfree(eps_acpi_cpu_perf); 74 eps_acpi_cpu_perf = NULL; 75 return -EIO; 76 } 77 return 0; 78 } 79 80 static int eps_acpi_exit(struct cpufreq_policy *policy) 81 { 82 if (eps_acpi_cpu_perf) { 83 acpi_processor_unregister_performance(0); 84 free_cpumask_var(eps_acpi_cpu_perf->shared_cpu_map); 85 kfree(eps_acpi_cpu_perf); 86 eps_acpi_cpu_perf = NULL; 87 } 88 return 0; 89 } 90 #endif 91 92 static unsigned int eps_get(unsigned int cpu) 93 { 94 struct eps_cpu_data *centaur; 95 u32 lo, hi; 96 97 if (cpu) 98 return 0; 99 centaur = eps_cpu[cpu]; 100 if (centaur == NULL) 101 return 0; 102 103 /* Return current frequency */ 104 rdmsr(MSR_IA32_PERF_STATUS, lo, hi); 105 return centaur->fsb * ((lo >> 8) & 0xff); 106 } 107 108 static int eps_set_state(struct eps_cpu_data *centaur, 109 struct cpufreq_policy *policy, 110 u32 dest_state) 111 { 112 u32 lo, hi; 113 int i; 114 115 /* Wait while CPU is busy */ 116 rdmsr(MSR_IA32_PERF_STATUS, lo, hi); 117 i = 0; 118 while (lo & ((1 << 16) | (1 << 17))) { 119 udelay(16); 120 rdmsr(MSR_IA32_PERF_STATUS, lo, hi); 121 i++; 122 if (unlikely(i > 64)) { 123 return -ENODEV; 124 } 125 } 126 /* Set new multiplier and voltage */ 127 wrmsr(MSR_IA32_PERF_CTL, dest_state & 0xffff, 0); 128 /* Wait until transition end */ 129 i = 0; 130 do { 131 udelay(16); 132 rdmsr(MSR_IA32_PERF_STATUS, lo, hi); 133 i++; 134 if (unlikely(i > 64)) { 135 return -ENODEV; 136 } 137 } while (lo & ((1 << 16) | (1 << 17))); 138 139 #ifdef DEBUG 140 { 141 u8 current_multiplier, current_voltage; 142 143 /* Print voltage and multiplier */ 144 rdmsr(MSR_IA32_PERF_STATUS, lo, hi); 145 current_voltage = lo & 0xff; 146 pr_info("Current voltage = %dmV\n", current_voltage * 16 + 700); 147 current_multiplier = (lo >> 8) & 0xff; 148 pr_info("Current multiplier = %d\n", current_multiplier); 149 } 150 #endif 151 return 0; 152 } 153 154 static int eps_target(struct cpufreq_policy *policy, unsigned int index) 155 { 156 struct eps_cpu_data *centaur; 157 unsigned int cpu = policy->cpu; 158 unsigned int dest_state; 159 int ret; 160 161 if (unlikely(eps_cpu[cpu] == NULL)) 162 return -ENODEV; 163 centaur = eps_cpu[cpu]; 164 165 /* Make frequency transition */ 166 dest_state = centaur->freq_table[index].driver_data & 0xffff; 167 ret = eps_set_state(centaur, policy, dest_state); 168 if (ret) 169 pr_err("Timeout!\n"); 170 return ret; 171 } 172 173 static int eps_cpu_init(struct cpufreq_policy *policy) 174 { 175 unsigned int i; 176 u32 lo, hi; 177 u64 val; 178 u8 current_multiplier, current_voltage; 179 u8 max_multiplier, max_voltage; 180 u8 min_multiplier, min_voltage; 181 u8 brand = 0; 182 u32 fsb; 183 struct eps_cpu_data *centaur; 184 struct cpuinfo_x86 *c = &cpu_data(0); 185 struct cpufreq_frequency_table *f_table; 186 int k, step, voltage; 187 int ret; 188 int states; 189 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR) 190 unsigned int limit; 191 #endif 192 193 if (policy->cpu != 0) 194 return -ENODEV; 195 196 /* Check brand */ 197 pr_info("Detected VIA "); 198 199 switch (c->x86_model) { 200 case 10: 201 rdmsr(0x1153, lo, hi); 202 brand = (((lo >> 2) ^ lo) >> 18) & 3; 203 pr_cont("Model A "); 204 break; 205 case 13: 206 rdmsr(0x1154, lo, hi); 207 brand = (((lo >> 4) ^ (lo >> 2))) & 0x000000ff; 208 pr_cont("Model D "); 209 break; 210 } 211 212 switch (brand) { 213 case EPS_BRAND_C7M: 214 pr_cont("C7-M\n"); 215 break; 216 case EPS_BRAND_C7: 217 pr_cont("C7\n"); 218 break; 219 case EPS_BRAND_EDEN: 220 pr_cont("Eden\n"); 221 break; 222 case EPS_BRAND_C7D: 223 pr_cont("C7-D\n"); 224 break; 225 case EPS_BRAND_C3: 226 pr_cont("C3\n"); 227 return -ENODEV; 228 break; 229 } 230 /* Enable Enhanced PowerSaver */ 231 rdmsrl(MSR_IA32_MISC_ENABLE, val); 232 if (!(val & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) { 233 val |= MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP; 234 wrmsrl(MSR_IA32_MISC_ENABLE, val); 235 /* Can be locked at 0 */ 236 rdmsrl(MSR_IA32_MISC_ENABLE, val); 237 if (!(val & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) { 238 pr_info("Can't enable Enhanced PowerSaver\n"); 239 return -ENODEV; 240 } 241 } 242 243 /* Print voltage and multiplier */ 244 rdmsr(MSR_IA32_PERF_STATUS, lo, hi); 245 current_voltage = lo & 0xff; 246 pr_info("Current voltage = %dmV\n", current_voltage * 16 + 700); 247 current_multiplier = (lo >> 8) & 0xff; 248 pr_info("Current multiplier = %d\n", current_multiplier); 249 250 /* Print limits */ 251 max_voltage = hi & 0xff; 252 pr_info("Highest voltage = %dmV\n", max_voltage * 16 + 700); 253 max_multiplier = (hi >> 8) & 0xff; 254 pr_info("Highest multiplier = %d\n", max_multiplier); 255 min_voltage = (hi >> 16) & 0xff; 256 pr_info("Lowest voltage = %dmV\n", min_voltage * 16 + 700); 257 min_multiplier = (hi >> 24) & 0xff; 258 pr_info("Lowest multiplier = %d\n", min_multiplier); 259 260 /* Sanity checks */ 261 if (current_multiplier == 0 || max_multiplier == 0 262 || min_multiplier == 0) 263 return -EINVAL; 264 if (current_multiplier > max_multiplier 265 || max_multiplier <= min_multiplier) 266 return -EINVAL; 267 if (current_voltage > 0x1f || max_voltage > 0x1f) 268 return -EINVAL; 269 if (max_voltage < min_voltage 270 || current_voltage < min_voltage 271 || current_voltage > max_voltage) 272 return -EINVAL; 273 274 /* Check for systems using underclocked CPU */ 275 if (!freq_failsafe_off && max_multiplier != current_multiplier) { 276 pr_info("Your processor is running at different frequency then its maximum. Aborting.\n"); 277 pr_info("You can use freq_failsafe_off option to disable this check.\n"); 278 return -EINVAL; 279 } 280 if (!voltage_failsafe_off && max_voltage != current_voltage) { 281 pr_info("Your processor is running at different voltage then its maximum. Aborting.\n"); 282 pr_info("You can use voltage_failsafe_off option to disable this check.\n"); 283 return -EINVAL; 284 } 285 286 /* Calc FSB speed */ 287 fsb = cpu_khz / current_multiplier; 288 289 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR) 290 /* Check for ACPI processor speed limit */ 291 if (!ignore_acpi_limit && !eps_acpi_init()) { 292 if (!acpi_processor_get_bios_limit(policy->cpu, &limit)) { 293 pr_info("ACPI limit %u.%uGHz\n", 294 limit/1000000, 295 (limit%1000000)/10000); 296 eps_acpi_exit(policy); 297 /* Check if max_multiplier is in BIOS limits */ 298 if (limit && max_multiplier * fsb > limit) { 299 pr_info("Aborting\n"); 300 return -EINVAL; 301 } 302 } 303 } 304 #endif 305 306 /* Allow user to set lower maximum voltage then that reported 307 * by processor */ 308 if (brand == EPS_BRAND_C7M && set_max_voltage) { 309 u32 v; 310 311 /* Change mV to something hardware can use */ 312 v = (set_max_voltage - 700) / 16; 313 /* Check if voltage is within limits */ 314 if (v >= min_voltage && v <= max_voltage) { 315 pr_info("Setting %dmV as maximum\n", v * 16 + 700); 316 max_voltage = v; 317 } 318 } 319 320 /* Calc number of p-states supported */ 321 if (brand == EPS_BRAND_C7M) 322 states = max_multiplier - min_multiplier + 1; 323 else 324 states = 2; 325 326 /* Allocate private data and frequency table for current cpu */ 327 centaur = kzalloc(sizeof(*centaur) 328 + (states + 1) * sizeof(struct cpufreq_frequency_table), 329 GFP_KERNEL); 330 if (!centaur) 331 return -ENOMEM; 332 eps_cpu[0] = centaur; 333 334 /* Copy basic values */ 335 centaur->fsb = fsb; 336 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR) 337 centaur->bios_limit = limit; 338 #endif 339 340 /* Fill frequency and MSR value table */ 341 f_table = ¢aur->freq_table[0]; 342 if (brand != EPS_BRAND_C7M) { 343 f_table[0].frequency = fsb * min_multiplier; 344 f_table[0].driver_data = (min_multiplier << 8) | min_voltage; 345 f_table[1].frequency = fsb * max_multiplier; 346 f_table[1].driver_data = (max_multiplier << 8) | max_voltage; 347 f_table[2].frequency = CPUFREQ_TABLE_END; 348 } else { 349 k = 0; 350 step = ((max_voltage - min_voltage) * 256) 351 / (max_multiplier - min_multiplier); 352 for (i = min_multiplier; i <= max_multiplier; i++) { 353 voltage = (k * step) / 256 + min_voltage; 354 f_table[k].frequency = fsb * i; 355 f_table[k].driver_data = (i << 8) | voltage; 356 k++; 357 } 358 f_table[k].frequency = CPUFREQ_TABLE_END; 359 } 360 361 policy->cpuinfo.transition_latency = 140000; /* 844mV -> 700mV in ns */ 362 363 ret = cpufreq_table_validate_and_show(policy, ¢aur->freq_table[0]); 364 if (ret) { 365 kfree(centaur); 366 return ret; 367 } 368 369 return 0; 370 } 371 372 static int eps_cpu_exit(struct cpufreq_policy *policy) 373 { 374 unsigned int cpu = policy->cpu; 375 376 /* Bye */ 377 kfree(eps_cpu[cpu]); 378 eps_cpu[cpu] = NULL; 379 return 0; 380 } 381 382 static struct cpufreq_driver eps_driver = { 383 .verify = cpufreq_generic_frequency_table_verify, 384 .target_index = eps_target, 385 .init = eps_cpu_init, 386 .exit = eps_cpu_exit, 387 .get = eps_get, 388 .name = "e_powersaver", 389 .attr = cpufreq_generic_attr, 390 }; 391 392 393 /* This driver will work only on Centaur C7 processors with 394 * Enhanced SpeedStep/PowerSaver registers */ 395 static const struct x86_cpu_id eps_cpu_id[] = { 396 { X86_VENDOR_CENTAUR, 6, X86_MODEL_ANY, X86_FEATURE_EST }, 397 {} 398 }; 399 MODULE_DEVICE_TABLE(x86cpu, eps_cpu_id); 400 401 static int __init eps_init(void) 402 { 403 if (!x86_match_cpu(eps_cpu_id) || boot_cpu_data.x86_model < 10) 404 return -ENODEV; 405 if (cpufreq_register_driver(&eps_driver)) 406 return -EINVAL; 407 return 0; 408 } 409 410 static void __exit eps_exit(void) 411 { 412 cpufreq_unregister_driver(&eps_driver); 413 } 414 415 /* Allow user to overclock his machine or to change frequency to higher after 416 * unloading module */ 417 module_param(freq_failsafe_off, int, 0644); 418 MODULE_PARM_DESC(freq_failsafe_off, "Disable current vs max frequency check"); 419 module_param(voltage_failsafe_off, int, 0644); 420 MODULE_PARM_DESC(voltage_failsafe_off, "Disable current vs max voltage check"); 421 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR) 422 module_param(ignore_acpi_limit, int, 0644); 423 MODULE_PARM_DESC(ignore_acpi_limit, "Don't check ACPI's processor speed limit"); 424 #endif 425 module_param(set_max_voltage, int, 0644); 426 MODULE_PARM_DESC(set_max_voltage, "Set maximum CPU voltage (mV) C7-M only"); 427 428 MODULE_AUTHOR("Rafal Bilski <rafalbilski@interia.pl>"); 429 MODULE_DESCRIPTION("Enhanced PowerSaver driver for VIA C7 CPU's."); 430 MODULE_LICENSE("GPL"); 431 432 module_init(eps_init); 433 module_exit(eps_exit); 434