blob: 12f2e708656059e3dc357c438ee5d0c405f2fd0f [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>,
Jan Engelhardt96de0e22007-10-19 23:21:04 +02006 Kyösti Mälkki <kmalkki@cc.hut.fi>, and
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 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>
Jean Delvareb9acb642009-01-07 16:37:35 +010065#include <linux/acpi.h>
H Hartley Sweeten6055fae2009-09-15 17:18:13 +020066#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68
69/* If force_addr is set to anything different from 0, we forcibly enable
70 the device at the given address. */
71static u16 force_addr;
72module_param(force_addr, ushort, 0);
73MODULE_PARM_DESC(force_addr,
74 "Initialize the base address of the sensors");
75
Jean Delvare17e7dc42007-06-09 10:11:16 -040076static struct platform_device *pdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78/* Many SIS5595 constants specified below */
79
80/* Length of ISA address segment */
81#define SIS5595_EXTENT 8
82/* PCI Config Registers */
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#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 */
123static 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
130static 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
137static 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 */
144static inline int TEMP_FROM_REG(s8 val)
145{
146 return val * 830 + 52120;
147}
148static 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) */
156static 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
Jean Delvareed6bafb2007-02-14 21:15:03 +0100162/* For each registered chip, we need to keep some data in memory.
163 The structure is dynamically allocated. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164struct sis5595_data {
Jean Delvare17e7dc42007-06-09 10:11:16 -0400165 unsigned short addr;
166 const char *name;
Tony Jones1beeffe2007-08-20 13:46:20 -0700167 struct device *hwmon_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100168 struct mutex lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100170 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 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
188static struct pci_dev *s_bridge; /* pointer to the (only) sis5595 */
189
Jean Delvare17e7dc42007-06-09 10:11:16 -0400190static int sis5595_probe(struct platform_device *pdev);
Jean Delvared0546122007-07-22 12:09:48 +0200191static int __devexit sis5595_remove(struct platform_device *pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Jean Delvare17e7dc42007-06-09 10:11:16 -0400193static int sis5595_read_value(struct sis5595_data *data, u8 reg);
194static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195static struct sis5595_data *sis5595_update_device(struct device *dev);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400196static void sis5595_init_device(struct sis5595_data *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Jean Delvare17e7dc42007-06-09 10:11:16 -0400198static struct platform_driver sis5595_driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100199 .driver = {
Jean Delvare87218842006-09-03 22:36:14 +0200200 .owner = THIS_MODULE,
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100201 .name = "sis5595",
202 },
Jean Delvare17e7dc42007-06-09 10:11:16 -0400203 .probe = sis5595_probe,
204 .remove = __devexit_p(sis5595_remove),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205};
206
207/* 4 Voltages */
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400208static ssize_t show_in(struct device *dev, struct device_attribute *da,
209 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210{
211 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400212 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
213 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
215}
216
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400217static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
218 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
220 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400221 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
222 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
224}
225
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400226static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
227 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
229 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400230 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
231 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
233}
234
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400235static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
236 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400238 struct sis5595_data *data = dev_get_drvdata(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400239 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
240 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 unsigned long val = simple_strtoul(buf, NULL, 10);
242
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100243 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 data->in_min[nr] = IN_TO_REG(val);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400245 sis5595_write_value(data, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100246 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 return count;
248}
249
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400250static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
251 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400253 struct sis5595_data *data = dev_get_drvdata(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400254 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
255 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 unsigned long val = simple_strtoul(buf, NULL, 10);
257
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100258 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 data->in_max[nr] = IN_TO_REG(val);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400260 sis5595_write_value(data, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100261 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 return count;
263}
264
265#define show_in_offset(offset) \
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400266static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
267 show_in, NULL, offset); \
268static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
269 show_in_min, set_in_min, offset); \
270static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
271 show_in_max, set_in_max, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
273show_in_offset(0);
274show_in_offset(1);
275show_in_offset(2);
276show_in_offset(3);
277show_in_offset(4);
278
279/* Temperature */
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400280static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
282 struct sis5595_data *data = sis5595_update_device(dev);
283 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
284}
285
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400286static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
288 struct sis5595_data *data = sis5595_update_device(dev);
289 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
290}
291
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400292static 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 -0700293{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400294 struct sis5595_data *data = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 long val = simple_strtol(buf, NULL, 10);
296
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100297 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 data->temp_over = TEMP_TO_REG(val);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400299 sis5595_write_value(data, SIS5595_REG_TEMP_OVER, data->temp_over);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100300 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 return count;
302}
303
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400304static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305{
306 struct sis5595_data *data = sis5595_update_device(dev);
307 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
308}
309
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400310static 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 -0700311{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400312 struct sis5595_data *data = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 long val = simple_strtol(buf, NULL, 10);
314
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100315 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 data->temp_hyst = TEMP_TO_REG(val);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400317 sis5595_write_value(data, SIS5595_REG_TEMP_HYST, data->temp_hyst);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100318 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 return count;
320}
321
322static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
323static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
324 show_temp_over, set_temp_over);
325static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
326 show_temp_hyst, set_temp_hyst);
327
328/* 2 Fans */
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400329static ssize_t show_fan(struct device *dev, struct device_attribute *da,
330 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331{
332 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400333 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
334 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
336 DIV_FROM_REG(data->fan_div[nr])) );
337}
338
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400339static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
340 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
342 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400343 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
344 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
346 DIV_FROM_REG(data->fan_div[nr])) );
347}
348
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400349static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
350 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400352 struct sis5595_data *data = dev_get_drvdata(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400353 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
354 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 unsigned long val = simple_strtoul(buf, NULL, 10);
356
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100357 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
Jean Delvare17e7dc42007-06-09 10:11:16 -0400359 sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100360 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 return count;
362}
363
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400364static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
365 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366{
367 struct sis5595_data *data = sis5595_update_device(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400368 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
369 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 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
Andreas Mohrd6e05ed2006-06-26 18:35:02 +0200375 least surprise; the user doesn't expect the fan minimum to change just
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 because the divisor changed. */
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400377static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
378 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400380 struct sis5595_data *data = dev_get_drvdata(dev);
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400381 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
382 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 unsigned long min;
384 unsigned long val = simple_strtoul(buf, NULL, 10);
385 int reg;
386
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100387 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 min = FAN_FROM_REG(data->fan_min[nr],
389 DIV_FROM_REG(data->fan_div[nr]));
Jean Delvare17e7dc42007-06-09 10:11:16 -0400390 reg = sis5595_read_value(data, SIS5595_REG_FANDIV);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
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:
Jean Delvare17e7dc42007-06-09 10:11:16 -0400398 dev_err(dev, "fan_div value %ld not "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 "supported. Choose one of 1, 2, 4 or 8!\n", val);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100400 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 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 }
Jean Delvare17e7dc42007-06-09 10:11:16 -0400412 sis5595_write_value(data, SIS5595_REG_FANDIV, reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 data->fan_min[nr] =
414 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
Jean Delvare17e7dc42007-06-09 10:11:16 -0400415 sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100416 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return count;
418}
419
420#define show_fan_offset(offset) \
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400421static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
422 show_fan, NULL, offset - 1); \
423static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
424 show_fan_min, set_fan_min, offset - 1); \
425static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
426 show_fan_div, set_fan_div, offset - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
428show_fan_offset(1);
429show_fan_offset(2);
430
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431/* Alarms */
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400432static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433{
434 struct sis5595_data *data = sis5595_update_device(dev);
435 return sprintf(buf, "%d\n", data->alarms);
436}
437static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
Jean Delvarea5ebe662006-09-24 21:24:46 +0200438
Ivo Manca5c726b32007-10-15 20:50:53 +0200439static 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}
446static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
447static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
448static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
449static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
450static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 15);
451static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
452static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
453static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 15);
454
Jean Delvare17e7dc42007-06-09 10:11:16 -0400455static 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}
461static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
462
Jean Delvarea5ebe662006-09-24 21:24:46 +0200463static struct attribute *sis5595_attributes[] = {
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400464 &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,
Ivo Manca5c726b32007-10-15 20:50:53 +0200467 &sensor_dev_attr_in0_alarm.dev_attr.attr,
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400468 &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,
Ivo Manca5c726b32007-10-15 20:50:53 +0200471 &sensor_dev_attr_in1_alarm.dev_attr.attr,
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400472 &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,
Ivo Manca5c726b32007-10-15 20:50:53 +0200475 &sensor_dev_attr_in2_alarm.dev_attr.attr,
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400476 &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,
Ivo Manca5c726b32007-10-15 20:50:53 +0200479 &sensor_dev_attr_in3_alarm.dev_attr.attr,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200480
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400481 &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,
Ivo Manca5c726b32007-10-15 20:50:53 +0200484 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400485 &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,
Ivo Manca5c726b32007-10-15 20:50:53 +0200488 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200489
490 &dev_attr_alarms.attr,
Jean Delvare17e7dc42007-06-09 10:11:16 -0400491 &dev_attr_name.attr,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200492 NULL
493};
494
495static const struct attribute_group sis5595_group = {
496 .attrs = sis5595_attributes,
497};
498
Ivo Manca76e63862007-10-15 13:27:13 +0200499static struct attribute *sis5595_attributes_in4[] = {
Jean Delvare1f5f48d2007-06-09 10:11:16 -0400500 &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,
Ivo Manca5c726b32007-10-15 20:50:53 +0200503 &sensor_dev_attr_in4_alarm.dev_attr.attr,
Ivo Manca76e63862007-10-15 13:27:13 +0200504 NULL
505};
Jean Delvarea5ebe662006-09-24 21:24:46 +0200506
Ivo Manca76e63862007-10-15 13:27:13 +0200507static const struct attribute_group sis5595_group_in4 = {
508 .attrs = sis5595_attributes_in4,
509};
510
511static struct attribute *sis5595_attributes_temp1[] = {
Jean Delvarea5ebe662006-09-24 21:24:46 +0200512 &dev_attr_temp1_input.attr,
513 &dev_attr_temp1_max.attr,
514 &dev_attr_temp1_max_hyst.attr,
Ivo Manca5c726b32007-10-15 20:50:53 +0200515 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200516 NULL
517};
518
Ivo Manca76e63862007-10-15 13:27:13 +0200519static const struct attribute_group sis5595_group_temp1 = {
520 .attrs = sis5595_attributes_temp1,
Jean Delvarea5ebe662006-09-24 21:24:46 +0200521};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
523/* This is called when the module is loaded */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400524static int __devinit sis5595_probe(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525{
526 int err = 0;
527 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 struct sis5595_data *data;
Jean Delvare17e7dc42007-06-09 10:11:16 -0400529 struct resource *res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 char val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 /* Reserve the ISA region */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400533 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
534 if (!request_region(res->start, SIS5595_EXTENT,
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100535 sis5595_driver.driver.name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 err = -EBUSY;
537 goto exit;
538 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Deepak Saxenaba9c2e82005-10-17 23:08:32 +0200540 if (!(data = kzalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 err = -ENOMEM;
542 goto exit_release;
543 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100545 mutex_init(&data->lock);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400546 mutex_init(&data->update_lock);
547 data->addr = res->start;
548 data->name = "sis5595";
549 platform_set_drvdata(pdev, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
551 /* Check revision and pin registers to determine whether 4 or 5 voltages */
Auke Kok7b6d1f02007-08-27 16:17:01 -0700552 data->revision = s_bridge->revision;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 /* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 /* Initialize the SIS5595 chip */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400563 sis5595_init_device(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
565 /* A few vars need to be filled upon startup */
566 for (i = 0; i < 2; i++) {
Jean Delvare17e7dc42007-06-09 10:11:16 -0400567 data->fan_min[i] = sis5595_read_value(data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 SIS5595_REG_FAN_MIN(i));
569 }
570
571 /* Register sysfs hooks */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400572 if ((err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group)))
573 goto exit_free;
Jean Delvarea5ebe662006-09-24 21:24:46 +0200574 if (data->maxins == 4) {
Ivo Manca76e63862007-10-15 13:27:13 +0200575 if ((err = sysfs_create_group(&pdev->dev.kobj,
576 &sis5595_group_in4)))
Jean Delvarea5ebe662006-09-24 21:24:46 +0200577 goto exit_remove_files;
578 } else {
Ivo Manca76e63862007-10-15 13:27:13 +0200579 if ((err = sysfs_create_group(&pdev->dev.kobj,
580 &sis5595_group_temp1)))
Jean Delvarea5ebe662006-09-24 21:24:46 +0200581 goto exit_remove_files;
582 }
583
Tony Jones1beeffe2007-08-20 13:46:20 -0700584 data->hwmon_dev = hwmon_device_register(&pdev->dev);
585 if (IS_ERR(data->hwmon_dev)) {
586 err = PTR_ERR(data->hwmon_dev);
Jean Delvarea5ebe662006-09-24 21:24:46 +0200587 goto exit_remove_files;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400588 }
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 return 0;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400591
Jean Delvarea5ebe662006-09-24 21:24:46 +0200592exit_remove_files:
Jean Delvare17e7dc42007-06-09 10:11:16 -0400593 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
Ivo Manca76e63862007-10-15 13:27:13 +0200594 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
595 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596exit_free:
597 kfree(data);
598exit_release:
Jean Delvare17e7dc42007-06-09 10:11:16 -0400599 release_region(res->start, SIS5595_EXTENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600exit:
601 return err;
602}
603
Jean Delvare17e7dc42007-06-09 10:11:16 -0400604static int __devexit sis5595_remove(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400606 struct sis5595_data *data = platform_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Tony Jones1beeffe2007-08-20 13:46:20 -0700608 hwmon_device_unregister(data->hwmon_dev);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400609 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
Ivo Manca76e63862007-10-15 13:27:13 +0200610 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
611 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400612
Jean Delvare17e7dc42007-06-09 10:11:16 -0400613 release_region(data->addr, SIS5595_EXTENT);
614 platform_set_drvdata(pdev, NULL);
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400615 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 return 0;
618}
619
620
621/* ISA access must be locked explicitly. */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400622static int sis5595_read_value(struct sis5595_data *data, u8 reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623{
624 int res;
625
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100626 mutex_lock(&data->lock);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400627 outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
628 res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100629 mutex_unlock(&data->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 return res;
631}
632
Jean Delvare17e7dc42007-06-09 10:11:16 -0400633static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634{
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100635 mutex_lock(&data->lock);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400636 outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
637 outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100638 mutex_unlock(&data->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639}
640
641/* Called when we have found a new SIS5595. */
Jean Delvare17e7dc42007-06-09 10:11:16 -0400642static void __devinit sis5595_init_device(struct sis5595_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400644 u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 if (!(config & 0x01))
Jean Delvare17e7dc42007-06-09 10:11:16 -0400646 sis5595_write_value(data, SIS5595_REG_CONFIG,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 (config & 0xf7) | 0x01);
648}
649
650static struct sis5595_data *sis5595_update_device(struct device *dev)
651{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400652 struct sis5595_data *data = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 int i;
654
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100655 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
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] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400662 sis5595_read_value(data, SIS5595_REG_IN(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 data->in_min[i] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400664 sis5595_read_value(data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 SIS5595_REG_IN_MIN(i));
666 data->in_max[i] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400667 sis5595_read_value(data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 SIS5595_REG_IN_MAX(i));
669 }
670 for (i = 0; i < 2; i++) {
671 data->fan[i] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400672 sis5595_read_value(data, SIS5595_REG_FAN(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 data->fan_min[i] =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400674 sis5595_read_value(data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 SIS5595_REG_FAN_MIN(i));
676 }
677 if (data->maxins == 3) {
678 data->temp =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400679 sis5595_read_value(data, SIS5595_REG_TEMP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 data->temp_over =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400681 sis5595_read_value(data, SIS5595_REG_TEMP_OVER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 data->temp_hyst =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400683 sis5595_read_value(data, SIS5595_REG_TEMP_HYST);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 }
Jean Delvare17e7dc42007-06-09 10:11:16 -0400685 i = sis5595_read_value(data, SIS5595_REG_FANDIV);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 data->fan_div[0] = (i >> 4) & 0x03;
687 data->fan_div[1] = i >> 6;
688 data->alarms =
Jean Delvare17e7dc42007-06-09 10:11:16 -0400689 sis5595_read_value(data, SIS5595_REG_ALARM1) |
690 (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 data->last_updated = jiffies;
692 data->valid = 1;
693 }
694
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100695 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 return data;
698}
699
700static struct pci_device_id sis5595_pci_ids[] = {
701 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
702 { 0, }
703};
704
705MODULE_DEVICE_TABLE(pci, sis5595_pci_ids);
706
707static 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
Jean Delvare17e7dc42007-06-09 10:11:16 -0400721static 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
Jean Delvareb9acb642009-01-07 16:37:35 +0100731 err = acpi_check_resource_conflict(&res);
732 if (err)
733 goto exit;
734
Jean Delvare17e7dc42007-06-09 10:11:16 -0400735 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
758exit_device_put:
759 platform_device_put(pdev);
760exit:
761 return err;
762}
763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764static int __devinit sis5595_pci_probe(struct pci_dev *dev,
765 const struct pci_device_id *id)
766{
Jean Delvare17e7dc42007-06-09 10:11:16 -0400767 u16 address;
768 u8 enable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 int *i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
771 for (i = blacklist; *i != 0; i++) {
Mark M. Hoffman5460a9d2007-10-14 14:57:35 -0400772 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 return -ENODEV;
777 }
778 }
779
Jean Delvare17e7dc42007-06-09 10:11:16 -0400780 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 if (PCIBIOS_SUCCESSFUL !=
Jean Delvare17e7dc42007-06-09 10:11:16 -0400787 pci_read_config_word(dev, SIS5595_BASE_REG, &address)) {
788 dev_err(&dev->dev, "Failed to read ISA address\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 return -ENODEV;
Jean Delvare17e7dc42007-06-09 10:11:16 -0400790 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Jean Delvare17e7dc42007-06-09 10:11:16 -0400792 address &= ~(SIS5595_EXTENT - 1);
793 if (!address) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 dev_err(&dev->dev, "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
795 return -ENODEV;
796 }
Jean Delvare17e7dc42007-06-09 10:11:16 -0400797 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 s_bridge = pci_dev_get(dev);
Jean Delvare17e7dc42007-06-09 10:11:16 -0400827 /* Sets global pdev as a side effect */
828 if (sis5595_device_add(address))
829 goto exit_unregister;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
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;
Jean Delvare17e7dc42007-06-09 10:11:16 -0400836
837exit_unregister:
838 pci_dev_put(dev);
839 platform_driver_unregister(&sis5595_driver);
840exit:
841 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842}
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) {
Jean Delvare17e7dc42007-06-09 10:11:16 -0400859 platform_device_unregister(pdev);
860 platform_driver_unregister(&sis5595_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 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);