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 * @index: index of new freq 239 * 240 * Sets a new CPUFreq policy/freq. 241 */ 242 static int speedstep_target(struct cpufreq_policy *policy, unsigned int index) 243 { 244 speedstep_set_state(index); 245 246 return 0; 247 } 248 249 250 static int speedstep_cpu_init(struct cpufreq_policy *policy) 251 { 252 int result; 253 unsigned int *low, *high; 254 255 /* capability check */ 256 if (policy->cpu != 0) 257 return -ENODEV; 258 259 result = speedstep_smi_ownership(); 260 if (result) { 261 pr_debug("fails in acquiring ownership of a SMI interface.\n"); 262 return -EINVAL; 263 } 264 265 /* detect low and high frequency */ 266 low = &speedstep_freqs[SPEEDSTEP_LOW].frequency; 267 high = &speedstep_freqs[SPEEDSTEP_HIGH].frequency; 268 269 result = speedstep_smi_get_freqs(low, high); 270 if (result) { 271 /* fall back to speedstep_lib.c dection mechanism: 272 * try both states out */ 273 pr_debug("could not detect low and high frequencies " 274 "by SMI call.\n"); 275 result = speedstep_get_freqs(speedstep_processor, 276 low, high, 277 NULL, 278 &speedstep_set_state); 279 280 if (result) { 281 pr_debug("could not detect two different speeds" 282 " -- aborting.\n"); 283 return result; 284 } else 285 pr_debug("workaround worked.\n"); 286 } 287 288 policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; 289 return cpufreq_table_validate_and_show(policy, speedstep_freqs); 290 } 291 292 static unsigned int speedstep_get(unsigned int cpu) 293 { 294 if (cpu) 295 return -ENODEV; 296 return speedstep_get_frequency(speedstep_processor); 297 } 298 299 300 static int speedstep_resume(struct cpufreq_policy *policy) 301 { 302 int result = speedstep_smi_ownership(); 303 304 if (result) 305 pr_debug("fails in re-acquiring ownership of a SMI interface.\n"); 306 307 return result; 308 } 309 310 static struct cpufreq_driver speedstep_driver = { 311 .name = "speedstep-smi", 312 .verify = cpufreq_generic_frequency_table_verify, 313 .target_index = speedstep_target, 314 .init = speedstep_cpu_init, 315 .exit = cpufreq_generic_exit, 316 .get = speedstep_get, 317 .resume = speedstep_resume, 318 .attr = cpufreq_generic_attr, 319 }; 320 321 static const struct x86_cpu_id ss_smi_ids[] = { 322 { X86_VENDOR_INTEL, 6, 0xb, }, 323 { X86_VENDOR_INTEL, 6, 0x8, }, 324 { X86_VENDOR_INTEL, 15, 2 }, 325 {} 326 }; 327 #if 0 328 /* Not auto loaded currently */ 329 MODULE_DEVICE_TABLE(x86cpu, ss_smi_ids); 330 #endif 331 332 /** 333 * speedstep_init - initializes the SpeedStep CPUFreq driver 334 * 335 * Initializes the SpeedStep support. Returns -ENODEV on unsupported 336 * BIOS, -EINVAL on problems during initiatization, and zero on 337 * success. 338 */ 339 static int __init speedstep_init(void) 340 { 341 if (!x86_match_cpu(ss_smi_ids)) 342 return -ENODEV; 343 344 speedstep_processor = speedstep_detect_processor(); 345 346 switch (speedstep_processor) { 347 case SPEEDSTEP_CPU_PIII_T: 348 case SPEEDSTEP_CPU_PIII_C: 349 case SPEEDSTEP_CPU_PIII_C_EARLY: 350 break; 351 default: 352 speedstep_processor = 0; 353 } 354 355 if (!speedstep_processor) { 356 pr_debug("No supported Intel CPU detected.\n"); 357 return -ENODEV; 358 } 359 360 pr_debug("signature:0x%.8ulx, command:0x%.8ulx, " 361 "event:0x%.8ulx, perf_level:0x%.8ulx.\n", 362 ist_info.signature, ist_info.command, 363 ist_info.event, ist_info.perf_level); 364 365 /* Error if no IST-SMI BIOS or no PARM 366 sig= 'ISGE' aka 'Intel Speedstep Gate E' */ 367 if ((ist_info.signature != 0x47534943) && ( 368 (smi_port == 0) || (smi_cmd == 0))) 369 return -ENODEV; 370 371 if (smi_sig == 1) 372 smi_sig = 0x47534943; 373 else 374 smi_sig = ist_info.signature; 375 376 /* setup smi_port from MODLULE_PARM or BIOS */ 377 if ((smi_port > 0xff) || (smi_port < 0)) 378 return -EINVAL; 379 else if (smi_port == 0) 380 smi_port = ist_info.command & 0xff; 381 382 if ((smi_cmd > 0xff) || (smi_cmd < 0)) 383 return -EINVAL; 384 else if (smi_cmd == 0) 385 smi_cmd = (ist_info.command >> 16) & 0xff; 386 387 return cpufreq_register_driver(&speedstep_driver); 388 } 389 390 391 /** 392 * speedstep_exit - unregisters SpeedStep support 393 * 394 * Unregisters SpeedStep support. 395 */ 396 static void __exit speedstep_exit(void) 397 { 398 cpufreq_unregister_driver(&speedstep_driver); 399 } 400 401 module_param(smi_port, int, 0444); 402 module_param(smi_cmd, int, 0444); 403 module_param(smi_sig, uint, 0444); 404 405 MODULE_PARM_DESC(smi_port, "Override the BIOS-given IST port with this value " 406 "-- Intel's default setting is 0xb2"); 407 MODULE_PARM_DESC(smi_cmd, "Override the BIOS-given IST command with this value " 408 "-- Intel's default setting is 0x82"); 409 MODULE_PARM_DESC(smi_sig, "Set to 1 to fake the IST signature when using the " 410 "SMI interface."); 411 412 MODULE_AUTHOR("Hiroshi Miura"); 413 MODULE_DESCRIPTION("Speedstep driver for IST applet SMI interface."); 414 MODULE_LICENSE("GPL"); 415 416 module_init(speedstep_init); 417 module_exit(speedstep_exit); 418