2 it87.c - Part of lm_sensors, Linux kernel modules for hardware
5 Supports: IT8705F Super I/O chip w/LPC interface
6 IT8712F Super I/O chip w/LPC interface
7 IT8716F Super I/O chip w/LPC interface
8 IT8718F Super I/O chip w/LPC interface
9 Sis950 A clone of the IT8705F
11 Copyright (C) 2001 Chris Gauthron <chrisg@0-in.com>
12 Copyright (C) 2005-2006 Jean Delvare <khali@linux-fr.org>
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/jiffies.h>
33 #include <linux/i2c.h>
34 #include <linux/i2c-isa.h>
35 #include <linux/hwmon.h>
36 #include <linux/hwmon-sysfs.h>
37 #include <linux/hwmon-vid.h>
38 #include <linux/err.h>
39 #include <linux/mutex.h>
40 #include <linux/sysfs.h>
44 static unsigned short isa_address
;
45 enum chips
{ it87
, it8712
, it8716
, it8718
};
47 #define REG 0x2e /* The register to read/write */
48 #define DEV 0x07 /* Register: Logical device select */
49 #define VAL 0x2f /* The value to read/write */
50 #define PME 0x04 /* The device with the fan registers in it */
51 #define GPIO 0x07 /* The device with the IT8718F VID value in it */
52 #define DEVID 0x20 /* Register: Device ID */
53 #define DEVREV 0x22 /* Register: Device Revision */
62 static int superio_inw(int reg
)
73 superio_select(int ldn
)
95 /* Logical device 4 registers */
96 #define IT8712F_DEVID 0x8712
97 #define IT8705F_DEVID 0x8705
98 #define IT8716F_DEVID 0x8716
99 #define IT8718F_DEVID 0x8718
100 #define IT87_ACT_REG 0x30
101 #define IT87_BASE_REG 0x60
103 /* Logical device 7 registers (IT8712F and later) */
104 #define IT87_SIO_PINX2_REG 0x2c /* Pin selection */
105 #define IT87_SIO_VID_REG 0xfc /* VID value */
107 /* Update battery voltage after every reading if true */
108 static int update_vbat
;
110 /* Not all BIOSes properly configure the PWM registers */
111 static int fix_pwm_polarity
;
113 /* Values read from Super-I/O config space */
114 static u16 chip_type
;
117 /* Many IT87 constants specified below */
119 /* Length of ISA address segment */
120 #define IT87_EXTENT 8
122 /* Where are the ISA address/data registers relative to the base address */
123 #define IT87_ADDR_REG_OFFSET 5
124 #define IT87_DATA_REG_OFFSET 6
126 /*----- The IT87 registers -----*/
128 #define IT87_REG_CONFIG 0x00
130 #define IT87_REG_ALARM1 0x01
131 #define IT87_REG_ALARM2 0x02
132 #define IT87_REG_ALARM3 0x03
134 /* The IT8718F has the VID value in a different register, in Super-I/O
135 configuration space. */
136 #define IT87_REG_VID 0x0a
137 /* Warning: register 0x0b is used for something completely different in
138 new chips/revisions. I suspect only 16-bit tachometer mode will work
140 #define IT87_REG_FAN_DIV 0x0b
141 #define IT87_REG_FAN_16BIT 0x0c
143 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
145 #define IT87_REG_FAN(nr) (0x0d + (nr))
146 #define IT87_REG_FAN_MIN(nr) (0x10 + (nr))
147 #define IT87_REG_FANX(nr) (0x18 + (nr))
148 #define IT87_REG_FANX_MIN(nr) (0x1b + (nr))
149 #define IT87_REG_FAN_MAIN_CTRL 0x13
150 #define IT87_REG_FAN_CTL 0x14
151 #define IT87_REG_PWM(nr) (0x15 + (nr))
153 #define IT87_REG_VIN(nr) (0x20 + (nr))
154 #define IT87_REG_TEMP(nr) (0x29 + (nr))
156 #define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2)
157 #define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2)
158 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
159 #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2)
161 #define IT87_REG_VIN_ENABLE 0x50
162 #define IT87_REG_TEMP_ENABLE 0x51
164 #define IT87_REG_CHIPID 0x58
166 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
167 #define IN_FROM_REG(val) ((val) * 16)
169 static inline u8
FAN_TO_REG(long rpm
, int div
)
173 rpm
= SENSORS_LIMIT(rpm
, 1, 1000000);
174 return SENSORS_LIMIT((1350000 + rpm
* div
/ 2) / (rpm
* div
), 1,
178 static inline u16
FAN16_TO_REG(long rpm
)
182 return SENSORS_LIMIT((1350000 + rpm
) / (rpm
* 2), 1, 0xfffe);
185 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
186 /* The divider is fixed to 2 in 16-bit mode */
187 #define FAN16_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:1350000/((val)*2))
189 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
190 ((val)+500)/1000),-128,127))
191 #define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
193 #define PWM_TO_REG(val) ((val) >> 1)
194 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
196 static int DIV_TO_REG(int val
)
199 while (answer
< 7 && (val
>>= 1))
203 #define DIV_FROM_REG(val) (1 << (val))
206 /* For each registered IT87, we need to keep some data in memory. That
207 data is pointed to by it87_list[NR]->data. The structure itself is
208 dynamically allocated, at the same time when a new it87 client is
211 struct i2c_client client
;
212 struct class_device
*class_dev
;
216 struct mutex update_lock
;
217 char valid
; /* !=0 if following fields are valid */
218 unsigned long last_updated
; /* In jiffies */
220 u8 in
[9]; /* Register value */
221 u8 in_max
[8]; /* Register value */
222 u8 in_min
[8]; /* Register value */
223 u8 has_fan
; /* Bitfield, fans enabled */
224 u16 fan
[3]; /* Register values, possibly combined */
225 u16 fan_min
[3]; /* Register values, possibly combined */
226 u8 temp
[3]; /* Register value */
227 u8 temp_high
[3]; /* Register value */
228 u8 temp_low
[3]; /* Register value */
229 u8 sensor
; /* Register value */
230 u8 fan_div
[3]; /* Register encoding, shifted right */
231 u8 vid
; /* Register encoding, combined */
233 u32 alarms
; /* Register encoding, combined */
234 u8 fan_main_ctrl
; /* Register value */
235 u8 manual_pwm_ctl
[3]; /* manual PWM value set by user */
239 static int it87_detect(struct i2c_adapter
*adapter
);
240 static int it87_detach_client(struct i2c_client
*client
);
242 static int it87_read_value(struct i2c_client
*client
, u8 reg
);
243 static void it87_write_value(struct i2c_client
*client
, u8 reg
, u8 value
);
244 static struct it87_data
*it87_update_device(struct device
*dev
);
245 static int it87_check_pwm(struct i2c_client
*client
);
246 static void it87_init_client(struct i2c_client
*client
, struct it87_data
*data
);
249 static struct i2c_driver it87_isa_driver
= {
251 .owner
= THIS_MODULE
,
254 .attach_adapter
= it87_detect
,
255 .detach_client
= it87_detach_client
,
259 static ssize_t
show_in(struct device
*dev
, struct device_attribute
*attr
,
262 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
263 int nr
= sensor_attr
->index
;
265 struct it87_data
*data
= it87_update_device(dev
);
266 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in
[nr
]));
269 static ssize_t
show_in_min(struct device
*dev
, struct device_attribute
*attr
,
272 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
273 int nr
= sensor_attr
->index
;
275 struct it87_data
*data
= it87_update_device(dev
);
276 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_min
[nr
]));
279 static ssize_t
show_in_max(struct device
*dev
, struct device_attribute
*attr
,
282 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
283 int nr
= sensor_attr
->index
;
285 struct it87_data
*data
= it87_update_device(dev
);
286 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_max
[nr
]));
289 static ssize_t
set_in_min(struct device
*dev
, struct device_attribute
*attr
,
290 const char *buf
, size_t count
)
292 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
293 int nr
= sensor_attr
->index
;
295 struct i2c_client
*client
= to_i2c_client(dev
);
296 struct it87_data
*data
= i2c_get_clientdata(client
);
297 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
299 mutex_lock(&data
->update_lock
);
300 data
->in_min
[nr
] = IN_TO_REG(val
);
301 it87_write_value(client
, IT87_REG_VIN_MIN(nr
),
303 mutex_unlock(&data
->update_lock
);
306 static ssize_t
set_in_max(struct device
*dev
, struct device_attribute
*attr
,
307 const char *buf
, size_t count
)
309 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
310 int nr
= sensor_attr
->index
;
312 struct i2c_client
*client
= to_i2c_client(dev
);
313 struct it87_data
*data
= i2c_get_clientdata(client
);
314 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
316 mutex_lock(&data
->update_lock
);
317 data
->in_max
[nr
] = IN_TO_REG(val
);
318 it87_write_value(client
, IT87_REG_VIN_MAX(nr
),
320 mutex_unlock(&data
->update_lock
);
324 #define show_in_offset(offset) \
325 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
326 show_in, NULL, offset);
328 #define limit_in_offset(offset) \
329 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
330 show_in_min, set_in_min, offset); \
331 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
332 show_in_max, set_in_max, offset);
353 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*attr
,
356 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
357 int nr
= sensor_attr
->index
;
359 struct it87_data
*data
= it87_update_device(dev
);
360 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp
[nr
]));
362 static ssize_t
show_temp_max(struct device
*dev
, struct device_attribute
*attr
,
365 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
366 int nr
= sensor_attr
->index
;
368 struct it87_data
*data
= it87_update_device(dev
);
369 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_high
[nr
]));
371 static ssize_t
show_temp_min(struct device
*dev
, struct device_attribute
*attr
,
374 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
375 int nr
= sensor_attr
->index
;
377 struct it87_data
*data
= it87_update_device(dev
);
378 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_low
[nr
]));
380 static ssize_t
set_temp_max(struct device
*dev
, struct device_attribute
*attr
,
381 const char *buf
, size_t count
)
383 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
384 int nr
= sensor_attr
->index
;
386 struct i2c_client
*client
= to_i2c_client(dev
);
387 struct it87_data
*data
= i2c_get_clientdata(client
);
388 int val
= simple_strtol(buf
, NULL
, 10);
390 mutex_lock(&data
->update_lock
);
391 data
->temp_high
[nr
] = TEMP_TO_REG(val
);
392 it87_write_value(client
, IT87_REG_TEMP_HIGH(nr
), data
->temp_high
[nr
]);
393 mutex_unlock(&data
->update_lock
);
396 static ssize_t
set_temp_min(struct device
*dev
, struct device_attribute
*attr
,
397 const char *buf
, size_t count
)
399 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
400 int nr
= sensor_attr
->index
;
402 struct i2c_client
*client
= to_i2c_client(dev
);
403 struct it87_data
*data
= i2c_get_clientdata(client
);
404 int val
= simple_strtol(buf
, NULL
, 10);
406 mutex_lock(&data
->update_lock
);
407 data
->temp_low
[nr
] = TEMP_TO_REG(val
);
408 it87_write_value(client
, IT87_REG_TEMP_LOW(nr
), data
->temp_low
[nr
]);
409 mutex_unlock(&data
->update_lock
);
412 #define show_temp_offset(offset) \
413 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
414 show_temp, NULL, offset - 1); \
415 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
416 show_temp_max, set_temp_max, offset - 1); \
417 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
418 show_temp_min, set_temp_min, offset - 1);
424 static ssize_t
show_sensor(struct device
*dev
, struct device_attribute
*attr
,
427 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
428 int nr
= sensor_attr
->index
;
430 struct it87_data
*data
= it87_update_device(dev
);
431 u8 reg
= data
->sensor
; /* In case the value is updated while we use it */
434 return sprintf(buf
, "3\n"); /* thermal diode */
436 return sprintf(buf
, "2\n"); /* thermistor */
437 return sprintf(buf
, "0\n"); /* disabled */
439 static ssize_t
set_sensor(struct device
*dev
, struct device_attribute
*attr
,
440 const char *buf
, size_t count
)
442 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
443 int nr
= sensor_attr
->index
;
445 struct i2c_client
*client
= to_i2c_client(dev
);
446 struct it87_data
*data
= i2c_get_clientdata(client
);
447 int val
= simple_strtol(buf
, NULL
, 10);
449 mutex_lock(&data
->update_lock
);
451 data
->sensor
&= ~(1 << nr
);
452 data
->sensor
&= ~(8 << nr
);
453 /* 3 = thermal diode; 2 = thermistor; 0 = disabled */
455 data
->sensor
|= 1 << nr
;
457 data
->sensor
|= 8 << nr
;
459 mutex_unlock(&data
->update_lock
);
462 it87_write_value(client
, IT87_REG_TEMP_ENABLE
, data
->sensor
);
463 mutex_unlock(&data
->update_lock
);
466 #define show_sensor_offset(offset) \
467 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
468 show_sensor, set_sensor, offset - 1);
470 show_sensor_offset(1);
471 show_sensor_offset(2);
472 show_sensor_offset(3);
475 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*attr
,
478 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
479 int nr
= sensor_attr
->index
;
481 struct it87_data
*data
= it87_update_device(dev
);
482 return sprintf(buf
,"%d\n", FAN_FROM_REG(data
->fan
[nr
],
483 DIV_FROM_REG(data
->fan_div
[nr
])));
485 static ssize_t
show_fan_min(struct device
*dev
, struct device_attribute
*attr
,
488 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
489 int nr
= sensor_attr
->index
;
491 struct it87_data
*data
= it87_update_device(dev
);
492 return sprintf(buf
,"%d\n",
493 FAN_FROM_REG(data
->fan_min
[nr
], DIV_FROM_REG(data
->fan_div
[nr
])));
495 static ssize_t
show_fan_div(struct device
*dev
, struct device_attribute
*attr
,
498 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
499 int nr
= sensor_attr
->index
;
501 struct it87_data
*data
= it87_update_device(dev
);
502 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[nr
]));
504 static ssize_t
show_pwm_enable(struct device
*dev
, struct device_attribute
*attr
,
507 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
508 int nr
= sensor_attr
->index
;
510 struct it87_data
*data
= it87_update_device(dev
);
511 return sprintf(buf
,"%d\n", (data
->fan_main_ctrl
& (1 << nr
)) ? 1 : 0);
513 static ssize_t
show_pwm(struct device
*dev
, struct device_attribute
*attr
,
516 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
517 int nr
= sensor_attr
->index
;
519 struct it87_data
*data
= it87_update_device(dev
);
520 return sprintf(buf
,"%d\n", data
->manual_pwm_ctl
[nr
]);
522 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*attr
,
523 const char *buf
, size_t count
)
525 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
526 int nr
= sensor_attr
->index
;
528 struct i2c_client
*client
= to_i2c_client(dev
);
529 struct it87_data
*data
= i2c_get_clientdata(client
);
530 int val
= simple_strtol(buf
, NULL
, 10);
531 u8 reg
= it87_read_value(client
, IT87_REG_FAN_DIV
);
533 mutex_lock(&data
->update_lock
);
535 case 0: data
->fan_div
[nr
] = reg
& 0x07; break;
536 case 1: data
->fan_div
[nr
] = (reg
>> 3) & 0x07; break;
537 case 2: data
->fan_div
[nr
] = (reg
& 0x40) ? 3 : 1; break;
540 data
->fan_min
[nr
] = FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
541 it87_write_value(client
, IT87_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
542 mutex_unlock(&data
->update_lock
);
545 static ssize_t
set_fan_div(struct device
*dev
, struct device_attribute
*attr
,
546 const char *buf
, size_t count
)
548 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
549 int nr
= sensor_attr
->index
;
551 struct i2c_client
*client
= to_i2c_client(dev
);
552 struct it87_data
*data
= i2c_get_clientdata(client
);
553 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
557 mutex_lock(&data
->update_lock
);
558 old
= it87_read_value(client
, IT87_REG_FAN_DIV
);
560 /* Save fan min limit */
561 min
= FAN_FROM_REG(data
->fan_min
[nr
], DIV_FROM_REG(data
->fan_div
[nr
]));
566 data
->fan_div
[nr
] = DIV_TO_REG(val
);
570 data
->fan_div
[nr
] = 1;
572 data
->fan_div
[nr
] = 3;
575 val
|= (data
->fan_div
[0] & 0x07);
576 val
|= (data
->fan_div
[1] & 0x07) << 3;
577 if (data
->fan_div
[2] == 3)
579 it87_write_value(client
, IT87_REG_FAN_DIV
, val
);
581 /* Restore fan min limit */
582 data
->fan_min
[nr
] = FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
583 it87_write_value(client
, IT87_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
585 mutex_unlock(&data
->update_lock
);
588 static ssize_t
set_pwm_enable(struct device
*dev
,
589 struct device_attribute
*attr
, const char *buf
, size_t count
)
591 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
592 int nr
= sensor_attr
->index
;
594 struct i2c_client
*client
= to_i2c_client(dev
);
595 struct it87_data
*data
= i2c_get_clientdata(client
);
596 int val
= simple_strtol(buf
, NULL
, 10);
598 mutex_lock(&data
->update_lock
);
602 /* make sure the fan is on when in on/off mode */
603 tmp
= it87_read_value(client
, IT87_REG_FAN_CTL
);
604 it87_write_value(client
, IT87_REG_FAN_CTL
, tmp
| (1 << nr
));
605 /* set on/off mode */
606 data
->fan_main_ctrl
&= ~(1 << nr
);
607 it87_write_value(client
, IT87_REG_FAN_MAIN_CTRL
, data
->fan_main_ctrl
);
608 } else if (val
== 1) {
609 /* set SmartGuardian mode */
610 data
->fan_main_ctrl
|= (1 << nr
);
611 it87_write_value(client
, IT87_REG_FAN_MAIN_CTRL
, data
->fan_main_ctrl
);
612 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
613 it87_write_value(client
, IT87_REG_PWM(nr
), PWM_TO_REG(data
->manual_pwm_ctl
[nr
]));
615 mutex_unlock(&data
->update_lock
);
619 mutex_unlock(&data
->update_lock
);
622 static ssize_t
set_pwm(struct device
*dev
, struct device_attribute
*attr
,
623 const char *buf
, size_t count
)
625 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
626 int nr
= sensor_attr
->index
;
628 struct i2c_client
*client
= to_i2c_client(dev
);
629 struct it87_data
*data
= i2c_get_clientdata(client
);
630 int val
= simple_strtol(buf
, NULL
, 10);
632 if (val
< 0 || val
> 255)
635 mutex_lock(&data
->update_lock
);
636 data
->manual_pwm_ctl
[nr
] = val
;
637 if (data
->fan_main_ctrl
& (1 << nr
))
638 it87_write_value(client
, IT87_REG_PWM(nr
), PWM_TO_REG(data
->manual_pwm_ctl
[nr
]));
639 mutex_unlock(&data
->update_lock
);
643 #define show_fan_offset(offset) \
644 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
645 show_fan, NULL, offset - 1); \
646 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
647 show_fan_min, set_fan_min, offset - 1); \
648 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
649 show_fan_div, set_fan_div, offset - 1);
655 #define show_pwm_offset(offset) \
656 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
657 show_pwm_enable, set_pwm_enable, offset - 1); \
658 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
659 show_pwm, set_pwm, offset - 1);
665 /* A different set of callbacks for 16-bit fans */
666 static ssize_t
show_fan16(struct device
*dev
, struct device_attribute
*attr
,
669 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
670 int nr
= sensor_attr
->index
;
671 struct it87_data
*data
= it87_update_device(dev
);
672 return sprintf(buf
, "%d\n", FAN16_FROM_REG(data
->fan
[nr
]));
675 static ssize_t
show_fan16_min(struct device
*dev
, struct device_attribute
*attr
,
678 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
679 int nr
= sensor_attr
->index
;
680 struct it87_data
*data
= it87_update_device(dev
);
681 return sprintf(buf
, "%d\n", FAN16_FROM_REG(data
->fan_min
[nr
]));
684 static ssize_t
set_fan16_min(struct device
*dev
, struct device_attribute
*attr
,
685 const char *buf
, size_t count
)
687 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
688 int nr
= sensor_attr
->index
;
689 struct i2c_client
*client
= to_i2c_client(dev
);
690 struct it87_data
*data
= i2c_get_clientdata(client
);
691 int val
= simple_strtol(buf
, NULL
, 10);
693 mutex_lock(&data
->update_lock
);
694 data
->fan_min
[nr
] = FAN16_TO_REG(val
);
695 it87_write_value(client
, IT87_REG_FAN_MIN(nr
),
696 data
->fan_min
[nr
] & 0xff);
697 it87_write_value(client
, IT87_REG_FANX_MIN(nr
),
698 data
->fan_min
[nr
] >> 8);
699 mutex_unlock(&data
->update_lock
);
703 /* We want to use the same sysfs file names as 8-bit fans, but we need
704 different variable names, so we have to use SENSOR_ATTR instead of
705 SENSOR_DEVICE_ATTR. */
706 #define show_fan16_offset(offset) \
707 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \
708 = SENSOR_ATTR(fan##offset##_input, S_IRUGO, \
709 show_fan16, NULL, offset - 1); \
710 static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \
711 = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
712 show_fan16_min, set_fan16_min, offset - 1)
714 show_fan16_offset(1);
715 show_fan16_offset(2);
716 show_fan16_offset(3);
719 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
721 struct it87_data
*data
= it87_update_device(dev
);
722 return sprintf(buf
, "%u\n", data
->alarms
);
724 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
727 show_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
729 struct it87_data
*data
= it87_update_device(dev
);
730 return sprintf(buf
, "%u\n", data
->vrm
);
733 store_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
735 struct i2c_client
*client
= to_i2c_client(dev
);
736 struct it87_data
*data
= i2c_get_clientdata(client
);
739 val
= simple_strtoul(buf
, NULL
, 10);
744 static DEVICE_ATTR(vrm
, S_IRUGO
| S_IWUSR
, show_vrm_reg
, store_vrm_reg
);
747 show_vid_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
749 struct it87_data
*data
= it87_update_device(dev
);
750 return sprintf(buf
, "%ld\n", (long) vid_from_reg(data
->vid
, data
->vrm
));
752 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid_reg
, NULL
);
754 static struct attribute
*it87_attributes
[] = {
755 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
756 &sensor_dev_attr_in1_input
.dev_attr
.attr
,
757 &sensor_dev_attr_in2_input
.dev_attr
.attr
,
758 &sensor_dev_attr_in3_input
.dev_attr
.attr
,
759 &sensor_dev_attr_in4_input
.dev_attr
.attr
,
760 &sensor_dev_attr_in5_input
.dev_attr
.attr
,
761 &sensor_dev_attr_in6_input
.dev_attr
.attr
,
762 &sensor_dev_attr_in7_input
.dev_attr
.attr
,
763 &sensor_dev_attr_in8_input
.dev_attr
.attr
,
764 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
765 &sensor_dev_attr_in1_min
.dev_attr
.attr
,
766 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
767 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
768 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
769 &sensor_dev_attr_in5_min
.dev_attr
.attr
,
770 &sensor_dev_attr_in6_min
.dev_attr
.attr
,
771 &sensor_dev_attr_in7_min
.dev_attr
.attr
,
772 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
773 &sensor_dev_attr_in1_max
.dev_attr
.attr
,
774 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
775 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
776 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
777 &sensor_dev_attr_in5_max
.dev_attr
.attr
,
778 &sensor_dev_attr_in6_max
.dev_attr
.attr
,
779 &sensor_dev_attr_in7_max
.dev_attr
.attr
,
781 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
782 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
783 &sensor_dev_attr_temp3_input
.dev_attr
.attr
,
784 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
785 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
786 &sensor_dev_attr_temp3_max
.dev_attr
.attr
,
787 &sensor_dev_attr_temp1_min
.dev_attr
.attr
,
788 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
789 &sensor_dev_attr_temp3_min
.dev_attr
.attr
,
790 &sensor_dev_attr_temp1_type
.dev_attr
.attr
,
791 &sensor_dev_attr_temp2_type
.dev_attr
.attr
,
792 &sensor_dev_attr_temp3_type
.dev_attr
.attr
,
794 &dev_attr_alarms
.attr
,
798 static const struct attribute_group it87_group
= {
799 .attrs
= it87_attributes
,
802 static struct attribute
*it87_attributes_opt
[] = {
803 &sensor_dev_attr_fan1_input16
.dev_attr
.attr
,
804 &sensor_dev_attr_fan1_min16
.dev_attr
.attr
,
805 &sensor_dev_attr_fan2_input16
.dev_attr
.attr
,
806 &sensor_dev_attr_fan2_min16
.dev_attr
.attr
,
807 &sensor_dev_attr_fan3_input16
.dev_attr
.attr
,
808 &sensor_dev_attr_fan3_min16
.dev_attr
.attr
,
810 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
811 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
812 &sensor_dev_attr_fan1_div
.dev_attr
.attr
,
813 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
814 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
815 &sensor_dev_attr_fan2_div
.dev_attr
.attr
,
816 &sensor_dev_attr_fan3_input
.dev_attr
.attr
,
817 &sensor_dev_attr_fan3_min
.dev_attr
.attr
,
818 &sensor_dev_attr_fan3_div
.dev_attr
.attr
,
820 &sensor_dev_attr_pwm1_enable
.dev_attr
.attr
,
821 &sensor_dev_attr_pwm2_enable
.dev_attr
.attr
,
822 &sensor_dev_attr_pwm3_enable
.dev_attr
.attr
,
823 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
824 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
825 &sensor_dev_attr_pwm3
.dev_attr
.attr
,
828 &dev_attr_cpu0_vid
.attr
,
832 static const struct attribute_group it87_group_opt
= {
833 .attrs
= it87_attributes_opt
,
836 /* SuperIO detection - will change isa_address if a chip is found */
837 static int __init
it87_find(unsigned short *address
)
842 chip_type
= superio_inw(DEVID
);
843 if (chip_type
!= IT8712F_DEVID
844 && chip_type
!= IT8716F_DEVID
845 && chip_type
!= IT8718F_DEVID
846 && chip_type
!= IT8705F_DEVID
)
850 if (!(superio_inb(IT87_ACT_REG
) & 0x01)) {
851 pr_info("it87: Device not activated, skipping\n");
855 *address
= superio_inw(IT87_BASE_REG
) & ~(IT87_EXTENT
- 1);
857 pr_info("it87: Base address not set, skipping\n");
862 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
863 chip_type
, *address
, superio_inb(DEVREV
) & 0x0f);
865 /* Read GPIO config and VID value from LDN 7 (GPIO) */
866 if (chip_type
!= IT8705F_DEVID
) {
869 superio_select(GPIO
);
870 if (chip_type
== it8718
)
871 vid_value
= superio_inb(IT87_SIO_VID_REG
);
873 reg
= superio_inb(IT87_SIO_PINX2_REG
);
875 pr_info("it87: in3 is VCC (+5V)\n");
877 pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
885 /* This function is called by i2c_probe */
886 static int it87_detect(struct i2c_adapter
*adapter
)
888 struct i2c_client
*new_client
;
889 struct it87_data
*data
;
892 int enable_pwm_interface
;
894 /* Reserve the ISA region */
895 if (!request_region(isa_address
, IT87_EXTENT
,
896 it87_isa_driver
.driver
.name
)){
901 if (!(data
= kzalloc(sizeof(struct it87_data
), GFP_KERNEL
))) {
906 new_client
= &data
->client
;
907 mutex_init(&data
->lock
);
908 i2c_set_clientdata(new_client
, data
);
909 new_client
->addr
= isa_address
;
910 new_client
->adapter
= adapter
;
911 new_client
->driver
= &it87_isa_driver
;
913 /* Now, we do the remaining detection. */
914 if ((it87_read_value(new_client
, IT87_REG_CONFIG
) & 0x80)
915 || it87_read_value(new_client
, IT87_REG_CHIPID
) != 0x90) {
920 /* Determine the chip type. */
939 /* Fill in the remaining client fields and put it into the global list */
940 strlcpy(new_client
->name
, name
, I2C_NAME_SIZE
);
941 mutex_init(&data
->update_lock
);
943 /* Tell the I2C layer a new client has arrived */
944 if ((err
= i2c_attach_client(new_client
)))
947 /* Check PWM configuration */
948 enable_pwm_interface
= it87_check_pwm(new_client
);
950 /* Initialize the IT87 chip */
951 it87_init_client(new_client
, data
);
953 /* Register sysfs hooks */
954 if ((err
= sysfs_create_group(&new_client
->dev
.kobj
, &it87_group
)))
957 /* Do not create fan files for disabled fans */
958 if (data
->type
== it8716
|| data
->type
== it8718
) {
959 /* 16-bit tachometers */
960 if (data
->has_fan
& (1 << 0)) {
961 if ((err
= device_create_file(&new_client
->dev
,
962 &sensor_dev_attr_fan1_input16
.dev_attr
))
963 || (err
= device_create_file(&new_client
->dev
,
964 &sensor_dev_attr_fan1_min16
.dev_attr
)))
967 if (data
->has_fan
& (1 << 1)) {
968 if ((err
= device_create_file(&new_client
->dev
,
969 &sensor_dev_attr_fan2_input16
.dev_attr
))
970 || (err
= device_create_file(&new_client
->dev
,
971 &sensor_dev_attr_fan2_min16
.dev_attr
)))
974 if (data
->has_fan
& (1 << 2)) {
975 if ((err
= device_create_file(&new_client
->dev
,
976 &sensor_dev_attr_fan3_input16
.dev_attr
))
977 || (err
= device_create_file(&new_client
->dev
,
978 &sensor_dev_attr_fan3_min16
.dev_attr
)))
982 /* 8-bit tachometers with clock divider */
983 if (data
->has_fan
& (1 << 0)) {
984 if ((err
= device_create_file(&new_client
->dev
,
985 &sensor_dev_attr_fan1_input
.dev_attr
))
986 || (err
= device_create_file(&new_client
->dev
,
987 &sensor_dev_attr_fan1_min
.dev_attr
))
988 || (err
= device_create_file(&new_client
->dev
,
989 &sensor_dev_attr_fan1_div
.dev_attr
)))
992 if (data
->has_fan
& (1 << 1)) {
993 if ((err
= device_create_file(&new_client
->dev
,
994 &sensor_dev_attr_fan2_input
.dev_attr
))
995 || (err
= device_create_file(&new_client
->dev
,
996 &sensor_dev_attr_fan2_min
.dev_attr
))
997 || (err
= device_create_file(&new_client
->dev
,
998 &sensor_dev_attr_fan2_div
.dev_attr
)))
1001 if (data
->has_fan
& (1 << 2)) {
1002 if ((err
= device_create_file(&new_client
->dev
,
1003 &sensor_dev_attr_fan3_input
.dev_attr
))
1004 || (err
= device_create_file(&new_client
->dev
,
1005 &sensor_dev_attr_fan3_min
.dev_attr
))
1006 || (err
= device_create_file(&new_client
->dev
,
1007 &sensor_dev_attr_fan3_div
.dev_attr
)))
1012 if (enable_pwm_interface
) {
1013 if ((err
= device_create_file(&new_client
->dev
,
1014 &sensor_dev_attr_pwm1_enable
.dev_attr
))
1015 || (err
= device_create_file(&new_client
->dev
,
1016 &sensor_dev_attr_pwm2_enable
.dev_attr
))
1017 || (err
= device_create_file(&new_client
->dev
,
1018 &sensor_dev_attr_pwm3_enable
.dev_attr
))
1019 || (err
= device_create_file(&new_client
->dev
,
1020 &sensor_dev_attr_pwm1
.dev_attr
))
1021 || (err
= device_create_file(&new_client
->dev
,
1022 &sensor_dev_attr_pwm2
.dev_attr
))
1023 || (err
= device_create_file(&new_client
->dev
,
1024 &sensor_dev_attr_pwm3
.dev_attr
)))
1028 if (data
->type
== it8712
|| data
->type
== it8716
1029 || data
->type
== it8718
) {
1030 data
->vrm
= vid_which_vrm();
1031 /* VID reading from Super-I/O config space if available */
1032 data
->vid
= vid_value
;
1033 if ((err
= device_create_file(&new_client
->dev
,
1035 || (err
= device_create_file(&new_client
->dev
,
1036 &dev_attr_cpu0_vid
)))
1040 data
->class_dev
= hwmon_device_register(&new_client
->dev
);
1041 if (IS_ERR(data
->class_dev
)) {
1042 err
= PTR_ERR(data
->class_dev
);
1049 sysfs_remove_group(&new_client
->dev
.kobj
, &it87_group
);
1050 sysfs_remove_group(&new_client
->dev
.kobj
, &it87_group_opt
);
1052 i2c_detach_client(new_client
);
1056 release_region(isa_address
, IT87_EXTENT
);
1061 static int it87_detach_client(struct i2c_client
*client
)
1063 struct it87_data
*data
= i2c_get_clientdata(client
);
1066 hwmon_device_unregister(data
->class_dev
);
1067 sysfs_remove_group(&client
->dev
.kobj
, &it87_group
);
1068 sysfs_remove_group(&client
->dev
.kobj
, &it87_group_opt
);
1070 if ((err
= i2c_detach_client(client
)))
1073 release_region(client
->addr
, IT87_EXTENT
);
1079 /* ISA access must be locked explicitly!
1080 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1081 would slow down the IT87 access and should not be necessary. */
1082 static int it87_read_value(struct i2c_client
*client
, u8 reg
)
1084 struct it87_data
*data
= i2c_get_clientdata(client
);
1087 mutex_lock(&data
->lock
);
1088 outb_p(reg
, client
->addr
+ IT87_ADDR_REG_OFFSET
);
1089 res
= inb_p(client
->addr
+ IT87_DATA_REG_OFFSET
);
1090 mutex_unlock(&data
->lock
);
1095 /* ISA access must be locked explicitly!
1096 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
1097 would slow down the IT87 access and should not be necessary. */
1098 static void it87_write_value(struct i2c_client
*client
, u8 reg
, u8 value
)
1100 struct it87_data
*data
= i2c_get_clientdata(client
);
1102 mutex_lock(&data
->lock
);
1103 outb_p(reg
, client
->addr
+ IT87_ADDR_REG_OFFSET
);
1104 outb_p(value
, client
->addr
+ IT87_DATA_REG_OFFSET
);
1105 mutex_unlock(&data
->lock
);
1108 /* Return 1 if and only if the PWM interface is safe to use */
1109 static int it87_check_pwm(struct i2c_client
*client
)
1111 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
1112 * and polarity set to active low is sign that this is the case so we
1113 * disable pwm control to protect the user. */
1114 int tmp
= it87_read_value(client
, IT87_REG_FAN_CTL
);
1115 if ((tmp
& 0x87) == 0) {
1116 if (fix_pwm_polarity
) {
1117 /* The user asks us to attempt a chip reconfiguration.
1118 * This means switching to active high polarity and
1119 * inverting all fan speed values. */
1123 for (i
= 0; i
< 3; i
++)
1124 pwm
[i
] = it87_read_value(client
,
1127 /* If any fan is in automatic pwm mode, the polarity
1128 * might be correct, as suspicious as it seems, so we
1129 * better don't change anything (but still disable the
1130 * PWM interface). */
1131 if (!((pwm
[0] | pwm
[1] | pwm
[2]) & 0x80)) {
1132 dev_info(&client
->dev
, "Reconfiguring PWM to "
1133 "active high polarity\n");
1134 it87_write_value(client
, IT87_REG_FAN_CTL
,
1136 for (i
= 0; i
< 3; i
++)
1137 it87_write_value(client
,
1143 dev_info(&client
->dev
, "PWM configuration is "
1144 "too broken to be fixed\n");
1147 dev_info(&client
->dev
, "Detected broken BIOS "
1148 "defaults, disabling PWM interface\n");
1150 } else if (fix_pwm_polarity
) {
1151 dev_info(&client
->dev
, "PWM configuration looks "
1152 "sane, won't touch\n");
1158 /* Called when we have found a new IT87. */
1159 static void it87_init_client(struct i2c_client
*client
, struct it87_data
*data
)
1163 /* initialize to sane defaults:
1164 * - if the chip is in manual pwm mode, this will be overwritten with
1165 * the actual settings on the chip (so in this case, initialization
1167 * - if in automatic or on/off mode, we could switch to manual mode,
1168 * read the registers and set manual_pwm_ctl accordingly, but currently
1169 * this is not implemented, so we initialize to something sane */
1170 for (i
= 0; i
< 3; i
++) {
1171 data
->manual_pwm_ctl
[i
] = 0xff;
1174 /* Some chips seem to have default value 0xff for all limit
1175 * registers. For low voltage limits it makes no sense and triggers
1176 * alarms, so change to 0 instead. For high temperature limits, it
1177 * means -1 degree C, which surprisingly doesn't trigger an alarm,
1178 * but is still confusing, so change to 127 degrees C. */
1179 for (i
= 0; i
< 8; i
++) {
1180 tmp
= it87_read_value(client
, IT87_REG_VIN_MIN(i
));
1182 it87_write_value(client
, IT87_REG_VIN_MIN(i
), 0);
1184 for (i
= 0; i
< 3; i
++) {
1185 tmp
= it87_read_value(client
, IT87_REG_TEMP_HIGH(i
));
1187 it87_write_value(client
, IT87_REG_TEMP_HIGH(i
), 127);
1190 /* Check if temperature channnels are reset manually or by some reason */
1191 tmp
= it87_read_value(client
, IT87_REG_TEMP_ENABLE
);
1192 if ((tmp
& 0x3f) == 0) {
1193 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1194 tmp
= (tmp
& 0xc0) | 0x2a;
1195 it87_write_value(client
, IT87_REG_TEMP_ENABLE
, tmp
);
1199 /* Check if voltage monitors are reset manually or by some reason */
1200 tmp
= it87_read_value(client
, IT87_REG_VIN_ENABLE
);
1201 if ((tmp
& 0xff) == 0) {
1202 /* Enable all voltage monitors */
1203 it87_write_value(client
, IT87_REG_VIN_ENABLE
, 0xff);
1206 /* Check if tachometers are reset manually or by some reason */
1207 data
->fan_main_ctrl
= it87_read_value(client
, IT87_REG_FAN_MAIN_CTRL
);
1208 if ((data
->fan_main_ctrl
& 0x70) == 0) {
1209 /* Enable all fan tachometers */
1210 data
->fan_main_ctrl
|= 0x70;
1211 it87_write_value(client
, IT87_REG_FAN_MAIN_CTRL
, data
->fan_main_ctrl
);
1213 data
->has_fan
= (data
->fan_main_ctrl
>> 4) & 0x07;
1215 /* Set tachometers to 16-bit mode if needed */
1216 if (data
->type
== it8716
|| data
->type
== it8718
) {
1217 tmp
= it87_read_value(client
, IT87_REG_FAN_16BIT
);
1218 if (~tmp
& 0x07 & data
->has_fan
) {
1219 dev_dbg(&client
->dev
,
1220 "Setting fan1-3 to 16-bit mode\n");
1221 it87_write_value(client
, IT87_REG_FAN_16BIT
,
1226 /* Set current fan mode registers and the default settings for the
1227 * other mode registers */
1228 for (i
= 0; i
< 3; i
++) {
1229 if (data
->fan_main_ctrl
& (1 << i
)) {
1231 tmp
= it87_read_value(client
, IT87_REG_PWM(i
));
1233 /* automatic pwm - not yet implemented, but
1234 * leave the settings made by the BIOS alone
1235 * until a change is requested via the sysfs
1239 data
->manual_pwm_ctl
[i
] = PWM_FROM_REG(tmp
);
1244 /* Start monitoring */
1245 it87_write_value(client
, IT87_REG_CONFIG
,
1246 (it87_read_value(client
, IT87_REG_CONFIG
) & 0x36)
1247 | (update_vbat
? 0x41 : 0x01));
1250 static struct it87_data
*it87_update_device(struct device
*dev
)
1252 struct i2c_client
*client
= to_i2c_client(dev
);
1253 struct it87_data
*data
= i2c_get_clientdata(client
);
1256 mutex_lock(&data
->update_lock
);
1258 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
1262 /* Cleared after each update, so reenable. Value
1263 returned by this read will be previous value */
1264 it87_write_value(client
, IT87_REG_CONFIG
,
1265 it87_read_value(client
, IT87_REG_CONFIG
) | 0x40);
1267 for (i
= 0; i
<= 7; i
++) {
1269 it87_read_value(client
, IT87_REG_VIN(i
));
1271 it87_read_value(client
, IT87_REG_VIN_MIN(i
));
1273 it87_read_value(client
, IT87_REG_VIN_MAX(i
));
1275 /* in8 (battery) has no limit registers */
1277 it87_read_value(client
, IT87_REG_VIN(8));
1279 for (i
= 0; i
< 3; i
++) {
1280 /* Skip disabled fans */
1281 if (!(data
->has_fan
& (1 << i
)))
1285 it87_read_value(client
, IT87_REG_FAN_MIN(i
));
1286 data
->fan
[i
] = it87_read_value(client
,
1288 /* Add high byte if in 16-bit mode */
1289 if (data
->type
== it8716
|| data
->type
== it8718
) {
1290 data
->fan
[i
] |= it87_read_value(client
,
1291 IT87_REG_FANX(i
)) << 8;
1292 data
->fan_min
[i
] |= it87_read_value(client
,
1293 IT87_REG_FANX_MIN(i
)) << 8;
1296 for (i
= 0; i
< 3; i
++) {
1298 it87_read_value(client
, IT87_REG_TEMP(i
));
1299 data
->temp_high
[i
] =
1300 it87_read_value(client
, IT87_REG_TEMP_HIGH(i
));
1302 it87_read_value(client
, IT87_REG_TEMP_LOW(i
));
1305 /* Newer chips don't have clock dividers */
1306 if ((data
->has_fan
& 0x07) && data
->type
!= it8716
1307 && data
->type
!= it8718
) {
1308 i
= it87_read_value(client
, IT87_REG_FAN_DIV
);
1309 data
->fan_div
[0] = i
& 0x07;
1310 data
->fan_div
[1] = (i
>> 3) & 0x07;
1311 data
->fan_div
[2] = (i
& 0x40) ? 3 : 1;
1315 it87_read_value(client
, IT87_REG_ALARM1
) |
1316 (it87_read_value(client
, IT87_REG_ALARM2
) << 8) |
1317 (it87_read_value(client
, IT87_REG_ALARM3
) << 16);
1318 data
->fan_main_ctrl
= it87_read_value(client
, IT87_REG_FAN_MAIN_CTRL
);
1320 data
->sensor
= it87_read_value(client
, IT87_REG_TEMP_ENABLE
);
1321 /* The 8705 does not have VID capability */
1322 if (data
->type
== it8712
|| data
->type
== it8716
) {
1323 data
->vid
= it87_read_value(client
, IT87_REG_VID
);
1324 /* The older IT8712F revisions had only 5 VID pins,
1325 but we assume it is always safe to read 6 bits. */
1328 data
->last_updated
= jiffies
;
1332 mutex_unlock(&data
->update_lock
);
1337 static int __init
sm_it87_init(void)
1341 if ((res
= it87_find(&isa_address
)))
1343 return i2c_isa_add_driver(&it87_isa_driver
);
1346 static void __exit
sm_it87_exit(void)
1348 i2c_isa_del_driver(&it87_isa_driver
);
1352 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>, "
1353 "Jean Delvare <khali@linux-fr.org>");
1354 MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F, SiS950 driver");
1355 module_param(update_vbat
, bool, 0);
1356 MODULE_PARM_DESC(update_vbat
, "Update vbat if set else return powerup value");
1357 module_param(fix_pwm_polarity
, bool, 0);
1358 MODULE_PARM_DESC(fix_pwm_polarity
, "Force PWM polarity to active high (DANGEROUS)");
1359 MODULE_LICENSE("GPL");
1361 module_init(sm_it87_init
);
1362 module_exit(sm_it87_exit
);