2 * sis5595.c - Part of lm_sensors, Linux kernel modules
3 * for hardware monitoring
5 * Copyright (C) 1998 - 2001 Frodo Looijaard <frodol@dds.nl>,
6 * Kyösti Mälkki <kmalkki@cc.hut.fi>, and
7 * Mark D. Studebaker <mdsxyz123@yahoo.com>
8 * Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with
9 * the help of Jean Delvare <khali@linux-fr.org>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 * SiS southbridge has a LM78-like chip integrated on the same IC.
28 * This driver is a customized copy of lm78.c
30 * Supports following revisions:
31 * Version PCI ID PCI Revision
32 * 1 1039/0008 AF or less
33 * 2 1039/0008 B0 or greater
35 * Note: these chips contain a 0008 device which is incompatible with the
36 * 5595. We recognize these by the presence of the listed
37 * "blacklist" PCI ID and refuse to load.
39 * NOT SUPPORTED PCI ID BLACKLIST PCI ID
53 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
55 #include <linux/module.h>
56 #include <linux/slab.h>
57 #include <linux/ioport.h>
58 #include <linux/pci.h>
59 #include <linux/platform_device.h>
60 #include <linux/hwmon.h>
61 #include <linux/hwmon-sysfs.h>
62 #include <linux/err.h>
63 #include <linux/init.h>
64 #include <linux/jiffies.h>
65 #include <linux/mutex.h>
66 #include <linux/sysfs.h>
67 #include <linux/acpi.h>
72 * If force_addr is set to anything different from 0, we forcibly enable
73 * the device at the given address.
75 static u16 force_addr
;
76 module_param(force_addr
, ushort
, 0);
77 MODULE_PARM_DESC(force_addr
,
78 "Initialize the base address of the sensors");
80 static struct platform_device
*pdev
;
82 /* Many SIS5595 constants specified below */
84 /* Length of ISA address segment */
85 #define SIS5595_EXTENT 8
86 /* PCI Config Registers */
87 #define SIS5595_BASE_REG 0x68
88 #define SIS5595_PIN_REG 0x7A
89 #define SIS5595_ENABLE_REG 0x7B
91 /* Where are the ISA address/data registers relative to the base address */
92 #define SIS5595_ADDR_REG_OFFSET 5
93 #define SIS5595_DATA_REG_OFFSET 6
95 /* The SIS5595 registers */
96 #define SIS5595_REG_IN_MAX(nr) (0x2b + (nr) * 2)
97 #define SIS5595_REG_IN_MIN(nr) (0x2c + (nr) * 2)
98 #define SIS5595_REG_IN(nr) (0x20 + (nr))
100 #define SIS5595_REG_FAN_MIN(nr) (0x3b + (nr))
101 #define SIS5595_REG_FAN(nr) (0x28 + (nr))
104 * On the first version of the chip, the temp registers are separate.
105 * On the second version,
106 * TEMP pin is shared with IN4, configured in PCI register 0x7A.
107 * The registers are the same as well.
108 * OVER and HYST are really MAX and MIN.
112 #define SIS5595_REG_TEMP (((data->revision) >= REV2MIN) ? \
113 SIS5595_REG_IN(4) : 0x27)
114 #define SIS5595_REG_TEMP_OVER (((data->revision) >= REV2MIN) ? \
115 SIS5595_REG_IN_MAX(4) : 0x39)
116 #define SIS5595_REG_TEMP_HYST (((data->revision) >= REV2MIN) ? \
117 SIS5595_REG_IN_MIN(4) : 0x3a)
119 #define SIS5595_REG_CONFIG 0x40
120 #define SIS5595_REG_ALARM1 0x41
121 #define SIS5595_REG_ALARM2 0x42
122 #define SIS5595_REG_FANDIV 0x47
125 * Conversions. Limit checking is only done on the TO_REG
130 * IN: mV, (0V to 4.08V)
133 static inline u8
IN_TO_REG(unsigned long val
)
135 unsigned long nval
= clamp_val(val
, 0, 4080);
136 return (nval
+ 8) / 16;
138 #define IN_FROM_REG(val) ((val) * 16)
140 static inline u8
FAN_TO_REG(long rpm
, int div
)
146 return clamp_val((1350000 + rpm
* div
/ 2) / (rpm
* div
), 1, 254);
149 static inline int FAN_FROM_REG(u8 val
, int div
)
151 return val
== 0 ? -1 : val
== 255 ? 0 : 1350000 / (val
* div
);
155 * TEMP: mC (-54.12C to +157.53C)
156 * REG: 0.83C/bit + 52.12, two's complement
158 static inline int TEMP_FROM_REG(s8 val
)
160 return val
* 830 + 52120;
162 static inline s8
TEMP_TO_REG(int val
)
164 int nval
= clamp_val(val
, -54120, 157530) ;
165 return nval
< 0 ? (nval
- 5212 - 415) / 830 : (nval
- 5212 + 415) / 830;
169 * FAN DIV: 1, 2, 4, or 8 (defaults to 2)
170 * REG: 0, 1, 2, or 3 (respectively) (defaults to 1)
172 static inline u8
DIV_TO_REG(int val
)
174 return val
== 8 ? 3 : val
== 4 ? 2 : val
== 1 ? 0 : 1;
176 #define DIV_FROM_REG(val) (1 << (val))
179 * For each registered chip, we need to keep some data in memory.
180 * The structure is dynamically allocated.
182 struct sis5595_data
{
185 struct device
*hwmon_dev
;
188 struct mutex update_lock
;
189 char valid
; /* !=0 if following fields are valid */
190 unsigned long last_updated
; /* In jiffies */
191 char maxins
; /* == 3 if temp enabled, otherwise == 4 */
192 u8 revision
; /* Reg. value */
194 u8 in
[5]; /* Register value */
195 u8 in_max
[5]; /* Register value */
196 u8 in_min
[5]; /* Register value */
197 u8 fan
[2]; /* Register value */
198 u8 fan_min
[2]; /* Register value */
199 s8 temp
; /* Register value */
200 s8 temp_over
; /* Register value */
201 s8 temp_hyst
; /* Register value */
202 u8 fan_div
[2]; /* Register encoding, shifted right */
203 u16 alarms
; /* Register encoding, combined */
206 static struct pci_dev
*s_bridge
; /* pointer to the (only) sis5595 */
208 static int sis5595_probe(struct platform_device
*pdev
);
209 static int sis5595_remove(struct platform_device
*pdev
);
211 static int sis5595_read_value(struct sis5595_data
*data
, u8 reg
);
212 static void sis5595_write_value(struct sis5595_data
*data
, u8 reg
, u8 value
);
213 static struct sis5595_data
*sis5595_update_device(struct device
*dev
);
214 static void sis5595_init_device(struct sis5595_data
*data
);
216 static struct platform_driver sis5595_driver
= {
218 .owner
= THIS_MODULE
,
221 .probe
= sis5595_probe
,
222 .remove
= sis5595_remove
,
226 static ssize_t
show_in(struct device
*dev
, struct device_attribute
*da
,
229 struct sis5595_data
*data
= sis5595_update_device(dev
);
230 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
231 int nr
= attr
->index
;
232 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in
[nr
]));
235 static ssize_t
show_in_min(struct device
*dev
, struct device_attribute
*da
,
238 struct sis5595_data
*data
= sis5595_update_device(dev
);
239 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
240 int nr
= attr
->index
;
241 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_min
[nr
]));
244 static ssize_t
show_in_max(struct device
*dev
, struct device_attribute
*da
,
247 struct sis5595_data
*data
= sis5595_update_device(dev
);
248 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
249 int nr
= attr
->index
;
250 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_max
[nr
]));
253 static ssize_t
set_in_min(struct device
*dev
, struct device_attribute
*da
,
254 const char *buf
, size_t count
)
256 struct sis5595_data
*data
= dev_get_drvdata(dev
);
257 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
258 int nr
= attr
->index
;
262 err
= kstrtoul(buf
, 10, &val
);
266 mutex_lock(&data
->update_lock
);
267 data
->in_min
[nr
] = IN_TO_REG(val
);
268 sis5595_write_value(data
, SIS5595_REG_IN_MIN(nr
), data
->in_min
[nr
]);
269 mutex_unlock(&data
->update_lock
);
273 static ssize_t
set_in_max(struct device
*dev
, struct device_attribute
*da
,
274 const char *buf
, size_t count
)
276 struct sis5595_data
*data
= dev_get_drvdata(dev
);
277 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
278 int nr
= attr
->index
;
282 err
= kstrtoul(buf
, 10, &val
);
286 mutex_lock(&data
->update_lock
);
287 data
->in_max
[nr
] = IN_TO_REG(val
);
288 sis5595_write_value(data
, SIS5595_REG_IN_MAX(nr
), data
->in_max
[nr
]);
289 mutex_unlock(&data
->update_lock
);
293 #define show_in_offset(offset) \
294 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
295 show_in, NULL, offset); \
296 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
297 show_in_min, set_in_min, offset); \
298 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
299 show_in_max, set_in_max, offset);
308 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*attr
,
311 struct sis5595_data
*data
= sis5595_update_device(dev
);
312 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp
));
315 static ssize_t
show_temp_over(struct device
*dev
, struct device_attribute
*attr
,
318 struct sis5595_data
*data
= sis5595_update_device(dev
);
319 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_over
));
322 static ssize_t
set_temp_over(struct device
*dev
, struct device_attribute
*attr
,
323 const char *buf
, size_t count
)
325 struct sis5595_data
*data
= dev_get_drvdata(dev
);
329 err
= kstrtol(buf
, 10, &val
);
333 mutex_lock(&data
->update_lock
);
334 data
->temp_over
= TEMP_TO_REG(val
);
335 sis5595_write_value(data
, SIS5595_REG_TEMP_OVER
, data
->temp_over
);
336 mutex_unlock(&data
->update_lock
);
340 static ssize_t
show_temp_hyst(struct device
*dev
, struct device_attribute
*attr
,
343 struct sis5595_data
*data
= sis5595_update_device(dev
);
344 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_hyst
));
347 static ssize_t
set_temp_hyst(struct device
*dev
, struct device_attribute
*attr
,
348 const char *buf
, size_t count
)
350 struct sis5595_data
*data
= dev_get_drvdata(dev
);
354 err
= kstrtol(buf
, 10, &val
);
358 mutex_lock(&data
->update_lock
);
359 data
->temp_hyst
= TEMP_TO_REG(val
);
360 sis5595_write_value(data
, SIS5595_REG_TEMP_HYST
, data
->temp_hyst
);
361 mutex_unlock(&data
->update_lock
);
365 static DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
);
366 static DEVICE_ATTR(temp1_max
, S_IRUGO
| S_IWUSR
,
367 show_temp_over
, set_temp_over
);
368 static DEVICE_ATTR(temp1_max_hyst
, S_IRUGO
| S_IWUSR
,
369 show_temp_hyst
, set_temp_hyst
);
372 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*da
,
375 struct sis5595_data
*data
= sis5595_update_device(dev
);
376 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
377 int nr
= attr
->index
;
378 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan
[nr
],
379 DIV_FROM_REG(data
->fan_div
[nr
])));
382 static ssize_t
show_fan_min(struct device
*dev
, struct device_attribute
*da
,
385 struct sis5595_data
*data
= sis5595_update_device(dev
);
386 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
387 int nr
= attr
->index
;
388 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan_min
[nr
],
389 DIV_FROM_REG(data
->fan_div
[nr
])));
392 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*da
,
393 const char *buf
, size_t count
)
395 struct sis5595_data
*data
= dev_get_drvdata(dev
);
396 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
397 int nr
= attr
->index
;
401 err
= kstrtoul(buf
, 10, &val
);
405 mutex_lock(&data
->update_lock
);
406 data
->fan_min
[nr
] = FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
407 sis5595_write_value(data
, SIS5595_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
408 mutex_unlock(&data
->update_lock
);
412 static ssize_t
show_fan_div(struct device
*dev
, struct device_attribute
*da
,
415 struct sis5595_data
*data
= sis5595_update_device(dev
);
416 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
417 int nr
= attr
->index
;
418 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[nr
]));
422 * Note: we save and restore the fan minimum here, because its value is
423 * determined in part by the fan divisor. This follows the principle of
424 * least surprise; the user doesn't expect the fan minimum to change just
425 * because the divisor changed.
427 static ssize_t
set_fan_div(struct device
*dev
, struct device_attribute
*da
,
428 const char *buf
, size_t count
)
430 struct sis5595_data
*data
= dev_get_drvdata(dev
);
431 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
432 int nr
= attr
->index
;
438 err
= kstrtoul(buf
, 10, &val
);
442 mutex_lock(&data
->update_lock
);
443 min
= FAN_FROM_REG(data
->fan_min
[nr
],
444 DIV_FROM_REG(data
->fan_div
[nr
]));
445 reg
= sis5595_read_value(data
, SIS5595_REG_FANDIV
);
449 data
->fan_div
[nr
] = 0;
452 data
->fan_div
[nr
] = 1;
455 data
->fan_div
[nr
] = 2;
458 data
->fan_div
[nr
] = 3;
462 "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
464 mutex_unlock(&data
->update_lock
);
470 reg
= (reg
& 0xcf) | (data
->fan_div
[nr
] << 4);
473 reg
= (reg
& 0x3f) | (data
->fan_div
[nr
] << 6);
476 sis5595_write_value(data
, SIS5595_REG_FANDIV
, reg
);
478 FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
479 sis5595_write_value(data
, SIS5595_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
480 mutex_unlock(&data
->update_lock
);
484 #define show_fan_offset(offset) \
485 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
486 show_fan, NULL, offset - 1); \
487 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
488 show_fan_min, set_fan_min, offset - 1); \
489 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
490 show_fan_div, set_fan_div, offset - 1);
496 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
,
499 struct sis5595_data
*data
= sis5595_update_device(dev
);
500 return sprintf(buf
, "%d\n", data
->alarms
);
502 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
504 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*da
,
507 struct sis5595_data
*data
= sis5595_update_device(dev
);
508 int nr
= to_sensor_dev_attr(da
)->index
;
509 return sprintf(buf
, "%u\n", (data
->alarms
>> nr
) & 1);
511 static SENSOR_DEVICE_ATTR(in0_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
512 static SENSOR_DEVICE_ATTR(in1_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
513 static SENSOR_DEVICE_ATTR(in2_alarm
, S_IRUGO
, show_alarm
, NULL
, 2);
514 static SENSOR_DEVICE_ATTR(in3_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
515 static SENSOR_DEVICE_ATTR(in4_alarm
, S_IRUGO
, show_alarm
, NULL
, 15);
516 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
517 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, show_alarm
, NULL
, 7);
518 static SENSOR_DEVICE_ATTR(temp1_alarm
, S_IRUGO
, show_alarm
, NULL
, 15);
520 static ssize_t
show_name(struct device
*dev
, struct device_attribute
*attr
,
523 struct sis5595_data
*data
= dev_get_drvdata(dev
);
524 return sprintf(buf
, "%s\n", data
->name
);
526 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
528 static struct attribute
*sis5595_attributes
[] = {
529 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
530 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
531 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
532 &sensor_dev_attr_in0_alarm
.dev_attr
.attr
,
533 &sensor_dev_attr_in1_input
.dev_attr
.attr
,
534 &sensor_dev_attr_in1_min
.dev_attr
.attr
,
535 &sensor_dev_attr_in1_max
.dev_attr
.attr
,
536 &sensor_dev_attr_in1_alarm
.dev_attr
.attr
,
537 &sensor_dev_attr_in2_input
.dev_attr
.attr
,
538 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
539 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
540 &sensor_dev_attr_in2_alarm
.dev_attr
.attr
,
541 &sensor_dev_attr_in3_input
.dev_attr
.attr
,
542 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
543 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
544 &sensor_dev_attr_in3_alarm
.dev_attr
.attr
,
546 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
547 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
548 &sensor_dev_attr_fan1_div
.dev_attr
.attr
,
549 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
550 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
551 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
552 &sensor_dev_attr_fan2_div
.dev_attr
.attr
,
553 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
555 &dev_attr_alarms
.attr
,
560 static const struct attribute_group sis5595_group
= {
561 .attrs
= sis5595_attributes
,
564 static struct attribute
*sis5595_attributes_in4
[] = {
565 &sensor_dev_attr_in4_input
.dev_attr
.attr
,
566 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
567 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
568 &sensor_dev_attr_in4_alarm
.dev_attr
.attr
,
572 static const struct attribute_group sis5595_group_in4
= {
573 .attrs
= sis5595_attributes_in4
,
576 static struct attribute
*sis5595_attributes_temp1
[] = {
577 &dev_attr_temp1_input
.attr
,
578 &dev_attr_temp1_max
.attr
,
579 &dev_attr_temp1_max_hyst
.attr
,
580 &sensor_dev_attr_temp1_alarm
.dev_attr
.attr
,
584 static const struct attribute_group sis5595_group_temp1
= {
585 .attrs
= sis5595_attributes_temp1
,
588 /* This is called when the module is loaded */
589 static int sis5595_probe(struct platform_device
*pdev
)
593 struct sis5595_data
*data
;
594 struct resource
*res
;
597 /* Reserve the ISA region */
598 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
599 if (!devm_request_region(&pdev
->dev
, res
->start
, SIS5595_EXTENT
,
600 sis5595_driver
.driver
.name
))
603 data
= devm_kzalloc(&pdev
->dev
, sizeof(struct sis5595_data
),
608 mutex_init(&data
->lock
);
609 mutex_init(&data
->update_lock
);
610 data
->addr
= res
->start
;
611 data
->name
= "sis5595";
612 platform_set_drvdata(pdev
, data
);
615 * Check revision and pin registers to determine whether 4 or 5 voltages
617 data
->revision
= s_bridge
->revision
;
618 /* 4 voltages, 1 temp */
620 if (data
->revision
>= REV2MIN
) {
621 pci_read_config_byte(s_bridge
, SIS5595_PIN_REG
, &val
);
623 /* 5 voltages, no temps */
627 /* Initialize the SIS5595 chip */
628 sis5595_init_device(data
);
630 /* A few vars need to be filled upon startup */
631 for (i
= 0; i
< 2; i
++) {
632 data
->fan_min
[i
] = sis5595_read_value(data
,
633 SIS5595_REG_FAN_MIN(i
));
636 /* Register sysfs hooks */
637 err
= sysfs_create_group(&pdev
->dev
.kobj
, &sis5595_group
);
640 if (data
->maxins
== 4) {
641 err
= sysfs_create_group(&pdev
->dev
.kobj
, &sis5595_group_in4
);
643 goto exit_remove_files
;
645 err
= sysfs_create_group(&pdev
->dev
.kobj
, &sis5595_group_temp1
);
647 goto exit_remove_files
;
650 data
->hwmon_dev
= hwmon_device_register(&pdev
->dev
);
651 if (IS_ERR(data
->hwmon_dev
)) {
652 err
= PTR_ERR(data
->hwmon_dev
);
653 goto exit_remove_files
;
659 sysfs_remove_group(&pdev
->dev
.kobj
, &sis5595_group
);
660 sysfs_remove_group(&pdev
->dev
.kobj
, &sis5595_group_in4
);
661 sysfs_remove_group(&pdev
->dev
.kobj
, &sis5595_group_temp1
);
665 static int sis5595_remove(struct platform_device
*pdev
)
667 struct sis5595_data
*data
= platform_get_drvdata(pdev
);
669 hwmon_device_unregister(data
->hwmon_dev
);
670 sysfs_remove_group(&pdev
->dev
.kobj
, &sis5595_group
);
671 sysfs_remove_group(&pdev
->dev
.kobj
, &sis5595_group_in4
);
672 sysfs_remove_group(&pdev
->dev
.kobj
, &sis5595_group_temp1
);
678 /* ISA access must be locked explicitly. */
679 static int sis5595_read_value(struct sis5595_data
*data
, u8 reg
)
683 mutex_lock(&data
->lock
);
684 outb_p(reg
, data
->addr
+ SIS5595_ADDR_REG_OFFSET
);
685 res
= inb_p(data
->addr
+ SIS5595_DATA_REG_OFFSET
);
686 mutex_unlock(&data
->lock
);
690 static void sis5595_write_value(struct sis5595_data
*data
, u8 reg
, u8 value
)
692 mutex_lock(&data
->lock
);
693 outb_p(reg
, data
->addr
+ SIS5595_ADDR_REG_OFFSET
);
694 outb_p(value
, data
->addr
+ SIS5595_DATA_REG_OFFSET
);
695 mutex_unlock(&data
->lock
);
698 /* Called when we have found a new SIS5595. */
699 static void sis5595_init_device(struct sis5595_data
*data
)
701 u8 config
= sis5595_read_value(data
, SIS5595_REG_CONFIG
);
702 if (!(config
& 0x01))
703 sis5595_write_value(data
, SIS5595_REG_CONFIG
,
704 (config
& 0xf7) | 0x01);
707 static struct sis5595_data
*sis5595_update_device(struct device
*dev
)
709 struct sis5595_data
*data
= dev_get_drvdata(dev
);
712 mutex_lock(&data
->update_lock
);
714 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
717 for (i
= 0; i
<= data
->maxins
; i
++) {
719 sis5595_read_value(data
, SIS5595_REG_IN(i
));
721 sis5595_read_value(data
,
722 SIS5595_REG_IN_MIN(i
));
724 sis5595_read_value(data
,
725 SIS5595_REG_IN_MAX(i
));
727 for (i
= 0; i
< 2; i
++) {
729 sis5595_read_value(data
, SIS5595_REG_FAN(i
));
731 sis5595_read_value(data
,
732 SIS5595_REG_FAN_MIN(i
));
734 if (data
->maxins
== 3) {
736 sis5595_read_value(data
, SIS5595_REG_TEMP
);
738 sis5595_read_value(data
, SIS5595_REG_TEMP_OVER
);
740 sis5595_read_value(data
, SIS5595_REG_TEMP_HYST
);
742 i
= sis5595_read_value(data
, SIS5595_REG_FANDIV
);
743 data
->fan_div
[0] = (i
>> 4) & 0x03;
744 data
->fan_div
[1] = i
>> 6;
746 sis5595_read_value(data
, SIS5595_REG_ALARM1
) |
747 (sis5595_read_value(data
, SIS5595_REG_ALARM2
) << 8);
748 data
->last_updated
= jiffies
;
752 mutex_unlock(&data
->update_lock
);
757 static DEFINE_PCI_DEVICE_TABLE(sis5595_pci_ids
) = {
758 { PCI_DEVICE(PCI_VENDOR_ID_SI
, PCI_DEVICE_ID_SI_503
) },
762 MODULE_DEVICE_TABLE(pci
, sis5595_pci_ids
);
764 static int blacklist
[] = {
765 PCI_DEVICE_ID_SI_540
,
766 PCI_DEVICE_ID_SI_550
,
767 PCI_DEVICE_ID_SI_630
,
768 PCI_DEVICE_ID_SI_645
,
769 PCI_DEVICE_ID_SI_730
,
770 PCI_DEVICE_ID_SI_735
,
771 PCI_DEVICE_ID_SI_5511
, /*
772 * 5513 chip has the 0008 device but
773 * that ID shows up in other chips so we
774 * use the 5511 ID for recognition
776 PCI_DEVICE_ID_SI_5597
,
777 PCI_DEVICE_ID_SI_5598
,
780 static int sis5595_device_add(unsigned short address
)
782 struct resource res
= {
784 .end
= address
+ SIS5595_EXTENT
- 1,
786 .flags
= IORESOURCE_IO
,
790 err
= acpi_check_resource_conflict(&res
);
794 pdev
= platform_device_alloc("sis5595", address
);
797 pr_err("Device allocation failed\n");
801 err
= platform_device_add_resources(pdev
, &res
, 1);
803 pr_err("Device resource addition failed (%d)\n", err
);
804 goto exit_device_put
;
807 err
= platform_device_add(pdev
);
809 pr_err("Device addition failed (%d)\n", err
);
810 goto exit_device_put
;
816 platform_device_put(pdev
);
821 static int sis5595_pci_probe(struct pci_dev
*dev
,
822 const struct pci_device_id
*id
)
828 for (i
= blacklist
; *i
!= 0; i
++) {
830 d
= pci_get_device(PCI_VENDOR_ID_SI
, *i
, NULL
);
833 "Looked for SIS5595 but found unsupported device %.4x\n",
840 force_addr
&= ~(SIS5595_EXTENT
- 1);
842 dev_warn(&dev
->dev
, "Forcing ISA address 0x%x\n", force_addr
);
843 pci_write_config_word(dev
, SIS5595_BASE_REG
, force_addr
);
846 if (PCIBIOS_SUCCESSFUL
!=
847 pci_read_config_word(dev
, SIS5595_BASE_REG
, &address
)) {
848 dev_err(&dev
->dev
, "Failed to read ISA address\n");
852 address
&= ~(SIS5595_EXTENT
- 1);
855 "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
858 if (force_addr
&& address
!= force_addr
) {
859 /* doesn't work for some chips? */
860 dev_err(&dev
->dev
, "Failed to force ISA address\n");
864 if (PCIBIOS_SUCCESSFUL
!=
865 pci_read_config_byte(dev
, SIS5595_ENABLE_REG
, &enable
)) {
866 dev_err(&dev
->dev
, "Failed to read enable register\n");
869 if (!(enable
& 0x80)) {
870 if ((PCIBIOS_SUCCESSFUL
!=
871 pci_write_config_byte(dev
, SIS5595_ENABLE_REG
,
873 || (PCIBIOS_SUCCESSFUL
!=
874 pci_read_config_byte(dev
, SIS5595_ENABLE_REG
, &enable
))
875 || (!(enable
& 0x80))) {
876 /* doesn't work for some chips! */
877 dev_err(&dev
->dev
, "Failed to enable HWM device\n");
882 if (platform_driver_register(&sis5595_driver
)) {
883 dev_dbg(&dev
->dev
, "Failed to register sis5595 driver\n");
887 s_bridge
= pci_dev_get(dev
);
888 /* Sets global pdev as a side effect */
889 if (sis5595_device_add(address
))
890 goto exit_unregister
;
893 * Always return failure here. This is to allow other drivers to bind
894 * to this pci device. We don't really want to have control over the
895 * pci device, we only wanted to read as few register values from it.
901 platform_driver_unregister(&sis5595_driver
);
906 static struct pci_driver sis5595_pci_driver
= {
908 .id_table
= sis5595_pci_ids
,
909 .probe
= sis5595_pci_probe
,
912 static int __init
sm_sis5595_init(void)
914 return pci_register_driver(&sis5595_pci_driver
);
917 static void __exit
sm_sis5595_exit(void)
919 pci_unregister_driver(&sis5595_pci_driver
);
920 if (s_bridge
!= NULL
) {
921 platform_device_unregister(pdev
);
922 platform_driver_unregister(&sis5595_driver
);
923 pci_dev_put(s_bridge
);
928 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
929 MODULE_DESCRIPTION("SiS 5595 Sensor device");
930 MODULE_LICENSE("GPL");
932 module_init(sm_sis5595_init
);
933 module_exit(sm_sis5595_exit
);