?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ARM] pxa: Gumstix Verdex PCMCIA support
[linux-2.6/verdex.git] / drivers / hwmon / sis5595.c
blob12f2e708656059e3dc357c438ee5d0c405f2fd0f
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);
Verdex Pro support