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
= {
237 .owner
= THIS_MODULE
,
239 .id
= I2C_DRIVERID_IT87
,
240 .flags
= I2C_DF_NOTIFY
,
241 .attach_adapter
= it87_attach_adapter
,
242 .detach_client
= it87_detach_client
,
245 static struct i2c_driver it87_isa_driver
= {
246 .owner
= THIS_MODULE
,
248 .attach_adapter
= it87_isa_attach_adapter
,
249 .detach_client
= it87_detach_client
,
253 static ssize_t
show_in(struct device
*dev
, struct device_attribute
*attr
,
256 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
257 int nr
= sensor_attr
->index
;
259 struct it87_data
*data
= it87_update_device(dev
);
260 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in
[nr
]));
263 static ssize_t
show_in_min(struct device
*dev
, struct device_attribute
*attr
,
266 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
267 int nr
= sensor_attr
->index
;
269 struct it87_data
*data
= it87_update_device(dev
);
270 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_min
[nr
]));
273 static ssize_t
show_in_max(struct device
*dev
, struct device_attribute
*attr
,
276 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
277 int nr
= sensor_attr
->index
;
279 struct it87_data
*data
= it87_update_device(dev
);
280 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_max
[nr
]));
283 static ssize_t
set_in_min(struct device
*dev
, struct device_attribute
*attr
,
284 const char *buf
, size_t count
)
286 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
287 int nr
= sensor_attr
->index
;
289 struct i2c_client
*client
= to_i2c_client(dev
);
290 struct it87_data
*data
= i2c_get_clientdata(client
);
291 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
293 down(&data
->update_lock
);
294 data
->in_min
[nr
] = IN_TO_REG(val
);
295 it87_write_value(client
, IT87_REG_VIN_MIN(nr
),
297 up(&data
->update_lock
);
300 static ssize_t
set_in_max(struct device
*dev
, struct device_attribute
*attr
,
301 const char *buf
, size_t count
)
303 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
304 int nr
= sensor_attr
->index
;
306 struct i2c_client
*client
= to_i2c_client(dev
);
307 struct it87_data
*data
= i2c_get_clientdata(client
);
308 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
310 down(&data
->update_lock
);
311 data
->in_max
[nr
] = IN_TO_REG(val
);
312 it87_write_value(client
, IT87_REG_VIN_MAX(nr
),
314 up(&data
->update_lock
);
318 #define show_in_offset(offset) \
319 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
320 show_in, NULL, offset);
322 #define limit_in_offset(offset) \
323 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
324 show_in_min, set_in_min, offset); \
325 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
326 show_in_max, set_in_max, offset);
347 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*attr
,
350 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
351 int nr
= sensor_attr
->index
;
353 struct it87_data
*data
= it87_update_device(dev
);
354 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp
[nr
]));
356 static ssize_t
show_temp_max(struct device
*dev
, struct device_attribute
*attr
,
359 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
360 int nr
= sensor_attr
->index
;
362 struct it87_data
*data
= it87_update_device(dev
);
363 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_high
[nr
]));
365 static ssize_t
show_temp_min(struct device
*dev
, struct device_attribute
*attr
,
368 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
369 int nr
= sensor_attr
->index
;
371 struct it87_data
*data
= it87_update_device(dev
);
372 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_low
[nr
]));
374 static ssize_t
set_temp_max(struct device
*dev
, struct device_attribute
*attr
,
375 const char *buf
, size_t count
)
377 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
378 int nr
= sensor_attr
->index
;
380 struct i2c_client
*client
= to_i2c_client(dev
);
381 struct it87_data
*data
= i2c_get_clientdata(client
);
382 int val
= simple_strtol(buf
, NULL
, 10);
384 down(&data
->update_lock
);
385 data
->temp_high
[nr
] = TEMP_TO_REG(val
);
386 it87_write_value(client
, IT87_REG_TEMP_HIGH(nr
), data
->temp_high
[nr
]);
387 up(&data
->update_lock
);
390 static ssize_t
set_temp_min(struct device
*dev
, struct device_attribute
*attr
,
391 const char *buf
, size_t count
)
393 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
394 int nr
= sensor_attr
->index
;
396 struct i2c_client
*client
= to_i2c_client(dev
);
397 struct it87_data
*data
= i2c_get_clientdata(client
);
398 int val
= simple_strtol(buf
, NULL
, 10);
400 down(&data
->update_lock
);
401 data
->temp_low
[nr
] = TEMP_TO_REG(val
);
402 it87_write_value(client
, IT87_REG_TEMP_LOW(nr
), data
->temp_low
[nr
]);
403 up(&data
->update_lock
);
406 #define show_temp_offset(offset) \
407 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
408 show_temp, NULL, offset - 1); \
409 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
410 show_temp_max, set_temp_max, offset - 1); \
411 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
412 show_temp_min, set_temp_min, offset - 1);
418 static ssize_t
show_sensor(struct device
*dev
, struct device_attribute
*attr
,
421 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
422 int nr
= sensor_attr
->index
;
424 struct it87_data
*data
= it87_update_device(dev
);
425 u8 reg
= data
->sensor
; /* In case the value is updated while we use it */
428 return sprintf(buf
, "3\n"); /* thermal diode */
430 return sprintf(buf
, "2\n"); /* thermistor */
431 return sprintf(buf
, "0\n"); /* disabled */
433 static ssize_t
set_sensor(struct device
*dev
, struct device_attribute
*attr
,
434 const char *buf
, size_t count
)
436 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
437 int nr
= sensor_attr
->index
;
439 struct i2c_client
*client
= to_i2c_client(dev
);
440 struct it87_data
*data
= i2c_get_clientdata(client
);
441 int val
= simple_strtol(buf
, NULL
, 10);
443 down(&data
->update_lock
);
445 data
->sensor
&= ~(1 << nr
);
446 data
->sensor
&= ~(8 << nr
);
447 /* 3 = thermal diode; 2 = thermistor; 0 = disabled */
449 data
->sensor
|= 1 << nr
;
451 data
->sensor
|= 8 << nr
;
453 up(&data
->update_lock
);
456 it87_write_value(client
, IT87_REG_TEMP_ENABLE
, data
->sensor
);
457 up(&data
->update_lock
);
460 #define show_sensor_offset(offset) \
461 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
462 show_sensor, set_sensor, offset - 1);
464 show_sensor_offset(1);
465 show_sensor_offset(2);
466 show_sensor_offset(3);
469 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*attr
,
472 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
473 int nr
= sensor_attr
->index
;
475 struct it87_data
*data
= it87_update_device(dev
);
476 return sprintf(buf
,"%d\n", FAN_FROM_REG(data
->fan
[nr
],
477 DIV_FROM_REG(data
->fan_div
[nr
])));
479 static ssize_t
show_fan_min(struct device
*dev
, struct device_attribute
*attr
,
482 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
483 int nr
= sensor_attr
->index
;
485 struct it87_data
*data
= it87_update_device(dev
);
486 return sprintf(buf
,"%d\n",
487 FAN_FROM_REG(data
->fan_min
[nr
], DIV_FROM_REG(data
->fan_div
[nr
])));
489 static ssize_t
show_fan_div(struct device
*dev
, struct device_attribute
*attr
,
492 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
493 int nr
= sensor_attr
->index
;
495 struct it87_data
*data
= it87_update_device(dev
);
496 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[nr
]));
498 static ssize_t
show_pwm_enable(struct device
*dev
, struct device_attribute
*attr
,
501 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
502 int nr
= sensor_attr
->index
;
504 struct it87_data
*data
= it87_update_device(dev
);
505 return sprintf(buf
,"%d\n", (data
->fan_main_ctrl
& (1 << nr
)) ? 1 : 0);
507 static ssize_t
show_pwm(struct device
*dev
, struct device_attribute
*attr
,
510 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
511 int nr
= sensor_attr
->index
;
513 struct it87_data
*data
= it87_update_device(dev
);
514 return sprintf(buf
,"%d\n", data
->manual_pwm_ctl
[nr
]);
516 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*attr
,
517 const char *buf
, size_t count
)
519 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
520 int nr
= sensor_attr
->index
;
522 struct i2c_client
*client
= to_i2c_client(dev
);
523 struct it87_data
*data
= i2c_get_clientdata(client
);
524 int val
= simple_strtol(buf
, NULL
, 10);
526 down(&data
->update_lock
);
527 data
->fan_min
[nr
] = FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
528 it87_write_value(client
, IT87_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
529 up(&data
->update_lock
);
532 static ssize_t
set_fan_div(struct device
*dev
, struct device_attribute
*attr
,
533 const char *buf
, size_t count
)
535 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
536 int nr
= sensor_attr
->index
;
538 struct i2c_client
*client
= to_i2c_client(dev
);
539 struct it87_data
*data
= i2c_get_clientdata(client
);
540 int val
= simple_strtol(buf
, NULL
, 10);
544 down(&data
->update_lock
);
545 old
= it87_read_value(client
, IT87_REG_FAN_DIV
);
547 for (i
= 0; i
< 3; i
++)
548 min
[i
] = FAN_FROM_REG(data
->fan_min
[i
], DIV_FROM_REG(data
->fan_div
[i
]));
553 data
->fan_div
[nr
] = DIV_TO_REG(val
);
557 data
->fan_div
[nr
] = 1;
559 data
->fan_div
[nr
] = 3;
562 val
|= (data
->fan_div
[0] & 0x07);
563 val
|= (data
->fan_div
[1] & 0x07) << 3;
564 if (data
->fan_div
[2] == 3)
566 it87_write_value(client
, IT87_REG_FAN_DIV
, val
);
568 for (i
= 0; i
< 3; i
++) {
569 data
->fan_min
[i
]=FAN_TO_REG(min
[i
], DIV_FROM_REG(data
->fan_div
[i
]));
570 it87_write_value(client
, IT87_REG_FAN_MIN(i
), data
->fan_min
[i
]);
572 up(&data
->update_lock
);
575 static ssize_t
set_pwm_enable(struct device
*dev
,
576 struct device_attribute
*attr
, const char *buf
, size_t count
)
578 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
579 int nr
= sensor_attr
->index
;
581 struct i2c_client
*client
= to_i2c_client(dev
);
582 struct it87_data
*data
= i2c_get_clientdata(client
);
583 int val
= simple_strtol(buf
, NULL
, 10);
585 down(&data
->update_lock
);
589 /* make sure the fan is on when in on/off mode */
590 tmp
= it87_read_value(client
, IT87_REG_FAN_CTL
);
591 it87_write_value(client
, IT87_REG_FAN_CTL
, tmp
| (1 << nr
));
592 /* set on/off mode */
593 data
->fan_main_ctrl
&= ~(1 << nr
);
594 it87_write_value(client
, IT87_REG_FAN_MAIN_CTRL
, data
->fan_main_ctrl
);
595 } else if (val
== 1) {
596 /* set SmartGuardian mode */
597 data
->fan_main_ctrl
|= (1 << nr
);
598 it87_write_value(client
, IT87_REG_FAN_MAIN_CTRL
, data
->fan_main_ctrl
);
599 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
600 it87_write_value(client
, IT87_REG_PWM(nr
), PWM_TO_REG(data
->manual_pwm_ctl
[nr
]));
602 up(&data
->update_lock
);
606 up(&data
->update_lock
);
609 static ssize_t
set_pwm(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 i2c_client
*client
= to_i2c_client(dev
);
616 struct it87_data
*data
= i2c_get_clientdata(client
);
617 int val
= simple_strtol(buf
, NULL
, 10);
619 if (val
< 0 || val
> 255)
622 down(&data
->update_lock
);
623 data
->manual_pwm_ctl
[nr
] = val
;
624 if (data
->fan_main_ctrl
& (1 << nr
))
625 it87_write_value(client
, IT87_REG_PWM(nr
), PWM_TO_REG(data
->manual_pwm_ctl
[nr
]));
626 up(&data
->update_lock
);
630 #define show_fan_offset(offset) \
631 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
632 show_fan, NULL, offset - 1); \
633 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
634 show_fan_min, set_fan_min, offset - 1); \
635 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
636 show_fan_div, set_fan_div, offset - 1);
642 #define show_pwm_offset(offset) \
643 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
644 show_pwm_enable, set_pwm_enable, offset - 1); \
645 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
646 show_pwm, set_pwm, offset - 1);
653 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
655 struct it87_data
*data
= it87_update_device(dev
);
656 return sprintf(buf
, "%u\n", data
->alarms
);
658 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
661 show_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
663 struct it87_data
*data
= it87_update_device(dev
);
664 return sprintf(buf
, "%ld\n", (long) data
->vrm
);
667 store_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
669 struct i2c_client
*client
= to_i2c_client(dev
);
670 struct it87_data
*data
= i2c_get_clientdata(client
);
673 val
= simple_strtoul(buf
, NULL
, 10);
678 static DEVICE_ATTR(vrm
, S_IRUGO
| S_IWUSR
, show_vrm_reg
, store_vrm_reg
);
679 #define device_create_file_vrm(client) \
680 device_create_file(&client->dev, &dev_attr_vrm)
683 show_vid_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
685 struct it87_data
*data
= it87_update_device(dev
);
686 return sprintf(buf
, "%ld\n", (long) vid_from_reg(data
->vid
, data
->vrm
));
688 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid_reg
, NULL
);
689 #define device_create_file_vid(client) \
690 device_create_file(&client->dev, &dev_attr_cpu0_vid)
692 /* This function is called when:
693 * it87_driver is inserted (when this module is loaded), for each
695 * when a new adapter is inserted (and it87_driver is still present) */
696 static int it87_attach_adapter(struct i2c_adapter
*adapter
)
698 if (!(adapter
->class & I2C_CLASS_HWMON
))
700 return i2c_probe(adapter
, &addr_data
, it87_detect
);
703 static int it87_isa_attach_adapter(struct i2c_adapter
*adapter
)
705 return it87_detect(adapter
, isa_address
, -1);
708 /* SuperIO detection - will change isa_address if a chip is found */
709 static int __init
it87_find(unsigned short *address
)
714 chip_type
= superio_inw(DEVID
);
715 if (chip_type
!= IT8712F_DEVID
716 && chip_type
!= IT8705F_DEVID
)
720 if (!(superio_inb(IT87_ACT_REG
) & 0x01)) {
721 pr_info("it87: Device not activated, skipping\n");
725 *address
= superio_inw(IT87_BASE_REG
) & ~(IT87_EXTENT
- 1);
727 pr_info("it87: Base address not set, skipping\n");
732 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
733 chip_type
, *address
, superio_inb(DEVREV
) & 0x0f);
740 /* This function is called by i2c_probe */
741 static int it87_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
744 struct i2c_client
*new_client
;
745 struct it87_data
*data
;
747 const char *name
= "";
748 int is_isa
= i2c_is_isa_adapter(adapter
);
749 int enable_pwm_interface
;
752 !i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
755 /* Reserve the ISA region */
757 if (!request_region(address
, IT87_EXTENT
, it87_isa_driver
.name
))
760 /* For now, we presume we have a valid client. We create the
761 client structure, even though we cannot fill it completely yet.
762 But it allows us to access it87_{read,write}_value. */
764 if (!(data
= kzalloc(sizeof(struct it87_data
), GFP_KERNEL
))) {
769 new_client
= &data
->client
;
771 init_MUTEX(&data
->lock
);
772 i2c_set_clientdata(new_client
, data
);
773 new_client
->addr
= address
;
774 new_client
->adapter
= adapter
;
775 new_client
->driver
= is_isa
? &it87_isa_driver
: &it87_driver
;
776 new_client
->flags
= 0;
778 /* Now, we do the remaining detection. */
781 if ((it87_read_value(new_client
, IT87_REG_CONFIG
) & 0x80)
783 && it87_read_value(new_client
, IT87_REG_I2C_ADDR
) != address
)) {
789 /* Determine the chip type. */
791 i
= it87_read_value(new_client
, IT87_REG_CHIPID
);
794 if ((is_isa
) && (chip_type
== IT8712F_DEVID
))
799 dev_info(&adapter
->dev
,
800 "Ignoring 'force' parameter for unknown chip at "
801 "adapter %d, address 0x%02x\n",
802 i2c_adapter_id(adapter
), address
);
810 } else if (kind
== it8712
) {
814 /* Fill in the remaining client fields and put it into the global list */
815 strlcpy(new_client
->name
, name
, I2C_NAME_SIZE
);
818 init_MUTEX(&data
->update_lock
);
820 /* Tell the I2C layer a new client has arrived */
821 if ((err
= i2c_attach_client(new_client
)))
824 /* Check PWM configuration */
825 enable_pwm_interface
= it87_check_pwm(new_client
);
827 /* Initialize the IT87 chip */
828 it87_init_client(new_client
, data
);
830 /* Register sysfs hooks */
831 data
->class_dev
= hwmon_device_register(&new_client
->dev
);
832 if (IS_ERR(data
->class_dev
)) {
833 err
= PTR_ERR(data
->class_dev
);
837 device_create_file(&new_client
->dev
, &sensor_dev_attr_in0_input
.dev_attr
);
838 device_create_file(&new_client
->dev
, &sensor_dev_attr_in1_input
.dev_attr
);
839 device_create_file(&new_client
->dev
, &sensor_dev_attr_in2_input
.dev_attr
);
840 device_create_file(&new_client
->dev
, &sensor_dev_attr_in3_input
.dev_attr
);
841 device_create_file(&new_client
->dev
, &sensor_dev_attr_in4_input
.dev_attr
);
842 device_create_file(&new_client
->dev
, &sensor_dev_attr_in5_input
.dev_attr
);
843 device_create_file(&new_client
->dev
, &sensor_dev_attr_in6_input
.dev_attr
);
844 device_create_file(&new_client
->dev
, &sensor_dev_attr_in7_input
.dev_attr
);
845 device_create_file(&new_client
->dev
, &sensor_dev_attr_in8_input
.dev_attr
);
846 device_create_file(&new_client
->dev
, &sensor_dev_attr_in0_min
.dev_attr
);
847 device_create_file(&new_client
->dev
, &sensor_dev_attr_in1_min
.dev_attr
);
848 device_create_file(&new_client
->dev
, &sensor_dev_attr_in2_min
.dev_attr
);
849 device_create_file(&new_client
->dev
, &sensor_dev_attr_in3_min
.dev_attr
);
850 device_create_file(&new_client
->dev
, &sensor_dev_attr_in4_min
.dev_attr
);
851 device_create_file(&new_client
->dev
, &sensor_dev_attr_in5_min
.dev_attr
);
852 device_create_file(&new_client
->dev
, &sensor_dev_attr_in6_min
.dev_attr
);
853 device_create_file(&new_client
->dev
, &sensor_dev_attr_in7_min
.dev_attr
);
854 device_create_file(&new_client
->dev
, &sensor_dev_attr_in0_max
.dev_attr
);
855 device_create_file(&new_client
->dev
, &sensor_dev_attr_in1_max
.dev_attr
);
856 device_create_file(&new_client
->dev
, &sensor_dev_attr_in2_max
.dev_attr
);
857 device_create_file(&new_client
->dev
, &sensor_dev_attr_in3_max
.dev_attr
);
858 device_create_file(&new_client
->dev
, &sensor_dev_attr_in4_max
.dev_attr
);
859 device_create_file(&new_client
->dev
, &sensor_dev_attr_in5_max
.dev_attr
);
860 device_create_file(&new_client
->dev
, &sensor_dev_attr_in6_max
.dev_attr
);
861 device_create_file(&new_client
->dev
, &sensor_dev_attr_in7_max
.dev_attr
);
862 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp1_input
.dev_attr
);
863 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp2_input
.dev_attr
);
864 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp3_input
.dev_attr
);
865 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp1_max
.dev_attr
);
866 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp2_max
.dev_attr
);
867 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp3_max
.dev_attr
);
868 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp1_min
.dev_attr
);
869 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp2_min
.dev_attr
);
870 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp3_min
.dev_attr
);
871 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp1_type
.dev_attr
);
872 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp2_type
.dev_attr
);
873 device_create_file(&new_client
->dev
, &sensor_dev_attr_temp3_type
.dev_attr
);
874 device_create_file(&new_client
->dev
, &sensor_dev_attr_fan1_input
.dev_attr
);
875 device_create_file(&new_client
->dev
, &sensor_dev_attr_fan2_input
.dev_attr
);
876 device_create_file(&new_client
->dev
, &sensor_dev_attr_fan3_input
.dev_attr
);
877 device_create_file(&new_client
->dev
, &sensor_dev_attr_fan1_min
.dev_attr
);
878 device_create_file(&new_client
->dev
, &sensor_dev_attr_fan2_min
.dev_attr
);
879 device_create_file(&new_client
->dev
, &sensor_dev_attr_fan3_min
.dev_attr
);
880 device_create_file(&new_client
->dev
, &sensor_dev_attr_fan1_div
.dev_attr
);
881 device_create_file(&new_client
->dev
, &sensor_dev_attr_fan2_div
.dev_attr
);
882 device_create_file(&new_client
->dev
, &sensor_dev_attr_fan3_div
.dev_attr
);
883 device_create_file(&new_client
->dev
, &dev_attr_alarms
);
884 if (enable_pwm_interface
) {
885 device_create_file(&new_client
->dev
, &sensor_dev_attr_pwm1_enable
.dev_attr
);
886 device_create_file(&new_client
->dev
, &sensor_dev_attr_pwm2_enable
.dev_attr
);
887 device_create_file(&new_client
->dev
, &sensor_dev_attr_pwm3_enable
.dev_attr
);
888 device_create_file(&new_client
->dev
, &sensor_dev_attr_pwm1
.dev_attr
);
889 device_create_file(&new_client
->dev
, &sensor_dev_attr_pwm2
.dev_attr
);
890 device_create_file(&new_client
->dev
, &sensor_dev_attr_pwm3
.dev_attr
);
893 if (data
->type
== it8712
) {
894 data
->vrm
= vid_which_vrm();
895 device_create_file_vrm(new_client
);
896 device_create_file_vid(new_client
);
902 i2c_detach_client(new_client
);
907 release_region(address
, IT87_EXTENT
);
912 static int it87_detach_client(struct i2c_client
*client
)
914 struct it87_data
*data
= i2c_get_clientdata(client
);
917 hwmon_device_unregister(data
->class_dev
);
919 if ((err
= i2c_detach_client(client
)))
922 if(i2c_is_isa_client(client
))
923 release_region(client
->addr
, IT87_EXTENT
);
929 /* The SMBus locks itself, but ISA access must be locked explicitly!
930 We don't want to lock the whole ISA bus, so we lock each client
932 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
933 would slow down the IT87 access and should not be necessary. */
934 static int it87_read_value(struct i2c_client
*client
, u8 reg
)
936 struct it87_data
*data
= i2c_get_clientdata(client
);
939 if (i2c_is_isa_client(client
)) {
941 outb_p(reg
, client
->addr
+ IT87_ADDR_REG_OFFSET
);
942 res
= inb_p(client
->addr
+ IT87_DATA_REG_OFFSET
);
946 return i2c_smbus_read_byte_data(client
, reg
);
949 /* The SMBus locks itself, but ISA access muse be locked explicitly!
950 We don't want to lock the whole ISA bus, so we lock each client
952 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
953 would slow down the IT87 access and should not be necessary. */
954 static int it87_write_value(struct i2c_client
*client
, u8 reg
, u8 value
)
956 struct it87_data
*data
= i2c_get_clientdata(client
);
958 if (i2c_is_isa_client(client
)) {
960 outb_p(reg
, client
->addr
+ IT87_ADDR_REG_OFFSET
);
961 outb_p(value
, client
->addr
+ IT87_DATA_REG_OFFSET
);
965 return i2c_smbus_write_byte_data(client
, reg
, value
);
968 /* Return 1 if and only if the PWM interface is safe to use */
969 static int it87_check_pwm(struct i2c_client
*client
)
971 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
972 * and polarity set to active low is sign that this is the case so we
973 * disable pwm control to protect the user. */
974 int tmp
= it87_read_value(client
, IT87_REG_FAN_CTL
);
975 if ((tmp
& 0x87) == 0) {
976 if (fix_pwm_polarity
) {
977 /* The user asks us to attempt a chip reconfiguration.
978 * This means switching to active high polarity and
979 * inverting all fan speed values. */
983 for (i
= 0; i
< 3; i
++)
984 pwm
[i
] = it87_read_value(client
,
987 /* If any fan is in automatic pwm mode, the polarity
988 * might be correct, as suspicious as it seems, so we
989 * better don't change anything (but still disable the
991 if (!((pwm
[0] | pwm
[1] | pwm
[2]) & 0x80)) {
992 dev_info(&client
->dev
, "Reconfiguring PWM to "
993 "active high polarity\n");
994 it87_write_value(client
, IT87_REG_FAN_CTL
,
996 for (i
= 0; i
< 3; i
++)
997 it87_write_value(client
,
1003 dev_info(&client
->dev
, "PWM configuration is "
1004 "too broken to be fixed\n");
1007 dev_info(&client
->dev
, "Detected broken BIOS "
1008 "defaults, disabling PWM interface\n");
1010 } else if (fix_pwm_polarity
) {
1011 dev_info(&client
->dev
, "PWM configuration looks "
1012 "sane, won't touch\n");
1018 /* Called when we have found a new IT87. */
1019 static void it87_init_client(struct i2c_client
*client
, struct it87_data
*data
)
1023 /* initialize to sane defaults:
1024 * - if the chip is in manual pwm mode, this will be overwritten with
1025 * the actual settings on the chip (so in this case, initialization
1027 * - if in automatic or on/off mode, we could switch to manual mode,
1028 * read the registers and set manual_pwm_ctl accordingly, but currently
1029 * this is not implemented, so we initialize to something sane */
1030 for (i
= 0; i
< 3; i
++) {
1031 data
->manual_pwm_ctl
[i
] = 0xff;
1034 /* Check if temperature channnels are reset manually or by some reason */
1035 tmp
= it87_read_value(client
, IT87_REG_TEMP_ENABLE
);
1036 if ((tmp
& 0x3f) == 0) {
1037 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1038 tmp
= (tmp
& 0xc0) | 0x2a;
1039 it87_write_value(client
, IT87_REG_TEMP_ENABLE
, tmp
);
1043 /* Check if voltage monitors are reset manually or by some reason */
1044 tmp
= it87_read_value(client
, IT87_REG_VIN_ENABLE
);
1045 if ((tmp
& 0xff) == 0) {
1046 /* Enable all voltage monitors */
1047 it87_write_value(client
, IT87_REG_VIN_ENABLE
, 0xff);
1050 /* Check if tachometers are reset manually or by some reason */
1051 data
->fan_main_ctrl
= it87_read_value(client
, IT87_REG_FAN_MAIN_CTRL
);
1052 if ((data
->fan_main_ctrl
& 0x70) == 0) {
1053 /* Enable all fan tachometers */
1054 data
->fan_main_ctrl
|= 0x70;
1055 it87_write_value(client
, IT87_REG_FAN_MAIN_CTRL
, data
->fan_main_ctrl
);
1058 /* Set current fan mode registers and the default settings for the
1059 * other mode registers */
1060 for (i
= 0; i
< 3; i
++) {
1061 if (data
->fan_main_ctrl
& (1 << i
)) {
1063 tmp
= it87_read_value(client
, IT87_REG_PWM(i
));
1065 /* automatic pwm - not yet implemented, but
1066 * leave the settings made by the BIOS alone
1067 * until a change is requested via the sysfs
1071 data
->manual_pwm_ctl
[i
] = PWM_FROM_REG(tmp
);
1076 /* Start monitoring */
1077 it87_write_value(client
, IT87_REG_CONFIG
,
1078 (it87_read_value(client
, IT87_REG_CONFIG
) & 0x36)
1079 | (update_vbat
? 0x41 : 0x01));
1082 static struct it87_data
*it87_update_device(struct device
*dev
)
1084 struct i2c_client
*client
= to_i2c_client(dev
);
1085 struct it87_data
*data
= i2c_get_clientdata(client
);
1088 down(&data
->update_lock
);
1090 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
1094 /* Cleared after each update, so reenable. Value
1095 returned by this read will be previous value */
1096 it87_write_value(client
, IT87_REG_CONFIG
,
1097 it87_read_value(client
, IT87_REG_CONFIG
) | 0x40);
1099 for (i
= 0; i
<= 7; i
++) {
1101 it87_read_value(client
, IT87_REG_VIN(i
));
1103 it87_read_value(client
, IT87_REG_VIN_MIN(i
));
1105 it87_read_value(client
, IT87_REG_VIN_MAX(i
));
1108 it87_read_value(client
, IT87_REG_VIN(8));
1109 /* Temperature sensor doesn't have limit registers, set
1110 to min and max value */
1111 data
->in_min
[8] = 0;
1112 data
->in_max
[8] = 255;
1114 for (i
= 0; i
< 3; i
++) {
1116 it87_read_value(client
, IT87_REG_FAN(i
));
1118 it87_read_value(client
, IT87_REG_FAN_MIN(i
));
1120 for (i
= 0; i
< 3; i
++) {
1122 it87_read_value(client
, IT87_REG_TEMP(i
));
1123 data
->temp_high
[i
] =
1124 it87_read_value(client
, IT87_REG_TEMP_HIGH(i
));
1126 it87_read_value(client
, IT87_REG_TEMP_LOW(i
));
1129 i
= it87_read_value(client
, IT87_REG_FAN_DIV
);
1130 data
->fan_div
[0] = i
& 0x07;
1131 data
->fan_div
[1] = (i
>> 3) & 0x07;
1132 data
->fan_div
[2] = (i
& 0x40) ? 3 : 1;
1135 it87_read_value(client
, IT87_REG_ALARM1
) |
1136 (it87_read_value(client
, IT87_REG_ALARM2
) << 8) |
1137 (it87_read_value(client
, IT87_REG_ALARM3
) << 16);
1138 data
->fan_main_ctrl
= it87_read_value(client
, IT87_REG_FAN_MAIN_CTRL
);
1140 data
->sensor
= it87_read_value(client
, IT87_REG_TEMP_ENABLE
);
1141 /* The 8705 does not have VID capability */
1142 if (data
->type
== it8712
) {
1143 data
->vid
= it87_read_value(client
, IT87_REG_VID
);
1146 data
->last_updated
= jiffies
;
1150 up(&data
->update_lock
);
1155 static int __init
sm_it87_init(void)
1159 res
= i2c_add_driver(&it87_driver
);
1163 if (!it87_find(&isa_address
)) {
1164 res
= i2c_isa_add_driver(&it87_isa_driver
);
1166 i2c_del_driver(&it87_driver
);
1174 static void __exit
sm_it87_exit(void)
1176 i2c_isa_del_driver(&it87_isa_driver
);
1177 i2c_del_driver(&it87_driver
);
1181 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
1182 MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
1183 module_param(update_vbat
, bool, 0);
1184 MODULE_PARM_DESC(update_vbat
, "Update vbat if set else return powerup value");
1185 module_param(fix_pwm_polarity
, bool, 0);
1186 MODULE_PARM_DESC(fix_pwm_polarity
, "Force PWM polarity to active high (DANGEROUS)");
1187 MODULE_LICENSE("GPL");
1189 module_init(sm_it87_init
);
1190 module_exit(sm_it87_exit
);