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