1/* 2 * i8k.c -- Linux driver for accessing the SMM BIOS on Dell laptops. 3 * 4 * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> 5 * 6 * Hwmon integration: 7 * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> 8 * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> 9 * Copyright (C) 2014 Pali Rohár <pali.rohar@gmail.com> 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the 13 * Free Software Foundation; either version 2, or (at your option) any 14 * later version. 15 * 16 * This program is distributed in the hope that it will be useful, but 17 * WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 */ 21 22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 23 24#include <linux/delay.h> 25#include <linux/module.h> 26#include <linux/types.h> 27#include <linux/init.h> 28#include <linux/proc_fs.h> 29#include <linux/seq_file.h> 30#include <linux/dmi.h> 31#include <linux/capability.h> 32#include <linux/mutex.h> 33#include <linux/hwmon.h> 34#include <linux/hwmon-sysfs.h> 35#include <linux/uaccess.h> 36#include <linux/io.h> 37#include <linux/sched.h> 38 39#include <linux/i8k.h> 40 41#define I8K_SMM_FN_STATUS 0x0025 42#define I8K_SMM_POWER_STATUS 0x0069 43#define I8K_SMM_SET_FAN 0x01a3 44#define I8K_SMM_GET_FAN 0x00a3 45#define I8K_SMM_GET_SPEED 0x02a3 46#define I8K_SMM_GET_FAN_TYPE 0x03a3 47#define I8K_SMM_GET_NOM_SPEED 0x04a3 48#define I8K_SMM_GET_TEMP 0x10a3 49#define I8K_SMM_GET_TEMP_TYPE 0x11a3 50#define I8K_SMM_GET_DELL_SIG1 0xfea3 51#define I8K_SMM_GET_DELL_SIG2 0xffa3 52 53#define I8K_FAN_MULT 30 54#define I8K_FAN_MAX_RPM 30000 55#define I8K_MAX_TEMP 127 56 57#define I8K_FN_NONE 0x00 58#define I8K_FN_UP 0x01 59#define I8K_FN_DOWN 0x02 60#define I8K_FN_MUTE 0x04 61#define I8K_FN_MASK 0x07 62#define I8K_FN_SHIFT 8 63 64#define I8K_POWER_AC 0x05 65#define I8K_POWER_BATTERY 0x01 66 67static DEFINE_MUTEX(i8k_mutex); 68static char bios_version[4]; 69static struct device *i8k_hwmon_dev; 70static u32 i8k_hwmon_flags; 71static uint i8k_fan_mult = I8K_FAN_MULT; 72static uint i8k_pwm_mult; 73static uint i8k_fan_max = I8K_FAN_HIGH; 74 75#define I8K_HWMON_HAVE_TEMP1 (1 << 0) 76#define I8K_HWMON_HAVE_TEMP2 (1 << 1) 77#define I8K_HWMON_HAVE_TEMP3 (1 << 2) 78#define I8K_HWMON_HAVE_TEMP4 (1 << 3) 79#define I8K_HWMON_HAVE_FAN1 (1 << 4) 80#define I8K_HWMON_HAVE_FAN2 (1 << 5) 81 82MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); 83MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); 84MODULE_LICENSE("GPL"); 85 86static bool force; 87module_param(force, bool, 0); 88MODULE_PARM_DESC(force, "Force loading without checking for supported models"); 89 90static bool ignore_dmi; 91module_param(ignore_dmi, bool, 0); 92MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); 93 94static bool restricted; 95module_param(restricted, bool, 0); 96MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); 97 98static bool power_status; 99module_param(power_status, bool, 0600); 100MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); 101 102static uint fan_mult; 103module_param(fan_mult, uint, 0); 104MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); 105 106static uint fan_max; 107module_param(fan_max, uint, 0); 108MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); 109 110static int i8k_open_fs(struct inode *inode, struct file *file); 111static long i8k_ioctl(struct file *, unsigned int, unsigned long); 112 113static const struct file_operations i8k_fops = { 114 .owner = THIS_MODULE, 115 .open = i8k_open_fs, 116 .read = seq_read, 117 .llseek = seq_lseek, 118 .release = single_release, 119 .unlocked_ioctl = i8k_ioctl, 120}; 121 122struct smm_regs { 123 unsigned int eax; 124 unsigned int ebx __packed; 125 unsigned int ecx __packed; 126 unsigned int edx __packed; 127 unsigned int esi __packed; 128 unsigned int edi __packed; 129}; 130 131static inline const char *i8k_get_dmi_data(int field) 132{ 133 const char *dmi_data = dmi_get_system_info(field); 134 135 return dmi_data && *dmi_data ? dmi_data : "?"; 136} 137 138/* 139 * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. 140 */ 141static int i8k_smm(struct smm_regs *regs) 142{ 143 int rc; 144 int eax = regs->eax; 145 cpumask_var_t old_mask; 146 147 /* SMM requires CPU 0 */ 148 if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) 149 return -ENOMEM; 150 cpumask_copy(old_mask, ¤t->cpus_allowed); 151 rc = set_cpus_allowed_ptr(current, cpumask_of(0)); 152 if (rc) 153 goto out; 154 if (smp_processor_id() != 0) { 155 rc = -EBUSY; 156 goto out; 157 } 158 159#if defined(CONFIG_X86_64) 160 asm volatile("pushq %%rax\n\t" 161 "movl 0(%%rax),%%edx\n\t" 162 "pushq %%rdx\n\t" 163 "movl 4(%%rax),%%ebx\n\t" 164 "movl 8(%%rax),%%ecx\n\t" 165 "movl 12(%%rax),%%edx\n\t" 166 "movl 16(%%rax),%%esi\n\t" 167 "movl 20(%%rax),%%edi\n\t" 168 "popq %%rax\n\t" 169 "out %%al,$0xb2\n\t" 170 "out %%al,$0x84\n\t" 171 "xchgq %%rax,(%%rsp)\n\t" 172 "movl %%ebx,4(%%rax)\n\t" 173 "movl %%ecx,8(%%rax)\n\t" 174 "movl %%edx,12(%%rax)\n\t" 175 "movl %%esi,16(%%rax)\n\t" 176 "movl %%edi,20(%%rax)\n\t" 177 "popq %%rdx\n\t" 178 "movl %%edx,0(%%rax)\n\t" 179 "pushfq\n\t" 180 "popq %%rax\n\t" 181 "andl $1,%%eax\n" 182 : "=a"(rc) 183 : "a"(regs) 184 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); 185#else 186 asm volatile("pushl %%eax\n\t" 187 "movl 0(%%eax),%%edx\n\t" 188 "push %%edx\n\t" 189 "movl 4(%%eax),%%ebx\n\t" 190 "movl 8(%%eax),%%ecx\n\t" 191 "movl 12(%%eax),%%edx\n\t" 192 "movl 16(%%eax),%%esi\n\t" 193 "movl 20(%%eax),%%edi\n\t" 194 "popl %%eax\n\t" 195 "out %%al,$0xb2\n\t" 196 "out %%al,$0x84\n\t" 197 "xchgl %%eax,(%%esp)\n\t" 198 "movl %%ebx,4(%%eax)\n\t" 199 "movl %%ecx,8(%%eax)\n\t" 200 "movl %%edx,12(%%eax)\n\t" 201 "movl %%esi,16(%%eax)\n\t" 202 "movl %%edi,20(%%eax)\n\t" 203 "popl %%edx\n\t" 204 "movl %%edx,0(%%eax)\n\t" 205 "lahf\n\t" 206 "shrl $8,%%eax\n\t" 207 "andl $1,%%eax\n" 208 : "=a"(rc) 209 : "a"(regs) 210 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); 211#endif 212 if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) 213 rc = -EINVAL; 214 215out: 216 set_cpus_allowed_ptr(current, old_mask); 217 free_cpumask_var(old_mask); 218 return rc; 219} 220 221/* 222 * Read the Fn key status. 223 */ 224static int i8k_get_fn_status(void) 225{ 226 struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; 227 int rc; 228 229 rc = i8k_smm(®s); 230 if (rc < 0) 231 return rc; 232 233 switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { 234 case I8K_FN_UP: 235 return I8K_VOL_UP; 236 case I8K_FN_DOWN: 237 return I8K_VOL_DOWN; 238 case I8K_FN_MUTE: 239 return I8K_VOL_MUTE; 240 default: 241 return 0; 242 } 243} 244 245/* 246 * Read the power status. 247 */ 248static int i8k_get_power_status(void) 249{ 250 struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; 251 int rc; 252 253 rc = i8k_smm(®s); 254 if (rc < 0) 255 return rc; 256 257 return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; 258} 259 260/* 261 * Read the fan status. 262 */ 263static int i8k_get_fan_status(int fan) 264{ 265 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; 266 267 regs.ebx = fan & 0xff; 268 return i8k_smm(®s) ? : regs.eax & 0xff; 269} 270 271/* 272 * Read the fan speed in RPM. 273 */ 274static int i8k_get_fan_speed(int fan) 275{ 276 struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; 277 278 regs.ebx = fan & 0xff; 279 return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; 280} 281 282/* 283 * Read the fan type. 284 */ 285static int i8k_get_fan_type(int fan) 286{ 287 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; 288 289 regs.ebx = fan & 0xff; 290 return i8k_smm(®s) ? : regs.eax & 0xff; 291} 292 293/* 294 * Read the fan nominal rpm for specific fan speed. 295 */ 296static int i8k_get_fan_nominal_speed(int fan, int speed) 297{ 298 struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; 299 300 regs.ebx = (fan & 0xff) | (speed << 8); 301 return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; 302} 303 304/* 305 * Set the fan speed (off, low, high). Returns the new fan status. 306 */ 307static int i8k_set_fan(int fan, int speed) 308{ 309 struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; 310 311 speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); 312 regs.ebx = (fan & 0xff) | (speed << 8); 313 314 return i8k_smm(®s) ? : i8k_get_fan_status(fan); 315} 316 317static int i8k_get_temp_type(int sensor) 318{ 319 struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; 320 321 regs.ebx = sensor & 0xff; 322 return i8k_smm(®s) ? : regs.eax & 0xff; 323} 324 325/* 326 * Read the cpu temperature. 327 */ 328static int _i8k_get_temp(int sensor) 329{ 330 struct smm_regs regs = { 331 .eax = I8K_SMM_GET_TEMP, 332 .ebx = sensor & 0xff, 333 }; 334 335 return i8k_smm(®s) ? : regs.eax & 0xff; 336} 337 338static int i8k_get_temp(int sensor) 339{ 340 int temp = _i8k_get_temp(sensor); 341 342 /* 343 * Sometimes the temperature sensor returns 0x99, which is out of range. 344 * In this case we retry (once) before returning an error. 345 # 1003655137 00000058 00005a4b 346 # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees 347 # 1003655139 00000054 00005c52 348 */ 349 if (temp == 0x99) { 350 msleep(100); 351 temp = _i8k_get_temp(sensor); 352 } 353 /* 354 * Return -ENODATA for all invalid temperatures. 355 * 356 * Known instances are the 0x99 value as seen above as well as 357 * 0xc1 (193), which may be returned when trying to read the GPU 358 * temperature if the system supports a GPU and it is currently 359 * turned off. 360 */ 361 if (temp > I8K_MAX_TEMP) 362 return -ENODATA; 363 364 return temp; 365} 366 367static int i8k_get_dell_signature(int req_fn) 368{ 369 struct smm_regs regs = { .eax = req_fn, }; 370 int rc; 371 372 rc = i8k_smm(®s); 373 if (rc < 0) 374 return rc; 375 376 return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; 377} 378 379static int 380i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) 381{ 382 int val = 0; 383 int speed; 384 unsigned char buff[16]; 385 int __user *argp = (int __user *)arg; 386 387 if (!argp) 388 return -EINVAL; 389 390 switch (cmd) { 391 case I8K_BIOS_VERSION: 392 val = (bios_version[0] << 16) | 393 (bios_version[1] << 8) | bios_version[2]; 394 break; 395 396 case I8K_MACHINE_ID: 397 memset(buff, 0, 16); 398 strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), 399 sizeof(buff)); 400 break; 401 402 case I8K_FN_STATUS: 403 val = i8k_get_fn_status(); 404 break; 405 406 case I8K_POWER_STATUS: 407 val = i8k_get_power_status(); 408 break; 409 410 case I8K_GET_TEMP: 411 val = i8k_get_temp(0); 412 break; 413 414 case I8K_GET_SPEED: 415 if (copy_from_user(&val, argp, sizeof(int))) 416 return -EFAULT; 417 418 val = i8k_get_fan_speed(val); 419 break; 420 421 case I8K_GET_FAN: 422 if (copy_from_user(&val, argp, sizeof(int))) 423 return -EFAULT; 424 425 val = i8k_get_fan_status(val); 426 break; 427 428 case I8K_SET_FAN: 429 if (restricted && !capable(CAP_SYS_ADMIN)) 430 return -EPERM; 431 432 if (copy_from_user(&val, argp, sizeof(int))) 433 return -EFAULT; 434 435 if (copy_from_user(&speed, argp + 1, sizeof(int))) 436 return -EFAULT; 437 438 val = i8k_set_fan(val, speed); 439 break; 440 441 default: 442 return -EINVAL; 443 } 444 445 if (val < 0) 446 return val; 447 448 switch (cmd) { 449 case I8K_BIOS_VERSION: 450 if (copy_to_user(argp, &val, 4)) 451 return -EFAULT; 452 453 break; 454 case I8K_MACHINE_ID: 455 if (copy_to_user(argp, buff, 16)) 456 return -EFAULT; 457 458 break; 459 default: 460 if (copy_to_user(argp, &val, sizeof(int))) 461 return -EFAULT; 462 463 break; 464 } 465 466 return 0; 467} 468 469static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) 470{ 471 long ret; 472 473 mutex_lock(&i8k_mutex); 474 ret = i8k_ioctl_unlocked(fp, cmd, arg); 475 mutex_unlock(&i8k_mutex); 476 477 return ret; 478} 479 480/* 481 * Print the information for /proc/i8k. 482 */ 483static int i8k_proc_show(struct seq_file *seq, void *offset) 484{ 485 int fn_key, cpu_temp, ac_power; 486 int left_fan, right_fan, left_speed, right_speed; 487 488 cpu_temp = i8k_get_temp(0); /* 11100 µs */ 489 left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ 490 right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ 491 left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ 492 right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ 493 fn_key = i8k_get_fn_status(); /* 750 µs */ 494 if (power_status) 495 ac_power = i8k_get_power_status(); /* 14700 µs */ 496 else 497 ac_power = -1; 498 499 /* 500 * Info: 501 * 502 * 1) Format version (this will change if format changes) 503 * 2) BIOS version 504 * 3) BIOS machine ID 505 * 4) Cpu temperature 506 * 5) Left fan status 507 * 6) Right fan status 508 * 7) Left fan speed 509 * 8) Right fan speed 510 * 9) AC power 511 * 10) Fn Key status 512 */ 513 seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", 514 I8K_PROC_FMT, 515 bios_version, 516 i8k_get_dmi_data(DMI_PRODUCT_SERIAL), 517 cpu_temp, 518 left_fan, right_fan, left_speed, right_speed, 519 ac_power, fn_key); 520 521 return 0; 522} 523 524static int i8k_open_fs(struct inode *inode, struct file *file) 525{ 526 return single_open(file, i8k_proc_show, NULL); 527} 528 529 530/* 531 * Hwmon interface 532 */ 533 534static ssize_t i8k_hwmon_show_temp_label(struct device *dev, 535 struct device_attribute *devattr, 536 char *buf) 537{ 538 static const char * const labels[] = { 539 "CPU", 540 "GPU", 541 "SODIMM", 542 "Other", 543 "Ambient", 544 "Other", 545 }; 546 int index = to_sensor_dev_attr(devattr)->index; 547 int type; 548 549 type = i8k_get_temp_type(index); 550 if (type < 0) 551 return type; 552 if (type >= ARRAY_SIZE(labels)) 553 type = ARRAY_SIZE(labels) - 1; 554 return sprintf(buf, "%s\n", labels[type]); 555} 556 557static ssize_t i8k_hwmon_show_temp(struct device *dev, 558 struct device_attribute *devattr, 559 char *buf) 560{ 561 int index = to_sensor_dev_attr(devattr)->index; 562 int temp; 563 564 temp = i8k_get_temp(index); 565 if (temp < 0) 566 return temp; 567 return sprintf(buf, "%d\n", temp * 1000); 568} 569 570static ssize_t i8k_hwmon_show_fan_label(struct device *dev, 571 struct device_attribute *devattr, 572 char *buf) 573{ 574 static const char * const labels[] = { 575 "Processor Fan", 576 "Motherboard Fan", 577 "Video Fan", 578 "Power Supply Fan", 579 "Chipset Fan", 580 "Other Fan", 581 }; 582 int index = to_sensor_dev_attr(devattr)->index; 583 bool dock = false; 584 int type; 585 586 type = i8k_get_fan_type(index); 587 if (type < 0) 588 return type; 589 590 if (type & 0x10) { 591 dock = true; 592 type &= 0x0F; 593 } 594 595 if (type >= ARRAY_SIZE(labels)) 596 type = (ARRAY_SIZE(labels) - 1); 597 598 return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); 599} 600 601static ssize_t i8k_hwmon_show_fan(struct device *dev, 602 struct device_attribute *devattr, 603 char *buf) 604{ 605 int index = to_sensor_dev_attr(devattr)->index; 606 int fan_speed; 607 608 fan_speed = i8k_get_fan_speed(index); 609 if (fan_speed < 0) 610 return fan_speed; 611 return sprintf(buf, "%d\n", fan_speed); 612} 613 614static ssize_t i8k_hwmon_show_pwm(struct device *dev, 615 struct device_attribute *devattr, 616 char *buf) 617{ 618 int index = to_sensor_dev_attr(devattr)->index; 619 int status; 620 621 status = i8k_get_fan_status(index); 622 if (status < 0) 623 return -EIO; 624 return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); 625} 626 627static ssize_t i8k_hwmon_set_pwm(struct device *dev, 628 struct device_attribute *attr, 629 const char *buf, size_t count) 630{ 631 int index = to_sensor_dev_attr(attr)->index; 632 unsigned long val; 633 int err; 634 635 err = kstrtoul(buf, 10, &val); 636 if (err) 637 return err; 638 val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); 639 640 mutex_lock(&i8k_mutex); 641 err = i8k_set_fan(index, val); 642 mutex_unlock(&i8k_mutex); 643 644 return err < 0 ? -EIO : count; 645} 646 647static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); 648static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, 649 0); 650static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); 651static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, 652 1); 653static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); 654static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, 655 2); 656static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); 657static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, 658 3); 659static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); 660static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, 661 0); 662static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, 663 i8k_hwmon_set_pwm, 0); 664static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 665 1); 666static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, 667 1); 668static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, 669 i8k_hwmon_set_pwm, 1); 670 671static struct attribute *i8k_attrs[] = { 672 &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ 673 &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ 674 &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ 675 &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ 676 &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ 677 &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ 678 &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ 679 &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ 680 &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ 681 &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ 682 &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ 683 &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ 684 &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ 685 &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ 686 NULL 687}; 688 689static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, 690 int index) 691{ 692 if (index >= 0 && index <= 1 && 693 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) 694 return 0; 695 if (index >= 2 && index <= 3 && 696 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) 697 return 0; 698 if (index >= 4 && index <= 5 && 699 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) 700 return 0; 701 if (index >= 6 && index <= 7 && 702 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) 703 return 0; 704 if (index >= 8 && index <= 10 && 705 !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) 706 return 0; 707 if (index >= 11 && index <= 13 && 708 !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) 709 return 0; 710 711 return attr->mode; 712} 713 714static const struct attribute_group i8k_group = { 715 .attrs = i8k_attrs, 716 .is_visible = i8k_is_visible, 717}; 718__ATTRIBUTE_GROUPS(i8k); 719 720static int __init i8k_init_hwmon(void) 721{ 722 int err; 723 724 i8k_hwmon_flags = 0; 725 726 /* CPU temperature attributes, if temperature type is OK */ 727 err = i8k_get_temp_type(0); 728 if (err >= 0) 729 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; 730 /* check for additional temperature sensors */ 731 err = i8k_get_temp_type(1); 732 if (err >= 0) 733 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; 734 err = i8k_get_temp_type(2); 735 if (err >= 0) 736 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; 737 err = i8k_get_temp_type(3); 738 if (err >= 0) 739 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; 740 741 /* First fan attributes, if fan type is OK */ 742 err = i8k_get_fan_type(0); 743 if (err >= 0) 744 i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; 745 746 /* Second fan attributes, if fan type is OK */ 747 err = i8k_get_fan_type(1); 748 if (err >= 0) 749 i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; 750 751 i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, 752 i8k_groups); 753 if (IS_ERR(i8k_hwmon_dev)) { 754 err = PTR_ERR(i8k_hwmon_dev); 755 i8k_hwmon_dev = NULL; 756 pr_err("hwmon registration failed (%d)\n", err); 757 return err; 758 } 759 return 0; 760} 761 762struct i8k_config_data { 763 uint fan_mult; 764 uint fan_max; 765}; 766 767enum i8k_configs { 768 DELL_LATITUDE_D520, 769 DELL_PRECISION_490, 770 DELL_STUDIO, 771 DELL_XPS, 772}; 773 774static const struct i8k_config_data i8k_config_data[] = { 775 [DELL_LATITUDE_D520] = { 776 .fan_mult = 1, 777 .fan_max = I8K_FAN_TURBO, 778 }, 779 [DELL_PRECISION_490] = { 780 .fan_mult = 1, 781 .fan_max = I8K_FAN_TURBO, 782 }, 783 [DELL_STUDIO] = { 784 .fan_mult = 1, 785 .fan_max = I8K_FAN_HIGH, 786 }, 787 [DELL_XPS] = { 788 .fan_mult = 1, 789 .fan_max = I8K_FAN_HIGH, 790 }, 791}; 792 793static struct dmi_system_id i8k_dmi_table[] __initdata = { 794 { 795 .ident = "Dell Inspiron", 796 .matches = { 797 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), 798 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), 799 }, 800 }, 801 { 802 .ident = "Dell Latitude", 803 .matches = { 804 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), 805 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), 806 }, 807 }, 808 { 809 .ident = "Dell Inspiron 2", 810 .matches = { 811 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 812 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), 813 }, 814 }, 815 { 816 .ident = "Dell Latitude D520", 817 .matches = { 818 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 819 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), 820 }, 821 .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], 822 }, 823 { 824 .ident = "Dell Latitude 2", 825 .matches = { 826 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 827 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), 828 }, 829 }, 830 { /* UK Inspiron 6400 */ 831 .ident = "Dell Inspiron 3", 832 .matches = { 833 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 834 DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), 835 }, 836 }, 837 { 838 .ident = "Dell Inspiron 3", 839 .matches = { 840 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 841 DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), 842 }, 843 }, 844 { 845 .ident = "Dell Precision 490", 846 .matches = { 847 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 848 DMI_MATCH(DMI_PRODUCT_NAME, 849 "Precision WorkStation 490"), 850 }, 851 .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], 852 }, 853 { 854 .ident = "Dell Precision", 855 .matches = { 856 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 857 DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), 858 }, 859 }, 860 { 861 .ident = "Dell Vostro", 862 .matches = { 863 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 864 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), 865 }, 866 }, 867 { 868 .ident = "Dell XPS421", 869 .matches = { 870 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 871 DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), 872 }, 873 }, 874 { 875 .ident = "Dell Studio", 876 .matches = { 877 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 878 DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), 879 }, 880 .driver_data = (void *)&i8k_config_data[DELL_STUDIO], 881 }, 882 { 883 .ident = "Dell XPS 13", 884 .matches = { 885 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 886 DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), 887 }, 888 .driver_data = (void *)&i8k_config_data[DELL_XPS], 889 }, 890 { 891 .ident = "Dell XPS M140", 892 .matches = { 893 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 894 DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), 895 }, 896 .driver_data = (void *)&i8k_config_data[DELL_XPS], 897 }, 898 { } 899}; 900 901MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); 902 903static struct dmi_system_id i8k_blacklist_dmi_table[] __initdata = { 904 { 905 /* 906 * CPU fan speed going up and down on Dell Studio XPS 8100 907 * for unknown reasons. 908 */ 909 .ident = "Dell Studio XPS 8100", 910 .matches = { 911 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 912 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Studio XPS 8100"), 913 }, 914 }, 915 { } 916}; 917 918/* 919 * Probe for the presence of a supported laptop. 920 */ 921static int __init i8k_probe(void) 922{ 923 const struct dmi_system_id *id; 924 int fan, ret; 925 926 /* 927 * Get DMI information 928 */ 929 if (!dmi_check_system(i8k_dmi_table) || 930 dmi_check_system(i8k_blacklist_dmi_table)) { 931 if (!ignore_dmi && !force) 932 return -ENODEV; 933 934 pr_info("not running on a supported Dell system.\n"); 935 pr_info("vendor=%s, model=%s, version=%s\n", 936 i8k_get_dmi_data(DMI_SYS_VENDOR), 937 i8k_get_dmi_data(DMI_PRODUCT_NAME), 938 i8k_get_dmi_data(DMI_BIOS_VERSION)); 939 } 940 941 strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), 942 sizeof(bios_version)); 943 944 /* 945 * Get SMM Dell signature 946 */ 947 if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && 948 i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { 949 pr_err("unable to get SMM Dell signature\n"); 950 if (!force) 951 return -ENODEV; 952 } 953 954 /* 955 * Set fan multiplier and maximal fan speed from dmi config 956 * Values specified in module parameters override values from dmi 957 */ 958 id = dmi_first_match(i8k_dmi_table); 959 if (id && id->driver_data) { 960 const struct i8k_config_data *conf = id->driver_data; 961 if (!fan_mult && conf->fan_mult) 962 fan_mult = conf->fan_mult; 963 if (!fan_max && conf->fan_max) 964 fan_max = conf->fan_max; 965 } 966 967 i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ 968 i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); 969 970 if (!fan_mult) { 971 /* 972 * Autodetect fan multiplier based on nominal rpm 973 * If fan reports rpm value too high then set multiplier to 1 974 */ 975 for (fan = 0; fan < 2; ++fan) { 976 ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); 977 if (ret < 0) 978 continue; 979 if (ret > I8K_FAN_MAX_RPM) 980 i8k_fan_mult = 1; 981 break; 982 } 983 } else { 984 /* Fan multiplier was specified in module param or in dmi */ 985 i8k_fan_mult = fan_mult; 986 } 987 988 return 0; 989} 990 991static int __init i8k_init(void) 992{ 993 struct proc_dir_entry *proc_i8k; 994 int err; 995 996 /* Are we running on an supported laptop? */ 997 if (i8k_probe()) 998 return -ENODEV; 999 1000 /* Register the proc entry */ 1001 proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); 1002 if (!proc_i8k) 1003 return -ENOENT; 1004 1005 err = i8k_init_hwmon(); 1006 if (err) 1007 goto exit_remove_proc; 1008 1009 return 0; 1010 1011 exit_remove_proc: 1012 remove_proc_entry("i8k", NULL); 1013 return err; 1014} 1015 1016static void __exit i8k_exit(void) 1017{ 1018 hwmon_device_unregister(i8k_hwmon_dev); 1019 remove_proc_entry("i8k", NULL); 1020} 1021 1022module_init(i8k_init); 1023module_exit(i8k_exit); 1024