2 * vt8231.c - Part of lm_sensors, Linux kernel modules
3 * for hardware monitoring
5 * Copyright (c) 2005 Roger Lucas <vt8231@hiddenengine.co.uk>
6 * Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
7 * Aaron M. Marsh <amarsh@sdf.lonestar.org>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * Supports VIA VT8231 South Bridge embedded sensors
28 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/slab.h>
33 #include <linux/pci.h>
34 #include <linux/jiffies.h>
35 #include <linux/platform_device.h>
36 #include <linux/hwmon.h>
37 #include <linux/hwmon-sysfs.h>
38 #include <linux/hwmon-vid.h>
39 #include <linux/err.h>
40 #include <linux/mutex.h>
41 #include <linux/acpi.h>
44 static int force_addr
;
45 module_param(force_addr
, int, 0);
46 MODULE_PARM_DESC(force_addr
, "Initialize the base address of the sensors");
48 static struct platform_device
*pdev
;
50 #define VT8231_EXTENT 0x80
51 #define VT8231_BASE_REG 0x70
52 #define VT8231_ENABLE_REG 0x74
55 * The VT8231 registers
57 * The reset value for the input channel configuration is used (Reg 0x4A=0x07)
58 * which sets the selected inputs marked with '*' below if multiple options are
61 * Voltage Mode Temperature Mode
62 * Sensor Linux Id Linux Id VIA Id
63 * -------- -------- -------- ------
64 * CPU Diode N/A temp1 0
72 * Note that the BIOS may set the configuration register to a different value
73 * to match the motherboard configuration.
76 /* fans numbered 0-1 */
77 #define VT8231_REG_FAN_MIN(nr) (0x3b + (nr))
78 #define VT8231_REG_FAN(nr) (0x29 + (nr))
80 /* Voltage inputs numbered 0-5 */
82 static const u8 regvolt
[] = { 0x21, 0x22, 0x23, 0x24, 0x25, 0x26 };
83 static const u8 regvoltmax
[] = { 0x3d, 0x2b, 0x2d, 0x2f, 0x31, 0x33 };
84 static const u8 regvoltmin
[] = { 0x3e, 0x2c, 0x2e, 0x30, 0x32, 0x34 };
87 * Temperatures are numbered 1-6 according to the Linux kernel specification.
89 * In the VIA datasheet, however, the temperatures are numbered from zero.
90 * Since it is important that this driver can easily be compared to the VIA
91 * datasheet, we will use the VIA numbering within this driver and map the
92 * kernel sysfs device name to the VIA number in the sysfs callback.
95 #define VT8231_REG_TEMP_LOW01 0x49
96 #define VT8231_REG_TEMP_LOW25 0x4d
98 static const u8 regtemp
[] = { 0x1f, 0x21, 0x22, 0x23, 0x24, 0x25 };
99 static const u8 regtempmax
[] = { 0x39, 0x3d, 0x2b, 0x2d, 0x2f, 0x31 };
100 static const u8 regtempmin
[] = { 0x3a, 0x3e, 0x2c, 0x2e, 0x30, 0x32 };
102 #define TEMP_FROM_REG(reg) (((253 * 4 - (reg)) * 550 + 105) / 210)
103 #define TEMP_MAXMIN_FROM_REG(reg) (((253 - (reg)) * 2200 + 105) / 210)
104 #define TEMP_MAXMIN_TO_REG(val) (253 - ((val) * 210 + 1100) / 2200)
106 #define VT8231_REG_CONFIG 0x40
107 #define VT8231_REG_ALARM1 0x41
108 #define VT8231_REG_ALARM2 0x42
109 #define VT8231_REG_FANDIV 0x47
110 #define VT8231_REG_UCH_CONFIG 0x4a
111 #define VT8231_REG_TEMP1_CONFIG 0x4b
112 #define VT8231_REG_TEMP2_CONFIG 0x4c
115 * temps 0-5 as numbered in VIA datasheet - see later for mapping to Linux
118 #define ISTEMP(i, ch_config) ((i) == 0 ? 1 : \
119 ((ch_config) >> ((i)+1)) & 0x01)
121 #define ISVOLT(i, ch_config) ((i) == 5 ? 1 : \
122 !(((ch_config) >> ((i)+2)) & 0x01))
124 #define DIV_FROM_REG(val) (1 << (val))
127 * NB The values returned here are NOT temperatures. The calibration curves
128 * for the thermistor curves are board-specific and must go in the
129 * sensors.conf file. Temperature sensors are actually ten bits, but the
130 * VIA datasheet only considers the 8 MSBs obtained from the regtemp[]
131 * register. The temperature value returned should have a magnitude of 3,
132 * so we use the VIA scaling as the "true" scaling and use the remaining 2
133 * LSBs as fractional precision.
135 * All the on-chip hardware temperature comparisons for the alarms are only
136 * 8-bits wide, and compare against the 8 MSBs of the temperature. The bits
137 * in the registers VT8231_REG_TEMP_LOW01 and VT8231_REG_TEMP_LOW25 are
142 ****** FAN RPM CONVERSIONS ********
143 * This chip saturates back at 0, not at 255 like many the other chips.
146 static inline u8
FAN_TO_REG(long rpm
, int div
)
150 return SENSORS_LIMIT(1310720 / (rpm
* div
), 1, 255);
153 #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : 1310720 / ((val) * (div)))
159 struct mutex update_lock
;
160 struct device
*hwmon_dev
;
161 char valid
; /* !=0 if following fields are valid */
162 unsigned long last_updated
; /* In jiffies */
164 u8 in
[6]; /* Register value */
165 u8 in_max
[6]; /* Register value */
166 u8 in_min
[6]; /* Register value */
167 u16 temp
[6]; /* Register value 10 bit, right aligned */
168 u8 temp_max
[6]; /* Register value */
169 u8 temp_min
[6]; /* Register value */
170 u8 fan
[2]; /* Register value */
171 u8 fan_min
[2]; /* Register value */
172 u8 fan_div
[2]; /* Register encoding, shifted right */
173 u16 alarms
; /* Register encoding */
177 static struct pci_dev
*s_bridge
;
178 static int vt8231_probe(struct platform_device
*pdev
);
179 static int __devexit
vt8231_remove(struct platform_device
*pdev
);
180 static struct vt8231_data
*vt8231_update_device(struct device
*dev
);
181 static void vt8231_init_device(struct vt8231_data
*data
);
183 static inline int vt8231_read_value(struct vt8231_data
*data
, u8 reg
)
185 return inb_p(data
->addr
+ reg
);
188 static inline void vt8231_write_value(struct vt8231_data
*data
, u8 reg
,
191 outb_p(value
, data
->addr
+ reg
);
194 /* following are the sysfs callback functions */
195 static ssize_t
show_in(struct device
*dev
, struct device_attribute
*attr
,
198 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
199 int nr
= sensor_attr
->index
;
200 struct vt8231_data
*data
= vt8231_update_device(dev
);
202 return sprintf(buf
, "%d\n", ((data
->in
[nr
] - 3) * 10000) / 958);
205 static ssize_t
show_in_min(struct device
*dev
, struct device_attribute
*attr
,
208 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
209 int nr
= sensor_attr
->index
;
210 struct vt8231_data
*data
= vt8231_update_device(dev
);
212 return sprintf(buf
, "%d\n", ((data
->in_min
[nr
] - 3) * 10000) / 958);
215 static ssize_t
show_in_max(struct device
*dev
, struct device_attribute
*attr
,
218 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
219 int nr
= sensor_attr
->index
;
220 struct vt8231_data
*data
= vt8231_update_device(dev
);
222 return sprintf(buf
, "%d\n", (((data
->in_max
[nr
] - 3) * 10000) / 958));
225 static ssize_t
set_in_min(struct device
*dev
, struct device_attribute
*attr
,
226 const char *buf
, size_t count
)
228 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
229 int nr
= sensor_attr
->index
;
230 struct vt8231_data
*data
= dev_get_drvdata(dev
);
234 err
= kstrtoul(buf
, 10, &val
);
238 mutex_lock(&data
->update_lock
);
239 data
->in_min
[nr
] = SENSORS_LIMIT(((val
* 958) / 10000) + 3, 0, 255);
240 vt8231_write_value(data
, regvoltmin
[nr
], data
->in_min
[nr
]);
241 mutex_unlock(&data
->update_lock
);
245 static ssize_t
set_in_max(struct device
*dev
, struct device_attribute
*attr
,
246 const char *buf
, size_t count
)
248 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
249 int nr
= sensor_attr
->index
;
250 struct vt8231_data
*data
= dev_get_drvdata(dev
);
254 err
= kstrtoul(buf
, 10, &val
);
258 mutex_lock(&data
->update_lock
);
259 data
->in_max
[nr
] = SENSORS_LIMIT(((val
* 958) / 10000) + 3, 0, 255);
260 vt8231_write_value(data
, regvoltmax
[nr
], data
->in_max
[nr
]);
261 mutex_unlock(&data
->update_lock
);
265 /* Special case for input 5 as this has 3.3V scaling built into the chip */
266 static ssize_t
show_in5(struct device
*dev
, struct device_attribute
*attr
,
269 struct vt8231_data
*data
= vt8231_update_device(dev
);
271 return sprintf(buf
, "%d\n",
272 (((data
->in
[5] - 3) * 10000 * 54) / (958 * 34)));
275 static ssize_t
show_in5_min(struct device
*dev
, struct device_attribute
*attr
,
278 struct vt8231_data
*data
= vt8231_update_device(dev
);
280 return sprintf(buf
, "%d\n",
281 (((data
->in_min
[5] - 3) * 10000 * 54) / (958 * 34)));
284 static ssize_t
show_in5_max(struct device
*dev
, struct device_attribute
*attr
,
287 struct vt8231_data
*data
= vt8231_update_device(dev
);
289 return sprintf(buf
, "%d\n",
290 (((data
->in_max
[5] - 3) * 10000 * 54) / (958 * 34)));
293 static ssize_t
set_in5_min(struct device
*dev
, struct device_attribute
*attr
,
294 const char *buf
, size_t count
)
296 struct vt8231_data
*data
= dev_get_drvdata(dev
);
300 err
= kstrtoul(buf
, 10, &val
);
304 mutex_lock(&data
->update_lock
);
305 data
->in_min
[5] = SENSORS_LIMIT(((val
* 958 * 34) / (10000 * 54)) + 3,
307 vt8231_write_value(data
, regvoltmin
[5], data
->in_min
[5]);
308 mutex_unlock(&data
->update_lock
);
312 static ssize_t
set_in5_max(struct device
*dev
, struct device_attribute
*attr
,
313 const char *buf
, size_t count
)
315 struct vt8231_data
*data
= dev_get_drvdata(dev
);
319 err
= kstrtoul(buf
, 10, &val
);
323 mutex_lock(&data
->update_lock
);
324 data
->in_max
[5] = SENSORS_LIMIT(((val
* 958 * 34) / (10000 * 54)) + 3,
326 vt8231_write_value(data
, regvoltmax
[5], data
->in_max
[5]);
327 mutex_unlock(&data
->update_lock
);
331 #define define_voltage_sysfs(offset) \
332 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
333 show_in, NULL, offset); \
334 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
335 show_in_min, set_in_min, offset); \
336 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
337 show_in_max, set_in_max, offset)
339 define_voltage_sysfs(0);
340 define_voltage_sysfs(1);
341 define_voltage_sysfs(2);
342 define_voltage_sysfs(3);
343 define_voltage_sysfs(4);
345 static DEVICE_ATTR(in5_input
, S_IRUGO
, show_in5
, NULL
);
346 static DEVICE_ATTR(in5_min
, S_IRUGO
| S_IWUSR
, show_in5_min
, set_in5_min
);
347 static DEVICE_ATTR(in5_max
, S_IRUGO
| S_IWUSR
, show_in5_max
, set_in5_max
);
350 static ssize_t
show_temp0(struct device
*dev
, struct device_attribute
*attr
,
353 struct vt8231_data
*data
= vt8231_update_device(dev
);
354 return sprintf(buf
, "%d\n", data
->temp
[0] * 250);
357 static ssize_t
show_temp0_max(struct device
*dev
, struct device_attribute
*attr
,
360 struct vt8231_data
*data
= vt8231_update_device(dev
);
361 return sprintf(buf
, "%d\n", data
->temp_max
[0] * 1000);
364 static ssize_t
show_temp0_min(struct device
*dev
, struct device_attribute
*attr
,
367 struct vt8231_data
*data
= vt8231_update_device(dev
);
368 return sprintf(buf
, "%d\n", data
->temp_min
[0] * 1000);
371 static ssize_t
set_temp0_max(struct device
*dev
, struct device_attribute
*attr
,
372 const char *buf
, size_t count
)
374 struct vt8231_data
*data
= dev_get_drvdata(dev
);
378 err
= kstrtol(buf
, 10, &val
);
382 mutex_lock(&data
->update_lock
);
383 data
->temp_max
[0] = SENSORS_LIMIT((val
+ 500) / 1000, 0, 255);
384 vt8231_write_value(data
, regtempmax
[0], data
->temp_max
[0]);
385 mutex_unlock(&data
->update_lock
);
388 static ssize_t
set_temp0_min(struct device
*dev
, struct device_attribute
*attr
,
389 const char *buf
, size_t count
)
391 struct vt8231_data
*data
= dev_get_drvdata(dev
);
395 err
= kstrtol(buf
, 10, &val
);
399 mutex_lock(&data
->update_lock
);
400 data
->temp_min
[0] = SENSORS_LIMIT((val
+ 500) / 1000, 0, 255);
401 vt8231_write_value(data
, regtempmin
[0], data
->temp_min
[0]);
402 mutex_unlock(&data
->update_lock
);
406 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*attr
,
409 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
410 int nr
= sensor_attr
->index
;
411 struct vt8231_data
*data
= vt8231_update_device(dev
);
412 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp
[nr
]));
415 static ssize_t
show_temp_max(struct device
*dev
, struct device_attribute
*attr
,
418 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
419 int nr
= sensor_attr
->index
;
420 struct vt8231_data
*data
= vt8231_update_device(dev
);
421 return sprintf(buf
, "%d\n", TEMP_MAXMIN_FROM_REG(data
->temp_max
[nr
]));
424 static ssize_t
show_temp_min(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
;
429 struct vt8231_data
*data
= vt8231_update_device(dev
);
430 return sprintf(buf
, "%d\n", TEMP_MAXMIN_FROM_REG(data
->temp_min
[nr
]));
433 static ssize_t
set_temp_max(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
;
438 struct vt8231_data
*data
= dev_get_drvdata(dev
);
442 err
= kstrtol(buf
, 10, &val
);
446 mutex_lock(&data
->update_lock
);
447 data
->temp_max
[nr
] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val
), 0, 255);
448 vt8231_write_value(data
, regtempmax
[nr
], data
->temp_max
[nr
]);
449 mutex_unlock(&data
->update_lock
);
452 static ssize_t
set_temp_min(struct device
*dev
, struct device_attribute
*attr
,
453 const char *buf
, size_t count
)
455 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
456 int nr
= sensor_attr
->index
;
457 struct vt8231_data
*data
= dev_get_drvdata(dev
);
461 err
= kstrtol(buf
, 10, &val
);
465 mutex_lock(&data
->update_lock
);
466 data
->temp_min
[nr
] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val
), 0, 255);
467 vt8231_write_value(data
, regtempmin
[nr
], data
->temp_min
[nr
]);
468 mutex_unlock(&data
->update_lock
);
473 * Note that these map the Linux temperature sensor numbering (1-6) to the VIA
474 * temperature sensor numbering (0-5)
476 #define define_temperature_sysfs(offset) \
477 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
478 show_temp, NULL, offset - 1); \
479 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
480 show_temp_max, set_temp_max, offset - 1); \
481 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \
482 show_temp_min, set_temp_min, offset - 1)
484 static DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp0
, NULL
);
485 static DEVICE_ATTR(temp1_max
, S_IRUGO
| S_IWUSR
, show_temp0_max
, set_temp0_max
);
486 static DEVICE_ATTR(temp1_max_hyst
, S_IRUGO
| S_IWUSR
, show_temp0_min
,
489 define_temperature_sysfs(2);
490 define_temperature_sysfs(3);
491 define_temperature_sysfs(4);
492 define_temperature_sysfs(5);
493 define_temperature_sysfs(6);
496 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*attr
,
499 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
500 int nr
= sensor_attr
->index
;
501 struct vt8231_data
*data
= vt8231_update_device(dev
);
502 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan
[nr
],
503 DIV_FROM_REG(data
->fan_div
[nr
])));
506 static ssize_t
show_fan_min(struct device
*dev
, struct device_attribute
*attr
,
509 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
510 int nr
= sensor_attr
->index
;
511 struct vt8231_data
*data
= vt8231_update_device(dev
);
512 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan_min
[nr
],
513 DIV_FROM_REG(data
->fan_div
[nr
])));
516 static ssize_t
show_fan_div(struct device
*dev
, struct device_attribute
*attr
,
519 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
520 int nr
= sensor_attr
->index
;
521 struct vt8231_data
*data
= vt8231_update_device(dev
);
522 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[nr
]));
525 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*attr
,
526 const char *buf
, size_t count
)
528 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
529 int nr
= sensor_attr
->index
;
530 struct vt8231_data
*data
= dev_get_drvdata(dev
);
534 err
= kstrtoul(buf
, 10, &val
);
538 mutex_lock(&data
->update_lock
);
539 data
->fan_min
[nr
] = FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
540 vt8231_write_value(data
, VT8231_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
541 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 vt8231_data
*data
= dev_get_drvdata(dev
);
549 struct sensor_device_attribute
*sensor_attr
= to_sensor_dev_attr(attr
);
551 int nr
= sensor_attr
->index
;
552 int old
= vt8231_read_value(data
, VT8231_REG_FANDIV
);
553 long min
= FAN_FROM_REG(data
->fan_min
[nr
],
554 DIV_FROM_REG(data
->fan_div
[nr
]));
557 err
= kstrtoul(buf
, 10, &val
);
561 mutex_lock(&data
->update_lock
);
564 data
->fan_div
[nr
] = 0;
567 data
->fan_div
[nr
] = 1;
570 data
->fan_div
[nr
] = 2;
573 data
->fan_div
[nr
] = 3;
576 dev_err(dev
, "fan_div value %ld not supported. "
577 "Choose one of 1, 2, 4 or 8!\n", val
);
578 mutex_unlock(&data
->update_lock
);
582 /* Correct the fan minimum speed */
583 data
->fan_min
[nr
] = FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
584 vt8231_write_value(data
, VT8231_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
586 old
= (old
& 0x0f) | (data
->fan_div
[1] << 6) | (data
->fan_div
[0] << 4);
587 vt8231_write_value(data
, VT8231_REG_FANDIV
, old
);
588 mutex_unlock(&data
->update_lock
);
593 #define define_fan_sysfs(offset) \
594 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
595 show_fan, NULL, offset - 1); \
596 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
597 show_fan_div, set_fan_div, offset - 1); \
598 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
599 show_fan_min, set_fan_min, offset - 1)
605 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
,
608 struct vt8231_data
*data
= vt8231_update_device(dev
);
609 return sprintf(buf
, "%d\n", data
->alarms
);
611 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
613 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*attr
,
616 int bitnr
= to_sensor_dev_attr(attr
)->index
;
617 struct vt8231_data
*data
= vt8231_update_device(dev
);
618 return sprintf(buf
, "%u\n", (data
->alarms
>> bitnr
) & 1);
620 static SENSOR_DEVICE_ATTR(temp1_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
621 static SENSOR_DEVICE_ATTR(temp2_alarm
, S_IRUGO
, show_alarm
, NULL
, 11);
622 static SENSOR_DEVICE_ATTR(temp3_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
623 static SENSOR_DEVICE_ATTR(temp4_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
624 static SENSOR_DEVICE_ATTR(temp5_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
625 static SENSOR_DEVICE_ATTR(temp6_alarm
, S_IRUGO
, show_alarm
, NULL
, 8);
626 static SENSOR_DEVICE_ATTR(in0_alarm
, S_IRUGO
, show_alarm
, NULL
, 11);
627 static SENSOR_DEVICE_ATTR(in1_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
628 static SENSOR_DEVICE_ATTR(in2_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
629 static SENSOR_DEVICE_ATTR(in3_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
630 static SENSOR_DEVICE_ATTR(in4_alarm
, S_IRUGO
, show_alarm
, NULL
, 8);
631 static SENSOR_DEVICE_ATTR(in5_alarm
, S_IRUGO
, show_alarm
, NULL
, 2);
632 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
633 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, show_alarm
, NULL
, 7);
635 static ssize_t
show_name(struct device
*dev
, struct device_attribute
638 struct vt8231_data
*data
= dev_get_drvdata(dev
);
639 return sprintf(buf
, "%s\n", data
->name
);
641 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
643 static struct attribute
*vt8231_attributes_temps
[6][5] = {
645 &dev_attr_temp1_input
.attr
,
646 &dev_attr_temp1_max_hyst
.attr
,
647 &dev_attr_temp1_max
.attr
,
648 &sensor_dev_attr_temp1_alarm
.dev_attr
.attr
,
651 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
652 &sensor_dev_attr_temp2_max_hyst
.dev_attr
.attr
,
653 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
654 &sensor_dev_attr_temp2_alarm
.dev_attr
.attr
,
657 &sensor_dev_attr_temp3_input
.dev_attr
.attr
,
658 &sensor_dev_attr_temp3_max_hyst
.dev_attr
.attr
,
659 &sensor_dev_attr_temp3_max
.dev_attr
.attr
,
660 &sensor_dev_attr_temp3_alarm
.dev_attr
.attr
,
663 &sensor_dev_attr_temp4_input
.dev_attr
.attr
,
664 &sensor_dev_attr_temp4_max_hyst
.dev_attr
.attr
,
665 &sensor_dev_attr_temp4_max
.dev_attr
.attr
,
666 &sensor_dev_attr_temp4_alarm
.dev_attr
.attr
,
669 &sensor_dev_attr_temp5_input
.dev_attr
.attr
,
670 &sensor_dev_attr_temp5_max_hyst
.dev_attr
.attr
,
671 &sensor_dev_attr_temp5_max
.dev_attr
.attr
,
672 &sensor_dev_attr_temp5_alarm
.dev_attr
.attr
,
675 &sensor_dev_attr_temp6_input
.dev_attr
.attr
,
676 &sensor_dev_attr_temp6_max_hyst
.dev_attr
.attr
,
677 &sensor_dev_attr_temp6_max
.dev_attr
.attr
,
678 &sensor_dev_attr_temp6_alarm
.dev_attr
.attr
,
683 static const struct attribute_group vt8231_group_temps
[6] = {
684 { .attrs
= vt8231_attributes_temps
[0] },
685 { .attrs
= vt8231_attributes_temps
[1] },
686 { .attrs
= vt8231_attributes_temps
[2] },
687 { .attrs
= vt8231_attributes_temps
[3] },
688 { .attrs
= vt8231_attributes_temps
[4] },
689 { .attrs
= vt8231_attributes_temps
[5] },
692 static struct attribute
*vt8231_attributes_volts
[6][5] = {
694 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
695 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
696 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
697 &sensor_dev_attr_in0_alarm
.dev_attr
.attr
,
700 &sensor_dev_attr_in1_input
.dev_attr
.attr
,
701 &sensor_dev_attr_in1_min
.dev_attr
.attr
,
702 &sensor_dev_attr_in1_max
.dev_attr
.attr
,
703 &sensor_dev_attr_in1_alarm
.dev_attr
.attr
,
706 &sensor_dev_attr_in2_input
.dev_attr
.attr
,
707 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
708 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
709 &sensor_dev_attr_in2_alarm
.dev_attr
.attr
,
712 &sensor_dev_attr_in3_input
.dev_attr
.attr
,
713 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
714 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
715 &sensor_dev_attr_in3_alarm
.dev_attr
.attr
,
718 &sensor_dev_attr_in4_input
.dev_attr
.attr
,
719 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
720 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
721 &sensor_dev_attr_in4_alarm
.dev_attr
.attr
,
724 &dev_attr_in5_input
.attr
,
725 &dev_attr_in5_min
.attr
,
726 &dev_attr_in5_max
.attr
,
727 &sensor_dev_attr_in5_alarm
.dev_attr
.attr
,
732 static const struct attribute_group vt8231_group_volts
[6] = {
733 { .attrs
= vt8231_attributes_volts
[0] },
734 { .attrs
= vt8231_attributes_volts
[1] },
735 { .attrs
= vt8231_attributes_volts
[2] },
736 { .attrs
= vt8231_attributes_volts
[3] },
737 { .attrs
= vt8231_attributes_volts
[4] },
738 { .attrs
= vt8231_attributes_volts
[5] },
741 static struct attribute
*vt8231_attributes
[] = {
742 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
743 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
744 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
745 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
746 &sensor_dev_attr_fan1_div
.dev_attr
.attr
,
747 &sensor_dev_attr_fan2_div
.dev_attr
.attr
,
748 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
749 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
750 &dev_attr_alarms
.attr
,
755 static const struct attribute_group vt8231_group
= {
756 .attrs
= vt8231_attributes
,
759 static struct platform_driver vt8231_driver
= {
761 .owner
= THIS_MODULE
,
764 .probe
= vt8231_probe
,
765 .remove
= __devexit_p(vt8231_remove
),
768 static DEFINE_PCI_DEVICE_TABLE(vt8231_pci_ids
) = {
769 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, PCI_DEVICE_ID_VIA_8231_4
) },
773 MODULE_DEVICE_TABLE(pci
, vt8231_pci_ids
);
775 static int __devinit
vt8231_pci_probe(struct pci_dev
*dev
,
776 const struct pci_device_id
*id
);
778 static struct pci_driver vt8231_pci_driver
= {
780 .id_table
= vt8231_pci_ids
,
781 .probe
= vt8231_pci_probe
,
784 static int vt8231_probe(struct platform_device
*pdev
)
786 struct resource
*res
;
787 struct vt8231_data
*data
;
790 /* Reserve the ISA region */
791 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
792 if (!request_region(res
->start
, VT8231_EXTENT
,
793 vt8231_driver
.driver
.name
)) {
794 dev_err(&pdev
->dev
, "Region 0x%lx-0x%lx already in use!\n",
795 (unsigned long)res
->start
, (unsigned long)res
->end
);
799 data
= kzalloc(sizeof(struct vt8231_data
), GFP_KERNEL
);
805 platform_set_drvdata(pdev
, data
);
806 data
->addr
= res
->start
;
807 data
->name
= "vt8231";
809 mutex_init(&data
->update_lock
);
810 vt8231_init_device(data
);
812 /* Register sysfs hooks */
813 err
= sysfs_create_group(&pdev
->dev
.kobj
, &vt8231_group
);
817 /* Must update device information to find out the config field */
818 data
->uch_config
= vt8231_read_value(data
, VT8231_REG_UCH_CONFIG
);
820 for (i
= 0; i
< ARRAY_SIZE(vt8231_group_temps
); i
++) {
821 if (ISTEMP(i
, data
->uch_config
)) {
822 err
= sysfs_create_group(&pdev
->dev
.kobj
,
823 &vt8231_group_temps
[i
]);
825 goto exit_remove_files
;
829 for (i
= 0; i
< ARRAY_SIZE(vt8231_group_volts
); i
++) {
830 if (ISVOLT(i
, data
->uch_config
)) {
831 err
= sysfs_create_group(&pdev
->dev
.kobj
,
832 &vt8231_group_volts
[i
]);
834 goto exit_remove_files
;
838 data
->hwmon_dev
= hwmon_device_register(&pdev
->dev
);
839 if (IS_ERR(data
->hwmon_dev
)) {
840 err
= PTR_ERR(data
->hwmon_dev
);
841 goto exit_remove_files
;
846 for (i
= 0; i
< ARRAY_SIZE(vt8231_group_volts
); i
++)
847 sysfs_remove_group(&pdev
->dev
.kobj
, &vt8231_group_volts
[i
]);
849 for (i
= 0; i
< ARRAY_SIZE(vt8231_group_temps
); i
++)
850 sysfs_remove_group(&pdev
->dev
.kobj
, &vt8231_group_temps
[i
]);
852 sysfs_remove_group(&pdev
->dev
.kobj
, &vt8231_group
);
855 platform_set_drvdata(pdev
, NULL
);
859 release_region(res
->start
, VT8231_EXTENT
);
863 static int __devexit
vt8231_remove(struct platform_device
*pdev
)
865 struct vt8231_data
*data
= platform_get_drvdata(pdev
);
868 hwmon_device_unregister(data
->hwmon_dev
);
870 for (i
= 0; i
< ARRAY_SIZE(vt8231_group_volts
); i
++)
871 sysfs_remove_group(&pdev
->dev
.kobj
, &vt8231_group_volts
[i
]);
873 for (i
= 0; i
< ARRAY_SIZE(vt8231_group_temps
); i
++)
874 sysfs_remove_group(&pdev
->dev
.kobj
, &vt8231_group_temps
[i
]);
876 sysfs_remove_group(&pdev
->dev
.kobj
, &vt8231_group
);
878 release_region(data
->addr
, VT8231_EXTENT
);
879 platform_set_drvdata(pdev
, NULL
);
884 static void vt8231_init_device(struct vt8231_data
*data
)
886 vt8231_write_value(data
, VT8231_REG_TEMP1_CONFIG
, 0);
887 vt8231_write_value(data
, VT8231_REG_TEMP2_CONFIG
, 0);
890 static struct vt8231_data
*vt8231_update_device(struct device
*dev
)
892 struct vt8231_data
*data
= dev_get_drvdata(dev
);
896 mutex_lock(&data
->update_lock
);
898 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
900 for (i
= 0; i
< 6; i
++) {
901 if (ISVOLT(i
, data
->uch_config
)) {
902 data
->in
[i
] = vt8231_read_value(data
,
904 data
->in_min
[i
] = vt8231_read_value(data
,
906 data
->in_max
[i
] = vt8231_read_value(data
,
910 for (i
= 0; i
< 2; i
++) {
911 data
->fan
[i
] = vt8231_read_value(data
,
913 data
->fan_min
[i
] = vt8231_read_value(data
,
914 VT8231_REG_FAN_MIN(i
));
917 low
= vt8231_read_value(data
, VT8231_REG_TEMP_LOW01
);
918 low
= (low
>> 6) | ((low
& 0x30) >> 2)
919 | (vt8231_read_value(data
, VT8231_REG_TEMP_LOW25
) << 4);
920 for (i
= 0; i
< 6; i
++) {
921 if (ISTEMP(i
, data
->uch_config
)) {
922 data
->temp
[i
] = (vt8231_read_value(data
,
924 | ((low
>> (2 * i
)) & 0x03);
925 data
->temp_max
[i
] = vt8231_read_value(data
,
927 data
->temp_min
[i
] = vt8231_read_value(data
,
932 i
= vt8231_read_value(data
, VT8231_REG_FANDIV
);
933 data
->fan_div
[0] = (i
>> 4) & 0x03;
934 data
->fan_div
[1] = i
>> 6;
935 data
->alarms
= vt8231_read_value(data
, VT8231_REG_ALARM1
) |
936 (vt8231_read_value(data
, VT8231_REG_ALARM2
) << 8);
938 /* Set alarm flags correctly */
939 if (!data
->fan
[0] && data
->fan_min
[0])
940 data
->alarms
|= 0x40;
941 else if (data
->fan
[0] && !data
->fan_min
[0])
942 data
->alarms
&= ~0x40;
944 if (!data
->fan
[1] && data
->fan_min
[1])
945 data
->alarms
|= 0x80;
946 else if (data
->fan
[1] && !data
->fan_min
[1])
947 data
->alarms
&= ~0x80;
949 data
->last_updated
= jiffies
;
953 mutex_unlock(&data
->update_lock
);
958 static int __devinit
vt8231_device_add(unsigned short address
)
960 struct resource res
= {
962 .end
= address
+ VT8231_EXTENT
- 1,
964 .flags
= IORESOURCE_IO
,
968 err
= acpi_check_resource_conflict(&res
);
972 pdev
= platform_device_alloc("vt8231", address
);
975 pr_err("Device allocation failed\n");
979 err
= platform_device_add_resources(pdev
, &res
, 1);
981 pr_err("Device resource addition failed (%d)\n", err
);
982 goto exit_device_put
;
985 err
= platform_device_add(pdev
);
987 pr_err("Device addition failed (%d)\n", err
);
988 goto exit_device_put
;
994 platform_device_put(pdev
);
999 static int __devinit
vt8231_pci_probe(struct pci_dev
*dev
,
1000 const struct pci_device_id
*id
)
1004 address
= force_addr
& 0xff00;
1005 dev_warn(&dev
->dev
, "Forcing ISA address 0x%x\n",
1008 if (PCIBIOS_SUCCESSFUL
!=
1009 pci_write_config_word(dev
, VT8231_BASE_REG
, address
| 1))
1013 if (PCIBIOS_SUCCESSFUL
!= pci_read_config_word(dev
, VT8231_BASE_REG
,
1017 address
= val
& ~(VT8231_EXTENT
- 1);
1019 dev_err(&dev
->dev
, "base address not set - upgrade BIOS or use force_addr=0xaddr\n");
1023 if (PCIBIOS_SUCCESSFUL
!= pci_read_config_word(dev
, VT8231_ENABLE_REG
,
1027 if (!(val
& 0x0001)) {
1028 dev_warn(&dev
->dev
, "enabling sensors\n");
1029 if (PCIBIOS_SUCCESSFUL
!=
1030 pci_write_config_word(dev
, VT8231_ENABLE_REG
,
1035 if (platform_driver_register(&vt8231_driver
))
1038 /* Sets global pdev as a side effect */
1039 if (vt8231_device_add(address
))
1040 goto exit_unregister
;
1043 * Always return failure here. This is to allow other drivers to bind
1044 * to this pci device. We don't really want to have control over the
1045 * pci device, we only wanted to read as few register values from it.
1049 * We do, however, mark ourselves as using the PCI device to stop it
1052 s_bridge
= pci_dev_get(dev
);
1056 platform_driver_unregister(&vt8231_driver
);
1061 static int __init
sm_vt8231_init(void)
1063 return pci_register_driver(&vt8231_pci_driver
);
1066 static void __exit
sm_vt8231_exit(void)
1068 pci_unregister_driver(&vt8231_pci_driver
);
1069 if (s_bridge
!= NULL
) {
1070 platform_device_unregister(pdev
);
1071 platform_driver_unregister(&vt8231_driver
);
1072 pci_dev_put(s_bridge
);
1077 MODULE_AUTHOR("Roger Lucas <vt8231@hiddenengine.co.uk>");
1078 MODULE_DESCRIPTION("VT8231 sensors");
1079 MODULE_LICENSE("GPL");
1081 module_init(sm_vt8231_init
);
1082 module_exit(sm_vt8231_exit
);