Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code »

Commit f0f0ce97e128569d07fae98c62d8cff1e042fa1e

Authored by Linus Torvalds
2 parents e8e3232627 bef2a508b4
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

Merge branch 'i8k-updates' from Alan 

* i8k-updates:
  i8k: Add Dell Vostro systems
  i8k: Enable i8k on Dell Precision Systems

Showing 1 changed file Inline Diff

1 /* 1 /*
2 * i8k.c -- Linux driver for accessing the SMM BIOS on Dell laptops. 2 * i8k.c -- Linux driver for accessing the SMM BIOS on Dell laptops.
3 * See http://www.debian.org/~dz/i8k/ for more information 3 * See http://www.debian.org/~dz/i8k/ for more information
4 * and for latest version of this driver. 4 * and for latest version of this driver.
5 * 5 *
6 * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> 6 * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org>
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify it 8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the 9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2, or (at your option) any 10 * Free Software Foundation; either version 2, or (at your option) any
11 * later version. 11 * later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, but 13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details. 16 * General Public License for more details.
17 */ 17 */
18 18
19 #include <linux/module.h> 19 #include <linux/module.h>
20 #include <linux/types.h> 20 #include <linux/types.h>
21 #include <linux/init.h> 21 #include <linux/init.h>
22 #include <linux/proc_fs.h> 22 #include <linux/proc_fs.h>
23 #include <linux/seq_file.h> 23 #include <linux/seq_file.h>
24 #include <linux/dmi.h> 24 #include <linux/dmi.h>
25 #include <linux/capability.h> 25 #include <linux/capability.h>
26 #include <asm/uaccess.h> 26 #include <asm/uaccess.h>
27 #include <asm/io.h> 27 #include <asm/io.h>
28 28
29 #include <linux/i8k.h> 29 #include <linux/i8k.h>
30 30
31 #define I8K_VERSION "1.14 21/02/2005" 31 #define I8K_VERSION "1.14 21/02/2005"
32 32
33 #define I8K_SMM_FN_STATUS 0x0025 33 #define I8K_SMM_FN_STATUS 0x0025
34 #define I8K_SMM_POWER_STATUS 0x0069 34 #define I8K_SMM_POWER_STATUS 0x0069
35 #define I8K_SMM_SET_FAN 0x01a3 35 #define I8K_SMM_SET_FAN 0x01a3
36 #define I8K_SMM_GET_FAN 0x00a3 36 #define I8K_SMM_GET_FAN 0x00a3
37 #define I8K_SMM_GET_SPEED 0x02a3 37 #define I8K_SMM_GET_SPEED 0x02a3
38 #define I8K_SMM_GET_TEMP 0x10a3 38 #define I8K_SMM_GET_TEMP 0x10a3
39 #define I8K_SMM_GET_DELL_SIG1 0xfea3 39 #define I8K_SMM_GET_DELL_SIG1 0xfea3
40 #define I8K_SMM_GET_DELL_SIG2 0xffa3 40 #define I8K_SMM_GET_DELL_SIG2 0xffa3
41 #define I8K_SMM_BIOS_VERSION 0x00a6 41 #define I8K_SMM_BIOS_VERSION 0x00a6
42 42
43 #define I8K_FAN_MULT 30 43 #define I8K_FAN_MULT 30
44 #define I8K_MAX_TEMP 127 44 #define I8K_MAX_TEMP 127
45 45
46 #define I8K_FN_NONE 0x00 46 #define I8K_FN_NONE 0x00
47 #define I8K_FN_UP 0x01 47 #define I8K_FN_UP 0x01
48 #define I8K_FN_DOWN 0x02 48 #define I8K_FN_DOWN 0x02
49 #define I8K_FN_MUTE 0x04 49 #define I8K_FN_MUTE 0x04
50 #define I8K_FN_MASK 0x07 50 #define I8K_FN_MASK 0x07
51 #define I8K_FN_SHIFT 8 51 #define I8K_FN_SHIFT 8
52 52
53 #define I8K_POWER_AC 0x05 53 #define I8K_POWER_AC 0x05
54 #define I8K_POWER_BATTERY 0x01 54 #define I8K_POWER_BATTERY 0x01
55 55
56 #define I8K_TEMPERATURE_BUG 1 56 #define I8K_TEMPERATURE_BUG 1
57 57
58 static char bios_version[4]; 58 static char bios_version[4];
59 59
60 MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); 60 MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)");
61 MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); 61 MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops");
62 MODULE_LICENSE("GPL"); 62 MODULE_LICENSE("GPL");
63 63
64 static int force; 64 static int force;
65 module_param(force, bool, 0); 65 module_param(force, bool, 0);
66 MODULE_PARM_DESC(force, "Force loading without checking for supported models"); 66 MODULE_PARM_DESC(force, "Force loading without checking for supported models");
67 67
68 static int ignore_dmi; 68 static int ignore_dmi;
69 module_param(ignore_dmi, bool, 0); 69 module_param(ignore_dmi, bool, 0);
70 MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); 70 MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match");
71 71
72 static int restricted; 72 static int restricted;
73 module_param(restricted, bool, 0); 73 module_param(restricted, bool, 0);
74 MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); 74 MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set");
75 75
76 static int power_status; 76 static int power_status;
77 module_param(power_status, bool, 0600); 77 module_param(power_status, bool, 0600);
78 MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); 78 MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k");
79 79
80 static int fan_mult = I8K_FAN_MULT; 80 static int fan_mult = I8K_FAN_MULT;
81 module_param(fan_mult, int, 0); 81 module_param(fan_mult, int, 0);
82 MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with"); 82 MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with");
83 83
84 static int i8k_open_fs(struct inode *inode, struct file *file); 84 static int i8k_open_fs(struct inode *inode, struct file *file);
85 static int i8k_ioctl(struct inode *, struct file *, unsigned int, 85 static int i8k_ioctl(struct inode *, struct file *, unsigned int,
86 unsigned long); 86 unsigned long);
87 87
88 static const struct file_operations i8k_fops = { 88 static const struct file_operations i8k_fops = {
89 .owner = THIS_MODULE, 89 .owner = THIS_MODULE,
90 .open = i8k_open_fs, 90 .open = i8k_open_fs,
91 .read = seq_read, 91 .read = seq_read,
92 .llseek = seq_lseek, 92 .llseek = seq_lseek,
93 .release = single_release, 93 .release = single_release,
94 .ioctl = i8k_ioctl, 94 .ioctl = i8k_ioctl,
95 }; 95 };
96 96
97 struct smm_regs { 97 struct smm_regs {
98 unsigned int eax; 98 unsigned int eax;
99 unsigned int ebx __attribute__ ((packed)); 99 unsigned int ebx __attribute__ ((packed));
100 unsigned int ecx __attribute__ ((packed)); 100 unsigned int ecx __attribute__ ((packed));
101 unsigned int edx __attribute__ ((packed)); 101 unsigned int edx __attribute__ ((packed));
102 unsigned int esi __attribute__ ((packed)); 102 unsigned int esi __attribute__ ((packed));
103 unsigned int edi __attribute__ ((packed)); 103 unsigned int edi __attribute__ ((packed));
104 }; 104 };
105 105
106 static inline const char *i8k_get_dmi_data(int field) 106 static inline const char *i8k_get_dmi_data(int field)
107 { 107 {
108 const char *dmi_data = dmi_get_system_info(field); 108 const char *dmi_data = dmi_get_system_info(field);
109 109
110 return dmi_data && *dmi_data ? dmi_data : "?"; 110 return dmi_data && *dmi_data ? dmi_data : "?";
111 } 111 }
112 112
113 /* 113 /*
114 * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. 114 * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard.
115 */ 115 */
116 static int i8k_smm(struct smm_regs *regs) 116 static int i8k_smm(struct smm_regs *regs)
117 { 117 {
118 int rc; 118 int rc;
119 int eax = regs->eax; 119 int eax = regs->eax;
120 120
121 #if defined(CONFIG_X86_64) 121 #if defined(CONFIG_X86_64)
122 asm("pushq %%rax\n\t" 122 asm("pushq %%rax\n\t"
123 "movl 0(%%rax),%%edx\n\t" 123 "movl 0(%%rax),%%edx\n\t"
124 "pushq %%rdx\n\t" 124 "pushq %%rdx\n\t"
125 "movl 4(%%rax),%%ebx\n\t" 125 "movl 4(%%rax),%%ebx\n\t"
126 "movl 8(%%rax),%%ecx\n\t" 126 "movl 8(%%rax),%%ecx\n\t"
127 "movl 12(%%rax),%%edx\n\t" 127 "movl 12(%%rax),%%edx\n\t"
128 "movl 16(%%rax),%%esi\n\t" 128 "movl 16(%%rax),%%esi\n\t"
129 "movl 20(%%rax),%%edi\n\t" 129 "movl 20(%%rax),%%edi\n\t"
130 "popq %%rax\n\t" 130 "popq %%rax\n\t"
131 "out %%al,$0xb2\n\t" 131 "out %%al,$0xb2\n\t"
132 "out %%al,$0x84\n\t" 132 "out %%al,$0x84\n\t"
133 "xchgq %%rax,(%%rsp)\n\t" 133 "xchgq %%rax,(%%rsp)\n\t"
134 "movl %%ebx,4(%%rax)\n\t" 134 "movl %%ebx,4(%%rax)\n\t"
135 "movl %%ecx,8(%%rax)\n\t" 135 "movl %%ecx,8(%%rax)\n\t"
136 "movl %%edx,12(%%rax)\n\t" 136 "movl %%edx,12(%%rax)\n\t"
137 "movl %%esi,16(%%rax)\n\t" 137 "movl %%esi,16(%%rax)\n\t"
138 "movl %%edi,20(%%rax)\n\t" 138 "movl %%edi,20(%%rax)\n\t"
139 "popq %%rdx\n\t" 139 "popq %%rdx\n\t"
140 "movl %%edx,0(%%rax)\n\t" 140 "movl %%edx,0(%%rax)\n\t"
141 "lahf\n\t" 141 "lahf\n\t"
142 "shrl $8,%%eax\n\t" 142 "shrl $8,%%eax\n\t"
143 "andl $1,%%eax\n" 143 "andl $1,%%eax\n"
144 :"=a"(rc) 144 :"=a"(rc)
145 : "a"(regs) 145 : "a"(regs)
146 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); 146 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory");
147 #else 147 #else
148 asm("pushl %%eax\n\t" 148 asm("pushl %%eax\n\t"
149 "movl 0(%%eax),%%edx\n\t" 149 "movl 0(%%eax),%%edx\n\t"
150 "push %%edx\n\t" 150 "push %%edx\n\t"
151 "movl 4(%%eax),%%ebx\n\t" 151 "movl 4(%%eax),%%ebx\n\t"
152 "movl 8(%%eax),%%ecx\n\t" 152 "movl 8(%%eax),%%ecx\n\t"
153 "movl 12(%%eax),%%edx\n\t" 153 "movl 12(%%eax),%%edx\n\t"
154 "movl 16(%%eax),%%esi\n\t" 154 "movl 16(%%eax),%%esi\n\t"
155 "movl 20(%%eax),%%edi\n\t" 155 "movl 20(%%eax),%%edi\n\t"
156 "popl %%eax\n\t" 156 "popl %%eax\n\t"
157 "out %%al,$0xb2\n\t" 157 "out %%al,$0xb2\n\t"
158 "out %%al,$0x84\n\t" 158 "out %%al,$0x84\n\t"
159 "xchgl %%eax,(%%esp)\n\t" 159 "xchgl %%eax,(%%esp)\n\t"
160 "movl %%ebx,4(%%eax)\n\t" 160 "movl %%ebx,4(%%eax)\n\t"
161 "movl %%ecx,8(%%eax)\n\t" 161 "movl %%ecx,8(%%eax)\n\t"
162 "movl %%edx,12(%%eax)\n\t" 162 "movl %%edx,12(%%eax)\n\t"
163 "movl %%esi,16(%%eax)\n\t" 163 "movl %%esi,16(%%eax)\n\t"
164 "movl %%edi,20(%%eax)\n\t" 164 "movl %%edi,20(%%eax)\n\t"
165 "popl %%edx\n\t" 165 "popl %%edx\n\t"
166 "movl %%edx,0(%%eax)\n\t" 166 "movl %%edx,0(%%eax)\n\t"
167 "lahf\n\t" 167 "lahf\n\t"
168 "shrl $8,%%eax\n\t" 168 "shrl $8,%%eax\n\t"
169 "andl $1,%%eax\n":"=a"(rc) 169 "andl $1,%%eax\n":"=a"(rc)
170 : "a"(regs) 170 : "a"(regs)
171 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); 171 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory");
172 #endif 172 #endif
173 if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) 173 if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax)
174 return -EINVAL; 174 return -EINVAL;
175 175
176 return 0; 176 return 0;
177 } 177 }
178 178
179 /* 179 /*
180 * Read the bios version. Return the version as an integer corresponding 180 * Read the bios version. Return the version as an integer corresponding
181 * to the ascii value, for example "A17" is returned as 0x00413137. 181 * to the ascii value, for example "A17" is returned as 0x00413137.
182 */ 182 */
183 static int i8k_get_bios_version(void) 183 static int i8k_get_bios_version(void)
184 { 184 {
185 struct smm_regs regs = { .eax = I8K_SMM_BIOS_VERSION, }; 185 struct smm_regs regs = { .eax = I8K_SMM_BIOS_VERSION, };
186 186
187 return i8k_smm(&regs) ? : regs.eax; 187 return i8k_smm(&regs) ? : regs.eax;
188 } 188 }
189 189
190 /* 190 /*
191 * Read the Fn key status. 191 * Read the Fn key status.
192 */ 192 */
193 static int i8k_get_fn_status(void) 193 static int i8k_get_fn_status(void)
194 { 194 {
195 struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; 195 struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, };
196 int rc; 196 int rc;
197 197
198 if ((rc = i8k_smm(&regs)) < 0) 198 if ((rc = i8k_smm(&regs)) < 0)
199 return rc; 199 return rc;
200 200
201 switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { 201 switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) {
202 case I8K_FN_UP: 202 case I8K_FN_UP:
203 return I8K_VOL_UP; 203 return I8K_VOL_UP;
204 case I8K_FN_DOWN: 204 case I8K_FN_DOWN:
205 return I8K_VOL_DOWN; 205 return I8K_VOL_DOWN;
206 case I8K_FN_MUTE: 206 case I8K_FN_MUTE:
207 return I8K_VOL_MUTE; 207 return I8K_VOL_MUTE;
208 default: 208 default:
209 return 0; 209 return 0;
210 } 210 }
211 } 211 }
212 212
213 /* 213 /*
214 * Read the power status. 214 * Read the power status.
215 */ 215 */
216 static int i8k_get_power_status(void) 216 static int i8k_get_power_status(void)
217 { 217 {
218 struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; 218 struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, };
219 int rc; 219 int rc;
220 220
221 if ((rc = i8k_smm(&regs)) < 0) 221 if ((rc = i8k_smm(&regs)) < 0)
222 return rc; 222 return rc;
223 223
224 return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; 224 return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY;
225 } 225 }
226 226
227 /* 227 /*
228 * Read the fan status. 228 * Read the fan status.
229 */ 229 */
230 static int i8k_get_fan_status(int fan) 230 static int i8k_get_fan_status(int fan)
231 { 231 {
232 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; 232 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, };
233 233
234 regs.ebx = fan & 0xff; 234 regs.ebx = fan & 0xff;
235 return i8k_smm(&regs) ? : regs.eax & 0xff; 235 return i8k_smm(&regs) ? : regs.eax & 0xff;
236 } 236 }
237 237
238 /* 238 /*
239 * Read the fan speed in RPM. 239 * Read the fan speed in RPM.
240 */ 240 */
241 static int i8k_get_fan_speed(int fan) 241 static int i8k_get_fan_speed(int fan)
242 { 242 {
243 struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; 243 struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, };
244 244
245 regs.ebx = fan & 0xff; 245 regs.ebx = fan & 0xff;
246 return i8k_smm(&regs) ? : (regs.eax & 0xffff) * fan_mult; 246 return i8k_smm(&regs) ? : (regs.eax & 0xffff) * fan_mult;
247 } 247 }
248 248
249 /* 249 /*
250 * Set the fan speed (off, low, high). Returns the new fan status. 250 * Set the fan speed (off, low, high). Returns the new fan status.
251 */ 251 */
252 static int i8k_set_fan(int fan, int speed) 252 static int i8k_set_fan(int fan, int speed)
253 { 253 {
254 struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; 254 struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, };
255 255
256 speed = (speed < 0) ? 0 : ((speed > I8K_FAN_MAX) ? I8K_FAN_MAX : speed); 256 speed = (speed < 0) ? 0 : ((speed > I8K_FAN_MAX) ? I8K_FAN_MAX : speed);
257 regs.ebx = (fan & 0xff) | (speed << 8); 257 regs.ebx = (fan & 0xff) | (speed << 8);
258 258
259 return i8k_smm(&regs) ? : i8k_get_fan_status(fan); 259 return i8k_smm(&regs) ? : i8k_get_fan_status(fan);
260 } 260 }
261 261
262 /* 262 /*
263 * Read the cpu temperature. 263 * Read the cpu temperature.
264 */ 264 */
265 static int i8k_get_temp(int sensor) 265 static int i8k_get_temp(int sensor)
266 { 266 {
267 struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP, }; 267 struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP, };
268 int rc; 268 int rc;
269 int temp; 269 int temp;
270 270
271 #ifdef I8K_TEMPERATURE_BUG 271 #ifdef I8K_TEMPERATURE_BUG
272 static int prev; 272 static int prev;
273 #endif 273 #endif
274 regs.ebx = sensor & 0xff; 274 regs.ebx = sensor & 0xff;
275 if ((rc = i8k_smm(&regs)) < 0) 275 if ((rc = i8k_smm(&regs)) < 0)
276 return rc; 276 return rc;
277 277
278 temp = regs.eax & 0xff; 278 temp = regs.eax & 0xff;
279 279
280 #ifdef I8K_TEMPERATURE_BUG 280 #ifdef I8K_TEMPERATURE_BUG
281 /* 281 /*
282 * Sometimes the temperature sensor returns 0x99, which is out of range. 282 * Sometimes the temperature sensor returns 0x99, which is out of range.
283 * In this case we return (once) the previous cached value. For example: 283 * In this case we return (once) the previous cached value. For example:
284 # 1003655137 00000058 00005a4b 284 # 1003655137 00000058 00005a4b
285 # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees 285 # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees
286 # 1003655139 00000054 00005c52 286 # 1003655139 00000054 00005c52
287 */ 287 */
288 if (temp > I8K_MAX_TEMP) { 288 if (temp > I8K_MAX_TEMP) {
289 temp = prev; 289 temp = prev;
290 prev = I8K_MAX_TEMP; 290 prev = I8K_MAX_TEMP;
291 } else { 291 } else {
292 prev = temp; 292 prev = temp;
293 } 293 }
294 #endif 294 #endif
295 295
296 return temp; 296 return temp;
297 } 297 }
298 298
299 static int i8k_get_dell_signature(int req_fn) 299 static int i8k_get_dell_signature(int req_fn)
300 { 300 {
301 struct smm_regs regs = { .eax = req_fn, }; 301 struct smm_regs regs = { .eax = req_fn, };
302 int rc; 302 int rc;
303 303
304 if ((rc = i8k_smm(&regs)) < 0) 304 if ((rc = i8k_smm(&regs)) < 0)
305 return rc; 305 return rc;
306 306
307 return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; 307 return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1;
308 } 308 }
309 309
310 static int i8k_ioctl(struct inode *ip, struct file *fp, unsigned int cmd, 310 static int i8k_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
311 unsigned long arg) 311 unsigned long arg)
312 { 312 {
313 int val = 0; 313 int val = 0;
314 int speed; 314 int speed;
315 unsigned char buff[16]; 315 unsigned char buff[16];
316 int __user *argp = (int __user *)arg; 316 int __user *argp = (int __user *)arg;
317 317
318 if (!argp) 318 if (!argp)
319 return -EINVAL; 319 return -EINVAL;
320 320
321 switch (cmd) { 321 switch (cmd) {
322 case I8K_BIOS_VERSION: 322 case I8K_BIOS_VERSION:
323 val = i8k_get_bios_version(); 323 val = i8k_get_bios_version();
324 break; 324 break;
325 325
326 case I8K_MACHINE_ID: 326 case I8K_MACHINE_ID:
327 memset(buff, 0, 16); 327 memset(buff, 0, 16);
328 strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), sizeof(buff)); 328 strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), sizeof(buff));
329 break; 329 break;
330 330
331 case I8K_FN_STATUS: 331 case I8K_FN_STATUS:
332 val = i8k_get_fn_status(); 332 val = i8k_get_fn_status();
333 break; 333 break;
334 334
335 case I8K_POWER_STATUS: 335 case I8K_POWER_STATUS:
336 val = i8k_get_power_status(); 336 val = i8k_get_power_status();
337 break; 337 break;
338 338
339 case I8K_GET_TEMP: 339 case I8K_GET_TEMP:
340 val = i8k_get_temp(0); 340 val = i8k_get_temp(0);
341 break; 341 break;
342 342
343 case I8K_GET_SPEED: 343 case I8K_GET_SPEED:
344 if (copy_from_user(&val, argp, sizeof(int))) 344 if (copy_from_user(&val, argp, sizeof(int)))
345 return -EFAULT; 345 return -EFAULT;
346 346
347 val = i8k_get_fan_speed(val); 347 val = i8k_get_fan_speed(val);
348 break; 348 break;
349 349
350 case I8K_GET_FAN: 350 case I8K_GET_FAN:
351 if (copy_from_user(&val, argp, sizeof(int))) 351 if (copy_from_user(&val, argp, sizeof(int)))
352 return -EFAULT; 352 return -EFAULT;
353 353
354 val = i8k_get_fan_status(val); 354 val = i8k_get_fan_status(val);
355 break; 355 break;
356 356
357 case I8K_SET_FAN: 357 case I8K_SET_FAN:
358 if (restricted && !capable(CAP_SYS_ADMIN)) 358 if (restricted && !capable(CAP_SYS_ADMIN))
359 return -EPERM; 359 return -EPERM;
360 360
361 if (copy_from_user(&val, argp, sizeof(int))) 361 if (copy_from_user(&val, argp, sizeof(int)))
362 return -EFAULT; 362 return -EFAULT;
363 363
364 if (copy_from_user(&speed, argp + 1, sizeof(int))) 364 if (copy_from_user(&speed, argp + 1, sizeof(int)))
365 return -EFAULT; 365 return -EFAULT;
366 366
367 val = i8k_set_fan(val, speed); 367 val = i8k_set_fan(val, speed);
368 break; 368 break;
369 369
370 default: 370 default:
371 return -EINVAL; 371 return -EINVAL;
372 } 372 }
373 373
374 if (val < 0) 374 if (val < 0)
375 return val; 375 return val;
376 376
377 switch (cmd) { 377 switch (cmd) {
378 case I8K_BIOS_VERSION: 378 case I8K_BIOS_VERSION:
379 if (copy_to_user(argp, &val, 4)) 379 if (copy_to_user(argp, &val, 4))
380 return -EFAULT; 380 return -EFAULT;
381 381
382 break; 382 break;
383 case I8K_MACHINE_ID: 383 case I8K_MACHINE_ID:
384 if (copy_to_user(argp, buff, 16)) 384 if (copy_to_user(argp, buff, 16))
385 return -EFAULT; 385 return -EFAULT;
386 386
387 break; 387 break;
388 default: 388 default:
389 if (copy_to_user(argp, &val, sizeof(int))) 389 if (copy_to_user(argp, &val, sizeof(int)))
390 return -EFAULT; 390 return -EFAULT;
391 391
392 break; 392 break;
393 } 393 }
394 394
395 return 0; 395 return 0;
396 } 396 }
397 397
398 /* 398 /*
399 * Print the information for /proc/i8k. 399 * Print the information for /proc/i8k.
400 */ 400 */
401 static int i8k_proc_show(struct seq_file *seq, void *offset) 401 static int i8k_proc_show(struct seq_file *seq, void *offset)
402 { 402 {
403 int fn_key, cpu_temp, ac_power; 403 int fn_key, cpu_temp, ac_power;
404 int left_fan, right_fan, left_speed, right_speed; 404 int left_fan, right_fan, left_speed, right_speed;
405 405
406 cpu_temp = i8k_get_temp(0); /* 11100 µs */ 406 cpu_temp = i8k_get_temp(0); /* 11100 µs */
407 left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ 407 left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */
408 right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ 408 right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */
409 left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ 409 left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */
410 right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ 410 right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */
411 fn_key = i8k_get_fn_status(); /* 750 µs */ 411 fn_key = i8k_get_fn_status(); /* 750 µs */
412 if (power_status) 412 if (power_status)
413 ac_power = i8k_get_power_status(); /* 14700 µs */ 413 ac_power = i8k_get_power_status(); /* 14700 µs */
414 else 414 else
415 ac_power = -1; 415 ac_power = -1;
416 416
417 /* 417 /*
418 * Info: 418 * Info:
419 * 419 *
420 * 1) Format version (this will change if format changes) 420 * 1) Format version (this will change if format changes)
421 * 2) BIOS version 421 * 2) BIOS version
422 * 3) BIOS machine ID 422 * 3) BIOS machine ID
423 * 4) Cpu temperature 423 * 4) Cpu temperature
424 * 5) Left fan status 424 * 5) Left fan status
425 * 6) Right fan status 425 * 6) Right fan status
426 * 7) Left fan speed 426 * 7) Left fan speed
427 * 8) Right fan speed 427 * 8) Right fan speed
428 * 9) AC power 428 * 9) AC power
429 * 10) Fn Key status 429 * 10) Fn Key status
430 */ 430 */
431 return seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", 431 return seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n",
432 I8K_PROC_FMT, 432 I8K_PROC_FMT,
433 bios_version, 433 bios_version,
434 i8k_get_dmi_data(DMI_PRODUCT_SERIAL), 434 i8k_get_dmi_data(DMI_PRODUCT_SERIAL),
435 cpu_temp, 435 cpu_temp,
436 left_fan, right_fan, left_speed, right_speed, 436 left_fan, right_fan, left_speed, right_speed,
437 ac_power, fn_key); 437 ac_power, fn_key);
438 } 438 }
439 439
440 static int i8k_open_fs(struct inode *inode, struct file *file) 440 static int i8k_open_fs(struct inode *inode, struct file *file)
441 { 441 {
442 return single_open(file, i8k_proc_show, NULL); 442 return single_open(file, i8k_proc_show, NULL);
443 } 443 }
444 444
445 static struct dmi_system_id __initdata i8k_dmi_table[] = { 445 static struct dmi_system_id __initdata i8k_dmi_table[] = {
446 { 446 {
447 .ident = "Dell Inspiron", 447 .ident = "Dell Inspiron",
448 .matches = { 448 .matches = {
449 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), 449 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"),
450 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), 450 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"),
451 }, 451 },
452 }, 452 },
453 { 453 {
454 .ident = "Dell Latitude", 454 .ident = "Dell Latitude",
455 .matches = { 455 .matches = {
456 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), 456 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"),
457 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), 457 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"),
458 }, 458 },
459 }, 459 },
460 { 460 {
461 .ident = "Dell Inspiron 2", 461 .ident = "Dell Inspiron 2",
462 .matches = { 462 .matches = {
463 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 463 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
464 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), 464 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"),
465 }, 465 },
466 }, 466 },
467 { 467 {
468 .ident = "Dell Latitude 2", 468 .ident = "Dell Latitude 2",
469 .matches = { 469 .matches = {
470 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 470 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
471 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), 471 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"),
472 }, 472 },
473 }, 473 },
474 { /* UK Inspiron 6400 */ 474 { /* UK Inspiron 6400 */
475 .ident = "Dell Inspiron 3", 475 .ident = "Dell Inspiron 3",
476 .matches = { 476 .matches = {
477 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 477 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
478 DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), 478 DMI_MATCH(DMI_PRODUCT_NAME, "MM061"),
479 }, 479 },
480 }, 480 },
481 { 481 {
482 .ident = "Dell Inspiron 3", 482 .ident = "Dell Inspiron 3",
483 .matches = { 483 .matches = {
484 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 484 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
485 DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), 485 DMI_MATCH(DMI_PRODUCT_NAME, "MP061"),
486 }, 486 },
487 }, 487 },
488 { } 488 {
489 .ident = "Dell Precision",
490 .matches = {
491 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
492 DMI_MATCH(DMI_PRODUCT_NAME, "Precision"),
493 },
494 },
495 {
496 .ident = "Dell Vostro",
497 .matches = {
498 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
499 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"),
500 },
501 },
502 { }
489 }; 503 };
490 504
491 /* 505 /*
492 * Probe for the presence of a supported laptop. 506 * Probe for the presence of a supported laptop.
493 */ 507 */
494 static int __init i8k_probe(void) 508 static int __init i8k_probe(void)
495 { 509 {
496 char buff[4]; 510 char buff[4];
497 int version; 511 int version;
498 512
499 /* 513 /*
500 * Get DMI information 514 * Get DMI information
501 */ 515 */
502 if (!dmi_check_system(i8k_dmi_table)) { 516 if (!dmi_check_system(i8k_dmi_table)) {
503 if (!ignore_dmi && !force) 517 if (!ignore_dmi && !force)
504 return -ENODEV; 518 return -ENODEV;
505 519
506 printk(KERN_INFO "i8k: not running on a supported Dell system.\n"); 520 printk(KERN_INFO "i8k: not running on a supported Dell system.\n");
507 printk(KERN_INFO "i8k: vendor=%s, model=%s, version=%s\n", 521 printk(KERN_INFO "i8k: vendor=%s, model=%s, version=%s\n",
508 i8k_get_dmi_data(DMI_SYS_VENDOR), 522 i8k_get_dmi_data(DMI_SYS_VENDOR),
509 i8k_get_dmi_data(DMI_PRODUCT_NAME), 523 i8k_get_dmi_data(DMI_PRODUCT_NAME),
510 i8k_get_dmi_data(DMI_BIOS_VERSION)); 524 i8k_get_dmi_data(DMI_BIOS_VERSION));
511 } 525 }
512 526
513 strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), sizeof(bios_version)); 527 strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), sizeof(bios_version));
514 528
515 /* 529 /*
516 * Get SMM Dell signature 530 * Get SMM Dell signature
517 */ 531 */
518 if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && 532 if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) &&
519 i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { 533 i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) {
520 printk(KERN_ERR "i8k: unable to get SMM Dell signature\n"); 534 printk(KERN_ERR "i8k: unable to get SMM Dell signature\n");
521 if (!force) 535 if (!force)
522 return -ENODEV; 536 return -ENODEV;
523 } 537 }
524 538
525 /* 539 /*
526 * Get SMM BIOS version. 540 * Get SMM BIOS version.
527 */ 541 */
528 version = i8k_get_bios_version(); 542 version = i8k_get_bios_version();
529 if (version <= 0) { 543 if (version <= 0) {
530 printk(KERN_WARNING "i8k: unable to get SMM BIOS version\n"); 544 printk(KERN_WARNING "i8k: unable to get SMM BIOS version\n");
531 } else { 545 } else {
532 buff[0] = (version >> 16) & 0xff; 546 buff[0] = (version >> 16) & 0xff;
533 buff[1] = (version >> 8) & 0xff; 547 buff[1] = (version >> 8) & 0xff;
534 buff[2] = (version) & 0xff; 548 buff[2] = (version) & 0xff;
535 buff[3] = '\0'; 549 buff[3] = '\0';
536 /* 550 /*
537 * If DMI BIOS version is unknown use SMM BIOS version. 551 * If DMI BIOS version is unknown use SMM BIOS version.
538 */ 552 */
539 if (!dmi_get_system_info(DMI_BIOS_VERSION)) 553 if (!dmi_get_system_info(DMI_BIOS_VERSION))
540 strlcpy(bios_version, buff, sizeof(bios_version)); 554 strlcpy(bios_version, buff, sizeof(bios_version));
541 555
542 /* 556 /*
543 * Check if the two versions match. 557 * Check if the two versions match.
544 */ 558 */
545 if (strncmp(buff, bios_version, sizeof(bios_version)) != 0) 559 if (strncmp(buff, bios_version, sizeof(bios_version)) != 0)
546 printk(KERN_WARNING "i8k: BIOS version mismatch: %s != %s\n", 560 printk(KERN_WARNING "i8k: BIOS version mismatch: %s != %s\n",
547 buff, bios_version); 561 buff, bios_version);
548 } 562 }
549 563
550 return 0; 564 return 0;
551 } 565 }
552 566
553 static int __init i8k_init(void) 567 static int __init i8k_init(void)
554 { 568 {
555 struct proc_dir_entry *proc_i8k; 569 struct proc_dir_entry *proc_i8k;
556 570
557 /* Are we running on an supported laptop? */ 571 /* Are we running on an supported laptop? */
558 if (i8k_probe()) 572 if (i8k_probe())
559 return -ENODEV; 573 return -ENODEV;
560 574
561 /* Register the proc entry */ 575 /* Register the proc entry */
562 proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); 576 proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops);
563 if (!proc_i8k) 577 if (!proc_i8k)
564 return -ENOENT; 578 return -ENOENT;
565 579
566 printk(KERN_INFO 580 printk(KERN_INFO
567 "Dell laptop SMM driver v%s Massimo Dal Zotto (dz@debian.org)\n", 581 "Dell laptop SMM driver v%s Massimo Dal Zotto (dz@debian.org)\n",
568 I8K_VERSION); 582 I8K_VERSION);
569 583
570 return 0; 584 return 0;
571 } 585 }
572 586
573 static void __exit i8k_exit(void) 587 static void __exit i8k_exit(void)
574 { 588 {
575 remove_proc_entry("i8k", NULL); 589 remove_proc_entry("i8k", NULL);
576 } 590 }
577 591
578 module_init(i8k_init); 592 module_init(i8k_init);
579 module_exit(i8k_exit); 593 module_exit(i8k_exit);
580 594