diff options
Diffstat (limited to 'drivers/i2c/chips/via686a.c')
-rw-r--r-- | drivers/i2c/chips/via686a.c | 879 |
1 files changed, 879 insertions, 0 deletions
diff --git a/drivers/i2c/chips/via686a.c b/drivers/i2c/chips/via686a.c new file mode 100644 index 000000000000..9b948f4531f5 --- /dev/null +++ b/drivers/i2c/chips/via686a.c | |||
@@ -0,0 +1,879 @@ | |||
1 | /* | ||
2 | via686a.c - Part of lm_sensors, Linux kernel modules | ||
3 | for hardware monitoring | ||
4 | |||
5 | Copyright (c) 1998 - 2002 Frodo Looijaard <frodol@dds.nl>, | ||
6 | Kyösti Mälkki <kmalkki@cc.hut.fi>, | ||
7 | Mark Studebaker <mdsxyz123@yahoo.com>, | ||
8 | and Bob Dougherty <bobd@stanford.edu> | ||
9 | (Some conversion-factor data were contributed by Jonathan Teh Soon Yew | ||
10 | <j.teh@iname.com> and Alex van Kaam <darkside@chello.nl>.) | ||
11 | |||
12 | This program is free software; you can redistribute it and/or modify | ||
13 | it under the terms of the GNU General Public License as published by | ||
14 | the Free Software Foundation; either version 2 of the License, or | ||
15 | (at your option) any later version. | ||
16 | |||
17 | This program is distributed in the hope that it will be useful, | ||
18 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
19 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
20 | GNU General Public License for more details. | ||
21 | |||
22 | You should have received a copy of the GNU General Public License | ||
23 | along with this program; if not, write to the Free Software | ||
24 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
25 | */ | ||
26 | |||
27 | /* | ||
28 | Supports the Via VT82C686A, VT82C686B south bridges. | ||
29 | Reports all as a 686A. | ||
30 | Warning - only supports a single device. | ||
31 | */ | ||
32 | |||
33 | #include <linux/config.h> | ||
34 | #include <linux/module.h> | ||
35 | #include <linux/slab.h> | ||
36 | #include <linux/pci.h> | ||
37 | #include <linux/delay.h> | ||
38 | #include <linux/jiffies.h> | ||
39 | #include <linux/i2c.h> | ||
40 | #include <linux/i2c-sensor.h> | ||
41 | #include <linux/init.h> | ||
42 | #include <asm/io.h> | ||
43 | |||
44 | |||
45 | /* If force_addr is set to anything different from 0, we forcibly enable | ||
46 | the device at the given address. */ | ||
47 | static unsigned short force_addr = 0; | ||
48 | module_param(force_addr, ushort, 0); | ||
49 | MODULE_PARM_DESC(force_addr, | ||
50 | "Initialize the base address of the sensors"); | ||
51 | |||
52 | /* Addresses to scan. | ||
53 | Note that we can't determine the ISA address until we have initialized | ||
54 | our module */ | ||
55 | static unsigned short normal_i2c[] = { I2C_CLIENT_END }; | ||
56 | static unsigned int normal_isa[] = { 0x0000, I2C_CLIENT_ISA_END }; | ||
57 | |||
58 | /* Insmod parameters */ | ||
59 | SENSORS_INSMOD_1(via686a); | ||
60 | |||
61 | /* | ||
62 | The Via 686a southbridge has a LM78-like chip integrated on the same IC. | ||
63 | This driver is a customized copy of lm78.c | ||
64 | */ | ||
65 | |||
66 | /* Many VIA686A constants specified below */ | ||
67 | |||
68 | /* Length of ISA address segment */ | ||
69 | #define VIA686A_EXTENT 0x80 | ||
70 | #define VIA686A_BASE_REG 0x70 | ||
71 | #define VIA686A_ENABLE_REG 0x74 | ||
72 | |||
73 | /* The VIA686A registers */ | ||
74 | /* ins numbered 0-4 */ | ||
75 | #define VIA686A_REG_IN_MAX(nr) (0x2b + ((nr) * 2)) | ||
76 | #define VIA686A_REG_IN_MIN(nr) (0x2c + ((nr) * 2)) | ||
77 | #define VIA686A_REG_IN(nr) (0x22 + (nr)) | ||
78 | |||
79 | /* fans numbered 1-2 */ | ||
80 | #define VIA686A_REG_FAN_MIN(nr) (0x3a + (nr)) | ||
81 | #define VIA686A_REG_FAN(nr) (0x28 + (nr)) | ||
82 | |||
83 | /* the following values are as speced by VIA: */ | ||
84 | static const u8 regtemp[] = { 0x20, 0x21, 0x1f }; | ||
85 | static const u8 regover[] = { 0x39, 0x3d, 0x1d }; | ||
86 | static const u8 reghyst[] = { 0x3a, 0x3e, 0x1e }; | ||
87 | |||
88 | /* temps numbered 1-3 */ | ||
89 | #define VIA686A_REG_TEMP(nr) (regtemp[nr]) | ||
90 | #define VIA686A_REG_TEMP_OVER(nr) (regover[nr]) | ||
91 | #define VIA686A_REG_TEMP_HYST(nr) (reghyst[nr]) | ||
92 | #define VIA686A_REG_TEMP_LOW1 0x4b // bits 7-6 | ||
93 | #define VIA686A_REG_TEMP_LOW23 0x49 // 2 = bits 5-4, 3 = bits 7-6 | ||
94 | |||
95 | #define VIA686A_REG_ALARM1 0x41 | ||
96 | #define VIA686A_REG_ALARM2 0x42 | ||
97 | #define VIA686A_REG_FANDIV 0x47 | ||
98 | #define VIA686A_REG_CONFIG 0x40 | ||
99 | /* The following register sets temp interrupt mode (bits 1-0 for temp1, | ||
100 | 3-2 for temp2, 5-4 for temp3). Modes are: | ||
101 | 00 interrupt stays as long as value is out-of-range | ||
102 | 01 interrupt is cleared once register is read (default) | ||
103 | 10 comparator mode- like 00, but ignores hysteresis | ||
104 | 11 same as 00 */ | ||
105 | #define VIA686A_REG_TEMP_MODE 0x4b | ||
106 | /* We'll just assume that you want to set all 3 simultaneously: */ | ||
107 | #define VIA686A_TEMP_MODE_MASK 0x3F | ||
108 | #define VIA686A_TEMP_MODE_CONTINUOUS (0x00) | ||
109 | |||
110 | /* Conversions. Limit checking is only done on the TO_REG | ||
111 | variants. | ||
112 | |||
113 | ********* VOLTAGE CONVERSIONS (Bob Dougherty) ******** | ||
114 | From HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew): | ||
115 | voltagefactor[0]=1.25/2628; (2628/1.25=2102.4) // Vccp | ||
116 | voltagefactor[1]=1.25/2628; (2628/1.25=2102.4) // +2.5V | ||
117 | voltagefactor[2]=1.67/2628; (2628/1.67=1573.7) // +3.3V | ||
118 | voltagefactor[3]=2.6/2628; (2628/2.60=1010.8) // +5V | ||
119 | voltagefactor[4]=6.3/2628; (2628/6.30=417.14) // +12V | ||
120 | in[i]=(data[i+2]*25.0+133)*voltagefactor[i]; | ||
121 | That is: | ||
122 | volts = (25*regVal+133)*factor | ||
123 | regVal = (volts/factor-133)/25 | ||
124 | (These conversions were contributed by Jonathan Teh Soon Yew | ||
125 | <j.teh@iname.com>) */ | ||
126 | static inline u8 IN_TO_REG(long val, int inNum) | ||
127 | { | ||
128 | /* To avoid floating point, we multiply constants by 10 (100 for +12V). | ||
129 | Rounding is done (120500 is actually 133000 - 12500). | ||
130 | Remember that val is expressed in 0.001V/bit, which is why we divide | ||
131 | by an additional 10000 (100000 for +12V): 1000 for val and 10 (100) | ||
132 | for the constants. */ | ||
133 | if (inNum <= 1) | ||
134 | return (u8) | ||
135 | SENSORS_LIMIT((val * 21024 - 1205000) / 250000, 0, 255); | ||
136 | else if (inNum == 2) | ||
137 | return (u8) | ||
138 | SENSORS_LIMIT((val * 15737 - 1205000) / 250000, 0, 255); | ||
139 | else if (inNum == 3) | ||
140 | return (u8) | ||
141 | SENSORS_LIMIT((val * 10108 - 1205000) / 250000, 0, 255); | ||
142 | else | ||
143 | return (u8) | ||
144 | SENSORS_LIMIT((val * 41714 - 12050000) / 2500000, 0, 255); | ||
145 | } | ||
146 | |||
147 | static inline long IN_FROM_REG(u8 val, int inNum) | ||
148 | { | ||
149 | /* To avoid floating point, we multiply constants by 10 (100 for +12V). | ||
150 | We also multiply them by 1000 because we want 0.001V/bit for the | ||
151 | output value. Rounding is done. */ | ||
152 | if (inNum <= 1) | ||
153 | return (long) ((250000 * val + 1330000 + 21024 / 2) / 21024); | ||
154 | else if (inNum == 2) | ||
155 | return (long) ((250000 * val + 1330000 + 15737 / 2) / 15737); | ||
156 | else if (inNum == 3) | ||
157 | return (long) ((250000 * val + 1330000 + 10108 / 2) / 10108); | ||
158 | else | ||
159 | return (long) ((2500000 * val + 13300000 + 41714 / 2) / 41714); | ||
160 | } | ||
161 | |||
162 | /********* FAN RPM CONVERSIONS ********/ | ||
163 | /* Higher register values = slower fans (the fan's strobe gates a counter). | ||
164 | But this chip saturates back at 0, not at 255 like all the other chips. | ||
165 | So, 0 means 0 RPM */ | ||
166 | static inline u8 FAN_TO_REG(long rpm, int div) | ||
167 | { | ||
168 | if (rpm == 0) | ||
169 | return 0; | ||
170 | rpm = SENSORS_LIMIT(rpm, 1, 1000000); | ||
171 | return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 255); | ||
172 | } | ||
173 | |||
174 | #define FAN_FROM_REG(val,div) ((val)==0?0:(val)==255?0:1350000/((val)*(div))) | ||
175 | |||
176 | /******** TEMP CONVERSIONS (Bob Dougherty) *********/ | ||
177 | /* linear fits from HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew) | ||
178 | if(temp<169) | ||
179 | return double(temp)*0.427-32.08; | ||
180 | else if(temp>=169 && temp<=202) | ||
181 | return double(temp)*0.582-58.16; | ||
182 | else | ||
183 | return double(temp)*0.924-127.33; | ||
184 | |||
185 | A fifth-order polynomial fits the unofficial data (provided by Alex van | ||
186 | Kaam <darkside@chello.nl>) a bit better. It also give more reasonable | ||
187 | numbers on my machine (ie. they agree with what my BIOS tells me). | ||
188 | Here's the fifth-order fit to the 8-bit data: | ||
189 | temp = 1.625093e-10*val^5 - 1.001632e-07*val^4 + 2.457653e-05*val^3 - | ||
190 | 2.967619e-03*val^2 + 2.175144e-01*val - 7.090067e+0. | ||
191 | |||
192 | (2000-10-25- RFD: thanks to Uwe Andersen <uandersen@mayah.com> for | ||
193 | finding my typos in this formula!) | ||
194 | |||
195 | Alas, none of the elegant function-fit solutions will work because we | ||
196 | aren't allowed to use floating point in the kernel and doing it with | ||
197 | integers doesn't rpovide enough precision. So we'll do boring old | ||
198 | look-up table stuff. The unofficial data (see below) have effectively | ||
199 | 7-bit resolution (they are rounded to the nearest degree). I'm assuming | ||
200 | that the transfer function of the device is monotonic and smooth, so a | ||
201 | smooth function fit to the data will allow us to get better precision. | ||
202 | I used the 5th-order poly fit described above and solved for | ||
203 | VIA register values 0-255. I *10 before rounding, so we get tenth-degree | ||
204 | precision. (I could have done all 1024 values for our 10-bit readings, | ||
205 | but the function is very linear in the useful range (0-80 deg C), so | ||
206 | we'll just use linear interpolation for 10-bit readings.) So, tempLUT | ||
207 | is the temp at via register values 0-255: */ | ||
208 | static const long tempLUT[] = | ||
209 | { -709, -688, -667, -646, -627, -607, -589, -570, -553, -536, -519, | ||
210 | -503, -487, -471, -456, -442, -428, -414, -400, -387, -375, | ||
211 | -362, -350, -339, -327, -316, -305, -295, -285, -275, -265, | ||
212 | -255, -246, -237, -229, -220, -212, -204, -196, -188, -180, | ||
213 | -173, -166, -159, -152, -145, -139, -132, -126, -120, -114, | ||
214 | -108, -102, -96, -91, -85, -80, -74, -69, -64, -59, -54, -49, | ||
215 | -44, -39, -34, -29, -25, -20, -15, -11, -6, -2, 3, 7, 12, 16, | ||
216 | 20, 25, 29, 33, 37, 42, 46, 50, 54, 59, 63, 67, 71, 75, 79, 84, | ||
217 | 88, 92, 96, 100, 104, 109, 113, 117, 121, 125, 130, 134, 138, | ||
218 | 142, 146, 151, 155, 159, 163, 168, 172, 176, 181, 185, 189, | ||
219 | 193, 198, 202, 206, 211, 215, 219, 224, 228, 232, 237, 241, | ||
220 | 245, 250, 254, 259, 263, 267, 272, 276, 281, 285, 290, 294, | ||
221 | 299, 303, 307, 312, 316, 321, 325, 330, 334, 339, 344, 348, | ||
222 | 353, 357, 362, 366, 371, 376, 380, 385, 390, 395, 399, 404, | ||
223 | 409, 414, 419, 423, 428, 433, 438, 443, 449, 454, 459, 464, | ||
224 | 469, 475, 480, 486, 491, 497, 502, 508, 514, 520, 526, 532, | ||
225 | 538, 544, 551, 557, 564, 571, 578, 584, 592, 599, 606, 614, | ||
226 | 621, 629, 637, 645, 654, 662, 671, 680, 689, 698, 708, 718, | ||
227 | 728, 738, 749, 759, 770, 782, 793, 805, 818, 830, 843, 856, | ||
228 | 870, 883, 898, 912, 927, 943, 958, 975, 991, 1008, 1026, 1044, | ||
229 | 1062, 1081, 1101, 1121, 1141, 1162, 1184, 1206, 1229, 1252, | ||
230 | 1276, 1301, 1326, 1352, 1378, 1406, 1434, 1462 | ||
231 | }; | ||
232 | |||
233 | /* the original LUT values from Alex van Kaam <darkside@chello.nl> | ||
234 | (for via register values 12-240): | ||
235 | {-50,-49,-47,-45,-43,-41,-39,-38,-37,-35,-34,-33,-32,-31, | ||
236 | -30,-29,-28,-27,-26,-25,-24,-24,-23,-22,-21,-20,-20,-19,-18,-17,-17,-16,-15, | ||
237 | -15,-14,-14,-13,-12,-12,-11,-11,-10,-9,-9,-8,-8,-7,-7,-6,-6,-5,-5,-4,-4,-3, | ||
238 | -3,-2,-2,-1,-1,0,0,1,1,1,3,3,3,4,4,4,5,5,5,6,6,7,7,8,8,9,9,9,10,10,11,11,12, | ||
239 | 12,12,13,13,13,14,14,15,15,16,16,16,17,17,18,18,19,19,20,20,21,21,21,22,22, | ||
240 | 22,23,23,24,24,25,25,26,26,26,27,27,27,28,28,29,29,30,30,30,31,31,32,32,33, | ||
241 | 33,34,34,35,35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,43,43,44,44,45, | ||
242 | 45,46,46,47,48,48,49,49,50,51,51,52,52,53,53,54,55,55,56,57,57,58,59,59,60, | ||
243 | 61,62,62,63,64,65,66,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,83,84, | ||
244 | 85,86,88,89,91,92,94,96,97,99,101,103,105,107,109,110}; | ||
245 | |||
246 | |||
247 | Here's the reverse LUT. I got it by doing a 6-th order poly fit (needed | ||
248 | an extra term for a good fit to these inverse data!) and then | ||
249 | solving for each temp value from -50 to 110 (the useable range for | ||
250 | this chip). Here's the fit: | ||
251 | viaRegVal = -1.160370e-10*val^6 +3.193693e-08*val^5 - 1.464447e-06*val^4 | ||
252 | - 2.525453e-04*val^3 + 1.424593e-02*val^2 + 2.148941e+00*val +7.275808e+01) | ||
253 | Note that n=161: */ | ||
254 | static const u8 viaLUT[] = | ||
255 | { 12, 12, 13, 14, 14, 15, 16, 16, 17, 18, 18, 19, 20, 20, 21, 22, 23, | ||
256 | 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 39, 40, | ||
257 | 41, 43, 45, 46, 48, 49, 51, 53, 55, 57, 59, 60, 62, 64, 66, | ||
258 | 69, 71, 73, 75, 77, 79, 82, 84, 86, 88, 91, 93, 95, 98, 100, | ||
259 | 103, 105, 107, 110, 112, 115, 117, 119, 122, 124, 126, 129, | ||
260 | 131, 134, 136, 138, 140, 143, 145, 147, 150, 152, 154, 156, | ||
261 | 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, | ||
262 | 182, 183, 185, 187, 188, 190, 192, 193, 195, 196, 198, 199, | ||
263 | 200, 202, 203, 205, 206, 207, 208, 209, 210, 211, 212, 213, | ||
264 | 214, 215, 216, 217, 218, 219, 220, 221, 222, 222, 223, 224, | ||
265 | 225, 226, 226, 227, 228, 228, 229, 230, 230, 231, 232, 232, | ||
266 | 233, 233, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, | ||
267 | 239, 240 | ||
268 | }; | ||
269 | |||
270 | /* Converting temps to (8-bit) hyst and over registers | ||
271 | No interpolation here. | ||
272 | The +50 is because the temps start at -50 */ | ||
273 | static inline u8 TEMP_TO_REG(long val) | ||
274 | { | ||
275 | return viaLUT[val <= -50000 ? 0 : val >= 110000 ? 160 : | ||
276 | (val < 0 ? val - 500 : val + 500) / 1000 + 50]; | ||
277 | } | ||
278 | |||
279 | /* for 8-bit temperature hyst and over registers */ | ||
280 | #define TEMP_FROM_REG(val) (tempLUT[(val)] * 100) | ||
281 | |||
282 | /* for 10-bit temperature readings */ | ||
283 | static inline long TEMP_FROM_REG10(u16 val) | ||
284 | { | ||
285 | u16 eightBits = val >> 2; | ||
286 | u16 twoBits = val & 3; | ||
287 | |||
288 | /* no interpolation for these */ | ||
289 | if (twoBits == 0 || eightBits == 255) | ||
290 | return TEMP_FROM_REG(eightBits); | ||
291 | |||
292 | /* do some linear interpolation */ | ||
293 | return (tempLUT[eightBits] * (4 - twoBits) + | ||
294 | tempLUT[eightBits + 1] * twoBits) * 25; | ||
295 | } | ||
296 | |||
297 | #define ALARMS_FROM_REG(val) (val) | ||
298 | |||
299 | #define DIV_FROM_REG(val) (1 << (val)) | ||
300 | #define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1) | ||
301 | |||
302 | /* For the VIA686A, we need to keep some data in memory. | ||
303 | The structure is dynamically allocated, at the same time when a new | ||
304 | via686a client is allocated. */ | ||
305 | struct via686a_data { | ||
306 | struct i2c_client client; | ||
307 | struct semaphore update_lock; | ||
308 | char valid; /* !=0 if following fields are valid */ | ||
309 | unsigned long last_updated; /* In jiffies */ | ||
310 | |||
311 | u8 in[5]; /* Register value */ | ||
312 | u8 in_max[5]; /* Register value */ | ||
313 | u8 in_min[5]; /* Register value */ | ||
314 | u8 fan[2]; /* Register value */ | ||
315 | u8 fan_min[2]; /* Register value */ | ||
316 | u16 temp[3]; /* Register value 10 bit */ | ||
317 | u8 temp_over[3]; /* Register value */ | ||
318 | u8 temp_hyst[3]; /* Register value */ | ||
319 | u8 fan_div[2]; /* Register encoding, shifted right */ | ||
320 | u16 alarms; /* Register encoding, combined */ | ||
321 | }; | ||
322 | |||
323 | static struct pci_dev *s_bridge; /* pointer to the (only) via686a */ | ||
324 | |||
325 | static int via686a_attach_adapter(struct i2c_adapter *adapter); | ||
326 | static int via686a_detect(struct i2c_adapter *adapter, int address, int kind); | ||
327 | static int via686a_detach_client(struct i2c_client *client); | ||
328 | |||
329 | static inline int via686a_read_value(struct i2c_client *client, u8 reg) | ||
330 | { | ||
331 | return (inb_p(client->addr + reg)); | ||
332 | } | ||
333 | |||
334 | static inline void via686a_write_value(struct i2c_client *client, u8 reg, | ||
335 | u8 value) | ||
336 | { | ||
337 | outb_p(value, client->addr + reg); | ||
338 | } | ||
339 | |||
340 | static struct via686a_data *via686a_update_device(struct device *dev); | ||
341 | static void via686a_init_client(struct i2c_client *client); | ||
342 | |||
343 | /* following are the sysfs callback functions */ | ||
344 | |||
345 | /* 7 voltage sensors */ | ||
346 | static ssize_t show_in(struct device *dev, char *buf, int nr) { | ||
347 | struct via686a_data *data = via686a_update_device(dev); | ||
348 | return sprintf(buf, "%ld\n", IN_FROM_REG(data->in[nr], nr)); | ||
349 | } | ||
350 | |||
351 | static ssize_t show_in_min(struct device *dev, char *buf, int nr) { | ||
352 | struct via686a_data *data = via686a_update_device(dev); | ||
353 | return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_min[nr], nr)); | ||
354 | } | ||
355 | |||
356 | static ssize_t show_in_max(struct device *dev, char *buf, int nr) { | ||
357 | struct via686a_data *data = via686a_update_device(dev); | ||
358 | return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_max[nr], nr)); | ||
359 | } | ||
360 | |||
361 | static ssize_t set_in_min(struct device *dev, const char *buf, | ||
362 | size_t count, int nr) { | ||
363 | struct i2c_client *client = to_i2c_client(dev); | ||
364 | struct via686a_data *data = i2c_get_clientdata(client); | ||
365 | unsigned long val = simple_strtoul(buf, NULL, 10); | ||
366 | |||
367 | down(&data->update_lock); | ||
368 | data->in_min[nr] = IN_TO_REG(val,nr); | ||
369 | via686a_write_value(client, VIA686A_REG_IN_MIN(nr), | ||
370 | data->in_min[nr]); | ||
371 | up(&data->update_lock); | ||
372 | return count; | ||
373 | } | ||
374 | static ssize_t set_in_max(struct device *dev, const char *buf, | ||
375 | size_t count, int nr) { | ||
376 | struct i2c_client *client = to_i2c_client(dev); | ||
377 | struct via686a_data *data = i2c_get_clientdata(client); | ||
378 | unsigned long val = simple_strtoul(buf, NULL, 10); | ||
379 | |||
380 | down(&data->update_lock); | ||
381 | data->in_max[nr] = IN_TO_REG(val,nr); | ||
382 | via686a_write_value(client, VIA686A_REG_IN_MAX(nr), | ||
383 | data->in_max[nr]); | ||
384 | up(&data->update_lock); | ||
385 | return count; | ||
386 | } | ||
387 | #define show_in_offset(offset) \ | ||
388 | static ssize_t \ | ||
389 | show_in##offset (struct device *dev, char *buf) \ | ||
390 | { \ | ||
391 | return show_in(dev, buf, offset); \ | ||
392 | } \ | ||
393 | static ssize_t \ | ||
394 | show_in##offset##_min (struct device *dev, char *buf) \ | ||
395 | { \ | ||
396 | return show_in_min(dev, buf, offset); \ | ||
397 | } \ | ||
398 | static ssize_t \ | ||
399 | show_in##offset##_max (struct device *dev, char *buf) \ | ||
400 | { \ | ||
401 | return show_in_max(dev, buf, offset); \ | ||
402 | } \ | ||
403 | static ssize_t set_in##offset##_min (struct device *dev, \ | ||
404 | const char *buf, size_t count) \ | ||
405 | { \ | ||
406 | return set_in_min(dev, buf, count, offset); \ | ||
407 | } \ | ||
408 | static ssize_t set_in##offset##_max (struct device *dev, \ | ||
409 | const char *buf, size_t count) \ | ||
410 | { \ | ||
411 | return set_in_max(dev, buf, count, offset); \ | ||
412 | } \ | ||
413 | static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in##offset, NULL);\ | ||
414 | static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ | ||
415 | show_in##offset##_min, set_in##offset##_min); \ | ||
416 | static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ | ||
417 | show_in##offset##_max, set_in##offset##_max); | ||
418 | |||
419 | show_in_offset(0); | ||
420 | show_in_offset(1); | ||
421 | show_in_offset(2); | ||
422 | show_in_offset(3); | ||
423 | show_in_offset(4); | ||
424 | |||
425 | /* 3 temperatures */ | ||
426 | static ssize_t show_temp(struct device *dev, char *buf, int nr) { | ||
427 | struct via686a_data *data = via686a_update_device(dev); | ||
428 | return sprintf(buf, "%ld\n", TEMP_FROM_REG10(data->temp[nr])); | ||
429 | } | ||
430 | static ssize_t show_temp_over(struct device *dev, char *buf, int nr) { | ||
431 | struct via686a_data *data = via686a_update_device(dev); | ||
432 | return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_over[nr])); | ||
433 | } | ||
434 | static ssize_t show_temp_hyst(struct device *dev, char *buf, int nr) { | ||
435 | struct via686a_data *data = via686a_update_device(dev); | ||
436 | return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_hyst[nr])); | ||
437 | } | ||
438 | static ssize_t set_temp_over(struct device *dev, const char *buf, | ||
439 | size_t count, int nr) { | ||
440 | struct i2c_client *client = to_i2c_client(dev); | ||
441 | struct via686a_data *data = i2c_get_clientdata(client); | ||
442 | int val = simple_strtol(buf, NULL, 10); | ||
443 | |||
444 | down(&data->update_lock); | ||
445 | data->temp_over[nr] = TEMP_TO_REG(val); | ||
446 | via686a_write_value(client, VIA686A_REG_TEMP_OVER(nr), data->temp_over[nr]); | ||
447 | up(&data->update_lock); | ||
448 | return count; | ||
449 | } | ||
450 | static ssize_t set_temp_hyst(struct device *dev, const char *buf, | ||
451 | size_t count, int nr) { | ||
452 | struct i2c_client *client = to_i2c_client(dev); | ||
453 | struct via686a_data *data = i2c_get_clientdata(client); | ||
454 | int val = simple_strtol(buf, NULL, 10); | ||
455 | |||
456 | down(&data->update_lock); | ||
457 | data->temp_hyst[nr] = TEMP_TO_REG(val); | ||
458 | via686a_write_value(client, VIA686A_REG_TEMP_HYST(nr), data->temp_hyst[nr]); | ||
459 | up(&data->update_lock); | ||
460 | return count; | ||
461 | } | ||
462 | #define show_temp_offset(offset) \ | ||
463 | static ssize_t show_temp_##offset (struct device *dev, char *buf) \ | ||
464 | { \ | ||
465 | return show_temp(dev, buf, offset - 1); \ | ||
466 | } \ | ||
467 | static ssize_t \ | ||
468 | show_temp_##offset##_over (struct device *dev, char *buf) \ | ||
469 | { \ | ||
470 | return show_temp_over(dev, buf, offset - 1); \ | ||
471 | } \ | ||
472 | static ssize_t \ | ||
473 | show_temp_##offset##_hyst (struct device *dev, char *buf) \ | ||
474 | { \ | ||
475 | return show_temp_hyst(dev, buf, offset - 1); \ | ||
476 | } \ | ||
477 | static ssize_t set_temp_##offset##_over (struct device *dev, \ | ||
478 | const char *buf, size_t count) \ | ||
479 | { \ | ||
480 | return set_temp_over(dev, buf, count, offset - 1); \ | ||
481 | } \ | ||
482 | static ssize_t set_temp_##offset##_hyst (struct device *dev, \ | ||
483 | const char *buf, size_t count) \ | ||
484 | { \ | ||
485 | return set_temp_hyst(dev, buf, count, offset - 1); \ | ||
486 | } \ | ||
487 | static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp_##offset, NULL);\ | ||
488 | static DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ | ||
489 | show_temp_##offset##_over, set_temp_##offset##_over); \ | ||
490 | static DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \ | ||
491 | show_temp_##offset##_hyst, set_temp_##offset##_hyst); | ||
492 | |||
493 | show_temp_offset(1); | ||
494 | show_temp_offset(2); | ||
495 | show_temp_offset(3); | ||
496 | |||
497 | /* 2 Fans */ | ||
498 | static ssize_t show_fan(struct device *dev, char *buf, int nr) { | ||
499 | struct via686a_data *data = via686a_update_device(dev); | ||
500 | return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr], | ||
501 | DIV_FROM_REG(data->fan_div[nr])) ); | ||
502 | } | ||
503 | static ssize_t show_fan_min(struct device *dev, char *buf, int nr) { | ||
504 | struct via686a_data *data = via686a_update_device(dev); | ||
505 | return sprintf(buf,"%d\n", | ||
506 | FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])) ); | ||
507 | } | ||
508 | static ssize_t show_fan_div(struct device *dev, char *buf, int nr) { | ||
509 | struct via686a_data *data = via686a_update_device(dev); | ||
510 | return sprintf(buf,"%d\n", DIV_FROM_REG(data->fan_div[nr]) ); | ||
511 | } | ||
512 | static ssize_t set_fan_min(struct device *dev, const char *buf, | ||
513 | size_t count, int nr) { | ||
514 | struct i2c_client *client = to_i2c_client(dev); | ||
515 | struct via686a_data *data = i2c_get_clientdata(client); | ||
516 | int val = simple_strtol(buf, NULL, 10); | ||
517 | |||
518 | down(&data->update_lock); | ||
519 | data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); | ||
520 | via686a_write_value(client, VIA686A_REG_FAN_MIN(nr+1), data->fan_min[nr]); | ||
521 | up(&data->update_lock); | ||
522 | return count; | ||
523 | } | ||
524 | static ssize_t set_fan_div(struct device *dev, const char *buf, | ||
525 | size_t count, int nr) { | ||
526 | struct i2c_client *client = to_i2c_client(dev); | ||
527 | struct via686a_data *data = i2c_get_clientdata(client); | ||
528 | int val = simple_strtol(buf, NULL, 10); | ||
529 | int old; | ||
530 | |||
531 | down(&data->update_lock); | ||
532 | old = via686a_read_value(client, VIA686A_REG_FANDIV); | ||
533 | data->fan_div[nr] = DIV_TO_REG(val); | ||
534 | old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4); | ||
535 | via686a_write_value(client, VIA686A_REG_FANDIV, old); | ||
536 | up(&data->update_lock); | ||
537 | return count; | ||
538 | } | ||
539 | |||
540 | #define show_fan_offset(offset) \ | ||
541 | static ssize_t show_fan_##offset (struct device *dev, char *buf) \ | ||
542 | { \ | ||
543 | return show_fan(dev, buf, offset - 1); \ | ||
544 | } \ | ||
545 | static ssize_t show_fan_##offset##_min (struct device *dev, char *buf) \ | ||
546 | { \ | ||
547 | return show_fan_min(dev, buf, offset - 1); \ | ||
548 | } \ | ||
549 | static ssize_t show_fan_##offset##_div (struct device *dev, char *buf) \ | ||
550 | { \ | ||
551 | return show_fan_div(dev, buf, offset - 1); \ | ||
552 | } \ | ||
553 | static ssize_t set_fan_##offset##_min (struct device *dev, \ | ||
554 | const char *buf, size_t count) \ | ||
555 | { \ | ||
556 | return set_fan_min(dev, buf, count, offset - 1); \ | ||
557 | } \ | ||
558 | static ssize_t set_fan_##offset##_div (struct device *dev, \ | ||
559 | const char *buf, size_t count) \ | ||
560 | { \ | ||
561 | return set_fan_div(dev, buf, count, offset - 1); \ | ||
562 | } \ | ||
563 | static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\ | ||
564 | static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ | ||
565 | show_fan_##offset##_min, set_fan_##offset##_min); \ | ||
566 | static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ | ||
567 | show_fan_##offset##_div, set_fan_##offset##_div); | ||
568 | |||
569 | show_fan_offset(1); | ||
570 | show_fan_offset(2); | ||
571 | |||
572 | /* Alarms */ | ||
573 | static ssize_t show_alarms(struct device *dev, char *buf) { | ||
574 | struct via686a_data *data = via686a_update_device(dev); | ||
575 | return sprintf(buf,"%d\n", ALARMS_FROM_REG(data->alarms)); | ||
576 | } | ||
577 | static DEVICE_ATTR(alarms, S_IRUGO | S_IWUSR, show_alarms, NULL); | ||
578 | |||
579 | /* The driver. I choose to use type i2c_driver, as at is identical to both | ||
580 | smbus_driver and isa_driver, and clients could be of either kind */ | ||
581 | static struct i2c_driver via686a_driver = { | ||
582 | .owner = THIS_MODULE, | ||
583 | .name = "via686a", | ||
584 | .id = I2C_DRIVERID_VIA686A, | ||
585 | .flags = I2C_DF_NOTIFY, | ||
586 | .attach_adapter = via686a_attach_adapter, | ||
587 | .detach_client = via686a_detach_client, | ||
588 | }; | ||
589 | |||
590 | |||
591 | /* This is called when the module is loaded */ | ||
592 | static int via686a_attach_adapter(struct i2c_adapter *adapter) | ||
593 | { | ||
594 | if (!(adapter->class & I2C_CLASS_HWMON)) | ||
595 | return 0; | ||
596 | return i2c_detect(adapter, &addr_data, via686a_detect); | ||
597 | } | ||
598 | |||
599 | static int via686a_detect(struct i2c_adapter *adapter, int address, int kind) | ||
600 | { | ||
601 | struct i2c_client *new_client; | ||
602 | struct via686a_data *data; | ||
603 | int err = 0; | ||
604 | const char client_name[] = "via686a"; | ||
605 | u16 val; | ||
606 | |||
607 | /* Make sure we are probing the ISA bus!! */ | ||
608 | if (!i2c_is_isa_adapter(adapter)) { | ||
609 | dev_err(&adapter->dev, | ||
610 | "via686a_detect called for an I2C bus adapter?!?\n"); | ||
611 | return 0; | ||
612 | } | ||
613 | |||
614 | /* 8231 requires multiple of 256, we enforce that on 686 as well */ | ||
615 | if(force_addr) | ||
616 | address = force_addr & 0xFF00; | ||
617 | |||
618 | if(force_addr) { | ||
619 | dev_warn(&adapter->dev,"forcing ISA address 0x%04X\n", address); | ||
620 | if (PCIBIOS_SUCCESSFUL != | ||
621 | pci_write_config_word(s_bridge, VIA686A_BASE_REG, address)) | ||
622 | return -ENODEV; | ||
623 | } | ||
624 | if (PCIBIOS_SUCCESSFUL != | ||
625 | pci_read_config_word(s_bridge, VIA686A_ENABLE_REG, &val)) | ||
626 | return -ENODEV; | ||
627 | if (!(val & 0x0001)) { | ||
628 | dev_warn(&adapter->dev,"enabling sensors\n"); | ||
629 | if (PCIBIOS_SUCCESSFUL != | ||
630 | pci_write_config_word(s_bridge, VIA686A_ENABLE_REG, | ||
631 | val | 0x0001)) | ||
632 | return -ENODEV; | ||
633 | } | ||
634 | |||
635 | /* Reserve the ISA region */ | ||
636 | if (!request_region(address, VIA686A_EXTENT, via686a_driver.name)) { | ||
637 | dev_err(&adapter->dev,"region 0x%x already in use!\n", | ||
638 | address); | ||
639 | return -ENODEV; | ||
640 | } | ||
641 | |||
642 | if (!(data = kmalloc(sizeof(struct via686a_data), GFP_KERNEL))) { | ||
643 | err = -ENOMEM; | ||
644 | goto ERROR0; | ||
645 | } | ||
646 | memset(data, 0, sizeof(struct via686a_data)); | ||
647 | |||
648 | new_client = &data->client; | ||
649 | i2c_set_clientdata(new_client, data); | ||
650 | new_client->addr = address; | ||
651 | new_client->adapter = adapter; | ||
652 | new_client->driver = &via686a_driver; | ||
653 | new_client->flags = 0; | ||
654 | new_client->dev.parent = &adapter->dev; | ||
655 | |||
656 | /* Fill in the remaining client fields and put into the global list */ | ||
657 | snprintf(new_client->name, I2C_NAME_SIZE, client_name); | ||
658 | |||
659 | data->valid = 0; | ||
660 | init_MUTEX(&data->update_lock); | ||
661 | /* Tell the I2C layer a new client has arrived */ | ||
662 | if ((err = i2c_attach_client(new_client))) | ||
663 | goto ERROR3; | ||
664 | |||
665 | /* Initialize the VIA686A chip */ | ||
666 | via686a_init_client(new_client); | ||
667 | |||
668 | /* Register sysfs hooks */ | ||
669 | device_create_file(&new_client->dev, &dev_attr_in0_input); | ||
670 | device_create_file(&new_client->dev, &dev_attr_in1_input); | ||
671 | device_create_file(&new_client->dev, &dev_attr_in2_input); | ||
672 | device_create_file(&new_client->dev, &dev_attr_in3_input); | ||
673 | device_create_file(&new_client->dev, &dev_attr_in4_input); | ||
674 | device_create_file(&new_client->dev, &dev_attr_in0_min); | ||
675 | device_create_file(&new_client->dev, &dev_attr_in1_min); | ||
676 | device_create_file(&new_client->dev, &dev_attr_in2_min); | ||
677 | device_create_file(&new_client->dev, &dev_attr_in3_min); | ||
678 | device_create_file(&new_client->dev, &dev_attr_in4_min); | ||
679 | device_create_file(&new_client->dev, &dev_attr_in0_max); | ||
680 | device_create_file(&new_client->dev, &dev_attr_in1_max); | ||
681 | device_create_file(&new_client->dev, &dev_attr_in2_max); | ||
682 | device_create_file(&new_client->dev, &dev_attr_in3_max); | ||
683 | device_create_file(&new_client->dev, &dev_attr_in4_max); | ||
684 | device_create_file(&new_client->dev, &dev_attr_temp1_input); | ||
685 | device_create_file(&new_client->dev, &dev_attr_temp2_input); | ||
686 | device_create_file(&new_client->dev, &dev_attr_temp3_input); | ||
687 | device_create_file(&new_client->dev, &dev_attr_temp1_max); | ||
688 | device_create_file(&new_client->dev, &dev_attr_temp2_max); | ||
689 | device_create_file(&new_client->dev, &dev_attr_temp3_max); | ||
690 | device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst); | ||
691 | device_create_file(&new_client->dev, &dev_attr_temp2_max_hyst); | ||
692 | device_create_file(&new_client->dev, &dev_attr_temp3_max_hyst); | ||
693 | device_create_file(&new_client->dev, &dev_attr_fan1_input); | ||
694 | device_create_file(&new_client->dev, &dev_attr_fan2_input); | ||
695 | device_create_file(&new_client->dev, &dev_attr_fan1_min); | ||
696 | device_create_file(&new_client->dev, &dev_attr_fan2_min); | ||
697 | device_create_file(&new_client->dev, &dev_attr_fan1_div); | ||
698 | device_create_file(&new_client->dev, &dev_attr_fan2_div); | ||
699 | device_create_file(&new_client->dev, &dev_attr_alarms); | ||
700 | |||
701 | return 0; | ||
702 | |||
703 | ERROR3: | ||
704 | kfree(data); | ||
705 | ERROR0: | ||
706 | release_region(address, VIA686A_EXTENT); | ||
707 | return err; | ||
708 | } | ||
709 | |||
710 | static int via686a_detach_client(struct i2c_client *client) | ||
711 | { | ||
712 | int err; | ||
713 | |||
714 | if ((err = i2c_detach_client(client))) { | ||
715 | dev_err(&client->dev, | ||
716 | "Client deregistration failed, client not detached.\n"); | ||
717 | return err; | ||
718 | } | ||
719 | |||
720 | release_region(client->addr, VIA686A_EXTENT); | ||
721 | kfree(i2c_get_clientdata(client)); | ||
722 | |||
723 | return 0; | ||
724 | } | ||
725 | |||
726 | /* Called when we have found a new VIA686A. Set limits, etc. */ | ||
727 | static void via686a_init_client(struct i2c_client *client) | ||
728 | { | ||
729 | u8 reg; | ||
730 | |||
731 | /* Start monitoring */ | ||
732 | reg = via686a_read_value(client, VIA686A_REG_CONFIG); | ||
733 | via686a_write_value(client, VIA686A_REG_CONFIG, (reg|0x01)&0x7F); | ||
734 | |||
735 | /* Configure temp interrupt mode for continuous-interrupt operation */ | ||
736 | via686a_write_value(client, VIA686A_REG_TEMP_MODE, | ||
737 | via686a_read_value(client, VIA686A_REG_TEMP_MODE) & | ||
738 | !(VIA686A_TEMP_MODE_MASK | VIA686A_TEMP_MODE_CONTINUOUS)); | ||
739 | } | ||
740 | |||
741 | static struct via686a_data *via686a_update_device(struct device *dev) | ||
742 | { | ||
743 | struct i2c_client *client = to_i2c_client(dev); | ||
744 | struct via686a_data *data = i2c_get_clientdata(client); | ||
745 | int i; | ||
746 | |||
747 | down(&data->update_lock); | ||
748 | |||
749 | if (time_after(jiffies, data->last_updated + HZ + HZ / 2) | ||
750 | || !data->valid) { | ||
751 | for (i = 0; i <= 4; i++) { | ||
752 | data->in[i] = | ||
753 | via686a_read_value(client, VIA686A_REG_IN(i)); | ||
754 | data->in_min[i] = via686a_read_value(client, | ||
755 | VIA686A_REG_IN_MIN | ||
756 | (i)); | ||
757 | data->in_max[i] = | ||
758 | via686a_read_value(client, VIA686A_REG_IN_MAX(i)); | ||
759 | } | ||
760 | for (i = 1; i <= 2; i++) { | ||
761 | data->fan[i - 1] = | ||
762 | via686a_read_value(client, VIA686A_REG_FAN(i)); | ||
763 | data->fan_min[i - 1] = via686a_read_value(client, | ||
764 | VIA686A_REG_FAN_MIN(i)); | ||
765 | } | ||
766 | for (i = 0; i <= 2; i++) { | ||
767 | data->temp[i] = via686a_read_value(client, | ||
768 | VIA686A_REG_TEMP(i)) << 2; | ||
769 | data->temp_over[i] = | ||
770 | via686a_read_value(client, | ||
771 | VIA686A_REG_TEMP_OVER(i)); | ||
772 | data->temp_hyst[i] = | ||
773 | via686a_read_value(client, | ||
774 | VIA686A_REG_TEMP_HYST(i)); | ||
775 | } | ||
776 | /* add in lower 2 bits | ||
777 | temp1 uses bits 7-6 of VIA686A_REG_TEMP_LOW1 | ||
778 | temp2 uses bits 5-4 of VIA686A_REG_TEMP_LOW23 | ||
779 | temp3 uses bits 7-6 of VIA686A_REG_TEMP_LOW23 | ||
780 | */ | ||
781 | data->temp[0] |= (via686a_read_value(client, | ||
782 | VIA686A_REG_TEMP_LOW1) | ||
783 | & 0xc0) >> 6; | ||
784 | data->temp[1] |= | ||
785 | (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) & | ||
786 | 0x30) >> 4; | ||
787 | data->temp[2] |= | ||
788 | (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) & | ||
789 | 0xc0) >> 6; | ||
790 | |||
791 | i = via686a_read_value(client, VIA686A_REG_FANDIV); | ||
792 | data->fan_div[0] = (i >> 4) & 0x03; | ||
793 | data->fan_div[1] = i >> 6; | ||
794 | data->alarms = | ||
795 | via686a_read_value(client, | ||
796 | VIA686A_REG_ALARM1) | | ||
797 | (via686a_read_value(client, VIA686A_REG_ALARM2) << 8); | ||
798 | data->last_updated = jiffies; | ||
799 | data->valid = 1; | ||
800 | } | ||
801 | |||
802 | up(&data->update_lock); | ||
803 | |||
804 | return data; | ||
805 | } | ||
806 | |||
807 | static struct pci_device_id via686a_pci_ids[] = { | ||
808 | { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4) }, | ||
809 | { 0, } | ||
810 | }; | ||
811 | |||
812 | MODULE_DEVICE_TABLE(pci, via686a_pci_ids); | ||
813 | |||
814 | static int __devinit via686a_pci_probe(struct pci_dev *dev, | ||
815 | const struct pci_device_id *id) | ||
816 | { | ||
817 | u16 val; | ||
818 | int addr = 0; | ||
819 | |||
820 | if (PCIBIOS_SUCCESSFUL != | ||
821 | pci_read_config_word(dev, VIA686A_BASE_REG, &val)) | ||
822 | return -ENODEV; | ||
823 | |||
824 | addr = val & ~(VIA686A_EXTENT - 1); | ||
825 | if (addr == 0 && force_addr == 0) { | ||
826 | dev_err(&dev->dev,"base address not set - upgrade BIOS or use force_addr=0xaddr\n"); | ||
827 | return -ENODEV; | ||
828 | } | ||
829 | if (force_addr) | ||
830 | addr = force_addr; /* so detect will get called */ | ||
831 | |||
832 | if (!addr) { | ||
833 | dev_err(&dev->dev,"No Via 686A sensors found.\n"); | ||
834 | return -ENODEV; | ||
835 | } | ||
836 | normal_isa[0] = addr; | ||
837 | |||
838 | s_bridge = pci_dev_get(dev); | ||
839 | if (i2c_add_driver(&via686a_driver)) { | ||
840 | pci_dev_put(s_bridge); | ||
841 | s_bridge = NULL; | ||
842 | } | ||
843 | |||
844 | /* Always return failure here. This is to allow other drivers to bind | ||
845 | * to this pci device. We don't really want to have control over the | ||
846 | * pci device, we only wanted to read as few register values from it. | ||
847 | */ | ||
848 | return -ENODEV; | ||
849 | } | ||
850 | |||
851 | static struct pci_driver via686a_pci_driver = { | ||
852 | .name = "via686a", | ||
853 | .id_table = via686a_pci_ids, | ||
854 | .probe = via686a_pci_probe, | ||
855 | }; | ||
856 | |||
857 | static int __init sm_via686a_init(void) | ||
858 | { | ||
859 | return pci_register_driver(&via686a_pci_driver); | ||
860 | } | ||
861 | |||
862 | static void __exit sm_via686a_exit(void) | ||
863 | { | ||
864 | pci_unregister_driver(&via686a_pci_driver); | ||
865 | if (s_bridge != NULL) { | ||
866 | i2c_del_driver(&via686a_driver); | ||
867 | pci_dev_put(s_bridge); | ||
868 | s_bridge = NULL; | ||
869 | } | ||
870 | } | ||
871 | |||
872 | MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>, " | ||
873 | "Mark Studebaker <mdsxyz123@yahoo.com> " | ||
874 | "and Bob Dougherty <bobd@stanford.edu>"); | ||
875 | MODULE_DESCRIPTION("VIA 686A Sensor device"); | ||
876 | MODULE_LICENSE("GPL"); | ||
877 | |||
878 | module_init(sm_via686a_init); | ||
879 | module_exit(sm_via686a_exit); | ||