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/i2c.h>
58 #include <linux/i2c-isa.h>
59 #include <linux/i2c-sensor.h>
60 #include <linux/hwmon.h>
61 #include <linux/err.h>
62 #include <linux/init.h>
63 #include <linux/jiffies.h>
67 /* If force_addr is set to anything different from 0, we forcibly enable
68 the device at the given address. */
69 static u16 force_addr;
70 module_param(force_addr, ushort, 0);
71 MODULE_PARM_DESC(force_addr,
72 "Initialize the base address of the sensors");
75 Note that we can't determine the ISA address until we have initialized
77 static unsigned short normal_i2c[] = { I2C_CLIENT_END };
78 static unsigned int normal_isa[] = { 0x0000, I2C_CLIENT_ISA_END };
80 /* Insmod parameters */
81 SENSORS_INSMOD_1(sis5595);
83 /* Many SIS5595 constants specified below */
85 /* Length of ISA address segment */
86 #define SIS5595_EXTENT 8
87 /* PCI Config Registers */
88 #define SIS5595_REVISION_REG 0x08
89 #define SIS5595_BASE_REG 0x68
90 #define SIS5595_PIN_REG 0x7A
91 #define SIS5595_ENABLE_REG 0x7B
93 /* Where are the ISA address/data registers relative to the base address */
94 #define SIS5595_ADDR_REG_OFFSET 5
95 #define SIS5595_DATA_REG_OFFSET 6
97 /* The SIS5595 registers */
98 #define SIS5595_REG_IN_MAX(nr) (0x2b + (nr) * 2)
99 #define SIS5595_REG_IN_MIN(nr) (0x2c + (nr) * 2)
100 #define SIS5595_REG_IN(nr) (0x20 + (nr))
102 #define SIS5595_REG_FAN_MIN(nr) (0x3b + (nr))
103 #define SIS5595_REG_FAN(nr) (0x28 + (nr))
105 /* On the first version of the chip, the temp registers are separate.
106 On the second version,
107 TEMP pin is shared with IN4, configured in PCI register 0x7A.
108 The registers are the same as well.
109 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
124 /* Conversions. Limit checking is only done on the TO_REG
127 /* IN: mV, (0V to 4.08V)
129 static inline u8 IN_TO_REG(unsigned long val)
131 unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
132 return (nval + 8) / 16;
134 #define IN_FROM_REG(val) ((val) * 16)
136 static inline u8 FAN_TO_REG(long rpm, int div)
140 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
143 static inline int FAN_FROM_REG(u8 val, int div)
145 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
148 /* TEMP: mC (-54.12C to +157.53C)
149 REG: 0.83C/bit + 52.12, two's complement */
150 static inline int TEMP_FROM_REG(s8 val)
152 return val * 830 + 52120;
154 static inline s8 TEMP_TO_REG(int val)
156 int nval = SENSORS_LIMIT(val, -54120, 157530) ;
157 return nval<0 ? (nval-5212-415)/830 : (nval-5212+415)/830;
160 /* FAN DIV: 1, 2, 4, or 8 (defaults to 2)
161 REG: 0, 1, 2, or 3 (respectively) (defaults to 1) */
162 static inline u8 DIV_TO_REG(int val)
164 return val==8 ? 3 : val==4 ? 2 : val==1 ? 0 : 1;
166 #define DIV_FROM_REG(val) (1 << (val))
168 /* For the SIS5595, we need to keep some data in memory. That
169 data is pointed to by sis5595_list[NR]->data. The structure itself is
170 dynamically allocated, at the time when the new sis5595 client is
172 struct sis5595_data {
173 struct i2c_client client;
174 struct class_device *class_dev;
175 struct semaphore lock;
177 struct semaphore update_lock;
178 char valid; /* !=0 if following fields are valid */
179 unsigned long last_updated; /* In jiffies */
180 char maxins; /* == 3 if temp enabled, otherwise == 4 */
181 u8 revision; /* Reg. value */
183 u8 in[5]; /* Register value */
184 u8 in_max[5]; /* Register value */
185 u8 in_min[5]; /* Register value */
186 u8 fan[2]; /* Register value */
187 u8 fan_min[2]; /* Register value */
188 s8 temp; /* Register value */
189 s8 temp_over; /* Register value */
190 s8 temp_hyst; /* Register value */
191 u8 fan_div[2]; /* Register encoding, shifted right */
192 u16 alarms; /* Register encoding, combined */
195 static struct pci_dev *s_bridge; /* pointer to the (only) sis5595 */
197 static int sis5595_attach_adapter(struct i2c_adapter *adapter);
198 static int sis5595_detect(struct i2c_adapter *adapter, int address, int kind);
199 static int sis5595_detach_client(struct i2c_client *client);
201 static int sis5595_read_value(struct i2c_client *client, u8 register);
202 static int sis5595_write_value(struct i2c_client *client, u8 register, u8 value);
203 static struct sis5595_data *sis5595_update_device(struct device *dev);
204 static void sis5595_init_client(struct i2c_client *client);
206 static struct i2c_driver sis5595_driver = {
207 .owner = THIS_MODULE,
209 .id = I2C_DRIVERID_SIS5595,
210 .flags = I2C_DF_NOTIFY,
211 .attach_adapter = sis5595_attach_adapter,
212 .detach_client = sis5595_detach_client,
216 static ssize_t show_in(struct device *dev, char *buf, int nr)
218 struct sis5595_data *data = sis5595_update_device(dev);
219 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
222 static ssize_t show_in_min(struct device *dev, char *buf, int nr)
224 struct sis5595_data *data = sis5595_update_device(dev);
225 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
228 static ssize_t show_in_max(struct device *dev, char *buf, int nr)
230 struct sis5595_data *data = sis5595_update_device(dev);
231 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
234 static ssize_t set_in_min(struct device *dev, const char *buf,
235 size_t count, int nr)
237 struct i2c_client *client = to_i2c_client(dev);
238 struct sis5595_data *data = i2c_get_clientdata(client);
239 unsigned long val = simple_strtoul(buf, NULL, 10);
241 down(&data->update_lock);
242 data->in_min[nr] = IN_TO_REG(val);
243 sis5595_write_value(client, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
244 up(&data->update_lock);
248 static ssize_t set_in_max(struct device *dev, const char *buf,
249 size_t count, int nr)
251 struct i2c_client *client = to_i2c_client(dev);
252 struct sis5595_data *data = i2c_get_clientdata(client);
253 unsigned long val = simple_strtoul(buf, NULL, 10);
255 down(&data->update_lock);
256 data->in_max[nr] = IN_TO_REG(val);
257 sis5595_write_value(client, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
258 up(&data->update_lock);
262 #define show_in_offset(offset) \
264 show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \
266 return show_in(dev, buf, offset); \
268 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \
269 show_in##offset, NULL); \
271 show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
273 return show_in_min(dev, buf, offset); \
276 show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \
278 return show_in_max(dev, buf, offset); \
280 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
281 const char *buf, size_t count) \
283 return set_in_min(dev, buf, count, offset); \
285 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
286 const char *buf, size_t count) \
288 return set_in_max(dev, buf, count, offset); \
290 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
291 show_in##offset##_min, set_in##offset##_min); \
292 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
293 show_in##offset##_max, set_in##offset##_max);
302 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
304 struct sis5595_data *data = sis5595_update_device(dev);
305 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
308 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
310 struct sis5595_data *data = sis5595_update_device(dev);
311 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
314 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
316 struct i2c_client *client = to_i2c_client(dev);
317 struct sis5595_data *data = i2c_get_clientdata(client);
318 long val = simple_strtol(buf, NULL, 10);
320 down(&data->update_lock);
321 data->temp_over = TEMP_TO_REG(val);
322 sis5595_write_value(client, SIS5595_REG_TEMP_OVER, data->temp_over);
323 up(&data->update_lock);
327 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
329 struct sis5595_data *data = sis5595_update_device(dev);
330 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
333 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
335 struct i2c_client *client = to_i2c_client(dev);
336 struct sis5595_data *data = i2c_get_clientdata(client);
337 long val = simple_strtol(buf, NULL, 10);
339 down(&data->update_lock);
340 data->temp_hyst = TEMP_TO_REG(val);
341 sis5595_write_value(client, SIS5595_REG_TEMP_HYST, data->temp_hyst);
342 up(&data->update_lock);
346 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
347 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
348 show_temp_over, set_temp_over);
349 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
350 show_temp_hyst, set_temp_hyst);
353 static ssize_t show_fan(struct device *dev, char *buf, int nr)
355 struct sis5595_data *data = sis5595_update_device(dev);
356 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
357 DIV_FROM_REG(data->fan_div[nr])) );
360 static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
362 struct sis5595_data *data = sis5595_update_device(dev);
363 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
364 DIV_FROM_REG(data->fan_div[nr])) );
367 static ssize_t set_fan_min(struct device *dev, const char *buf,
368 size_t count, int nr)
370 struct i2c_client *client = to_i2c_client(dev);
371 struct sis5595_data *data = i2c_get_clientdata(client);
372 unsigned long val = simple_strtoul(buf, NULL, 10);
374 down(&data->update_lock);
375 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
376 sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
377 up(&data->update_lock);
381 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
383 struct sis5595_data *data = sis5595_update_device(dev);
384 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
387 /* Note: we save and restore the fan minimum here, because its value is
388 determined in part by the fan divisor. This follows the principle of
389 least suprise; the user doesn't expect the fan minimum to change just
390 because the divisor changed. */
391 static ssize_t set_fan_div(struct device *dev, const char *buf,
392 size_t count, int nr)
394 struct i2c_client *client = to_i2c_client(dev);
395 struct sis5595_data *data = i2c_get_clientdata(client);
397 unsigned long val = simple_strtoul(buf, NULL, 10);
400 down(&data->update_lock);
401 min = FAN_FROM_REG(data->fan_min[nr],
402 DIV_FROM_REG(data->fan_div[nr]));
403 reg = sis5595_read_value(client, SIS5595_REG_FANDIV);
406 case 1: data->fan_div[nr] = 0; break;
407 case 2: data->fan_div[nr] = 1; break;
408 case 4: data->fan_div[nr] = 2; break;
409 case 8: data->fan_div[nr] = 3; break;
411 dev_err(&client->dev, "fan_div value %ld not "
412 "supported. Choose one of 1, 2, 4 or 8!\n", val);
413 up(&data->update_lock);
419 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
422 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
425 sis5595_write_value(client, SIS5595_REG_FANDIV, reg);
427 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
428 sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
429 up(&data->update_lock);
433 #define show_fan_offset(offset) \
434 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
436 return show_fan(dev, buf, offset - 1); \
438 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
440 return show_fan_min(dev, buf, offset - 1); \
442 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \
444 return show_fan_div(dev, buf, offset - 1); \
446 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr, \
447 const char *buf, size_t count) \
449 return set_fan_min(dev, buf, count, offset - 1); \
451 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
452 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
453 show_fan_##offset##_min, set_fan_##offset##_min);
458 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf,
461 return set_fan_div(dev, buf, count, 0) ;
464 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf,
467 return set_fan_div(dev, buf, count, 1) ;
469 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
470 show_fan_1_div, set_fan_1_div);
471 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
472 show_fan_2_div, set_fan_2_div);
475 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
477 struct sis5595_data *data = sis5595_update_device(dev);
478 return sprintf(buf, "%d\n", data->alarms);
480 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
482 /* This is called when the module is loaded */
483 static int sis5595_attach_adapter(struct i2c_adapter *adapter)
485 if (!(adapter->class & I2C_CLASS_HWMON))
487 return i2c_detect(adapter, &addr_data, sis5595_detect);
490 int sis5595_detect(struct i2c_adapter *adapter, int address, int kind)
494 struct i2c_client *new_client;
495 struct sis5595_data *data;
499 /* Make sure we are probing the ISA bus!! */
500 if (!i2c_is_isa_adapter(adapter))
504 address = force_addr & ~(SIS5595_EXTENT - 1);
505 /* Reserve the ISA region */
506 if (!request_region(address, SIS5595_EXTENT, sis5595_driver.name)) {
511 dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n", address);
512 if (PCIBIOS_SUCCESSFUL !=
513 pci_write_config_word(s_bridge, SIS5595_BASE_REG, address))
515 if (PCIBIOS_SUCCESSFUL !=
516 pci_read_config_word(s_bridge, SIS5595_BASE_REG, &a))
518 if ((a & ~(SIS5595_EXTENT - 1)) != address)
519 /* doesn't work for some chips? */
523 if (PCIBIOS_SUCCESSFUL !=
524 pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val)) {
527 if ((val & 0x80) == 0) {
528 if (PCIBIOS_SUCCESSFUL !=
529 pci_write_config_byte(s_bridge, SIS5595_ENABLE_REG,
532 if (PCIBIOS_SUCCESSFUL !=
533 pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val))
535 if ((val & 0x80) == 0)
536 /* doesn't work for some chips! */
540 if (!(data = kmalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
544 memset(data, 0, sizeof(struct sis5595_data));
546 new_client = &data->client;
547 new_client->addr = address;
548 init_MUTEX(&data->lock);
549 i2c_set_clientdata(new_client, data);
550 new_client->adapter = adapter;
551 new_client->driver = &sis5595_driver;
552 new_client->flags = 0;
554 /* Check revision and pin registers to determine whether 4 or 5 voltages */
555 pci_read_config_byte(s_bridge, SIS5595_REVISION_REG, &(data->revision));
556 /* 4 voltages, 1 temp */
558 if (data->revision >= REV2MIN) {
559 pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val);
561 /* 5 voltages, no temps */
565 /* Fill in the remaining client fields and put it into the global list */
566 strlcpy(new_client->name, "sis5595", I2C_NAME_SIZE);
569 init_MUTEX(&data->update_lock);
571 /* Tell the I2C layer a new client has arrived */
572 if ((err = i2c_attach_client(new_client)))
575 /* Initialize the SIS5595 chip */
576 sis5595_init_client(new_client);
578 /* A few vars need to be filled upon startup */
579 for (i = 0; i < 2; i++) {
580 data->fan_min[i] = sis5595_read_value(new_client,
581 SIS5595_REG_FAN_MIN(i));
584 /* Register sysfs hooks */
585 data->class_dev = hwmon_device_register(&new_client->dev);
586 if (IS_ERR(data->class_dev)) {
587 err = PTR_ERR(data->class_dev);
591 device_create_file(&new_client->dev, &dev_attr_in0_input);
592 device_create_file(&new_client->dev, &dev_attr_in0_min);
593 device_create_file(&new_client->dev, &dev_attr_in0_max);
594 device_create_file(&new_client->dev, &dev_attr_in1_input);
595 device_create_file(&new_client->dev, &dev_attr_in1_min);
596 device_create_file(&new_client->dev, &dev_attr_in1_max);
597 device_create_file(&new_client->dev, &dev_attr_in2_input);
598 device_create_file(&new_client->dev, &dev_attr_in2_min);
599 device_create_file(&new_client->dev, &dev_attr_in2_max);
600 device_create_file(&new_client->dev, &dev_attr_in3_input);
601 device_create_file(&new_client->dev, &dev_attr_in3_min);
602 device_create_file(&new_client->dev, &dev_attr_in3_max);
603 if (data->maxins == 4) {
604 device_create_file(&new_client->dev, &dev_attr_in4_input);
605 device_create_file(&new_client->dev, &dev_attr_in4_min);
606 device_create_file(&new_client->dev, &dev_attr_in4_max);
608 device_create_file(&new_client->dev, &dev_attr_fan1_input);
609 device_create_file(&new_client->dev, &dev_attr_fan1_min);
610 device_create_file(&new_client->dev, &dev_attr_fan1_div);
611 device_create_file(&new_client->dev, &dev_attr_fan2_input);
612 device_create_file(&new_client->dev, &dev_attr_fan2_min);
613 device_create_file(&new_client->dev, &dev_attr_fan2_div);
614 device_create_file(&new_client->dev, &dev_attr_alarms);
615 if (data->maxins == 3) {
616 device_create_file(&new_client->dev, &dev_attr_temp1_input);
617 device_create_file(&new_client->dev, &dev_attr_temp1_max);
618 device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
623 i2c_detach_client(new_client);
627 release_region(address, SIS5595_EXTENT);
632 static int sis5595_detach_client(struct i2c_client *client)
634 struct sis5595_data *data = i2c_get_clientdata(client);
637 hwmon_device_unregister(data->class_dev);
639 if ((err = i2c_detach_client(client))) {
640 dev_err(&client->dev,
641 "Client deregistration failed, client not detached.\n");
645 if (i2c_is_isa_client(client))
646 release_region(client->addr, SIS5595_EXTENT);
654 /* ISA access must be locked explicitly. */
655 static int sis5595_read_value(struct i2c_client *client, u8 reg)
659 struct sis5595_data *data = i2c_get_clientdata(client);
661 outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
662 res = inb_p(client->addr + SIS5595_DATA_REG_OFFSET);
667 static int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value)
669 struct sis5595_data *data = i2c_get_clientdata(client);
671 outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
672 outb_p(value, client->addr + SIS5595_DATA_REG_OFFSET);
677 /* Called when we have found a new SIS5595. */
678 static void sis5595_init_client(struct i2c_client *client)
680 u8 config = sis5595_read_value(client, SIS5595_REG_CONFIG);
681 if (!(config & 0x01))
682 sis5595_write_value(client, SIS5595_REG_CONFIG,
683 (config & 0xf7) | 0x01);
686 static struct sis5595_data *sis5595_update_device(struct device *dev)
688 struct i2c_client *client = to_i2c_client(dev);
689 struct sis5595_data *data = i2c_get_clientdata(client);
692 down(&data->update_lock);
694 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
697 for (i = 0; i <= data->maxins; i++) {
699 sis5595_read_value(client, SIS5595_REG_IN(i));
701 sis5595_read_value(client,
702 SIS5595_REG_IN_MIN(i));
704 sis5595_read_value(client,
705 SIS5595_REG_IN_MAX(i));
707 for (i = 0; i < 2; i++) {
709 sis5595_read_value(client, SIS5595_REG_FAN(i));
711 sis5595_read_value(client,
712 SIS5595_REG_FAN_MIN(i));
714 if (data->maxins == 3) {
716 sis5595_read_value(client, SIS5595_REG_TEMP);
718 sis5595_read_value(client, SIS5595_REG_TEMP_OVER);
720 sis5595_read_value(client, SIS5595_REG_TEMP_HYST);
722 i = sis5595_read_value(client, SIS5595_REG_FANDIV);
723 data->fan_div[0] = (i >> 4) & 0x03;
724 data->fan_div[1] = i >> 6;
726 sis5595_read_value(client, SIS5595_REG_ALARM1) |
727 (sis5595_read_value(client, SIS5595_REG_ALARM2) << 8);
728 data->last_updated = jiffies;
732 up(&data->update_lock);
737 static struct pci_device_id sis5595_pci_ids[] = {
738 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
742 MODULE_DEVICE_TABLE(pci, sis5595_pci_ids);
744 static int blacklist[] __devinitdata = {
745 PCI_DEVICE_ID_SI_540,
746 PCI_DEVICE_ID_SI_550,
747 PCI_DEVICE_ID_SI_630,
748 PCI_DEVICE_ID_SI_645,
749 PCI_DEVICE_ID_SI_730,
750 PCI_DEVICE_ID_SI_735,
751 PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but
752 that ID shows up in other chips so we
753 use the 5511 ID for recognition */
754 PCI_DEVICE_ID_SI_5597,
755 PCI_DEVICE_ID_SI_5598,
758 static int __devinit sis5595_pci_probe(struct pci_dev *dev,
759 const struct pci_device_id *id)
765 for (i = blacklist; *i != 0; i++) {
767 dev = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
769 dev_err(&dev->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
775 if (PCIBIOS_SUCCESSFUL !=
776 pci_read_config_word(dev, SIS5595_BASE_REG, &val))
779 addr = val & ~(SIS5595_EXTENT - 1);
780 if (addr == 0 && force_addr == 0) {
781 dev_err(&dev->dev, "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
785 addr = force_addr; /* so detect will get called */
788 dev_err(&dev->dev,"No SiS 5595 sensors found.\n");
791 normal_isa[0] = addr;
793 s_bridge = pci_dev_get(dev);
794 if (i2c_isa_add_driver(&sis5595_driver)) {
795 pci_dev_put(s_bridge);
799 /* Always return failure here. This is to allow other drivers to bind
800 * to this pci device. We don't really want to have control over the
801 * pci device, we only wanted to read as few register values from it.
806 static struct pci_driver sis5595_pci_driver = {
808 .id_table = sis5595_pci_ids,
809 .probe = sis5595_pci_probe,
812 static int __init sm_sis5595_init(void)
814 return pci_register_driver(&sis5595_pci_driver);
817 static void __exit sm_sis5595_exit(void)
819 pci_unregister_driver(&sis5595_pci_driver);
820 if (s_bridge != NULL) {
821 i2c_isa_del_driver(&sis5595_driver);
822 pci_dev_put(s_bridge);
827 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
828 MODULE_DESCRIPTION("SiS 5595 Sensor device");
829 MODULE_LICENSE("GPL");
831 module_init(sm_sis5595_init);
832 module_exit(sm_sis5595_exit);