Merge branch 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jdelv...
[linux-2.6.git] / 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/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>
65 #include <linux/acpi.h>
66 #include <linux/io.h>
67
68
69 /* If force_addr is set to anything different from 0, we forcibly enable
70    the device at the given address. */
71 static u16 force_addr;
72 module_param(force_addr, ushort, 0);
73 MODULE_PARM_DESC(force_addr,
74                  "Initialize the base address of the sensors");
75
76 static struct platform_device *pdev;
77
78 /* Many SIS5595 constants specified below */
79
80 /* Length of ISA address segment */
81 #define SIS5595_EXTENT 8
82 /* PCI Config Registers */
83 #define SIS5595_BASE_REG 0x68
84 #define SIS5595_PIN_REG 0x7A
85 #define SIS5595_ENABLE_REG 0x7B
86
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
90
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))
95
96 #define SIS5595_REG_FAN_MIN(nr) (0x3b + (nr))
97 #define SIS5595_REG_FAN(nr) (0x28 + (nr))
98
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. */
104
105 #define REV2MIN 0xb0
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
112
113 #define SIS5595_REG_CONFIG 0x40
114 #define SIS5595_REG_ALARM1 0x41
115 #define SIS5595_REG_ALARM2 0x42
116 #define SIS5595_REG_FANDIV 0x47
117
118 /* Conversions. Limit checking is only done on the TO_REG
119    variants. */
120
121 /* IN: mV, (0V to 4.08V)
122    REG: 16mV/bit */
123 static inline u8 IN_TO_REG(unsigned long val)
124 {
125         unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
126         return (nval + 8) / 16;
127 }
128 #define IN_FROM_REG(val) ((val) *  16)
129
130 static inline u8 FAN_TO_REG(long rpm, int div)
131 {
132         if (rpm <= 0)
133                 return 255;
134         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
135 }
136
137 static inline int FAN_FROM_REG(u8 val, int div)
138 {
139         return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
140 }
141
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)
145 {
146         return val * 830 + 52120;
147 }
148 static inline s8 TEMP_TO_REG(int val)
149 {
150         int nval = SENSORS_LIMIT(val, -54120, 157530) ;
151         return nval<0 ? (nval-5212-415)/830 : (nval-5212+415)/830;
152 }
153
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)
157 {
158         return val==8 ? 3 : val==4 ? 2 : val==1 ? 0 : 1;
159 }
160 #define DIV_FROM_REG(val) (1 << (val))
161
162 /* For each registered chip, we need to keep some data in memory.
163    The structure is dynamically allocated. */
164 struct sis5595_data {
165         unsigned short addr;
166         const char *name;
167         struct device *hwmon_dev;
168         struct mutex lock;
169
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 */
175
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 */
186 };
187
188 static struct pci_dev *s_bridge;        /* pointer to the (only) sis5595 */
189
190 static int sis5595_probe(struct platform_device *pdev);
191 static int __devexit sis5595_remove(struct platform_device *pdev);
192
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);
197
198 static struct platform_driver sis5595_driver = {
199         .driver = {
200                 .owner  = THIS_MODULE,
201                 .name   = "sis5595",
202         },
203         .probe          = sis5595_probe,
204         .remove         = __devexit_p(sis5595_remove),
205 };
206
207 /* 4 Voltages */
208 static ssize_t show_in(struct device *dev, struct device_attribute *da,
209                        char *buf)
210 {
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]));
215 }
216
217 static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
218                            char *buf)
219 {
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]));
224 }
225
226 static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
227                            char *buf)
228 {
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]));
233 }
234
235 static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
236                           const char *buf, size_t count)
237 {
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);
242
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);
247         return count;
248 }
249
250 static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
251                           const char *buf, size_t count)
252 {
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);
257
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);
262         return count;
263 }
264
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);
272
273 show_in_offset(0);
274 show_in_offset(1);
275 show_in_offset(2);
276 show_in_offset(3);
277 show_in_offset(4);
278
279 /* Temperature */
280 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
281 {
282         struct sis5595_data *data = sis5595_update_device(dev);
283         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
284 }
285
286 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
287 {
288         struct sis5595_data *data = sis5595_update_device(dev);
289         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
290 }
291
292 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
293 {
294         struct sis5595_data *data = dev_get_drvdata(dev);
295         long val = simple_strtol(buf, NULL, 10);
296
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);
301         return count;
302 }
303
304 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
305 {
306         struct sis5595_data *data = sis5595_update_device(dev);
307         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
308 }
309
310 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
311 {
312         struct sis5595_data *data = dev_get_drvdata(dev);
313         long val = simple_strtol(buf, NULL, 10);
314
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);
319         return count;
320 }
321
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);
327
328 /* 2 Fans */
329 static ssize_t show_fan(struct device *dev, struct device_attribute *da,
330                         char *buf)
331 {
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])) );
337 }
338
339 static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
340                             char *buf)
341 {
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])) );
347 }
348
349 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
350                            const char *buf, size_t count)
351 {
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);
356
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);
361         return count;
362 }
363
364 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
365                             char *buf)
366 {
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]) );
371 }
372
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)
379 {
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;
383         unsigned long min;
384         unsigned long val = simple_strtoul(buf, NULL, 10);
385         int reg;
386
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);
391
392         switch (val) {
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;
397         default:
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);
401                 return -EINVAL;
402         }
403         
404         switch (nr) {
405         case 0:
406                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
407                 break;
408         case 1:
409                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
410                 break;
411         }
412         sis5595_write_value(data, SIS5595_REG_FANDIV, reg);
413         data->fan_min[nr] =
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);
417         return count;
418 }
419
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);
427
428 show_fan_offset(1);
429 show_fan_offset(2);
430
431 /* Alarms */
432 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
433 {
434         struct sis5595_data *data = sis5595_update_device(dev);
435         return sprintf(buf, "%d\n", data->alarms);
436 }
437 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
438
439 static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
440                           char *buf)
441 {
442         struct sis5595_data *data = sis5595_update_device(dev);
443         int nr = to_sensor_dev_attr(da)->index;
444         return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
445 }
446 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
447 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
448 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
449 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
450 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 15);
451 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
452 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
453 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 15);
454
455 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
456                          char *buf)
457 {
458         struct sis5595_data *data = dev_get_drvdata(dev);
459         return sprintf(buf, "%s\n", data->name);
460 }
461 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
462
463 static struct attribute *sis5595_attributes[] = {
464         &sensor_dev_attr_in0_input.dev_attr.attr,
465         &sensor_dev_attr_in0_min.dev_attr.attr,
466         &sensor_dev_attr_in0_max.dev_attr.attr,
467         &sensor_dev_attr_in0_alarm.dev_attr.attr,
468         &sensor_dev_attr_in1_input.dev_attr.attr,
469         &sensor_dev_attr_in1_min.dev_attr.attr,
470         &sensor_dev_attr_in1_max.dev_attr.attr,
471         &sensor_dev_attr_in1_alarm.dev_attr.attr,
472         &sensor_dev_attr_in2_input.dev_attr.attr,
473         &sensor_dev_attr_in2_min.dev_attr.attr,
474         &sensor_dev_attr_in2_max.dev_attr.attr,
475         &sensor_dev_attr_in2_alarm.dev_attr.attr,
476         &sensor_dev_attr_in3_input.dev_attr.attr,
477         &sensor_dev_attr_in3_min.dev_attr.attr,
478         &sensor_dev_attr_in3_max.dev_attr.attr,
479         &sensor_dev_attr_in3_alarm.dev_attr.attr,
480
481         &sensor_dev_attr_fan1_input.dev_attr.attr,
482         &sensor_dev_attr_fan1_min.dev_attr.attr,
483         &sensor_dev_attr_fan1_div.dev_attr.attr,
484         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
485         &sensor_dev_attr_fan2_input.dev_attr.attr,
486         &sensor_dev_attr_fan2_min.dev_attr.attr,
487         &sensor_dev_attr_fan2_div.dev_attr.attr,
488         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
489
490         &dev_attr_alarms.attr,
491         &dev_attr_name.attr,
492         NULL
493 };
494
495 static const struct attribute_group sis5595_group = {
496         .attrs = sis5595_attributes,
497 };
498
499 static struct attribute *sis5595_attributes_in4[] = {
500         &sensor_dev_attr_in4_input.dev_attr.attr,
501         &sensor_dev_attr_in4_min.dev_attr.attr,
502         &sensor_dev_attr_in4_max.dev_attr.attr,
503         &sensor_dev_attr_in4_alarm.dev_attr.attr,
504         NULL
505 };
506
507 static const struct attribute_group sis5595_group_in4 = {
508         .attrs = sis5595_attributes_in4,
509 };
510
511 static struct attribute *sis5595_attributes_temp1[] = {
512         &dev_attr_temp1_input.attr,
513         &dev_attr_temp1_max.attr,
514         &dev_attr_temp1_max_hyst.attr,
515         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
516         NULL
517 };
518
519 static const struct attribute_group sis5595_group_temp1 = {
520         .attrs = sis5595_attributes_temp1,
521 };
522  
523 /* This is called when the module is loaded */
524 static int __devinit sis5595_probe(struct platform_device *pdev)
525 {
526         int err = 0;
527         int i;
528         struct sis5595_data *data;
529         struct resource *res;
530         char val;
531
532         /* Reserve the ISA region */
533         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
534         if (!request_region(res->start, SIS5595_EXTENT,
535                             sis5595_driver.driver.name)) {
536                 err = -EBUSY;
537                 goto exit;
538         }
539
540         if (!(data = kzalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
541                 err = -ENOMEM;
542                 goto exit_release;
543         }
544
545         mutex_init(&data->lock);
546         mutex_init(&data->update_lock);
547         data->addr = res->start;
548         data->name = "sis5595";
549         platform_set_drvdata(pdev, data);
550
551         /* Check revision and pin registers to determine whether 4 or 5 voltages */
552         data->revision = s_bridge->revision;
553         /* 4 voltages, 1 temp */
554         data->maxins = 3;
555         if (data->revision >= REV2MIN) {
556                 pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val);
557                 if (!(val & 0x80))
558                         /* 5 voltages, no temps */
559                         data->maxins = 4;
560         }
561         
562         /* Initialize the SIS5595 chip */
563         sis5595_init_device(data);
564
565         /* A few vars need to be filled upon startup */
566         for (i = 0; i < 2; i++) {
567                 data->fan_min[i] = sis5595_read_value(data,
568                                         SIS5595_REG_FAN_MIN(i));
569         }
570
571         /* Register sysfs hooks */
572         if ((err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group)))
573                 goto exit_free;
574         if (data->maxins == 4) {
575                 if ((err = sysfs_create_group(&pdev->dev.kobj,
576                                               &sis5595_group_in4)))
577                         goto exit_remove_files;
578         } else {
579                 if ((err = sysfs_create_group(&pdev->dev.kobj,
580                                               &sis5595_group_temp1)))
581                         goto exit_remove_files;
582         }
583
584         data->hwmon_dev = hwmon_device_register(&pdev->dev);
585         if (IS_ERR(data->hwmon_dev)) {
586                 err = PTR_ERR(data->hwmon_dev);
587                 goto exit_remove_files;
588         }
589
590         return 0;
591
592 exit_remove_files:
593         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
594         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
595         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
596 exit_free:
597         kfree(data);
598 exit_release:
599         release_region(res->start, SIS5595_EXTENT);
600 exit:
601         return err;
602 }
603
604 static int __devexit sis5595_remove(struct platform_device *pdev)
605 {
606         struct sis5595_data *data = platform_get_drvdata(pdev);
607
608         hwmon_device_unregister(data->hwmon_dev);
609         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
610         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
611         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
612
613         release_region(data->addr, SIS5595_EXTENT);
614         platform_set_drvdata(pdev, NULL);
615         kfree(data);
616
617         return 0;
618 }
619
620
621 /* ISA access must be locked explicitly. */
622 static int sis5595_read_value(struct sis5595_data *data, u8 reg)
623 {
624         int res;
625
626         mutex_lock(&data->lock);
627         outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
628         res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET);
629         mutex_unlock(&data->lock);
630         return res;
631 }
632
633 static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value)
634 {
635         mutex_lock(&data->lock);
636         outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
637         outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET);
638         mutex_unlock(&data->lock);
639 }
640
641 /* Called when we have found a new SIS5595. */
642 static void __devinit sis5595_init_device(struct sis5595_data *data)
643 {
644         u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG);
645         if (!(config & 0x01))
646                 sis5595_write_value(data, SIS5595_REG_CONFIG,
647                                 (config & 0xf7) | 0x01);
648 }
649
650 static struct sis5595_data *sis5595_update_device(struct device *dev)
651 {
652         struct sis5595_data *data = dev_get_drvdata(dev);
653         int i;
654
655         mutex_lock(&data->update_lock);
656
657         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
658             || !data->valid) {
659
660                 for (i = 0; i <= data->maxins; i++) {
661                         data->in[i] =
662                             sis5595_read_value(data, SIS5595_REG_IN(i));
663                         data->in_min[i] =
664                             sis5595_read_value(data,
665                                                SIS5595_REG_IN_MIN(i));
666                         data->in_max[i] =
667                             sis5595_read_value(data,
668                                                SIS5595_REG_IN_MAX(i));
669                 }
670                 for (i = 0; i < 2; i++) {
671                         data->fan[i] =
672                             sis5595_read_value(data, SIS5595_REG_FAN(i));
673                         data->fan_min[i] =
674                             sis5595_read_value(data,
675                                                SIS5595_REG_FAN_MIN(i));
676                 }
677                 if (data->maxins == 3) {
678                         data->temp =
679                             sis5595_read_value(data, SIS5595_REG_TEMP);
680                         data->temp_over =
681                             sis5595_read_value(data, SIS5595_REG_TEMP_OVER);
682                         data->temp_hyst =
683                             sis5595_read_value(data, SIS5595_REG_TEMP_HYST);
684                 }
685                 i = sis5595_read_value(data, SIS5595_REG_FANDIV);
686                 data->fan_div[0] = (i >> 4) & 0x03;
687                 data->fan_div[1] = i >> 6;
688                 data->alarms =
689                     sis5595_read_value(data, SIS5595_REG_ALARM1) |
690                     (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8);
691                 data->last_updated = jiffies;
692                 data->valid = 1;
693         }
694
695         mutex_unlock(&data->update_lock);
696
697         return data;
698 }
699
700 static struct pci_device_id sis5595_pci_ids[] = {
701         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
702         { 0, }
703 };
704
705 MODULE_DEVICE_TABLE(pci, sis5595_pci_ids);
706
707 static int blacklist[] __devinitdata = {
708         PCI_DEVICE_ID_SI_540,
709         PCI_DEVICE_ID_SI_550,
710         PCI_DEVICE_ID_SI_630,
711         PCI_DEVICE_ID_SI_645,
712         PCI_DEVICE_ID_SI_730,
713         PCI_DEVICE_ID_SI_735,
714         PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but
715                                   that ID shows up in other chips so we
716                                   use the 5511 ID for recognition */
717         PCI_DEVICE_ID_SI_5597,
718         PCI_DEVICE_ID_SI_5598,
719         0 };
720
721 static int __devinit sis5595_device_add(unsigned short address)
722 {
723         struct resource res = {
724                 .start  = address,
725                 .end    = address + SIS5595_EXTENT - 1,
726                 .name   = "sis5595",
727                 .flags  = IORESOURCE_IO,
728         };
729         int err;
730
731         err = acpi_check_resource_conflict(&res);
732         if (err)
733                 goto exit;
734
735         pdev = platform_device_alloc("sis5595", address);
736         if (!pdev) {
737                 err = -ENOMEM;
738                 printk(KERN_ERR "sis5595: Device allocation failed\n");
739                 goto exit;
740         }
741
742         err = platform_device_add_resources(pdev, &res, 1);
743         if (err) {
744                 printk(KERN_ERR "sis5595: Device resource addition failed "
745                        "(%d)\n", err);
746                 goto exit_device_put;
747         }
748
749         err = platform_device_add(pdev);
750         if (err) {
751                 printk(KERN_ERR "sis5595: Device addition failed (%d)\n",
752                        err);
753                 goto exit_device_put;
754         }
755
756         return 0;
757
758 exit_device_put:
759         platform_device_put(pdev);
760 exit:
761         return err;
762 }
763
764 static int __devinit sis5595_pci_probe(struct pci_dev *dev,
765                                        const struct pci_device_id *id)
766 {
767         u16 address;
768         u8 enable;
769         int *i;
770
771         for (i = blacklist; *i != 0; i++) {
772                 struct pci_dev *d;
773                 if ((d = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL))) {
774                         dev_err(&d->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
775                         pci_dev_put(d);
776                         return -ENODEV;
777                 }
778         }
779         
780         force_addr &= ~(SIS5595_EXTENT - 1);
781         if (force_addr) {
782                 dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", force_addr);
783                 pci_write_config_word(dev, SIS5595_BASE_REG, force_addr);
784         }
785
786         if (PCIBIOS_SUCCESSFUL !=
787             pci_read_config_word(dev, SIS5595_BASE_REG, &address)) {
788                 dev_err(&dev->dev, "Failed to read ISA address\n");
789                 return -ENODEV;
790         }
791         
792         address &= ~(SIS5595_EXTENT - 1);
793         if (!address) {
794                 dev_err(&dev->dev, "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
795                 return -ENODEV;
796         }
797         if (force_addr && address != force_addr) {
798                 /* doesn't work for some chips? */
799                 dev_err(&dev->dev, "Failed to force ISA address\n");
800                 return -ENODEV;
801         }
802
803         if (PCIBIOS_SUCCESSFUL !=
804             pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable)) {
805                 dev_err(&dev->dev, "Failed to read enable register\n");
806                 return -ENODEV;
807         }
808         if (!(enable & 0x80)) {
809                 if ((PCIBIOS_SUCCESSFUL !=
810                      pci_write_config_byte(dev, SIS5595_ENABLE_REG,
811                                            enable | 0x80))
812                  || (PCIBIOS_SUCCESSFUL !=
813                      pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable))
814                  || (!(enable & 0x80))) {
815                         /* doesn't work for some chips! */
816                         dev_err(&dev->dev, "Failed to enable HWM device\n");
817                         return -ENODEV;
818                 }
819         }
820
821         if (platform_driver_register(&sis5595_driver)) {
822                 dev_dbg(&dev->dev, "Failed to register sis5595 driver\n");
823                 goto exit;
824         }
825
826         s_bridge = pci_dev_get(dev);
827         /* Sets global pdev as a side effect */
828         if (sis5595_device_add(address))
829                 goto exit_unregister;
830
831         /* Always return failure here.  This is to allow other drivers to bind
832          * to this pci device.  We don't really want to have control over the
833          * pci device, we only wanted to read as few register values from it.
834          */
835         return -ENODEV;
836
837 exit_unregister:
838         pci_dev_put(dev);
839         platform_driver_unregister(&sis5595_driver);
840 exit:
841         return -ENODEV;
842 }
843
844 static struct pci_driver sis5595_pci_driver = {
845         .name            = "sis5595",
846         .id_table        = sis5595_pci_ids,
847         .probe           = sis5595_pci_probe,
848 };
849
850 static int __init sm_sis5595_init(void)
851 {
852         return pci_register_driver(&sis5595_pci_driver);
853 }
854
855 static void __exit sm_sis5595_exit(void)
856 {
857         pci_unregister_driver(&sis5595_pci_driver);
858         if (s_bridge != NULL) {
859                 platform_device_unregister(pdev);
860                 platform_driver_unregister(&sis5595_driver);
861                 pci_dev_put(s_bridge);
862                 s_bridge = NULL;
863         }
864 }
865
866 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
867 MODULE_DESCRIPTION("SiS 5595 Sensor device");
868 MODULE_LICENSE("GPL");
869
870 module_init(sm_sis5595_init);
871 module_exit(sm_sis5595_exit);