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