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);
755 #define show_fan_offset(offset) \
756 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
757 show_fan, NULL, offset - 1); \
758 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
759 show_fan_min, set_fan_min, offset - 1); \
760 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
761 show_fan_div, set_fan_div, offset - 1);
767 #define show_pwm_offset(offset) \
768 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
769 show_pwm_enable, set_pwm_enable, offset - 1); \
770 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
771 show_pwm, set_pwm, offset - 1); \
772 static DEVICE_ATTR(pwm##offset##_freq, \
773 (offset == 1 ? S_IRUGO | S_IWUSR : S_IRUGO), \
774 show_pwm_freq, (offset == 1 ? set_pwm_freq : NULL));
780 /* A different set of callbacks for 16-bit fans */
781 static ssize_t show_fan16(struct device *dev, struct device_attribute *attr,
784 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
785 int nr = sensor_attr->index;
786 struct it87_data *data = it87_update_device(dev);
787 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan[nr]));
790 static ssize_t show_fan16_min(struct device *dev, struct device_attribute *attr,
793 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
794 int nr = sensor_attr->index;
795 struct it87_data *data = it87_update_device(dev);
796 return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan_min[nr]));
799 static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr,
800 const char *buf, size_t count)
802 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
803 int nr = sensor_attr->index;
804 struct it87_data *data = dev_get_drvdata(dev);
805 int val = simple_strtol(buf, NULL, 10);
807 mutex_lock(&data->update_lock);
808 data->fan_min[nr] = FAN16_TO_REG(val);
809 it87_write_value(data, IT87_REG_FAN_MIN[nr],
810 data->fan_min[nr] & 0xff);
811 it87_write_value(data, IT87_REG_FANX_MIN[nr],
812 data->fan_min[nr] >> 8);
813 mutex_unlock(&data->update_lock);
817 /* We want to use the same sysfs file names as 8-bit fans, but we need
818 different variable names, so we have to use SENSOR_ATTR instead of
819 SENSOR_DEVICE_ATTR. */
820 #define show_fan16_offset(offset) \
821 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \
822 = SENSOR_ATTR(fan##offset##_input, S_IRUGO, \
823 show_fan16, NULL, offset - 1); \
824 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \
825 = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
826 show_fan16_min, set_fan16_min, offset - 1)
828 show_fan16_offset(1);
829 show_fan16_offset(2);
830 show_fan16_offset(3);
831 show_fan16_offset(4);
832 show_fan16_offset(5);
835 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
837 struct it87_data *data = it87_update_device(dev);
838 return sprintf(buf, "%u\n", data->alarms);
840 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
842 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
845 int bitnr = to_sensor_dev_attr(attr)->index;
846 struct it87_data *data = it87_update_device(dev);
847 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
849 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8);
850 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9);
851 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10);
852 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11);
853 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12);
854 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13);
855 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14);
856 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15);
857 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
858 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1);
859 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 2);
860 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 3);
861 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 6);
862 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 16);
863 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 17);
864 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 18);
867 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
869 struct it87_data *data = dev_get_drvdata(dev);
870 return sprintf(buf, "%u\n", data->vrm);
873 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
875 struct it87_data *data = dev_get_drvdata(dev);
878 val = simple_strtoul(buf, NULL, 10);
883 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
886 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
888 struct it87_data *data = it87_update_device(dev);
889 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
891 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
893 static ssize_t show_name(struct device *dev, struct device_attribute
896 struct it87_data *data = dev_get_drvdata(dev);
897 return sprintf(buf, "%s\n", data->name);
899 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
901 static struct attribute *it87_attributes[] = {
902 &sensor_dev_attr_in0_input.dev_attr.attr,
903 &sensor_dev_attr_in1_input.dev_attr.attr,
904 &sensor_dev_attr_in2_input.dev_attr.attr,
905 &sensor_dev_attr_in3_input.dev_attr.attr,
906 &sensor_dev_attr_in4_input.dev_attr.attr,
907 &sensor_dev_attr_in5_input.dev_attr.attr,
908 &sensor_dev_attr_in6_input.dev_attr.attr,
909 &sensor_dev_attr_in7_input.dev_attr.attr,
910 &sensor_dev_attr_in8_input.dev_attr.attr,
911 &sensor_dev_attr_in0_min.dev_attr.attr,
912 &sensor_dev_attr_in1_min.dev_attr.attr,
913 &sensor_dev_attr_in2_min.dev_attr.attr,
914 &sensor_dev_attr_in3_min.dev_attr.attr,
915 &sensor_dev_attr_in4_min.dev_attr.attr,
916 &sensor_dev_attr_in5_min.dev_attr.attr,
917 &sensor_dev_attr_in6_min.dev_attr.attr,
918 &sensor_dev_attr_in7_min.dev_attr.attr,
919 &sensor_dev_attr_in0_max.dev_attr.attr,
920 &sensor_dev_attr_in1_max.dev_attr.attr,
921 &sensor_dev_attr_in2_max.dev_attr.attr,
922 &sensor_dev_attr_in3_max.dev_attr.attr,
923 &sensor_dev_attr_in4_max.dev_attr.attr,
924 &sensor_dev_attr_in5_max.dev_attr.attr,
925 &sensor_dev_attr_in6_max.dev_attr.attr,
926 &sensor_dev_attr_in7_max.dev_attr.attr,
927 &sensor_dev_attr_in0_alarm.dev_attr.attr,
928 &sensor_dev_attr_in1_alarm.dev_attr.attr,
929 &sensor_dev_attr_in2_alarm.dev_attr.attr,
930 &sensor_dev_attr_in3_alarm.dev_attr.attr,
931 &sensor_dev_attr_in4_alarm.dev_attr.attr,
932 &sensor_dev_attr_in5_alarm.dev_attr.attr,
933 &sensor_dev_attr_in6_alarm.dev_attr.attr,
934 &sensor_dev_attr_in7_alarm.dev_attr.attr,
936 &sensor_dev_attr_temp1_input.dev_attr.attr,
937 &sensor_dev_attr_temp2_input.dev_attr.attr,
938 &sensor_dev_attr_temp3_input.dev_attr.attr,
939 &sensor_dev_attr_temp1_max.dev_attr.attr,
940 &sensor_dev_attr_temp2_max.dev_attr.attr,
941 &sensor_dev_attr_temp3_max.dev_attr.attr,
942 &sensor_dev_attr_temp1_min.dev_attr.attr,
943 &sensor_dev_attr_temp2_min.dev_attr.attr,
944 &sensor_dev_attr_temp3_min.dev_attr.attr,
945 &sensor_dev_attr_temp1_type.dev_attr.attr,
946 &sensor_dev_attr_temp2_type.dev_attr.attr,
947 &sensor_dev_attr_temp3_type.dev_attr.attr,
948 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
949 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
950 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
952 &dev_attr_alarms.attr,
957 static const struct attribute_group it87_group = {
958 .attrs = it87_attributes,
961 static struct attribute *it87_attributes_opt[] = {
962 &sensor_dev_attr_fan1_input16.dev_attr.attr,
963 &sensor_dev_attr_fan1_min16.dev_attr.attr,
964 &sensor_dev_attr_fan2_input16.dev_attr.attr,
965 &sensor_dev_attr_fan2_min16.dev_attr.attr,
966 &sensor_dev_attr_fan3_input16.dev_attr.attr,
967 &sensor_dev_attr_fan3_min16.dev_attr.attr,
968 &sensor_dev_attr_fan4_input16.dev_attr.attr,
969 &sensor_dev_attr_fan4_min16.dev_attr.attr,
970 &sensor_dev_attr_fan5_input16.dev_attr.attr,
971 &sensor_dev_attr_fan5_min16.dev_attr.attr,
973 &sensor_dev_attr_fan1_input.dev_attr.attr,
974 &sensor_dev_attr_fan1_min.dev_attr.attr,
975 &sensor_dev_attr_fan1_div.dev_attr.attr,
976 &sensor_dev_attr_fan2_input.dev_attr.attr,
977 &sensor_dev_attr_fan2_min.dev_attr.attr,
978 &sensor_dev_attr_fan2_div.dev_attr.attr,
979 &sensor_dev_attr_fan3_input.dev_attr.attr,
980 &sensor_dev_attr_fan3_min.dev_attr.attr,
981 &sensor_dev_attr_fan3_div.dev_attr.attr,
983 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
984 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
985 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
986 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
987 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
989 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
990 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
991 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
992 &sensor_dev_attr_pwm1.dev_attr.attr,
993 &sensor_dev_attr_pwm2.dev_attr.attr,
994 &sensor_dev_attr_pwm3.dev_attr.attr,
995 &dev_attr_pwm1_freq.attr,
996 &dev_attr_pwm2_freq.attr,
997 &dev_attr_pwm3_freq.attr,
1000 &dev_attr_cpu0_vid.attr,
1004 static const struct attribute_group it87_group_opt = {
1005 .attrs = it87_attributes_opt,
1008 /* SuperIO detection - will change isa_address if a chip is found */
1009 static int __init it87_find(unsigned short *address,
1010 struct it87_sio_data *sio_data)
1014 const char *board_vendor, *board_name;
1017 chip_type = force_id ? force_id : superio_inw(DEVID);
1019 switch (chip_type) {
1021 sio_data->type = it87;
1024 sio_data->type = it8712;
1028 sio_data->type = it8716;
1031 sio_data->type = it8718;
1034 sio_data->type = it8720;
1036 case 0xffff: /* No device at all */
1039 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
1044 superio_select(PME);
1045 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
1046 pr_info("it87: Device not activated, skipping\n");
1050 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
1051 if (*address == 0) {
1052 pr_info("it87: Base address not set, skipping\n");
1057 sio_data->revision = superio_inb(DEVREV) & 0x0f;
1058 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
1059 chip_type, *address, sio_data->revision);
1061 /* Read GPIO config and VID value from LDN 7 (GPIO) */
1062 if (sio_data->type == it87) {
1063 /* The IT8705F doesn't have VID pins at all */
1064 sio_data->skip_vid = 1;
1068 superio_select(GPIO);
1069 /* We need at least 4 VID pins */
1070 reg = superio_inb(IT87_SIO_GPIO3_REG);
1072 pr_info("it87: VID is disabled (pins used for GPIO)\n");
1073 sio_data->skip_vid = 1;
1076 /* Check if fan3 is there or not */
1078 sio_data->skip_pwm |= (1 << 2);
1080 sio_data->skip_fan |= (1 << 2);
1082 /* Check if fan2 is there or not */
1083 reg = superio_inb(IT87_SIO_GPIO5_REG);
1085 sio_data->skip_pwm |= (1 << 1);
1087 sio_data->skip_fan |= (1 << 1);
1089 if ((sio_data->type == it8718 || sio_data->type == it8720)
1090 && !(sio_data->skip_vid))
1091 sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
1093 reg = superio_inb(IT87_SIO_PINX2_REG);
1095 pr_info("it87: in3 is VCC (+5V)\n");
1097 pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
1100 /* Disable specific features based on DMI strings */
1101 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1102 board_name = dmi_get_system_info(DMI_BOARD_NAME);
1103 if (board_vendor && board_name) {
1104 if (strcmp(board_vendor, "nVIDIA") == 0
1105 && strcmp(board_name, "FN68PT") == 0) {
1106 /* On the Shuttle SN68PT, FAN_CTL2 is apparently not
1107 connected to a fan, but to something else. One user
1108 has reported instant system power-off when changing
1109 the PWM2 duty cycle, so we disable it.
1110 I use the board name string as the trigger in case
1111 the same board is ever used in other systems. */
1112 pr_info("it87: Disabling pwm2 due to "
1113 "hardware constraints\n");
1114 sio_data->skip_pwm = (1 << 1);
1123 static int __devinit it87_probe(struct platform_device *pdev)
1125 struct it87_data *data;
1126 struct resource *res;
1127 struct device *dev = &pdev->dev;
1128 struct it87_sio_data *sio_data = dev->platform_data;
1130 int enable_pwm_interface;
1131 static const char *names[] = {
1139 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1140 if (!request_region(res->start, IT87_EC_EXTENT, DRVNAME)) {
1141 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1142 (unsigned long)res->start,
1143 (unsigned long)(res->start + IT87_EC_EXTENT - 1));
1148 if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
1153 data->addr = res->start;
1154 data->type = sio_data->type;
1155 data->revision = sio_data->revision;
1156 data->name = names[sio_data->type];
1158 /* Now, we do the remaining detection. */
1159 if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80)
1160 || it87_read_value(data, IT87_REG_CHIPID) != 0x90) {
1165 platform_set_drvdata(pdev, data);
1167 mutex_init(&data->update_lock);
1169 /* Check PWM configuration */
1170 enable_pwm_interface = it87_check_pwm(dev);
1172 /* Initialize the IT87 chip */
1173 it87_init_device(pdev);
1175 /* Register sysfs hooks */
1176 if ((err = sysfs_create_group(&dev->kobj, &it87_group)))
1179 /* Do not create fan files for disabled fans */
1180 if (has_16bit_fans(data)) {
1181 /* 16-bit tachometers */
1182 if (data->has_fan & (1 << 0)) {
1183 if ((err = device_create_file(dev,
1184 &sensor_dev_attr_fan1_input16.dev_attr))
1185 || (err = device_create_file(dev,
1186 &sensor_dev_attr_fan1_min16.dev_attr))
1187 || (err = device_create_file(dev,
1188 &sensor_dev_attr_fan1_alarm.dev_attr)))
1191 if (data->has_fan & (1 << 1)) {
1192 if ((err = device_create_file(dev,
1193 &sensor_dev_attr_fan2_input16.dev_attr))
1194 || (err = device_create_file(dev,
1195 &sensor_dev_attr_fan2_min16.dev_attr))
1196 || (err = device_create_file(dev,
1197 &sensor_dev_attr_fan2_alarm.dev_attr)))
1200 if (data->has_fan & (1 << 2)) {
1201 if ((err = device_create_file(dev,
1202 &sensor_dev_attr_fan3_input16.dev_attr))
1203 || (err = device_create_file(dev,
1204 &sensor_dev_attr_fan3_min16.dev_attr))
1205 || (err = device_create_file(dev,
1206 &sensor_dev_attr_fan3_alarm.dev_attr)))
1209 if (data->has_fan & (1 << 3)) {
1210 if ((err = device_create_file(dev,
1211 &sensor_dev_attr_fan4_input16.dev_attr))
1212 || (err = device_create_file(dev,
1213 &sensor_dev_attr_fan4_min16.dev_attr))
1214 || (err = device_create_file(dev,
1215 &sensor_dev_attr_fan4_alarm.dev_attr)))
1218 if (data->has_fan & (1 << 4)) {
1219 if ((err = device_create_file(dev,
1220 &sensor_dev_attr_fan5_input16.dev_attr))
1221 || (err = device_create_file(dev,
1222 &sensor_dev_attr_fan5_min16.dev_attr))
1223 || (err = device_create_file(dev,
1224 &sensor_dev_attr_fan5_alarm.dev_attr)))
1228 /* 8-bit tachometers with clock divider */
1229 if (data->has_fan & (1 << 0)) {
1230 if ((err = device_create_file(dev,
1231 &sensor_dev_attr_fan1_input.dev_attr))
1232 || (err = device_create_file(dev,
1233 &sensor_dev_attr_fan1_min.dev_attr))
1234 || (err = device_create_file(dev,
1235 &sensor_dev_attr_fan1_div.dev_attr))
1236 || (err = device_create_file(dev,
1237 &sensor_dev_attr_fan1_alarm.dev_attr)))
1240 if (data->has_fan & (1 << 1)) {
1241 if ((err = device_create_file(dev,
1242 &sensor_dev_attr_fan2_input.dev_attr))
1243 || (err = device_create_file(dev,
1244 &sensor_dev_attr_fan2_min.dev_attr))
1245 || (err = device_create_file(dev,
1246 &sensor_dev_attr_fan2_div.dev_attr))
1247 || (err = device_create_file(dev,
1248 &sensor_dev_attr_fan2_alarm.dev_attr)))
1251 if (data->has_fan & (1 << 2)) {
1252 if ((err = device_create_file(dev,
1253 &sensor_dev_attr_fan3_input.dev_attr))
1254 || (err = device_create_file(dev,
1255 &sensor_dev_attr_fan3_min.dev_attr))
1256 || (err = device_create_file(dev,
1257 &sensor_dev_attr_fan3_div.dev_attr))
1258 || (err = device_create_file(dev,
1259 &sensor_dev_attr_fan3_alarm.dev_attr)))
1264 if (enable_pwm_interface) {
1265 if (!(sio_data->skip_pwm & (1 << 0))) {
1266 if ((err = device_create_file(dev,
1267 &sensor_dev_attr_pwm1_enable.dev_attr))
1268 || (err = device_create_file(dev,
1269 &sensor_dev_attr_pwm1.dev_attr))
1270 || (err = device_create_file(dev,
1271 &dev_attr_pwm1_freq)))
1274 if (!(sio_data->skip_pwm & (1 << 1))) {
1275 if ((err = device_create_file(dev,
1276 &sensor_dev_attr_pwm2_enable.dev_attr))
1277 || (err = device_create_file(dev,
1278 &sensor_dev_attr_pwm2.dev_attr))
1279 || (err = device_create_file(dev,
1280 &dev_attr_pwm2_freq)))
1283 if (!(sio_data->skip_pwm & (1 << 2))) {
1284 if ((err = device_create_file(dev,
1285 &sensor_dev_attr_pwm3_enable.dev_attr))
1286 || (err = device_create_file(dev,
1287 &sensor_dev_attr_pwm3.dev_attr))
1288 || (err = device_create_file(dev,
1289 &dev_attr_pwm3_freq)))
1294 if (!sio_data->skip_vid) {
1295 data->vrm = vid_which_vrm();
1296 /* VID reading from Super-I/O config space if available */
1297 data->vid = sio_data->vid_value;
1298 if ((err = device_create_file(dev,
1300 || (err = device_create_file(dev,
1301 &dev_attr_cpu0_vid)))
1305 data->hwmon_dev = hwmon_device_register(dev);
1306 if (IS_ERR(data->hwmon_dev)) {
1307 err = PTR_ERR(data->hwmon_dev);
1314 sysfs_remove_group(&dev->kobj, &it87_group);
1315 sysfs_remove_group(&dev->kobj, &it87_group_opt);
1317 platform_set_drvdata(pdev, NULL);
1320 release_region(res->start, IT87_EC_EXTENT);
1325 static int __devexit it87_remove(struct platform_device *pdev)
1327 struct it87_data *data = platform_get_drvdata(pdev);
1329 hwmon_device_unregister(data->hwmon_dev);
1330 sysfs_remove_group(&pdev->dev.kobj, &it87_group);
1331 sysfs_remove_group(&pdev->dev.kobj, &it87_group_opt);
1333 release_region(data->addr, IT87_EC_EXTENT);
1334 platform_set_drvdata(pdev, NULL);
1340 /* Must be called with data->update_lock held, except during initialization.
1341 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1342 would slow down the IT87 access and should not be necessary. */
1343 static int it87_read_value(struct it87_data *data, u8 reg)
1345 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1346 return inb_p(data->addr + IT87_DATA_REG_OFFSET);
1349 /* Must be called with data->update_lock held, except during initialization.
1350 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1351 would slow down the IT87 access and should not be necessary. */
1352 static void it87_write_value(struct it87_data *data, u8 reg, u8 value)
1354 outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
1355 outb_p(value, data->addr + IT87_DATA_REG_OFFSET);
1358 /* Return 1 if and only if the PWM interface is safe to use */
1359 static int __devinit it87_check_pwm(struct device *dev)
1361 struct it87_data *data = dev_get_drvdata(dev);
1362 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
1363 * and polarity set to active low is sign that this is the case so we
1364 * disable pwm control to protect the user. */
1365 int tmp = it87_read_value(data, IT87_REG_FAN_CTL);
1366 if ((tmp & 0x87) == 0) {
1367 if (fix_pwm_polarity) {
1368 /* The user asks us to attempt a chip reconfiguration.
1369 * This means switching to active high polarity and
1370 * inverting all fan speed values. */
1374 for (i = 0; i < 3; i++)
1375 pwm[i] = it87_read_value(data,
1378 /* If any fan is in automatic pwm mode, the polarity
1379 * might be correct, as suspicious as it seems, so we
1380 * better don't change anything (but still disable the
1381 * PWM interface). */
1382 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1383 dev_info(dev, "Reconfiguring PWM to "
1384 "active high polarity\n");
1385 it87_write_value(data, IT87_REG_FAN_CTL,
1387 for (i = 0; i < 3; i++)
1388 it87_write_value(data,
1394 dev_info(dev, "PWM configuration is "
1395 "too broken to be fixed\n");
1398 dev_info(dev, "Detected broken BIOS "
1399 "defaults, disabling PWM interface\n");
1401 } else if (fix_pwm_polarity) {
1402 dev_info(dev, "PWM configuration looks "
1403 "sane, won't touch\n");
1409 /* Called when we have found a new IT87. */
1410 static void __devinit it87_init_device(struct platform_device *pdev)
1412 struct it87_sio_data *sio_data = pdev->dev.platform_data;
1413 struct it87_data *data = platform_get_drvdata(pdev);
1417 /* For each PWM channel:
1418 * - If it is in automatic mode, setting to manual mode should set
1419 * the fan to full speed by default.
1420 * - If it is in manual mode, we need a mapping to temperature
1421 * channels to use when later setting to automatic mode later.
1422 * Use a 1:1 mapping by default (we are clueless.)
1423 * In both cases, the value can (and should) be changed by the user
1424 * prior to switching to a different mode. */
1425 for (i = 0; i < 3; i++) {
1426 data->pwm_temp_map[i] = i;
1427 data->pwm_duty[i] = 0x7f; /* Full speed */
1430 /* Some chips seem to have default value 0xff for all limit
1431 * registers. For low voltage limits it makes no sense and triggers
1432 * alarms, so change to 0 instead. For high temperature limits, it
1433 * means -1 degree C, which surprisingly doesn't trigger an alarm,
1434 * but is still confusing, so change to 127 degrees C. */
1435 for (i = 0; i < 8; i++) {
1436 tmp = it87_read_value(data, IT87_REG_VIN_MIN(i));
1438 it87_write_value(data, IT87_REG_VIN_MIN(i), 0);
1440 for (i = 0; i < 3; i++) {
1441 tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1443 it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127);
1446 /* Check if temperature channels are reset manually or by some reason */
1447 tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1448 if ((tmp & 0x3f) == 0) {
1449 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1450 tmp = (tmp & 0xc0) | 0x2a;
1451 it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp);
1455 /* Check if voltage monitors are reset manually or by some reason */
1456 tmp = it87_read_value(data, IT87_REG_VIN_ENABLE);
1457 if ((tmp & 0xff) == 0) {
1458 /* Enable all voltage monitors */
1459 it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff);
1462 /* Check if tachometers are reset manually or by some reason */
1463 mask = 0x70 & ~(sio_data->skip_fan << 4);
1464 data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
1465 if ((data->fan_main_ctrl & mask) == 0) {
1466 /* Enable all fan tachometers */
1467 data->fan_main_ctrl |= mask;
1468 it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1470 data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
1472 /* Set tachometers to 16-bit mode if needed */
1473 if (has_16bit_fans(data)) {
1474 tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
1475 if (~tmp & 0x07 & data->has_fan) {
1477 "Setting fan1-3 to 16-bit mode\n");
1478 it87_write_value(data, IT87_REG_FAN_16BIT,
1481 /* IT8705F only supports three fans. */
1482 if (data->type != it87) {
1484 data->has_fan |= (1 << 3); /* fan4 enabled */
1486 data->has_fan |= (1 << 4); /* fan5 enabled */
1490 /* Fan input pins may be used for alternative functions */
1491 data->has_fan &= ~sio_data->skip_fan;
1493 /* Start monitoring */
1494 it87_write_value(data, IT87_REG_CONFIG,
1495 (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
1496 | (update_vbat ? 0x41 : 0x01));
1499 static void it87_update_pwm_ctrl(struct it87_data *data, int nr)
1501 data->pwm_ctrl[nr] = it87_read_value(data, IT87_REG_PWM(nr));
1502 if (data->pwm_ctrl[nr] & 0x80) /* Automatic mode */
1503 data->pwm_temp_map[nr] = data->pwm_ctrl[nr] & 0x03;
1504 else /* Manual mode */
1505 data->pwm_duty[nr] = data->pwm_ctrl[nr] & 0x7f;
1508 static struct it87_data *it87_update_device(struct device *dev)
1510 struct it87_data *data = dev_get_drvdata(dev);
1513 mutex_lock(&data->update_lock);
1515 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1519 /* Cleared after each update, so reenable. Value
1520 returned by this read will be previous value */
1521 it87_write_value(data, IT87_REG_CONFIG,
1522 it87_read_value(data, IT87_REG_CONFIG) | 0x40);
1524 for (i = 0; i <= 7; i++) {
1526 it87_read_value(data, IT87_REG_VIN(i));
1528 it87_read_value(data, IT87_REG_VIN_MIN(i));
1530 it87_read_value(data, IT87_REG_VIN_MAX(i));
1532 /* in8 (battery) has no limit registers */
1534 it87_read_value(data, IT87_REG_VIN(8));
1536 for (i = 0; i < 5; i++) {
1537 /* Skip disabled fans */
1538 if (!(data->has_fan & (1 << i)))
1542 it87_read_value(data, IT87_REG_FAN_MIN[i]);
1543 data->fan[i] = it87_read_value(data,
1545 /* Add high byte if in 16-bit mode */
1546 if (has_16bit_fans(data)) {
1547 data->fan[i] |= it87_read_value(data,
1548 IT87_REG_FANX[i]) << 8;
1549 data->fan_min[i] |= it87_read_value(data,
1550 IT87_REG_FANX_MIN[i]) << 8;
1553 for (i = 0; i < 3; i++) {
1555 it87_read_value(data, IT87_REG_TEMP(i));
1556 data->temp_high[i] =
1557 it87_read_value(data, IT87_REG_TEMP_HIGH(i));
1559 it87_read_value(data, IT87_REG_TEMP_LOW(i));
1562 /* Newer chips don't have clock dividers */
1563 if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
1564 i = it87_read_value(data, IT87_REG_FAN_DIV);
1565 data->fan_div[0] = i & 0x07;
1566 data->fan_div[1] = (i >> 3) & 0x07;
1567 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1571 it87_read_value(data, IT87_REG_ALARM1) |
1572 (it87_read_value(data, IT87_REG_ALARM2) << 8) |
1573 (it87_read_value(data, IT87_REG_ALARM3) << 16);
1575 data->fan_main_ctrl = it87_read_value(data,
1576 IT87_REG_FAN_MAIN_CTRL);
1577 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
1578 for (i = 0; i < 3; i++)
1579 it87_update_pwm_ctrl(data, i);
1581 data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
1582 /* The 8705 does not have VID capability.
1583 The 8718 and the 8720 don't use IT87_REG_VID for the
1585 if (data->type == it8712 || data->type == it8716) {
1586 data->vid = it87_read_value(data, IT87_REG_VID);
1587 /* The older IT8712F revisions had only 5 VID pins,
1588 but we assume it is always safe to read 6 bits. */
1591 data->last_updated = jiffies;
1595 mutex_unlock(&data->update_lock);
1600 static int __init it87_device_add(unsigned short address,
1601 const struct it87_sio_data *sio_data)
1603 struct resource res = {
1604 .start = address + IT87_EC_OFFSET,
1605 .end = address + IT87_EC_OFFSET + IT87_EC_EXTENT - 1,
1607 .flags = IORESOURCE_IO,
1611 err = acpi_check_resource_conflict(&res);
1615 pdev = platform_device_alloc(DRVNAME, address);
1618 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1622 err = platform_device_add_resources(pdev, &res, 1);
1624 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1626 goto exit_device_put;
1629 err = platform_device_add_data(pdev, sio_data,
1630 sizeof(struct it87_sio_data));
1632 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1633 goto exit_device_put;
1636 err = platform_device_add(pdev);
1638 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1640 goto exit_device_put;
1646 platform_device_put(pdev);
1651 static int __init sm_it87_init(void)
1654 unsigned short isa_address=0;
1655 struct it87_sio_data sio_data;
1657 memset(&sio_data, 0, sizeof(struct it87_sio_data));
1658 err = it87_find(&isa_address, &sio_data);
1661 err = platform_driver_register(&it87_driver);
1665 err = it87_device_add(isa_address, &sio_data);
1667 platform_driver_unregister(&it87_driver);
1674 static void __exit sm_it87_exit(void)
1676 platform_device_unregister(pdev);
1677 platform_driver_unregister(&it87_driver);
1681 MODULE_AUTHOR("Chris Gauthron, "
1682 "Jean Delvare <khali@linux-fr.org>");
1683 MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8720F/8726F, SiS950 driver");
1684 module_param(update_vbat, bool, 0);
1685 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1686 module_param(fix_pwm_polarity, bool, 0);
1687 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1688 MODULE_LICENSE("GPL");
1690 module_init(sm_it87_init);
1691 module_exit(sm_it87_exit);