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>
54 #define DRVNAME "it87"
56 enum chips { it87, it8712, it8716, it8718, it8720 };
58 static unsigned short force_id;
59 module_param(force_id, ushort, 0);
60 MODULE_PARM_DESC(force_id, "Override the detected device ID");
62 static struct platform_device *pdev;
64 #define REG 0x2e /* The register to read/write */
65 #define DEV 0x07 /* Register: Logical device select */
66 #define VAL 0x2f /* The value to read/write */
67 #define PME 0x04 /* The device with the fan registers in it */
69 /* The device with the IT8718F/IT8720F VID value in it */
72 #define DEVID 0x20 /* Register: Device ID */
73 #define DEVREV 0x22 /* Register: Device Revision */
82 static int superio_inw(int reg)
93 superio_select(int ldn)
115 /* Logical device 4 registers */
116 #define IT8712F_DEVID 0x8712
117 #define IT8705F_DEVID 0x8705
118 #define IT8716F_DEVID 0x8716
119 #define IT8718F_DEVID 0x8718
120 #define IT8720F_DEVID 0x8720
121 #define IT8726F_DEVID 0x8726
122 #define IT87_ACT_REG 0x30
123 #define IT87_BASE_REG 0x60
125 /* Logical device 7 registers (IT8712F and later) */
126 #define IT87_SIO_PINX2_REG 0x2c /* Pin selection */
127 #define IT87_SIO_VID_REG 0xfc /* VID value */
129 /* Update battery voltage after every reading if true */
130 static int update_vbat;
132 /* Not all BIOSes properly configure the PWM registers */
133 static int fix_pwm_polarity;
135 /* Many IT87 constants specified below */
137 /* Length of ISA address segment */
138 #define IT87_EXTENT 8
140 /* Length of ISA address segment for Environmental Controller */
141 #define IT87_EC_EXTENT 2
143 /* Offset of EC registers from ISA base address */
144 #define IT87_EC_OFFSET 5
146 /* Where are the ISA address/data registers relative to the EC base address */
147 #define IT87_ADDR_REG_OFFSET 0
148 #define IT87_DATA_REG_OFFSET 1
150 /*----- The IT87 registers -----*/
152 #define IT87_REG_CONFIG 0x00
154 #define IT87_REG_ALARM1 0x01
155 #define IT87_REG_ALARM2 0x02
156 #define IT87_REG_ALARM3 0x03
158 /* The IT8718F and IT8720F have the VID value in a different register, in
159 Super-I/O configuration space. */
160 #define IT87_REG_VID 0x0a
161 /* The IT8705F and IT8712F earlier than revision 0x08 use register 0x0b
162 for fan divisors. Later IT8712F revisions must use 16-bit tachometer
164 #define IT87_REG_FAN_DIV 0x0b
165 #define IT87_REG_FAN_16BIT 0x0c
167 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
169 static const u8 IT87_REG_FAN[] = { 0x0d, 0x0e, 0x0f, 0x80, 0x82 };
170 static const u8 IT87_REG_FAN_MIN[] = { 0x10, 0x11, 0x12, 0x84, 0x86 };
171 static const u8 IT87_REG_FANX[] = { 0x18, 0x19, 0x1a, 0x81, 0x83 };
172 static const u8 IT87_REG_FANX_MIN[] = { 0x1b, 0x1c, 0x1d, 0x85, 0x87 };
173 #define IT87_REG_FAN_MAIN_CTRL 0x13
174 #define IT87_REG_FAN_CTL 0x14
175 #define IT87_REG_PWM(nr) (0x15 + (nr))
177 #define IT87_REG_VIN(nr) (0x20 + (nr))
178 #define IT87_REG_TEMP(nr) (0x29 + (nr))
180 #define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2)
181 #define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2)
182 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
183 #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2)
185 #define IT87_REG_VIN_ENABLE 0x50
186 #define IT87_REG_TEMP_ENABLE 0x51
188 #define IT87_REG_CHIPID 0x58
190 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
191 #define IN_FROM_REG(val) ((val) * 16)
193 static inline u8 FAN_TO_REG(long rpm, int div)
197 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
198 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
202 static inline u16 FAN16_TO_REG(long rpm)
206 return SENSORS_LIMIT((1350000 + rpm) / (rpm * 2), 1, 0xfffe);
209 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
210 /* The divider is fixed to 2 in 16-bit mode */
211 #define FAN16_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:1350000/((val)*2))
213 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
214 ((val)+500)/1000),-128,127))
215 #define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
217 #define PWM_TO_REG(val) ((val) >> 1)
218 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
220 static int DIV_TO_REG(int val)
223 while (answer < 7 && (val >>= 1))
227 #define DIV_FROM_REG(val) (1 << (val))
229 static const unsigned int pwm_freq[8] = {
241 struct it87_sio_data {
243 /* Values read from Super-I/O config space */
246 /* Values set based on DMI strings */
250 /* For each registered chip, we need to keep some data in memory.
251 The structure is dynamically allocated. */
253 struct device *hwmon_dev;
259 struct mutex update_lock;
260 char valid; /* !=0 if following fields are valid */
261 unsigned long last_updated; /* In jiffies */
263 u8 in[9]; /* Register value */
264 u8 in_max[8]; /* Register value */
265 u8 in_min[8]; /* Register value */
266 u8 has_fan; /* Bitfield, fans enabled */
267 u16 fan[5]; /* Register values, possibly combined */
268 u16 fan_min[5]; /* Register values, possibly combined */
269 u8 temp[3]; /* Register value */
270 u8 temp_high[3]; /* Register value */
271 u8 temp_low[3]; /* Register value */
272 u8 sensor; /* Register value */
273 u8 fan_div[3]; /* Register encoding, shifted right */
274 u8 vid; /* Register encoding, combined */
276 u32 alarms; /* Register encoding, combined */
277 u8 fan_main_ctrl; /* Register value */
278 u8 fan_ctl; /* Register value */
279 u8 manual_pwm_ctl[3]; /* manual PWM value set by user */
282 static inline int has_16bit_fans(const struct it87_data *data)
284 /* IT8705F Datasheet 0.4.1, 3h == Version G.
285 IT8712F Datasheet 0.9.1, section 8.3.5 indicates 8h == Version J.
286 These are the first revisions with 16bit tachometer support. */
287 return (data->type == it87 && data->revision >= 0x03)
288 || (data->type == it8712 && data->revision >= 0x08)
289 || data->type == it8716
290 || data->type == it8718
291 || data->type == it8720;
294 static int it87_probe(struct platform_device *pdev);
295 static int __devexit it87_remove(struct platform_device *pdev);
297 static int it87_read_value(struct it87_data *data, u8 reg);
298 static void it87_write_value(struct it87_data *data, u8 reg, u8 value);
299 static struct it87_data *it87_update_device(struct device *dev);
300 static int it87_check_pwm(struct device *dev);
301 static void it87_init_device(struct platform_device *pdev);
304 static struct platform_driver it87_driver = {
306 .owner = THIS_MODULE,
310 .remove = __devexit_p(it87_remove),
313 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
316 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
317 int nr = sensor_attr->index;
319 struct it87_data *data = it87_update_device(dev);
320 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
323 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
326 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
327 int nr = sensor_attr->index;
329 struct it87_data *data = it87_update_device(dev);
330 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
333 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
336 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
337 int nr = sensor_attr->index;
339 struct it87_data *data = it87_update_device(dev);
340 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
343 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
344 const char *buf, size_t count)
346 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
347 int nr = sensor_attr->index;
349 struct it87_data *data = dev_get_drvdata(dev);
350 unsigned long val = simple_strtoul(buf, NULL, 10);
352 mutex_lock(&data->update_lock);
353 data->in_min[nr] = IN_TO_REG(val);
354 it87_write_value(data, IT87_REG_VIN_MIN(nr),
356 mutex_unlock(&data->update_lock);
359 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
360 const char *buf, size_t count)
362 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
363 int nr = sensor_attr->index;
365 struct it87_data *data = dev_get_drvdata(dev);
366 unsigned long val = simple_strtoul(buf, NULL, 10);
368 mutex_lock(&data->update_lock);
369 data->in_max[nr] = IN_TO_REG(val);
370 it87_write_value(data, IT87_REG_VIN_MAX(nr),
372 mutex_unlock(&data->update_lock);
376 #define show_in_offset(offset) \
377 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
378 show_in, NULL, offset);
380 #define limit_in_offset(offset) \
381 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
382 show_in_min, set_in_min, offset); \
383 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
384 show_in_max, set_in_max, offset);
405 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
408 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
409 int nr = sensor_attr->index;
411 struct it87_data *data = it87_update_device(dev);
412 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
414 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
417 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
418 int nr = sensor_attr->index;
420 struct it87_data *data = it87_update_device(dev);
421 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
423 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
426 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
427 int nr = sensor_attr->index;
429 struct it87_data *data = it87_update_device(dev);
430 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
432 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
433 const char *buf, size_t count)
435 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
436 int nr = sensor_attr->index;
438 struct it87_data *data = dev_get_drvdata(dev);
439 int val = simple_strtol(buf, NULL, 10);
441 mutex_lock(&data->update_lock);
442 data->temp_high[nr] = TEMP_TO_REG(val);
443 it87_write_value(data, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
444 mutex_unlock(&data->update_lock);
447 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
448 const char *buf, size_t count)
450 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
451 int nr = sensor_attr->index;
453 struct it87_data *data = dev_get_drvdata(dev);
454 int val = simple_strtol(buf, NULL, 10);
456 mutex_lock(&data->update_lock);
457 data->temp_low[nr] = TEMP_TO_REG(val);
458 it87_write_value(data, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
459 mutex_unlock(&data->update_lock);
462 #define show_temp_offset(offset) \
463 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
464 show_temp, NULL, offset - 1); \
465 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
466 show_temp_max, set_temp_max, offset - 1); \
467 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
468 show_temp_min, set_temp_min, offset - 1);
474 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
477 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
478 int nr = sensor_attr->index;
480 struct it87_data *data = it87_update_device(dev);
481 u8 reg = data->sensor; /* In case the value is updated while we use it */
484 return sprintf(buf, "3\n"); /* thermal diode */
486 return sprintf(buf, "4\n"); /* thermistor */
487 return sprintf(buf, "0\n"); /* disabled */
489 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
490 const char *buf, size_t count)
492 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
493 int nr = sensor_attr->index;
495 struct it87_data *data = dev_get_drvdata(dev);
496 int val = simple_strtol(buf, NULL, 10);
498 mutex_lock(&data->update_lock);
500 data->sensor &= ~(1 << nr);
501 data->sensor &= ~(8 << nr);
502 if (val == 2) { /* backwards compatibility */
503 dev_warn(dev, "Sensor type 2 is deprecated, please use 4 "
507 /* 3 = thermal diode; 4 = thermistor; 0 = disabled */
509 data->sensor |= 1 << nr;
511 data->sensor |= 8 << nr;
513 mutex_unlock(&data->update_lock);
516 it87_write_value(data, IT87_REG_TEMP_ENABLE, data->sensor);
517 mutex_unlock(&data->update_lock);
520 #define show_sensor_offset(offset) \
521 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
522 show_sensor, set_sensor, offset - 1);
524 show_sensor_offset(1);
525 show_sensor_offset(2);
526 show_sensor_offset(3);
529 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
532 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
533 int nr = sensor_attr->index;
535 struct it87_data *data = it87_update_device(dev);
536 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
537 DIV_FROM_REG(data->fan_div[nr])));
539 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
542 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
543 int nr = sensor_attr->index;
545 struct it87_data *data = it87_update_device(dev);
546 return sprintf(buf,"%d\n",
547 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
549 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
552 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
553 int nr = sensor_attr->index;
555 struct it87_data *data = it87_update_device(dev);
556 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
558 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
561 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
562 int nr = sensor_attr->index;
564 struct it87_data *data = it87_update_device(dev);
565 return sprintf(buf,"%d\n", (data->fan_main_ctrl & (1 << nr)) ? 1 : 0);
567 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
570 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
571 int nr = sensor_attr->index;
573 struct it87_data *data = it87_update_device(dev);
574 return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]);
576 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
579 struct it87_data *data = it87_update_device(dev);
580 int index = (data->fan_ctl >> 4) & 0x07;
582 return sprintf(buf, "%u\n", pwm_freq[index]);
584 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
585 const char *buf, size_t count)
587 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
588 int nr = sensor_attr->index;
590 struct it87_data *data = dev_get_drvdata(dev);
591 int val = simple_strtol(buf, NULL, 10);
594 mutex_lock(&data->update_lock);
595 reg = it87_read_value(data, IT87_REG_FAN_DIV);
597 case 0: data->fan_div[nr] = reg & 0x07; break;
598 case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
599 case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break;
602 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
603 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
604 mutex_unlock(&data->update_lock);
607 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
608 const char *buf, size_t count)
610 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
611 int nr = sensor_attr->index;
613 struct it87_data *data = dev_get_drvdata(dev);
614 unsigned long val = simple_strtoul(buf, NULL, 10);
618 mutex_lock(&data->update_lock);
619 old = it87_read_value(data, IT87_REG_FAN_DIV);
621 /* Save fan min limit */
622 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
627 data->fan_div[nr] = DIV_TO_REG(val);
631 data->fan_div[nr] = 1;
633 data->fan_div[nr] = 3;
636 val |= (data->fan_div[0] & 0x07);
637 val |= (data->fan_div[1] & 0x07) << 3;
638 if (data->fan_div[2] == 3)
640 it87_write_value(data, IT87_REG_FAN_DIV, val);
642 /* Restore fan min limit */
643 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
644 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
646 mutex_unlock(&data->update_lock);
649 static ssize_t set_pwm_enable(struct device *dev,
650 struct device_attribute *attr, const char *buf, size_t count)
652 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
653 int nr = sensor_attr->index;
655 struct it87_data *data = dev_get_drvdata(dev);
656 int val = simple_strtol(buf, NULL, 10);
658 mutex_lock(&data->update_lock);
662 /* make sure the fan is on when in on/off mode */
663 tmp = it87_read_value(data, IT87_REG_FAN_CTL);
664 it87_write_value(data, IT87_REG_FAN_CTL, tmp | (1 << nr));
665 /* set on/off mode */
666 data->fan_main_ctrl &= ~(1 << nr);
667 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
668 } else if (val == 1) {
669 /* set SmartGuardian mode */
670 data->fan_main_ctrl |= (1 << nr);
671 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
672 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
673 it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
675 mutex_unlock(&data->update_lock);
679 mutex_unlock(&data->update_lock);
682 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
683 const char *buf, size_t count)
685 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
686 int nr = sensor_attr->index;
688 struct it87_data *data = dev_get_drvdata(dev);
689 int val = simple_strtol(buf, NULL, 10);
691 if (val < 0 || val > 255)
694 mutex_lock(&data->update_lock);
695 data->manual_pwm_ctl[nr] = val;
696 if (data->fan_main_ctrl & (1 << nr))
697 it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
698 mutex_unlock(&data->update_lock);
701 static ssize_t set_pwm_freq(struct device *dev,
702 struct device_attribute *attr, const char *buf, size_t count)
704 struct it87_data *data = dev_get_drvdata(dev);
705 unsigned long val = simple_strtoul(buf, NULL, 10);
708 /* Search for the nearest available frequency */
709 for (i = 0; i < 7; i++) {
710 if (val > (pwm_freq[i] + pwm_freq[i+1]) / 2)
714 mutex_lock(&data->update_lock);
715 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL) & 0x8f;
716 data->fan_ctl |= i << 4;
717 it87_write_value(data, IT87_REG_FAN_CTL, data->fan_ctl);
718 mutex_unlock(&data->update_lock);
723 #define show_fan_offset(offset) \
724 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
725 show_fan, NULL, offset - 1); \
726 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
727 show_fan_min, set_fan_min, offset - 1); \
728 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
729 show_fan_div, set_fan_div, offset - 1);
735 #define show_pwm_offset(offset) \
736 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
737 show_pwm_enable, set_pwm_enable, offset - 1); \
738 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
739 show_pwm, set_pwm, offset - 1); \
740 static DEVICE_ATTR(pwm##offset##_freq, \
741 (offset == 1 ? S_IRUGO | S_IWUSR : S_IRUGO), \
742 show_pwm_freq, (offset == 1 ? set_pwm_freq : NULL));
748 /* A different set of callbacks for 16-bit fans */
749 static ssize_t show_fan16(struct device *dev, struct device_attribute *attr,
752 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
753 int nr = sensor_attr->index;
754 struct it87_data *data = it87_update_device(dev);
755 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan[nr]));
758 static ssize_t show_fan16_min(struct device *dev, struct device_attribute *attr,
761 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
762 int nr = sensor_attr->index;
763 struct it87_data *data = it87_update_device(dev);
764 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan_min[nr]));
767 static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr,
768 const char *buf, size_t count)
770 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
771 int nr = sensor_attr->index;
772 struct it87_data *data = dev_get_drvdata(dev);
773 int val = simple_strtol(buf, NULL, 10);
775 mutex_lock(&data->update_lock);
776 data->fan_min[nr] = FAN16_TO_REG(val);
777 it87_write_value(data, IT87_REG_FAN_MIN[nr],
778 data->fan_min[nr] & 0xff);
779 it87_write_value(data, IT87_REG_FANX_MIN[nr],
780 data->fan_min[nr] >> 8);
781 mutex_unlock(&data->update_lock);
785 /* We want to use the same sysfs file names as 8-bit fans, but we need
786 different variable names, so we have to use SENSOR_ATTR instead of
787 SENSOR_DEVICE_ATTR. */
788 #define show_fan16_offset(offset) \
789 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \
790 = SENSOR_ATTR(fan##offset##_input, S_IRUGO, \
791 show_fan16, NULL, offset - 1); \
792 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \
793 = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
794 show_fan16_min, set_fan16_min, offset - 1)
796 show_fan16_offset(1);
797 show_fan16_offset(2);
798 show_fan16_offset(3);
799 show_fan16_offset(4);
800 show_fan16_offset(5);
803 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
805 struct it87_data *data = it87_update_device(dev);
806 return sprintf(buf, "%u\n", data->alarms);
808 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
810 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
813 int bitnr = to_sensor_dev_attr(attr)->index;
814 struct it87_data *data = it87_update_device(dev);
815 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
817 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8);
818 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9);
819 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10);
820 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11);
821 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12);
822 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13);
823 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14);
824 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15);
825 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
826 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1);
827 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 2);
828 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 3);
829 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 6);
830 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 16);
831 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 17);
832 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 18);
835 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
837 struct it87_data *data = dev_get_drvdata(dev);
838 return sprintf(buf, "%u\n", data->vrm);
841 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
843 struct it87_data *data = dev_get_drvdata(dev);
846 val = simple_strtoul(buf, NULL, 10);
851 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
854 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
856 struct it87_data *data = it87_update_device(dev);
857 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
859 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
861 static ssize_t show_name(struct device *dev, struct device_attribute
864 struct it87_data *data = dev_get_drvdata(dev);
865 return sprintf(buf, "%s\n", data->name);
867 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
869 static struct attribute *it87_attributes[] = {
870 &sensor_dev_attr_in0_input.dev_attr.attr,
871 &sensor_dev_attr_in1_input.dev_attr.attr,
872 &sensor_dev_attr_in2_input.dev_attr.attr,
873 &sensor_dev_attr_in3_input.dev_attr.attr,
874 &sensor_dev_attr_in4_input.dev_attr.attr,
875 &sensor_dev_attr_in5_input.dev_attr.attr,
876 &sensor_dev_attr_in6_input.dev_attr.attr,
877 &sensor_dev_attr_in7_input.dev_attr.attr,
878 &sensor_dev_attr_in8_input.dev_attr.attr,
879 &sensor_dev_attr_in0_min.dev_attr.attr,
880 &sensor_dev_attr_in1_min.dev_attr.attr,
881 &sensor_dev_attr_in2_min.dev_attr.attr,
882 &sensor_dev_attr_in3_min.dev_attr.attr,
883 &sensor_dev_attr_in4_min.dev_attr.attr,
884 &sensor_dev_attr_in5_min.dev_attr.attr,
885 &sensor_dev_attr_in6_min.dev_attr.attr,
886 &sensor_dev_attr_in7_min.dev_attr.attr,
887 &sensor_dev_attr_in0_max.dev_attr.attr,
888 &sensor_dev_attr_in1_max.dev_attr.attr,
889 &sensor_dev_attr_in2_max.dev_attr.attr,
890 &sensor_dev_attr_in3_max.dev_attr.attr,
891 &sensor_dev_attr_in4_max.dev_attr.attr,
892 &sensor_dev_attr_in5_max.dev_attr.attr,
893 &sensor_dev_attr_in6_max.dev_attr.attr,
894 &sensor_dev_attr_in7_max.dev_attr.attr,
895 &sensor_dev_attr_in0_alarm.dev_attr.attr,
896 &sensor_dev_attr_in1_alarm.dev_attr.attr,
897 &sensor_dev_attr_in2_alarm.dev_attr.attr,
898 &sensor_dev_attr_in3_alarm.dev_attr.attr,
899 &sensor_dev_attr_in4_alarm.dev_attr.attr,
900 &sensor_dev_attr_in5_alarm.dev_attr.attr,
901 &sensor_dev_attr_in6_alarm.dev_attr.attr,
902 &sensor_dev_attr_in7_alarm.dev_attr.attr,
904 &sensor_dev_attr_temp1_input.dev_attr.attr,
905 &sensor_dev_attr_temp2_input.dev_attr.attr,
906 &sensor_dev_attr_temp3_input.dev_attr.attr,
907 &sensor_dev_attr_temp1_max.dev_attr.attr,
908 &sensor_dev_attr_temp2_max.dev_attr.attr,
909 &sensor_dev_attr_temp3_max.dev_attr.attr,
910 &sensor_dev_attr_temp1_min.dev_attr.attr,
911 &sensor_dev_attr_temp2_min.dev_attr.attr,
912 &sensor_dev_attr_temp3_min.dev_attr.attr,
913 &sensor_dev_attr_temp1_type.dev_attr.attr,
914 &sensor_dev_attr_temp2_type.dev_attr.attr,
915 &sensor_dev_attr_temp3_type.dev_attr.attr,
916 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
917 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
918 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
920 &dev_attr_alarms.attr,
925 static const struct attribute_group it87_group = {
926 .attrs = it87_attributes,
929 static struct attribute *it87_attributes_opt[] = {
930 &sensor_dev_attr_fan1_input16.dev_attr.attr,
931 &sensor_dev_attr_fan1_min16.dev_attr.attr,
932 &sensor_dev_attr_fan2_input16.dev_attr.attr,
933 &sensor_dev_attr_fan2_min16.dev_attr.attr,
934 &sensor_dev_attr_fan3_input16.dev_attr.attr,
935 &sensor_dev_attr_fan3_min16.dev_attr.attr,
936 &sensor_dev_attr_fan4_input16.dev_attr.attr,
937 &sensor_dev_attr_fan4_min16.dev_attr.attr,
938 &sensor_dev_attr_fan5_input16.dev_attr.attr,
939 &sensor_dev_attr_fan5_min16.dev_attr.attr,
941 &sensor_dev_attr_fan1_input.dev_attr.attr,
942 &sensor_dev_attr_fan1_min.dev_attr.attr,
943 &sensor_dev_attr_fan1_div.dev_attr.attr,
944 &sensor_dev_attr_fan2_input.dev_attr.attr,
945 &sensor_dev_attr_fan2_min.dev_attr.attr,
946 &sensor_dev_attr_fan2_div.dev_attr.attr,
947 &sensor_dev_attr_fan3_input.dev_attr.attr,
948 &sensor_dev_attr_fan3_min.dev_attr.attr,
949 &sensor_dev_attr_fan3_div.dev_attr.attr,
951 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
952 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
953 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
954 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
955 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
957 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
958 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
959 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
960 &sensor_dev_attr_pwm1.dev_attr.attr,
961 &sensor_dev_attr_pwm2.dev_attr.attr,
962 &sensor_dev_attr_pwm3.dev_attr.attr,
963 &dev_attr_pwm1_freq.attr,
964 &dev_attr_pwm2_freq.attr,
965 &dev_attr_pwm3_freq.attr,
968 &dev_attr_cpu0_vid.attr,
972 static const struct attribute_group it87_group_opt = {
973 .attrs = it87_attributes_opt,
976 /* SuperIO detection - will change isa_address if a chip is found */
977 static int __init it87_find(unsigned short *address,
978 struct it87_sio_data *sio_data)
982 const char *board_vendor, *board_name;
985 chip_type = force_id ? force_id : superio_inw(DEVID);
989 sio_data->type = it87;
992 sio_data->type = it8712;
996 sio_data->type = it8716;
999 sio_data->type = it8718;
1002 sio_data->type = it8720;
1004 case 0xffff: /* No device at all */
1007 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
1012 superio_select(PME);
1013 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
1014 pr_info("it87: Device not activated, skipping\n");
1018 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
1019 if (*address == 0) {
1020 pr_info("it87: Base address not set, skipping\n");
1025 sio_data->revision = superio_inb(DEVREV) & 0x0f;
1026 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
1027 chip_type, *address, sio_data->revision);
1029 /* Read GPIO config and VID value from LDN 7 (GPIO) */
1030 if (chip_type != IT8705F_DEVID) {
1033 superio_select(GPIO);
1034 if ((chip_type == it8718) ||
1035 (chip_type == it8720))
1036 sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
1038 reg = superio_inb(IT87_SIO_PINX2_REG);
1040 pr_info("it87: in3 is VCC (+5V)\n");
1042 pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
1045 /* Disable specific features based on DMI strings */
1046 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1047 board_name = dmi_get_system_info(DMI_BOARD_NAME);
1048 if (board_vendor && board_name) {
1049 if (strcmp(board_vendor, "nVIDIA") == 0
1050 && strcmp(board_name, "FN68PT") == 0) {
1051 /* On the Shuttle SN68PT, FAN_CTL2 is apparently not
1052 connected to a fan, but to something else. One user
1053 has reported instant system power-off when changing
1054 the PWM2 duty cycle, so we disable it.
1055 I use the board name string as the trigger in case
1056 the same board is ever used in other systems. */
1057 pr_info("it87: Disabling pwm2 due to "
1058 "hardware constraints\n");
1059 sio_data->skip_pwm = (1 << 1);
1068 static int __devinit it87_probe(struct platform_device *pdev)
1070 struct it87_data *data;
1071 struct resource *res;
1072 struct device *dev = &pdev->dev;
1073 struct it87_sio_data *sio_data = dev->platform_data;
1075 int enable_pwm_interface;
1076 static const char *names[] = {
1084 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1085 if (!request_region(res->start, IT87_EC_EXTENT, DRVNAME)) {
1086 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1087 (unsigned long)res->start,
1088 (unsigned long)(res->start + IT87_EC_EXTENT - 1));
1093 if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
1098 data->addr = res->start;
1099 data->type = sio_data->type;
1100 data->revision = sio_data->revision;
1101 data->name = names[sio_data->type];
1103 /* Now, we do the remaining detection. */
1104 if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80)
1105 || it87_read_value(data, IT87_REG_CHIPID) != 0x90) {
1110 platform_set_drvdata(pdev, data);
1112 mutex_init(&data->update_lock);
1114 /* Check PWM configuration */
1115 enable_pwm_interface = it87_check_pwm(dev);
1117 /* Initialize the IT87 chip */
1118 it87_init_device(pdev);
1120 /* Register sysfs hooks */
1121 if ((err = sysfs_create_group(&dev->kobj, &it87_group)))
1124 /* Do not create fan files for disabled fans */
1125 if (has_16bit_fans(data)) {
1126 /* 16-bit tachometers */
1127 if (data->has_fan & (1 << 0)) {
1128 if ((err = device_create_file(dev,
1129 &sensor_dev_attr_fan1_input16.dev_attr))
1130 || (err = device_create_file(dev,
1131 &sensor_dev_attr_fan1_min16.dev_attr))
1132 || (err = device_create_file(dev,
1133 &sensor_dev_attr_fan1_alarm.dev_attr)))
1136 if (data->has_fan & (1 << 1)) {
1137 if ((err = device_create_file(dev,
1138 &sensor_dev_attr_fan2_input16.dev_attr))
1139 || (err = device_create_file(dev,
1140 &sensor_dev_attr_fan2_min16.dev_attr))
1141 || (err = device_create_file(dev,
1142 &sensor_dev_attr_fan2_alarm.dev_attr)))
1145 if (data->has_fan & (1 << 2)) {
1146 if ((err = device_create_file(dev,
1147 &sensor_dev_attr_fan3_input16.dev_attr))
1148 || (err = device_create_file(dev,
1149 &sensor_dev_attr_fan3_min16.dev_attr))
1150 || (err = device_create_file(dev,
1151 &sensor_dev_attr_fan3_alarm.dev_attr)))
1154 if (data->has_fan & (1 << 3)) {
1155 if ((err = device_create_file(dev,
1156 &sensor_dev_attr_fan4_input16.dev_attr))
1157 || (err = device_create_file(dev,
1158 &sensor_dev_attr_fan4_min16.dev_attr))
1159 || (err = device_create_file(dev,
1160 &sensor_dev_attr_fan4_alarm.dev_attr)))
1163 if (data->has_fan & (1 << 4)) {
1164 if ((err = device_create_file(dev,
1165 &sensor_dev_attr_fan5_input16.dev_attr))
1166 || (err = device_create_file(dev,
1167 &sensor_dev_attr_fan5_min16.dev_attr))
1168 || (err = device_create_file(dev,
1169 &sensor_dev_attr_fan5_alarm.dev_attr)))
1173 /* 8-bit tachometers with clock divider */
1174 if (data->has_fan & (1 << 0)) {
1175 if ((err = device_create_file(dev,
1176 &sensor_dev_attr_fan1_input.dev_attr))
1177 || (err = device_create_file(dev,
1178 &sensor_dev_attr_fan1_min.dev_attr))
1179 || (err = device_create_file(dev,
1180 &sensor_dev_attr_fan1_div.dev_attr))
1181 || (err = device_create_file(dev,
1182 &sensor_dev_attr_fan1_alarm.dev_attr)))
1185 if (data->has_fan & (1 << 1)) {
1186 if ((err = device_create_file(dev,
1187 &sensor_dev_attr_fan2_input.dev_attr))
1188 || (err = device_create_file(dev,
1189 &sensor_dev_attr_fan2_min.dev_attr))
1190 || (err = device_create_file(dev,
1191 &sensor_dev_attr_fan2_div.dev_attr))
1192 || (err = device_create_file(dev,
1193 &sensor_dev_attr_fan2_alarm.dev_attr)))
1196 if (data->has_fan & (1 << 2)) {
1197 if ((err = device_create_file(dev,
1198 &sensor_dev_attr_fan3_input.dev_attr))
1199 || (err = device_create_file(dev,
1200 &sensor_dev_attr_fan3_min.dev_attr))
1201 || (err = device_create_file(dev,
1202 &sensor_dev_attr_fan3_div.dev_attr))
1203 || (err = device_create_file(dev,
1204 &sensor_dev_attr_fan3_alarm.dev_attr)))
1209 if (enable_pwm_interface) {
1210 if (!(sio_data->skip_pwm & (1 << 0))) {
1211 if ((err = device_create_file(dev,
1212 &sensor_dev_attr_pwm1_enable.dev_attr))
1213 || (err = device_create_file(dev,
1214 &sensor_dev_attr_pwm1.dev_attr))
1215 || (err = device_create_file(dev,
1216 &dev_attr_pwm1_freq)))
1219 if (!(sio_data->skip_pwm & (1 << 1))) {
1220 if ((err = device_create_file(dev,
1221 &sensor_dev_attr_pwm2_enable.dev_attr))
1222 || (err = device_create_file(dev,
1223 &sensor_dev_attr_pwm2.dev_attr))
1224 || (err = device_create_file(dev,
1225 &dev_attr_pwm2_freq)))
1228 if (!(sio_data->skip_pwm & (1 << 2))) {
1229 if ((err = device_create_file(dev,
1230 &sensor_dev_attr_pwm3_enable.dev_attr))
1231 || (err = device_create_file(dev,
1232 &sensor_dev_attr_pwm3.dev_attr))
1233 || (err = device_create_file(dev,
1234 &dev_attr_pwm3_freq)))
1239 if (data->type == it8712 || data->type == it8716
1240 || data->type == it8718 || data->type == it8720) {
1241 data->vrm = vid_which_vrm();
1242 /* VID reading from Super-I/O config space if available */
1243 data->vid = sio_data->vid_value;
1244 if ((err = device_create_file(dev,
1246 || (err = device_create_file(dev,
1247 &dev_attr_cpu0_vid)))
1251 data->hwmon_dev = hwmon_device_register(dev);
1252 if (IS_ERR(data->hwmon_dev)) {
1253 err = PTR_ERR(data->hwmon_dev);
1260 sysfs_remove_group(&dev->kobj, &it87_group);
1261 sysfs_remove_group(&dev->kobj, &it87_group_opt);
1263 platform_set_drvdata(pdev, NULL);
1266 release_region(res->start, IT87_EC_EXTENT);
1271 static int __devexit it87_remove(struct platform_device *pdev)
1273 struct it87_data *data = platform_get_drvdata(pdev);
1275 hwmon_device_unregister(data->hwmon_dev);
1276 sysfs_remove_group(&pdev->dev.kobj, &it87_group);
1277 sysfs_remove_group(&pdev->dev.kobj, &it87_group_opt);
1279 release_region(data->addr, IT87_EC_EXTENT);
1280 platform_set_drvdata(pdev, NULL);
1286 /* Must be called with data->update_lock held, except during initialization.
1287 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1288 would slow down the IT87 access and should not be necessary. */
1289 static int it87_read_value(struct it87_data *data, u8 reg)
1291 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1292 return inb_p(data->addr + IT87_DATA_REG_OFFSET);
1295 /* Must be called with data->update_lock held, except during initialization.
1296 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1297 would slow down the IT87 access and should not be necessary. */
1298 static void it87_write_value(struct it87_data *data, u8 reg, u8 value)
1300 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1301 outb_p(value, data->addr + IT87_DATA_REG_OFFSET);
1304 /* Return 1 if and only if the PWM interface is safe to use */
1305 static int __devinit it87_check_pwm(struct device *dev)
1307 struct it87_data *data = dev_get_drvdata(dev);
1308 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
1309 * and polarity set to active low is sign that this is the case so we
1310 * disable pwm control to protect the user. */
1311 int tmp = it87_read_value(data, IT87_REG_FAN_CTL);
1312 if ((tmp & 0x87) == 0) {
1313 if (fix_pwm_polarity) {
1314 /* The user asks us to attempt a chip reconfiguration.
1315 * This means switching to active high polarity and
1316 * inverting all fan speed values. */
1320 for (i = 0; i < 3; i++)
1321 pwm[i] = it87_read_value(data,
1324 /* If any fan is in automatic pwm mode, the polarity
1325 * might be correct, as suspicious as it seems, so we
1326 * better don't change anything (but still disable the
1327 * PWM interface). */
1328 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1329 dev_info(dev, "Reconfiguring PWM to "
1330 "active high polarity\n");
1331 it87_write_value(data, IT87_REG_FAN_CTL,
1333 for (i = 0; i < 3; i++)
1334 it87_write_value(data,
1340 dev_info(dev, "PWM configuration is "
1341 "too broken to be fixed\n");
1344 dev_info(dev, "Detected broken BIOS "
1345 "defaults, disabling PWM interface\n");
1347 } else if (fix_pwm_polarity) {
1348 dev_info(dev, "PWM configuration looks "
1349 "sane, won't touch\n");
1355 /* Called when we have found a new IT87. */
1356 static void __devinit it87_init_device(struct platform_device *pdev)
1358 struct it87_data *data = platform_get_drvdata(pdev);
1361 /* initialize to sane defaults:
1362 * - if the chip is in manual pwm mode, this will be overwritten with
1363 * the actual settings on the chip (so in this case, initialization
1365 * - if in automatic or on/off mode, we could switch to manual mode,
1366 * read the registers and set manual_pwm_ctl accordingly, but currently
1367 * this is not implemented, so we initialize to something sane */
1368 for (i = 0; i < 3; i++) {
1369 data->manual_pwm_ctl[i] = 0xff;
1372 /* Some chips seem to have default value 0xff for all limit
1373 * registers. For low voltage limits it makes no sense and triggers
1374 * alarms, so change to 0 instead. For high temperature limits, it
1375 * means -1 degree C, which surprisingly doesn't trigger an alarm,
1376 * but is still confusing, so change to 127 degrees C. */
1377 for (i = 0; i < 8; i++) {
1378 tmp = it87_read_value(data, IT87_REG_VIN_MIN(i));
1380 it87_write_value(data, IT87_REG_VIN_MIN(i), 0);
1382 for (i = 0; i < 3; i++) {
1383 tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1385 it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127);
1388 /* Check if temperature channnels are reset manually or by some reason */
1389 tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1390 if ((tmp & 0x3f) == 0) {
1391 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1392 tmp = (tmp & 0xc0) | 0x2a;
1393 it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp);
1397 /* Check if voltage monitors are reset manually or by some reason */
1398 tmp = it87_read_value(data, IT87_REG_VIN_ENABLE);
1399 if ((tmp & 0xff) == 0) {
1400 /* Enable all voltage monitors */
1401 it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff);
1404 /* Check if tachometers are reset manually or by some reason */
1405 data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
1406 if ((data->fan_main_ctrl & 0x70) == 0) {
1407 /* Enable all fan tachometers */
1408 data->fan_main_ctrl |= 0x70;
1409 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1411 data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
1413 /* Set tachometers to 16-bit mode if needed */
1414 if (has_16bit_fans(data)) {
1415 tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
1416 if (~tmp & 0x07 & data->has_fan) {
1418 "Setting fan1-3 to 16-bit mode\n");
1419 it87_write_value(data, IT87_REG_FAN_16BIT,
1422 /* IT8705F only supports three fans. */
1423 if (data->type != it87) {
1425 data->has_fan |= (1 << 3); /* fan4 enabled */
1427 data->has_fan |= (1 << 4); /* fan5 enabled */
1431 /* Set current fan mode registers and the default settings for the
1432 * other mode registers */
1433 for (i = 0; i < 3; i++) {
1434 if (data->fan_main_ctrl & (1 << i)) {
1436 tmp = it87_read_value(data, IT87_REG_PWM(i));
1438 /* automatic pwm - not yet implemented, but
1439 * leave the settings made by the BIOS alone
1440 * until a change is requested via the sysfs
1444 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1449 /* Start monitoring */
1450 it87_write_value(data, IT87_REG_CONFIG,
1451 (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
1452 | (update_vbat ? 0x41 : 0x01));
1455 static struct it87_data *it87_update_device(struct device *dev)
1457 struct it87_data *data = dev_get_drvdata(dev);
1460 mutex_lock(&data->update_lock);
1462 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1466 /* Cleared after each update, so reenable. Value
1467 returned by this read will be previous value */
1468 it87_write_value(data, IT87_REG_CONFIG,
1469 it87_read_value(data, IT87_REG_CONFIG) | 0x40);
1471 for (i = 0; i <= 7; i++) {
1473 it87_read_value(data, IT87_REG_VIN(i));
1475 it87_read_value(data, IT87_REG_VIN_MIN(i));
1477 it87_read_value(data, IT87_REG_VIN_MAX(i));
1479 /* in8 (battery) has no limit registers */
1481 it87_read_value(data, IT87_REG_VIN(8));
1483 for (i = 0; i < 5; i++) {
1484 /* Skip disabled fans */
1485 if (!(data->has_fan & (1 << i)))
1489 it87_read_value(data, IT87_REG_FAN_MIN[i]);
1490 data->fan[i] = it87_read_value(data,
1492 /* Add high byte if in 16-bit mode */
1493 if (has_16bit_fans(data)) {
1494 data->fan[i] |= it87_read_value(data,
1495 IT87_REG_FANX[i]) << 8;
1496 data->fan_min[i] |= it87_read_value(data,
1497 IT87_REG_FANX_MIN[i]) << 8;
1500 for (i = 0; i < 3; i++) {
1502 it87_read_value(data, IT87_REG_TEMP(i));
1503 data->temp_high[i] =
1504 it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1506 it87_read_value(data, IT87_REG_TEMP_LOW(i));
1509 /* Newer chips don't have clock dividers */
1510 if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
1511 i = it87_read_value(data, IT87_REG_FAN_DIV);
1512 data->fan_div[0] = i & 0x07;
1513 data->fan_div[1] = (i >> 3) & 0x07;
1514 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1518 it87_read_value(data, IT87_REG_ALARM1) |
1519 (it87_read_value(data, IT87_REG_ALARM2) << 8) |
1520 (it87_read_value(data, IT87_REG_ALARM3) << 16);
1521 data->fan_main_ctrl = it87_read_value(data,
1522 IT87_REG_FAN_MAIN_CTRL);
1523 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
1525 data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1526 /* The 8705 does not have VID capability.
1527 The 8718 and the 8720 don't use IT87_REG_VID for the
1529 if (data->type == it8712 || data->type == it8716) {
1530 data->vid = it87_read_value(data, IT87_REG_VID);
1531 /* The older IT8712F revisions had only 5 VID pins,
1532 but we assume it is always safe to read 6 bits. */
1535 data->last_updated = jiffies;
1539 mutex_unlock(&data->update_lock);
1544 static int __init it87_device_add(unsigned short address,
1545 const struct it87_sio_data *sio_data)
1547 struct resource res = {
1548 .start = address + IT87_EC_OFFSET,
1549 .end = address + IT87_EC_OFFSET + IT87_EC_EXTENT - 1,
1551 .flags = IORESOURCE_IO,
1555 pdev = platform_device_alloc(DRVNAME, address);
1558 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1562 err = platform_device_add_resources(pdev, &res, 1);
1564 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1566 goto exit_device_put;
1569 err = platform_device_add_data(pdev, sio_data,
1570 sizeof(struct it87_sio_data));
1572 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1573 goto exit_device_put;
1576 err = platform_device_add(pdev);
1578 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1580 goto exit_device_put;
1586 platform_device_put(pdev);
1591 static int __init sm_it87_init(void)
1594 unsigned short isa_address=0;
1595 struct it87_sio_data sio_data;
1597 memset(&sio_data, 0, sizeof(struct it87_sio_data));
1598 err = it87_find(&isa_address, &sio_data);
1601 err = platform_driver_register(&it87_driver);
1605 err = it87_device_add(isa_address, &sio_data);
1607 platform_driver_unregister(&it87_driver);
1614 static void __exit sm_it87_exit(void)
1616 platform_device_unregister(pdev);
1617 platform_driver_unregister(&it87_driver);
1621 MODULE_AUTHOR("Chris Gauthron, "
1622 "Jean Delvare <khali@linux-fr.org>");
1623 MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8720F/8726F, SiS950 driver");
1624 module_param(update_vbat, bool, 0);
1625 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1626 module_param(fix_pwm_polarity, bool, 0);
1627 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1628 MODULE_LICENSE("GPL");
1630 module_init(sm_it87_init);
1631 module_exit(sm_it87_exit);