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 */
132 /* Update battery voltage after every reading if true */
133 static int update_vbat;
135 /* Not all BIOSes properly configure the PWM registers */
136 static int fix_pwm_polarity;
138 /* Many IT87 constants specified below */
140 /* Length of ISA address segment */
141 #define IT87_EXTENT 8
143 /* Length of ISA address segment for Environmental Controller */
144 #define IT87_EC_EXTENT 2
146 /* Offset of EC registers from ISA base address */
147 #define IT87_EC_OFFSET 5
149 /* Where are the ISA address/data registers relative to the EC base address */
150 #define IT87_ADDR_REG_OFFSET 0
151 #define IT87_DATA_REG_OFFSET 1
153 /*----- The IT87 registers -----*/
155 #define IT87_REG_CONFIG 0x00
157 #define IT87_REG_ALARM1 0x01
158 #define IT87_REG_ALARM2 0x02
159 #define IT87_REG_ALARM3 0x03
161 /* The IT8718F and IT8720F have the VID value in a different register, in
162 Super-I/O configuration space. */
163 #define IT87_REG_VID 0x0a
164 /* The IT8705F and IT8712F earlier than revision 0x08 use register 0x0b
165 for fan divisors. Later IT8712F revisions must use 16-bit tachometer
167 #define IT87_REG_FAN_DIV 0x0b
168 #define IT87_REG_FAN_16BIT 0x0c
170 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
172 static const u8 IT87_REG_FAN[] = { 0x0d, 0x0e, 0x0f, 0x80, 0x82 };
173 static const u8 IT87_REG_FAN_MIN[] = { 0x10, 0x11, 0x12, 0x84, 0x86 };
174 static const u8 IT87_REG_FANX[] = { 0x18, 0x19, 0x1a, 0x81, 0x83 };
175 static const u8 IT87_REG_FANX_MIN[] = { 0x1b, 0x1c, 0x1d, 0x85, 0x87 };
176 #define IT87_REG_FAN_MAIN_CTRL 0x13
177 #define IT87_REG_FAN_CTL 0x14
178 #define IT87_REG_PWM(nr) (0x15 + (nr))
180 #define IT87_REG_VIN(nr) (0x20 + (nr))
181 #define IT87_REG_TEMP(nr) (0x29 + (nr))
183 #define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2)
184 #define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2)
185 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
186 #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2)
188 #define IT87_REG_VIN_ENABLE 0x50
189 #define IT87_REG_TEMP_ENABLE 0x51
191 #define IT87_REG_CHIPID 0x58
193 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
194 #define IN_FROM_REG(val) ((val) * 16)
196 static inline u8 FAN_TO_REG(long rpm, int div)
200 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
201 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
205 static inline u16 FAN16_TO_REG(long rpm)
209 return SENSORS_LIMIT((1350000 + rpm) / (rpm * 2), 1, 0xfffe);
212 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
213 /* The divider is fixed to 2 in 16-bit mode */
214 #define FAN16_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:1350000/((val)*2))
216 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
217 ((val)+500)/1000),-128,127))
218 #define TEMP_FROM_REG(val) ((val) * 1000)
220 #define PWM_TO_REG(val) ((val) >> 1)
221 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
223 static int DIV_TO_REG(int val)
226 while (answer < 7 && (val >>= 1))
230 #define DIV_FROM_REG(val) (1 << (val))
232 static const unsigned int pwm_freq[8] = {
244 struct it87_sio_data {
246 /* Values read from Super-I/O config space */
249 /* Features skipped based on config or DMI */
255 /* For each registered chip, we need to keep some data in memory.
256 The structure is dynamically allocated. */
258 struct device *hwmon_dev;
264 struct mutex update_lock;
265 char valid; /* !=0 if following fields are valid */
266 unsigned long last_updated; /* In jiffies */
268 u8 in[9]; /* Register value */
269 u8 in_max[8]; /* Register value */
270 u8 in_min[8]; /* Register value */
271 u8 has_fan; /* Bitfield, fans enabled */
272 u16 fan[5]; /* Register values, possibly combined */
273 u16 fan_min[5]; /* Register values, possibly combined */
274 s8 temp[3]; /* Register value */
275 s8 temp_high[3]; /* Register value */
276 s8 temp_low[3]; /* Register value */
277 u8 sensor; /* Register value */
278 u8 fan_div[3]; /* Register encoding, shifted right */
279 u8 vid; /* Register encoding, combined */
281 u32 alarms; /* Register encoding, combined */
282 u8 fan_main_ctrl; /* Register value */
283 u8 fan_ctl; /* Register value */
285 /* The following 3 arrays correspond to the same registers. The
286 * meaning of bits 6-0 depends on the value of bit 7, and we want
287 * to preserve settings on mode changes, so we have to track all
288 * values separately. */
289 u8 pwm_ctrl[3]; /* Register value */
290 u8 pwm_duty[3]; /* Manual PWM value set by user (bit 6-0) */
291 u8 pwm_temp_map[3]; /* PWM to temp. chan. mapping (bits 1-0) */
294 static inline int has_16bit_fans(const struct it87_data *data)
296 /* IT8705F Datasheet 0.4.1, 3h == Version G.
297 IT8712F Datasheet 0.9.1, section 8.3.5 indicates 8h == Version J.
298 These are the first revisions with 16bit tachometer support. */
299 return (data->type == it87 && data->revision >= 0x03)
300 || (data->type == it8712 && data->revision >= 0x08)
301 || data->type == it8716
302 || data->type == it8718
303 || data->type == it8720;
306 static int it87_probe(struct platform_device *pdev);
307 static int __devexit it87_remove(struct platform_device *pdev);
309 static int it87_read_value(struct it87_data *data, u8 reg);
310 static void it87_write_value(struct it87_data *data, u8 reg, u8 value);
311 static struct it87_data *it87_update_device(struct device *dev);
312 static int it87_check_pwm(struct device *dev);
313 static void it87_init_device(struct platform_device *pdev);
316 static struct platform_driver it87_driver = {
318 .owner = THIS_MODULE,
322 .remove = __devexit_p(it87_remove),
325 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
328 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
329 int nr = sensor_attr->index;
331 struct it87_data *data = it87_update_device(dev);
332 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
335 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
338 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
339 int nr = sensor_attr->index;
341 struct it87_data *data = it87_update_device(dev);
342 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
345 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
348 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
349 int nr = sensor_attr->index;
351 struct it87_data *data = it87_update_device(dev);
352 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
355 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
356 const char *buf, size_t count)
358 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
359 int nr = sensor_attr->index;
361 struct it87_data *data = dev_get_drvdata(dev);
362 unsigned long val = simple_strtoul(buf, NULL, 10);
364 mutex_lock(&data->update_lock);
365 data->in_min[nr] = IN_TO_REG(val);
366 it87_write_value(data, IT87_REG_VIN_MIN(nr),
368 mutex_unlock(&data->update_lock);
371 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
372 const char *buf, size_t count)
374 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
375 int nr = sensor_attr->index;
377 struct it87_data *data = dev_get_drvdata(dev);
378 unsigned long val = simple_strtoul(buf, NULL, 10);
380 mutex_lock(&data->update_lock);
381 data->in_max[nr] = IN_TO_REG(val);
382 it87_write_value(data, IT87_REG_VIN_MAX(nr),
384 mutex_unlock(&data->update_lock);
388 #define show_in_offset(offset) \
389 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
390 show_in, NULL, offset);
392 #define limit_in_offset(offset) \
393 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
394 show_in_min, set_in_min, offset); \
395 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
396 show_in_max, set_in_max, offset);
417 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
420 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
421 int nr = sensor_attr->index;
423 struct it87_data *data = it87_update_device(dev);
424 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
426 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
429 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
430 int nr = sensor_attr->index;
432 struct it87_data *data = it87_update_device(dev);
433 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
435 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
438 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
439 int nr = sensor_attr->index;
441 struct it87_data *data = it87_update_device(dev);
442 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
444 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
445 const char *buf, size_t count)
447 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
448 int nr = sensor_attr->index;
450 struct it87_data *data = dev_get_drvdata(dev);
451 int val = simple_strtol(buf, NULL, 10);
453 mutex_lock(&data->update_lock);
454 data->temp_high[nr] = TEMP_TO_REG(val);
455 it87_write_value(data, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
456 mutex_unlock(&data->update_lock);
459 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
460 const char *buf, size_t count)
462 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
463 int nr = sensor_attr->index;
465 struct it87_data *data = dev_get_drvdata(dev);
466 int val = simple_strtol(buf, NULL, 10);
468 mutex_lock(&data->update_lock);
469 data->temp_low[nr] = TEMP_TO_REG(val);
470 it87_write_value(data, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
471 mutex_unlock(&data->update_lock);
474 #define show_temp_offset(offset) \
475 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
476 show_temp, NULL, offset - 1); \
477 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
478 show_temp_max, set_temp_max, offset - 1); \
479 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
480 show_temp_min, set_temp_min, offset - 1);
486 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
489 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
490 int nr = sensor_attr->index;
492 struct it87_data *data = it87_update_device(dev);
493 u8 reg = data->sensor; /* In case the value is updated while we use it */
496 return sprintf(buf, "3\n"); /* thermal diode */
498 return sprintf(buf, "4\n"); /* thermistor */
499 return sprintf(buf, "0\n"); /* disabled */
501 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
502 const char *buf, size_t count)
504 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
505 int nr = sensor_attr->index;
507 struct it87_data *data = dev_get_drvdata(dev);
508 int val = simple_strtol(buf, NULL, 10);
510 mutex_lock(&data->update_lock);
512 data->sensor &= ~(1 << nr);
513 data->sensor &= ~(8 << nr);
514 if (val == 2) { /* backwards compatibility */
515 dev_warn(dev, "Sensor type 2 is deprecated, please use 4 "
519 /* 3 = thermal diode; 4 = thermistor; 0 = disabled */
521 data->sensor |= 1 << nr;
523 data->sensor |= 8 << nr;
525 mutex_unlock(&data->update_lock);
528 it87_write_value(data, IT87_REG_TEMP_ENABLE, data->sensor);
529 mutex_unlock(&data->update_lock);
532 #define show_sensor_offset(offset) \
533 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
534 show_sensor, set_sensor, offset - 1);
536 show_sensor_offset(1);
537 show_sensor_offset(2);
538 show_sensor_offset(3);
542 static int pwm_mode(const struct it87_data *data, int nr)
544 int ctrl = data->fan_main_ctrl & (1 << nr);
546 if (ctrl == 0) /* Full speed */
548 if (data->pwm_ctrl[nr] & 0x80) /* Automatic mode */
550 else /* Manual mode */
554 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
557 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
558 int nr = sensor_attr->index;
560 struct it87_data *data = it87_update_device(dev);
561 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
562 DIV_FROM_REG(data->fan_div[nr])));
564 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
567 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
568 int nr = sensor_attr->index;
570 struct it87_data *data = it87_update_device(dev);
571 return sprintf(buf,"%d\n",
572 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
574 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
577 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
578 int nr = sensor_attr->index;
580 struct it87_data *data = it87_update_device(dev);
581 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
583 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
586 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
587 int nr = sensor_attr->index;
589 struct it87_data *data = it87_update_device(dev);
590 return sprintf(buf, "%d\n", pwm_mode(data, nr));
592 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
595 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
596 int nr = sensor_attr->index;
598 struct it87_data *data = it87_update_device(dev);
599 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm_duty[nr]));
601 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
604 struct it87_data *data = it87_update_device(dev);
605 int index = (data->fan_ctl >> 4) & 0x07;
607 return sprintf(buf, "%u\n", pwm_freq[index]);
609 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
610 const char *buf, size_t count)
612 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
613 int nr = sensor_attr->index;
615 struct it87_data *data = dev_get_drvdata(dev);
616 int val = simple_strtol(buf, NULL, 10);
619 mutex_lock(&data->update_lock);
620 reg = it87_read_value(data, IT87_REG_FAN_DIV);
622 case 0: data->fan_div[nr] = reg & 0x07; break;
623 case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
624 case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break;
627 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
628 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
629 mutex_unlock(&data->update_lock);
632 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
633 const char *buf, size_t count)
635 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
636 int nr = sensor_attr->index;
638 struct it87_data *data = dev_get_drvdata(dev);
639 unsigned long val = simple_strtoul(buf, NULL, 10);
643 mutex_lock(&data->update_lock);
644 old = it87_read_value(data, IT87_REG_FAN_DIV);
646 /* Save fan min limit */
647 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
652 data->fan_div[nr] = DIV_TO_REG(val);
656 data->fan_div[nr] = 1;
658 data->fan_div[nr] = 3;
661 val |= (data->fan_div[0] & 0x07);
662 val |= (data->fan_div[1] & 0x07) << 3;
663 if (data->fan_div[2] == 3)
665 it87_write_value(data, IT87_REG_FAN_DIV, val);
667 /* Restore fan min limit */
668 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
669 it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
671 mutex_unlock(&data->update_lock);
674 static ssize_t set_pwm_enable(struct device *dev,
675 struct device_attribute *attr, const char *buf, size_t count)
677 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
678 int nr = sensor_attr->index;
680 struct it87_data *data = dev_get_drvdata(dev);
681 int val = simple_strtol(buf, NULL, 10);
683 if (val < 0 || val > 2)
686 mutex_lock(&data->update_lock);
690 /* make sure the fan is on when in on/off mode */
691 tmp = it87_read_value(data, IT87_REG_FAN_CTL);
692 it87_write_value(data, IT87_REG_FAN_CTL, tmp | (1 << nr));
693 /* set on/off mode */
694 data->fan_main_ctrl &= ~(1 << nr);
695 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
697 if (val == 1) /* Manual mode */
698 data->pwm_ctrl[nr] = data->pwm_duty[nr];
699 else /* Automatic mode */
700 data->pwm_ctrl[nr] = 0x80 | data->pwm_temp_map[nr];
701 it87_write_value(data, IT87_REG_PWM(nr), data->pwm_ctrl[nr]);
702 /* set SmartGuardian mode */
703 data->fan_main_ctrl |= (1 << nr);
704 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
707 mutex_unlock(&data->update_lock);
710 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
711 const char *buf, size_t count)
713 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
714 int nr = sensor_attr->index;
716 struct it87_data *data = dev_get_drvdata(dev);
717 int val = simple_strtol(buf, NULL, 10);
719 if (val < 0 || val > 255)
722 mutex_lock(&data->update_lock);
723 data->pwm_duty[nr] = PWM_TO_REG(val);
724 /* If we are in manual mode, write the duty cycle immediately;
725 * otherwise, just store it for later use. */
726 if (!(data->pwm_ctrl[nr] & 0x80)) {
727 data->pwm_ctrl[nr] = data->pwm_duty[nr];
728 it87_write_value(data, IT87_REG_PWM(nr), data->pwm_ctrl[nr]);
730 mutex_unlock(&data->update_lock);
733 static ssize_t set_pwm_freq(struct device *dev,
734 struct device_attribute *attr, const char *buf, size_t count)
736 struct it87_data *data = dev_get_drvdata(dev);
737 unsigned long val = simple_strtoul(buf, NULL, 10);
740 /* Search for the nearest available frequency */
741 for (i = 0; i < 7; i++) {
742 if (val > (pwm_freq[i] + pwm_freq[i+1]) / 2)
746 mutex_lock(&data->update_lock);
747 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL) & 0x8f;
748 data->fan_ctl |= i << 4;
749 it87_write_value(data, IT87_REG_FAN_CTL, data->fan_ctl);
750 mutex_unlock(&data->update_lock);
754 static ssize_t show_pwm_temp_map(struct device *dev,
755 struct device_attribute *attr, char *buf)
757 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
758 int nr = sensor_attr->index;
760 struct it87_data *data = it87_update_device(dev);
763 if (data->pwm_temp_map[nr] < 3)
764 map = 1 << data->pwm_temp_map[nr];
766 map = 0; /* Should never happen */
767 return sprintf(buf, "%d\n", map);
769 static ssize_t set_pwm_temp_map(struct device *dev,
770 struct device_attribute *attr, const char *buf, size_t count)
772 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
773 int nr = sensor_attr->index;
775 struct it87_data *data = dev_get_drvdata(dev);
779 if (strict_strtol(buf, 10, &val) < 0)
796 mutex_lock(&data->update_lock);
797 data->pwm_temp_map[nr] = reg;
798 /* If we are in automatic mode, write the temp mapping immediately;
799 * otherwise, just store it for later use. */
800 if (data->pwm_ctrl[nr] & 0x80) {
801 data->pwm_ctrl[nr] = 0x80 | data->pwm_temp_map[nr];
802 it87_write_value(data, IT87_REG_PWM(nr), data->pwm_ctrl[nr]);
804 mutex_unlock(&data->update_lock);
808 #define show_fan_offset(offset) \
809 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
810 show_fan, NULL, offset - 1); \
811 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
812 show_fan_min, set_fan_min, offset - 1); \
813 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
814 show_fan_div, set_fan_div, offset - 1);
820 #define show_pwm_offset(offset) \
821 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
822 show_pwm_enable, set_pwm_enable, offset - 1); \
823 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
824 show_pwm, set_pwm, offset - 1); \
825 static DEVICE_ATTR(pwm##offset##_freq, \
826 (offset == 1 ? S_IRUGO | S_IWUSR : S_IRUGO), \
827 show_pwm_freq, (offset == 1 ? set_pwm_freq : NULL)); \
828 static SENSOR_DEVICE_ATTR(pwm##offset##_auto_channels_temp, \
829 S_IRUGO, show_pwm_temp_map, set_pwm_temp_map, \
836 /* A different set of callbacks for 16-bit fans */
837 static ssize_t show_fan16(struct device *dev, struct device_attribute *attr,
840 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
841 int nr = sensor_attr->index;
842 struct it87_data *data = it87_update_device(dev);
843 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan[nr]));
846 static ssize_t show_fan16_min(struct device *dev, struct device_attribute *attr,
849 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
850 int nr = sensor_attr->index;
851 struct it87_data *data = it87_update_device(dev);
852 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan_min[nr]));
855 static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr,
856 const char *buf, size_t count)
858 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
859 int nr = sensor_attr->index;
860 struct it87_data *data = dev_get_drvdata(dev);
861 int val = simple_strtol(buf, NULL, 10);
863 mutex_lock(&data->update_lock);
864 data->fan_min[nr] = FAN16_TO_REG(val);
865 it87_write_value(data, IT87_REG_FAN_MIN[nr],
866 data->fan_min[nr] & 0xff);
867 it87_write_value(data, IT87_REG_FANX_MIN[nr],
868 data->fan_min[nr] >> 8);
869 mutex_unlock(&data->update_lock);
873 /* We want to use the same sysfs file names as 8-bit fans, but we need
874 different variable names, so we have to use SENSOR_ATTR instead of
875 SENSOR_DEVICE_ATTR. */
876 #define show_fan16_offset(offset) \
877 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \
878 = SENSOR_ATTR(fan##offset##_input, S_IRUGO, \
879 show_fan16, NULL, offset - 1); \
880 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \
881 = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
882 show_fan16_min, set_fan16_min, offset - 1)
884 show_fan16_offset(1);
885 show_fan16_offset(2);
886 show_fan16_offset(3);
887 show_fan16_offset(4);
888 show_fan16_offset(5);
891 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
893 struct it87_data *data = it87_update_device(dev);
894 return sprintf(buf, "%u\n", data->alarms);
896 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
898 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
901 int bitnr = to_sensor_dev_attr(attr)->index;
902 struct it87_data *data = it87_update_device(dev);
903 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
905 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8);
906 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9);
907 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10);
908 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11);
909 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12);
910 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13);
911 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14);
912 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15);
913 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
914 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1);
915 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 2);
916 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 3);
917 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 6);
918 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 16);
919 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 17);
920 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 18);
923 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
925 struct it87_data *data = dev_get_drvdata(dev);
926 return sprintf(buf, "%u\n", data->vrm);
929 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
931 struct it87_data *data = dev_get_drvdata(dev);
934 val = simple_strtoul(buf, NULL, 10);
939 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
942 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
944 struct it87_data *data = it87_update_device(dev);
945 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
947 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
949 static ssize_t show_name(struct device *dev, struct device_attribute
952 struct it87_data *data = dev_get_drvdata(dev);
953 return sprintf(buf, "%s\n", data->name);
955 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
957 static struct attribute *it87_attributes[] = {
958 &sensor_dev_attr_in0_input.dev_attr.attr,
959 &sensor_dev_attr_in1_input.dev_attr.attr,
960 &sensor_dev_attr_in2_input.dev_attr.attr,
961 &sensor_dev_attr_in3_input.dev_attr.attr,
962 &sensor_dev_attr_in4_input.dev_attr.attr,
963 &sensor_dev_attr_in5_input.dev_attr.attr,
964 &sensor_dev_attr_in6_input.dev_attr.attr,
965 &sensor_dev_attr_in7_input.dev_attr.attr,
966 &sensor_dev_attr_in8_input.dev_attr.attr,
967 &sensor_dev_attr_in0_min.dev_attr.attr,
968 &sensor_dev_attr_in1_min.dev_attr.attr,
969 &sensor_dev_attr_in2_min.dev_attr.attr,
970 &sensor_dev_attr_in3_min.dev_attr.attr,
971 &sensor_dev_attr_in4_min.dev_attr.attr,
972 &sensor_dev_attr_in5_min.dev_attr.attr,
973 &sensor_dev_attr_in6_min.dev_attr.attr,
974 &sensor_dev_attr_in7_min.dev_attr.attr,
975 &sensor_dev_attr_in0_max.dev_attr.attr,
976 &sensor_dev_attr_in1_max.dev_attr.attr,
977 &sensor_dev_attr_in2_max.dev_attr.attr,
978 &sensor_dev_attr_in3_max.dev_attr.attr,
979 &sensor_dev_attr_in4_max.dev_attr.attr,
980 &sensor_dev_attr_in5_max.dev_attr.attr,
981 &sensor_dev_attr_in6_max.dev_attr.attr,
982 &sensor_dev_attr_in7_max.dev_attr.attr,
983 &sensor_dev_attr_in0_alarm.dev_attr.attr,
984 &sensor_dev_attr_in1_alarm.dev_attr.attr,
985 &sensor_dev_attr_in2_alarm.dev_attr.attr,
986 &sensor_dev_attr_in3_alarm.dev_attr.attr,
987 &sensor_dev_attr_in4_alarm.dev_attr.attr,
988 &sensor_dev_attr_in5_alarm.dev_attr.attr,
989 &sensor_dev_attr_in6_alarm.dev_attr.attr,
990 &sensor_dev_attr_in7_alarm.dev_attr.attr,
992 &sensor_dev_attr_temp1_input.dev_attr.attr,
993 &sensor_dev_attr_temp2_input.dev_attr.attr,
994 &sensor_dev_attr_temp3_input.dev_attr.attr,
995 &sensor_dev_attr_temp1_max.dev_attr.attr,
996 &sensor_dev_attr_temp2_max.dev_attr.attr,
997 &sensor_dev_attr_temp3_max.dev_attr.attr,
998 &sensor_dev_attr_temp1_min.dev_attr.attr,
999 &sensor_dev_attr_temp2_min.dev_attr.attr,
1000 &sensor_dev_attr_temp3_min.dev_attr.attr,
1001 &sensor_dev_attr_temp1_type.dev_attr.attr,
1002 &sensor_dev_attr_temp2_type.dev_attr.attr,
1003 &sensor_dev_attr_temp3_type.dev_attr.attr,
1004 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1005 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1006 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1008 &dev_attr_alarms.attr,
1009 &dev_attr_name.attr,
1013 static const struct attribute_group it87_group = {
1014 .attrs = it87_attributes,
1017 static struct attribute *it87_attributes_opt[] = {
1018 &sensor_dev_attr_fan1_input16.dev_attr.attr,
1019 &sensor_dev_attr_fan1_min16.dev_attr.attr,
1020 &sensor_dev_attr_fan2_input16.dev_attr.attr,
1021 &sensor_dev_attr_fan2_min16.dev_attr.attr,
1022 &sensor_dev_attr_fan3_input16.dev_attr.attr,
1023 &sensor_dev_attr_fan3_min16.dev_attr.attr,
1024 &sensor_dev_attr_fan4_input16.dev_attr.attr,
1025 &sensor_dev_attr_fan4_min16.dev_attr.attr,
1026 &sensor_dev_attr_fan5_input16.dev_attr.attr,
1027 &sensor_dev_attr_fan5_min16.dev_attr.attr,
1029 &sensor_dev_attr_fan1_input.dev_attr.attr,
1030 &sensor_dev_attr_fan1_min.dev_attr.attr,
1031 &sensor_dev_attr_fan1_div.dev_attr.attr,
1032 &sensor_dev_attr_fan2_input.dev_attr.attr,
1033 &sensor_dev_attr_fan2_min.dev_attr.attr,
1034 &sensor_dev_attr_fan2_div.dev_attr.attr,
1035 &sensor_dev_attr_fan3_input.dev_attr.attr,
1036 &sensor_dev_attr_fan3_min.dev_attr.attr,
1037 &sensor_dev_attr_fan3_div.dev_attr.attr,
1039 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1040 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1041 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1042 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1043 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1045 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1046 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1047 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1048 &sensor_dev_attr_pwm1.dev_attr.attr,
1049 &sensor_dev_attr_pwm2.dev_attr.attr,
1050 &sensor_dev_attr_pwm3.dev_attr.attr,
1051 &dev_attr_pwm1_freq.attr,
1052 &dev_attr_pwm2_freq.attr,
1053 &dev_attr_pwm3_freq.attr,
1054 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1055 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1056 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1059 &dev_attr_cpu0_vid.attr,
1063 static const struct attribute_group it87_group_opt = {
1064 .attrs = it87_attributes_opt,
1067 /* SuperIO detection - will change isa_address if a chip is found */
1068 static int __init it87_find(unsigned short *address,
1069 struct it87_sio_data *sio_data)
1073 const char *board_vendor, *board_name;
1076 chip_type = force_id ? force_id : superio_inw(DEVID);
1078 switch (chip_type) {
1080 sio_data->type = it87;
1083 sio_data->type = it8712;
1087 sio_data->type = it8716;
1090 sio_data->type = it8718;
1093 sio_data->type = it8720;
1095 case 0xffff: /* No device at all */
1098 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
1103 superio_select(PME);
1104 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
1105 pr_info("it87: Device not activated, skipping\n");
1109 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
1110 if (*address == 0) {
1111 pr_info("it87: Base address not set, skipping\n");
1116 sio_data->revision = superio_inb(DEVREV) & 0x0f;
1117 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
1118 chip_type, *address, sio_data->revision);
1120 /* Read GPIO config and VID value from LDN 7 (GPIO) */
1121 if (sio_data->type == it87) {
1122 /* The IT8705F doesn't have VID pins at all */
1123 sio_data->skip_vid = 1;
1127 superio_select(GPIO);
1128 /* We need at least 4 VID pins */
1129 reg = superio_inb(IT87_SIO_GPIO3_REG);
1131 pr_info("it87: VID is disabled (pins used for GPIO)\n");
1132 sio_data->skip_vid = 1;
1135 /* Check if fan3 is there or not */
1137 sio_data->skip_pwm |= (1 << 2);
1139 sio_data->skip_fan |= (1 << 2);
1141 /* Check if fan2 is there or not */
1142 reg = superio_inb(IT87_SIO_GPIO5_REG);
1144 sio_data->skip_pwm |= (1 << 1);
1146 sio_data->skip_fan |= (1 << 1);
1148 if ((sio_data->type == it8718 || sio_data->type == it8720)
1149 && !(sio_data->skip_vid))
1150 sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
1152 reg = superio_inb(IT87_SIO_PINX2_REG);
1154 pr_info("it87: in3 is VCC (+5V)\n");
1156 pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
1159 /* Disable specific features based on DMI strings */
1160 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1161 board_name = dmi_get_system_info(DMI_BOARD_NAME);
1162 if (board_vendor && board_name) {
1163 if (strcmp(board_vendor, "nVIDIA") == 0
1164 && strcmp(board_name, "FN68PT") == 0) {
1165 /* On the Shuttle SN68PT, FAN_CTL2 is apparently not
1166 connected to a fan, but to something else. One user
1167 has reported instant system power-off when changing
1168 the PWM2 duty cycle, so we disable it.
1169 I use the board name string as the trigger in case
1170 the same board is ever used in other systems. */
1171 pr_info("it87: Disabling pwm2 due to "
1172 "hardware constraints\n");
1173 sio_data->skip_pwm = (1 << 1);
1182 static int __devinit it87_probe(struct platform_device *pdev)
1184 struct it87_data *data;
1185 struct resource *res;
1186 struct device *dev = &pdev->dev;
1187 struct it87_sio_data *sio_data = dev->platform_data;
1189 int enable_pwm_interface;
1190 static const char *names[] = {
1198 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1199 if (!request_region(res->start, IT87_EC_EXTENT, DRVNAME)) {
1200 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1201 (unsigned long)res->start,
1202 (unsigned long)(res->start + IT87_EC_EXTENT - 1));
1207 if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
1212 data->addr = res->start;
1213 data->type = sio_data->type;
1214 data->revision = sio_data->revision;
1215 data->name = names[sio_data->type];
1217 /* Now, we do the remaining detection. */
1218 if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80)
1219 || it87_read_value(data, IT87_REG_CHIPID) != 0x90) {
1224 platform_set_drvdata(pdev, data);
1226 mutex_init(&data->update_lock);
1228 /* Check PWM configuration */
1229 enable_pwm_interface = it87_check_pwm(dev);
1231 /* Initialize the IT87 chip */
1232 it87_init_device(pdev);
1234 /* Register sysfs hooks */
1235 if ((err = sysfs_create_group(&dev->kobj, &it87_group)))
1238 /* Do not create fan files for disabled fans */
1239 if (has_16bit_fans(data)) {
1240 /* 16-bit tachometers */
1241 if (data->has_fan & (1 << 0)) {
1242 if ((err = device_create_file(dev,
1243 &sensor_dev_attr_fan1_input16.dev_attr))
1244 || (err = device_create_file(dev,
1245 &sensor_dev_attr_fan1_min16.dev_attr))
1246 || (err = device_create_file(dev,
1247 &sensor_dev_attr_fan1_alarm.dev_attr)))
1250 if (data->has_fan & (1 << 1)) {
1251 if ((err = device_create_file(dev,
1252 &sensor_dev_attr_fan2_input16.dev_attr))
1253 || (err = device_create_file(dev,
1254 &sensor_dev_attr_fan2_min16.dev_attr))
1255 || (err = device_create_file(dev,
1256 &sensor_dev_attr_fan2_alarm.dev_attr)))
1259 if (data->has_fan & (1 << 2)) {
1260 if ((err = device_create_file(dev,
1261 &sensor_dev_attr_fan3_input16.dev_attr))
1262 || (err = device_create_file(dev,
1263 &sensor_dev_attr_fan3_min16.dev_attr))
1264 || (err = device_create_file(dev,
1265 &sensor_dev_attr_fan3_alarm.dev_attr)))
1268 if (data->has_fan & (1 << 3)) {
1269 if ((err = device_create_file(dev,
1270 &sensor_dev_attr_fan4_input16.dev_attr))
1271 || (err = device_create_file(dev,
1272 &sensor_dev_attr_fan4_min16.dev_attr))
1273 || (err = device_create_file(dev,
1274 &sensor_dev_attr_fan4_alarm.dev_attr)))
1277 if (data->has_fan & (1 << 4)) {
1278 if ((err = device_create_file(dev,
1279 &sensor_dev_attr_fan5_input16.dev_attr))
1280 || (err = device_create_file(dev,
1281 &sensor_dev_attr_fan5_min16.dev_attr))
1282 || (err = device_create_file(dev,
1283 &sensor_dev_attr_fan5_alarm.dev_attr)))
1287 /* 8-bit tachometers with clock divider */
1288 if (data->has_fan & (1 << 0)) {
1289 if ((err = device_create_file(dev,
1290 &sensor_dev_attr_fan1_input.dev_attr))
1291 || (err = device_create_file(dev,
1292 &sensor_dev_attr_fan1_min.dev_attr))
1293 || (err = device_create_file(dev,
1294 &sensor_dev_attr_fan1_div.dev_attr))
1295 || (err = device_create_file(dev,
1296 &sensor_dev_attr_fan1_alarm.dev_attr)))
1299 if (data->has_fan & (1 << 1)) {
1300 if ((err = device_create_file(dev,
1301 &sensor_dev_attr_fan2_input.dev_attr))
1302 || (err = device_create_file(dev,
1303 &sensor_dev_attr_fan2_min.dev_attr))
1304 || (err = device_create_file(dev,
1305 &sensor_dev_attr_fan2_div.dev_attr))
1306 || (err = device_create_file(dev,
1307 &sensor_dev_attr_fan2_alarm.dev_attr)))
1310 if (data->has_fan & (1 << 2)) {
1311 if ((err = device_create_file(dev,
1312 &sensor_dev_attr_fan3_input.dev_attr))
1313 || (err = device_create_file(dev,
1314 &sensor_dev_attr_fan3_min.dev_attr))
1315 || (err = device_create_file(dev,
1316 &sensor_dev_attr_fan3_div.dev_attr))
1317 || (err = device_create_file(dev,
1318 &sensor_dev_attr_fan3_alarm.dev_attr)))
1323 if (enable_pwm_interface) {
1324 if (!(sio_data->skip_pwm & (1 << 0))) {
1325 if ((err = device_create_file(dev,
1326 &sensor_dev_attr_pwm1_enable.dev_attr))
1327 || (err = device_create_file(dev,
1328 &sensor_dev_attr_pwm1.dev_attr))
1329 || (err = device_create_file(dev,
1330 &dev_attr_pwm1_freq))
1331 || (err = device_create_file(dev,
1332 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr)))
1335 if (!(sio_data->skip_pwm & (1 << 1))) {
1336 if ((err = device_create_file(dev,
1337 &sensor_dev_attr_pwm2_enable.dev_attr))
1338 || (err = device_create_file(dev,
1339 &sensor_dev_attr_pwm2.dev_attr))
1340 || (err = device_create_file(dev,
1341 &dev_attr_pwm2_freq))
1342 || (err = device_create_file(dev,
1343 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr)))
1346 if (!(sio_data->skip_pwm & (1 << 2))) {
1347 if ((err = device_create_file(dev,
1348 &sensor_dev_attr_pwm3_enable.dev_attr))
1349 || (err = device_create_file(dev,
1350 &sensor_dev_attr_pwm3.dev_attr))
1351 || (err = device_create_file(dev,
1352 &dev_attr_pwm3_freq))
1353 || (err = device_create_file(dev,
1354 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr)))
1359 if (!sio_data->skip_vid) {
1360 data->vrm = vid_which_vrm();
1361 /* VID reading from Super-I/O config space if available */
1362 data->vid = sio_data->vid_value;
1363 if ((err = device_create_file(dev,
1365 || (err = device_create_file(dev,
1366 &dev_attr_cpu0_vid)))
1370 data->hwmon_dev = hwmon_device_register(dev);
1371 if (IS_ERR(data->hwmon_dev)) {
1372 err = PTR_ERR(data->hwmon_dev);
1379 sysfs_remove_group(&dev->kobj, &it87_group);
1380 sysfs_remove_group(&dev->kobj, &it87_group_opt);
1382 platform_set_drvdata(pdev, NULL);
1385 release_region(res->start, IT87_EC_EXTENT);
1390 static int __devexit it87_remove(struct platform_device *pdev)
1392 struct it87_data *data = platform_get_drvdata(pdev);
1394 hwmon_device_unregister(data->hwmon_dev);
1395 sysfs_remove_group(&pdev->dev.kobj, &it87_group);
1396 sysfs_remove_group(&pdev->dev.kobj, &it87_group_opt);
1398 release_region(data->addr, IT87_EC_EXTENT);
1399 platform_set_drvdata(pdev, NULL);
1405 /* Must be called with data->update_lock held, except during initialization.
1406 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1407 would slow down the IT87 access and should not be necessary. */
1408 static int it87_read_value(struct it87_data *data, u8 reg)
1410 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1411 return inb_p(data->addr + IT87_DATA_REG_OFFSET);
1414 /* Must be called with data->update_lock held, except during initialization.
1415 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1416 would slow down the IT87 access and should not be necessary. */
1417 static void it87_write_value(struct it87_data *data, u8 reg, u8 value)
1419 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1420 outb_p(value, data->addr + IT87_DATA_REG_OFFSET);
1423 /* Return 1 if and only if the PWM interface is safe to use */
1424 static int __devinit it87_check_pwm(struct device *dev)
1426 struct it87_data *data = dev_get_drvdata(dev);
1427 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
1428 * and polarity set to active low is sign that this is the case so we
1429 * disable pwm control to protect the user. */
1430 int tmp = it87_read_value(data, IT87_REG_FAN_CTL);
1431 if ((tmp & 0x87) == 0) {
1432 if (fix_pwm_polarity) {
1433 /* The user asks us to attempt a chip reconfiguration.
1434 * This means switching to active high polarity and
1435 * inverting all fan speed values. */
1439 for (i = 0; i < 3; i++)
1440 pwm[i] = it87_read_value(data,
1443 /* If any fan is in automatic pwm mode, the polarity
1444 * might be correct, as suspicious as it seems, so we
1445 * better don't change anything (but still disable the
1446 * PWM interface). */
1447 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1448 dev_info(dev, "Reconfiguring PWM to "
1449 "active high polarity\n");
1450 it87_write_value(data, IT87_REG_FAN_CTL,
1452 for (i = 0; i < 3; i++)
1453 it87_write_value(data,
1459 dev_info(dev, "PWM configuration is "
1460 "too broken to be fixed\n");
1463 dev_info(dev, "Detected broken BIOS "
1464 "defaults, disabling PWM interface\n");
1466 } else if (fix_pwm_polarity) {
1467 dev_info(dev, "PWM configuration looks "
1468 "sane, won't touch\n");
1474 /* Called when we have found a new IT87. */
1475 static void __devinit it87_init_device(struct platform_device *pdev)
1477 struct it87_sio_data *sio_data = pdev->dev.platform_data;
1478 struct it87_data *data = platform_get_drvdata(pdev);
1482 /* For each PWM channel:
1483 * - If it is in automatic mode, setting to manual mode should set
1484 * the fan to full speed by default.
1485 * - If it is in manual mode, we need a mapping to temperature
1486 * channels to use when later setting to automatic mode later.
1487 * Use a 1:1 mapping by default (we are clueless.)
1488 * In both cases, the value can (and should) be changed by the user
1489 * prior to switching to a different mode. */
1490 for (i = 0; i < 3; i++) {
1491 data->pwm_temp_map[i] = i;
1492 data->pwm_duty[i] = 0x7f; /* Full speed */
1495 /* Some chips seem to have default value 0xff for all limit
1496 * registers. For low voltage limits it makes no sense and triggers
1497 * alarms, so change to 0 instead. For high temperature limits, it
1498 * means -1 degree C, which surprisingly doesn't trigger an alarm,
1499 * but is still confusing, so change to 127 degrees C. */
1500 for (i = 0; i < 8; i++) {
1501 tmp = it87_read_value(data, IT87_REG_VIN_MIN(i));
1503 it87_write_value(data, IT87_REG_VIN_MIN(i), 0);
1505 for (i = 0; i < 3; i++) {
1506 tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1508 it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127);
1511 /* Check if temperature channels are reset manually or by some reason */
1512 tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1513 if ((tmp & 0x3f) == 0) {
1514 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1515 tmp = (tmp & 0xc0) | 0x2a;
1516 it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp);
1520 /* Check if voltage monitors are reset manually or by some reason */
1521 tmp = it87_read_value(data, IT87_REG_VIN_ENABLE);
1522 if ((tmp & 0xff) == 0) {
1523 /* Enable all voltage monitors */
1524 it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff);
1527 /* Check if tachometers are reset manually or by some reason */
1528 mask = 0x70 & ~(sio_data->skip_fan << 4);
1529 data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
1530 if ((data->fan_main_ctrl & mask) == 0) {
1531 /* Enable all fan tachometers */
1532 data->fan_main_ctrl |= mask;
1533 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1535 data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
1537 /* Set tachometers to 16-bit mode if needed */
1538 if (has_16bit_fans(data)) {
1539 tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
1540 if (~tmp & 0x07 & data->has_fan) {
1542 "Setting fan1-3 to 16-bit mode\n");
1543 it87_write_value(data, IT87_REG_FAN_16BIT,
1546 /* IT8705F only supports three fans. */
1547 if (data->type != it87) {
1549 data->has_fan |= (1 << 3); /* fan4 enabled */
1551 data->has_fan |= (1 << 4); /* fan5 enabled */
1555 /* Fan input pins may be used for alternative functions */
1556 data->has_fan &= ~sio_data->skip_fan;
1558 /* Start monitoring */
1559 it87_write_value(data, IT87_REG_CONFIG,
1560 (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
1561 | (update_vbat ? 0x41 : 0x01));
1564 static void it87_update_pwm_ctrl(struct it87_data *data, int nr)
1566 data->pwm_ctrl[nr] = it87_read_value(data, IT87_REG_PWM(nr));
1567 if (data->pwm_ctrl[nr] & 0x80) /* Automatic mode */
1568 data->pwm_temp_map[nr] = data->pwm_ctrl[nr] & 0x03;
1569 else /* Manual mode */
1570 data->pwm_duty[nr] = data->pwm_ctrl[nr] & 0x7f;
1573 static struct it87_data *it87_update_device(struct device *dev)
1575 struct it87_data *data = dev_get_drvdata(dev);
1578 mutex_lock(&data->update_lock);
1580 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1584 /* Cleared after each update, so reenable. Value
1585 returned by this read will be previous value */
1586 it87_write_value(data, IT87_REG_CONFIG,
1587 it87_read_value(data, IT87_REG_CONFIG) | 0x40);
1589 for (i = 0; i <= 7; i++) {
1591 it87_read_value(data, IT87_REG_VIN(i));
1593 it87_read_value(data, IT87_REG_VIN_MIN(i));
1595 it87_read_value(data, IT87_REG_VIN_MAX(i));
1597 /* in8 (battery) has no limit registers */
1599 it87_read_value(data, IT87_REG_VIN(8));
1601 for (i = 0; i < 5; i++) {
1602 /* Skip disabled fans */
1603 if (!(data->has_fan & (1 << i)))
1607 it87_read_value(data, IT87_REG_FAN_MIN[i]);
1608 data->fan[i] = it87_read_value(data,
1610 /* Add high byte if in 16-bit mode */
1611 if (has_16bit_fans(data)) {
1612 data->fan[i] |= it87_read_value(data,
1613 IT87_REG_FANX[i]) << 8;
1614 data->fan_min[i] |= it87_read_value(data,
1615 IT87_REG_FANX_MIN[i]) << 8;
1618 for (i = 0; i < 3; i++) {
1620 it87_read_value(data, IT87_REG_TEMP(i));
1621 data->temp_high[i] =
1622 it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1624 it87_read_value(data, IT87_REG_TEMP_LOW(i));
1627 /* Newer chips don't have clock dividers */
1628 if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
1629 i = it87_read_value(data, IT87_REG_FAN_DIV);
1630 data->fan_div[0] = i & 0x07;
1631 data->fan_div[1] = (i >> 3) & 0x07;
1632 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1636 it87_read_value(data, IT87_REG_ALARM1) |
1637 (it87_read_value(data, IT87_REG_ALARM2) << 8) |
1638 (it87_read_value(data, IT87_REG_ALARM3) << 16);
1640 data->fan_main_ctrl = it87_read_value(data,
1641 IT87_REG_FAN_MAIN_CTRL);
1642 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
1643 for (i = 0; i < 3; i++)
1644 it87_update_pwm_ctrl(data, i);
1646 data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1647 /* The 8705 does not have VID capability.
1648 The 8718 and the 8720 don't use IT87_REG_VID for the
1650 if (data->type == it8712 || data->type == it8716) {
1651 data->vid = it87_read_value(data, IT87_REG_VID);
1652 /* The older IT8712F revisions had only 5 VID pins,
1653 but we assume it is always safe to read 6 bits. */
1656 data->last_updated = jiffies;
1660 mutex_unlock(&data->update_lock);
1665 static int __init it87_device_add(unsigned short address,
1666 const struct it87_sio_data *sio_data)
1668 struct resource res = {
1669 .start = address + IT87_EC_OFFSET,
1670 .end = address + IT87_EC_OFFSET + IT87_EC_EXTENT - 1,
1672 .flags = IORESOURCE_IO,
1676 err = acpi_check_resource_conflict(&res);
1680 pdev = platform_device_alloc(DRVNAME, address);
1683 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1687 err = platform_device_add_resources(pdev, &res, 1);
1689 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1691 goto exit_device_put;
1694 err = platform_device_add_data(pdev, sio_data,
1695 sizeof(struct it87_sio_data));
1697 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1698 goto exit_device_put;
1701 err = platform_device_add(pdev);
1703 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1705 goto exit_device_put;
1711 platform_device_put(pdev);
1716 static int __init sm_it87_init(void)
1719 unsigned short isa_address=0;
1720 struct it87_sio_data sio_data;
1722 memset(&sio_data, 0, sizeof(struct it87_sio_data));
1723 err = it87_find(&isa_address, &sio_data);
1726 err = platform_driver_register(&it87_driver);
1730 err = it87_device_add(isa_address, &sio_data);
1732 platform_driver_unregister(&it87_driver);
1739 static void __exit sm_it87_exit(void)
1741 platform_device_unregister(pdev);
1742 platform_driver_unregister(&it87_driver);
1746 MODULE_AUTHOR("Chris Gauthron, "
1747 "Jean Delvare <khali@linux-fr.org>");
1748 MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8720F/8726F, SiS950 driver");
1749 module_param(update_vbat, bool, 0);
1750 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1751 module_param(fix_pwm_polarity, bool, 0);
1752 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1753 MODULE_LICENSE("GPL");
1755 module_init(sm_it87_init);
1756 module_exit(sm_it87_exit);