2 it87.c - Part of lm_sensors, Linux kernel modules for hardware
5 The IT8705F is an LPC-based Super I/O part that contains UARTs, a
6 parallel port, an IR port, a MIDI port, a floppy controller, etc., in
7 addition to an Environment Controller (Enhanced Hardware Monitor and
10 This driver supports only the Environment Controller in the IT8705F and
11 similar parts. The other devices are supported by different drivers.
13 Supports: IT8705F Super I/O chip w/LPC interface
14 IT8712F Super I/O chip w/LPC interface
15 IT8716F Super I/O chip w/LPC interface
16 IT8718F Super I/O chip w/LPC interface
17 IT8720F Super I/O chip w/LPC interface
18 IT8726F Super I/O chip w/LPC interface
19 Sis950 A clone of the IT8705F
21 Copyright (C) 2001 Chris Gauthron
22 Copyright (C) 2005-2007 Jean Delvare <khali@linux-fr.org>
24 This program is free software; you can redistribute it and/or modify
25 it under the terms of the GNU General Public License as published by
26 the Free Software Foundation; either version 2 of the License, or
27 (at your option) any later version.
29 This program is distributed in the hope that it will be useful,
30 but WITHOUT ANY WARRANTY; without even the implied warranty of
31 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 GNU General Public License for more details.
34 You should have received a copy of the GNU General Public License
35 along with this program; if not, write to the Free Software
36 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
39 #include <linux/module.h>
40 #include <linux/init.h>
41 #include <linux/slab.h>
42 #include <linux/jiffies.h>
43 #include <linux/platform_device.h>
44 #include <linux/hwmon.h>
45 #include <linux/hwmon-sysfs.h>
46 #include <linux/hwmon-vid.h>
47 #include <linux/err.h>
48 #include <linux/mutex.h>
49 #include <linux/sysfs.h>
50 #include <linux/string.h>
51 #include <linux/dmi.h>
52 #include <linux/acpi.h>
55 #define DRVNAME "it87"
57 enum chips { it87, it8712, it8716, it8718, it8720 };
59 static unsigned short force_id;
60 module_param(force_id, ushort, 0);
61 MODULE_PARM_DESC(force_id, "Override the detected device ID");
63 static struct platform_device *pdev;
65 #define REG 0x2e /* The register to read/write */
66 #define DEV 0x07 /* Register: Logical device select */
67 #define VAL 0x2f /* The value to read/write */
68 #define PME 0x04 /* The device with the fan registers in it */
70 /* The device with the IT8718F/IT8720F VID value in it */
73 #define DEVID 0x20 /* Register: Device ID */
74 #define DEVREV 0x22 /* Register: Device Revision */
84 superio_outb(int reg, int val)
90 static int superio_inw(int reg)
101 superio_select(int ldn)
123 /* Logical device 4 registers */
124 #define IT8712F_DEVID 0x8712
125 #define IT8705F_DEVID 0x8705
126 #define IT8716F_DEVID 0x8716
127 #define IT8718F_DEVID 0x8718
128 #define IT8720F_DEVID 0x8720
129 #define IT8726F_DEVID 0x8726
130 #define IT87_ACT_REG 0x30
131 #define IT87_BASE_REG 0x60
133 /* Logical device 7 registers (IT8712F and later) */
134 #define IT87_SIO_PINX2_REG 0x2c /* Pin selection */
135 #define IT87_SIO_VID_REG 0xfc /* VID value */
137 /* Update battery voltage after every reading if true */
138 static int update_vbat;
140 /* Not all BIOSes properly configure the PWM registers */
141 static int fix_pwm_polarity;
143 /* Many IT87 constants specified below */
145 /* Length of ISA address segment */
146 #define IT87_EXTENT 8
148 /* Length of ISA address segment for Environmental Controller */
149 #define IT87_EC_EXTENT 2
151 /* Offset of EC registers from ISA base address */
152 #define IT87_EC_OFFSET 5
154 /* Where are the ISA address/data registers relative to the EC base address */
155 #define IT87_ADDR_REG_OFFSET 0
156 #define IT87_DATA_REG_OFFSET 1
158 /*----- The IT87 registers -----*/
160 #define IT87_REG_CONFIG 0x00
162 #define IT87_REG_ALARM1 0x01
163 #define IT87_REG_ALARM2 0x02
164 #define IT87_REG_ALARM3 0x03
166 /* The IT8718F and IT8720F have the VID value in a different register, in
167 Super-I/O configuration space. */
168 #define IT87_REG_VID 0x0a
169 /* The IT8705F and IT8712F earlier than revision 0x08 use register 0x0b
170 for fan divisors. Later IT8712F revisions must use 16-bit tachometer
172 #define IT87_REG_FAN_DIV 0x0b
173 #define IT87_REG_FAN_16BIT 0x0c
175 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
177 static const u8 IT87_REG_FAN[] = { 0x0d, 0x0e, 0x0f, 0x80, 0x82 };
178 static const u8 IT87_REG_FAN_MIN[] = { 0x10, 0x11, 0x12, 0x84, 0x86 };
179 static const u8 IT87_REG_FANX[] = { 0x18, 0x19, 0x1a, 0x81, 0x83 };
180 static const u8 IT87_REG_FANX_MIN[] = { 0x1b, 0x1c, 0x1d, 0x85, 0x87 };
181 #define IT87_REG_FAN_MAIN_CTRL 0x13
182 #define IT87_REG_FAN_CTL 0x14
183 #define IT87_REG_PWM(nr) (0x15 + (nr))
185 #define IT87_REG_VIN(nr) (0x20 + (nr))
186 #define IT87_REG_TEMP(nr) (0x29 + (nr))
188 #define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2)
189 #define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2)
190 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
191 #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2)
193 #define IT87_REG_VIN_ENABLE 0x50
194 #define IT87_REG_TEMP_ENABLE 0x51
196 #define IT87_REG_CHIPID 0x58
198 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
199 #define IN_FROM_REG(val) ((val) * 16)
201 static inline u8 FAN_TO_REG(long rpm, int div)
205 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
206 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
210 static inline u16 FAN16_TO_REG(long rpm)
214 return SENSORS_LIMIT((1350000 + rpm) / (rpm * 2), 1, 0xfffe);
217 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
218 /* The divider is fixed to 2 in 16-bit mode */
219 #define FAN16_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:1350000/((val)*2))
221 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
222 ((val)+500)/1000),-128,127))
223 #define TEMP_FROM_REG(val) ((val) * 1000)
225 #define PWM_TO_REG(val) ((val) >> 1)
226 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
228 static int DIV_TO_REG(int val)
231 while (answer < 7 && (val >>= 1))
235 #define DIV_FROM_REG(val) (1 << (val))
237 static const unsigned int pwm_freq[8] = {
249 struct it87_sio_data {
251 /* Values read from Super-I/O config space */
254 /* Values set based on DMI strings */
258 /* For each registered chip, we need to keep some data in memory.
259 The structure is dynamically allocated. */
261 struct device *hwmon_dev;
267 struct mutex update_lock;
268 char valid; /* !=0 if following fields are valid */
269 unsigned long last_updated; /* In jiffies */
271 u8 in[9]; /* Register value */
272 u8 in_max[8]; /* Register value */
273 u8 in_min[8]; /* Register value */
274 u8 has_fan; /* Bitfield, fans enabled */
275 u16 fan[5]; /* Register values, possibly combined */
276 u16 fan_min[5]; /* Register values, possibly combined */
277 s8 temp[3]; /* Register value */
278 s8 temp_high[3]; /* Register value */
279 s8 temp_low[3]; /* Register value */
280 u8 sensor; /* Register value */
281 u8 fan_div[3]; /* Register encoding, shifted right */
282 u8 vid; /* Register encoding, combined */
284 u32 alarms; /* Register encoding, combined */
285 u8 fan_main_ctrl; /* Register value */
286 u8 fan_ctl; /* Register value */
287 u8 manual_pwm_ctl[3]; /* manual PWM value set by user */
290 static inline int has_16bit_fans(const struct it87_data *data)
292 /* IT8705F Datasheet 0.4.1, 3h == Version G.
293 IT8712F Datasheet 0.9.1, section 8.3.5 indicates 8h == Version J.
294 These are the first revisions with 16bit tachometer support. */
295 return (data->type == it87 && data->revision >= 0x03)
296 || (data->type == it8712 && data->revision >= 0x08)
297 || data->type == it8716
298 || data->type == it8718
299 || data->type == it8720;
302 static int it87_probe(struct platform_device *pdev);
303 static int __devexit it87_remove(struct platform_device *pdev);
305 static int it87_read_value(struct it87_data *data, u8 reg);
306 static void it87_write_value(struct it87_data *data, u8 reg, u8 value);
307 static struct it87_data *it87_update_device(struct device *dev);
308 static int it87_check_pwm(struct device *dev);
309 static void it87_init_device(struct platform_device *pdev);
312 static struct platform_driver it87_driver = {
314 .owner = THIS_MODULE,
318 .remove = __devexit_p(it87_remove),
321 static ssize_t show_in(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[nr]));
331 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
334 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
335 int nr = sensor_attr->index;
337 struct it87_data *data = it87_update_device(dev);
338 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
341 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
344 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
345 int nr = sensor_attr->index;
347 struct it87_data *data = it87_update_device(dev);
348 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
351 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
352 const char *buf, size_t count)
354 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
355 int nr = sensor_attr->index;
357 struct it87_data *data = dev_get_drvdata(dev);
358 unsigned long val = simple_strtoul(buf, NULL, 10);
360 mutex_lock(&data->update_lock);
361 data->in_min[nr] = IN_TO_REG(val);
362 it87_write_value(data, IT87_REG_VIN_MIN(nr),
364 mutex_unlock(&data->update_lock);
367 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
368 const char *buf, size_t count)
370 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
371 int nr = sensor_attr->index;
373 struct it87_data *data = dev_get_drvdata(dev);
374 unsigned long val = simple_strtoul(buf, NULL, 10);
376 mutex_lock(&data->update_lock);
377 data->in_max[nr] = IN_TO_REG(val);
378 it87_write_value(data, IT87_REG_VIN_MAX(nr),
380 mutex_unlock(&data->update_lock);
384 #define show_in_offset(offset) \
385 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
386 show_in, NULL, offset);
388 #define limit_in_offset(offset) \
389 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
390 show_in_min, set_in_min, offset); \
391 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
392 show_in_max, set_in_max, offset);
413 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
416 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
417 int nr = sensor_attr->index;
419 struct it87_data *data = it87_update_device(dev);
420 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
422 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
425 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
426 int nr = sensor_attr->index;
428 struct it87_data *data = it87_update_device(dev);
429 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
431 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
434 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
435 int nr = sensor_attr->index;
437 struct it87_data *data = it87_update_device(dev);
438 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
440 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
441 const char *buf, size_t count)
443 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
444 int nr = sensor_attr->index;
446 struct it87_data *data = dev_get_drvdata(dev);
447 int val = simple_strtol(buf, NULL, 10);
449 mutex_lock(&data->update_lock);
450 data->temp_high[nr] = TEMP_TO_REG(val);
451 it87_write_value(data, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
452 mutex_unlock(&data->update_lock);
455 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
456 const char *buf, size_t count)
458 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
459 int nr = sensor_attr->index;
461 struct it87_data *data = dev_get_drvdata(dev);
462 int val = simple_strtol(buf, NULL, 10);
464 mutex_lock(&data->update_lock);
465 data->temp_low[nr] = TEMP_TO_REG(val);
466 it87_write_value(data, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
467 mutex_unlock(&data->update_lock);
470 #define show_temp_offset(offset) \
471 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
472 show_temp, NULL, offset - 1); \
473 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
474 show_temp_max, set_temp_max, offset - 1); \
475 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
476 show_temp_min, set_temp_min, offset - 1);
482 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
485 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
486 int nr = sensor_attr->index;
488 struct it87_data *data = it87_update_device(dev);
489 u8 reg = data->sensor; /* In case the value is updated while we use it */
492 return sprintf(buf, "3\n"); /* thermal diode */
494 return sprintf(buf, "4\n"); /* thermistor */
495 return sprintf(buf, "0\n"); /* disabled */
497 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
498 const char *buf, size_t count)
500 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
501 int nr = sensor_attr->index;
503 struct it87_data *data = dev_get_drvdata(dev);
504 int val = simple_strtol(buf, NULL, 10);
506 mutex_lock(&data->update_lock);
508 data->sensor &= ~(1 << nr);
509 data->sensor &= ~(8 << nr);
510 if (val == 2) { /* backwards compatibility */
511 dev_warn(dev, "Sensor type 2 is deprecated, please use 4 "
515 /* 3 = thermal diode; 4 = thermistor; 0 = disabled */
517 data->sensor |= 1 << nr;
519 data->sensor |= 8 << nr;
521 mutex_unlock(&data->update_lock);
524 it87_write_value(data, IT87_REG_TEMP_ENABLE, data->sensor);
525 mutex_unlock(&data->update_lock);
528 #define show_sensor_offset(offset) \
529 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
530 show_sensor, set_sensor, offset - 1);
532 show_sensor_offset(1);
533 show_sensor_offset(2);
534 show_sensor_offset(3);
537 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
540 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
541 int nr = sensor_attr->index;
543 struct it87_data *data = it87_update_device(dev);
544 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
545 DIV_FROM_REG(data->fan_div[nr])));
547 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
550 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
551 int nr = sensor_attr->index;
553 struct it87_data *data = it87_update_device(dev);
554 return sprintf(buf,"%d\n",
555 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
557 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
560 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
561 int nr = sensor_attr->index;
563 struct it87_data *data = it87_update_device(dev);
564 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
566 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
569 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
570 int nr = sensor_attr->index;
572 struct it87_data *data = it87_update_device(dev);
573 return sprintf(buf,"%d\n", (data->fan_main_ctrl & (1 << nr)) ? 1 : 0);
575 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
578 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
579 int nr = sensor_attr->index;
581 struct it87_data *data = it87_update_device(dev);
582 return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]);
584 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
587 struct it87_data *data = it87_update_device(dev);
588 int index = (data->fan_ctl >> 4) & 0x07;
590 return sprintf(buf, "%u\n", pwm_freq[index]);
592 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
593 const char *buf, size_t count)
595 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
596 int nr = sensor_attr->index;
598 struct it87_data *data = dev_get_drvdata(dev);
599 int val = simple_strtol(buf, NULL, 10);
602 mutex_lock(&data->update_lock);
603 reg = it87_read_value(data, IT87_REG_FAN_DIV);
605 case 0: data->fan_div[nr] = reg & 0x07; break;
606 case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
607 case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break;
610 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
611 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
612 mutex_unlock(&data->update_lock);
615 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
616 const char *buf, size_t count)
618 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
619 int nr = sensor_attr->index;
621 struct it87_data *data = dev_get_drvdata(dev);
622 unsigned long val = simple_strtoul(buf, NULL, 10);
626 mutex_lock(&data->update_lock);
627 old = it87_read_value(data, IT87_REG_FAN_DIV);
629 /* Save fan min limit */
630 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
635 data->fan_div[nr] = DIV_TO_REG(val);
639 data->fan_div[nr] = 1;
641 data->fan_div[nr] = 3;
644 val |= (data->fan_div[0] & 0x07);
645 val |= (data->fan_div[1] & 0x07) << 3;
646 if (data->fan_div[2] == 3)
648 it87_write_value(data, IT87_REG_FAN_DIV, val);
650 /* Restore fan min limit */
651 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
652 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
654 mutex_unlock(&data->update_lock);
657 static ssize_t set_pwm_enable(struct device *dev,
658 struct device_attribute *attr, const char *buf, size_t count)
660 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
661 int nr = sensor_attr->index;
663 struct it87_data *data = dev_get_drvdata(dev);
664 int val = simple_strtol(buf, NULL, 10);
666 mutex_lock(&data->update_lock);
670 /* make sure the fan is on when in on/off mode */
671 tmp = it87_read_value(data, IT87_REG_FAN_CTL);
672 it87_write_value(data, IT87_REG_FAN_CTL, tmp | (1 << nr));
673 /* set on/off mode */
674 data->fan_main_ctrl &= ~(1 << nr);
675 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
676 } else if (val == 1) {
677 /* set SmartGuardian mode */
678 data->fan_main_ctrl |= (1 << nr);
679 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
680 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
681 it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
683 mutex_unlock(&data->update_lock);
687 mutex_unlock(&data->update_lock);
690 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
691 const char *buf, size_t count)
693 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
694 int nr = sensor_attr->index;
696 struct it87_data *data = dev_get_drvdata(dev);
697 int val = simple_strtol(buf, NULL, 10);
699 if (val < 0 || val > 255)
702 mutex_lock(&data->update_lock);
703 data->manual_pwm_ctl[nr] = val;
704 if (data->fan_main_ctrl & (1 << nr))
705 it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
706 mutex_unlock(&data->update_lock);
709 static ssize_t set_pwm_freq(struct device *dev,
710 struct device_attribute *attr, const char *buf, size_t count)
712 struct it87_data *data = dev_get_drvdata(dev);
713 unsigned long val = simple_strtoul(buf, NULL, 10);
716 /* Search for the nearest available frequency */
717 for (i = 0; i < 7; i++) {
718 if (val > (pwm_freq[i] + pwm_freq[i+1]) / 2)
722 mutex_lock(&data->update_lock);
723 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL) & 0x8f;
724 data->fan_ctl |= i << 4;
725 it87_write_value(data, IT87_REG_FAN_CTL, data->fan_ctl);
726 mutex_unlock(&data->update_lock);
731 #define show_fan_offset(offset) \
732 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
733 show_fan, NULL, offset - 1); \
734 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
735 show_fan_min, set_fan_min, offset - 1); \
736 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
737 show_fan_div, set_fan_div, offset - 1);
743 #define show_pwm_offset(offset) \
744 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
745 show_pwm_enable, set_pwm_enable, offset - 1); \
746 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
747 show_pwm, set_pwm, offset - 1); \
748 static DEVICE_ATTR(pwm##offset##_freq, \
749 (offset == 1 ? S_IRUGO | S_IWUSR : S_IRUGO), \
750 show_pwm_freq, (offset == 1 ? set_pwm_freq : NULL));
756 /* A different set of callbacks for 16-bit fans */
757 static ssize_t show_fan16(struct device *dev, struct device_attribute *attr,
760 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
761 int nr = sensor_attr->index;
762 struct it87_data *data = it87_update_device(dev);
763 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan[nr]));
766 static ssize_t show_fan16_min(struct device *dev, struct device_attribute *attr,
769 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
770 int nr = sensor_attr->index;
771 struct it87_data *data = it87_update_device(dev);
772 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan_min[nr]));
775 static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr,
776 const char *buf, size_t count)
778 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
779 int nr = sensor_attr->index;
780 struct it87_data *data = dev_get_drvdata(dev);
781 int val = simple_strtol(buf, NULL, 10);
783 mutex_lock(&data->update_lock);
784 data->fan_min[nr] = FAN16_TO_REG(val);
785 it87_write_value(data, IT87_REG_FAN_MIN[nr],
786 data->fan_min[nr] & 0xff);
787 it87_write_value(data, IT87_REG_FANX_MIN[nr],
788 data->fan_min[nr] >> 8);
789 mutex_unlock(&data->update_lock);
793 /* We want to use the same sysfs file names as 8-bit fans, but we need
794 different variable names, so we have to use SENSOR_ATTR instead of
795 SENSOR_DEVICE_ATTR. */
796 #define show_fan16_offset(offset) \
797 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \
798 = SENSOR_ATTR(fan##offset##_input, S_IRUGO, \
799 show_fan16, NULL, offset - 1); \
800 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \
801 = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
802 show_fan16_min, set_fan16_min, offset - 1)
804 show_fan16_offset(1);
805 show_fan16_offset(2);
806 show_fan16_offset(3);
807 show_fan16_offset(4);
808 show_fan16_offset(5);
811 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
813 struct it87_data *data = it87_update_device(dev);
814 return sprintf(buf, "%u\n", data->alarms);
816 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
818 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
821 int bitnr = to_sensor_dev_attr(attr)->index;
822 struct it87_data *data = it87_update_device(dev);
823 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
825 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8);
826 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9);
827 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10);
828 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11);
829 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12);
830 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13);
831 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14);
832 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15);
833 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
834 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1);
835 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 2);
836 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 3);
837 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 6);
838 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 16);
839 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 17);
840 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 18);
843 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
845 struct it87_data *data = dev_get_drvdata(dev);
846 return sprintf(buf, "%u\n", data->vrm);
849 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
851 struct it87_data *data = dev_get_drvdata(dev);
854 val = simple_strtoul(buf, NULL, 10);
859 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
862 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
864 struct it87_data *data = it87_update_device(dev);
865 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
867 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
869 static ssize_t show_name(struct device *dev, struct device_attribute
872 struct it87_data *data = dev_get_drvdata(dev);
873 return sprintf(buf, "%s\n", data->name);
875 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
877 static struct attribute *it87_attributes[] = {
878 &sensor_dev_attr_in0_input.dev_attr.attr,
879 &sensor_dev_attr_in1_input.dev_attr.attr,
880 &sensor_dev_attr_in2_input.dev_attr.attr,
881 &sensor_dev_attr_in3_input.dev_attr.attr,
882 &sensor_dev_attr_in4_input.dev_attr.attr,
883 &sensor_dev_attr_in5_input.dev_attr.attr,
884 &sensor_dev_attr_in6_input.dev_attr.attr,
885 &sensor_dev_attr_in7_input.dev_attr.attr,
886 &sensor_dev_attr_in8_input.dev_attr.attr,
887 &sensor_dev_attr_in0_min.dev_attr.attr,
888 &sensor_dev_attr_in1_min.dev_attr.attr,
889 &sensor_dev_attr_in2_min.dev_attr.attr,
890 &sensor_dev_attr_in3_min.dev_attr.attr,
891 &sensor_dev_attr_in4_min.dev_attr.attr,
892 &sensor_dev_attr_in5_min.dev_attr.attr,
893 &sensor_dev_attr_in6_min.dev_attr.attr,
894 &sensor_dev_attr_in7_min.dev_attr.attr,
895 &sensor_dev_attr_in0_max.dev_attr.attr,
896 &sensor_dev_attr_in1_max.dev_attr.attr,
897 &sensor_dev_attr_in2_max.dev_attr.attr,
898 &sensor_dev_attr_in3_max.dev_attr.attr,
899 &sensor_dev_attr_in4_max.dev_attr.attr,
900 &sensor_dev_attr_in5_max.dev_attr.attr,
901 &sensor_dev_attr_in6_max.dev_attr.attr,
902 &sensor_dev_attr_in7_max.dev_attr.attr,
903 &sensor_dev_attr_in0_alarm.dev_attr.attr,
904 &sensor_dev_attr_in1_alarm.dev_attr.attr,
905 &sensor_dev_attr_in2_alarm.dev_attr.attr,
906 &sensor_dev_attr_in3_alarm.dev_attr.attr,
907 &sensor_dev_attr_in4_alarm.dev_attr.attr,
908 &sensor_dev_attr_in5_alarm.dev_attr.attr,
909 &sensor_dev_attr_in6_alarm.dev_attr.attr,
910 &sensor_dev_attr_in7_alarm.dev_attr.attr,
912 &sensor_dev_attr_temp1_input.dev_attr.attr,
913 &sensor_dev_attr_temp2_input.dev_attr.attr,
914 &sensor_dev_attr_temp3_input.dev_attr.attr,
915 &sensor_dev_attr_temp1_max.dev_attr.attr,
916 &sensor_dev_attr_temp2_max.dev_attr.attr,
917 &sensor_dev_attr_temp3_max.dev_attr.attr,
918 &sensor_dev_attr_temp1_min.dev_attr.attr,
919 &sensor_dev_attr_temp2_min.dev_attr.attr,
920 &sensor_dev_attr_temp3_min.dev_attr.attr,
921 &sensor_dev_attr_temp1_type.dev_attr.attr,
922 &sensor_dev_attr_temp2_type.dev_attr.attr,
923 &sensor_dev_attr_temp3_type.dev_attr.attr,
924 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
925 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
926 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
928 &dev_attr_alarms.attr,
933 static const struct attribute_group it87_group = {
934 .attrs = it87_attributes,
937 static struct attribute *it87_attributes_opt[] = {
938 &sensor_dev_attr_fan1_input16.dev_attr.attr,
939 &sensor_dev_attr_fan1_min16.dev_attr.attr,
940 &sensor_dev_attr_fan2_input16.dev_attr.attr,
941 &sensor_dev_attr_fan2_min16.dev_attr.attr,
942 &sensor_dev_attr_fan3_input16.dev_attr.attr,
943 &sensor_dev_attr_fan3_min16.dev_attr.attr,
944 &sensor_dev_attr_fan4_input16.dev_attr.attr,
945 &sensor_dev_attr_fan4_min16.dev_attr.attr,
946 &sensor_dev_attr_fan5_input16.dev_attr.attr,
947 &sensor_dev_attr_fan5_min16.dev_attr.attr,
949 &sensor_dev_attr_fan1_input.dev_attr.attr,
950 &sensor_dev_attr_fan1_min.dev_attr.attr,
951 &sensor_dev_attr_fan1_div.dev_attr.attr,
952 &sensor_dev_attr_fan2_input.dev_attr.attr,
953 &sensor_dev_attr_fan2_min.dev_attr.attr,
954 &sensor_dev_attr_fan2_div.dev_attr.attr,
955 &sensor_dev_attr_fan3_input.dev_attr.attr,
956 &sensor_dev_attr_fan3_min.dev_attr.attr,
957 &sensor_dev_attr_fan3_div.dev_attr.attr,
959 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
960 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
961 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
962 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
963 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
965 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
966 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
967 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
968 &sensor_dev_attr_pwm1.dev_attr.attr,
969 &sensor_dev_attr_pwm2.dev_attr.attr,
970 &sensor_dev_attr_pwm3.dev_attr.attr,
971 &dev_attr_pwm1_freq.attr,
972 &dev_attr_pwm2_freq.attr,
973 &dev_attr_pwm3_freq.attr,
976 &dev_attr_cpu0_vid.attr,
980 static const struct attribute_group it87_group_opt = {
981 .attrs = it87_attributes_opt,
984 /* SuperIO detection - will change isa_address if a chip is found */
985 static int __init it87_find(unsigned short *address,
986 struct it87_sio_data *sio_data)
990 const char *board_vendor, *board_name;
993 chip_type = force_id ? force_id : superio_inw(DEVID);
997 sio_data->type = it87;
1000 sio_data->type = it8712;
1004 sio_data->type = it8716;
1007 sio_data->type = it8718;
1010 sio_data->type = it8720;
1012 case 0xffff: /* No device at all */
1015 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
1020 superio_select(PME);
1021 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
1022 pr_info("it87: Device not activated, skipping\n");
1026 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
1027 if (*address == 0) {
1028 pr_info("it87: Base address not set, skipping\n");
1033 sio_data->revision = superio_inb(DEVREV) & 0x0f;
1034 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
1035 chip_type, *address, sio_data->revision);
1037 /* Read GPIO config and VID value from LDN 7 (GPIO) */
1038 if (sio_data->type != it87) {
1041 superio_select(GPIO);
1042 if (sio_data->type == it8718 || sio_data->type == it8720)
1043 sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
1045 reg = superio_inb(IT87_SIO_PINX2_REG);
1047 * The IT8720F has no VIN7 pin, so VCCH should always be
1048 * routed internally to VIN7 with an internal divider.
1049 * Curiously, there still is a configuration bit to control
1050 * this, which means it can be set incorrectly. And even
1051 * more curiously, many boards out there are improperly
1052 * configured, even though the IT8720F datasheet claims
1053 * that the internal routing of VCCH to VIN7 is the default
1054 * setting. So we force the internal routing in this case.
1056 if (sio_data->type == it8720 && !(reg & (1 << 1))) {
1058 superio_outb(IT87_SIO_PINX2_REG, reg);
1059 pr_notice("it87: Routing internal VCCH to in7\n");
1062 pr_info("it87: in3 is VCC (+5V)\n");
1064 pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
1067 /* Disable specific features based on DMI strings */
1068 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1069 board_name = dmi_get_system_info(DMI_BOARD_NAME);
1070 if (board_vendor && board_name) {
1071 if (strcmp(board_vendor, "nVIDIA") == 0
1072 && strcmp(board_name, "FN68PT") == 0) {
1073 /* On the Shuttle SN68PT, FAN_CTL2 is apparently not
1074 connected to a fan, but to something else. One user
1075 has reported instant system power-off when changing
1076 the PWM2 duty cycle, so we disable it.
1077 I use the board name string as the trigger in case
1078 the same board is ever used in other systems. */
1079 pr_info("it87: Disabling pwm2 due to "
1080 "hardware constraints\n");
1081 sio_data->skip_pwm = (1 << 1);
1090 static int __devinit it87_probe(struct platform_device *pdev)
1092 struct it87_data *data;
1093 struct resource *res;
1094 struct device *dev = &pdev->dev;
1095 struct it87_sio_data *sio_data = dev->platform_data;
1097 int enable_pwm_interface;
1098 static const char *names[] = {
1106 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1107 if (!request_region(res->start, IT87_EC_EXTENT, DRVNAME)) {
1108 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1109 (unsigned long)res->start,
1110 (unsigned long)(res->start + IT87_EC_EXTENT - 1));
1115 if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
1120 data->addr = res->start;
1121 data->type = sio_data->type;
1122 data->revision = sio_data->revision;
1123 data->name = names[sio_data->type];
1125 /* Now, we do the remaining detection. */
1126 if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80)
1127 || it87_read_value(data, IT87_REG_CHIPID) != 0x90) {
1132 platform_set_drvdata(pdev, data);
1134 mutex_init(&data->update_lock);
1136 /* Check PWM configuration */
1137 enable_pwm_interface = it87_check_pwm(dev);
1139 /* Initialize the IT87 chip */
1140 it87_init_device(pdev);
1142 /* Register sysfs hooks */
1143 if ((err = sysfs_create_group(&dev->kobj, &it87_group)))
1146 /* Do not create fan files for disabled fans */
1147 if (has_16bit_fans(data)) {
1148 /* 16-bit tachometers */
1149 if (data->has_fan & (1 << 0)) {
1150 if ((err = device_create_file(dev,
1151 &sensor_dev_attr_fan1_input16.dev_attr))
1152 || (err = device_create_file(dev,
1153 &sensor_dev_attr_fan1_min16.dev_attr))
1154 || (err = device_create_file(dev,
1155 &sensor_dev_attr_fan1_alarm.dev_attr)))
1158 if (data->has_fan & (1 << 1)) {
1159 if ((err = device_create_file(dev,
1160 &sensor_dev_attr_fan2_input16.dev_attr))
1161 || (err = device_create_file(dev,
1162 &sensor_dev_attr_fan2_min16.dev_attr))
1163 || (err = device_create_file(dev,
1164 &sensor_dev_attr_fan2_alarm.dev_attr)))
1167 if (data->has_fan & (1 << 2)) {
1168 if ((err = device_create_file(dev,
1169 &sensor_dev_attr_fan3_input16.dev_attr))
1170 || (err = device_create_file(dev,
1171 &sensor_dev_attr_fan3_min16.dev_attr))
1172 || (err = device_create_file(dev,
1173 &sensor_dev_attr_fan3_alarm.dev_attr)))
1176 if (data->has_fan & (1 << 3)) {
1177 if ((err = device_create_file(dev,
1178 &sensor_dev_attr_fan4_input16.dev_attr))
1179 || (err = device_create_file(dev,
1180 &sensor_dev_attr_fan4_min16.dev_attr))
1181 || (err = device_create_file(dev,
1182 &sensor_dev_attr_fan4_alarm.dev_attr)))
1185 if (data->has_fan & (1 << 4)) {
1186 if ((err = device_create_file(dev,
1187 &sensor_dev_attr_fan5_input16.dev_attr))
1188 || (err = device_create_file(dev,
1189 &sensor_dev_attr_fan5_min16.dev_attr))
1190 || (err = device_create_file(dev,
1191 &sensor_dev_attr_fan5_alarm.dev_attr)))
1195 /* 8-bit tachometers with clock divider */
1196 if (data->has_fan & (1 << 0)) {
1197 if ((err = device_create_file(dev,
1198 &sensor_dev_attr_fan1_input.dev_attr))
1199 || (err = device_create_file(dev,
1200 &sensor_dev_attr_fan1_min.dev_attr))
1201 || (err = device_create_file(dev,
1202 &sensor_dev_attr_fan1_div.dev_attr))
1203 || (err = device_create_file(dev,
1204 &sensor_dev_attr_fan1_alarm.dev_attr)))
1207 if (data->has_fan & (1 << 1)) {
1208 if ((err = device_create_file(dev,
1209 &sensor_dev_attr_fan2_input.dev_attr))
1210 || (err = device_create_file(dev,
1211 &sensor_dev_attr_fan2_min.dev_attr))
1212 || (err = device_create_file(dev,
1213 &sensor_dev_attr_fan2_div.dev_attr))
1214 || (err = device_create_file(dev,
1215 &sensor_dev_attr_fan2_alarm.dev_attr)))
1218 if (data->has_fan & (1 << 2)) {
1219 if ((err = device_create_file(dev,
1220 &sensor_dev_attr_fan3_input.dev_attr))
1221 || (err = device_create_file(dev,
1222 &sensor_dev_attr_fan3_min.dev_attr))
1223 || (err = device_create_file(dev,
1224 &sensor_dev_attr_fan3_div.dev_attr))
1225 || (err = device_create_file(dev,
1226 &sensor_dev_attr_fan3_alarm.dev_attr)))
1231 if (enable_pwm_interface) {
1232 if (!(sio_data->skip_pwm & (1 << 0))) {
1233 if ((err = device_create_file(dev,
1234 &sensor_dev_attr_pwm1_enable.dev_attr))
1235 || (err = device_create_file(dev,
1236 &sensor_dev_attr_pwm1.dev_attr))
1237 || (err = device_create_file(dev,
1238 &dev_attr_pwm1_freq)))
1241 if (!(sio_data->skip_pwm & (1 << 1))) {
1242 if ((err = device_create_file(dev,
1243 &sensor_dev_attr_pwm2_enable.dev_attr))
1244 || (err = device_create_file(dev,
1245 &sensor_dev_attr_pwm2.dev_attr))
1246 || (err = device_create_file(dev,
1247 &dev_attr_pwm2_freq)))
1250 if (!(sio_data->skip_pwm & (1 << 2))) {
1251 if ((err = device_create_file(dev,
1252 &sensor_dev_attr_pwm3_enable.dev_attr))
1253 || (err = device_create_file(dev,
1254 &sensor_dev_attr_pwm3.dev_attr))
1255 || (err = device_create_file(dev,
1256 &dev_attr_pwm3_freq)))
1261 if (data->type == it8712 || data->type == it8716
1262 || data->type == it8718 || data->type == it8720) {
1263 data->vrm = vid_which_vrm();
1264 /* VID reading from Super-I/O config space if available */
1265 data->vid = sio_data->vid_value;
1266 if ((err = device_create_file(dev,
1268 || (err = device_create_file(dev,
1269 &dev_attr_cpu0_vid)))
1273 data->hwmon_dev = hwmon_device_register(dev);
1274 if (IS_ERR(data->hwmon_dev)) {
1275 err = PTR_ERR(data->hwmon_dev);
1282 sysfs_remove_group(&dev->kobj, &it87_group);
1283 sysfs_remove_group(&dev->kobj, &it87_group_opt);
1285 platform_set_drvdata(pdev, NULL);
1288 release_region(res->start, IT87_EC_EXTENT);
1293 static int __devexit it87_remove(struct platform_device *pdev)
1295 struct it87_data *data = platform_get_drvdata(pdev);
1297 hwmon_device_unregister(data->hwmon_dev);
1298 sysfs_remove_group(&pdev->dev.kobj, &it87_group);
1299 sysfs_remove_group(&pdev->dev.kobj, &it87_group_opt);
1301 release_region(data->addr, IT87_EC_EXTENT);
1302 platform_set_drvdata(pdev, NULL);
1308 /* Must be called with data->update_lock held, except during initialization.
1309 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1310 would slow down the IT87 access and should not be necessary. */
1311 static int it87_read_value(struct it87_data *data, u8 reg)
1313 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1314 return inb_p(data->addr + IT87_DATA_REG_OFFSET);
1317 /* Must be called with data->update_lock held, except during initialization.
1318 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1319 would slow down the IT87 access and should not be necessary. */
1320 static void it87_write_value(struct it87_data *data, u8 reg, u8 value)
1322 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1323 outb_p(value, data->addr + IT87_DATA_REG_OFFSET);
1326 /* Return 1 if and only if the PWM interface is safe to use */
1327 static int __devinit it87_check_pwm(struct device *dev)
1329 struct it87_data *data = dev_get_drvdata(dev);
1330 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
1331 * and polarity set to active low is sign that this is the case so we
1332 * disable pwm control to protect the user. */
1333 int tmp = it87_read_value(data, IT87_REG_FAN_CTL);
1334 if ((tmp & 0x87) == 0) {
1335 if (fix_pwm_polarity) {
1336 /* The user asks us to attempt a chip reconfiguration.
1337 * This means switching to active high polarity and
1338 * inverting all fan speed values. */
1342 for (i = 0; i < 3; i++)
1343 pwm[i] = it87_read_value(data,
1346 /* If any fan is in automatic pwm mode, the polarity
1347 * might be correct, as suspicious as it seems, so we
1348 * better don't change anything (but still disable the
1349 * PWM interface). */
1350 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1351 dev_info(dev, "Reconfiguring PWM to "
1352 "active high polarity\n");
1353 it87_write_value(data, IT87_REG_FAN_CTL,
1355 for (i = 0; i < 3; i++)
1356 it87_write_value(data,
1362 dev_info(dev, "PWM configuration is "
1363 "too broken to be fixed\n");
1366 dev_info(dev, "Detected broken BIOS "
1367 "defaults, disabling PWM interface\n");
1369 } else if (fix_pwm_polarity) {
1370 dev_info(dev, "PWM configuration looks "
1371 "sane, won't touch\n");
1377 /* Called when we have found a new IT87. */
1378 static void __devinit it87_init_device(struct platform_device *pdev)
1380 struct it87_data *data = platform_get_drvdata(pdev);
1383 /* initialize to sane defaults:
1384 * - if the chip is in manual pwm mode, this will be overwritten with
1385 * the actual settings on the chip (so in this case, initialization
1387 * - if in automatic or on/off mode, we could switch to manual mode,
1388 * read the registers and set manual_pwm_ctl accordingly, but currently
1389 * this is not implemented, so we initialize to something sane */
1390 for (i = 0; i < 3; i++) {
1391 data->manual_pwm_ctl[i] = 0xff;
1394 /* Some chips seem to have default value 0xff for all limit
1395 * registers. For low voltage limits it makes no sense and triggers
1396 * alarms, so change to 0 instead. For high temperature limits, it
1397 * means -1 degree C, which surprisingly doesn't trigger an alarm,
1398 * but is still confusing, so change to 127 degrees C. */
1399 for (i = 0; i < 8; i++) {
1400 tmp = it87_read_value(data, IT87_REG_VIN_MIN(i));
1402 it87_write_value(data, IT87_REG_VIN_MIN(i), 0);
1404 for (i = 0; i < 3; i++) {
1405 tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1407 it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127);
1410 /* Check if temperature channels are reset manually or by some reason */
1411 tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1412 if ((tmp & 0x3f) == 0) {
1413 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1414 tmp = (tmp & 0xc0) | 0x2a;
1415 it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp);
1419 /* Check if voltage monitors are reset manually or by some reason */
1420 tmp = it87_read_value(data, IT87_REG_VIN_ENABLE);
1421 if ((tmp & 0xff) == 0) {
1422 /* Enable all voltage monitors */
1423 it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff);
1426 /* Check if tachometers are reset manually or by some reason */
1427 data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
1428 if ((data->fan_main_ctrl & 0x70) == 0) {
1429 /* Enable all fan tachometers */
1430 data->fan_main_ctrl |= 0x70;
1431 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1433 data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
1435 /* Set tachometers to 16-bit mode if needed */
1436 if (has_16bit_fans(data)) {
1437 tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
1438 if (~tmp & 0x07 & data->has_fan) {
1440 "Setting fan1-3 to 16-bit mode\n");
1441 it87_write_value(data, IT87_REG_FAN_16BIT,
1444 /* IT8705F only supports three fans. */
1445 if (data->type != it87) {
1447 data->has_fan |= (1 << 3); /* fan4 enabled */
1449 data->has_fan |= (1 << 4); /* fan5 enabled */
1453 /* Set current fan mode registers and the default settings for the
1454 * other mode registers */
1455 for (i = 0; i < 3; i++) {
1456 if (data->fan_main_ctrl & (1 << i)) {
1458 tmp = it87_read_value(data, IT87_REG_PWM(i));
1460 /* automatic pwm - not yet implemented, but
1461 * leave the settings made by the BIOS alone
1462 * until a change is requested via the sysfs
1466 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1471 /* Start monitoring */
1472 it87_write_value(data, IT87_REG_CONFIG,
1473 (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
1474 | (update_vbat ? 0x41 : 0x01));
1477 static struct it87_data *it87_update_device(struct device *dev)
1479 struct it87_data *data = dev_get_drvdata(dev);
1482 mutex_lock(&data->update_lock);
1484 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1488 /* Cleared after each update, so reenable. Value
1489 returned by this read will be previous value */
1490 it87_write_value(data, IT87_REG_CONFIG,
1491 it87_read_value(data, IT87_REG_CONFIG) | 0x40);
1493 for (i = 0; i <= 7; i++) {
1495 it87_read_value(data, IT87_REG_VIN(i));
1497 it87_read_value(data, IT87_REG_VIN_MIN(i));
1499 it87_read_value(data, IT87_REG_VIN_MAX(i));
1501 /* in8 (battery) has no limit registers */
1503 it87_read_value(data, IT87_REG_VIN(8));
1505 for (i = 0; i < 5; i++) {
1506 /* Skip disabled fans */
1507 if (!(data->has_fan & (1 << i)))
1511 it87_read_value(data, IT87_REG_FAN_MIN[i]);
1512 data->fan[i] = it87_read_value(data,
1514 /* Add high byte if in 16-bit mode */
1515 if (has_16bit_fans(data)) {
1516 data->fan[i] |= it87_read_value(data,
1517 IT87_REG_FANX[i]) << 8;
1518 data->fan_min[i] |= it87_read_value(data,
1519 IT87_REG_FANX_MIN[i]) << 8;
1522 for (i = 0; i < 3; i++) {
1524 it87_read_value(data, IT87_REG_TEMP(i));
1525 data->temp_high[i] =
1526 it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1528 it87_read_value(data, IT87_REG_TEMP_LOW(i));
1531 /* Newer chips don't have clock dividers */
1532 if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
1533 i = it87_read_value(data, IT87_REG_FAN_DIV);
1534 data->fan_div[0] = i & 0x07;
1535 data->fan_div[1] = (i >> 3) & 0x07;
1536 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1540 it87_read_value(data, IT87_REG_ALARM1) |
1541 (it87_read_value(data, IT87_REG_ALARM2) << 8) |
1542 (it87_read_value(data, IT87_REG_ALARM3) << 16);
1543 data->fan_main_ctrl = it87_read_value(data,
1544 IT87_REG_FAN_MAIN_CTRL);
1545 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
1547 data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1548 /* The 8705 does not have VID capability.
1549 The 8718 and the 8720 don't use IT87_REG_VID for the
1551 if (data->type == it8712 || data->type == it8716) {
1552 data->vid = it87_read_value(data, IT87_REG_VID);
1553 /* The older IT8712F revisions had only 5 VID pins,
1554 but we assume it is always safe to read 6 bits. */
1557 data->last_updated = jiffies;
1561 mutex_unlock(&data->update_lock);
1566 static int __init it87_device_add(unsigned short address,
1567 const struct it87_sio_data *sio_data)
1569 struct resource res = {
1570 .start = address + IT87_EC_OFFSET,
1571 .end = address + IT87_EC_OFFSET + IT87_EC_EXTENT - 1,
1573 .flags = IORESOURCE_IO,
1577 err = acpi_check_resource_conflict(&res);
1581 pdev = platform_device_alloc(DRVNAME, address);
1584 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1588 err = platform_device_add_resources(pdev, &res, 1);
1590 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1592 goto exit_device_put;
1595 err = platform_device_add_data(pdev, sio_data,
1596 sizeof(struct it87_sio_data));
1598 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1599 goto exit_device_put;
1602 err = platform_device_add(pdev);
1604 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1606 goto exit_device_put;
1612 platform_device_put(pdev);
1617 static int __init sm_it87_init(void)
1620 unsigned short isa_address=0;
1621 struct it87_sio_data sio_data;
1623 memset(&sio_data, 0, sizeof(struct it87_sio_data));
1624 err = it87_find(&isa_address, &sio_data);
1627 err = platform_driver_register(&it87_driver);
1631 err = it87_device_add(isa_address, &sio_data);
1633 platform_driver_unregister(&it87_driver);
1640 static void __exit sm_it87_exit(void)
1642 platform_device_unregister(pdev);
1643 platform_driver_unregister(&it87_driver);
1647 MODULE_AUTHOR("Chris Gauthron, "
1648 "Jean Delvare <khali@linux-fr.org>");
1649 MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8720F/8726F, SiS950 driver");
1650 module_param(update_vbat, bool, 0);
1651 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1652 module_param(fix_pwm_polarity, bool, 0);
1653 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1654 MODULE_LICENSE("GPL");
1656 module_init(sm_it87_init);
1657 module_exit(sm_it87_exit);