blob: 92956eb3f3c15b657bcabf341cf4984b484cbbd0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Jean Delvare17e7dc42007-06-09 10:11:16 -040057#include <linux/platform_device.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040058#include <linux/hwmon.h>
Jean Delvare1f5f48d2007-06-09 10:11:16 -040059#include <linux/hwmon-sysfs.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040060#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include <linux/init.h>
Dominik Hacklff324092005-05-16 18:12:18 +020062#include <linux/jiffies.h>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010063#include <linux/mutex.h>
Jean Delvarea5ebe662006-09-24 21:24:46 +020064#include <linux/sysfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#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. */
70static u16 force_addr;
71module_param(force_addr, ushort, 0);
72MODULE_PARM_DESC(force_addr,
73 "Initialize the base address of the sensors");
74
Jean Delvare17e7dc42007-06-09 10:11:16 -040075static struct platform_device *pdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77/* Many SIS5595 constants specified below */
78
79/* Length of ISA address segment */
80#define SIS5595_EXTENT 8
81/* PCI Config Registers */
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#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 */
122static 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
129static 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
136static 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 */
143static inline int TEMP_FROM_REG(s8 val)
144{
145 return val * 830 + 52120;
146}
147static 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) */
155static 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
Jean Delvareed6bafb2007-02-14 21:15:03 +0100161/* For each registered chip, we need to keep some data in memory.
162 The structure is dynamically allocated. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163struct sis5595_data {
Jean Delvare17e7dc42007-06-09 10:11:16 -0400164 unsigned short addr;
165 const char *name;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400166 struct class_device *class_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100167 struct mutex lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100169 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 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
187static struct pci_dev *s_bridge; /* pointer to the (only) sis5595 */
188
Jean Delvare17e7dc42007-06-09 10:11:16 -0400189static int sis5595_probe(struct platform_device *pdev);
Jean Delvared0546122007-07-22 12:09:48 +0200190static int __devexit sis5595_remove(struct platform_device *pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Jean Delvare17e7dc42007-06-09 10:11:16 -0400192static int sis5595_read_value(struct sis5595_data *data, u8 reg);
193static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194static struct sis5595_data *sis5595_update_device(struct device *dev);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400195static void sis5595_init_device(struct sis5595_data *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
Jean Delvare17e7dc42007-06-09 10:11:16 -0400197static struct platform_driver sis5595_driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100198 .driver = {
Jean Delvare87218842006-09-03 22:36:14 +0200199 .owner = THIS_MODULE,
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100200 .name = "sis5595",
201 },
Jean Delvare17e7dc42007-06-09 10:11:16 -0400202 .probe = sis5595_probe,
203 .remove = __devexit_p(sis5595_remove),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204};
205
206/* 4 Voltages */
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400207static ssize_t show_in(struct device *dev, struct device_attribute *da,
208 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
210 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400211 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
212 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
214}
215
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400216static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
217 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400220 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
221 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
223}
224
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400225static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
226 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
228 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400229 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
230 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
232}
233
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400234static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
235 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400237 struct sis5595_data *data = dev_get_drvdata(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400238 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
239 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 unsigned long val = simple_strtoul(buf, NULL, 10);
241
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100242 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 data->in_min[nr] = IN_TO_REG(val);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400244 sis5595_write_value(data, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100245 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 return count;
247}
248
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400249static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
250 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400252 struct sis5595_data *data = dev_get_drvdata(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400253 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
254 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 unsigned long val = simple_strtoul(buf, NULL, 10);
256
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100257 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 data->in_max[nr] = IN_TO_REG(val);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400259 sis5595_write_value(data, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100260 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 return count;
262}
263
264#define show_in_offset(offset) \
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400265static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
266 show_in, NULL, offset); \
267static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
268 show_in_min, set_in_min, offset); \
269static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
270 show_in_max, set_in_max, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
272show_in_offset(0);
273show_in_offset(1);
274show_in_offset(2);
275show_in_offset(3);
276show_in_offset(4);
277
278/* Temperature */
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400279static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280{
281 struct sis5595_data *data = sis5595_update_device(dev);
282 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
283}
284
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400285static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
287 struct sis5595_data *data = sis5595_update_device(dev);
288 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
289}
290
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400291static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400293 struct sis5595_data *data = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 long val = simple_strtol(buf, NULL, 10);
295
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100296 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 data->temp_over = TEMP_TO_REG(val);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400298 sis5595_write_value(data, SIS5595_REG_TEMP_OVER, data->temp_over);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100299 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 return count;
301}
302
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400303static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304{
305 struct sis5595_data *data = sis5595_update_device(dev);
306 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
307}
308
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400309static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400311 struct sis5595_data *data = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 long val = simple_strtol(buf, NULL, 10);
313
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100314 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 data->temp_hyst = TEMP_TO_REG(val);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400316 sis5595_write_value(data, SIS5595_REG_TEMP_HYST, data->temp_hyst);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100317 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 return count;
319}
320
321static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
322static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
323 show_temp_over, set_temp_over);
324static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
325 show_temp_hyst, set_temp_hyst);
326
327/* 2 Fans */
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400328static ssize_t show_fan(struct device *dev, struct device_attribute *da,
329 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
331 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400332 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
333 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
335 DIV_FROM_REG(data->fan_div[nr])) );
336}
337
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400338static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
339 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
341 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400342 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
343 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
345 DIV_FROM_REG(data->fan_div[nr])) );
346}
347
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400348static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
349 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400351 struct sis5595_data *data = dev_get_drvdata(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400352 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
353 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 unsigned long val = simple_strtoul(buf, NULL, 10);
355
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100356 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
Jean Delvare17e7dc42007-06-09 10:11:16 -0400358 sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100359 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 return count;
361}
362
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400363static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
364 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
366 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400367 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
368 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 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
Andreas Mohrd6e05ed2006-06-26 18:35:02 +0200374 least surprise; the user doesn't expect the fan minimum to change just
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 because the divisor changed. */
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400376static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
377 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400379 struct sis5595_data *data = dev_get_drvdata(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400380 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
381 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 unsigned long min;
383 unsigned long val = simple_strtoul(buf, NULL, 10);
384 int reg;
385
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100386 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 min = FAN_FROM_REG(data->fan_min[nr],
388 DIV_FROM_REG(data->fan_div[nr]));
Jean Delvare17e7dc42007-06-09 10:11:16 -0400389 reg = sis5595_read_value(data, SIS5595_REG_FANDIV);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
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:
Jean Delvare17e7dc42007-06-09 10:11:16 -0400397 dev_err(dev, "fan_div value %ld not "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 "supported. Choose one of 1, 2, 4 or 8!\n", val);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100399 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 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 }
Jean Delvare17e7dc42007-06-09 10:11:16 -0400411 sis5595_write_value(data, SIS5595_REG_FANDIV, reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 data->fan_min[nr] =
413 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
Jean Delvare17e7dc42007-06-09 10:11:16 -0400414 sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100415 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return count;
417}
418
419#define show_fan_offset(offset) \
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400420static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
421 show_fan, NULL, offset - 1); \
422static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
423 show_fan_min, set_fan_min, offset - 1); \
424static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
425 show_fan_div, set_fan_div, offset - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
427show_fan_offset(1);
428show_fan_offset(2);
429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430/* Alarms */
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400431static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432{
433 struct sis5595_data *data = sis5595_update_device(dev);
434 return sprintf(buf, "%d\n", data->alarms);
435}
436static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
Jean Delvarea5ebe662006-09-24 21:24:46 +0200437
Jean Delvare17e7dc42007-06-09 10:11:16 -0400438static ssize_t show_name(struct device *dev, struct device_attribute *attr,
439 char *buf)
440{
441 struct sis5595_data *data = dev_get_drvdata(dev);
442 return sprintf(buf, "%s\n", data->name);
443}
444static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
445
Jean Delvarea5ebe662006-09-24 21:24:46 +0200446static struct attribute *sis5595_attributes[] = {
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400447 &sensor_dev_attr_in0_input.dev_attr.attr,
448 &sensor_dev_attr_in0_min.dev_attr.attr,
449 &sensor_dev_attr_in0_max.dev_attr.attr,
450 &sensor_dev_attr_in1_input.dev_attr.attr,
451 &sensor_dev_attr_in1_min.dev_attr.attr,
452 &sensor_dev_attr_in1_max.dev_attr.attr,
453 &sensor_dev_attr_in2_input.dev_attr.attr,
454 &sensor_dev_attr_in2_min.dev_attr.attr,
455 &sensor_dev_attr_in2_max.dev_attr.attr,
456 &sensor_dev_attr_in3_input.dev_attr.attr,
457 &sensor_dev_attr_in3_min.dev_attr.attr,
458 &sensor_dev_attr_in3_max.dev_attr.attr,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200459
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400460 &sensor_dev_attr_fan1_input.dev_attr.attr,
461 &sensor_dev_attr_fan1_min.dev_attr.attr,
462 &sensor_dev_attr_fan1_div.dev_attr.attr,
463 &sensor_dev_attr_fan2_input.dev_attr.attr,
464 &sensor_dev_attr_fan2_min.dev_attr.attr,
465 &sensor_dev_attr_fan2_div.dev_attr.attr,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200466
467 &dev_attr_alarms.attr,
Jean Delvare17e7dc42007-06-09 10:11:16 -0400468 &dev_attr_name.attr,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200469 NULL
470};
471
472static const struct attribute_group sis5595_group = {
473 .attrs = sis5595_attributes,
474};
475
476static struct attribute *sis5595_attributes_opt[] = {
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400477 &sensor_dev_attr_in4_input.dev_attr.attr,
478 &sensor_dev_attr_in4_min.dev_attr.attr,
479 &sensor_dev_attr_in4_max.dev_attr.attr,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200480
481 &dev_attr_temp1_input.attr,
482 &dev_attr_temp1_max.attr,
483 &dev_attr_temp1_max_hyst.attr,
484 NULL
485};
486
487static const struct attribute_group sis5595_group_opt = {
488 .attrs = sis5595_attributes_opt,
489};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
491/* This is called when the module is loaded */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400492static int __devinit sis5595_probe(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493{
494 int err = 0;
495 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 struct sis5595_data *data;
Jean Delvare17e7dc42007-06-09 10:11:16 -0400497 struct resource *res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 char val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 /* Reserve the ISA region */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400501 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
502 if (!request_region(res->start, SIS5595_EXTENT,
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100503 sis5595_driver.driver.name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 err = -EBUSY;
505 goto exit;
506 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Deepak Saxenaba9c2e82005-10-17 23:08:32 +0200508 if (!(data = kzalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 err = -ENOMEM;
510 goto exit_release;
511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100513 mutex_init(&data->lock);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400514 mutex_init(&data->update_lock);
515 data->addr = res->start;
516 data->name = "sis5595";
517 platform_set_drvdata(pdev, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
519 /* Check revision and pin registers to determine whether 4 or 5 voltages */
Jean Delvare2f6ae152007-06-09 10:11:17 -0400520 pci_read_config_byte(s_bridge, PCI_REVISION_ID, &data->revision);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 /* 4 voltages, 1 temp */
522 data->maxins = 3;
523 if (data->revision >= REV2MIN) {
524 pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val);
525 if (!(val & 0x80))
526 /* 5 voltages, no temps */
527 data->maxins = 4;
528 }
529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 /* Initialize the SIS5595 chip */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400531 sis5595_init_device(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
533 /* A few vars need to be filled upon startup */
534 for (i = 0; i < 2; i++) {
Jean Delvare17e7dc42007-06-09 10:11:16 -0400535 data->fan_min[i] = sis5595_read_value(data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 SIS5595_REG_FAN_MIN(i));
537 }
538
539 /* Register sysfs hooks */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400540 if ((err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group)))
541 goto exit_free;
Jean Delvarea5ebe662006-09-24 21:24:46 +0200542 if (data->maxins == 4) {
Jean Delvare17e7dc42007-06-09 10:11:16 -0400543 if ((err = device_create_file(&pdev->dev,
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400544 &sensor_dev_attr_in4_input.dev_attr))
Jean Delvare17e7dc42007-06-09 10:11:16 -0400545 || (err = device_create_file(&pdev->dev,
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400546 &sensor_dev_attr_in4_min.dev_attr))
Jean Delvare17e7dc42007-06-09 10:11:16 -0400547 || (err = device_create_file(&pdev->dev,
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400548 &sensor_dev_attr_in4_max.dev_attr)))
Jean Delvarea5ebe662006-09-24 21:24:46 +0200549 goto exit_remove_files;
550 } else {
Jean Delvare17e7dc42007-06-09 10:11:16 -0400551 if ((err = device_create_file(&pdev->dev,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200552 &dev_attr_temp1_input))
Jean Delvare17e7dc42007-06-09 10:11:16 -0400553 || (err = device_create_file(&pdev->dev,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200554 &dev_attr_temp1_max))
Jean Delvare17e7dc42007-06-09 10:11:16 -0400555 || (err = device_create_file(&pdev->dev,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200556 &dev_attr_temp1_max_hyst)))
557 goto exit_remove_files;
558 }
559
Jean Delvare17e7dc42007-06-09 10:11:16 -0400560 data->class_dev = hwmon_device_register(&pdev->dev);
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400561 if (IS_ERR(data->class_dev)) {
562 err = PTR_ERR(data->class_dev);
Jean Delvarea5ebe662006-09-24 21:24:46 +0200563 goto exit_remove_files;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400564 }
565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 return 0;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400567
Jean Delvarea5ebe662006-09-24 21:24:46 +0200568exit_remove_files:
Jean Delvare17e7dc42007-06-09 10:11:16 -0400569 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
570 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571exit_free:
572 kfree(data);
573exit_release:
Jean Delvare17e7dc42007-06-09 10:11:16 -0400574 release_region(res->start, SIS5595_EXTENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575exit:
576 return err;
577}
578
Jean Delvare17e7dc42007-06-09 10:11:16 -0400579static int __devexit sis5595_remove(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400581 struct sis5595_data *data = platform_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400583 hwmon_device_unregister(data->class_dev);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400584 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
585 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_opt);
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400586
Jean Delvare17e7dc42007-06-09 10:11:16 -0400587 release_region(data->addr, SIS5595_EXTENT);
588 platform_set_drvdata(pdev, NULL);
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400589 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
591 return 0;
592}
593
594
595/* ISA access must be locked explicitly. */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400596static int sis5595_read_value(struct sis5595_data *data, u8 reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597{
598 int res;
599
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100600 mutex_lock(&data->lock);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400601 outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
602 res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100603 mutex_unlock(&data->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 return res;
605}
606
Jean Delvare17e7dc42007-06-09 10:11:16 -0400607static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100609 mutex_lock(&data->lock);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400610 outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
611 outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100612 mutex_unlock(&data->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613}
614
615/* Called when we have found a new SIS5595. */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400616static void __devinit sis5595_init_device(struct sis5595_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400618 u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 if (!(config & 0x01))
Jean Delvare17e7dc42007-06-09 10:11:16 -0400620 sis5595_write_value(data, SIS5595_REG_CONFIG,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 (config & 0xf7) | 0x01);
622}
623
624static struct sis5595_data *sis5595_update_device(struct device *dev)
625{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400626 struct sis5595_data *data = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 int i;
628
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100629 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
631 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
632 || !data->valid) {
633
634 for (i = 0; i <= data->maxins; i++) {
635 data->in[i] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400636 sis5595_read_value(data, SIS5595_REG_IN(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 data->in_min[i] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400638 sis5595_read_value(data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 SIS5595_REG_IN_MIN(i));
640 data->in_max[i] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400641 sis5595_read_value(data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 SIS5595_REG_IN_MAX(i));
643 }
644 for (i = 0; i < 2; i++) {
645 data->fan[i] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400646 sis5595_read_value(data, SIS5595_REG_FAN(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 data->fan_min[i] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400648 sis5595_read_value(data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 SIS5595_REG_FAN_MIN(i));
650 }
651 if (data->maxins == 3) {
652 data->temp =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400653 sis5595_read_value(data, SIS5595_REG_TEMP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 data->temp_over =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400655 sis5595_read_value(data, SIS5595_REG_TEMP_OVER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 data->temp_hyst =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400657 sis5595_read_value(data, SIS5595_REG_TEMP_HYST);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 }
Jean Delvare17e7dc42007-06-09 10:11:16 -0400659 i = sis5595_read_value(data, SIS5595_REG_FANDIV);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 data->fan_div[0] = (i >> 4) & 0x03;
661 data->fan_div[1] = i >> 6;
662 data->alarms =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400663 sis5595_read_value(data, SIS5595_REG_ALARM1) |
664 (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 data->last_updated = jiffies;
666 data->valid = 1;
667 }
668
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100669 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
671 return data;
672}
673
674static struct pci_device_id sis5595_pci_ids[] = {
675 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
676 { 0, }
677};
678
679MODULE_DEVICE_TABLE(pci, sis5595_pci_ids);
680
681static int blacklist[] __devinitdata = {
682 PCI_DEVICE_ID_SI_540,
683 PCI_DEVICE_ID_SI_550,
684 PCI_DEVICE_ID_SI_630,
685 PCI_DEVICE_ID_SI_645,
686 PCI_DEVICE_ID_SI_730,
687 PCI_DEVICE_ID_SI_735,
688 PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but
689 that ID shows up in other chips so we
690 use the 5511 ID for recognition */
691 PCI_DEVICE_ID_SI_5597,
692 PCI_DEVICE_ID_SI_5598,
693 0 };
694
Jean Delvare17e7dc42007-06-09 10:11:16 -0400695static int __devinit sis5595_device_add(unsigned short address)
696{
697 struct resource res = {
698 .start = address,
699 .end = address + SIS5595_EXTENT - 1,
700 .name = "sis5595",
701 .flags = IORESOURCE_IO,
702 };
703 int err;
704
705 pdev = platform_device_alloc("sis5595", address);
706 if (!pdev) {
707 err = -ENOMEM;
708 printk(KERN_ERR "sis5595: Device allocation failed\n");
709 goto exit;
710 }
711
712 err = platform_device_add_resources(pdev, &res, 1);
713 if (err) {
714 printk(KERN_ERR "sis5595: Device resource addition failed "
715 "(%d)\n", err);
716 goto exit_device_put;
717 }
718
719 err = platform_device_add(pdev);
720 if (err) {
721 printk(KERN_ERR "sis5595: Device addition failed (%d)\n",
722 err);
723 goto exit_device_put;
724 }
725
726 return 0;
727
728exit_device_put:
729 platform_device_put(pdev);
730exit:
731 return err;
732}
733
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734static int __devinit sis5595_pci_probe(struct pci_dev *dev,
735 const struct pci_device_id *id)
736{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400737 u16 address;
738 u8 enable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 int *i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
741 for (i = blacklist; *i != 0; i++) {
742 struct pci_dev *dev;
743 dev = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
744 if (dev) {
745 dev_err(&dev->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
746 pci_dev_put(dev);
747 return -ENODEV;
748 }
749 }
750
Jean Delvare17e7dc42007-06-09 10:11:16 -0400751 force_addr &= ~(SIS5595_EXTENT - 1);
752 if (force_addr) {
753 dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", force_addr);
754 pci_write_config_word(dev, SIS5595_BASE_REG, force_addr);
755 }
756
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 if (PCIBIOS_SUCCESSFUL !=
Jean Delvare17e7dc42007-06-09 10:11:16 -0400758 pci_read_config_word(dev, SIS5595_BASE_REG, &address)) {
759 dev_err(&dev->dev, "Failed to read ISA address\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 return -ENODEV;
Jean Delvare17e7dc42007-06-09 10:11:16 -0400761 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Jean Delvare17e7dc42007-06-09 10:11:16 -0400763 address &= ~(SIS5595_EXTENT - 1);
764 if (!address) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 dev_err(&dev->dev, "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
766 return -ENODEV;
767 }
Jean Delvare17e7dc42007-06-09 10:11:16 -0400768 if (force_addr && address != force_addr) {
769 /* doesn't work for some chips? */
770 dev_err(&dev->dev, "Failed to force ISA address\n");
771 return -ENODEV;
772 }
773
774 if (PCIBIOS_SUCCESSFUL !=
775 pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable)) {
776 dev_err(&dev->dev, "Failed to read enable register\n");
777 return -ENODEV;
778 }
779 if (!(enable & 0x80)) {
780 if ((PCIBIOS_SUCCESSFUL !=
781 pci_write_config_byte(dev, SIS5595_ENABLE_REG,
782 enable | 0x80))
783 || (PCIBIOS_SUCCESSFUL !=
784 pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable))
785 || (!(enable & 0x80))) {
786 /* doesn't work for some chips! */
787 dev_err(&dev->dev, "Failed to enable HWM device\n");
788 return -ENODEV;
789 }
790 }
791
792 if (platform_driver_register(&sis5595_driver)) {
793 dev_dbg(&dev->dev, "Failed to register sis5595 driver\n");
794 goto exit;
795 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 s_bridge = pci_dev_get(dev);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400798 /* Sets global pdev as a side effect */
799 if (sis5595_device_add(address))
800 goto exit_unregister;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
802 /* Always return failure here. This is to allow other drivers to bind
803 * to this pci device. We don't really want to have control over the
804 * pci device, we only wanted to read as few register values from it.
805 */
806 return -ENODEV;
Jean Delvare17e7dc42007-06-09 10:11:16 -0400807
808exit_unregister:
809 pci_dev_put(dev);
810 platform_driver_unregister(&sis5595_driver);
811exit:
812 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813}
814
815static struct pci_driver sis5595_pci_driver = {
816 .name = "sis5595",
817 .id_table = sis5595_pci_ids,
818 .probe = sis5595_pci_probe,
819};
820
821static int __init sm_sis5595_init(void)
822{
823 return pci_register_driver(&sis5595_pci_driver);
824}
825
826static void __exit sm_sis5595_exit(void)
827{
828 pci_unregister_driver(&sis5595_pci_driver);
829 if (s_bridge != NULL) {
Jean Delvare17e7dc42007-06-09 10:11:16 -0400830 platform_device_unregister(pdev);
831 platform_driver_unregister(&sis5595_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 pci_dev_put(s_bridge);
833 s_bridge = NULL;
834 }
835}
836
837MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
838MODULE_DESCRIPTION("SiS 5595 Sensor device");
839MODULE_LICENSE("GPL");
840
841module_init(sm_sis5595_init);
842module_exit(sm_sis5595_exit);