Thomas Gleixner | 4f19048 | 2019-05-27 08:55:14 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Intel SpeedStep SMI driver. |
| 4 | * |
| 5 | * (C) 2003 Hiroshi Miura <miura@da-cha.org> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | */ |
| 7 | |
| 8 | |
| 9 | /********************************************************************* |
| 10 | * SPEEDSTEP - DEFINITIONS * |
| 11 | *********************************************************************/ |
| 12 | |
Joe Perches | 1c5864e | 2016-04-05 13:28:25 -0700 | [diff] [blame] | 13 | #define pr_fmt(fmt) "cpufreq: " fmt |
| 14 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/kernel.h> |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 16 | #include <linux/module.h> |
| 17 | #include <linux/moduleparam.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | #include <linux/init.h> |
| 19 | #include <linux/cpufreq.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/delay.h> |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 21 | #include <linux/io.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #include <asm/ist.h> |
Andi Kleen | fa8031a | 2012-01-26 00:09:12 +0100 | [diff] [blame] | 23 | #include <asm/cpu_device_id.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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. |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 31 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | */ |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 33 | static int smi_port; |
| 34 | static int smi_cmd; |
| 35 | static unsigned int smi_sig; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | |
| 37 | /* info about the processor */ |
Rusty Russell | 1cce76c | 2009-11-17 14:39:53 -0800 | [diff] [blame] | 38 | static enum speedstep_processor speedstep_processor; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 40 | /* |
| 41 | * There are only two frequency states for each processor. Values |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 42 | * are in kHz for the time being. |
| 43 | */ |
| 44 | static struct cpufreq_frequency_table speedstep_freqs[] = { |
Viresh Kumar | 7f4b046 | 2014-03-28 19:11:47 +0530 | [diff] [blame] | 45 | {0, SPEEDSTEP_HIGH, 0}, |
| 46 | {0, SPEEDSTEP_LOW, 0}, |
| 47 | {0, 0, CPUFREQ_TABLE_END}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | /** |
| 60 | * speedstep_smi_ownership |
| 61 | */ |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 62 | static int speedstep_smi_ownership(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | { |
Stephan Diestelhorst | c6e8256 | 2008-03-10 16:05:41 +0100 | [diff] [blame] | 64 | u32 command, result, magic, dummy; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 71 | pr_debug("trying to obtain ownership with command %x at port %x\n", |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 72 | command, smi_port); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | |
| 74 | __asm__ __volatile__( |
Stephan Diestelhorst | c6e8256 | 2008-03-10 16:05:41 +0100 | [diff] [blame] | 75 | "push %%ebp\n" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | "out %%al, (%%dx)\n" |
Stephan Diestelhorst | c6e8256 | 2008-03-10 16:05:41 +0100 | [diff] [blame] | 77 | "pop %%ebp\n" |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 78 | : "=D" (result), |
| 79 | "=a" (dummy), "=b" (dummy), "=c" (dummy), "=d" (dummy), |
| 80 | "=S" (dummy) |
Andrew Morton | f081a52 | 2006-03-25 01:51:51 -0800 | [diff] [blame] | 81 | : "a" (command), "b" (function), "c" (0), "d" (smi_port), |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 82 | "D" (0), "S" (magic) |
Andrew Morton | f081a52 | 2006-03-25 01:51:51 -0800 | [diff] [blame] | 83 | : "memory" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | ); |
| 85 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 86 | pr_debug("result is %x\n", result); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 100 | static int speedstep_smi_get_freqs(unsigned int *low, unsigned int *high) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | { |
Stephan Diestelhorst | c6e8256 | 2008-03-10 16:05:41 +0100 | [diff] [blame] | 102 | u32 command, result = 0, edi, high_mhz, low_mhz, dummy; |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 103 | u32 state = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | u32 function = GET_SPEEDSTEP_FREQS; |
| 105 | |
| 106 | if (!(ist_info.event & 0xFFFF)) { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 107 | pr_debug("bug #1422 -- can't read freqs from BIOS\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | return -ENODEV; |
| 109 | } |
| 110 | |
| 111 | command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff); |
| 112 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 113 | pr_debug("trying to determine frequencies with command %x at port %x\n", |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 114 | command, smi_port); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | |
Stephan Diestelhorst | c6e8256 | 2008-03-10 16:05:41 +0100 | [diff] [blame] | 116 | __asm__ __volatile__( |
| 117 | "push %%ebp\n" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | "out %%al, (%%dx)\n" |
Stephan Diestelhorst | c6e8256 | 2008-03-10 16:05:41 +0100 | [diff] [blame] | 119 | "pop %%ebp" |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 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) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | ); |
| 129 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 130 | pr_debug("result %x, low_freq %u, high_freq %u\n", |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 131 | result, low_mhz, high_mhz); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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; |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 141 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | |
| 143 | /** |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | * speedstep_set_state - set the SpeedStep state |
| 145 | * @state: new processor frequency state (SPEEDSTEP_LOW or SPEEDSTEP_HIGH) |
| 146 | * |
| 147 | */ |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 148 | static void speedstep_set_state(unsigned int state) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | { |
Stephan Diestelhorst | c6e8256 | 2008-03-10 16:05:41 +0100 | [diff] [blame] | 150 | unsigned int result = 0, command, new_state, dummy; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | unsigned long flags; |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 152 | unsigned int function = SET_SPEEDSTEP_STATE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | unsigned int retry = 0; |
| 154 | |
| 155 | if (state > 0x1) |
| 156 | return; |
| 157 | |
| 158 | /* Disable IRQs */ |
Mikulas Patocka | d4d4eda | 2015-02-09 13:38:17 -0500 | [diff] [blame] | 159 | preempt_disable(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | local_irq_save(flags); |
| 161 | |
| 162 | command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff); |
| 163 | |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 164 | pr_debug("trying to set frequency to state %u " |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 165 | "with command %x at port %x\n", |
| 166 | state, command, smi_port); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | |
| 168 | do { |
| 169 | if (retry) { |
Mikulas Patocka | d4d4eda | 2015-02-09 13:38:17 -0500 | [diff] [blame] | 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 | */ |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 178 | pr_debug("retry %u, previous result %u, waiting...\n", |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 179 | retry, result); |
Mikulas Patocka | d4d4eda | 2015-02-09 13:38:17 -0500 | [diff] [blame] | 180 | local_irq_enable(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | mdelay(retry * 50); |
Mikulas Patocka | d4d4eda | 2015-02-09 13:38:17 -0500 | [diff] [blame] | 182 | local_irq_disable(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 183 | } |
| 184 | retry++; |
| 185 | __asm__ __volatile__( |
Stephan Diestelhorst | c6e8256 | 2008-03-10 16:05:41 +0100 | [diff] [blame] | 186 | "push %%ebp\n" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 187 | "out %%al, (%%dx)\n" |
Stephan Diestelhorst | c6e8256 | 2008-03-10 16:05:41 +0100 | [diff] [blame] | 188 | "pop %%ebp" |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 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) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | ); |
| 195 | } while ((new_state != state) && (retry <= SMI_TRIES)); |
| 196 | |
| 197 | /* enable IRQs */ |
| 198 | local_irq_restore(flags); |
Mikulas Patocka | d4d4eda | 2015-02-09 13:38:17 -0500 | [diff] [blame] | 199 | preempt_enable(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 201 | if (new_state == state) |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 202 | pr_debug("change to %u MHz succeeded after %u tries " |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 203 | "with result %u\n", |
| 204 | (speedstep_freqs[new_state].frequency / 1000), |
| 205 | retry, result); |
| 206 | else |
Joe Perches | 1c5864e | 2016-04-05 13:28:25 -0700 | [diff] [blame] | 207 | pr_err("change to state %u failed with new_state %u and result %u\n", |
Joe Perches | b49c22a | 2016-04-05 13:28:24 -0700 | [diff] [blame] | 208 | state, new_state, result); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 209 | |
| 210 | return; |
| 211 | } |
| 212 | |
| 213 | |
| 214 | /** |
| 215 | * speedstep_target - set a new CPUFreq policy |
| 216 | * @policy: new policy |
Viresh Kumar | 9c0ebcf | 2013-10-25 19:45:48 +0530 | [diff] [blame] | 217 | * @index: index of new freq |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | * |
| 219 | * Sets a new CPUFreq policy/freq. |
| 220 | */ |
Viresh Kumar | 9c0ebcf | 2013-10-25 19:45:48 +0530 | [diff] [blame] | 221 | static int speedstep_target(struct cpufreq_policy *policy, unsigned int index) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 222 | { |
Viresh Kumar | 9c0ebcf | 2013-10-25 19:45:48 +0530 | [diff] [blame] | 223 | speedstep_set_state(index); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | |
| 225 | return 0; |
| 226 | } |
| 227 | |
| 228 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | static int speedstep_cpu_init(struct cpufreq_policy *policy) |
| 230 | { |
| 231 | int result; |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 232 | unsigned int *low, *high; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | |
| 234 | /* capability check */ |
| 235 | if (policy->cpu != 0) |
| 236 | return -ENODEV; |
| 237 | |
| 238 | result = speedstep_smi_ownership(); |
| 239 | if (result) { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 240 | pr_debug("fails in acquiring ownership of a SMI interface.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | return -EINVAL; |
| 242 | } |
| 243 | |
| 244 | /* detect low and high frequency */ |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 245 | low = &speedstep_freqs[SPEEDSTEP_LOW].frequency; |
| 246 | high = &speedstep_freqs[SPEEDSTEP_HIGH].frequency; |
| 247 | |
| 248 | result = speedstep_smi_get_freqs(low, high); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | if (result) { |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 250 | /* fall back to speedstep_lib.c dection mechanism: |
| 251 | * try both states out */ |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 252 | pr_debug("could not detect low and high frequencies " |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 253 | "by SMI call.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | result = speedstep_get_freqs(speedstep_processor, |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 255 | low, high, |
Mattia Dongili | 1a10760 | 2005-12-02 21:59:41 +0100 | [diff] [blame] | 256 | NULL, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | &speedstep_set_state); |
| 258 | |
| 259 | if (result) { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 260 | pr_debug("could not detect two different speeds" |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 261 | " -- aborting.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | return result; |
| 263 | } else |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 264 | pr_debug("workaround worked.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | } |
| 266 | |
Viresh Kumar | 2d28b03 | 2018-02-26 10:39:08 +0530 | [diff] [blame] | 267 | policy->freq_table = speedstep_freqs; |
| 268 | |
| 269 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | } |
| 271 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | static unsigned int speedstep_get(unsigned int cpu) |
| 273 | { |
| 274 | if (cpu) |
| 275 | return -ENODEV; |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 276 | return speedstep_get_frequency(speedstep_processor); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | } |
| 278 | |
| 279 | |
| 280 | static int speedstep_resume(struct cpufreq_policy *policy) |
| 281 | { |
| 282 | int result = speedstep_smi_ownership(); |
| 283 | |
| 284 | if (result) |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 285 | pr_debug("fails in re-acquiring ownership of a SMI interface.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 286 | |
| 287 | return result; |
| 288 | } |
| 289 | |
Linus Torvalds | 221dee2 | 2007-02-26 14:55:48 -0800 | [diff] [blame] | 290 | static struct cpufreq_driver speedstep_driver = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | .name = "speedstep-smi", |
Viresh Kumar | fe829ed | 2017-07-19 15:42:48 +0530 | [diff] [blame] | 292 | .flags = CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING, |
Viresh Kumar | 3be1394 | 2013-10-03 20:28:28 +0530 | [diff] [blame] | 293 | .verify = cpufreq_generic_frequency_table_verify, |
Viresh Kumar | 9c0ebcf | 2013-10-25 19:45:48 +0530 | [diff] [blame] | 294 | .target_index = speedstep_target, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 295 | .init = speedstep_cpu_init, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | .get = speedstep_get, |
| 297 | .resume = speedstep_resume, |
Viresh Kumar | 3be1394 | 2013-10-03 20:28:28 +0530 | [diff] [blame] | 298 | .attr = cpufreq_generic_attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | }; |
| 300 | |
Andi Kleen | fa8031a | 2012-01-26 00:09:12 +0100 | [diff] [blame] | 301 | static const struct x86_cpu_id ss_smi_ids[] = { |
Thomas Gleixner | b11d77f | 2020-03-24 14:51:51 +0100 | [diff] [blame] | 302 | X86_MATCH_VENDOR_FAM_MODEL(INTEL, 6, 0x8, 0), |
| 303 | X86_MATCH_VENDOR_FAM_MODEL(INTEL, 6, 0xb, 0), |
| 304 | X86_MATCH_VENDOR_FAM_MODEL(INTEL, 15, 0x2, 0), |
Andi Kleen | fa8031a | 2012-01-26 00:09:12 +0100 | [diff] [blame] | 305 | {} |
| 306 | }; |
Andi Kleen | fa8031a | 2012-01-26 00:09:12 +0100 | [diff] [blame] | 307 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | /** |
| 309 | * speedstep_init - initializes the SpeedStep CPUFreq driver |
| 310 | * |
| 311 | * Initializes the SpeedStep support. Returns -ENODEV on unsupported |
| 312 | * BIOS, -EINVAL on problems during initiatization, and zero on |
| 313 | * success. |
| 314 | */ |
| 315 | static int __init speedstep_init(void) |
| 316 | { |
Andi Kleen | fa8031a | 2012-01-26 00:09:12 +0100 | [diff] [blame] | 317 | if (!x86_match_cpu(ss_smi_ids)) |
| 318 | return -ENODEV; |
| 319 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | speedstep_processor = speedstep_detect_processor(); |
| 321 | |
| 322 | switch (speedstep_processor) { |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 323 | case SPEEDSTEP_CPU_PIII_T: |
| 324 | case SPEEDSTEP_CPU_PIII_C: |
| 325 | case SPEEDSTEP_CPU_PIII_C_EARLY: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | default: |
| 328 | speedstep_processor = 0; |
| 329 | } |
| 330 | |
| 331 | if (!speedstep_processor) { |
Dominik Brodowski | 2d06d8c | 2011-03-27 15:04:46 +0200 | [diff] [blame] | 332 | pr_debug("No supported Intel CPU detected.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 333 | return -ENODEV; |
| 334 | } |
| 335 | |
Hans Wennborg | a5f30eb | 2014-08-06 22:52:23 -0700 | [diff] [blame] | 336 | pr_debug("signature:0x%.8x, command:0x%.8x, " |
| 337 | "event:0x%.8x, perf_level:0x%.8x.\n", |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 338 | ist_info.signature, ist_info.command, |
| 339 | ist_info.event, ist_info.perf_level); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 341 | /* Error if no IST-SMI BIOS or no PARM |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | sig= 'ISGE' aka 'Intel Speedstep Gate E' */ |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 343 | if ((ist_info.signature != 0x47534943) && ( |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | (smi_port == 0) || (smi_cmd == 0))) |
| 345 | return -ENODEV; |
| 346 | |
| 347 | if (smi_sig == 1) |
| 348 | smi_sig = 0x47534943; |
| 349 | else |
| 350 | smi_sig = ist_info.signature; |
| 351 | |
| 352 | /* setup smi_port from MODLULE_PARM or BIOS */ |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 353 | if ((smi_port > 0xff) || (smi_port < 0)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 354 | return -EINVAL; |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 355 | else if (smi_port == 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | smi_port = ist_info.command & 0xff; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 357 | |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 358 | if ((smi_cmd > 0xff) || (smi_cmd < 0)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | return -EINVAL; |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 360 | else if (smi_cmd == 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | smi_cmd = (ist_info.command >> 16) & 0xff; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 362 | |
| 363 | return cpufreq_register_driver(&speedstep_driver); |
| 364 | } |
| 365 | |
| 366 | |
| 367 | /** |
| 368 | * speedstep_exit - unregisters SpeedStep support |
| 369 | * |
| 370 | * Unregisters SpeedStep support. |
| 371 | */ |
| 372 | static void __exit speedstep_exit(void) |
| 373 | { |
| 374 | cpufreq_unregister_driver(&speedstep_driver); |
| 375 | } |
| 376 | |
David Howells | 40059ec | 2017-04-04 16:54:22 +0100 | [diff] [blame] | 377 | module_param_hw(smi_port, int, ioport, 0444); |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 378 | module_param(smi_cmd, int, 0444); |
| 379 | module_param(smi_sig, uint, 0444); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 380 | |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 381 | MODULE_PARM_DESC(smi_port, "Override the BIOS-given IST port with this value " |
| 382 | "-- Intel's default setting is 0xb2"); |
| 383 | MODULE_PARM_DESC(smi_cmd, "Override the BIOS-given IST command with this value " |
| 384 | "-- Intel's default setting is 0x82"); |
| 385 | MODULE_PARM_DESC(smi_sig, "Set to 1 to fake the IST signature when using the " |
| 386 | "SMI interface."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | |
Dave Jones | bbfebd6 | 2009-01-17 23:55:22 -0500 | [diff] [blame] | 388 | MODULE_AUTHOR("Hiroshi Miura"); |
| 389 | MODULE_DESCRIPTION("Speedstep driver for IST applet SMI interface."); |
| 390 | MODULE_LICENSE("GPL"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | |
| 392 | module_init(speedstep_init); |
| 393 | module_exit(speedstep_exit); |