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 & SMBus
7 Sis950 A clone of the IT8705F
9 Copyright (C) 2001 Chris Gauthron <chrisg@0-in.com>
10 Largely inspired by lm78.c of the same package
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 djg@pdp8.net David Gesswein 7/18/01
29 Modified to fix bug with not all alarms enabled.
30 Added ability to read battery voltage and select temperature sensor
31 type at module load time.
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 #include <linux/jiffies.h>
38 #include <linux/i2c.h>
39 #include <linux/i2c-isa.h>
40 #include <linux/hwmon.h>
41 #include <linux/hwmon-sysfs.h>
42 #include <linux/hwmon-vid.h>
43 #include <linux/err.h>
47 /* Addresses to scan */
48 static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
49 0x2e, 0x2f, I2C_CLIENT_END };
50 static unsigned short isa_address;
52 /* Insmod parameters */
53 I2C_CLIENT_INSMOD_2(it87, it8712);
55 #define REG 0x2e /* The register to read/write */
56 #define DEV 0x07 /* Register: Logical device select */
57 #define VAL 0x2f /* The value to read/write */
58 #define PME 0x04 /* The device with the fan registers in it */
59 #define DEVID 0x20 /* Register: Device ID */
60 #define DEVREV 0x22 /* Register: Device Revision */
69 static int superio_inw(int reg)
102 #define IT8712F_DEVID 0x8712
103 #define IT8705F_DEVID 0x8705
104 #define IT87_ACT_REG 0x30
105 #define IT87_BASE_REG 0x60
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;
115 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 #define IT87_REG_VID 0x0a
135 #define IT87_REG_FAN_DIV 0x0b
137 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
139 #define IT87_REG_FAN(nr) (0x0d + (nr))
140 #define IT87_REG_FAN_MIN(nr) (0x10 + (nr))
141 #define IT87_REG_FAN_MAIN_CTRL 0x13
142 #define IT87_REG_FAN_CTL 0x14
143 #define IT87_REG_PWM(nr) (0x15 + (nr))
145 #define IT87_REG_VIN(nr) (0x20 + (nr))
146 #define IT87_REG_TEMP(nr) (0x29 + (nr))
148 #define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2)
149 #define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2)
150 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
151 #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2)
153 #define IT87_REG_I2C_ADDR 0x48
155 #define IT87_REG_VIN_ENABLE 0x50
156 #define IT87_REG_TEMP_ENABLE 0x51
158 #define IT87_REG_CHIPID 0x58
160 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
161 #define IN_FROM_REG(val) ((val) * 16)
163 static inline u8 FAN_TO_REG(long rpm, int div)
167 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
168 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
172 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
174 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
175 ((val)+500)/1000),-128,127))
176 #define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
178 #define PWM_TO_REG(val) ((val) >> 1)
179 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
181 static int DIV_TO_REG(int val)
184 while ((val >>= 1) != 0)
188 #define DIV_FROM_REG(val) (1 << (val))
191 /* For each registered IT87, we need to keep some data in memory. That
192 data is pointed to by it87_list[NR]->data. The structure itself is
193 dynamically allocated, at the same time when a new it87 client is
196 struct i2c_client client;
197 struct class_device *class_dev;
198 struct semaphore lock;
201 struct semaphore update_lock;
202 char valid; /* !=0 if following fields are valid */
203 unsigned long last_updated; /* In jiffies */
205 u8 in[9]; /* Register value */
206 u8 in_max[9]; /* Register value */
207 u8 in_min[9]; /* Register value */
208 u8 fan[3]; /* Register value */
209 u8 fan_min[3]; /* Register value */
210 u8 temp[3]; /* Register value */
211 u8 temp_high[3]; /* Register value */
212 u8 temp_low[3]; /* Register value */
213 u8 sensor; /* Register value */
214 u8 fan_div[3]; /* Register encoding, shifted right */
215 u8 vid; /* Register encoding, combined */
217 u32 alarms; /* Register encoding, combined */
218 u8 fan_main_ctrl; /* Register value */
219 u8 manual_pwm_ctl[3]; /* manual PWM value set by user */
223 static int it87_attach_adapter(struct i2c_adapter *adapter);
224 static int it87_isa_attach_adapter(struct i2c_adapter *adapter);
225 static int it87_detect(struct i2c_adapter *adapter, int address, int kind);
226 static int it87_detach_client(struct i2c_client *client);
228 static int it87_read_value(struct i2c_client *client, u8 register);
229 static int it87_write_value(struct i2c_client *client, u8 register,
231 static struct it87_data *it87_update_device(struct device *dev);
232 static int it87_check_pwm(struct i2c_client *client);
233 static void it87_init_client(struct i2c_client *client, struct it87_data *data);
236 static struct i2c_driver it87_driver = {
238 .owner = THIS_MODULE,
241 .id = I2C_DRIVERID_IT87,
242 .attach_adapter = it87_attach_adapter,
243 .detach_client = it87_detach_client,
246 static struct i2c_driver it87_isa_driver = {
248 .owner = THIS_MODULE,
251 .attach_adapter = it87_isa_attach_adapter,
252 .detach_client = it87_detach_client,
256 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
259 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
260 int nr = sensor_attr->index;
262 struct it87_data *data = it87_update_device(dev);
263 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
266 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
269 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
270 int nr = sensor_attr->index;
272 struct it87_data *data = it87_update_device(dev);
273 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
276 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
279 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
280 int nr = sensor_attr->index;
282 struct it87_data *data = it87_update_device(dev);
283 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
286 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
287 const char *buf, size_t count)
289 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
290 int nr = sensor_attr->index;
292 struct i2c_client *client = to_i2c_client(dev);
293 struct it87_data *data = i2c_get_clientdata(client);
294 unsigned long val = simple_strtoul(buf, NULL, 10);
296 down(&data->update_lock);
297 data->in_min[nr] = IN_TO_REG(val);
298 it87_write_value(client, IT87_REG_VIN_MIN(nr),
300 up(&data->update_lock);
303 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
304 const char *buf, size_t count)
306 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
307 int nr = sensor_attr->index;
309 struct i2c_client *client = to_i2c_client(dev);
310 struct it87_data *data = i2c_get_clientdata(client);
311 unsigned long val = simple_strtoul(buf, NULL, 10);
313 down(&data->update_lock);
314 data->in_max[nr] = IN_TO_REG(val);
315 it87_write_value(client, IT87_REG_VIN_MAX(nr),
317 up(&data->update_lock);
321 #define show_in_offset(offset) \
322 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
323 show_in, NULL, offset);
325 #define limit_in_offset(offset) \
326 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
327 show_in_min, set_in_min, offset); \
328 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
329 show_in_max, set_in_max, offset);
350 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
353 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
354 int nr = sensor_attr->index;
356 struct it87_data *data = it87_update_device(dev);
357 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
359 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
362 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
363 int nr = sensor_attr->index;
365 struct it87_data *data = it87_update_device(dev);
366 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
368 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
371 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
372 int nr = sensor_attr->index;
374 struct it87_data *data = it87_update_device(dev);
375 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
377 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
378 const char *buf, size_t count)
380 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
381 int nr = sensor_attr->index;
383 struct i2c_client *client = to_i2c_client(dev);
384 struct it87_data *data = i2c_get_clientdata(client);
385 int val = simple_strtol(buf, NULL, 10);
387 down(&data->update_lock);
388 data->temp_high[nr] = TEMP_TO_REG(val);
389 it87_write_value(client, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
390 up(&data->update_lock);
393 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
394 const char *buf, size_t count)
396 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
397 int nr = sensor_attr->index;
399 struct i2c_client *client = to_i2c_client(dev);
400 struct it87_data *data = i2c_get_clientdata(client);
401 int val = simple_strtol(buf, NULL, 10);
403 down(&data->update_lock);
404 data->temp_low[nr] = TEMP_TO_REG(val);
405 it87_write_value(client, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
406 up(&data->update_lock);
409 #define show_temp_offset(offset) \
410 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
411 show_temp, NULL, offset - 1); \
412 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
413 show_temp_max, set_temp_max, offset - 1); \
414 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
415 show_temp_min, set_temp_min, offset - 1);
421 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
424 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
425 int nr = sensor_attr->index;
427 struct it87_data *data = it87_update_device(dev);
428 u8 reg = data->sensor; /* In case the value is updated while we use it */
431 return sprintf(buf, "3\n"); /* thermal diode */
433 return sprintf(buf, "2\n"); /* thermistor */
434 return sprintf(buf, "0\n"); /* disabled */
436 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
437 const char *buf, size_t count)
439 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
440 int nr = sensor_attr->index;
442 struct i2c_client *client = to_i2c_client(dev);
443 struct it87_data *data = i2c_get_clientdata(client);
444 int val = simple_strtol(buf, NULL, 10);
446 down(&data->update_lock);
448 data->sensor &= ~(1 << nr);
449 data->sensor &= ~(8 << nr);
450 /* 3 = thermal diode; 2 = thermistor; 0 = disabled */
452 data->sensor |= 1 << nr;
454 data->sensor |= 8 << nr;
456 up(&data->update_lock);
459 it87_write_value(client, IT87_REG_TEMP_ENABLE, data->sensor);
460 up(&data->update_lock);
463 #define show_sensor_offset(offset) \
464 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
465 show_sensor, set_sensor, offset - 1);
467 show_sensor_offset(1);
468 show_sensor_offset(2);
469 show_sensor_offset(3);
472 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
475 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
476 int nr = sensor_attr->index;
478 struct it87_data *data = it87_update_device(dev);
479 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
480 DIV_FROM_REG(data->fan_div[nr])));
482 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
485 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
486 int nr = sensor_attr->index;
488 struct it87_data *data = it87_update_device(dev);
489 return sprintf(buf,"%d\n",
490 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
492 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
495 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
496 int nr = sensor_attr->index;
498 struct it87_data *data = it87_update_device(dev);
499 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
501 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
504 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
505 int nr = sensor_attr->index;
507 struct it87_data *data = it87_update_device(dev);
508 return sprintf(buf,"%d\n", (data->fan_main_ctrl & (1 << nr)) ? 1 : 0);
510 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
513 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
514 int nr = sensor_attr->index;
516 struct it87_data *data = it87_update_device(dev);
517 return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]);
519 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
520 const char *buf, size_t count)
522 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
523 int nr = sensor_attr->index;
525 struct i2c_client *client = to_i2c_client(dev);
526 struct it87_data *data = i2c_get_clientdata(client);
527 int val = simple_strtol(buf, NULL, 10);
528 u8 reg = it87_read_value(client, IT87_REG_FAN_DIV);
530 down(&data->update_lock);
532 case 0: data->fan_div[nr] = reg & 0x07; break;
533 case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
534 case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break;
537 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
538 it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
539 up(&data->update_lock);
542 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
543 const char *buf, size_t count)
545 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
546 int nr = sensor_attr->index;
548 struct i2c_client *client = to_i2c_client(dev);
549 struct it87_data *data = i2c_get_clientdata(client);
550 int val = simple_strtol(buf, NULL, 10);
554 down(&data->update_lock);
555 old = it87_read_value(client, IT87_REG_FAN_DIV);
557 for (i = 0; i < 3; i++)
558 min[i] = FAN_FROM_REG(data->fan_min[i], DIV_FROM_REG(data->fan_div[i]));
563 data->fan_div[nr] = DIV_TO_REG(val);
567 data->fan_div[nr] = 1;
569 data->fan_div[nr] = 3;
572 val |= (data->fan_div[0] & 0x07);
573 val |= (data->fan_div[1] & 0x07) << 3;
574 if (data->fan_div[2] == 3)
576 it87_write_value(client, IT87_REG_FAN_DIV, val);
578 for (i = 0; i < 3; i++) {
579 data->fan_min[i]=FAN_TO_REG(min[i], DIV_FROM_REG(data->fan_div[i]));
580 it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]);
582 up(&data->update_lock);
585 static ssize_t set_pwm_enable(struct device *dev,
586 struct device_attribute *attr, const char *buf, size_t count)
588 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
589 int nr = sensor_attr->index;
591 struct i2c_client *client = to_i2c_client(dev);
592 struct it87_data *data = i2c_get_clientdata(client);
593 int val = simple_strtol(buf, NULL, 10);
595 down(&data->update_lock);
599 /* make sure the fan is on when in on/off mode */
600 tmp = it87_read_value(client, IT87_REG_FAN_CTL);
601 it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr));
602 /* set on/off mode */
603 data->fan_main_ctrl &= ~(1 << nr);
604 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
605 } else if (val == 1) {
606 /* set SmartGuardian mode */
607 data->fan_main_ctrl |= (1 << nr);
608 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
609 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
610 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
612 up(&data->update_lock);
616 up(&data->update_lock);
619 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
620 const char *buf, size_t count)
622 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
623 int nr = sensor_attr->index;
625 struct i2c_client *client = to_i2c_client(dev);
626 struct it87_data *data = i2c_get_clientdata(client);
627 int val = simple_strtol(buf, NULL, 10);
629 if (val < 0 || val > 255)
632 down(&data->update_lock);
633 data->manual_pwm_ctl[nr] = val;
634 if (data->fan_main_ctrl & (1 << nr))
635 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
636 up(&data->update_lock);
640 #define show_fan_offset(offset) \
641 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
642 show_fan, NULL, offset - 1); \
643 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
644 show_fan_min, set_fan_min, offset - 1); \
645 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
646 show_fan_div, set_fan_div, offset - 1);
652 #define show_pwm_offset(offset) \
653 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
654 show_pwm_enable, set_pwm_enable, offset - 1); \
655 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
656 show_pwm, set_pwm, offset - 1);
663 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
665 struct it87_data *data = it87_update_device(dev);
666 return sprintf(buf, "%u\n", data->alarms);
668 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
671 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
673 struct it87_data *data = it87_update_device(dev);
674 return sprintf(buf, "%ld\n", (long) data->vrm);
677 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
679 struct i2c_client *client = to_i2c_client(dev);
680 struct it87_data *data = i2c_get_clientdata(client);
683 val = simple_strtoul(buf, NULL, 10);
688 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
689 #define device_create_file_vrm(client) \
690 device_create_file(&client->dev, &dev_attr_vrm)
693 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
695 struct it87_data *data = it87_update_device(dev);
696 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
698 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
699 #define device_create_file_vid(client) \
700 device_create_file(&client->dev, &dev_attr_cpu0_vid)
702 /* This function is called when:
703 * it87_driver is inserted (when this module is loaded), for each
705 * when a new adapter is inserted (and it87_driver is still present) */
706 static int it87_attach_adapter(struct i2c_adapter *adapter)
708 if (!(adapter->class & I2C_CLASS_HWMON))
710 return i2c_probe(adapter, &addr_data, it87_detect);
713 static int it87_isa_attach_adapter(struct i2c_adapter *adapter)
715 return it87_detect(adapter, isa_address, -1);
718 /* SuperIO detection - will change isa_address if a chip is found */
719 static int __init it87_find(unsigned short *address)
724 chip_type = superio_inw(DEVID);
725 if (chip_type != IT8712F_DEVID
726 && chip_type != IT8705F_DEVID)
730 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
731 pr_info("it87: Device not activated, skipping\n");
735 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
737 pr_info("it87: Base address not set, skipping\n");
742 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
743 chip_type, *address, superio_inb(DEVREV) & 0x0f);
750 /* This function is called by i2c_probe */
751 static int it87_detect(struct i2c_adapter *adapter, int address, int kind)
754 struct i2c_client *new_client;
755 struct it87_data *data;
757 const char *name = "";
758 int is_isa = i2c_is_isa_adapter(adapter);
759 int enable_pwm_interface;
762 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
765 /* Reserve the ISA region */
767 if (!request_region(address, IT87_EXTENT,
768 it87_isa_driver.driver.name))
771 /* For now, we presume we have a valid client. We create the
772 client structure, even though we cannot fill it completely yet.
773 But it allows us to access it87_{read,write}_value. */
775 if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
780 new_client = &data->client;
782 init_MUTEX(&data->lock);
783 i2c_set_clientdata(new_client, data);
784 new_client->addr = address;
785 new_client->adapter = adapter;
786 new_client->driver = is_isa ? &it87_isa_driver : &it87_driver;
787 new_client->flags = 0;
789 /* Now, we do the remaining detection. */
792 if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
794 && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) {
800 /* Determine the chip type. */
802 i = it87_read_value(new_client, IT87_REG_CHIPID);
805 if ((is_isa) && (chip_type == IT8712F_DEVID))
810 dev_info(&adapter->dev,
811 "Ignoring 'force' parameter for unknown chip at "
812 "adapter %d, address 0x%02x\n",
813 i2c_adapter_id(adapter), address);
821 } else if (kind == it8712) {
825 /* Fill in the remaining client fields and put it into the global list */
826 strlcpy(new_client->name, name, I2C_NAME_SIZE);
829 init_MUTEX(&data->update_lock);
831 /* Tell the I2C layer a new client has arrived */
832 if ((err = i2c_attach_client(new_client)))
835 /* Check PWM configuration */
836 enable_pwm_interface = it87_check_pwm(new_client);
838 /* Initialize the IT87 chip */
839 it87_init_client(new_client, data);
841 /* Register sysfs hooks */
842 data->class_dev = hwmon_device_register(&new_client->dev);
843 if (IS_ERR(data->class_dev)) {
844 err = PTR_ERR(data->class_dev);
848 device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
849 device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
850 device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
851 device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
852 device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
853 device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
854 device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
855 device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr);
856 device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr);
857 device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
858 device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
859 device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
860 device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
861 device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
862 device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
863 device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
864 device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr);
865 device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
866 device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
867 device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
868 device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
869 device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
870 device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
871 device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
872 device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr);
873 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
874 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
875 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
876 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
877 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
878 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
879 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
880 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
881 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
882 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr);
883 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr);
884 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr);
885 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr);
886 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr);
887 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr);
888 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr);
889 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr);
890 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr);
891 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr);
892 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr);
893 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr);
894 device_create_file(&new_client->dev, &dev_attr_alarms);
895 if (enable_pwm_interface) {
896 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr);
897 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr);
898 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr);
899 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
900 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
901 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
904 if (data->type == it8712) {
905 data->vrm = vid_which_vrm();
906 device_create_file_vrm(new_client);
907 device_create_file_vid(new_client);
913 i2c_detach_client(new_client);
918 release_region(address, IT87_EXTENT);
923 static int it87_detach_client(struct i2c_client *client)
925 struct it87_data *data = i2c_get_clientdata(client);
928 hwmon_device_unregister(data->class_dev);
930 if ((err = i2c_detach_client(client)))
933 if(i2c_is_isa_client(client))
934 release_region(client->addr, IT87_EXTENT);
940 /* The SMBus locks itself, but ISA access must be locked explicitly!
941 We don't want to lock the whole ISA bus, so we lock each client
943 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
944 would slow down the IT87 access and should not be necessary. */
945 static int it87_read_value(struct i2c_client *client, u8 reg)
947 struct it87_data *data = i2c_get_clientdata(client);
950 if (i2c_is_isa_client(client)) {
952 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
953 res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
957 return i2c_smbus_read_byte_data(client, reg);
960 /* The SMBus locks itself, but ISA access muse be locked explicitly!
961 We don't want to lock the whole ISA bus, so we lock each client
963 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
964 would slow down the IT87 access and should not be necessary. */
965 static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
967 struct it87_data *data = i2c_get_clientdata(client);
969 if (i2c_is_isa_client(client)) {
971 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
972 outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
976 return i2c_smbus_write_byte_data(client, reg, value);
979 /* Return 1 if and only if the PWM interface is safe to use */
980 static int it87_check_pwm(struct i2c_client *client)
982 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
983 * and polarity set to active low is sign that this is the case so we
984 * disable pwm control to protect the user. */
985 int tmp = it87_read_value(client, IT87_REG_FAN_CTL);
986 if ((tmp & 0x87) == 0) {
987 if (fix_pwm_polarity) {
988 /* The user asks us to attempt a chip reconfiguration.
989 * This means switching to active high polarity and
990 * inverting all fan speed values. */
994 for (i = 0; i < 3; i++)
995 pwm[i] = it87_read_value(client,
998 /* If any fan is in automatic pwm mode, the polarity
999 * might be correct, as suspicious as it seems, so we
1000 * better don't change anything (but still disable the
1001 * PWM interface). */
1002 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1003 dev_info(&client->dev, "Reconfiguring PWM to "
1004 "active high polarity\n");
1005 it87_write_value(client, IT87_REG_FAN_CTL,
1007 for (i = 0; i < 3; i++)
1008 it87_write_value(client,
1014 dev_info(&client->dev, "PWM configuration is "
1015 "too broken to be fixed\n");
1018 dev_info(&client->dev, "Detected broken BIOS "
1019 "defaults, disabling PWM interface\n");
1021 } else if (fix_pwm_polarity) {
1022 dev_info(&client->dev, "PWM configuration looks "
1023 "sane, won't touch\n");
1029 /* Called when we have found a new IT87. */
1030 static void it87_init_client(struct i2c_client *client, struct it87_data *data)
1034 /* initialize to sane defaults:
1035 * - if the chip is in manual pwm mode, this will be overwritten with
1036 * the actual settings on the chip (so in this case, initialization
1038 * - if in automatic or on/off mode, we could switch to manual mode,
1039 * read the registers and set manual_pwm_ctl accordingly, but currently
1040 * this is not implemented, so we initialize to something sane */
1041 for (i = 0; i < 3; i++) {
1042 data->manual_pwm_ctl[i] = 0xff;
1045 /* Check if temperature channnels are reset manually or by some reason */
1046 tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1047 if ((tmp & 0x3f) == 0) {
1048 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1049 tmp = (tmp & 0xc0) | 0x2a;
1050 it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
1054 /* Check if voltage monitors are reset manually or by some reason */
1055 tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
1056 if ((tmp & 0xff) == 0) {
1057 /* Enable all voltage monitors */
1058 it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
1061 /* Check if tachometers are reset manually or by some reason */
1062 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1063 if ((data->fan_main_ctrl & 0x70) == 0) {
1064 /* Enable all fan tachometers */
1065 data->fan_main_ctrl |= 0x70;
1066 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1069 /* Set current fan mode registers and the default settings for the
1070 * other mode registers */
1071 for (i = 0; i < 3; i++) {
1072 if (data->fan_main_ctrl & (1 << i)) {
1074 tmp = it87_read_value(client, IT87_REG_PWM(i));
1076 /* automatic pwm - not yet implemented, but
1077 * leave the settings made by the BIOS alone
1078 * until a change is requested via the sysfs
1082 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1087 /* Start monitoring */
1088 it87_write_value(client, IT87_REG_CONFIG,
1089 (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
1090 | (update_vbat ? 0x41 : 0x01));
1093 static struct it87_data *it87_update_device(struct device *dev)
1095 struct i2c_client *client = to_i2c_client(dev);
1096 struct it87_data *data = i2c_get_clientdata(client);
1099 down(&data->update_lock);
1101 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1105 /* Cleared after each update, so reenable. Value
1106 returned by this read will be previous value */
1107 it87_write_value(client, IT87_REG_CONFIG,
1108 it87_read_value(client, IT87_REG_CONFIG) | 0x40);
1110 for (i = 0; i <= 7; i++) {
1112 it87_read_value(client, IT87_REG_VIN(i));
1114 it87_read_value(client, IT87_REG_VIN_MIN(i));
1116 it87_read_value(client, IT87_REG_VIN_MAX(i));
1119 it87_read_value(client, IT87_REG_VIN(8));
1120 /* Temperature sensor doesn't have limit registers, set
1121 to min and max value */
1122 data->in_min[8] = 0;
1123 data->in_max[8] = 255;
1125 for (i = 0; i < 3; i++) {
1127 it87_read_value(client, IT87_REG_FAN(i));
1129 it87_read_value(client, IT87_REG_FAN_MIN(i));
1131 for (i = 0; i < 3; i++) {
1133 it87_read_value(client, IT87_REG_TEMP(i));
1134 data->temp_high[i] =
1135 it87_read_value(client, IT87_REG_TEMP_HIGH(i));
1137 it87_read_value(client, IT87_REG_TEMP_LOW(i));
1140 i = it87_read_value(client, IT87_REG_FAN_DIV);
1141 data->fan_div[0] = i & 0x07;
1142 data->fan_div[1] = (i >> 3) & 0x07;
1143 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1146 it87_read_value(client, IT87_REG_ALARM1) |
1147 (it87_read_value(client, IT87_REG_ALARM2) << 8) |
1148 (it87_read_value(client, IT87_REG_ALARM3) << 16);
1149 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1151 data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1152 /* The 8705 does not have VID capability */
1153 if (data->type == it8712) {
1154 data->vid = it87_read_value(client, IT87_REG_VID);
1157 data->last_updated = jiffies;
1161 up(&data->update_lock);
1166 static int __init sm_it87_init(void)
1170 res = i2c_add_driver(&it87_driver);
1174 if (!it87_find(&isa_address)) {
1175 res = i2c_isa_add_driver(&it87_isa_driver);
1177 i2c_del_driver(&it87_driver);
1185 static void __exit sm_it87_exit(void)
1187 i2c_isa_del_driver(&it87_isa_driver);
1188 i2c_del_driver(&it87_driver);
1192 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
1193 MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
1194 module_param(update_vbat, bool, 0);
1195 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1196 module_param(fix_pwm_polarity, bool, 0);
1197 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1198 MODULE_LICENSE("GPL");
1200 module_init(sm_it87_init);
1201 module_exit(sm_it87_exit);