1 /* 2 * Intel SpeedStep SMI driver. 3 * 4 * (C) 2003 Hiroshi Miura <miura@da-cha.org> 5 * 6 * Licensed under the terms of the GNU GPL License version 2. 7 * 8 */ 9 10 11 /********************************************************************* 12 * SPEEDSTEP - DEFINITIONS * 13 *********************************************************************/ 14 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/moduleparam.h> 18 #include <linux/init.h> 19 #include <linux/cpufreq.h> 20 #include <linux/delay.h> 21 #include <linux/io.h> 22 #include <asm/ist.h> 23 #include <asm/cpu_device_id.h> 24 25 #include "speedstep-lib.h" 26 27 /* speedstep system management interface port/command. 28 * 29 * These parameters are got from IST-SMI BIOS call. 30 * If user gives it, these are used. 31 * 32 */ 33 static int smi_port; 34 static int smi_cmd; 35 static unsigned int smi_sig; 36 37 /* info about the processor */ 38 static enum speedstep_processor speedstep_processor; 39 40 /* 41 * There are only two frequency states for each processor. Values 42 * are in kHz for the time being. 43 */ 44 static struct cpufreq_frequency_table speedstep_freqs[] = { 45 {SPEEDSTEP_HIGH, 0}, 46 {SPEEDSTEP_LOW, 0}, 47 {0, CPUFREQ_TABLE_END}, 48 }; 49 50 #define GET_SPEEDSTEP_OWNER 0 51 #define GET_SPEEDSTEP_STATE 1 52 #define SET_SPEEDSTEP_STATE 2 53 #define GET_SPEEDSTEP_FREQS 4 54 55 /* how often shall the SMI call be tried if it failed, e.g. because 56 * of DMA activity going on? */ 57 #define SMI_TRIES 5 58 59 /** 60 * speedstep_smi_ownership 61 */ 62 static int speedstep_smi_ownership(void) 63 { 64 u32 command, result, magic, dummy; 65 u32 function = GET_SPEEDSTEP_OWNER; 66 unsigned char magic_data[] = "Copyright (c) 1999 Intel Corporation"; 67 68 command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff); 69 magic = virt_to_phys(magic_data); 70 71 pr_debug("trying to obtain ownership with command %x at port %x\n", 72 command, smi_port); 73 74 __asm__ __volatile__( 75 "push %%ebp\n" 76 "out %%al, (%%dx)\n" 77 "pop %%ebp\n" 78 : "=D" (result), 79 "=a" (dummy), "=b" (dummy), "=c" (dummy), "=d" (dummy), 80 "=S" (dummy) 81 : "a" (command), "b" (function), "c" (0), "d" (smi_port), 82 "D" (0), "S" (magic) 83 : "memory" 84 ); 85 86 pr_debug("result is %x\n", result); 87 88 return result; 89 } 90 91 /** 92 * speedstep_smi_get_freqs - get SpeedStep preferred & current freq. 93 * @low: the low frequency value is placed here 94 * @high: the high frequency value is placed here 95 * 96 * Only available on later SpeedStep-enabled systems, returns false results or 97 * even hangs [cf. bugme.osdl.org # 1422] on earlier systems. Empirical testing 98 * shows that the latter occurs if !(ist_info.event & 0xFFFF). 99 */ 100 static int speedstep_smi_get_freqs(unsigned int *low, unsigned int *high) 101 { 102 u32 command, result = 0, edi, high_mhz, low_mhz, dummy; 103 u32 state = 0; 104 u32 function = GET_SPEEDSTEP_FREQS; 105 106 if (!(ist_info.event & 0xFFFF)) { 107 pr_debug("bug #1422 -- can't read freqs from BIOS\n"); 108 return -ENODEV; 109 } 110 111 command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff); 112 113 pr_debug("trying to determine frequencies with command %x at port %x\n", 114 command, smi_port); 115 116 __asm__ __volatile__( 117 "push %%ebp\n" 118 "out %%al, (%%dx)\n" 119 "pop %%ebp" 120 : "=a" (result), 121 "=b" (high_mhz), 122 "=c" (low_mhz), 123 "=d" (state), "=D" (edi), "=S" (dummy) 124 : "a" (command), 125 "b" (function), 126 "c" (state), 127 "d" (smi_port), "S" (0), "D" (0) 128 ); 129 130 pr_debug("result %x, low_freq %u, high_freq %u\n", 131 result, low_mhz, high_mhz); 132 133 /* abort if results are obviously incorrect... */ 134 if ((high_mhz + low_mhz) < 600) 135 return -EINVAL; 136 137 *high = high_mhz * 1000; 138 *low = low_mhz * 1000; 139 140 return result; 141 } 142 143 /** 144 * speedstep_get_state - set the SpeedStep state 145 * @state: processor frequency state (SPEEDSTEP_LOW or SPEEDSTEP_HIGH) 146 * 147 */ 148 static int speedstep_get_state(void) 149 { 150 u32 function = GET_SPEEDSTEP_STATE; 151 u32 result, state, edi, command, dummy; 152 153 command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff); 154 155 pr_debug("trying to determine current setting with command %x " 156 "at port %x\n", command, smi_port); 157 158 __asm__ __volatile__( 159 "push %%ebp\n" 160 "out %%al, (%%dx)\n" 161 "pop %%ebp\n" 162 : "=a" (result), 163 "=b" (state), "=D" (edi), 164 "=c" (dummy), "=d" (dummy), "=S" (dummy) 165 : "a" (command), "b" (function), "c" (0), 166 "d" (smi_port), "S" (0), "D" (0) 167 ); 168 169 pr_debug("state is %x, result is %x\n", state, result); 170 171 return state & 1; 172 } 173 174 175 /** 176 * speedstep_set_state - set the SpeedStep state 177 * @state: new processor frequency state (SPEEDSTEP_LOW or SPEEDSTEP_HIGH) 178 * 179 */ 180 static void speedstep_set_state(unsigned int state) 181 { 182 unsigned int result = 0, command, new_state, dummy; 183 unsigned long flags; 184 unsigned int function = SET_SPEEDSTEP_STATE; 185 unsigned int retry = 0; 186 187 if (state > 0x1) 188 return; 189 190 /* Disable IRQs */ 191 local_irq_save(flags); 192 193 command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff); 194 195 pr_debug("trying to set frequency to state %u " 196 "with command %x at port %x\n", 197 state, command, smi_port); 198 199 do { 200 if (retry) { 201 pr_debug("retry %u, previous result %u, waiting...\n", 202 retry, result); 203 mdelay(retry * 50); 204 } 205 retry++; 206 __asm__ __volatile__( 207 "push %%ebp\n" 208 "out %%al, (%%dx)\n" 209 "pop %%ebp" 210 : "=b" (new_state), "=D" (result), 211 "=c" (dummy), "=a" (dummy), 212 "=d" (dummy), "=S" (dummy) 213 : "a" (command), "b" (function), "c" (state), 214 "d" (smi_port), "S" (0), "D" (0) 215 ); 216 } while ((new_state != state) && (retry <= SMI_TRIES)); 217 218 /* enable IRQs */ 219 local_irq_restore(flags); 220 221 if (new_state == state) 222 pr_debug("change to %u MHz succeeded after %u tries " 223 "with result %u\n", 224 (speedstep_freqs[new_state].frequency / 1000), 225 retry, result); 226 else 227 printk(KERN_ERR "cpufreq: change to state %u " 228 "failed with new_state %u and result %u\n", 229 state, new_state, result); 230 231 return; 232 } 233 234 235 /** 236 * speedstep_target - set a new CPUFreq policy 237 * @policy: new policy 238 * @target_freq: new freq 239 * @relation: 240 * 241 * Sets a new CPUFreq policy/freq. 242 */ 243 static int speedstep_target(struct cpufreq_policy *policy, 244 unsigned int target_freq, unsigned int relation) 245 { 246 unsigned int newstate = 0; 247 struct cpufreq_freqs freqs; 248 249 if (cpufreq_frequency_table_target(policy, &speedstep_freqs[0], 250 target_freq, relation, &newstate)) 251 return -EINVAL; 252 253 freqs.old = speedstep_freqs[speedstep_get_state()].frequency; 254 freqs.new = speedstep_freqs[newstate].frequency; 255 freqs.cpu = 0; /* speedstep.c is UP only driver */ 256 257 if (freqs.old == freqs.new) 258 return 0; 259 260 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); 261 speedstep_set_state(newstate); 262 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE); 263 264 return 0; 265 } 266 267 268 /** 269 * speedstep_verify - verifies a new CPUFreq policy 270 * @policy: new policy 271 * 272 * Limit must be within speedstep_low_freq and speedstep_high_freq, with 273 * at least one border included. 274 */ 275 static int speedstep_verify(struct cpufreq_policy *policy) 276 { 277 return cpufreq_frequency_table_verify(policy, &speedstep_freqs[0]); 278 } 279 280 281 static int speedstep_cpu_init(struct cpufreq_policy *policy) 282 { 283 int result; 284 unsigned int speed, state; 285 unsigned int *low, *high; 286 287 /* capability check */ 288 if (policy->cpu != 0) 289 return -ENODEV; 290 291 result = speedstep_smi_ownership(); 292 if (result) { 293 pr_debug("fails in acquiring ownership of a SMI interface.\n"); 294 return -EINVAL; 295 } 296 297 /* detect low and high frequency */ 298 low = &speedstep_freqs[SPEEDSTEP_LOW].frequency; 299 high = &speedstep_freqs[SPEEDSTEP_HIGH].frequency; 300 301 result = speedstep_smi_get_freqs(low, high); 302 if (result) { 303 /* fall back to speedstep_lib.c dection mechanism: 304 * try both states out */ 305 pr_debug("could not detect low and high frequencies " 306 "by SMI call.\n"); 307 result = speedstep_get_freqs(speedstep_processor, 308 low, high, 309 NULL, 310 &speedstep_set_state); 311 312 if (result) { 313 pr_debug("could not detect two different speeds" 314 " -- aborting.\n"); 315 return result; 316 } else 317 pr_debug("workaround worked.\n"); 318 } 319 320 /* get current speed setting */ 321 state = speedstep_get_state(); 322 speed = speedstep_freqs[state].frequency; 323 324 pr_debug("currently at %s speed setting - %i MHz\n", 325 (speed == speedstep_freqs[SPEEDSTEP_LOW].frequency) 326 ? "low" : "high", 327 (speed / 1000)); 328 329 /* cpuinfo and default policy values */ 330 policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; 331 policy->cur = speed; 332 333 result = cpufreq_frequency_table_cpuinfo(policy, speedstep_freqs); 334 if (result) 335 return result; 336 337 cpufreq_frequency_table_get_attr(speedstep_freqs, policy->cpu); 338 339 return 0; 340 } 341 342 static int speedstep_cpu_exit(struct cpufreq_policy *policy) 343 { 344 cpufreq_frequency_table_put_attr(policy->cpu); 345 return 0; 346 } 347 348 static unsigned int speedstep_get(unsigned int cpu) 349 { 350 if (cpu) 351 return -ENODEV; 352 return speedstep_get_frequency(speedstep_processor); 353 } 354 355 356 static int speedstep_resume(struct cpufreq_policy *policy) 357 { 358 int result = speedstep_smi_ownership(); 359 360 if (result) 361 pr_debug("fails in re-acquiring ownership of a SMI interface.\n"); 362 363 return result; 364 } 365 366 static struct freq_attr *speedstep_attr[] = { 367 &cpufreq_freq_attr_scaling_available_freqs, 368 NULL, 369 }; 370 371 static struct cpufreq_driver speedstep_driver = { 372 .name = "speedstep-smi", 373 .verify = speedstep_verify, 374 .target = speedstep_target, 375 .init = speedstep_cpu_init, 376 .exit = speedstep_cpu_exit, 377 .get = speedstep_get, 378 .resume = speedstep_resume, 379 .owner = THIS_MODULE, 380 .attr = speedstep_attr, 381 }; 382 383 static const struct x86_cpu_id ss_smi_ids[] = { 384 { X86_VENDOR_INTEL, 6, 0xb, }, 385 { X86_VENDOR_INTEL, 6, 0x8, }, 386 { X86_VENDOR_INTEL, 15, 2 }, 387 {} 388 }; 389 #if 0 390 /* Not auto loaded currently */ 391 MODULE_DEVICE_TABLE(x86cpu, ss_smi_ids); 392 #endif 393 394 /** 395 * speedstep_init - initializes the SpeedStep CPUFreq driver 396 * 397 * Initializes the SpeedStep support. Returns -ENODEV on unsupported 398 * BIOS, -EINVAL on problems during initiatization, and zero on 399 * success. 400 */ 401 static int __init speedstep_init(void) 402 { 403 if (!x86_match_cpu(ss_smi_ids)) 404 return -ENODEV; 405 406 speedstep_processor = speedstep_detect_processor(); 407 408 switch (speedstep_processor) { 409 case SPEEDSTEP_CPU_PIII_T: 410 case SPEEDSTEP_CPU_PIII_C: 411 case SPEEDSTEP_CPU_PIII_C_EARLY: 412 break; 413 default: 414 speedstep_processor = 0; 415 } 416 417 if (!speedstep_processor) { 418 pr_debug("No supported Intel CPU detected.\n"); 419 return -ENODEV; 420 } 421 422 pr_debug("signature:0x%.8ulx, command:0x%.8ulx, " 423 "event:0x%.8ulx, perf_level:0x%.8ulx.\n", 424 ist_info.signature, ist_info.command, 425 ist_info.event, ist_info.perf_level); 426 427 /* Error if no IST-SMI BIOS or no PARM 428 sig= 'ISGE' aka 'Intel Speedstep Gate E' */ 429 if ((ist_info.signature != 0x47534943) && ( 430 (smi_port == 0) || (smi_cmd == 0))) 431 return -ENODEV; 432 433 if (smi_sig == 1) 434 smi_sig = 0x47534943; 435 else 436 smi_sig = ist_info.signature; 437 438 /* setup smi_port from MODLULE_PARM or BIOS */ 439 if ((smi_port > 0xff) || (smi_port < 0)) 440 return -EINVAL; 441 else if (smi_port == 0) 442 smi_port = ist_info.command & 0xff; 443 444 if ((smi_cmd > 0xff) || (smi_cmd < 0)) 445 return -EINVAL; 446 else if (smi_cmd == 0) 447 smi_cmd = (ist_info.command >> 16) & 0xff; 448 449 return cpufreq_register_driver(&speedstep_driver); 450 } 451 452 453 /** 454 * speedstep_exit - unregisters SpeedStep support 455 * 456 * Unregisters SpeedStep support. 457 */ 458 static void __exit speedstep_exit(void) 459 { 460 cpufreq_unregister_driver(&speedstep_driver); 461 } 462 463 module_param(smi_port, int, 0444); 464 module_param(smi_cmd, int, 0444); 465 module_param(smi_sig, uint, 0444); 466 467 MODULE_PARM_DESC(smi_port, "Override the BIOS-given IST port with this value " 468 "-- Intel's default setting is 0xb2"); 469 MODULE_PARM_DESC(smi_cmd, "Override the BIOS-given IST command with this value " 470 "-- Intel's default setting is 0x82"); 471 MODULE_PARM_DESC(smi_sig, "Set to 1 to fake the IST signature when using the " 472 "SMI interface."); 473 474 MODULE_AUTHOR("Hiroshi Miura"); 475 MODULE_DESCRIPTION("Speedstep driver for IST applet SMI interface."); 476 MODULE_LICENSE("GPL"); 477 478 module_init(speedstep_init); 479 module_exit(speedstep_exit); 480