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 IT8726F Super I/O chip w/LPC interface
18 Sis950 A clone of the IT8705F
20 Copyright (C) 2001 Chris Gauthron
21 Copyright (C) 2005-2007 Jean Delvare <khali@linux-fr.org>
23 This program is free software; you can redistribute it and/or modify
24 it under the terms of the GNU General Public License as published by
25 the Free Software Foundation; either version 2 of the License, or
26 (at your option) any later version.
28 This program is distributed in the hope that it will be useful,
29 but WITHOUT ANY WARRANTY; without even the implied warranty of
30 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31 GNU General Public License for more details.
33 You should have received a copy of the GNU General Public License
34 along with this program; if not, write to the Free Software
35 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/slab.h>
41 #include <linux/jiffies.h>
42 #include <linux/platform_device.h>
43 #include <linux/hwmon.h>
44 #include <linux/hwmon-sysfs.h>
45 #include <linux/hwmon-vid.h>
46 #include <linux/err.h>
47 #include <linux/mutex.h>
48 #include <linux/sysfs.h>
51 #define DRVNAME "it87"
53 enum chips { it87, it8712, it8716, it8718 };
55 static unsigned short force_id;
56 module_param(force_id, ushort, 0);
57 MODULE_PARM_DESC(force_id, "Override the detected device ID");
59 static struct platform_device *pdev;
61 #define REG 0x2e /* The register to read/write */
62 #define DEV 0x07 /* Register: Logical device select */
63 #define VAL 0x2f /* The value to read/write */
64 #define PME 0x04 /* The device with the fan registers in it */
65 #define GPIO 0x07 /* The device with the IT8718F VID value in it */
66 #define DEVID 0x20 /* Register: Device ID */
67 #define DEVREV 0x22 /* Register: Device Revision */
76 static int superio_inw(int reg)
87 superio_select(int ldn)
109 /* Logical device 4 registers */
110 #define IT8712F_DEVID 0x8712
111 #define IT8705F_DEVID 0x8705
112 #define IT8716F_DEVID 0x8716
113 #define IT8718F_DEVID 0x8718
114 #define IT8726F_DEVID 0x8726
115 #define IT87_ACT_REG 0x30
116 #define IT87_BASE_REG 0x60
118 /* Logical device 7 registers (IT8712F and later) */
119 #define IT87_SIO_PINX2_REG 0x2c /* Pin selection */
120 #define IT87_SIO_VID_REG 0xfc /* VID value */
122 /* Update battery voltage after every reading if true */
123 static int update_vbat;
125 /* Not all BIOSes properly configure the PWM registers */
126 static int fix_pwm_polarity;
128 /* Many IT87 constants specified below */
130 /* Length of ISA address segment */
131 #define IT87_EXTENT 8
133 /* Length of ISA address segment for Environmental Controller */
134 #define IT87_EC_EXTENT 2
136 /* Offset of EC registers from ISA base address */
137 #define IT87_EC_OFFSET 5
139 /* Where are the ISA address/data registers relative to the EC base address */
140 #define IT87_ADDR_REG_OFFSET 0
141 #define IT87_DATA_REG_OFFSET 1
143 /*----- The IT87 registers -----*/
145 #define IT87_REG_CONFIG 0x00
147 #define IT87_REG_ALARM1 0x01
148 #define IT87_REG_ALARM2 0x02
149 #define IT87_REG_ALARM3 0x03
151 /* The IT8718F has the VID value in a different register, in Super-I/O
152 configuration space. */
153 #define IT87_REG_VID 0x0a
154 /* The IT8705F and IT8712F earlier than revision 0x08 use register 0x0b
155 for fan divisors. Later IT8712F revisions must use 16-bit tachometer
157 #define IT87_REG_FAN_DIV 0x0b
158 #define IT87_REG_FAN_16BIT 0x0c
160 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
162 static const u8 IT87_REG_FAN[] = { 0x0d, 0x0e, 0x0f, 0x80, 0x82 };
163 static const u8 IT87_REG_FAN_MIN[] = { 0x10, 0x11, 0x12, 0x84, 0x86 };
164 static const u8 IT87_REG_FANX[] = { 0x18, 0x19, 0x1a, 0x81, 0x83 };
165 static const u8 IT87_REG_FANX_MIN[] = { 0x1b, 0x1c, 0x1d, 0x85, 0x87 };
166 #define IT87_REG_FAN_MAIN_CTRL 0x13
167 #define IT87_REG_FAN_CTL 0x14
168 #define IT87_REG_PWM(nr) (0x15 + (nr))
170 #define IT87_REG_VIN(nr) (0x20 + (nr))
171 #define IT87_REG_TEMP(nr) (0x29 + (nr))
173 #define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2)
174 #define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2)
175 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
176 #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2)
178 #define IT87_REG_VIN_ENABLE 0x50
179 #define IT87_REG_TEMP_ENABLE 0x51
181 #define IT87_REG_CHIPID 0x58
183 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
184 #define IN_FROM_REG(val) ((val) * 16)
186 static inline u8 FAN_TO_REG(long rpm, int div)
190 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
191 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
195 static inline u16 FAN16_TO_REG(long rpm)
199 return SENSORS_LIMIT((1350000 + rpm) / (rpm * 2), 1, 0xfffe);
202 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
203 /* The divider is fixed to 2 in 16-bit mode */
204 #define FAN16_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:1350000/((val)*2))
206 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
207 ((val)+500)/1000),-128,127))
208 #define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
210 #define PWM_TO_REG(val) ((val) >> 1)
211 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
213 static int DIV_TO_REG(int val)
216 while (answer < 7 && (val >>= 1))
220 #define DIV_FROM_REG(val) (1 << (val))
222 static const unsigned int pwm_freq[8] = {
234 struct it87_sio_data {
236 /* Values read from Super-I/O config space */
241 /* For each registered chip, we need to keep some data in memory.
242 The structure is dynamically allocated. */
244 struct device *hwmon_dev;
250 struct mutex update_lock;
251 char valid; /* !=0 if following fields are valid */
252 unsigned long last_updated; /* In jiffies */
254 u8 in[9]; /* Register value */
255 u8 in_max[8]; /* Register value */
256 u8 in_min[8]; /* Register value */
257 u8 has_fan; /* Bitfield, fans enabled */
258 u16 fan[5]; /* Register values, possibly combined */
259 u16 fan_min[5]; /* Register values, possibly combined */
260 u8 temp[3]; /* Register value */
261 u8 temp_high[3]; /* Register value */
262 u8 temp_low[3]; /* Register value */
263 u8 sensor; /* Register value */
264 u8 fan_div[3]; /* Register encoding, shifted right */
265 u8 vid; /* Register encoding, combined */
267 u32 alarms; /* Register encoding, combined */
268 u8 fan_main_ctrl; /* Register value */
269 u8 fan_ctl; /* Register value */
270 u8 manual_pwm_ctl[3]; /* manual PWM value set by user */
273 static inline int has_16bit_fans(const struct it87_data *data)
275 /* IT8712F Datasheet 0.9.1, section 8.3.5 indicates 7h == Version I.
276 This is the first revision with 16bit tachometer support. */
277 return (data->type == it8712 && data->revision >= 0x07)
278 || data->type == it8716
279 || data->type == it8718;
282 static int it87_probe(struct platform_device *pdev);
283 static int __devexit it87_remove(struct platform_device *pdev);
285 static int it87_read_value(struct it87_data *data, u8 reg);
286 static void it87_write_value(struct it87_data *data, u8 reg, u8 value);
287 static struct it87_data *it87_update_device(struct device *dev);
288 static int it87_check_pwm(struct device *dev);
289 static void it87_init_device(struct platform_device *pdev);
292 static struct platform_driver it87_driver = {
294 .owner = THIS_MODULE,
298 .remove = __devexit_p(it87_remove),
301 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
304 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
305 int nr = sensor_attr->index;
307 struct it87_data *data = it87_update_device(dev);
308 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
311 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
314 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
315 int nr = sensor_attr->index;
317 struct it87_data *data = it87_update_device(dev);
318 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
321 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
324 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
325 int nr = sensor_attr->index;
327 struct it87_data *data = it87_update_device(dev);
328 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
331 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
332 const char *buf, size_t count)
334 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
335 int nr = sensor_attr->index;
337 struct it87_data *data = dev_get_drvdata(dev);
338 unsigned long val = simple_strtoul(buf, NULL, 10);
340 mutex_lock(&data->update_lock);
341 data->in_min[nr] = IN_TO_REG(val);
342 it87_write_value(data, IT87_REG_VIN_MIN(nr),
344 mutex_unlock(&data->update_lock);
347 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
348 const char *buf, size_t count)
350 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
351 int nr = sensor_attr->index;
353 struct it87_data *data = dev_get_drvdata(dev);
354 unsigned long val = simple_strtoul(buf, NULL, 10);
356 mutex_lock(&data->update_lock);
357 data->in_max[nr] = IN_TO_REG(val);
358 it87_write_value(data, IT87_REG_VIN_MAX(nr),
360 mutex_unlock(&data->update_lock);
364 #define show_in_offset(offset) \
365 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
366 show_in, NULL, offset);
368 #define limit_in_offset(offset) \
369 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
370 show_in_min, set_in_min, offset); \
371 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
372 show_in_max, set_in_max, offset);
393 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
396 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
397 int nr = sensor_attr->index;
399 struct it87_data *data = it87_update_device(dev);
400 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
402 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
405 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
406 int nr = sensor_attr->index;
408 struct it87_data *data = it87_update_device(dev);
409 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
411 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
414 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
415 int nr = sensor_attr->index;
417 struct it87_data *data = it87_update_device(dev);
418 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
420 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
421 const char *buf, size_t count)
423 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
424 int nr = sensor_attr->index;
426 struct it87_data *data = dev_get_drvdata(dev);
427 int val = simple_strtol(buf, NULL, 10);
429 mutex_lock(&data->update_lock);
430 data->temp_high[nr] = TEMP_TO_REG(val);
431 it87_write_value(data, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
432 mutex_unlock(&data->update_lock);
435 static ssize_t set_temp_min(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_low[nr] = TEMP_TO_REG(val);
446 it87_write_value(data, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
447 mutex_unlock(&data->update_lock);
450 #define show_temp_offset(offset) \
451 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
452 show_temp, NULL, offset - 1); \
453 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
454 show_temp_max, set_temp_max, offset - 1); \
455 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
456 show_temp_min, set_temp_min, offset - 1);
462 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
465 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
466 int nr = sensor_attr->index;
468 struct it87_data *data = it87_update_device(dev);
469 u8 reg = data->sensor; /* In case the value is updated while we use it */
472 return sprintf(buf, "3\n"); /* thermal diode */
474 return sprintf(buf, "2\n"); /* thermistor */
475 return sprintf(buf, "0\n"); /* disabled */
477 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
478 const char *buf, size_t count)
480 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
481 int nr = sensor_attr->index;
483 struct it87_data *data = dev_get_drvdata(dev);
484 int val = simple_strtol(buf, NULL, 10);
486 mutex_lock(&data->update_lock);
488 data->sensor &= ~(1 << nr);
489 data->sensor &= ~(8 << nr);
490 /* 3 = thermal diode; 2 = thermistor; 0 = disabled */
492 data->sensor |= 1 << nr;
494 data->sensor |= 8 << nr;
496 mutex_unlock(&data->update_lock);
499 it87_write_value(data, IT87_REG_TEMP_ENABLE, data->sensor);
500 mutex_unlock(&data->update_lock);
503 #define show_sensor_offset(offset) \
504 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
505 show_sensor, set_sensor, offset - 1);
507 show_sensor_offset(1);
508 show_sensor_offset(2);
509 show_sensor_offset(3);
512 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
515 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
516 int nr = sensor_attr->index;
518 struct it87_data *data = it87_update_device(dev);
519 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
520 DIV_FROM_REG(data->fan_div[nr])));
522 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
525 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
526 int nr = sensor_attr->index;
528 struct it87_data *data = it87_update_device(dev);
529 return sprintf(buf,"%d\n",
530 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
532 static ssize_t show_fan_div(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", DIV_FROM_REG(data->fan_div[nr]));
541 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
544 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
545 int nr = sensor_attr->index;
547 struct it87_data *data = it87_update_device(dev);
548 return sprintf(buf,"%d\n", (data->fan_main_ctrl & (1 << nr)) ? 1 : 0);
550 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
553 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
554 int nr = sensor_attr->index;
556 struct it87_data *data = it87_update_device(dev);
557 return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]);
559 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
562 struct it87_data *data = it87_update_device(dev);
563 int index = (data->fan_ctl >> 4) & 0x07;
565 return sprintf(buf, "%u\n", pwm_freq[index]);
567 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
568 const char *buf, size_t count)
570 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
571 int nr = sensor_attr->index;
573 struct it87_data *data = dev_get_drvdata(dev);
574 int val = simple_strtol(buf, NULL, 10);
577 mutex_lock(&data->update_lock);
578 reg = it87_read_value(data, IT87_REG_FAN_DIV);
580 case 0: data->fan_div[nr] = reg & 0x07; break;
581 case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
582 case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break;
585 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
586 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
587 mutex_unlock(&data->update_lock);
590 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
591 const char *buf, size_t count)
593 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
594 int nr = sensor_attr->index;
596 struct it87_data *data = dev_get_drvdata(dev);
597 unsigned long val = simple_strtoul(buf, NULL, 10);
601 mutex_lock(&data->update_lock);
602 old = it87_read_value(data, IT87_REG_FAN_DIV);
604 /* Save fan min limit */
605 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
610 data->fan_div[nr] = DIV_TO_REG(val);
614 data->fan_div[nr] = 1;
616 data->fan_div[nr] = 3;
619 val |= (data->fan_div[0] & 0x07);
620 val |= (data->fan_div[1] & 0x07) << 3;
621 if (data->fan_div[2] == 3)
623 it87_write_value(data, IT87_REG_FAN_DIV, val);
625 /* Restore fan min limit */
626 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
627 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
629 mutex_unlock(&data->update_lock);
632 static ssize_t set_pwm_enable(struct device *dev,
633 struct device_attribute *attr, const char *buf, size_t count)
635 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
636 int nr = sensor_attr->index;
638 struct it87_data *data = dev_get_drvdata(dev);
639 int val = simple_strtol(buf, NULL, 10);
641 mutex_lock(&data->update_lock);
645 /* make sure the fan is on when in on/off mode */
646 tmp = it87_read_value(data, IT87_REG_FAN_CTL);
647 it87_write_value(data, IT87_REG_FAN_CTL, tmp | (1 << nr));
648 /* set on/off mode */
649 data->fan_main_ctrl &= ~(1 << nr);
650 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
651 } else if (val == 1) {
652 /* set SmartGuardian mode */
653 data->fan_main_ctrl |= (1 << nr);
654 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
655 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
656 it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
658 mutex_unlock(&data->update_lock);
662 mutex_unlock(&data->update_lock);
665 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
666 const char *buf, size_t count)
668 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
669 int nr = sensor_attr->index;
671 struct it87_data *data = dev_get_drvdata(dev);
672 int val = simple_strtol(buf, NULL, 10);
674 if (val < 0 || val > 255)
677 mutex_lock(&data->update_lock);
678 data->manual_pwm_ctl[nr] = val;
679 if (data->fan_main_ctrl & (1 << nr))
680 it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
681 mutex_unlock(&data->update_lock);
684 static ssize_t set_pwm_freq(struct device *dev,
685 struct device_attribute *attr, const char *buf, size_t count)
687 struct it87_data *data = dev_get_drvdata(dev);
688 unsigned long val = simple_strtoul(buf, NULL, 10);
691 /* Search for the nearest available frequency */
692 for (i = 0; i < 7; i++) {
693 if (val > (pwm_freq[i] + pwm_freq[i+1]) / 2)
697 mutex_lock(&data->update_lock);
698 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL) & 0x8f;
699 data->fan_ctl |= i << 4;
700 it87_write_value(data, IT87_REG_FAN_CTL, data->fan_ctl);
701 mutex_unlock(&data->update_lock);
706 #define show_fan_offset(offset) \
707 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
708 show_fan, NULL, offset - 1); \
709 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
710 show_fan_min, set_fan_min, offset - 1); \
711 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
712 show_fan_div, set_fan_div, offset - 1);
718 #define show_pwm_offset(offset) \
719 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
720 show_pwm_enable, set_pwm_enable, offset - 1); \
721 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
722 show_pwm, set_pwm, offset - 1); \
723 static DEVICE_ATTR(pwm##offset##_freq, \
724 (offset == 1 ? S_IRUGO | S_IWUSR : S_IRUGO), \
725 show_pwm_freq, (offset == 1 ? set_pwm_freq : NULL));
731 /* A different set of callbacks for 16-bit fans */
732 static ssize_t show_fan16(struct device *dev, struct device_attribute *attr,
735 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
736 int nr = sensor_attr->index;
737 struct it87_data *data = it87_update_device(dev);
738 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan[nr]));
741 static ssize_t show_fan16_min(struct device *dev, struct device_attribute *attr,
744 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
745 int nr = sensor_attr->index;
746 struct it87_data *data = it87_update_device(dev);
747 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan_min[nr]));
750 static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr,
751 const char *buf, size_t count)
753 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
754 int nr = sensor_attr->index;
755 struct it87_data *data = dev_get_drvdata(dev);
756 int val = simple_strtol(buf, NULL, 10);
758 mutex_lock(&data->update_lock);
759 data->fan_min[nr] = FAN16_TO_REG(val);
760 it87_write_value(data, IT87_REG_FAN_MIN[nr],
761 data->fan_min[nr] & 0xff);
762 it87_write_value(data, IT87_REG_FANX_MIN[nr],
763 data->fan_min[nr] >> 8);
764 mutex_unlock(&data->update_lock);
768 /* We want to use the same sysfs file names as 8-bit fans, but we need
769 different variable names, so we have to use SENSOR_ATTR instead of
770 SENSOR_DEVICE_ATTR. */
771 #define show_fan16_offset(offset) \
772 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \
773 = SENSOR_ATTR(fan##offset##_input, S_IRUGO, \
774 show_fan16, NULL, offset - 1); \
775 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \
776 = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
777 show_fan16_min, set_fan16_min, offset - 1)
779 show_fan16_offset(1);
780 show_fan16_offset(2);
781 show_fan16_offset(3);
782 show_fan16_offset(4);
783 show_fan16_offset(5);
786 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
788 struct it87_data *data = it87_update_device(dev);
789 return sprintf(buf, "%u\n", data->alarms);
791 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
793 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
796 int bitnr = to_sensor_dev_attr(attr)->index;
797 struct it87_data *data = it87_update_device(dev);
798 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
800 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8);
801 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9);
802 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10);
803 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11);
804 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12);
805 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13);
806 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14);
807 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15);
808 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
809 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1);
810 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 2);
811 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 3);
812 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 6);
813 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 16);
814 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 17);
815 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 18);
818 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
820 struct it87_data *data = dev_get_drvdata(dev);
821 return sprintf(buf, "%u\n", data->vrm);
824 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
826 struct it87_data *data = dev_get_drvdata(dev);
829 val = simple_strtoul(buf, NULL, 10);
834 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
837 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
839 struct it87_data *data = it87_update_device(dev);
840 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
842 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
844 static ssize_t show_name(struct device *dev, struct device_attribute
847 struct it87_data *data = dev_get_drvdata(dev);
848 return sprintf(buf, "%s\n", data->name);
850 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
852 static struct attribute *it87_attributes[] = {
853 &sensor_dev_attr_in0_input.dev_attr.attr,
854 &sensor_dev_attr_in1_input.dev_attr.attr,
855 &sensor_dev_attr_in2_input.dev_attr.attr,
856 &sensor_dev_attr_in3_input.dev_attr.attr,
857 &sensor_dev_attr_in4_input.dev_attr.attr,
858 &sensor_dev_attr_in5_input.dev_attr.attr,
859 &sensor_dev_attr_in6_input.dev_attr.attr,
860 &sensor_dev_attr_in7_input.dev_attr.attr,
861 &sensor_dev_attr_in8_input.dev_attr.attr,
862 &sensor_dev_attr_in0_min.dev_attr.attr,
863 &sensor_dev_attr_in1_min.dev_attr.attr,
864 &sensor_dev_attr_in2_min.dev_attr.attr,
865 &sensor_dev_attr_in3_min.dev_attr.attr,
866 &sensor_dev_attr_in4_min.dev_attr.attr,
867 &sensor_dev_attr_in5_min.dev_attr.attr,
868 &sensor_dev_attr_in6_min.dev_attr.attr,
869 &sensor_dev_attr_in7_min.dev_attr.attr,
870 &sensor_dev_attr_in0_max.dev_attr.attr,
871 &sensor_dev_attr_in1_max.dev_attr.attr,
872 &sensor_dev_attr_in2_max.dev_attr.attr,
873 &sensor_dev_attr_in3_max.dev_attr.attr,
874 &sensor_dev_attr_in4_max.dev_attr.attr,
875 &sensor_dev_attr_in5_max.dev_attr.attr,
876 &sensor_dev_attr_in6_max.dev_attr.attr,
877 &sensor_dev_attr_in7_max.dev_attr.attr,
878 &sensor_dev_attr_in0_alarm.dev_attr.attr,
879 &sensor_dev_attr_in1_alarm.dev_attr.attr,
880 &sensor_dev_attr_in2_alarm.dev_attr.attr,
881 &sensor_dev_attr_in3_alarm.dev_attr.attr,
882 &sensor_dev_attr_in4_alarm.dev_attr.attr,
883 &sensor_dev_attr_in5_alarm.dev_attr.attr,
884 &sensor_dev_attr_in6_alarm.dev_attr.attr,
885 &sensor_dev_attr_in7_alarm.dev_attr.attr,
887 &sensor_dev_attr_temp1_input.dev_attr.attr,
888 &sensor_dev_attr_temp2_input.dev_attr.attr,
889 &sensor_dev_attr_temp3_input.dev_attr.attr,
890 &sensor_dev_attr_temp1_max.dev_attr.attr,
891 &sensor_dev_attr_temp2_max.dev_attr.attr,
892 &sensor_dev_attr_temp3_max.dev_attr.attr,
893 &sensor_dev_attr_temp1_min.dev_attr.attr,
894 &sensor_dev_attr_temp2_min.dev_attr.attr,
895 &sensor_dev_attr_temp3_min.dev_attr.attr,
896 &sensor_dev_attr_temp1_type.dev_attr.attr,
897 &sensor_dev_attr_temp2_type.dev_attr.attr,
898 &sensor_dev_attr_temp3_type.dev_attr.attr,
899 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
900 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
901 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
903 &dev_attr_alarms.attr,
908 static const struct attribute_group it87_group = {
909 .attrs = it87_attributes,
912 static struct attribute *it87_attributes_opt[] = {
913 &sensor_dev_attr_fan1_input16.dev_attr.attr,
914 &sensor_dev_attr_fan1_min16.dev_attr.attr,
915 &sensor_dev_attr_fan2_input16.dev_attr.attr,
916 &sensor_dev_attr_fan2_min16.dev_attr.attr,
917 &sensor_dev_attr_fan3_input16.dev_attr.attr,
918 &sensor_dev_attr_fan3_min16.dev_attr.attr,
919 &sensor_dev_attr_fan4_input16.dev_attr.attr,
920 &sensor_dev_attr_fan4_min16.dev_attr.attr,
921 &sensor_dev_attr_fan5_input16.dev_attr.attr,
922 &sensor_dev_attr_fan5_min16.dev_attr.attr,
924 &sensor_dev_attr_fan1_input.dev_attr.attr,
925 &sensor_dev_attr_fan1_min.dev_attr.attr,
926 &sensor_dev_attr_fan1_div.dev_attr.attr,
927 &sensor_dev_attr_fan2_input.dev_attr.attr,
928 &sensor_dev_attr_fan2_min.dev_attr.attr,
929 &sensor_dev_attr_fan2_div.dev_attr.attr,
930 &sensor_dev_attr_fan3_input.dev_attr.attr,
931 &sensor_dev_attr_fan3_min.dev_attr.attr,
932 &sensor_dev_attr_fan3_div.dev_attr.attr,
934 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
935 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
936 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
937 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
938 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
940 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
941 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
942 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
943 &sensor_dev_attr_pwm1.dev_attr.attr,
944 &sensor_dev_attr_pwm2.dev_attr.attr,
945 &sensor_dev_attr_pwm3.dev_attr.attr,
946 &dev_attr_pwm1_freq.attr,
947 &dev_attr_pwm2_freq.attr,
948 &dev_attr_pwm3_freq.attr,
951 &dev_attr_cpu0_vid.attr,
955 static const struct attribute_group it87_group_opt = {
956 .attrs = it87_attributes_opt,
959 /* SuperIO detection - will change isa_address if a chip is found */
960 static int __init it87_find(unsigned short *address,
961 struct it87_sio_data *sio_data)
967 chip_type = force_id ? force_id : superio_inw(DEVID);
971 sio_data->type = it87;
974 sio_data->type = it8712;
978 sio_data->type = it8716;
981 sio_data->type = it8718;
983 case 0xffff: /* No device at all */
986 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
992 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
993 pr_info("it87: Device not activated, skipping\n");
997 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
999 pr_info("it87: Base address not set, skipping\n");
1004 sio_data->revision = superio_inb(DEVREV) & 0x0f;
1005 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
1006 chip_type, *address, sio_data->revision);
1008 /* Read GPIO config and VID value from LDN 7 (GPIO) */
1009 if (chip_type != IT8705F_DEVID) {
1012 superio_select(GPIO);
1013 if (chip_type == it8718)
1014 sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
1016 reg = superio_inb(IT87_SIO_PINX2_REG);
1018 pr_info("it87: in3 is VCC (+5V)\n");
1020 pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
1028 static int __devinit it87_probe(struct platform_device *pdev)
1030 struct it87_data *data;
1031 struct resource *res;
1032 struct device *dev = &pdev->dev;
1033 struct it87_sio_data *sio_data = dev->platform_data;
1035 int enable_pwm_interface;
1036 static const char *names[] = {
1043 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1044 if (!request_region(res->start, IT87_EC_EXTENT, DRVNAME)) {
1045 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1046 (unsigned long)res->start,
1047 (unsigned long)(res->start + IT87_EC_EXTENT - 1));
1052 if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
1057 data->addr = res->start;
1058 data->type = sio_data->type;
1059 data->revision = sio_data->revision;
1060 data->name = names[sio_data->type];
1062 /* Now, we do the remaining detection. */
1063 if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80)
1064 || it87_read_value(data, IT87_REG_CHIPID) != 0x90) {
1069 platform_set_drvdata(pdev, data);
1071 mutex_init(&data->update_lock);
1073 /* Check PWM configuration */
1074 enable_pwm_interface = it87_check_pwm(dev);
1076 /* Initialize the IT87 chip */
1077 it87_init_device(pdev);
1079 /* Register sysfs hooks */
1080 if ((err = sysfs_create_group(&dev->kobj, &it87_group)))
1083 /* Do not create fan files for disabled fans */
1084 if (has_16bit_fans(data)) {
1085 /* 16-bit tachometers */
1086 if (data->has_fan & (1 << 0)) {
1087 if ((err = device_create_file(dev,
1088 &sensor_dev_attr_fan1_input16.dev_attr))
1089 || (err = device_create_file(dev,
1090 &sensor_dev_attr_fan1_min16.dev_attr))
1091 || (err = device_create_file(dev,
1092 &sensor_dev_attr_fan1_alarm.dev_attr)))
1095 if (data->has_fan & (1 << 1)) {
1096 if ((err = device_create_file(dev,
1097 &sensor_dev_attr_fan2_input16.dev_attr))
1098 || (err = device_create_file(dev,
1099 &sensor_dev_attr_fan2_min16.dev_attr))
1100 || (err = device_create_file(dev,
1101 &sensor_dev_attr_fan2_alarm.dev_attr)))
1104 if (data->has_fan & (1 << 2)) {
1105 if ((err = device_create_file(dev,
1106 &sensor_dev_attr_fan3_input16.dev_attr))
1107 || (err = device_create_file(dev,
1108 &sensor_dev_attr_fan3_min16.dev_attr))
1109 || (err = device_create_file(dev,
1110 &sensor_dev_attr_fan3_alarm.dev_attr)))
1113 if (data->has_fan & (1 << 3)) {
1114 if ((err = device_create_file(dev,
1115 &sensor_dev_attr_fan4_input16.dev_attr))
1116 || (err = device_create_file(dev,
1117 &sensor_dev_attr_fan4_min16.dev_attr))
1118 || (err = device_create_file(dev,
1119 &sensor_dev_attr_fan4_alarm.dev_attr)))
1122 if (data->has_fan & (1 << 4)) {
1123 if ((err = device_create_file(dev,
1124 &sensor_dev_attr_fan5_input16.dev_attr))
1125 || (err = device_create_file(dev,
1126 &sensor_dev_attr_fan5_min16.dev_attr))
1127 || (err = device_create_file(dev,
1128 &sensor_dev_attr_fan5_alarm.dev_attr)))
1132 /* 8-bit tachometers with clock divider */
1133 if (data->has_fan & (1 << 0)) {
1134 if ((err = device_create_file(dev,
1135 &sensor_dev_attr_fan1_input.dev_attr))
1136 || (err = device_create_file(dev,
1137 &sensor_dev_attr_fan1_min.dev_attr))
1138 || (err = device_create_file(dev,
1139 &sensor_dev_attr_fan1_div.dev_attr))
1140 || (err = device_create_file(dev,
1141 &sensor_dev_attr_fan1_alarm.dev_attr)))
1144 if (data->has_fan & (1 << 1)) {
1145 if ((err = device_create_file(dev,
1146 &sensor_dev_attr_fan2_input.dev_attr))
1147 || (err = device_create_file(dev,
1148 &sensor_dev_attr_fan2_min.dev_attr))
1149 || (err = device_create_file(dev,
1150 &sensor_dev_attr_fan2_div.dev_attr))
1151 || (err = device_create_file(dev,
1152 &sensor_dev_attr_fan2_alarm.dev_attr)))
1155 if (data->has_fan & (1 << 2)) {
1156 if ((err = device_create_file(dev,
1157 &sensor_dev_attr_fan3_input.dev_attr))
1158 || (err = device_create_file(dev,
1159 &sensor_dev_attr_fan3_min.dev_attr))
1160 || (err = device_create_file(dev,
1161 &sensor_dev_attr_fan3_div.dev_attr))
1162 || (err = device_create_file(dev,
1163 &sensor_dev_attr_fan3_alarm.dev_attr)))
1168 if (enable_pwm_interface) {
1169 if ((err = device_create_file(dev,
1170 &sensor_dev_attr_pwm1_enable.dev_attr))
1171 || (err = device_create_file(dev,
1172 &sensor_dev_attr_pwm2_enable.dev_attr))
1173 || (err = device_create_file(dev,
1174 &sensor_dev_attr_pwm3_enable.dev_attr))
1175 || (err = device_create_file(dev,
1176 &sensor_dev_attr_pwm1.dev_attr))
1177 || (err = device_create_file(dev,
1178 &sensor_dev_attr_pwm2.dev_attr))
1179 || (err = device_create_file(dev,
1180 &sensor_dev_attr_pwm3.dev_attr))
1181 || (err = device_create_file(dev,
1182 &dev_attr_pwm1_freq))
1183 || (err = device_create_file(dev,
1184 &dev_attr_pwm2_freq))
1185 || (err = device_create_file(dev,
1186 &dev_attr_pwm3_freq)))
1190 if (data->type == it8712 || data->type == it8716
1191 || data->type == it8718) {
1192 data->vrm = vid_which_vrm();
1193 /* VID reading from Super-I/O config space if available */
1194 data->vid = sio_data->vid_value;
1195 if ((err = device_create_file(dev,
1197 || (err = device_create_file(dev,
1198 &dev_attr_cpu0_vid)))
1202 data->hwmon_dev = hwmon_device_register(dev);
1203 if (IS_ERR(data->hwmon_dev)) {
1204 err = PTR_ERR(data->hwmon_dev);
1211 sysfs_remove_group(&dev->kobj, &it87_group);
1212 sysfs_remove_group(&dev->kobj, &it87_group_opt);
1214 platform_set_drvdata(pdev, NULL);
1217 release_region(res->start, IT87_EC_EXTENT);
1222 static int __devexit it87_remove(struct platform_device *pdev)
1224 struct it87_data *data = platform_get_drvdata(pdev);
1226 hwmon_device_unregister(data->hwmon_dev);
1227 sysfs_remove_group(&pdev->dev.kobj, &it87_group);
1228 sysfs_remove_group(&pdev->dev.kobj, &it87_group_opt);
1230 release_region(data->addr, IT87_EC_EXTENT);
1231 platform_set_drvdata(pdev, NULL);
1237 /* Must be called with data->update_lock held, except during initialization.
1238 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1239 would slow down the IT87 access and should not be necessary. */
1240 static int it87_read_value(struct it87_data *data, u8 reg)
1242 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1243 return inb_p(data->addr + IT87_DATA_REG_OFFSET);
1246 /* Must be called with data->update_lock held, except during initialization.
1247 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1248 would slow down the IT87 access and should not be necessary. */
1249 static void it87_write_value(struct it87_data *data, u8 reg, u8 value)
1251 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1252 outb_p(value, data->addr + IT87_DATA_REG_OFFSET);
1255 /* Return 1 if and only if the PWM interface is safe to use */
1256 static int __devinit it87_check_pwm(struct device *dev)
1258 struct it87_data *data = dev_get_drvdata(dev);
1259 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
1260 * and polarity set to active low is sign that this is the case so we
1261 * disable pwm control to protect the user. */
1262 int tmp = it87_read_value(data, IT87_REG_FAN_CTL);
1263 if ((tmp & 0x87) == 0) {
1264 if (fix_pwm_polarity) {
1265 /* The user asks us to attempt a chip reconfiguration.
1266 * This means switching to active high polarity and
1267 * inverting all fan speed values. */
1271 for (i = 0; i < 3; i++)
1272 pwm[i] = it87_read_value(data,
1275 /* If any fan is in automatic pwm mode, the polarity
1276 * might be correct, as suspicious as it seems, so we
1277 * better don't change anything (but still disable the
1278 * PWM interface). */
1279 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1280 dev_info(dev, "Reconfiguring PWM to "
1281 "active high polarity\n");
1282 it87_write_value(data, IT87_REG_FAN_CTL,
1284 for (i = 0; i < 3; i++)
1285 it87_write_value(data,
1291 dev_info(dev, "PWM configuration is "
1292 "too broken to be fixed\n");
1295 dev_info(dev, "Detected broken BIOS "
1296 "defaults, disabling PWM interface\n");
1298 } else if (fix_pwm_polarity) {
1299 dev_info(dev, "PWM configuration looks "
1300 "sane, won't touch\n");
1306 /* Called when we have found a new IT87. */
1307 static void __devinit it87_init_device(struct platform_device *pdev)
1309 struct it87_data *data = platform_get_drvdata(pdev);
1312 /* initialize to sane defaults:
1313 * - if the chip is in manual pwm mode, this will be overwritten with
1314 * the actual settings on the chip (so in this case, initialization
1316 * - if in automatic or on/off mode, we could switch to manual mode,
1317 * read the registers and set manual_pwm_ctl accordingly, but currently
1318 * this is not implemented, so we initialize to something sane */
1319 for (i = 0; i < 3; i++) {
1320 data->manual_pwm_ctl[i] = 0xff;
1323 /* Some chips seem to have default value 0xff for all limit
1324 * registers. For low voltage limits it makes no sense and triggers
1325 * alarms, so change to 0 instead. For high temperature limits, it
1326 * means -1 degree C, which surprisingly doesn't trigger an alarm,
1327 * but is still confusing, so change to 127 degrees C. */
1328 for (i = 0; i < 8; i++) {
1329 tmp = it87_read_value(data, IT87_REG_VIN_MIN(i));
1331 it87_write_value(data, IT87_REG_VIN_MIN(i), 0);
1333 for (i = 0; i < 3; i++) {
1334 tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1336 it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127);
1339 /* Check if temperature channnels are reset manually or by some reason */
1340 tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1341 if ((tmp & 0x3f) == 0) {
1342 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1343 tmp = (tmp & 0xc0) | 0x2a;
1344 it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp);
1348 /* Check if voltage monitors are reset manually or by some reason */
1349 tmp = it87_read_value(data, IT87_REG_VIN_ENABLE);
1350 if ((tmp & 0xff) == 0) {
1351 /* Enable all voltage monitors */
1352 it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff);
1355 /* Check if tachometers are reset manually or by some reason */
1356 data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
1357 if ((data->fan_main_ctrl & 0x70) == 0) {
1358 /* Enable all fan tachometers */
1359 data->fan_main_ctrl |= 0x70;
1360 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1362 data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
1364 /* Set tachometers to 16-bit mode if needed */
1365 if (has_16bit_fans(data)) {
1366 tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
1367 if (~tmp & 0x07 & data->has_fan) {
1369 "Setting fan1-3 to 16-bit mode\n");
1370 it87_write_value(data, IT87_REG_FAN_16BIT,
1374 data->has_fan |= (1 << 3); /* fan4 enabled */
1376 data->has_fan |= (1 << 4); /* fan5 enabled */
1379 /* Set current fan mode registers and the default settings for the
1380 * other mode registers */
1381 for (i = 0; i < 3; i++) {
1382 if (data->fan_main_ctrl & (1 << i)) {
1384 tmp = it87_read_value(data, IT87_REG_PWM(i));
1386 /* automatic pwm - not yet implemented, but
1387 * leave the settings made by the BIOS alone
1388 * until a change is requested via the sysfs
1392 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1397 /* Start monitoring */
1398 it87_write_value(data, IT87_REG_CONFIG,
1399 (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
1400 | (update_vbat ? 0x41 : 0x01));
1403 static struct it87_data *it87_update_device(struct device *dev)
1405 struct it87_data *data = dev_get_drvdata(dev);
1408 mutex_lock(&data->update_lock);
1410 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1414 /* Cleared after each update, so reenable. Value
1415 returned by this read will be previous value */
1416 it87_write_value(data, IT87_REG_CONFIG,
1417 it87_read_value(data, IT87_REG_CONFIG) | 0x40);
1419 for (i = 0; i <= 7; i++) {
1421 it87_read_value(data, IT87_REG_VIN(i));
1423 it87_read_value(data, IT87_REG_VIN_MIN(i));
1425 it87_read_value(data, IT87_REG_VIN_MAX(i));
1427 /* in8 (battery) has no limit registers */
1429 it87_read_value(data, IT87_REG_VIN(8));
1431 for (i = 0; i < 5; i++) {
1432 /* Skip disabled fans */
1433 if (!(data->has_fan & (1 << i)))
1437 it87_read_value(data, IT87_REG_FAN_MIN[i]);
1438 data->fan[i] = it87_read_value(data,
1440 /* Add high byte if in 16-bit mode */
1441 if (has_16bit_fans(data)) {
1442 data->fan[i] |= it87_read_value(data,
1443 IT87_REG_FANX[i]) << 8;
1444 data->fan_min[i] |= it87_read_value(data,
1445 IT87_REG_FANX_MIN[i]) << 8;
1448 for (i = 0; i < 3; i++) {
1450 it87_read_value(data, IT87_REG_TEMP(i));
1451 data->temp_high[i] =
1452 it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1454 it87_read_value(data, IT87_REG_TEMP_LOW(i));
1457 /* Newer chips don't have clock dividers */
1458 if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
1459 i = it87_read_value(data, IT87_REG_FAN_DIV);
1460 data->fan_div[0] = i & 0x07;
1461 data->fan_div[1] = (i >> 3) & 0x07;
1462 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1466 it87_read_value(data, IT87_REG_ALARM1) |
1467 (it87_read_value(data, IT87_REG_ALARM2) << 8) |
1468 (it87_read_value(data, IT87_REG_ALARM3) << 16);
1469 data->fan_main_ctrl = it87_read_value(data,
1470 IT87_REG_FAN_MAIN_CTRL);
1471 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
1473 data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1474 /* The 8705 does not have VID capability.
1475 The 8718 does not use IT87_REG_VID for the same purpose. */
1476 if (data->type == it8712 || data->type == it8716) {
1477 data->vid = it87_read_value(data, IT87_REG_VID);
1478 /* The older IT8712F revisions had only 5 VID pins,
1479 but we assume it is always safe to read 6 bits. */
1482 data->last_updated = jiffies;
1486 mutex_unlock(&data->update_lock);
1491 static int __init it87_device_add(unsigned short address,
1492 const struct it87_sio_data *sio_data)
1494 struct resource res = {
1495 .start = address + IT87_EC_OFFSET,
1496 .end = address + IT87_EC_OFFSET + IT87_EC_EXTENT - 1,
1498 .flags = IORESOURCE_IO,
1502 pdev = platform_device_alloc(DRVNAME, address);
1505 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1509 err = platform_device_add_resources(pdev, &res, 1);
1511 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1513 goto exit_device_put;
1516 err = platform_device_add_data(pdev, sio_data,
1517 sizeof(struct it87_sio_data));
1519 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1520 goto exit_device_put;
1523 err = platform_device_add(pdev);
1525 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1527 goto exit_device_put;
1533 platform_device_put(pdev);
1538 static int __init sm_it87_init(void)
1541 unsigned short isa_address=0;
1542 struct it87_sio_data sio_data;
1544 err = it87_find(&isa_address, &sio_data);
1547 err = platform_driver_register(&it87_driver);
1551 err = it87_device_add(isa_address, &sio_data);
1553 platform_driver_unregister(&it87_driver);
1560 static void __exit sm_it87_exit(void)
1562 platform_device_unregister(pdev);
1563 platform_driver_unregister(&it87_driver);
1567 MODULE_AUTHOR("Chris Gauthron, "
1568 "Jean Delvare <khali@linux-fr.org>");
1569 MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8726F, SiS950 driver");
1570 module_param(update_vbat, bool, 0);
1571 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1572 module_param(fix_pwm_polarity, bool, 0);
1573 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1574 MODULE_LICENSE("GPL");
1576 module_init(sm_it87_init);
1577 module_exit(sm_it87_exit);