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