Root/drivers/cpufreq/speedstep-smi.c

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 */
33static int smi_port;
34static int smi_cmd;
35static unsigned int smi_sig;
36
37/* info about the processor */
38static 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 */
44static 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 */
62static 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 */
100static 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 */
148static 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 */
180static 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 */
243static 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 */
275static int speedstep_verify(struct cpufreq_policy *policy)
276{
277    return cpufreq_frequency_table_verify(policy, &speedstep_freqs[0]);
278}
279
280
281static 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
342static int speedstep_cpu_exit(struct cpufreq_policy *policy)
343{
344    cpufreq_frequency_table_put_attr(policy->cpu);
345    return 0;
346}
347
348static unsigned int speedstep_get(unsigned int cpu)
349{
350    if (cpu)
351        return -ENODEV;
352    return speedstep_get_frequency(speedstep_processor);
353}
354
355
356static 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
366static struct freq_attr *speedstep_attr[] = {
367    &cpufreq_freq_attr_scaling_available_freqs,
368    NULL,
369};
370
371static 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
383static 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 */
391MODULE_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 */
401static 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 */
458static void __exit speedstep_exit(void)
459{
460    cpufreq_unregister_driver(&speedstep_driver);
461}
462
463module_param(smi_port, int, 0444);
464module_param(smi_cmd, int, 0444);
465module_param(smi_sig, uint, 0444);
466
467MODULE_PARM_DESC(smi_port, "Override the BIOS-given IST port with this value "
468        "-- Intel's default setting is 0xb2");
469MODULE_PARM_DESC(smi_cmd, "Override the BIOS-given IST command with this value "
470        "-- Intel's default setting is 0x82");
471MODULE_PARM_DESC(smi_sig, "Set to 1 to fake the IST signature when using the "
472        "SMI interface.");
473
474MODULE_AUTHOR("Hiroshi Miura");
475MODULE_DESCRIPTION("Speedstep driver for IST applet SMI interface.");
476MODULE_LICENSE("GPL");
477
478module_init(speedstep_init);
479module_exit(speedstep_exit);
480

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive