2 it87.c - Part of lm_sensors, Linux kernel modules for hardware
5 The IT8705F is an LPC-based Super I/O part that contains UARTs, a
6 parallel port, an IR port, a MIDI port, a floppy controller, etc., in
7 addition to an Environment Controller (Enhanced Hardware Monitor and
10 This driver supports only the Environment Controller in the IT8705F and
11 similar parts. The other devices are supported by different drivers.
13 Supports: IT8705F Super I/O chip w/LPC interface
14 IT8712F Super I/O chip w/LPC interface
15 IT8716F Super I/O chip w/LPC interface
16 IT8718F Super I/O chip w/LPC interface
17 IT8720F Super I/O chip w/LPC interface
18 IT8726F Super I/O chip w/LPC interface
19 Sis950 A clone of the IT8705F
21 Copyright (C) 2001 Chris Gauthron
22 Copyright (C) 2005-2007 Jean Delvare <khali@linux-fr.org>
24 This program is free software; you can redistribute it and/or modify
25 it under the terms of the GNU General Public License as published by
26 the Free Software Foundation; either version 2 of the License, or
27 (at your option) any later version.
29 This program is distributed in the hope that it will be useful,
30 but WITHOUT ANY WARRANTY; without even the implied warranty of
31 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 GNU General Public License for more details.
34 You should have received a copy of the GNU General Public License
35 along with this program; if not, write to the Free Software
36 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
39 #include <linux/module.h>
40 #include <linux/init.h>
41 #include <linux/slab.h>
42 #include <linux/jiffies.h>
43 #include <linux/platform_device.h>
44 #include <linux/hwmon.h>
45 #include <linux/hwmon-sysfs.h>
46 #include <linux/hwmon-vid.h>
47 #include <linux/err.h>
48 #include <linux/mutex.h>
49 #include <linux/sysfs.h>
50 #include <linux/string.h>
51 #include <linux/dmi.h>
52 #include <linux/acpi.h>
55 #define DRVNAME "it87"
57 enum chips { it87, it8712, it8716, it8718, it8720 };
59 static unsigned short force_id;
60 module_param(force_id, ushort, 0);
61 MODULE_PARM_DESC(force_id, "Override the detected device ID");
63 static struct platform_device *pdev;
65 #define REG 0x2e /* The register to read/write */
66 #define DEV 0x07 /* Register: Logical device select */
67 #define VAL 0x2f /* The value to read/write */
68 #define PME 0x04 /* The device with the fan registers in it */
70 /* The device with the IT8718F/IT8720F VID value in it */
73 #define DEVID 0x20 /* Register: Device ID */
74 #define DEVREV 0x22 /* Register: Device Revision */
83 static int superio_inw(int reg)
94 superio_select(int ldn)
116 /* Logical device 4 registers */
117 #define IT8712F_DEVID 0x8712
118 #define IT8705F_DEVID 0x8705
119 #define IT8716F_DEVID 0x8716
120 #define IT8718F_DEVID 0x8718
121 #define IT8720F_DEVID 0x8720
122 #define IT8726F_DEVID 0x8726
123 #define IT87_ACT_REG 0x30
124 #define IT87_BASE_REG 0x60
126 /* Logical device 7 registers (IT8712F and later) */
127 #define IT87_SIO_GPIO3_REG 0x27
128 #define IT87_SIO_PINX2_REG 0x2c /* Pin selection */
129 #define IT87_SIO_VID_REG 0xfc /* VID value */
131 /* Update battery voltage after every reading if true */
132 static int update_vbat;
134 /* Not all BIOSes properly configure the PWM registers */
135 static int fix_pwm_polarity;
137 /* Many IT87 constants specified below */
139 /* Length of ISA address segment */
140 #define IT87_EXTENT 8
142 /* Length of ISA address segment for Environmental Controller */
143 #define IT87_EC_EXTENT 2
145 /* Offset of EC registers from ISA base address */
146 #define IT87_EC_OFFSET 5
148 /* Where are the ISA address/data registers relative to the EC base address */
149 #define IT87_ADDR_REG_OFFSET 0
150 #define IT87_DATA_REG_OFFSET 1
152 /*----- The IT87 registers -----*/
154 #define IT87_REG_CONFIG 0x00
156 #define IT87_REG_ALARM1 0x01
157 #define IT87_REG_ALARM2 0x02
158 #define IT87_REG_ALARM3 0x03
160 /* The IT8718F and IT8720F have the VID value in a different register, in
161 Super-I/O configuration space. */
162 #define IT87_REG_VID 0x0a
163 /* The IT8705F and IT8712F earlier than revision 0x08 use register 0x0b
164 for fan divisors. Later IT8712F revisions must use 16-bit tachometer
166 #define IT87_REG_FAN_DIV 0x0b
167 #define IT87_REG_FAN_16BIT 0x0c
169 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
171 static const u8 IT87_REG_FAN[] = { 0x0d, 0x0e, 0x0f, 0x80, 0x82 };
172 static const u8 IT87_REG_FAN_MIN[] = { 0x10, 0x11, 0x12, 0x84, 0x86 };
173 static const u8 IT87_REG_FANX[] = { 0x18, 0x19, 0x1a, 0x81, 0x83 };
174 static const u8 IT87_REG_FANX_MIN[] = { 0x1b, 0x1c, 0x1d, 0x85, 0x87 };
175 #define IT87_REG_FAN_MAIN_CTRL 0x13
176 #define IT87_REG_FAN_CTL 0x14
177 #define IT87_REG_PWM(nr) (0x15 + (nr))
179 #define IT87_REG_VIN(nr) (0x20 + (nr))
180 #define IT87_REG_TEMP(nr) (0x29 + (nr))
182 #define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2)
183 #define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2)
184 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
185 #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2)
187 #define IT87_REG_VIN_ENABLE 0x50
188 #define IT87_REG_TEMP_ENABLE 0x51
190 #define IT87_REG_CHIPID 0x58
192 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
193 #define IN_FROM_REG(val) ((val) * 16)
195 static inline u8 FAN_TO_REG(long rpm, int div)
199 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
200 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
204 static inline u16 FAN16_TO_REG(long rpm)
208 return SENSORS_LIMIT((1350000 + rpm) / (rpm * 2), 1, 0xfffe);
211 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
212 /* The divider is fixed to 2 in 16-bit mode */
213 #define FAN16_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:1350000/((val)*2))
215 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
216 ((val)+500)/1000),-128,127))
217 #define TEMP_FROM_REG(val) ((val) * 1000)
219 #define PWM_TO_REG(val) ((val) >> 1)
220 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
222 static int DIV_TO_REG(int val)
225 while (answer < 7 && (val >>= 1))
229 #define DIV_FROM_REG(val) (1 << (val))
231 static const unsigned int pwm_freq[8] = {
243 struct it87_sio_data {
245 /* Values read from Super-I/O config space */
249 /* Values set based on DMI strings */
253 /* For each registered chip, we need to keep some data in memory.
254 The structure is dynamically allocated. */
256 struct device *hwmon_dev;
262 struct mutex update_lock;
263 char valid; /* !=0 if following fields are valid */
264 unsigned long last_updated; /* In jiffies */
266 u8 in[9]; /* Register value */
267 u8 in_max[8]; /* Register value */
268 u8 in_min[8]; /* Register value */
269 u8 has_fan; /* Bitfield, fans enabled */
270 u16 fan[5]; /* Register values, possibly combined */
271 u16 fan_min[5]; /* Register values, possibly combined */
272 s8 temp[3]; /* Register value */
273 s8 temp_high[3]; /* Register value */
274 s8 temp_low[3]; /* Register value */
275 u8 sensor; /* Register value */
276 u8 fan_div[3]; /* Register encoding, shifted right */
277 u8 vid; /* Register encoding, combined */
279 u32 alarms; /* Register encoding, combined */
280 u8 fan_main_ctrl; /* Register value */
281 u8 fan_ctl; /* Register value */
282 u8 manual_pwm_ctl[3]; /* manual PWM value set by user */
285 static inline int has_16bit_fans(const struct it87_data *data)
287 /* IT8705F Datasheet 0.4.1, 3h == Version G.
288 IT8712F Datasheet 0.9.1, section 8.3.5 indicates 8h == Version J.
289 These are the first revisions with 16bit tachometer support. */
290 return (data->type == it87 && data->revision >= 0x03)
291 || (data->type == it8712 && data->revision >= 0x08)
292 || data->type == it8716
293 || data->type == it8718
294 || data->type == it8720;
297 static int it87_probe(struct platform_device *pdev);
298 static int __devexit it87_remove(struct platform_device *pdev);
300 static int it87_read_value(struct it87_data *data, u8 reg);
301 static void it87_write_value(struct it87_data *data, u8 reg, u8 value);
302 static struct it87_data *it87_update_device(struct device *dev);
303 static int it87_check_pwm(struct device *dev);
304 static void it87_init_device(struct platform_device *pdev);
307 static struct platform_driver it87_driver = {
309 .owner = THIS_MODULE,
313 .remove = __devexit_p(it87_remove),
316 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
319 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
320 int nr = sensor_attr->index;
322 struct it87_data *data = it87_update_device(dev);
323 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
326 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
329 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
330 int nr = sensor_attr->index;
332 struct it87_data *data = it87_update_device(dev);
333 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
336 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
339 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
340 int nr = sensor_attr->index;
342 struct it87_data *data = it87_update_device(dev);
343 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
346 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
347 const char *buf, size_t count)
349 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
350 int nr = sensor_attr->index;
352 struct it87_data *data = dev_get_drvdata(dev);
353 unsigned long val = simple_strtoul(buf, NULL, 10);
355 mutex_lock(&data->update_lock);
356 data->in_min[nr] = IN_TO_REG(val);
357 it87_write_value(data, IT87_REG_VIN_MIN(nr),
359 mutex_unlock(&data->update_lock);
362 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
363 const char *buf, size_t count)
365 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
366 int nr = sensor_attr->index;
368 struct it87_data *data = dev_get_drvdata(dev);
369 unsigned long val = simple_strtoul(buf, NULL, 10);
371 mutex_lock(&data->update_lock);
372 data->in_max[nr] = IN_TO_REG(val);
373 it87_write_value(data, IT87_REG_VIN_MAX(nr),
375 mutex_unlock(&data->update_lock);
379 #define show_in_offset(offset) \
380 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
381 show_in, NULL, offset);
383 #define limit_in_offset(offset) \
384 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
385 show_in_min, set_in_min, offset); \
386 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
387 show_in_max, set_in_max, offset);
408 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
411 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
412 int nr = sensor_attr->index;
414 struct it87_data *data = it87_update_device(dev);
415 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
417 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
420 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
421 int nr = sensor_attr->index;
423 struct it87_data *data = it87_update_device(dev);
424 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
426 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
429 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
430 int nr = sensor_attr->index;
432 struct it87_data *data = it87_update_device(dev);
433 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
435 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
436 const char *buf, size_t count)
438 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
439 int nr = sensor_attr->index;
441 struct it87_data *data = dev_get_drvdata(dev);
442 int val = simple_strtol(buf, NULL, 10);
444 mutex_lock(&data->update_lock);
445 data->temp_high[nr] = TEMP_TO_REG(val);
446 it87_write_value(data, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
447 mutex_unlock(&data->update_lock);
450 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
451 const char *buf, size_t count)
453 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
454 int nr = sensor_attr->index;
456 struct it87_data *data = dev_get_drvdata(dev);
457 int val = simple_strtol(buf, NULL, 10);
459 mutex_lock(&data->update_lock);
460 data->temp_low[nr] = TEMP_TO_REG(val);
461 it87_write_value(data, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
462 mutex_unlock(&data->update_lock);
465 #define show_temp_offset(offset) \
466 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
467 show_temp, NULL, offset - 1); \
468 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
469 show_temp_max, set_temp_max, offset - 1); \
470 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
471 show_temp_min, set_temp_min, offset - 1);
477 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
480 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
481 int nr = sensor_attr->index;
483 struct it87_data *data = it87_update_device(dev);
484 u8 reg = data->sensor; /* In case the value is updated while we use it */
487 return sprintf(buf, "3\n"); /* thermal diode */
489 return sprintf(buf, "4\n"); /* thermistor */
490 return sprintf(buf, "0\n"); /* disabled */
492 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
493 const char *buf, size_t count)
495 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
496 int nr = sensor_attr->index;
498 struct it87_data *data = dev_get_drvdata(dev);
499 int val = simple_strtol(buf, NULL, 10);
501 mutex_lock(&data->update_lock);
503 data->sensor &= ~(1 << nr);
504 data->sensor &= ~(8 << nr);
505 if (val == 2) { /* backwards compatibility */
506 dev_warn(dev, "Sensor type 2 is deprecated, please use 4 "
510 /* 3 = thermal diode; 4 = thermistor; 0 = disabled */
512 data->sensor |= 1 << nr;
514 data->sensor |= 8 << nr;
516 mutex_unlock(&data->update_lock);
519 it87_write_value(data, IT87_REG_TEMP_ENABLE, data->sensor);
520 mutex_unlock(&data->update_lock);
523 #define show_sensor_offset(offset) \
524 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
525 show_sensor, set_sensor, offset - 1);
527 show_sensor_offset(1);
528 show_sensor_offset(2);
529 show_sensor_offset(3);
532 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
535 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
536 int nr = sensor_attr->index;
538 struct it87_data *data = it87_update_device(dev);
539 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
540 DIV_FROM_REG(data->fan_div[nr])));
542 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
545 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
546 int nr = sensor_attr->index;
548 struct it87_data *data = it87_update_device(dev);
549 return sprintf(buf,"%d\n",
550 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
552 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
555 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
556 int nr = sensor_attr->index;
558 struct it87_data *data = it87_update_device(dev);
559 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
561 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
564 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
565 int nr = sensor_attr->index;
567 struct it87_data *data = it87_update_device(dev);
568 return sprintf(buf,"%d\n", (data->fan_main_ctrl & (1 << nr)) ? 1 : 0);
570 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
573 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
574 int nr = sensor_attr->index;
576 struct it87_data *data = it87_update_device(dev);
577 return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]);
579 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
582 struct it87_data *data = it87_update_device(dev);
583 int index = (data->fan_ctl >> 4) & 0x07;
585 return sprintf(buf, "%u\n", pwm_freq[index]);
587 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
588 const char *buf, size_t count)
590 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
591 int nr = sensor_attr->index;
593 struct it87_data *data = dev_get_drvdata(dev);
594 int val = simple_strtol(buf, NULL, 10);
597 mutex_lock(&data->update_lock);
598 reg = it87_read_value(data, IT87_REG_FAN_DIV);
600 case 0: data->fan_div[nr] = reg & 0x07; break;
601 case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
602 case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break;
605 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
606 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
607 mutex_unlock(&data->update_lock);
610 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
611 const char *buf, size_t count)
613 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
614 int nr = sensor_attr->index;
616 struct it87_data *data = dev_get_drvdata(dev);
617 unsigned long val = simple_strtoul(buf, NULL, 10);
621 mutex_lock(&data->update_lock);
622 old = it87_read_value(data, IT87_REG_FAN_DIV);
624 /* Save fan min limit */
625 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
630 data->fan_div[nr] = DIV_TO_REG(val);
634 data->fan_div[nr] = 1;
636 data->fan_div[nr] = 3;
639 val |= (data->fan_div[0] & 0x07);
640 val |= (data->fan_div[1] & 0x07) << 3;
641 if (data->fan_div[2] == 3)
643 it87_write_value(data, IT87_REG_FAN_DIV, val);
645 /* Restore fan min limit */
646 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
647 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
649 mutex_unlock(&data->update_lock);
652 static ssize_t set_pwm_enable(struct device *dev,
653 struct device_attribute *attr, const char *buf, size_t count)
655 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
656 int nr = sensor_attr->index;
658 struct it87_data *data = dev_get_drvdata(dev);
659 int val = simple_strtol(buf, NULL, 10);
661 mutex_lock(&data->update_lock);
665 /* make sure the fan is on when in on/off mode */
666 tmp = it87_read_value(data, IT87_REG_FAN_CTL);
667 it87_write_value(data, IT87_REG_FAN_CTL, tmp | (1 << nr));
668 /* set on/off mode */
669 data->fan_main_ctrl &= ~(1 << nr);
670 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
671 } else if (val == 1) {
672 /* set SmartGuardian mode */
673 data->fan_main_ctrl |= (1 << nr);
674 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
675 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
676 it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
678 mutex_unlock(&data->update_lock);
682 mutex_unlock(&data->update_lock);
685 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
686 const char *buf, size_t count)
688 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
689 int nr = sensor_attr->index;
691 struct it87_data *data = dev_get_drvdata(dev);
692 int val = simple_strtol(buf, NULL, 10);
694 if (val < 0 || val > 255)
697 mutex_lock(&data->update_lock);
698 data->manual_pwm_ctl[nr] = val;
699 if (data->fan_main_ctrl & (1 << nr))
700 it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
701 mutex_unlock(&data->update_lock);
704 static ssize_t set_pwm_freq(struct device *dev,
705 struct device_attribute *attr, const char *buf, size_t count)
707 struct it87_data *data = dev_get_drvdata(dev);
708 unsigned long val = simple_strtoul(buf, NULL, 10);
711 /* Search for the nearest available frequency */
712 for (i = 0; i < 7; i++) {
713 if (val > (pwm_freq[i] + pwm_freq[i+1]) / 2)
717 mutex_lock(&data->update_lock);
718 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL) & 0x8f;
719 data->fan_ctl |= i << 4;
720 it87_write_value(data, IT87_REG_FAN_CTL, data->fan_ctl);
721 mutex_unlock(&data->update_lock);
726 #define show_fan_offset(offset) \
727 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
728 show_fan, NULL, offset - 1); \
729 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
730 show_fan_min, set_fan_min, offset - 1); \
731 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
732 show_fan_div, set_fan_div, offset - 1);
738 #define show_pwm_offset(offset) \
739 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
740 show_pwm_enable, set_pwm_enable, offset - 1); \
741 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
742 show_pwm, set_pwm, offset - 1); \
743 static DEVICE_ATTR(pwm##offset##_freq, \
744 (offset == 1 ? S_IRUGO | S_IWUSR : S_IRUGO), \
745 show_pwm_freq, (offset == 1 ? set_pwm_freq : NULL));
751 /* A different set of callbacks for 16-bit fans */
752 static ssize_t show_fan16(struct device *dev, struct device_attribute *attr,
755 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
756 int nr = sensor_attr->index;
757 struct it87_data *data = it87_update_device(dev);
758 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan[nr]));
761 static ssize_t show_fan16_min(struct device *dev, struct device_attribute *attr,
764 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
765 int nr = sensor_attr->index;
766 struct it87_data *data = it87_update_device(dev);
767 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan_min[nr]));
770 static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr,
771 const char *buf, size_t count)
773 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
774 int nr = sensor_attr->index;
775 struct it87_data *data = dev_get_drvdata(dev);
776 int val = simple_strtol(buf, NULL, 10);
778 mutex_lock(&data->update_lock);
779 data->fan_min[nr] = FAN16_TO_REG(val);
780 it87_write_value(data, IT87_REG_FAN_MIN[nr],
781 data->fan_min[nr] & 0xff);
782 it87_write_value(data, IT87_REG_FANX_MIN[nr],
783 data->fan_min[nr] >> 8);
784 mutex_unlock(&data->update_lock);
788 /* We want to use the same sysfs file names as 8-bit fans, but we need
789 different variable names, so we have to use SENSOR_ATTR instead of
790 SENSOR_DEVICE_ATTR. */
791 #define show_fan16_offset(offset) \
792 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \
793 = SENSOR_ATTR(fan##offset##_input, S_IRUGO, \
794 show_fan16, NULL, offset - 1); \
795 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \
796 = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
797 show_fan16_min, set_fan16_min, offset - 1)
799 show_fan16_offset(1);
800 show_fan16_offset(2);
801 show_fan16_offset(3);
802 show_fan16_offset(4);
803 show_fan16_offset(5);
806 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
808 struct it87_data *data = it87_update_device(dev);
809 return sprintf(buf, "%u\n", data->alarms);
811 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
813 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
816 int bitnr = to_sensor_dev_attr(attr)->index;
817 struct it87_data *data = it87_update_device(dev);
818 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
820 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8);
821 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9);
822 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10);
823 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11);
824 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12);
825 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13);
826 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14);
827 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15);
828 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
829 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1);
830 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 2);
831 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 3);
832 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 6);
833 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 16);
834 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 17);
835 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 18);
838 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
840 struct it87_data *data = dev_get_drvdata(dev);
841 return sprintf(buf, "%u\n", data->vrm);
844 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
846 struct it87_data *data = dev_get_drvdata(dev);
849 val = simple_strtoul(buf, NULL, 10);
854 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
857 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
859 struct it87_data *data = it87_update_device(dev);
860 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
862 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
864 static ssize_t show_name(struct device *dev, struct device_attribute
867 struct it87_data *data = dev_get_drvdata(dev);
868 return sprintf(buf, "%s\n", data->name);
870 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
872 static struct attribute *it87_attributes[] = {
873 &sensor_dev_attr_in0_input.dev_attr.attr,
874 &sensor_dev_attr_in1_input.dev_attr.attr,
875 &sensor_dev_attr_in2_input.dev_attr.attr,
876 &sensor_dev_attr_in3_input.dev_attr.attr,
877 &sensor_dev_attr_in4_input.dev_attr.attr,
878 &sensor_dev_attr_in5_input.dev_attr.attr,
879 &sensor_dev_attr_in6_input.dev_attr.attr,
880 &sensor_dev_attr_in7_input.dev_attr.attr,
881 &sensor_dev_attr_in8_input.dev_attr.attr,
882 &sensor_dev_attr_in0_min.dev_attr.attr,
883 &sensor_dev_attr_in1_min.dev_attr.attr,
884 &sensor_dev_attr_in2_min.dev_attr.attr,
885 &sensor_dev_attr_in3_min.dev_attr.attr,
886 &sensor_dev_attr_in4_min.dev_attr.attr,
887 &sensor_dev_attr_in5_min.dev_attr.attr,
888 &sensor_dev_attr_in6_min.dev_attr.attr,
889 &sensor_dev_attr_in7_min.dev_attr.attr,
890 &sensor_dev_attr_in0_max.dev_attr.attr,
891 &sensor_dev_attr_in1_max.dev_attr.attr,
892 &sensor_dev_attr_in2_max.dev_attr.attr,
893 &sensor_dev_attr_in3_max.dev_attr.attr,
894 &sensor_dev_attr_in4_max.dev_attr.attr,
895 &sensor_dev_attr_in5_max.dev_attr.attr,
896 &sensor_dev_attr_in6_max.dev_attr.attr,
897 &sensor_dev_attr_in7_max.dev_attr.attr,
898 &sensor_dev_attr_in0_alarm.dev_attr.attr,
899 &sensor_dev_attr_in1_alarm.dev_attr.attr,
900 &sensor_dev_attr_in2_alarm.dev_attr.attr,
901 &sensor_dev_attr_in3_alarm.dev_attr.attr,
902 &sensor_dev_attr_in4_alarm.dev_attr.attr,
903 &sensor_dev_attr_in5_alarm.dev_attr.attr,
904 &sensor_dev_attr_in6_alarm.dev_attr.attr,
905 &sensor_dev_attr_in7_alarm.dev_attr.attr,
907 &sensor_dev_attr_temp1_input.dev_attr.attr,
908 &sensor_dev_attr_temp2_input.dev_attr.attr,
909 &sensor_dev_attr_temp3_input.dev_attr.attr,
910 &sensor_dev_attr_temp1_max.dev_attr.attr,
911 &sensor_dev_attr_temp2_max.dev_attr.attr,
912 &sensor_dev_attr_temp3_max.dev_attr.attr,
913 &sensor_dev_attr_temp1_min.dev_attr.attr,
914 &sensor_dev_attr_temp2_min.dev_attr.attr,
915 &sensor_dev_attr_temp3_min.dev_attr.attr,
916 &sensor_dev_attr_temp1_type.dev_attr.attr,
917 &sensor_dev_attr_temp2_type.dev_attr.attr,
918 &sensor_dev_attr_temp3_type.dev_attr.attr,
919 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
920 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
921 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
923 &dev_attr_alarms.attr,
928 static const struct attribute_group it87_group = {
929 .attrs = it87_attributes,
932 static struct attribute *it87_attributes_opt[] = {
933 &sensor_dev_attr_fan1_input16.dev_attr.attr,
934 &sensor_dev_attr_fan1_min16.dev_attr.attr,
935 &sensor_dev_attr_fan2_input16.dev_attr.attr,
936 &sensor_dev_attr_fan2_min16.dev_attr.attr,
937 &sensor_dev_attr_fan3_input16.dev_attr.attr,
938 &sensor_dev_attr_fan3_min16.dev_attr.attr,
939 &sensor_dev_attr_fan4_input16.dev_attr.attr,
940 &sensor_dev_attr_fan4_min16.dev_attr.attr,
941 &sensor_dev_attr_fan5_input16.dev_attr.attr,
942 &sensor_dev_attr_fan5_min16.dev_attr.attr,
944 &sensor_dev_attr_fan1_input.dev_attr.attr,
945 &sensor_dev_attr_fan1_min.dev_attr.attr,
946 &sensor_dev_attr_fan1_div.dev_attr.attr,
947 &sensor_dev_attr_fan2_input.dev_attr.attr,
948 &sensor_dev_attr_fan2_min.dev_attr.attr,
949 &sensor_dev_attr_fan2_div.dev_attr.attr,
950 &sensor_dev_attr_fan3_input.dev_attr.attr,
951 &sensor_dev_attr_fan3_min.dev_attr.attr,
952 &sensor_dev_attr_fan3_div.dev_attr.attr,
954 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
955 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
956 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
957 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
958 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
960 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
961 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
962 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
963 &sensor_dev_attr_pwm1.dev_attr.attr,
964 &sensor_dev_attr_pwm2.dev_attr.attr,
965 &sensor_dev_attr_pwm3.dev_attr.attr,
966 &dev_attr_pwm1_freq.attr,
967 &dev_attr_pwm2_freq.attr,
968 &dev_attr_pwm3_freq.attr,
971 &dev_attr_cpu0_vid.attr,
975 static const struct attribute_group it87_group_opt = {
976 .attrs = it87_attributes_opt,
979 /* SuperIO detection - will change isa_address if a chip is found */
980 static int __init it87_find(unsigned short *address,
981 struct it87_sio_data *sio_data)
985 const char *board_vendor, *board_name;
988 chip_type = force_id ? force_id : superio_inw(DEVID);
992 sio_data->type = it87;
995 sio_data->type = it8712;
999 sio_data->type = it8716;
1002 sio_data->type = it8718;
1005 sio_data->type = it8720;
1007 case 0xffff: /* No device at all */
1010 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
1015 superio_select(PME);
1016 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
1017 pr_info("it87: Device not activated, skipping\n");
1021 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
1022 if (*address == 0) {
1023 pr_info("it87: Base address not set, skipping\n");
1028 sio_data->revision = superio_inb(DEVREV) & 0x0f;
1029 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
1030 chip_type, *address, sio_data->revision);
1032 /* Read GPIO config and VID value from LDN 7 (GPIO) */
1033 if (sio_data->type == it87) {
1034 /* The IT8705F doesn't have VID pins at all */
1035 sio_data->skip_vid = 1;
1039 superio_select(GPIO);
1040 /* We need at least 4 VID pins */
1041 reg = superio_inb(IT87_SIO_GPIO3_REG);
1043 pr_info("it87: VID is disabled (pins used for GPIO)\n");
1044 sio_data->skip_vid = 1;
1047 if ((sio_data->type == it8718 || sio_data->type == it8720)
1048 && !(sio_data->skip_vid))
1049 sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
1051 reg = superio_inb(IT87_SIO_PINX2_REG);
1053 pr_info("it87: in3 is VCC (+5V)\n");
1055 pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
1058 /* Disable specific features based on DMI strings */
1059 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1060 board_name = dmi_get_system_info(DMI_BOARD_NAME);
1061 if (board_vendor && board_name) {
1062 if (strcmp(board_vendor, "nVIDIA") == 0
1063 && strcmp(board_name, "FN68PT") == 0) {
1064 /* On the Shuttle SN68PT, FAN_CTL2 is apparently not
1065 connected to a fan, but to something else. One user
1066 has reported instant system power-off when changing
1067 the PWM2 duty cycle, so we disable it.
1068 I use the board name string as the trigger in case
1069 the same board is ever used in other systems. */
1070 pr_info("it87: Disabling pwm2 due to "
1071 "hardware constraints\n");
1072 sio_data->skip_pwm = (1 << 1);
1081 static int __devinit it87_probe(struct platform_device *pdev)
1083 struct it87_data *data;
1084 struct resource *res;
1085 struct device *dev = &pdev->dev;
1086 struct it87_sio_data *sio_data = dev->platform_data;
1088 int enable_pwm_interface;
1089 static const char *names[] = {
1097 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1098 if (!request_region(res->start, IT87_EC_EXTENT, DRVNAME)) {
1099 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1100 (unsigned long)res->start,
1101 (unsigned long)(res->start + IT87_EC_EXTENT - 1));
1106 if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
1111 data->addr = res->start;
1112 data->type = sio_data->type;
1113 data->revision = sio_data->revision;
1114 data->name = names[sio_data->type];
1116 /* Now, we do the remaining detection. */
1117 if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80)
1118 || it87_read_value(data, IT87_REG_CHIPID) != 0x90) {
1123 platform_set_drvdata(pdev, data);
1125 mutex_init(&data->update_lock);
1127 /* Check PWM configuration */
1128 enable_pwm_interface = it87_check_pwm(dev);
1130 /* Initialize the IT87 chip */
1131 it87_init_device(pdev);
1133 /* Register sysfs hooks */
1134 if ((err = sysfs_create_group(&dev->kobj, &it87_group)))
1137 /* Do not create fan files for disabled fans */
1138 if (has_16bit_fans(data)) {
1139 /* 16-bit tachometers */
1140 if (data->has_fan & (1 << 0)) {
1141 if ((err = device_create_file(dev,
1142 &sensor_dev_attr_fan1_input16.dev_attr))
1143 || (err = device_create_file(dev,
1144 &sensor_dev_attr_fan1_min16.dev_attr))
1145 || (err = device_create_file(dev,
1146 &sensor_dev_attr_fan1_alarm.dev_attr)))
1149 if (data->has_fan & (1 << 1)) {
1150 if ((err = device_create_file(dev,
1151 &sensor_dev_attr_fan2_input16.dev_attr))
1152 || (err = device_create_file(dev,
1153 &sensor_dev_attr_fan2_min16.dev_attr))
1154 || (err = device_create_file(dev,
1155 &sensor_dev_attr_fan2_alarm.dev_attr)))
1158 if (data->has_fan & (1 << 2)) {
1159 if ((err = device_create_file(dev,
1160 &sensor_dev_attr_fan3_input16.dev_attr))
1161 || (err = device_create_file(dev,
1162 &sensor_dev_attr_fan3_min16.dev_attr))
1163 || (err = device_create_file(dev,
1164 &sensor_dev_attr_fan3_alarm.dev_attr)))
1167 if (data->has_fan & (1 << 3)) {
1168 if ((err = device_create_file(dev,
1169 &sensor_dev_attr_fan4_input16.dev_attr))
1170 || (err = device_create_file(dev,
1171 &sensor_dev_attr_fan4_min16.dev_attr))
1172 || (err = device_create_file(dev,
1173 &sensor_dev_attr_fan4_alarm.dev_attr)))
1176 if (data->has_fan & (1 << 4)) {
1177 if ((err = device_create_file(dev,
1178 &sensor_dev_attr_fan5_input16.dev_attr))
1179 || (err = device_create_file(dev,
1180 &sensor_dev_attr_fan5_min16.dev_attr))
1181 || (err = device_create_file(dev,
1182 &sensor_dev_attr_fan5_alarm.dev_attr)))
1186 /* 8-bit tachometers with clock divider */
1187 if (data->has_fan & (1 << 0)) {
1188 if ((err = device_create_file(dev,
1189 &sensor_dev_attr_fan1_input.dev_attr))
1190 || (err = device_create_file(dev,
1191 &sensor_dev_attr_fan1_min.dev_attr))
1192 || (err = device_create_file(dev,
1193 &sensor_dev_attr_fan1_div.dev_attr))
1194 || (err = device_create_file(dev,
1195 &sensor_dev_attr_fan1_alarm.dev_attr)))
1198 if (data->has_fan & (1 << 1)) {
1199 if ((err = device_create_file(dev,
1200 &sensor_dev_attr_fan2_input.dev_attr))
1201 || (err = device_create_file(dev,
1202 &sensor_dev_attr_fan2_min.dev_attr))
1203 || (err = device_create_file(dev,
1204 &sensor_dev_attr_fan2_div.dev_attr))
1205 || (err = device_create_file(dev,
1206 &sensor_dev_attr_fan2_alarm.dev_attr)))
1209 if (data->has_fan & (1 << 2)) {
1210 if ((err = device_create_file(dev,
1211 &sensor_dev_attr_fan3_input.dev_attr))
1212 || (err = device_create_file(dev,
1213 &sensor_dev_attr_fan3_min.dev_attr))
1214 || (err = device_create_file(dev,
1215 &sensor_dev_attr_fan3_div.dev_attr))
1216 || (err = device_create_file(dev,
1217 &sensor_dev_attr_fan3_alarm.dev_attr)))
1222 if (enable_pwm_interface) {
1223 if (!(sio_data->skip_pwm & (1 << 0))) {
1224 if ((err = device_create_file(dev,
1225 &sensor_dev_attr_pwm1_enable.dev_attr))
1226 || (err = device_create_file(dev,
1227 &sensor_dev_attr_pwm1.dev_attr))
1228 || (err = device_create_file(dev,
1229 &dev_attr_pwm1_freq)))
1232 if (!(sio_data->skip_pwm & (1 << 1))) {
1233 if ((err = device_create_file(dev,
1234 &sensor_dev_attr_pwm2_enable.dev_attr))
1235 || (err = device_create_file(dev,
1236 &sensor_dev_attr_pwm2.dev_attr))
1237 || (err = device_create_file(dev,
1238 &dev_attr_pwm2_freq)))
1241 if (!(sio_data->skip_pwm & (1 << 2))) {
1242 if ((err = device_create_file(dev,
1243 &sensor_dev_attr_pwm3_enable.dev_attr))
1244 || (err = device_create_file(dev,
1245 &sensor_dev_attr_pwm3.dev_attr))
1246 || (err = device_create_file(dev,
1247 &dev_attr_pwm3_freq)))
1252 if (!sio_data->skip_vid) {
1253 data->vrm = vid_which_vrm();
1254 /* VID reading from Super-I/O config space if available */
1255 data->vid = sio_data->vid_value;
1256 if ((err = device_create_file(dev,
1258 || (err = device_create_file(dev,
1259 &dev_attr_cpu0_vid)))
1263 data->hwmon_dev = hwmon_device_register(dev);
1264 if (IS_ERR(data->hwmon_dev)) {
1265 err = PTR_ERR(data->hwmon_dev);
1272 sysfs_remove_group(&dev->kobj, &it87_group);
1273 sysfs_remove_group(&dev->kobj, &it87_group_opt);
1275 platform_set_drvdata(pdev, NULL);
1278 release_region(res->start, IT87_EC_EXTENT);
1283 static int __devexit it87_remove(struct platform_device *pdev)
1285 struct it87_data *data = platform_get_drvdata(pdev);
1287 hwmon_device_unregister(data->hwmon_dev);
1288 sysfs_remove_group(&pdev->dev.kobj, &it87_group);
1289 sysfs_remove_group(&pdev->dev.kobj, &it87_group_opt);
1291 release_region(data->addr, IT87_EC_EXTENT);
1292 platform_set_drvdata(pdev, NULL);
1298 /* Must be called with data->update_lock held, except during initialization.
1299 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1300 would slow down the IT87 access and should not be necessary. */
1301 static int it87_read_value(struct it87_data *data, u8 reg)
1303 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1304 return inb_p(data->addr + IT87_DATA_REG_OFFSET);
1307 /* Must be called with data->update_lock held, except during initialization.
1308 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1309 would slow down the IT87 access and should not be necessary. */
1310 static void it87_write_value(struct it87_data *data, u8 reg, u8 value)
1312 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1313 outb_p(value, data->addr + IT87_DATA_REG_OFFSET);
1316 /* Return 1 if and only if the PWM interface is safe to use */
1317 static int __devinit it87_check_pwm(struct device *dev)
1319 struct it87_data *data = dev_get_drvdata(dev);
1320 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
1321 * and polarity set to active low is sign that this is the case so we
1322 * disable pwm control to protect the user. */
1323 int tmp = it87_read_value(data, IT87_REG_FAN_CTL);
1324 if ((tmp & 0x87) == 0) {
1325 if (fix_pwm_polarity) {
1326 /* The user asks us to attempt a chip reconfiguration.
1327 * This means switching to active high polarity and
1328 * inverting all fan speed values. */
1332 for (i = 0; i < 3; i++)
1333 pwm[i] = it87_read_value(data,
1336 /* If any fan is in automatic pwm mode, the polarity
1337 * might be correct, as suspicious as it seems, so we
1338 * better don't change anything (but still disable the
1339 * PWM interface). */
1340 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1341 dev_info(dev, "Reconfiguring PWM to "
1342 "active high polarity\n");
1343 it87_write_value(data, IT87_REG_FAN_CTL,
1345 for (i = 0; i < 3; i++)
1346 it87_write_value(data,
1352 dev_info(dev, "PWM configuration is "
1353 "too broken to be fixed\n");
1356 dev_info(dev, "Detected broken BIOS "
1357 "defaults, disabling PWM interface\n");
1359 } else if (fix_pwm_polarity) {
1360 dev_info(dev, "PWM configuration looks "
1361 "sane, won't touch\n");
1367 /* Called when we have found a new IT87. */
1368 static void __devinit it87_init_device(struct platform_device *pdev)
1370 struct it87_data *data = platform_get_drvdata(pdev);
1373 /* initialize to sane defaults:
1374 * - if the chip is in manual pwm mode, this will be overwritten with
1375 * the actual settings on the chip (so in this case, initialization
1377 * - if in automatic or on/off mode, we could switch to manual mode,
1378 * read the registers and set manual_pwm_ctl accordingly, but currently
1379 * this is not implemented, so we initialize to something sane */
1380 for (i = 0; i < 3; i++) {
1381 data->manual_pwm_ctl[i] = 0xff;
1384 /* Some chips seem to have default value 0xff for all limit
1385 * registers. For low voltage limits it makes no sense and triggers
1386 * alarms, so change to 0 instead. For high temperature limits, it
1387 * means -1 degree C, which surprisingly doesn't trigger an alarm,
1388 * but is still confusing, so change to 127 degrees C. */
1389 for (i = 0; i < 8; i++) {
1390 tmp = it87_read_value(data, IT87_REG_VIN_MIN(i));
1392 it87_write_value(data, IT87_REG_VIN_MIN(i), 0);
1394 for (i = 0; i < 3; i++) {
1395 tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1397 it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127);
1400 /* Check if temperature channels are reset manually or by some reason */
1401 tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1402 if ((tmp & 0x3f) == 0) {
1403 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1404 tmp = (tmp & 0xc0) | 0x2a;
1405 it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp);
1409 /* Check if voltage monitors are reset manually or by some reason */
1410 tmp = it87_read_value(data, IT87_REG_VIN_ENABLE);
1411 if ((tmp & 0xff) == 0) {
1412 /* Enable all voltage monitors */
1413 it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff);
1416 /* Check if tachometers are reset manually or by some reason */
1417 data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
1418 if ((data->fan_main_ctrl & 0x70) == 0) {
1419 /* Enable all fan tachometers */
1420 data->fan_main_ctrl |= 0x70;
1421 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1423 data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
1425 /* Set tachometers to 16-bit mode if needed */
1426 if (has_16bit_fans(data)) {
1427 tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
1428 if (~tmp & 0x07 & data->has_fan) {
1430 "Setting fan1-3 to 16-bit mode\n");
1431 it87_write_value(data, IT87_REG_FAN_16BIT,
1434 /* IT8705F only supports three fans. */
1435 if (data->type != it87) {
1437 data->has_fan |= (1 << 3); /* fan4 enabled */
1439 data->has_fan |= (1 << 4); /* fan5 enabled */
1443 /* Set current fan mode registers and the default settings for the
1444 * other mode registers */
1445 for (i = 0; i < 3; i++) {
1446 if (data->fan_main_ctrl & (1 << i)) {
1448 tmp = it87_read_value(data, IT87_REG_PWM(i));
1450 /* automatic pwm - not yet implemented, but
1451 * leave the settings made by the BIOS alone
1452 * until a change is requested via the sysfs
1456 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1461 /* Start monitoring */
1462 it87_write_value(data, IT87_REG_CONFIG,
1463 (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
1464 | (update_vbat ? 0x41 : 0x01));
1467 static struct it87_data *it87_update_device(struct device *dev)
1469 struct it87_data *data = dev_get_drvdata(dev);
1472 mutex_lock(&data->update_lock);
1474 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1478 /* Cleared after each update, so reenable. Value
1479 returned by this read will be previous value */
1480 it87_write_value(data, IT87_REG_CONFIG,
1481 it87_read_value(data, IT87_REG_CONFIG) | 0x40);
1483 for (i = 0; i <= 7; i++) {
1485 it87_read_value(data, IT87_REG_VIN(i));
1487 it87_read_value(data, IT87_REG_VIN_MIN(i));
1489 it87_read_value(data, IT87_REG_VIN_MAX(i));
1491 /* in8 (battery) has no limit registers */
1493 it87_read_value(data, IT87_REG_VIN(8));
1495 for (i = 0; i < 5; i++) {
1496 /* Skip disabled fans */
1497 if (!(data->has_fan & (1 << i)))
1501 it87_read_value(data, IT87_REG_FAN_MIN[i]);
1502 data->fan[i] = it87_read_value(data,
1504 /* Add high byte if in 16-bit mode */
1505 if (has_16bit_fans(data)) {
1506 data->fan[i] |= it87_read_value(data,
1507 IT87_REG_FANX[i]) << 8;
1508 data->fan_min[i] |= it87_read_value(data,
1509 IT87_REG_FANX_MIN[i]) << 8;
1512 for (i = 0; i < 3; i++) {
1514 it87_read_value(data, IT87_REG_TEMP(i));
1515 data->temp_high[i] =
1516 it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1518 it87_read_value(data, IT87_REG_TEMP_LOW(i));
1521 /* Newer chips don't have clock dividers */
1522 if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
1523 i = it87_read_value(data, IT87_REG_FAN_DIV);
1524 data->fan_div[0] = i & 0x07;
1525 data->fan_div[1] = (i >> 3) & 0x07;
1526 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1530 it87_read_value(data, IT87_REG_ALARM1) |
1531 (it87_read_value(data, IT87_REG_ALARM2) << 8) |
1532 (it87_read_value(data, IT87_REG_ALARM3) << 16);
1533 data->fan_main_ctrl = it87_read_value(data,
1534 IT87_REG_FAN_MAIN_CTRL);
1535 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
1537 data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1538 /* The 8705 does not have VID capability.
1539 The 8718 and the 8720 don't use IT87_REG_VID for the
1541 if (data->type == it8712 || data->type == it8716) {
1542 data->vid = it87_read_value(data, IT87_REG_VID);
1543 /* The older IT8712F revisions had only 5 VID pins,
1544 but we assume it is always safe to read 6 bits. */
1547 data->last_updated = jiffies;
1551 mutex_unlock(&data->update_lock);
1556 static int __init it87_device_add(unsigned short address,
1557 const struct it87_sio_data *sio_data)
1559 struct resource res = {
1560 .start = address + IT87_EC_OFFSET,
1561 .end = address + IT87_EC_OFFSET + IT87_EC_EXTENT - 1,
1563 .flags = IORESOURCE_IO,
1567 err = acpi_check_resource_conflict(&res);
1571 pdev = platform_device_alloc(DRVNAME, address);
1574 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1578 err = platform_device_add_resources(pdev, &res, 1);
1580 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1582 goto exit_device_put;
1585 err = platform_device_add_data(pdev, sio_data,
1586 sizeof(struct it87_sio_data));
1588 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1589 goto exit_device_put;
1592 err = platform_device_add(pdev);
1594 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1596 goto exit_device_put;
1602 platform_device_put(pdev);
1607 static int __init sm_it87_init(void)
1610 unsigned short isa_address=0;
1611 struct it87_sio_data sio_data;
1613 memset(&sio_data, 0, sizeof(struct it87_sio_data));
1614 err = it87_find(&isa_address, &sio_data);
1617 err = platform_driver_register(&it87_driver);
1621 err = it87_device_add(isa_address, &sio_data);
1623 platform_driver_unregister(&it87_driver);
1630 static void __exit sm_it87_exit(void)
1632 platform_device_unregister(pdev);
1633 platform_driver_unregister(&it87_driver);
1637 MODULE_AUTHOR("Chris Gauthron, "
1638 "Jean Delvare <khali@linux-fr.org>");
1639 MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8720F/8726F, SiS950 driver");
1640 module_param(update_vbat, bool, 0);
1641 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1642 module_param(fix_pwm_polarity, bool, 0);
1643 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1644 MODULE_LICENSE("GPL");
1646 module_init(sm_it87_init);
1647 module_exit(sm_it87_exit);