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 {0, SPEEDSTEP_HIGH, 0}, 46 {0, SPEEDSTEP_LOW, 0}, 47 {0, 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_set_state - set the SpeedStep state 145 * @state: new processor frequency state (SPEEDSTEP_LOW or SPEEDSTEP_HIGH) 146 * 147 */ 148 static void speedstep_set_state(unsigned int state) 149 { 150 unsigned int result = 0, command, new_state, dummy; 151 unsigned long flags; 152 unsigned int function = SET_SPEEDSTEP_STATE; 153 unsigned int retry = 0; 154 155 if (state > 0x1) 156 return; 157 158 /* Disable IRQs */ 159 preempt_disable(); 160 local_irq_save(flags); 161 162 command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff); 163 164 pr_debug("trying to set frequency to state %u " 165 "with command %x at port %x\n", 166 state, command, smi_port); 167 168 do { 169 if (retry) { 170 /* 171 * We need to enable interrupts, otherwise the blockage 172 * won't resolve. 173 * 174 * We disable preemption so that other processes don't 175 * run. If other processes were running, they could 176 * submit more DMA requests, making the blockage worse. 177 */ 178 pr_debug("retry %u, previous result %u, waiting...\n", 179 retry, result); 180 local_irq_enable(); 181 mdelay(retry * 50); 182 local_irq_disable(); 183 } 184 retry++; 185 __asm__ __volatile__( 186 "push %%ebp\n" 187 "out %%al, (%%dx)\n" 188 "pop %%ebp" 189 : "=b" (new_state), "=D" (result), 190 "=c" (dummy), "=a" (dummy), 191 "=d" (dummy), "=S" (dummy) 192 : "a" (command), "b" (function), "c" (state), 193 "d" (smi_port), "S" (0), "D" (0) 194 ); 195 } while ((new_state != state) && (retry <= SMI_TRIES)); 196 197 /* enable IRQs */ 198 local_irq_restore(flags); 199 preempt_enable(); 200 201 if (new_state == state) 202 pr_debug("change to %u MHz succeeded after %u tries " 203 "with result %u\n", 204 (speedstep_freqs[new_state].frequency / 1000), 205 retry, result); 206 else 207 printk(KERN_ERR "cpufreq: change to state %u " 208 "failed with new_state %u and result %u\n", 209 state, new_state, result); 210 211 return; 212 } 213 214 215 /** 216 * speedstep_target - set a new CPUFreq policy 217 * @policy: new policy 218 * @index: index of new freq 219 * 220 * Sets a new CPUFreq policy/freq. 221 */ 222 static int speedstep_target(struct cpufreq_policy *policy, unsigned int index) 223 { 224 speedstep_set_state(index); 225 226 return 0; 227 } 228 229 230 static int speedstep_cpu_init(struct cpufreq_policy *policy) 231 { 232 int result; 233 unsigned int *low, *high; 234 235 /* capability check */ 236 if (policy->cpu != 0) 237 return -ENODEV; 238 239 result = speedstep_smi_ownership(); 240 if (result) { 241 pr_debug("fails in acquiring ownership of a SMI interface.\n"); 242 return -EINVAL; 243 } 244 245 /* detect low and high frequency */ 246 low = &speedstep_freqs[SPEEDSTEP_LOW].frequency; 247 high = &speedstep_freqs[SPEEDSTEP_HIGH].frequency; 248 249 result = speedstep_smi_get_freqs(low, high); 250 if (result) { 251 /* fall back to speedstep_lib.c dection mechanism: 252 * try both states out */ 253 pr_debug("could not detect low and high frequencies " 254 "by SMI call.\n"); 255 result = speedstep_get_freqs(speedstep_processor, 256 low, high, 257 NULL, 258 &speedstep_set_state); 259 260 if (result) { 261 pr_debug("could not detect two different speeds" 262 " -- aborting.\n"); 263 return result; 264 } else 265 pr_debug("workaround worked.\n"); 266 } 267 268 policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; 269 return cpufreq_table_validate_and_show(policy, speedstep_freqs); 270 } 271 272 static unsigned int speedstep_get(unsigned int cpu) 273 { 274 if (cpu) 275 return -ENODEV; 276 return speedstep_get_frequency(speedstep_processor); 277 } 278 279 280 static int speedstep_resume(struct cpufreq_policy *policy) 281 { 282 int result = speedstep_smi_ownership(); 283 284 if (result) 285 pr_debug("fails in re-acquiring ownership of a SMI interface.\n"); 286 287 return result; 288 } 289 290 static struct cpufreq_driver speedstep_driver = { 291 .name = "speedstep-smi", 292 .verify = cpufreq_generic_frequency_table_verify, 293 .target_index = speedstep_target, 294 .init = speedstep_cpu_init, 295 .get = speedstep_get, 296 .resume = speedstep_resume, 297 .attr = cpufreq_generic_attr, 298 }; 299 300 static const struct x86_cpu_id ss_smi_ids[] = { 301 { X86_VENDOR_INTEL, 6, 0xb, }, 302 { X86_VENDOR_INTEL, 6, 0x8, }, 303 { X86_VENDOR_INTEL, 15, 2 }, 304 {} 305 }; 306 #if 0 307 /* Not auto loaded currently */ 308 MODULE_DEVICE_TABLE(x86cpu, ss_smi_ids); 309 #endif 310 311 /** 312 * speedstep_init - initializes the SpeedStep CPUFreq driver 313 * 314 * Initializes the SpeedStep support. Returns -ENODEV on unsupported 315 * BIOS, -EINVAL on problems during initiatization, and zero on 316 * success. 317 */ 318 static int __init speedstep_init(void) 319 { 320 if (!x86_match_cpu(ss_smi_ids)) 321 return -ENODEV; 322 323 speedstep_processor = speedstep_detect_processor(); 324 325 switch (speedstep_processor) { 326 case SPEEDSTEP_CPU_PIII_T: 327 case SPEEDSTEP_CPU_PIII_C: 328 case SPEEDSTEP_CPU_PIII_C_EARLY: 329 break; 330 default: 331 speedstep_processor = 0; 332 } 333 334 if (!speedstep_processor) { 335 pr_debug("No supported Intel CPU detected.\n"); 336 return -ENODEV; 337 } 338 339 pr_debug("signature:0x%.8x, command:0x%.8x, " 340 "event:0x%.8x, perf_level:0x%.8x.\n", 341 ist_info.signature, ist_info.command, 342 ist_info.event, ist_info.perf_level); 343 344 /* Error if no IST-SMI BIOS or no PARM 345 sig= 'ISGE' aka 'Intel Speedstep Gate E' */ 346 if ((ist_info.signature != 0x47534943) && ( 347 (smi_port == 0) || (smi_cmd == 0))) 348 return -ENODEV; 349 350 if (smi_sig == 1) 351 smi_sig = 0x47534943; 352 else 353 smi_sig = ist_info.signature; 354 355 /* setup smi_port from MODLULE_PARM or BIOS */ 356 if ((smi_port > 0xff) || (smi_port < 0)) 357 return -EINVAL; 358 else if (smi_port == 0) 359 smi_port = ist_info.command & 0xff; 360 361 if ((smi_cmd > 0xff) || (smi_cmd < 0)) 362 return -EINVAL; 363 else if (smi_cmd == 0) 364 smi_cmd = (ist_info.command >> 16) & 0xff; 365 366 return cpufreq_register_driver(&speedstep_driver); 367 } 368 369 370 /** 371 * speedstep_exit - unregisters SpeedStep support 372 * 373 * Unregisters SpeedStep support. 374 */ 375 static void __exit speedstep_exit(void) 376 { 377 cpufreq_unregister_driver(&speedstep_driver); 378 } 379 380 module_param(smi_port, int, 0444); 381 module_param(smi_cmd, int, 0444); 382 module_param(smi_sig, uint, 0444); 383 384 MODULE_PARM_DESC(smi_port, "Override the BIOS-given IST port with this value " 385 "-- Intel's default setting is 0xb2"); 386 MODULE_PARM_DESC(smi_cmd, "Override the BIOS-given IST command with this value " 387 "-- Intel's default setting is 0x82"); 388 MODULE_PARM_DESC(smi_sig, "Set to 1 to fake the IST signature when using the " 389 "SMI interface."); 390 391 MODULE_AUTHOR("Hiroshi Miura"); 392 MODULE_DESCRIPTION("Speedstep driver for IST applet SMI interface."); 393 MODULE_LICENSE("GPL"); 394 395 module_init(speedstep_init); 396 module_exit(speedstep_exit); 397