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 #include <linux/module.h>
54 #include <linux/slab.h>
55 #include <linux/ioport.h>
56 #include <linux/pci.h>
57 #include <linux/platform_device.h>
58 #include <linux/hwmon.h>
59 #include <linux/hwmon-sysfs.h>
60 #include <linux/err.h>
61 #include <linux/init.h>
62 #include <linux/jiffies.h>
63 #include <linux/mutex.h>
64 #include <linux/sysfs.h>
68 /* If force_addr is set to anything different from 0, we forcibly enable
69 the device at the given address. */
70 static u16 force_addr;
71 module_param(force_addr, ushort, 0);
72 MODULE_PARM_DESC(force_addr,
73 "Initialize the base address of the sensors");
75 static struct platform_device *pdev;
77 /* Many SIS5595 constants specified below */
79 /* Length of ISA address segment */
80 #define SIS5595_EXTENT 8
81 /* PCI Config Registers */
82 #define SIS5595_REVISION_REG 0x08
83 #define SIS5595_BASE_REG 0x68
84 #define SIS5595_PIN_REG 0x7A
85 #define SIS5595_ENABLE_REG 0x7B
87 /* Where are the ISA address/data registers relative to the base address */
88 #define SIS5595_ADDR_REG_OFFSET 5
89 #define SIS5595_DATA_REG_OFFSET 6
91 /* The SIS5595 registers */
92 #define SIS5595_REG_IN_MAX(nr) (0x2b + (nr) * 2)
93 #define SIS5595_REG_IN_MIN(nr) (0x2c + (nr) * 2)
94 #define SIS5595_REG_IN(nr) (0x20 + (nr))
96 #define SIS5595_REG_FAN_MIN(nr) (0x3b + (nr))
97 #define SIS5595_REG_FAN(nr) (0x28 + (nr))
99 /* On the first version of the chip, the temp registers are separate.
100 On the second version,
101 TEMP pin is shared with IN4, configured in PCI register 0x7A.
102 The registers are the same as well.
103 OVER and HYST are really MAX and MIN. */
106 #define SIS5595_REG_TEMP (( data->revision) >= REV2MIN) ? \
107 SIS5595_REG_IN(4) : 0x27
108 #define SIS5595_REG_TEMP_OVER (( data->revision) >= REV2MIN) ? \
109 SIS5595_REG_IN_MAX(4) : 0x39
110 #define SIS5595_REG_TEMP_HYST (( data->revision) >= REV2MIN) ? \
111 SIS5595_REG_IN_MIN(4) : 0x3a
113 #define SIS5595_REG_CONFIG 0x40
114 #define SIS5595_REG_ALARM1 0x41
115 #define SIS5595_REG_ALARM2 0x42
116 #define SIS5595_REG_FANDIV 0x47
118 /* Conversions. Limit checking is only done on the TO_REG
121 /* IN: mV, (0V to 4.08V)
123 static inline u8 IN_TO_REG(unsigned long val)
125 unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
126 return (nval + 8) / 16;
128 #define IN_FROM_REG(val) ((val) * 16)
130 static inline u8 FAN_TO_REG(long rpm, int div)
134 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
137 static inline int FAN_FROM_REG(u8 val, int div)
139 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
142 /* TEMP: mC (-54.12C to +157.53C)
143 REG: 0.83C/bit + 52.12, two's complement */
144 static inline int TEMP_FROM_REG(s8 val)
146 return val * 830 + 52120;
148 static inline s8 TEMP_TO_REG(int val)
150 int nval = SENSORS_LIMIT(val, -54120, 157530) ;
151 return nval<0 ? (nval-5212-415)/830 : (nval-5212+415)/830;
154 /* FAN DIV: 1, 2, 4, or 8 (defaults to 2)
155 REG: 0, 1, 2, or 3 (respectively) (defaults to 1) */
156 static inline u8 DIV_TO_REG(int val)
158 return val==8 ? 3 : val==4 ? 2 : val==1 ? 0 : 1;
160 #define DIV_FROM_REG(val) (1 << (val))
162 /* For each registered chip, we need to keep some data in memory.
163 The structure is dynamically allocated. */
164 struct sis5595_data {
167 struct class_device *class_dev;
170 struct mutex update_lock;
171 char valid; /* !=0 if following fields are valid */
172 unsigned long last_updated; /* In jiffies */
173 char maxins; /* == 3 if temp enabled, otherwise == 4 */
174 u8 revision; /* Reg. value */
176 u8 in[5]; /* Register value */
177 u8 in_max[5]; /* Register value */
178 u8 in_min[5]; /* Register value */
179 u8 fan[2]; /* Register value */
180 u8 fan_min[2]; /* Register value */
181 s8 temp; /* Register value */
182 s8 temp_over; /* Register value */
183 s8 temp_hyst; /* Register value */
184 u8 fan_div[2]; /* Register encoding, shifted right */
185 u16 alarms; /* Register encoding, combined */
188 static struct pci_dev *s_bridge; /* pointer to the (only) sis5595 */
190 static int sis5595_probe(struct platform_device *pdev);
191 static int sis5595_remove(struct platform_device *pdev);
193 static int sis5595_read_value(struct sis5595_data *data, u8 reg);
194 static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value);
195 static struct sis5595_data *sis5595_update_device(struct device *dev);
196 static void sis5595_init_device(struct sis5595_data *data);
198 static struct platform_driver sis5595_driver = {
200 .owner = THIS_MODULE,
203 .probe = sis5595_probe,
204 .remove = __devexit_p(sis5595_remove),
208 static ssize_t show_in(struct device *dev, struct device_attribute *da,
211 struct sis5595_data *data = sis5595_update_device(dev);
212 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
213 int nr = attr->index;
214 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
217 static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
220 struct sis5595_data *data = sis5595_update_device(dev);
221 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
222 int nr = attr->index;
223 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
226 static ssize_t show_in_max(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_max[nr]));
235 static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
236 const char *buf, size_t count)
238 struct sis5595_data *data = dev_get_drvdata(dev);
239 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
240 int nr = attr->index;
241 unsigned long val = simple_strtoul(buf, NULL, 10);
243 mutex_lock(&data->update_lock);
244 data->in_min[nr] = IN_TO_REG(val);
245 sis5595_write_value(data, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
246 mutex_unlock(&data->update_lock);
250 static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
251 const char *buf, size_t count)
253 struct sis5595_data *data = dev_get_drvdata(dev);
254 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
255 int nr = attr->index;
256 unsigned long val = simple_strtoul(buf, NULL, 10);
258 mutex_lock(&data->update_lock);
259 data->in_max[nr] = IN_TO_REG(val);
260 sis5595_write_value(data, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
261 mutex_unlock(&data->update_lock);
265 #define show_in_offset(offset) \
266 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
267 show_in, NULL, offset); \
268 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
269 show_in_min, set_in_min, offset); \
270 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
271 show_in_max, set_in_max, offset);
280 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
282 struct sis5595_data *data = sis5595_update_device(dev);
283 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
286 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
288 struct sis5595_data *data = sis5595_update_device(dev);
289 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
292 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
294 struct sis5595_data *data = dev_get_drvdata(dev);
295 long val = simple_strtol(buf, NULL, 10);
297 mutex_lock(&data->update_lock);
298 data->temp_over = TEMP_TO_REG(val);
299 sis5595_write_value(data, SIS5595_REG_TEMP_OVER, data->temp_over);
300 mutex_unlock(&data->update_lock);
304 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
306 struct sis5595_data *data = sis5595_update_device(dev);
307 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
310 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
312 struct sis5595_data *data = dev_get_drvdata(dev);
313 long val = simple_strtol(buf, NULL, 10);
315 mutex_lock(&data->update_lock);
316 data->temp_hyst = TEMP_TO_REG(val);
317 sis5595_write_value(data, SIS5595_REG_TEMP_HYST, data->temp_hyst);
318 mutex_unlock(&data->update_lock);
322 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
323 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
324 show_temp_over, set_temp_over);
325 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
326 show_temp_hyst, set_temp_hyst);
329 static ssize_t show_fan(struct device *dev, struct device_attribute *da,
332 struct sis5595_data *data = sis5595_update_device(dev);
333 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
334 int nr = attr->index;
335 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
336 DIV_FROM_REG(data->fan_div[nr])) );
339 static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
342 struct sis5595_data *data = sis5595_update_device(dev);
343 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
344 int nr = attr->index;
345 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
346 DIV_FROM_REG(data->fan_div[nr])) );
349 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
350 const char *buf, size_t count)
352 struct sis5595_data *data = dev_get_drvdata(dev);
353 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
354 int nr = attr->index;
355 unsigned long val = simple_strtoul(buf, NULL, 10);
357 mutex_lock(&data->update_lock);
358 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
359 sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
360 mutex_unlock(&data->update_lock);
364 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
367 struct sis5595_data *data = sis5595_update_device(dev);
368 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
369 int nr = attr->index;
370 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
373 /* Note: we save and restore the fan minimum here, because its value is
374 determined in part by the fan divisor. This follows the principle of
375 least surprise; the user doesn't expect the fan minimum to change just
376 because the divisor changed. */
377 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
378 const char *buf, size_t count)
380 struct sis5595_data *data = dev_get_drvdata(dev);
381 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
382 int nr = attr->index;
384 unsigned long val = simple_strtoul(buf, NULL, 10);
387 mutex_lock(&data->update_lock);
388 min = FAN_FROM_REG(data->fan_min[nr],
389 DIV_FROM_REG(data->fan_div[nr]));
390 reg = sis5595_read_value(data, SIS5595_REG_FANDIV);
393 case 1: data->fan_div[nr] = 0; break;
394 case 2: data->fan_div[nr] = 1; break;
395 case 4: data->fan_div[nr] = 2; break;
396 case 8: data->fan_div[nr] = 3; break;
398 dev_err(dev, "fan_div value %ld not "
399 "supported. Choose one of 1, 2, 4 or 8!\n", val);
400 mutex_unlock(&data->update_lock);
406 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
409 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
412 sis5595_write_value(data, SIS5595_REG_FANDIV, reg);
414 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
415 sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
416 mutex_unlock(&data->update_lock);
420 #define show_fan_offset(offset) \
421 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
422 show_fan, NULL, offset - 1); \
423 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
424 show_fan_min, set_fan_min, offset - 1); \
425 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
426 show_fan_div, set_fan_div, offset - 1);
432 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
434 struct sis5595_data *data = sis5595_update_device(dev);
435 return sprintf(buf, "%d\n", data->alarms);
437 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
439 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
442 struct sis5595_data *data = dev_get_drvdata(dev);
443 return sprintf(buf, "%s\n", data->name);
445 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
447 static struct attribute *sis5595_attributes[] = {
448 &sensor_dev_attr_in0_input.dev_attr.attr,
449 &sensor_dev_attr_in0_min.dev_attr.attr,
450 &sensor_dev_attr_in0_max.dev_attr.attr,
451 &sensor_dev_attr_in1_input.dev_attr.attr,
452 &sensor_dev_attr_in1_min.dev_attr.attr,
453 &sensor_dev_attr_in1_max.dev_attr.attr,
454 &sensor_dev_attr_in2_input.dev_attr.attr,
455 &sensor_dev_attr_in2_min.dev_attr.attr,
456 &sensor_dev_attr_in2_max.dev_attr.attr,
457 &sensor_dev_attr_in3_input.dev_attr.attr,
458 &sensor_dev_attr_in3_min.dev_attr.attr,
459 &sensor_dev_attr_in3_max.dev_attr.attr,
461 &sensor_dev_attr_fan1_input.dev_attr.attr,
462 &sensor_dev_attr_fan1_min.dev_attr.attr,
463 &sensor_dev_attr_fan1_div.dev_attr.attr,
464 &sensor_dev_attr_fan2_input.dev_attr.attr,
465 &sensor_dev_attr_fan2_min.dev_attr.attr,
466 &sensor_dev_attr_fan2_div.dev_attr.attr,
468 &dev_attr_alarms.attr,
473 static const struct attribute_group sis5595_group = {
474 .attrs = sis5595_attributes,
477 static struct attribute *sis5595_attributes_opt[] = {
478 &sensor_dev_attr_in4_input.dev_attr.attr,
479 &sensor_dev_attr_in4_min.dev_attr.attr,
480 &sensor_dev_attr_in4_max.dev_attr.attr,
482 &dev_attr_temp1_input.attr,
483 &dev_attr_temp1_max.attr,
484 &dev_attr_temp1_max_hyst.attr,
488 static const struct attribute_group sis5595_group_opt = {
489 .attrs = sis5595_attributes_opt,
492 /* This is called when the module is loaded */
493 static int __devinit sis5595_probe(struct platform_device *pdev)
497 struct sis5595_data *data;
498 struct resource *res;
501 /* Reserve the ISA region */
502 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
503 if (!request_region(res->start, SIS5595_EXTENT,
504 sis5595_driver.driver.name)) {
509 if (!(data = kzalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
514 mutex_init(&data->lock);
515 mutex_init(&data->update_lock);
516 data->addr = res->start;
517 data->name = "sis5595";
518 platform_set_drvdata(pdev, data);
520 /* Check revision and pin registers to determine whether 4 or 5 voltages */
521 pci_read_config_byte(s_bridge, SIS5595_REVISION_REG, &(data->revision));
522 /* 4 voltages, 1 temp */
524 if (data->revision >= REV2MIN) {
525 pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val);
527 /* 5 voltages, no temps */
531 /* Initialize the SIS5595 chip */
532 sis5595_init_device(data);
534 /* A few vars need to be filled upon startup */
535 for (i = 0; i < 2; i++) {
536 data->fan_min[i] = sis5595_read_value(data,
537 SIS5595_REG_FAN_MIN(i));
540 /* Register sysfs hooks */
541 if ((err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group)))
543 if (data->maxins == 4) {
544 if ((err = device_create_file(&pdev->dev,
545 &sensor_dev_attr_in4_input.dev_attr))
546 || (err = device_create_file(&pdev->dev,
547 &sensor_dev_attr_in4_min.dev_attr))
548 || (err = device_create_file(&pdev->dev,
549 &sensor_dev_attr_in4_max.dev_attr)))
550 goto exit_remove_files;
552 if ((err = device_create_file(&pdev->dev,
553 &dev_attr_temp1_input))
554 || (err = device_create_file(&pdev->dev,
555 &dev_attr_temp1_max))
556 || (err = device_create_file(&pdev->dev,
557 &dev_attr_temp1_max_hyst)))
558 goto exit_remove_files;
561 data->class_dev = hwmon_device_register(&pdev->dev);
562 if (IS_ERR(data->class_dev)) {
563 err = PTR_ERR(data->class_dev);
564 goto exit_remove_files;
570 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
571 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_opt);
575 release_region(res->start, SIS5595_EXTENT);
580 static int __devexit sis5595_remove(struct platform_device *pdev)
582 struct sis5595_data *data = platform_get_drvdata(pdev);
584 hwmon_device_unregister(data->class_dev);
585 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
586 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_opt);
588 release_region(data->addr, SIS5595_EXTENT);
589 platform_set_drvdata(pdev, NULL);
596 /* ISA access must be locked explicitly. */
597 static int sis5595_read_value(struct sis5595_data *data, u8 reg)
601 mutex_lock(&data->lock);
602 outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
603 res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET);
604 mutex_unlock(&data->lock);
608 static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value)
610 mutex_lock(&data->lock);
611 outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
612 outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET);
613 mutex_unlock(&data->lock);
616 /* Called when we have found a new SIS5595. */
617 static void __devinit sis5595_init_device(struct sis5595_data *data)
619 u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG);
620 if (!(config & 0x01))
621 sis5595_write_value(data, SIS5595_REG_CONFIG,
622 (config & 0xf7) | 0x01);
625 static struct sis5595_data *sis5595_update_device(struct device *dev)
627 struct sis5595_data *data = dev_get_drvdata(dev);
630 mutex_lock(&data->update_lock);
632 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
635 for (i = 0; i <= data->maxins; i++) {
637 sis5595_read_value(data, SIS5595_REG_IN(i));
639 sis5595_read_value(data,
640 SIS5595_REG_IN_MIN(i));
642 sis5595_read_value(data,
643 SIS5595_REG_IN_MAX(i));
645 for (i = 0; i < 2; i++) {
647 sis5595_read_value(data, SIS5595_REG_FAN(i));
649 sis5595_read_value(data,
650 SIS5595_REG_FAN_MIN(i));
652 if (data->maxins == 3) {
654 sis5595_read_value(data, SIS5595_REG_TEMP);
656 sis5595_read_value(data, SIS5595_REG_TEMP_OVER);
658 sis5595_read_value(data, SIS5595_REG_TEMP_HYST);
660 i = sis5595_read_value(data, SIS5595_REG_FANDIV);
661 data->fan_div[0] = (i >> 4) & 0x03;
662 data->fan_div[1] = i >> 6;
664 sis5595_read_value(data, SIS5595_REG_ALARM1) |
665 (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8);
666 data->last_updated = jiffies;
670 mutex_unlock(&data->update_lock);
675 static struct pci_device_id sis5595_pci_ids[] = {
676 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
680 MODULE_DEVICE_TABLE(pci, sis5595_pci_ids);
682 static int blacklist[] __devinitdata = {
683 PCI_DEVICE_ID_SI_540,
684 PCI_DEVICE_ID_SI_550,
685 PCI_DEVICE_ID_SI_630,
686 PCI_DEVICE_ID_SI_645,
687 PCI_DEVICE_ID_SI_730,
688 PCI_DEVICE_ID_SI_735,
689 PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but
690 that ID shows up in other chips so we
691 use the 5511 ID for recognition */
692 PCI_DEVICE_ID_SI_5597,
693 PCI_DEVICE_ID_SI_5598,
696 static int __devinit sis5595_device_add(unsigned short address)
698 struct resource res = {
700 .end = address + SIS5595_EXTENT - 1,
702 .flags = IORESOURCE_IO,
706 pdev = platform_device_alloc("sis5595", address);
709 printk(KERN_ERR "sis5595: Device allocation failed\n");
713 err = platform_device_add_resources(pdev, &res, 1);
715 printk(KERN_ERR "sis5595: Device resource addition failed "
717 goto exit_device_put;
720 err = platform_device_add(pdev);
722 printk(KERN_ERR "sis5595: Device addition failed (%d)\n",
724 goto exit_device_put;
730 platform_device_put(pdev);
735 static int __devinit sis5595_pci_probe(struct pci_dev *dev,
736 const struct pci_device_id *id)
742 for (i = blacklist; *i != 0; i++) {
744 dev = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
746 dev_err(&dev->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
752 force_addr &= ~(SIS5595_EXTENT - 1);
754 dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", force_addr);
755 pci_write_config_word(dev, SIS5595_BASE_REG, force_addr);
758 if (PCIBIOS_SUCCESSFUL !=
759 pci_read_config_word(dev, SIS5595_BASE_REG, &address)) {
760 dev_err(&dev->dev, "Failed to read ISA address\n");
764 address &= ~(SIS5595_EXTENT - 1);
766 dev_err(&dev->dev, "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
769 if (force_addr && address != force_addr) {
770 /* doesn't work for some chips? */
771 dev_err(&dev->dev, "Failed to force ISA address\n");
775 if (PCIBIOS_SUCCESSFUL !=
776 pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable)) {
777 dev_err(&dev->dev, "Failed to read enable register\n");
780 if (!(enable & 0x80)) {
781 if ((PCIBIOS_SUCCESSFUL !=
782 pci_write_config_byte(dev, SIS5595_ENABLE_REG,
784 || (PCIBIOS_SUCCESSFUL !=
785 pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable))
786 || (!(enable & 0x80))) {
787 /* doesn't work for some chips! */
788 dev_err(&dev->dev, "Failed to enable HWM device\n");
793 if (platform_driver_register(&sis5595_driver)) {
794 dev_dbg(&dev->dev, "Failed to register sis5595 driver\n");
798 s_bridge = pci_dev_get(dev);
799 /* Sets global pdev as a side effect */
800 if (sis5595_device_add(address))
801 goto exit_unregister;
803 /* Always return failure here. This is to allow other drivers to bind
804 * to this pci device. We don't really want to have control over the
805 * pci device, we only wanted to read as few register values from it.
811 platform_driver_unregister(&sis5595_driver);
816 static struct pci_driver sis5595_pci_driver = {
818 .id_table = sis5595_pci_ids,
819 .probe = sis5595_pci_probe,
822 static int __init sm_sis5595_init(void)
824 return pci_register_driver(&sis5595_pci_driver);
827 static void __exit sm_sis5595_exit(void)
829 pci_unregister_driver(&sis5595_pci_driver);
830 if (s_bridge != NULL) {
831 platform_device_unregister(pdev);
832 platform_driver_unregister(&sis5595_driver);
833 pci_dev_put(s_bridge);
838 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
839 MODULE_DESCRIPTION("SiS 5595 Sensor device");
840 MODULE_LICENSE("GPL");
842 module_init(sm_sis5595_init);
843 module_exit(sm_sis5595_exit);