2 it87.c - Part of lm_sensors, Linux kernel modules for hardware
5 The IT8705F is an LPC-based Super I/O part that contains UARTs, a
6 parallel port, an IR port, a MIDI port, a floppy controller, etc., in
7 addition to an Environment Controller (Enhanced Hardware Monitor and
10 This driver supports only the Environment Controller in the IT8705F and
11 similar parts. The other devices are supported by different drivers.
13 Supports: IT8705F Super I/O chip w/LPC interface
14 IT8712F Super I/O chip w/LPC interface
15 IT8716F Super I/O chip w/LPC interface
16 IT8718F Super I/O chip w/LPC interface
17 IT8720F Super I/O chip w/LPC interface
18 IT8726F Super I/O chip w/LPC interface
19 Sis950 A clone of the IT8705F
21 Copyright (C) 2001 Chris Gauthron
22 Copyright (C) 2005-2007 Jean Delvare <khali@linux-fr.org>
24 This program is free software; you can redistribute it and/or modify
25 it under the terms of the GNU General Public License as published by
26 the Free Software Foundation; either version 2 of the License, or
27 (at your option) any later version.
29 This program is distributed in the hope that it will be useful,
30 but WITHOUT ANY WARRANTY; without even the implied warranty of
31 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 GNU General Public License for more details.
34 You should have received a copy of the GNU General Public License
35 along with this program; if not, write to the Free Software
36 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
39 #include <linux/module.h>
40 #include <linux/init.h>
41 #include <linux/slab.h>
42 #include <linux/jiffies.h>
43 #include <linux/platform_device.h>
44 #include <linux/hwmon.h>
45 #include <linux/hwmon-sysfs.h>
46 #include <linux/hwmon-vid.h>
47 #include <linux/err.h>
48 #include <linux/mutex.h>
49 #include <linux/sysfs.h>
50 #include <linux/string.h>
51 #include <linux/dmi.h>
52 #include <linux/acpi.h>
55 #define DRVNAME "it87"
57 enum chips { it87, it8712, it8716, it8718, it8720 };
59 static unsigned short force_id;
60 module_param(force_id, ushort, 0);
61 MODULE_PARM_DESC(force_id, "Override the detected device ID");
63 static struct platform_device *pdev;
65 #define REG 0x2e /* The register to read/write */
66 #define DEV 0x07 /* Register: Logical device select */
67 #define VAL 0x2f /* The value to read/write */
68 #define PME 0x04 /* The device with the fan registers in it */
70 /* The device with the IT8718F/IT8720F VID value in it */
73 #define DEVID 0x20 /* Register: Device ID */
74 #define DEVREV 0x22 /* Register: Device Revision */
83 static int superio_inw(int reg)
94 superio_select(int ldn)
116 /* Logical device 4 registers */
117 #define IT8712F_DEVID 0x8712
118 #define IT8705F_DEVID 0x8705
119 #define IT8716F_DEVID 0x8716
120 #define IT8718F_DEVID 0x8718
121 #define IT8720F_DEVID 0x8720
122 #define IT8726F_DEVID 0x8726
123 #define IT87_ACT_REG 0x30
124 #define IT87_BASE_REG 0x60
126 /* Logical device 7 registers (IT8712F and later) */
127 #define IT87_SIO_GPIO3_REG 0x27
128 #define IT87_SIO_GPIO5_REG 0x29
129 #define IT87_SIO_PINX2_REG 0x2c /* Pin selection */
130 #define IT87_SIO_VID_REG 0xfc /* VID value */
131 #define IT87_SIO_BEEP_PIN_REG 0xf6 /* Beep pin mapping */
133 /* Update battery voltage after every reading if true */
134 static int update_vbat;
136 /* Not all BIOSes properly configure the PWM registers */
137 static int fix_pwm_polarity;
139 /* Many IT87 constants specified below */
141 /* Length of ISA address segment */
142 #define IT87_EXTENT 8
144 /* Length of ISA address segment for Environmental Controller */
145 #define IT87_EC_EXTENT 2
147 /* Offset of EC registers from ISA base address */
148 #define IT87_EC_OFFSET 5
150 /* Where are the ISA address/data registers relative to the EC base address */
151 #define IT87_ADDR_REG_OFFSET 0
152 #define IT87_DATA_REG_OFFSET 1
154 /*----- The IT87 registers -----*/
156 #define IT87_REG_CONFIG 0x00
158 #define IT87_REG_ALARM1 0x01
159 #define IT87_REG_ALARM2 0x02
160 #define IT87_REG_ALARM3 0x03
162 /* The IT8718F and IT8720F have the VID value in a different register, in
163 Super-I/O configuration space. */
164 #define IT87_REG_VID 0x0a
165 /* The IT8705F and IT8712F earlier than revision 0x08 use register 0x0b
166 for fan divisors. Later IT8712F revisions must use 16-bit tachometer
168 #define IT87_REG_FAN_DIV 0x0b
169 #define IT87_REG_FAN_16BIT 0x0c
171 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
173 static const u8 IT87_REG_FAN[] = { 0x0d, 0x0e, 0x0f, 0x80, 0x82 };
174 static const u8 IT87_REG_FAN_MIN[] = { 0x10, 0x11, 0x12, 0x84, 0x86 };
175 static const u8 IT87_REG_FANX[] = { 0x18, 0x19, 0x1a, 0x81, 0x83 };
176 static const u8 IT87_REG_FANX_MIN[] = { 0x1b, 0x1c, 0x1d, 0x85, 0x87 };
177 #define IT87_REG_FAN_MAIN_CTRL 0x13
178 #define IT87_REG_FAN_CTL 0x14
179 #define IT87_REG_PWM(nr) (0x15 + (nr))
181 #define IT87_REG_VIN(nr) (0x20 + (nr))
182 #define IT87_REG_TEMP(nr) (0x29 + (nr))
184 #define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2)
185 #define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2)
186 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
187 #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2)
189 #define IT87_REG_VIN_ENABLE 0x50
190 #define IT87_REG_TEMP_ENABLE 0x51
191 #define IT87_REG_BEEP_ENABLE 0x5c
193 #define IT87_REG_CHIPID 0x58
195 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
196 #define IN_FROM_REG(val) ((val) * 16)
198 static inline u8 FAN_TO_REG(long rpm, int div)
202 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
203 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
207 static inline u16 FAN16_TO_REG(long rpm)
211 return SENSORS_LIMIT((1350000 + rpm) / (rpm * 2), 1, 0xfffe);
214 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
215 /* The divider is fixed to 2 in 16-bit mode */
216 #define FAN16_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:1350000/((val)*2))
218 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
219 ((val)+500)/1000),-128,127))
220 #define TEMP_FROM_REG(val) ((val) * 1000)
222 #define PWM_TO_REG(val) ((val) >> 1)
223 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
225 static int DIV_TO_REG(int val)
228 while (answer < 7 && (val >>= 1))
232 #define DIV_FROM_REG(val) (1 << (val))
234 static const unsigned int pwm_freq[8] = {
246 struct it87_sio_data {
248 /* Values read from Super-I/O config space */
252 /* Features skipped based on config or DMI */
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 beeps; /* Register encoding */
286 u8 fan_main_ctrl; /* Register value */
287 u8 fan_ctl; /* Register value */
289 /* The following 3 arrays correspond to the same registers. The
290 * meaning of bits 6-0 depends on the value of bit 7, and we want
291 * to preserve settings on mode changes, so we have to track all
292 * values separately. */
293 u8 pwm_ctrl[3]; /* Register value */
294 u8 pwm_duty[3]; /* Manual PWM value set by user (bit 6-0) */
295 u8 pwm_temp_map[3]; /* PWM to temp. chan. mapping (bits 1-0) */
298 static inline int has_16bit_fans(const struct it87_data *data)
300 /* IT8705F Datasheet 0.4.1, 3h == Version G.
301 IT8712F Datasheet 0.9.1, section 8.3.5 indicates 8h == Version J.
302 These are the first revisions with 16bit tachometer support. */
303 return (data->type == it87 && data->revision >= 0x03)
304 || (data->type == it8712 && data->revision >= 0x08)
305 || data->type == it8716
306 || data->type == it8718
307 || data->type == it8720;
310 static int it87_probe(struct platform_device *pdev);
311 static int __devexit it87_remove(struct platform_device *pdev);
313 static int it87_read_value(struct it87_data *data, u8 reg);
314 static void it87_write_value(struct it87_data *data, u8 reg, u8 value);
315 static struct it87_data *it87_update_device(struct device *dev);
316 static int it87_check_pwm(struct device *dev);
317 static void it87_init_device(struct platform_device *pdev);
320 static struct platform_driver it87_driver = {
322 .owner = THIS_MODULE,
326 .remove = __devexit_p(it87_remove),
329 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
332 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
333 int nr = sensor_attr->index;
335 struct it87_data *data = it87_update_device(dev);
336 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
339 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
342 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
343 int nr = sensor_attr->index;
345 struct it87_data *data = it87_update_device(dev);
346 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
349 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
352 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
353 int nr = sensor_attr->index;
355 struct it87_data *data = it87_update_device(dev);
356 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
359 static ssize_t set_in_min(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_min[nr] = IN_TO_REG(val);
370 it87_write_value(data, IT87_REG_VIN_MIN(nr),
372 mutex_unlock(&data->update_lock);
375 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
376 const char *buf, size_t count)
378 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
379 int nr = sensor_attr->index;
381 struct it87_data *data = dev_get_drvdata(dev);
382 unsigned long val = simple_strtoul(buf, NULL, 10);
384 mutex_lock(&data->update_lock);
385 data->in_max[nr] = IN_TO_REG(val);
386 it87_write_value(data, IT87_REG_VIN_MAX(nr),
388 mutex_unlock(&data->update_lock);
392 #define show_in_offset(offset) \
393 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
394 show_in, NULL, offset);
396 #define limit_in_offset(offset) \
397 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
398 show_in_min, set_in_min, offset); \
399 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
400 show_in_max, set_in_max, offset);
421 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
424 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
425 int nr = sensor_attr->index;
427 struct it87_data *data = it87_update_device(dev);
428 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
430 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
433 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
434 int nr = sensor_attr->index;
436 struct it87_data *data = it87_update_device(dev);
437 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
439 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
442 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
443 int nr = sensor_attr->index;
445 struct it87_data *data = it87_update_device(dev);
446 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
448 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
449 const char *buf, size_t count)
451 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
452 int nr = sensor_attr->index;
454 struct it87_data *data = dev_get_drvdata(dev);
455 int val = simple_strtol(buf, NULL, 10);
457 mutex_lock(&data->update_lock);
458 data->temp_high[nr] = TEMP_TO_REG(val);
459 it87_write_value(data, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
460 mutex_unlock(&data->update_lock);
463 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
464 const char *buf, size_t count)
466 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
467 int nr = sensor_attr->index;
469 struct it87_data *data = dev_get_drvdata(dev);
470 int val = simple_strtol(buf, NULL, 10);
472 mutex_lock(&data->update_lock);
473 data->temp_low[nr] = TEMP_TO_REG(val);
474 it87_write_value(data, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
475 mutex_unlock(&data->update_lock);
478 #define show_temp_offset(offset) \
479 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
480 show_temp, NULL, offset - 1); \
481 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
482 show_temp_max, set_temp_max, offset - 1); \
483 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
484 show_temp_min, set_temp_min, offset - 1);
490 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
493 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
494 int nr = sensor_attr->index;
496 struct it87_data *data = it87_update_device(dev);
497 u8 reg = data->sensor; /* In case the value is updated while we use it */
500 return sprintf(buf, "3\n"); /* thermal diode */
502 return sprintf(buf, "4\n"); /* thermistor */
503 return sprintf(buf, "0\n"); /* disabled */
505 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
506 const char *buf, size_t count)
508 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
509 int nr = sensor_attr->index;
511 struct it87_data *data = dev_get_drvdata(dev);
512 int val = simple_strtol(buf, NULL, 10);
514 mutex_lock(&data->update_lock);
516 data->sensor &= ~(1 << nr);
517 data->sensor &= ~(8 << nr);
518 if (val == 2) { /* backwards compatibility */
519 dev_warn(dev, "Sensor type 2 is deprecated, please use 4 "
523 /* 3 = thermal diode; 4 = thermistor; 0 = disabled */
525 data->sensor |= 1 << nr;
527 data->sensor |= 8 << nr;
529 mutex_unlock(&data->update_lock);
532 it87_write_value(data, IT87_REG_TEMP_ENABLE, data->sensor);
533 mutex_unlock(&data->update_lock);
536 #define show_sensor_offset(offset) \
537 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
538 show_sensor, set_sensor, offset - 1);
540 show_sensor_offset(1);
541 show_sensor_offset(2);
542 show_sensor_offset(3);
546 static int pwm_mode(const struct it87_data *data, int nr)
548 int ctrl = data->fan_main_ctrl & (1 << nr);
550 if (ctrl == 0) /* Full speed */
552 if (data->pwm_ctrl[nr] & 0x80) /* Automatic mode */
554 else /* Manual mode */
558 static ssize_t show_fan(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", FAN_FROM_REG(data->fan[nr],
566 DIV_FROM_REG(data->fan_div[nr])));
568 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
571 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
572 int nr = sensor_attr->index;
574 struct it87_data *data = it87_update_device(dev);
575 return sprintf(buf,"%d\n",
576 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
578 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
581 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
582 int nr = sensor_attr->index;
584 struct it87_data *data = it87_update_device(dev);
585 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
587 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
590 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
591 int nr = sensor_attr->index;
593 struct it87_data *data = it87_update_device(dev);
594 return sprintf(buf, "%d\n", pwm_mode(data, nr));
596 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
599 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
600 int nr = sensor_attr->index;
602 struct it87_data *data = it87_update_device(dev);
603 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm_duty[nr]));
605 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
608 struct it87_data *data = it87_update_device(dev);
609 int index = (data->fan_ctl >> 4) & 0x07;
611 return sprintf(buf, "%u\n", pwm_freq[index]);
613 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
614 const char *buf, size_t count)
616 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
617 int nr = sensor_attr->index;
619 struct it87_data *data = dev_get_drvdata(dev);
620 int val = simple_strtol(buf, NULL, 10);
623 mutex_lock(&data->update_lock);
624 reg = it87_read_value(data, IT87_REG_FAN_DIV);
626 case 0: data->fan_div[nr] = reg & 0x07; break;
627 case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
628 case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break;
631 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
632 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
633 mutex_unlock(&data->update_lock);
636 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
637 const char *buf, size_t count)
639 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
640 int nr = sensor_attr->index;
642 struct it87_data *data = dev_get_drvdata(dev);
643 unsigned long val = simple_strtoul(buf, NULL, 10);
647 mutex_lock(&data->update_lock);
648 old = it87_read_value(data, IT87_REG_FAN_DIV);
650 /* Save fan min limit */
651 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
656 data->fan_div[nr] = DIV_TO_REG(val);
660 data->fan_div[nr] = 1;
662 data->fan_div[nr] = 3;
665 val |= (data->fan_div[0] & 0x07);
666 val |= (data->fan_div[1] & 0x07) << 3;
667 if (data->fan_div[2] == 3)
669 it87_write_value(data, IT87_REG_FAN_DIV, val);
671 /* Restore fan min limit */
672 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
673 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
675 mutex_unlock(&data->update_lock);
678 static ssize_t set_pwm_enable(struct device *dev,
679 struct device_attribute *attr, const char *buf, size_t count)
681 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
682 int nr = sensor_attr->index;
684 struct it87_data *data = dev_get_drvdata(dev);
685 int val = simple_strtol(buf, NULL, 10);
687 if (val < 0 || val > 2)
690 mutex_lock(&data->update_lock);
694 /* make sure the fan is on when in on/off mode */
695 tmp = it87_read_value(data, IT87_REG_FAN_CTL);
696 it87_write_value(data, IT87_REG_FAN_CTL, tmp | (1 << nr));
697 /* set on/off mode */
698 data->fan_main_ctrl &= ~(1 << nr);
699 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
701 if (val == 1) /* Manual mode */
702 data->pwm_ctrl[nr] = data->pwm_duty[nr];
703 else /* Automatic mode */
704 data->pwm_ctrl[nr] = 0x80 | data->pwm_temp_map[nr];
705 it87_write_value(data, IT87_REG_PWM(nr), data->pwm_ctrl[nr]);
706 /* set SmartGuardian mode */
707 data->fan_main_ctrl |= (1 << nr);
708 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
711 mutex_unlock(&data->update_lock);
714 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
715 const char *buf, size_t count)
717 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
718 int nr = sensor_attr->index;
720 struct it87_data *data = dev_get_drvdata(dev);
721 int val = simple_strtol(buf, NULL, 10);
723 if (val < 0 || val > 255)
726 mutex_lock(&data->update_lock);
727 data->pwm_duty[nr] = PWM_TO_REG(val);
728 /* If we are in manual mode, write the duty cycle immediately;
729 * otherwise, just store it for later use. */
730 if (!(data->pwm_ctrl[nr] & 0x80)) {
731 data->pwm_ctrl[nr] = data->pwm_duty[nr];
732 it87_write_value(data, IT87_REG_PWM(nr), data->pwm_ctrl[nr]);
734 mutex_unlock(&data->update_lock);
737 static ssize_t set_pwm_freq(struct device *dev,
738 struct device_attribute *attr, const char *buf, size_t count)
740 struct it87_data *data = dev_get_drvdata(dev);
741 unsigned long val = simple_strtoul(buf, NULL, 10);
744 /* Search for the nearest available frequency */
745 for (i = 0; i < 7; i++) {
746 if (val > (pwm_freq[i] + pwm_freq[i+1]) / 2)
750 mutex_lock(&data->update_lock);
751 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL) & 0x8f;
752 data->fan_ctl |= i << 4;
753 it87_write_value(data, IT87_REG_FAN_CTL, data->fan_ctl);
754 mutex_unlock(&data->update_lock);
758 static ssize_t show_pwm_temp_map(struct device *dev,
759 struct device_attribute *attr, char *buf)
761 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
762 int nr = sensor_attr->index;
764 struct it87_data *data = it87_update_device(dev);
767 if (data->pwm_temp_map[nr] < 3)
768 map = 1 << data->pwm_temp_map[nr];
770 map = 0; /* Should never happen */
771 return sprintf(buf, "%d\n", map);
773 static ssize_t set_pwm_temp_map(struct device *dev,
774 struct device_attribute *attr, const char *buf, size_t count)
776 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
777 int nr = sensor_attr->index;
779 struct it87_data *data = dev_get_drvdata(dev);
783 if (strict_strtol(buf, 10, &val) < 0)
800 mutex_lock(&data->update_lock);
801 data->pwm_temp_map[nr] = reg;
802 /* If we are in automatic mode, write the temp mapping immediately;
803 * otherwise, just store it for later use. */
804 if (data->pwm_ctrl[nr] & 0x80) {
805 data->pwm_ctrl[nr] = 0x80 | data->pwm_temp_map[nr];
806 it87_write_value(data, IT87_REG_PWM(nr), data->pwm_ctrl[nr]);
808 mutex_unlock(&data->update_lock);
812 #define show_fan_offset(offset) \
813 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
814 show_fan, NULL, offset - 1); \
815 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
816 show_fan_min, set_fan_min, offset - 1); \
817 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
818 show_fan_div, set_fan_div, offset - 1);
824 #define show_pwm_offset(offset) \
825 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
826 show_pwm_enable, set_pwm_enable, offset - 1); \
827 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
828 show_pwm, set_pwm, offset - 1); \
829 static DEVICE_ATTR(pwm##offset##_freq, \
830 (offset == 1 ? S_IRUGO | S_IWUSR : S_IRUGO), \
831 show_pwm_freq, (offset == 1 ? set_pwm_freq : NULL)); \
832 static SENSOR_DEVICE_ATTR(pwm##offset##_auto_channels_temp, \
833 S_IRUGO, show_pwm_temp_map, set_pwm_temp_map, \
840 /* A different set of callbacks for 16-bit fans */
841 static ssize_t show_fan16(struct device *dev, struct device_attribute *attr,
844 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
845 int nr = sensor_attr->index;
846 struct it87_data *data = it87_update_device(dev);
847 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan[nr]));
850 static ssize_t show_fan16_min(struct device *dev, struct device_attribute *attr,
853 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
854 int nr = sensor_attr->index;
855 struct it87_data *data = it87_update_device(dev);
856 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan_min[nr]));
859 static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr,
860 const char *buf, size_t count)
862 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
863 int nr = sensor_attr->index;
864 struct it87_data *data = dev_get_drvdata(dev);
865 int val = simple_strtol(buf, NULL, 10);
867 mutex_lock(&data->update_lock);
868 data->fan_min[nr] = FAN16_TO_REG(val);
869 it87_write_value(data, IT87_REG_FAN_MIN[nr],
870 data->fan_min[nr] & 0xff);
871 it87_write_value(data, IT87_REG_FANX_MIN[nr],
872 data->fan_min[nr] >> 8);
873 mutex_unlock(&data->update_lock);
877 /* We want to use the same sysfs file names as 8-bit fans, but we need
878 different variable names, so we have to use SENSOR_ATTR instead of
879 SENSOR_DEVICE_ATTR. */
880 #define show_fan16_offset(offset) \
881 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \
882 = SENSOR_ATTR(fan##offset##_input, S_IRUGO, \
883 show_fan16, NULL, offset - 1); \
884 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \
885 = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
886 show_fan16_min, set_fan16_min, offset - 1)
888 show_fan16_offset(1);
889 show_fan16_offset(2);
890 show_fan16_offset(3);
891 show_fan16_offset(4);
892 show_fan16_offset(5);
895 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
897 struct it87_data *data = it87_update_device(dev);
898 return sprintf(buf, "%u\n", data->alarms);
900 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
902 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
905 int bitnr = to_sensor_dev_attr(attr)->index;
906 struct it87_data *data = it87_update_device(dev);
907 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
909 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8);
910 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9);
911 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10);
912 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11);
913 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12);
914 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13);
915 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14);
916 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15);
917 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
918 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1);
919 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 2);
920 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 3);
921 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 6);
922 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 16);
923 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 17);
924 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 18);
926 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
929 int bitnr = to_sensor_dev_attr(attr)->index;
930 struct it87_data *data = it87_update_device(dev);
931 return sprintf(buf, "%u\n", (data->beeps >> bitnr) & 1);
933 static ssize_t set_beep(struct device *dev, struct device_attribute *attr,
934 const char *buf, size_t count)
936 int bitnr = to_sensor_dev_attr(attr)->index;
937 struct it87_data *data = dev_get_drvdata(dev);
940 if (strict_strtol(buf, 10, &val) < 0
941 || (val != 0 && val != 1))
944 mutex_lock(&data->update_lock);
945 data->beeps = it87_read_value(data, IT87_REG_BEEP_ENABLE);
947 data->beeps |= (1 << bitnr);
949 data->beeps &= ~(1 << bitnr);
950 it87_write_value(data, IT87_REG_BEEP_ENABLE, data->beeps);
951 mutex_unlock(&data->update_lock);
955 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR,
956 show_beep, set_beep, 1);
957 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO, show_beep, NULL, 1);
958 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO, show_beep, NULL, 1);
959 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO, show_beep, NULL, 1);
960 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO, show_beep, NULL, 1);
961 static SENSOR_DEVICE_ATTR(in5_beep, S_IRUGO, show_beep, NULL, 1);
962 static SENSOR_DEVICE_ATTR(in6_beep, S_IRUGO, show_beep, NULL, 1);
963 static SENSOR_DEVICE_ATTR(in7_beep, S_IRUGO, show_beep, NULL, 1);
964 /* fanX_beep writability is set later */
965 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO, show_beep, set_beep, 0);
966 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO, show_beep, set_beep, 0);
967 static SENSOR_DEVICE_ATTR(fan3_beep, S_IRUGO, show_beep, set_beep, 0);
968 static SENSOR_DEVICE_ATTR(fan4_beep, S_IRUGO, show_beep, set_beep, 0);
969 static SENSOR_DEVICE_ATTR(fan5_beep, S_IRUGO, show_beep, set_beep, 0);
970 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR,
971 show_beep, set_beep, 2);
972 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO, show_beep, NULL, 2);
973 static SENSOR_DEVICE_ATTR(temp3_beep, S_IRUGO, show_beep, NULL, 2);
976 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
978 struct it87_data *data = dev_get_drvdata(dev);
979 return sprintf(buf, "%u\n", data->vrm);
982 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
984 struct it87_data *data = dev_get_drvdata(dev);
987 val = simple_strtoul(buf, NULL, 10);
992 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
995 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
997 struct it87_data *data = it87_update_device(dev);
998 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
1000 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
1002 static ssize_t show_name(struct device *dev, struct device_attribute
1003 *devattr, char *buf)
1005 struct it87_data *data = dev_get_drvdata(dev);
1006 return sprintf(buf, "%s\n", data->name);
1008 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1010 static struct attribute *it87_attributes[] = {
1011 &sensor_dev_attr_in0_input.dev_attr.attr,
1012 &sensor_dev_attr_in1_input.dev_attr.attr,
1013 &sensor_dev_attr_in2_input.dev_attr.attr,
1014 &sensor_dev_attr_in3_input.dev_attr.attr,
1015 &sensor_dev_attr_in4_input.dev_attr.attr,
1016 &sensor_dev_attr_in5_input.dev_attr.attr,
1017 &sensor_dev_attr_in6_input.dev_attr.attr,
1018 &sensor_dev_attr_in7_input.dev_attr.attr,
1019 &sensor_dev_attr_in8_input.dev_attr.attr,
1020 &sensor_dev_attr_in0_min.dev_attr.attr,
1021 &sensor_dev_attr_in1_min.dev_attr.attr,
1022 &sensor_dev_attr_in2_min.dev_attr.attr,
1023 &sensor_dev_attr_in3_min.dev_attr.attr,
1024 &sensor_dev_attr_in4_min.dev_attr.attr,
1025 &sensor_dev_attr_in5_min.dev_attr.attr,
1026 &sensor_dev_attr_in6_min.dev_attr.attr,
1027 &sensor_dev_attr_in7_min.dev_attr.attr,
1028 &sensor_dev_attr_in0_max.dev_attr.attr,
1029 &sensor_dev_attr_in1_max.dev_attr.attr,
1030 &sensor_dev_attr_in2_max.dev_attr.attr,
1031 &sensor_dev_attr_in3_max.dev_attr.attr,
1032 &sensor_dev_attr_in4_max.dev_attr.attr,
1033 &sensor_dev_attr_in5_max.dev_attr.attr,
1034 &sensor_dev_attr_in6_max.dev_attr.attr,
1035 &sensor_dev_attr_in7_max.dev_attr.attr,
1036 &sensor_dev_attr_in0_alarm.dev_attr.attr,
1037 &sensor_dev_attr_in1_alarm.dev_attr.attr,
1038 &sensor_dev_attr_in2_alarm.dev_attr.attr,
1039 &sensor_dev_attr_in3_alarm.dev_attr.attr,
1040 &sensor_dev_attr_in4_alarm.dev_attr.attr,
1041 &sensor_dev_attr_in5_alarm.dev_attr.attr,
1042 &sensor_dev_attr_in6_alarm.dev_attr.attr,
1043 &sensor_dev_attr_in7_alarm.dev_attr.attr,
1045 &sensor_dev_attr_temp1_input.dev_attr.attr,
1046 &sensor_dev_attr_temp2_input.dev_attr.attr,
1047 &sensor_dev_attr_temp3_input.dev_attr.attr,
1048 &sensor_dev_attr_temp1_max.dev_attr.attr,
1049 &sensor_dev_attr_temp2_max.dev_attr.attr,
1050 &sensor_dev_attr_temp3_max.dev_attr.attr,
1051 &sensor_dev_attr_temp1_min.dev_attr.attr,
1052 &sensor_dev_attr_temp2_min.dev_attr.attr,
1053 &sensor_dev_attr_temp3_min.dev_attr.attr,
1054 &sensor_dev_attr_temp1_type.dev_attr.attr,
1055 &sensor_dev_attr_temp2_type.dev_attr.attr,
1056 &sensor_dev_attr_temp3_type.dev_attr.attr,
1057 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1058 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1059 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1061 &dev_attr_alarms.attr,
1062 &dev_attr_name.attr,
1066 static const struct attribute_group it87_group = {
1067 .attrs = it87_attributes,
1070 static struct attribute *it87_attributes_beep[] = {
1071 &sensor_dev_attr_in0_beep.dev_attr.attr,
1072 &sensor_dev_attr_in1_beep.dev_attr.attr,
1073 &sensor_dev_attr_in2_beep.dev_attr.attr,
1074 &sensor_dev_attr_in3_beep.dev_attr.attr,
1075 &sensor_dev_attr_in4_beep.dev_attr.attr,
1076 &sensor_dev_attr_in5_beep.dev_attr.attr,
1077 &sensor_dev_attr_in6_beep.dev_attr.attr,
1078 &sensor_dev_attr_in7_beep.dev_attr.attr,
1080 &sensor_dev_attr_temp1_beep.dev_attr.attr,
1081 &sensor_dev_attr_temp2_beep.dev_attr.attr,
1082 &sensor_dev_attr_temp3_beep.dev_attr.attr,
1086 static const struct attribute_group it87_group_beep = {
1087 .attrs = it87_attributes_beep,
1090 static struct attribute *it87_attributes_fan16[5][3+1] = { {
1091 &sensor_dev_attr_fan1_input16.dev_attr.attr,
1092 &sensor_dev_attr_fan1_min16.dev_attr.attr,
1093 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1096 &sensor_dev_attr_fan2_input16.dev_attr.attr,
1097 &sensor_dev_attr_fan2_min16.dev_attr.attr,
1098 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1101 &sensor_dev_attr_fan3_input16.dev_attr.attr,
1102 &sensor_dev_attr_fan3_min16.dev_attr.attr,
1103 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1106 &sensor_dev_attr_fan4_input16.dev_attr.attr,
1107 &sensor_dev_attr_fan4_min16.dev_attr.attr,
1108 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1111 &sensor_dev_attr_fan5_input16.dev_attr.attr,
1112 &sensor_dev_attr_fan5_min16.dev_attr.attr,
1113 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1117 static const struct attribute_group it87_group_fan16[5] = {
1118 { .attrs = it87_attributes_fan16[0] },
1119 { .attrs = it87_attributes_fan16[1] },
1120 { .attrs = it87_attributes_fan16[2] },
1121 { .attrs = it87_attributes_fan16[3] },
1122 { .attrs = it87_attributes_fan16[4] },
1125 static struct attribute *it87_attributes_fan[3][4+1] = { {
1126 &sensor_dev_attr_fan1_input.dev_attr.attr,
1127 &sensor_dev_attr_fan1_min.dev_attr.attr,
1128 &sensor_dev_attr_fan1_div.dev_attr.attr,
1129 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1132 &sensor_dev_attr_fan2_input.dev_attr.attr,
1133 &sensor_dev_attr_fan2_min.dev_attr.attr,
1134 &sensor_dev_attr_fan2_div.dev_attr.attr,
1135 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1138 &sensor_dev_attr_fan3_input.dev_attr.attr,
1139 &sensor_dev_attr_fan3_min.dev_attr.attr,
1140 &sensor_dev_attr_fan3_div.dev_attr.attr,
1141 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1145 static const struct attribute_group it87_group_fan[3] = {
1146 { .attrs = it87_attributes_fan[0] },
1147 { .attrs = it87_attributes_fan[1] },
1148 { .attrs = it87_attributes_fan[2] },
1151 static const struct attribute_group *
1152 it87_get_fan_group(const struct it87_data *data)
1154 return has_16bit_fans(data) ? it87_group_fan16 : it87_group_fan;
1157 static struct attribute *it87_attributes_pwm[3][4+1] = { {
1158 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1159 &sensor_dev_attr_pwm1.dev_attr.attr,
1160 &dev_attr_pwm1_freq.attr,
1161 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1164 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1165 &sensor_dev_attr_pwm2.dev_attr.attr,
1166 &dev_attr_pwm2_freq.attr,
1167 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1170 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1171 &sensor_dev_attr_pwm3.dev_attr.attr,
1172 &dev_attr_pwm3_freq.attr,
1173 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1177 static const struct attribute_group it87_group_pwm[3] = {
1178 { .attrs = it87_attributes_pwm[0] },
1179 { .attrs = it87_attributes_pwm[1] },
1180 { .attrs = it87_attributes_pwm[2] },
1183 static struct attribute *it87_attributes_fan_beep[] = {
1184 &sensor_dev_attr_fan1_beep.dev_attr.attr,
1185 &sensor_dev_attr_fan2_beep.dev_attr.attr,
1186 &sensor_dev_attr_fan3_beep.dev_attr.attr,
1187 &sensor_dev_attr_fan4_beep.dev_attr.attr,
1188 &sensor_dev_attr_fan5_beep.dev_attr.attr,
1191 static struct attribute *it87_attributes_vid[] = {
1193 &dev_attr_cpu0_vid.attr,
1197 static const struct attribute_group it87_group_vid = {
1198 .attrs = it87_attributes_vid,
1201 /* SuperIO detection - will change isa_address if a chip is found */
1202 static int __init it87_find(unsigned short *address,
1203 struct it87_sio_data *sio_data)
1207 const char *board_vendor, *board_name;
1210 chip_type = force_id ? force_id : superio_inw(DEVID);
1212 switch (chip_type) {
1214 sio_data->type = it87;
1217 sio_data->type = it8712;
1221 sio_data->type = it8716;
1224 sio_data->type = it8718;
1227 sio_data->type = it8720;
1229 case 0xffff: /* No device at all */
1232 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
1237 superio_select(PME);
1238 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
1239 pr_info("it87: Device not activated, skipping\n");
1243 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
1244 if (*address == 0) {
1245 pr_info("it87: Base address not set, skipping\n");
1250 sio_data->revision = superio_inb(DEVREV) & 0x0f;
1251 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
1252 chip_type, *address, sio_data->revision);
1254 /* Read GPIO config and VID value from LDN 7 (GPIO) */
1255 if (sio_data->type == it87) {
1256 /* The IT8705F doesn't have VID pins at all */
1257 sio_data->skip_vid = 1;
1259 /* The IT8705F has a different LD number for GPIO */
1261 sio_data->beep_pin = superio_inb(IT87_SIO_BEEP_PIN_REG) & 0x3f;
1265 superio_select(GPIO);
1266 /* We need at least 4 VID pins */
1267 reg = superio_inb(IT87_SIO_GPIO3_REG);
1269 pr_info("it87: VID is disabled (pins used for GPIO)\n");
1270 sio_data->skip_vid = 1;
1273 /* Check if fan3 is there or not */
1275 sio_data->skip_pwm |= (1 << 2);
1277 sio_data->skip_fan |= (1 << 2);
1279 /* Check if fan2 is there or not */
1280 reg = superio_inb(IT87_SIO_GPIO5_REG);
1282 sio_data->skip_pwm |= (1 << 1);
1284 sio_data->skip_fan |= (1 << 1);
1286 if ((sio_data->type == it8718 || sio_data->type == it8720)
1287 && !(sio_data->skip_vid))
1288 sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
1290 reg = superio_inb(IT87_SIO_PINX2_REG);
1292 pr_info("it87: in3 is VCC (+5V)\n");
1294 pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
1296 sio_data->beep_pin = superio_inb(IT87_SIO_BEEP_PIN_REG) & 0x3f;
1298 if (sio_data->beep_pin)
1299 pr_info("it87: Beeping is supported\n");
1301 /* Disable specific features based on DMI strings */
1302 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1303 board_name = dmi_get_system_info(DMI_BOARD_NAME);
1304 if (board_vendor && board_name) {
1305 if (strcmp(board_vendor, "nVIDIA") == 0
1306 && strcmp(board_name, "FN68PT") == 0) {
1307 /* On the Shuttle SN68PT, FAN_CTL2 is apparently not
1308 connected to a fan, but to something else. One user
1309 has reported instant system power-off when changing
1310 the PWM2 duty cycle, so we disable it.
1311 I use the board name string as the trigger in case
1312 the same board is ever used in other systems. */
1313 pr_info("it87: Disabling pwm2 due to "
1314 "hardware constraints\n");
1315 sio_data->skip_pwm = (1 << 1);
1324 static void it87_remove_files(struct device *dev)
1326 struct it87_data *data = platform_get_drvdata(pdev);
1327 struct it87_sio_data *sio_data = dev->platform_data;
1328 const struct attribute_group *fan_group = it87_get_fan_group(data);
1331 sysfs_remove_group(&dev->kobj, &it87_group);
1332 if (sio_data->beep_pin)
1333 sysfs_remove_group(&dev->kobj, &it87_group_beep);
1334 for (i = 0; i < 5; i++) {
1335 if (!(data->has_fan & (1 << i)))
1337 sysfs_remove_group(&dev->kobj, &fan_group[i]);
1338 if (sio_data->beep_pin)
1339 sysfs_remove_file(&dev->kobj,
1340 it87_attributes_fan_beep[i]);
1342 for (i = 0; i < 3; i++) {
1343 if (sio_data->skip_pwm & (1 << 0))
1345 sysfs_remove_group(&dev->kobj, &it87_group_pwm[i]);
1347 if (!sio_data->skip_vid)
1348 sysfs_remove_group(&dev->kobj, &it87_group_vid);
1351 static int __devinit it87_probe(struct platform_device *pdev)
1353 struct it87_data *data;
1354 struct resource *res;
1355 struct device *dev = &pdev->dev;
1356 struct it87_sio_data *sio_data = dev->platform_data;
1357 const struct attribute_group *fan_group;
1359 int enable_pwm_interface;
1360 int fan_beep_need_rw;
1361 static const char *names[] = {
1369 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1370 if (!request_region(res->start, IT87_EC_EXTENT, DRVNAME)) {
1371 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1372 (unsigned long)res->start,
1373 (unsigned long)(res->start + IT87_EC_EXTENT - 1));
1378 if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
1383 data->addr = res->start;
1384 data->type = sio_data->type;
1385 data->revision = sio_data->revision;
1386 data->name = names[sio_data->type];
1388 /* Now, we do the remaining detection. */
1389 if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80)
1390 || it87_read_value(data, IT87_REG_CHIPID) != 0x90) {
1395 platform_set_drvdata(pdev, data);
1397 mutex_init(&data->update_lock);
1399 /* Check PWM configuration */
1400 enable_pwm_interface = it87_check_pwm(dev);
1402 /* Initialize the IT87 chip */
1403 it87_init_device(pdev);
1405 /* Register sysfs hooks */
1406 if ((err = sysfs_create_group(&dev->kobj, &it87_group)))
1409 if (sio_data->beep_pin) {
1410 err = sysfs_create_group(&dev->kobj, &it87_group_beep);
1415 /* Do not create fan files for disabled fans */
1416 fan_group = it87_get_fan_group(data);
1417 fan_beep_need_rw = 1;
1418 for (i = 0; i < 5; i++) {
1419 if (!(data->has_fan & (1 << i)))
1421 err = sysfs_create_group(&dev->kobj, &fan_group[i]);
1425 if (sio_data->beep_pin) {
1426 err = sysfs_create_file(&dev->kobj,
1427 it87_attributes_fan_beep[i]);
1430 if (!fan_beep_need_rw)
1433 /* As we have a single beep enable bit for all fans,
1434 * only the first enabled fan has a writable attribute
1436 if (sysfs_chmod_file(&dev->kobj,
1437 it87_attributes_fan_beep[i],
1439 dev_dbg(dev, "chmod +w fan%d_beep failed\n",
1441 fan_beep_need_rw = 0;
1445 if (enable_pwm_interface) {
1446 for (i = 0; i < 3; i++) {
1447 if (sio_data->skip_pwm & (1 << i))
1449 err = sysfs_create_group(&dev->kobj,
1450 &it87_group_pwm[i]);
1456 if (!sio_data->skip_vid) {
1457 data->vrm = vid_which_vrm();
1458 /* VID reading from Super-I/O config space if available */
1459 data->vid = sio_data->vid_value;
1460 err = sysfs_create_group(&dev->kobj, &it87_group_vid);
1465 data->hwmon_dev = hwmon_device_register(dev);
1466 if (IS_ERR(data->hwmon_dev)) {
1467 err = PTR_ERR(data->hwmon_dev);
1474 it87_remove_files(dev);
1476 platform_set_drvdata(pdev, NULL);
1479 release_region(res->start, IT87_EC_EXTENT);
1484 static int __devexit it87_remove(struct platform_device *pdev)
1486 struct it87_data *data = platform_get_drvdata(pdev);
1488 hwmon_device_unregister(data->hwmon_dev);
1489 it87_remove_files(&pdev->dev);
1491 release_region(data->addr, IT87_EC_EXTENT);
1492 platform_set_drvdata(pdev, NULL);
1498 /* Must be called with data->update_lock held, except during initialization.
1499 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1500 would slow down the IT87 access and should not be necessary. */
1501 static int it87_read_value(struct it87_data *data, u8 reg)
1503 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1504 return inb_p(data->addr + IT87_DATA_REG_OFFSET);
1507 /* Must be called with data->update_lock held, except during initialization.
1508 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1509 would slow down the IT87 access and should not be necessary. */
1510 static void it87_write_value(struct it87_data *data, u8 reg, u8 value)
1512 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1513 outb_p(value, data->addr + IT87_DATA_REG_OFFSET);
1516 /* Return 1 if and only if the PWM interface is safe to use */
1517 static int __devinit it87_check_pwm(struct device *dev)
1519 struct it87_data *data = dev_get_drvdata(dev);
1520 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
1521 * and polarity set to active low is sign that this is the case so we
1522 * disable pwm control to protect the user. */
1523 int tmp = it87_read_value(data, IT87_REG_FAN_CTL);
1524 if ((tmp & 0x87) == 0) {
1525 if (fix_pwm_polarity) {
1526 /* The user asks us to attempt a chip reconfiguration.
1527 * This means switching to active high polarity and
1528 * inverting all fan speed values. */
1532 for (i = 0; i < 3; i++)
1533 pwm[i] = it87_read_value(data,
1536 /* If any fan is in automatic pwm mode, the polarity
1537 * might be correct, as suspicious as it seems, so we
1538 * better don't change anything (but still disable the
1539 * PWM interface). */
1540 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1541 dev_info(dev, "Reconfiguring PWM to "
1542 "active high polarity\n");
1543 it87_write_value(data, IT87_REG_FAN_CTL,
1545 for (i = 0; i < 3; i++)
1546 it87_write_value(data,
1552 dev_info(dev, "PWM configuration is "
1553 "too broken to be fixed\n");
1556 dev_info(dev, "Detected broken BIOS "
1557 "defaults, disabling PWM interface\n");
1559 } else if (fix_pwm_polarity) {
1560 dev_info(dev, "PWM configuration looks "
1561 "sane, won't touch\n");
1567 /* Called when we have found a new IT87. */
1568 static void __devinit it87_init_device(struct platform_device *pdev)
1570 struct it87_sio_data *sio_data = pdev->dev.platform_data;
1571 struct it87_data *data = platform_get_drvdata(pdev);
1575 /* For each PWM channel:
1576 * - If it is in automatic mode, setting to manual mode should set
1577 * the fan to full speed by default.
1578 * - If it is in manual mode, we need a mapping to temperature
1579 * channels to use when later setting to automatic mode later.
1580 * Use a 1:1 mapping by default (we are clueless.)
1581 * In both cases, the value can (and should) be changed by the user
1582 * prior to switching to a different mode. */
1583 for (i = 0; i < 3; i++) {
1584 data->pwm_temp_map[i] = i;
1585 data->pwm_duty[i] = 0x7f; /* Full speed */
1588 /* Some chips seem to have default value 0xff for all limit
1589 * registers. For low voltage limits it makes no sense and triggers
1590 * alarms, so change to 0 instead. For high temperature limits, it
1591 * means -1 degree C, which surprisingly doesn't trigger an alarm,
1592 * but is still confusing, so change to 127 degrees C. */
1593 for (i = 0; i < 8; i++) {
1594 tmp = it87_read_value(data, IT87_REG_VIN_MIN(i));
1596 it87_write_value(data, IT87_REG_VIN_MIN(i), 0);
1598 for (i = 0; i < 3; i++) {
1599 tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1601 it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127);
1604 /* Check if temperature channels are reset manually or by some reason */
1605 tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1606 if ((tmp & 0x3f) == 0) {
1607 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1608 tmp = (tmp & 0xc0) | 0x2a;
1609 it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp);
1613 /* Check if voltage monitors are reset manually or by some reason */
1614 tmp = it87_read_value(data, IT87_REG_VIN_ENABLE);
1615 if ((tmp & 0xff) == 0) {
1616 /* Enable all voltage monitors */
1617 it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff);
1620 /* Check if tachometers are reset manually or by some reason */
1621 mask = 0x70 & ~(sio_data->skip_fan << 4);
1622 data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
1623 if ((data->fan_main_ctrl & mask) == 0) {
1624 /* Enable all fan tachometers */
1625 data->fan_main_ctrl |= mask;
1626 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1628 data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
1630 /* Set tachometers to 16-bit mode if needed */
1631 if (has_16bit_fans(data)) {
1632 tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
1633 if (~tmp & 0x07 & data->has_fan) {
1635 "Setting fan1-3 to 16-bit mode\n");
1636 it87_write_value(data, IT87_REG_FAN_16BIT,
1639 /* IT8705F only supports three fans. */
1640 if (data->type != it87) {
1642 data->has_fan |= (1 << 3); /* fan4 enabled */
1644 data->has_fan |= (1 << 4); /* fan5 enabled */
1648 /* Fan input pins may be used for alternative functions */
1649 data->has_fan &= ~sio_data->skip_fan;
1651 /* Start monitoring */
1652 it87_write_value(data, IT87_REG_CONFIG,
1653 (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
1654 | (update_vbat ? 0x41 : 0x01));
1657 static void it87_update_pwm_ctrl(struct it87_data *data, int nr)
1659 data->pwm_ctrl[nr] = it87_read_value(data, IT87_REG_PWM(nr));
1660 if (data->pwm_ctrl[nr] & 0x80) /* Automatic mode */
1661 data->pwm_temp_map[nr] = data->pwm_ctrl[nr] & 0x03;
1662 else /* Manual mode */
1663 data->pwm_duty[nr] = data->pwm_ctrl[nr] & 0x7f;
1666 static struct it87_data *it87_update_device(struct device *dev)
1668 struct it87_data *data = dev_get_drvdata(dev);
1671 mutex_lock(&data->update_lock);
1673 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1677 /* Cleared after each update, so reenable. Value
1678 returned by this read will be previous value */
1679 it87_write_value(data, IT87_REG_CONFIG,
1680 it87_read_value(data, IT87_REG_CONFIG) | 0x40);
1682 for (i = 0; i <= 7; i++) {
1684 it87_read_value(data, IT87_REG_VIN(i));
1686 it87_read_value(data, IT87_REG_VIN_MIN(i));
1688 it87_read_value(data, IT87_REG_VIN_MAX(i));
1690 /* in8 (battery) has no limit registers */
1692 it87_read_value(data, IT87_REG_VIN(8));
1694 for (i = 0; i < 5; i++) {
1695 /* Skip disabled fans */
1696 if (!(data->has_fan & (1 << i)))
1700 it87_read_value(data, IT87_REG_FAN_MIN[i]);
1701 data->fan[i] = it87_read_value(data,
1703 /* Add high byte if in 16-bit mode */
1704 if (has_16bit_fans(data)) {
1705 data->fan[i] |= it87_read_value(data,
1706 IT87_REG_FANX[i]) << 8;
1707 data->fan_min[i] |= it87_read_value(data,
1708 IT87_REG_FANX_MIN[i]) << 8;
1711 for (i = 0; i < 3; i++) {
1713 it87_read_value(data, IT87_REG_TEMP(i));
1714 data->temp_high[i] =
1715 it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1717 it87_read_value(data, IT87_REG_TEMP_LOW(i));
1720 /* Newer chips don't have clock dividers */
1721 if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
1722 i = it87_read_value(data, IT87_REG_FAN_DIV);
1723 data->fan_div[0] = i & 0x07;
1724 data->fan_div[1] = (i >> 3) & 0x07;
1725 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1729 it87_read_value(data, IT87_REG_ALARM1) |
1730 (it87_read_value(data, IT87_REG_ALARM2) << 8) |
1731 (it87_read_value(data, IT87_REG_ALARM3) << 16);
1732 data->beeps = it87_read_value(data, IT87_REG_BEEP_ENABLE);
1734 data->fan_main_ctrl = it87_read_value(data,
1735 IT87_REG_FAN_MAIN_CTRL);
1736 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
1737 for (i = 0; i < 3; i++)
1738 it87_update_pwm_ctrl(data, i);
1740 data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1741 /* The 8705 does not have VID capability.
1742 The 8718 and the 8720 don't use IT87_REG_VID for the
1744 if (data->type == it8712 || data->type == it8716) {
1745 data->vid = it87_read_value(data, IT87_REG_VID);
1746 /* The older IT8712F revisions had only 5 VID pins,
1747 but we assume it is always safe to read 6 bits. */
1750 data->last_updated = jiffies;
1754 mutex_unlock(&data->update_lock);
1759 static int __init it87_device_add(unsigned short address,
1760 const struct it87_sio_data *sio_data)
1762 struct resource res = {
1763 .start = address + IT87_EC_OFFSET,
1764 .end = address + IT87_EC_OFFSET + IT87_EC_EXTENT - 1,
1766 .flags = IORESOURCE_IO,
1770 err = acpi_check_resource_conflict(&res);
1774 pdev = platform_device_alloc(DRVNAME, address);
1777 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1781 err = platform_device_add_resources(pdev, &res, 1);
1783 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1785 goto exit_device_put;
1788 err = platform_device_add_data(pdev, sio_data,
1789 sizeof(struct it87_sio_data));
1791 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1792 goto exit_device_put;
1795 err = platform_device_add(pdev);
1797 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1799 goto exit_device_put;
1805 platform_device_put(pdev);
1810 static int __init sm_it87_init(void)
1813 unsigned short isa_address=0;
1814 struct it87_sio_data sio_data;
1816 memset(&sio_data, 0, sizeof(struct it87_sio_data));
1817 err = it87_find(&isa_address, &sio_data);
1820 err = platform_driver_register(&it87_driver);
1824 err = it87_device_add(isa_address, &sio_data);
1826 platform_driver_unregister(&it87_driver);
1833 static void __exit sm_it87_exit(void)
1835 platform_device_unregister(pdev);
1836 platform_driver_unregister(&it87_driver);
1840 MODULE_AUTHOR("Chris Gauthron, "
1841 "Jean Delvare <khali@linux-fr.org>");
1842 MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8720F/8726F, SiS950 driver");
1843 module_param(update_vbat, bool, 0);
1844 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1845 module_param(fix_pwm_polarity, bool, 0);
1846 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1847 MODULE_LICENSE("GPL");
1849 module_init(sm_it87_init);
1850 module_exit(sm_it87_exit);