Merge branch 'master' into upstream
[linux-2.6] / drivers / hwmon / sis5595.c
1 /*
2     sis5595.c - Part of lm_sensors, Linux kernel modules
3                 for hardware monitoring
4
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>
10
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.
15
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.
20
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.
24 */
25
26 /*
27    SiS southbridge has a LM78-like chip integrated on the same IC.
28    This driver is a customized copy of lm78.c
29    
30    Supports following revisions:
31         Version         PCI ID          PCI Revision
32         1               1039/0008       AF or less
33         2               1039/0008       B0 or greater
34
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.
38
39    NOT SUPPORTED        PCI ID          BLACKLIST PCI ID        
40          540            0008            0540
41          550            0008            0550
42         5513            0008            5511
43         5581            0008            5597
44         5582            0008            5597
45         5597            0008            5597
46         5598            0008            5597/5598
47          630            0008            0630
48          645            0008            0645
49          730            0008            0730
50          735            0008            0735
51 */
52
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/hwmon.h>
60 #include <linux/err.h>
61 #include <linux/init.h>
62 #include <linux/jiffies.h>
63 #include <linux/mutex.h>
64 #include <asm/io.h>
65
66
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");
73
74 /* Device address
75    Note that we can't determine the ISA address until we have initialized
76    our module */
77 static unsigned short address;
78
79 /* Many SIS5595 constants specified below */
80
81 /* Length of ISA address segment */
82 #define SIS5595_EXTENT 8
83 /* PCI Config Registers */
84 #define SIS5595_REVISION_REG 0x08
85 #define SIS5595_BASE_REG 0x68
86 #define SIS5595_PIN_REG 0x7A
87 #define SIS5595_ENABLE_REG 0x7B
88
89 /* Where are the ISA address/data registers relative to the base address */
90 #define SIS5595_ADDR_REG_OFFSET 5
91 #define SIS5595_DATA_REG_OFFSET 6
92
93 /* The SIS5595 registers */
94 #define SIS5595_REG_IN_MAX(nr) (0x2b + (nr) * 2)
95 #define SIS5595_REG_IN_MIN(nr) (0x2c + (nr) * 2)
96 #define SIS5595_REG_IN(nr) (0x20 + (nr))
97
98 #define SIS5595_REG_FAN_MIN(nr) (0x3b + (nr))
99 #define SIS5595_REG_FAN(nr) (0x28 + (nr))
100
101 /* On the first version of the chip, the temp registers are separate.
102    On the second version,
103    TEMP pin is shared with IN4, configured in PCI register 0x7A.
104    The registers are the same as well.
105    OVER and HYST are really MAX and MIN. */
106
107 #define REV2MIN 0xb0
108 #define SIS5595_REG_TEMP        (( data->revision) >= REV2MIN) ? \
109                                         SIS5595_REG_IN(4) : 0x27
110 #define SIS5595_REG_TEMP_OVER   (( data->revision) >= REV2MIN) ? \
111                                         SIS5595_REG_IN_MAX(4) : 0x39
112 #define SIS5595_REG_TEMP_HYST   (( data->revision) >= REV2MIN) ? \
113                                         SIS5595_REG_IN_MIN(4) : 0x3a
114
115 #define SIS5595_REG_CONFIG 0x40
116 #define SIS5595_REG_ALARM1 0x41
117 #define SIS5595_REG_ALARM2 0x42
118 #define SIS5595_REG_FANDIV 0x47
119
120 /* Conversions. Limit checking is only done on the TO_REG
121    variants. */
122
123 /* IN: mV, (0V to 4.08V)
124    REG: 16mV/bit */
125 static inline u8 IN_TO_REG(unsigned long val)
126 {
127         unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
128         return (nval + 8) / 16;
129 }
130 #define IN_FROM_REG(val) ((val) *  16)
131
132 static inline u8 FAN_TO_REG(long rpm, int div)
133 {
134         if (rpm <= 0)
135                 return 255;
136         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
137 }
138
139 static inline int FAN_FROM_REG(u8 val, int div)
140 {
141         return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
142 }
143
144 /* TEMP: mC (-54.12C to +157.53C)
145    REG: 0.83C/bit + 52.12, two's complement  */
146 static inline int TEMP_FROM_REG(s8 val)
147 {
148         return val * 830 + 52120;
149 }
150 static inline s8 TEMP_TO_REG(int val)
151 {
152         int nval = SENSORS_LIMIT(val, -54120, 157530) ;
153         return nval<0 ? (nval-5212-415)/830 : (nval-5212+415)/830;
154 }
155
156 /* FAN DIV: 1, 2, 4, or 8 (defaults to 2)
157    REG: 0, 1, 2, or 3 (respectively) (defaults to 1) */
158 static inline u8 DIV_TO_REG(int val)
159 {
160         return val==8 ? 3 : val==4 ? 2 : val==1 ? 0 : 1;
161 }
162 #define DIV_FROM_REG(val) (1 << (val))
163
164 /* For the SIS5595, we need to keep some data in memory. That
165    data is pointed to by sis5595_list[NR]->data. The structure itself is
166    dynamically allocated, at the time when the new sis5595 client is
167    allocated. */
168 struct sis5595_data {
169         struct i2c_client client;
170         struct class_device *class_dev;
171         struct mutex lock;
172
173         struct mutex update_lock;
174         char valid;             /* !=0 if following fields are valid */
175         unsigned long last_updated;     /* In jiffies */
176         char maxins;            /* == 3 if temp enabled, otherwise == 4 */
177         u8 revision;            /* Reg. value */
178
179         u8 in[5];               /* Register value */
180         u8 in_max[5];           /* Register value */
181         u8 in_min[5];           /* Register value */
182         u8 fan[2];              /* Register value */
183         u8 fan_min[2];          /* Register value */
184         s8 temp;                /* Register value */
185         s8 temp_over;           /* Register value */
186         s8 temp_hyst;           /* Register value */
187         u8 fan_div[2];          /* Register encoding, shifted right */
188         u16 alarms;             /* Register encoding, combined */
189 };
190
191 static struct pci_dev *s_bridge;        /* pointer to the (only) sis5595 */
192
193 static int sis5595_detect(struct i2c_adapter *adapter);
194 static int sis5595_detach_client(struct i2c_client *client);
195
196 static int sis5595_read_value(struct i2c_client *client, u8 reg);
197 static int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value);
198 static struct sis5595_data *sis5595_update_device(struct device *dev);
199 static void sis5595_init_client(struct i2c_client *client);
200
201 static struct i2c_driver sis5595_driver = {
202         .driver = {
203                 .owner  = THIS_MODULE,
204                 .name   = "sis5595",
205         },
206         .attach_adapter = sis5595_detect,
207         .detach_client  = sis5595_detach_client,
208 };
209
210 /* 4 Voltages */
211 static ssize_t show_in(struct device *dev, char *buf, int nr)
212 {
213         struct sis5595_data *data = sis5595_update_device(dev);
214         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
215 }
216
217 static ssize_t show_in_min(struct device *dev, char *buf, int nr)
218 {
219         struct sis5595_data *data = sis5595_update_device(dev);
220         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
221 }
222
223 static ssize_t show_in_max(struct device *dev, char *buf, int nr)
224 {
225         struct sis5595_data *data = sis5595_update_device(dev);
226         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
227 }
228
229 static ssize_t set_in_min(struct device *dev, const char *buf,
230                size_t count, int nr)
231 {
232         struct i2c_client *client = to_i2c_client(dev);
233         struct sis5595_data *data = i2c_get_clientdata(client);
234         unsigned long val = simple_strtoul(buf, NULL, 10);
235
236         mutex_lock(&data->update_lock);
237         data->in_min[nr] = IN_TO_REG(val);
238         sis5595_write_value(client, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
239         mutex_unlock(&data->update_lock);
240         return count;
241 }
242
243 static ssize_t set_in_max(struct device *dev, const char *buf,
244                size_t count, int nr)
245 {
246         struct i2c_client *client = to_i2c_client(dev);
247         struct sis5595_data *data = i2c_get_clientdata(client);
248         unsigned long val = simple_strtoul(buf, NULL, 10);
249
250         mutex_lock(&data->update_lock);
251         data->in_max[nr] = IN_TO_REG(val);
252         sis5595_write_value(client, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
253         mutex_unlock(&data->update_lock);
254         return count;
255 }
256
257 #define show_in_offset(offset)                                  \
258 static ssize_t                                                  \
259         show_in##offset (struct device *dev, struct device_attribute *attr, char *buf)          \
260 {                                                               \
261         return show_in(dev, buf, offset);                       \
262 }                                                               \
263 static DEVICE_ATTR(in##offset##_input, S_IRUGO,                 \
264                 show_in##offset, NULL);                         \
265 static ssize_t                                                  \
266         show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)    \
267 {                                                               \
268         return show_in_min(dev, buf, offset);                   \
269 }                                                               \
270 static ssize_t                                                  \
271         show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf)    \
272 {                                                               \
273         return show_in_max(dev, buf, offset);                   \
274 }                                                               \
275 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
276                 const char *buf, size_t count)                  \
277 {                                                               \
278         return set_in_min(dev, buf, count, offset);             \
279 }                                                               \
280 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
281                 const char *buf, size_t count)                  \
282 {                                                               \
283         return set_in_max(dev, buf, count, offset);             \
284 }                                                               \
285 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,         \
286                 show_in##offset##_min, set_in##offset##_min);   \
287 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,         \
288                 show_in##offset##_max, set_in##offset##_max);
289
290 show_in_offset(0);
291 show_in_offset(1);
292 show_in_offset(2);
293 show_in_offset(3);
294 show_in_offset(4);
295
296 /* Temperature */
297 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
298 {
299         struct sis5595_data *data = sis5595_update_device(dev);
300         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
301 }
302
303 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
304 {
305         struct sis5595_data *data = sis5595_update_device(dev);
306         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
307 }
308
309 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
310 {
311         struct i2c_client *client = to_i2c_client(dev);
312         struct sis5595_data *data = i2c_get_clientdata(client);
313         long val = simple_strtol(buf, NULL, 10);
314
315         mutex_lock(&data->update_lock);
316         data->temp_over = TEMP_TO_REG(val);
317         sis5595_write_value(client, SIS5595_REG_TEMP_OVER, data->temp_over);
318         mutex_unlock(&data->update_lock);
319         return count;
320 }
321
322 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
323 {
324         struct sis5595_data *data = sis5595_update_device(dev);
325         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
326 }
327
328 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
329 {
330         struct i2c_client *client = to_i2c_client(dev);
331         struct sis5595_data *data = i2c_get_clientdata(client);
332         long val = simple_strtol(buf, NULL, 10);
333
334         mutex_lock(&data->update_lock);
335         data->temp_hyst = TEMP_TO_REG(val);
336         sis5595_write_value(client, SIS5595_REG_TEMP_HYST, data->temp_hyst);
337         mutex_unlock(&data->update_lock);
338         return count;
339 }
340
341 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
342 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
343                 show_temp_over, set_temp_over);
344 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
345                 show_temp_hyst, set_temp_hyst);
346
347 /* 2 Fans */
348 static ssize_t show_fan(struct device *dev, char *buf, int nr)
349 {
350         struct sis5595_data *data = sis5595_update_device(dev);
351         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
352                 DIV_FROM_REG(data->fan_div[nr])) );
353 }
354
355 static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
356 {
357         struct sis5595_data *data = sis5595_update_device(dev);
358         return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
359                 DIV_FROM_REG(data->fan_div[nr])) );
360 }
361
362 static ssize_t set_fan_min(struct device *dev, const char *buf,
363                 size_t count, int nr)
364 {
365         struct i2c_client *client = to_i2c_client(dev);
366         struct sis5595_data *data = i2c_get_clientdata(client);
367         unsigned long val = simple_strtoul(buf, NULL, 10);
368
369         mutex_lock(&data->update_lock);
370         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
371         sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
372         mutex_unlock(&data->update_lock);
373         return count;
374 }
375
376 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
377 {
378         struct sis5595_data *data = sis5595_update_device(dev);
379         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
380 }
381
382 /* Note: we save and restore the fan minimum here, because its value is
383    determined in part by the fan divisor.  This follows the principle of
384    least surprise; the user doesn't expect the fan minimum to change just
385    because the divisor changed. */
386 static ssize_t set_fan_div(struct device *dev, const char *buf,
387         size_t count, int nr)
388 {
389         struct i2c_client *client = to_i2c_client(dev);
390         struct sis5595_data *data = i2c_get_clientdata(client);
391         unsigned long min;
392         unsigned long val = simple_strtoul(buf, NULL, 10);
393         int reg;
394
395         mutex_lock(&data->update_lock);
396         min = FAN_FROM_REG(data->fan_min[nr],
397                         DIV_FROM_REG(data->fan_div[nr]));
398         reg = sis5595_read_value(client, SIS5595_REG_FANDIV);
399
400         switch (val) {
401         case 1: data->fan_div[nr] = 0; break;
402         case 2: data->fan_div[nr] = 1; break;
403         case 4: data->fan_div[nr] = 2; break;
404         case 8: data->fan_div[nr] = 3; break;
405         default:
406                 dev_err(&client->dev, "fan_div value %ld not "
407                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
408                 mutex_unlock(&data->update_lock);
409                 return -EINVAL;
410         }
411         
412         switch (nr) {
413         case 0:
414                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
415                 break;
416         case 1:
417                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
418                 break;
419         }
420         sis5595_write_value(client, SIS5595_REG_FANDIV, reg);
421         data->fan_min[nr] =
422                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
423         sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
424         mutex_unlock(&data->update_lock);
425         return count;
426 }
427
428 #define show_fan_offset(offset)                                         \
429 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
430 {                                                                       \
431         return show_fan(dev, buf, offset - 1);                  \
432 }                                                                       \
433 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)   \
434 {                                                                       \
435         return show_fan_min(dev, buf, offset - 1);                      \
436 }                                                                       \
437 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)   \
438 {                                                                       \
439         return show_fan_div(dev, buf, offset - 1);                      \
440 }                                                                       \
441 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr,               \
442                 const char *buf, size_t count)                          \
443 {                                                                       \
444         return set_fan_min(dev, buf, count, offset - 1);                \
445 }                                                                       \
446 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
447 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,                \
448                 show_fan_##offset##_min, set_fan_##offset##_min);
449
450 show_fan_offset(1);
451 show_fan_offset(2);
452
453 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf,
454                 size_t count)
455 {
456         return set_fan_div(dev, buf, count, 0) ;
457 }
458
459 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf,
460                 size_t count)
461 {
462         return set_fan_div(dev, buf, count, 1) ;
463 }
464 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
465                 show_fan_1_div, set_fan_1_div);
466 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
467                 show_fan_2_div, set_fan_2_div);
468
469 /* Alarms */
470 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
471 {
472         struct sis5595_data *data = sis5595_update_device(dev);
473         return sprintf(buf, "%d\n", data->alarms);
474 }
475 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
476  
477 /* This is called when the module is loaded */
478 static int sis5595_detect(struct i2c_adapter *adapter)
479 {
480         int err = 0;
481         int i;
482         struct i2c_client *new_client;
483         struct sis5595_data *data;
484         char val;
485         u16 a;
486
487         if (force_addr)
488                 address = force_addr & ~(SIS5595_EXTENT - 1);
489         /* Reserve the ISA region */
490         if (!request_region(address, SIS5595_EXTENT,
491                             sis5595_driver.driver.name)) {
492                 err = -EBUSY;
493                 goto exit;
494         }
495         if (force_addr) {
496                 dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n", address);
497                 if (PCIBIOS_SUCCESSFUL !=
498                     pci_write_config_word(s_bridge, SIS5595_BASE_REG, address))
499                         goto exit_release;
500                 if (PCIBIOS_SUCCESSFUL !=
501                     pci_read_config_word(s_bridge, SIS5595_BASE_REG, &a))
502                         goto exit_release;
503                 if ((a & ~(SIS5595_EXTENT - 1)) != address)
504                         /* doesn't work for some chips? */
505                         goto exit_release;
506         }
507
508         if (PCIBIOS_SUCCESSFUL !=
509             pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val)) {
510                 goto exit_release;
511         }
512         if ((val & 0x80) == 0) {
513                 if (PCIBIOS_SUCCESSFUL !=
514                     pci_write_config_byte(s_bridge, SIS5595_ENABLE_REG,
515                                           val | 0x80))
516                         goto exit_release;
517                 if (PCIBIOS_SUCCESSFUL !=
518                     pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val))
519                         goto exit_release;
520                 if ((val & 0x80) == 0) 
521                         /* doesn't work for some chips! */
522                         goto exit_release;
523         }
524
525         if (!(data = kzalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
526                 err = -ENOMEM;
527                 goto exit_release;
528         }
529
530         new_client = &data->client;
531         new_client->addr = address;
532         mutex_init(&data->lock);
533         i2c_set_clientdata(new_client, data);
534         new_client->adapter = adapter;
535         new_client->driver = &sis5595_driver;
536         new_client->flags = 0;
537
538         /* Check revision and pin registers to determine whether 4 or 5 voltages */
539         pci_read_config_byte(s_bridge, SIS5595_REVISION_REG, &(data->revision));
540         /* 4 voltages, 1 temp */
541         data->maxins = 3;
542         if (data->revision >= REV2MIN) {
543                 pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val);
544                 if (!(val & 0x80))
545                         /* 5 voltages, no temps */
546                         data->maxins = 4;
547         }
548         
549         /* Fill in the remaining client fields and put it into the global list */
550         strlcpy(new_client->name, "sis5595", I2C_NAME_SIZE);
551
552         data->valid = 0;
553         mutex_init(&data->update_lock);
554
555         /* Tell the I2C layer a new client has arrived */
556         if ((err = i2c_attach_client(new_client)))
557                 goto exit_free;
558         
559         /* Initialize the SIS5595 chip */
560         sis5595_init_client(new_client);
561
562         /* A few vars need to be filled upon startup */
563         for (i = 0; i < 2; i++) {
564                 data->fan_min[i] = sis5595_read_value(new_client,
565                                         SIS5595_REG_FAN_MIN(i));
566         }
567
568         /* Register sysfs hooks */
569         data->class_dev = hwmon_device_register(&new_client->dev);
570         if (IS_ERR(data->class_dev)) {
571                 err = PTR_ERR(data->class_dev);
572                 goto exit_detach;
573         }
574
575         device_create_file(&new_client->dev, &dev_attr_in0_input);
576         device_create_file(&new_client->dev, &dev_attr_in0_min);
577         device_create_file(&new_client->dev, &dev_attr_in0_max);
578         device_create_file(&new_client->dev, &dev_attr_in1_input);
579         device_create_file(&new_client->dev, &dev_attr_in1_min);
580         device_create_file(&new_client->dev, &dev_attr_in1_max);
581         device_create_file(&new_client->dev, &dev_attr_in2_input);
582         device_create_file(&new_client->dev, &dev_attr_in2_min);
583         device_create_file(&new_client->dev, &dev_attr_in2_max);
584         device_create_file(&new_client->dev, &dev_attr_in3_input);
585         device_create_file(&new_client->dev, &dev_attr_in3_min);
586         device_create_file(&new_client->dev, &dev_attr_in3_max);
587         if (data->maxins == 4) {
588                 device_create_file(&new_client->dev, &dev_attr_in4_input);
589                 device_create_file(&new_client->dev, &dev_attr_in4_min);
590                 device_create_file(&new_client->dev, &dev_attr_in4_max);
591         }
592         device_create_file(&new_client->dev, &dev_attr_fan1_input);
593         device_create_file(&new_client->dev, &dev_attr_fan1_min);
594         device_create_file(&new_client->dev, &dev_attr_fan1_div);
595         device_create_file(&new_client->dev, &dev_attr_fan2_input);
596         device_create_file(&new_client->dev, &dev_attr_fan2_min);
597         device_create_file(&new_client->dev, &dev_attr_fan2_div);
598         device_create_file(&new_client->dev, &dev_attr_alarms);
599         if (data->maxins == 3) {
600                 device_create_file(&new_client->dev, &dev_attr_temp1_input);
601                 device_create_file(&new_client->dev, &dev_attr_temp1_max);
602                 device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
603         }
604         return 0;
605
606 exit_detach:
607         i2c_detach_client(new_client);
608 exit_free:
609         kfree(data);
610 exit_release:
611         release_region(address, SIS5595_EXTENT);
612 exit:
613         return err;
614 }
615
616 static int sis5595_detach_client(struct i2c_client *client)
617 {
618         struct sis5595_data *data = i2c_get_clientdata(client);
619         int err;
620
621         hwmon_device_unregister(data->class_dev);
622
623         if ((err = i2c_detach_client(client)))
624                 return err;
625
626         release_region(client->addr, SIS5595_EXTENT);
627
628         kfree(data);
629
630         return 0;
631 }
632
633
634 /* ISA access must be locked explicitly. */
635 static int sis5595_read_value(struct i2c_client *client, u8 reg)
636 {
637         int res;
638
639         struct sis5595_data *data = i2c_get_clientdata(client);
640         mutex_lock(&data->lock);
641         outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
642         res = inb_p(client->addr + SIS5595_DATA_REG_OFFSET);
643         mutex_unlock(&data->lock);
644         return res;
645 }
646
647 static int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value)
648 {
649         struct sis5595_data *data = i2c_get_clientdata(client);
650         mutex_lock(&data->lock);
651         outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
652         outb_p(value, client->addr + SIS5595_DATA_REG_OFFSET);
653         mutex_unlock(&data->lock);
654         return 0;
655 }
656
657 /* Called when we have found a new SIS5595. */
658 static void sis5595_init_client(struct i2c_client *client)
659 {
660         u8 config = sis5595_read_value(client, SIS5595_REG_CONFIG);
661         if (!(config & 0x01))
662                 sis5595_write_value(client, SIS5595_REG_CONFIG,
663                                 (config & 0xf7) | 0x01);
664 }
665
666 static struct sis5595_data *sis5595_update_device(struct device *dev)
667 {
668         struct i2c_client *client = to_i2c_client(dev);
669         struct sis5595_data *data = i2c_get_clientdata(client);
670         int i;
671
672         mutex_lock(&data->update_lock);
673
674         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
675             || !data->valid) {
676
677                 for (i = 0; i <= data->maxins; i++) {
678                         data->in[i] =
679                             sis5595_read_value(client, SIS5595_REG_IN(i));
680                         data->in_min[i] =
681                             sis5595_read_value(client,
682                                                SIS5595_REG_IN_MIN(i));
683                         data->in_max[i] =
684                             sis5595_read_value(client,
685                                                SIS5595_REG_IN_MAX(i));
686                 }
687                 for (i = 0; i < 2; i++) {
688                         data->fan[i] =
689                             sis5595_read_value(client, SIS5595_REG_FAN(i));
690                         data->fan_min[i] =
691                             sis5595_read_value(client,
692                                                SIS5595_REG_FAN_MIN(i));
693                 }
694                 if (data->maxins == 3) {
695                         data->temp =
696                             sis5595_read_value(client, SIS5595_REG_TEMP);
697                         data->temp_over =
698                             sis5595_read_value(client, SIS5595_REG_TEMP_OVER);
699                         data->temp_hyst =
700                             sis5595_read_value(client, SIS5595_REG_TEMP_HYST);
701                 }
702                 i = sis5595_read_value(client, SIS5595_REG_FANDIV);
703                 data->fan_div[0] = (i >> 4) & 0x03;
704                 data->fan_div[1] = i >> 6;
705                 data->alarms =
706                     sis5595_read_value(client, SIS5595_REG_ALARM1) |
707                     (sis5595_read_value(client, SIS5595_REG_ALARM2) << 8);
708                 data->last_updated = jiffies;
709                 data->valid = 1;
710         }
711
712         mutex_unlock(&data->update_lock);
713
714         return data;
715 }
716
717 static struct pci_device_id sis5595_pci_ids[] = {
718         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
719         { 0, }
720 };
721
722 MODULE_DEVICE_TABLE(pci, sis5595_pci_ids);
723
724 static int blacklist[] __devinitdata = {
725         PCI_DEVICE_ID_SI_540,
726         PCI_DEVICE_ID_SI_550,
727         PCI_DEVICE_ID_SI_630,
728         PCI_DEVICE_ID_SI_645,
729         PCI_DEVICE_ID_SI_730,
730         PCI_DEVICE_ID_SI_735,
731         PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but
732                                   that ID shows up in other chips so we
733                                   use the 5511 ID for recognition */
734         PCI_DEVICE_ID_SI_5597,
735         PCI_DEVICE_ID_SI_5598,
736         0 };
737
738 static int __devinit sis5595_pci_probe(struct pci_dev *dev,
739                                        const struct pci_device_id *id)
740 {
741         u16 val;
742         int *i;
743
744         for (i = blacklist; *i != 0; i++) {
745                 struct pci_dev *dev;
746                 dev = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
747                 if (dev) {
748                         dev_err(&dev->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
749                         pci_dev_put(dev);
750                         return -ENODEV;
751                 }
752         }
753         
754         if (PCIBIOS_SUCCESSFUL !=
755             pci_read_config_word(dev, SIS5595_BASE_REG, &val))
756                 return -ENODEV;
757         
758         address = val & ~(SIS5595_EXTENT - 1);
759         if (address == 0 && force_addr == 0) {
760                 dev_err(&dev->dev, "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
761                 return -ENODEV;
762         }
763
764         s_bridge = pci_dev_get(dev);
765         if (i2c_isa_add_driver(&sis5595_driver)) {
766                 pci_dev_put(s_bridge);
767                 s_bridge = NULL;
768         }
769
770         /* Always return failure here.  This is to allow other drivers to bind
771          * to this pci device.  We don't really want to have control over the
772          * pci device, we only wanted to read as few register values from it.
773          */
774         return -ENODEV;
775 }
776
777 static struct pci_driver sis5595_pci_driver = {
778         .name            = "sis5595",
779         .id_table        = sis5595_pci_ids,
780         .probe           = sis5595_pci_probe,
781 };
782
783 static int __init sm_sis5595_init(void)
784 {
785         return pci_register_driver(&sis5595_pci_driver);
786 }
787
788 static void __exit sm_sis5595_exit(void)
789 {
790         pci_unregister_driver(&sis5595_pci_driver);
791         if (s_bridge != NULL) {
792                 i2c_isa_del_driver(&sis5595_driver);
793                 pci_dev_put(s_bridge);
794                 s_bridge = NULL;
795         }
796 }
797
798 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
799 MODULE_DESCRIPTION("SiS 5595 Sensor device");
800 MODULE_LICENSE("GPL");
801
802 module_init(sm_sis5595_init);
803 module_exit(sm_sis5595_exit);