hwmon: Check for ACPI resource conflicts
[linux-2.6.git] / drivers / hwmon / w83627ehf.c
1 /*
2     w83627ehf - Driver for the hardware monitoring functionality of
3                 the Winbond W83627EHF Super-I/O chip
4     Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
5     Copyright (C) 2006  Yuan Mu (Winbond),
6                         Rudolf Marek <r.marek@assembler.cz>
7                         David Hubbard <david.c.hubbard@gmail.com>
8
9     Shamelessly ripped from the w83627hf driver
10     Copyright (C) 2003  Mark Studebaker
11
12     Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
13     in testing and debugging this driver.
14
15     This driver also supports the W83627EHG, which is the lead-free
16     version of the W83627EHF.
17
18     This program is free software; you can redistribute it and/or modify
19     it under the terms of the GNU General Public License as published by
20     the Free Software Foundation; either version 2 of the License, or
21     (at your option) any later version.
22
23     This program is distributed in the hope that it will be useful,
24     but WITHOUT ANY WARRANTY; without even the implied warranty of
25     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26     GNU General Public License for more details.
27
28     You should have received a copy of the GNU General Public License
29     along with this program; if not, write to the Free Software
30     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31
32
33     Supports the following chips:
34
35     Chip        #vin    #fan    #pwm    #temp  chip IDs       man ID
36     w83627ehf   10      5       4       3      0x8850 0x88    0x5ca3
37                                                0x8860 0xa1
38     w83627dhg    9      5       4       3      0xa020 0xc1    0x5ca3
39 */
40
41 #include <linux/module.h>
42 #include <linux/init.h>
43 #include <linux/slab.h>
44 #include <linux/jiffies.h>
45 #include <linux/platform_device.h>
46 #include <linux/hwmon.h>
47 #include <linux/hwmon-sysfs.h>
48 #include <linux/hwmon-vid.h>
49 #include <linux/err.h>
50 #include <linux/mutex.h>
51 #include <linux/acpi.h>
52 #include <asm/io.h>
53 #include "lm75.h"
54
55 enum kinds { w83627ehf, w83627dhg };
56
57 /* used to set data->name = w83627ehf_device_names[data->sio_kind] */
58 static const char * w83627ehf_device_names[] = {
59         "w83627ehf",
60         "w83627dhg",
61 };
62
63 static unsigned short force_id;
64 module_param(force_id, ushort, 0);
65 MODULE_PARM_DESC(force_id, "Override the detected device ID");
66
67 #define DRVNAME "w83627ehf"
68
69 /*
70  * Super-I/O constants and functions
71  */
72
73 #define W83627EHF_LD_HWM        0x0b
74
75 #define SIO_REG_LDSEL           0x07    /* Logical device select */
76 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
77 #define SIO_REG_EN_VRM10        0x2C    /* GPIO3, GPIO4 selection */
78 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
79 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
80 #define SIO_REG_VID_CTRL        0xF0    /* VID control */
81 #define SIO_REG_VID_DATA        0xF1    /* VID data */
82
83 #define SIO_W83627EHF_ID        0x8850
84 #define SIO_W83627EHG_ID        0x8860
85 #define SIO_W83627DHG_ID        0xa020
86 #define SIO_ID_MASK             0xFFF0
87
88 static inline void
89 superio_outb(int ioreg, int reg, int val)
90 {
91         outb(reg, ioreg);
92         outb(val, ioreg + 1);
93 }
94
95 static inline int
96 superio_inb(int ioreg, int reg)
97 {
98         outb(reg, ioreg);
99         return inb(ioreg + 1);
100 }
101
102 static inline void
103 superio_select(int ioreg, int ld)
104 {
105         outb(SIO_REG_LDSEL, ioreg);
106         outb(ld, ioreg + 1);
107 }
108
109 static inline void
110 superio_enter(int ioreg)
111 {
112         outb(0x87, ioreg);
113         outb(0x87, ioreg);
114 }
115
116 static inline void
117 superio_exit(int ioreg)
118 {
119         outb(0x02, ioreg);
120         outb(0x02, ioreg + 1);
121 }
122
123 /*
124  * ISA constants
125  */
126
127 #define IOREGION_ALIGNMENT      ~7
128 #define IOREGION_OFFSET         5
129 #define IOREGION_LENGTH         2
130 #define ADDR_REG_OFFSET         0
131 #define DATA_REG_OFFSET         1
132
133 #define W83627EHF_REG_BANK              0x4E
134 #define W83627EHF_REG_CONFIG            0x40
135
136 /* Not currently used:
137  * REG_MAN_ID has the value 0x5ca3 for all supported chips.
138  * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
139  * REG_MAN_ID is at port 0x4f
140  * REG_CHIP_ID is at port 0x58 */
141
142 static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 };
143 static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c };
144
145 /* The W83627EHF registers for nr=7,8,9 are in bank 5 */
146 #define W83627EHF_REG_IN_MAX(nr)        ((nr < 7) ? (0x2b + (nr) * 2) : \
147                                          (0x554 + (((nr) - 7) * 2)))
148 #define W83627EHF_REG_IN_MIN(nr)        ((nr < 7) ? (0x2c + (nr) * 2) : \
149                                          (0x555 + (((nr) - 7) * 2)))
150 #define W83627EHF_REG_IN(nr)            ((nr < 7) ? (0x20 + (nr)) : \
151                                          (0x550 + (nr) - 7))
152
153 #define W83627EHF_REG_TEMP1             0x27
154 #define W83627EHF_REG_TEMP1_HYST        0x3a
155 #define W83627EHF_REG_TEMP1_OVER        0x39
156 static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 };
157 static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 };
158 static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 };
159 static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 };
160
161 /* Fan clock dividers are spread over the following five registers */
162 #define W83627EHF_REG_FANDIV1           0x47
163 #define W83627EHF_REG_FANDIV2           0x4B
164 #define W83627EHF_REG_VBAT              0x5D
165 #define W83627EHF_REG_DIODE             0x59
166 #define W83627EHF_REG_SMI_OVT           0x4C
167
168 #define W83627EHF_REG_ALARM1            0x459
169 #define W83627EHF_REG_ALARM2            0x45A
170 #define W83627EHF_REG_ALARM3            0x45B
171
172 /* SmartFan registers */
173 /* DC or PWM output fan configuration */
174 static const u8 W83627EHF_REG_PWM_ENABLE[] = {
175         0x04,                   /* SYS FAN0 output mode and PWM mode */
176         0x04,                   /* CPU FAN0 output mode and PWM mode */
177         0x12,                   /* AUX FAN mode */
178         0x62,                   /* CPU fan1 mode */
179 };
180
181 static const u8 W83627EHF_PWM_MODE_SHIFT[] = { 0, 1, 0, 6 };
182 static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 };
183
184 /* FAN Duty Cycle, be used to control */
185 static const u8 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
186 static const u8 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
187 static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
188
189
190 /* Advanced Fan control, some values are common for all fans */
191 static const u8 W83627EHF_REG_FAN_MIN_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
192 static const u8 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0C, 0x0D, 0x17, 0x66 };
193
194 /*
195  * Conversions
196  */
197
198 /* 1 is PWM mode, output in ms */
199 static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
200 {
201         return mode ? 100 * reg : 400 * reg;
202 }
203
204 static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
205 {
206         return SENSORS_LIMIT((mode ? (msec + 50) / 100 :
207                                                 (msec + 200) / 400), 1, 255);
208 }
209
210 static inline unsigned int
211 fan_from_reg(u8 reg, unsigned int div)
212 {
213         if (reg == 0 || reg == 255)
214                 return 0;
215         return 1350000U / (reg * div);
216 }
217
218 static inline unsigned int
219 div_from_reg(u8 reg)
220 {
221         return 1 << reg;
222 }
223
224 static inline int
225 temp1_from_reg(s8 reg)
226 {
227         return reg * 1000;
228 }
229
230 static inline s8
231 temp1_to_reg(long temp, int min, int max)
232 {
233         if (temp <= min)
234                 return min / 1000;
235         if (temp >= max)
236                 return max / 1000;
237         if (temp < 0)
238                 return (temp - 500) / 1000;
239         return (temp + 500) / 1000;
240 }
241
242 /* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
243
244 static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 };
245
246 static inline long in_from_reg(u8 reg, u8 nr)
247 {
248         return reg * scale_in[nr];
249 }
250
251 static inline u8 in_to_reg(u32 val, u8 nr)
252 {
253         return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0, 255);
254 }
255
256 /*
257  * Data structures and manipulation thereof
258  */
259
260 struct w83627ehf_data {
261         int addr;       /* IO base of hw monitor block */
262         const char *name;
263
264         struct device *hwmon_dev;
265         struct mutex lock;
266
267         struct mutex update_lock;
268         char valid;             /* !=0 if following fields are valid */
269         unsigned long last_updated;     /* In jiffies */
270
271         /* Register values */
272         u8 in_num;              /* number of in inputs we have */
273         u8 in[10];              /* Register value */
274         u8 in_max[10];          /* Register value */
275         u8 in_min[10];          /* Register value */
276         u8 fan[5];
277         u8 fan_min[5];
278         u8 fan_div[5];
279         u8 has_fan;             /* some fan inputs can be disabled */
280         u8 temp_type[3];
281         s8 temp1;
282         s8 temp1_max;
283         s8 temp1_max_hyst;
284         s16 temp[2];
285         s16 temp_max[2];
286         s16 temp_max_hyst[2];
287         u32 alarms;
288
289         u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */
290         u8 pwm_enable[4]; /* 1->manual
291                              2->thermal cruise (also called SmartFan I) */
292         u8 pwm[4];
293         u8 target_temp[4];
294         u8 tolerance[4];
295
296         u8 fan_min_output[4]; /* minimum fan speed */
297         u8 fan_stop_time[4];
298
299         u8 vid;
300         u8 vrm;
301 };
302
303 struct w83627ehf_sio_data {
304         int sioreg;
305         enum kinds kind;
306 };
307
308 static inline int is_word_sized(u16 reg)
309 {
310         return (((reg & 0xff00) == 0x100
311               || (reg & 0xff00) == 0x200)
312              && ((reg & 0x00ff) == 0x50
313               || (reg & 0x00ff) == 0x53
314               || (reg & 0x00ff) == 0x55));
315 }
316
317 /* Registers 0x50-0x5f are banked */
318 static inline void w83627ehf_set_bank(struct w83627ehf_data *data, u16 reg)
319 {
320         if ((reg & 0x00f0) == 0x50) {
321                 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
322                 outb_p(reg >> 8, data->addr + DATA_REG_OFFSET);
323         }
324 }
325
326 /* Not strictly necessary, but play it safe for now */
327 static inline void w83627ehf_reset_bank(struct w83627ehf_data *data, u16 reg)
328 {
329         if (reg & 0xff00) {
330                 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
331                 outb_p(0, data->addr + DATA_REG_OFFSET);
332         }
333 }
334
335 static u16 w83627ehf_read_value(struct w83627ehf_data *data, u16 reg)
336 {
337         int res, word_sized = is_word_sized(reg);
338
339         mutex_lock(&data->lock);
340
341         w83627ehf_set_bank(data, reg);
342         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
343         res = inb_p(data->addr + DATA_REG_OFFSET);
344         if (word_sized) {
345                 outb_p((reg & 0xff) + 1,
346                        data->addr + ADDR_REG_OFFSET);
347                 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
348         }
349         w83627ehf_reset_bank(data, reg);
350
351         mutex_unlock(&data->lock);
352
353         return res;
354 }
355
356 static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg, u16 value)
357 {
358         int word_sized = is_word_sized(reg);
359
360         mutex_lock(&data->lock);
361
362         w83627ehf_set_bank(data, reg);
363         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
364         if (word_sized) {
365                 outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
366                 outb_p((reg & 0xff) + 1,
367                        data->addr + ADDR_REG_OFFSET);
368         }
369         outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
370         w83627ehf_reset_bank(data, reg);
371
372         mutex_unlock(&data->lock);
373         return 0;
374 }
375
376 /* This function assumes that the caller holds data->update_lock */
377 static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr)
378 {
379         u8 reg;
380
381         switch (nr) {
382         case 0:
383                 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0xcf)
384                     | ((data->fan_div[0] & 0x03) << 4);
385                 /* fan5 input control bit is write only, compute the value */
386                 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
387                 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
388                 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xdf)
389                     | ((data->fan_div[0] & 0x04) << 3);
390                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
391                 break;
392         case 1:
393                 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0x3f)
394                     | ((data->fan_div[1] & 0x03) << 6);
395                 /* fan5 input control bit is write only, compute the value */
396                 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
397                 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
398                 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xbf)
399                     | ((data->fan_div[1] & 0x04) << 4);
400                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
401                 break;
402         case 2:
403                 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV2) & 0x3f)
404                     | ((data->fan_div[2] & 0x03) << 6);
405                 w83627ehf_write_value(data, W83627EHF_REG_FANDIV2, reg);
406                 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0x7f)
407                     | ((data->fan_div[2] & 0x04) << 5);
408                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
409                 break;
410         case 3:
411                 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0xfc)
412                     | (data->fan_div[3] & 0x03);
413                 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
414                 reg = (w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT) & 0x7f)
415                     | ((data->fan_div[3] & 0x04) << 5);
416                 w83627ehf_write_value(data, W83627EHF_REG_SMI_OVT, reg);
417                 break;
418         case 4:
419                 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0x73)
420                     | ((data->fan_div[4] & 0x03) << 2)
421                     | ((data->fan_div[4] & 0x04) << 5);
422                 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
423                 break;
424         }
425 }
426
427 static void w83627ehf_update_fan_div(struct w83627ehf_data *data)
428 {
429         int i;
430
431         i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
432         data->fan_div[0] = (i >> 4) & 0x03;
433         data->fan_div[1] = (i >> 6) & 0x03;
434         i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV2);
435         data->fan_div[2] = (i >> 6) & 0x03;
436         i = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
437         data->fan_div[0] |= (i >> 3) & 0x04;
438         data->fan_div[1] |= (i >> 4) & 0x04;
439         data->fan_div[2] |= (i >> 5) & 0x04;
440         if (data->has_fan & ((1 << 3) | (1 << 4))) {
441                 i = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
442                 data->fan_div[3] = i & 0x03;
443                 data->fan_div[4] = ((i >> 2) & 0x03)
444                                  | ((i >> 5) & 0x04);
445         }
446         if (data->has_fan & (1 << 3)) {
447                 i = w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT);
448                 data->fan_div[3] |= (i >> 5) & 0x04;
449         }
450 }
451
452 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
453 {
454         struct w83627ehf_data *data = dev_get_drvdata(dev);
455         int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
456         int i;
457
458         mutex_lock(&data->update_lock);
459
460         if (time_after(jiffies, data->last_updated + HZ + HZ/2)
461          || !data->valid) {
462                 /* Fan clock dividers */
463                 w83627ehf_update_fan_div(data);
464
465                 /* Measured voltages and limits */
466                 for (i = 0; i < data->in_num; i++) {
467                         data->in[i] = w83627ehf_read_value(data,
468                                       W83627EHF_REG_IN(i));
469                         data->in_min[i] = w83627ehf_read_value(data,
470                                           W83627EHF_REG_IN_MIN(i));
471                         data->in_max[i] = w83627ehf_read_value(data,
472                                           W83627EHF_REG_IN_MAX(i));
473                 }
474
475                 /* Measured fan speeds and limits */
476                 for (i = 0; i < 5; i++) {
477                         if (!(data->has_fan & (1 << i)))
478                                 continue;
479
480                         data->fan[i] = w83627ehf_read_value(data,
481                                        W83627EHF_REG_FAN[i]);
482                         data->fan_min[i] = w83627ehf_read_value(data,
483                                            W83627EHF_REG_FAN_MIN[i]);
484
485                         /* If we failed to measure the fan speed and clock
486                            divider can be increased, let's try that for next
487                            time */
488                         if (data->fan[i] == 0xff
489                          && data->fan_div[i] < 0x07) {
490                                 dev_dbg(dev, "Increasing fan%d "
491                                         "clock divider from %u to %u\n",
492                                         i + 1, div_from_reg(data->fan_div[i]),
493                                         div_from_reg(data->fan_div[i] + 1));
494                                 data->fan_div[i]++;
495                                 w83627ehf_write_fan_div(data, i);
496                                 /* Preserve min limit if possible */
497                                 if (data->fan_min[i] >= 2
498                                  && data->fan_min[i] != 255)
499                                         w83627ehf_write_value(data,
500                                                 W83627EHF_REG_FAN_MIN[i],
501                                                 (data->fan_min[i] /= 2));
502                         }
503                 }
504
505                 for (i = 0; i < 4; i++) {
506                         /* pwmcfg, tolarance mapped for i=0, i=1 to same reg */
507                         if (i != 1) {
508                                 pwmcfg = w83627ehf_read_value(data,
509                                                 W83627EHF_REG_PWM_ENABLE[i]);
510                                 tolerance = w83627ehf_read_value(data,
511                                                 W83627EHF_REG_TOLERANCE[i]);
512                         }
513                         data->pwm_mode[i] =
514                                 ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1)
515                                 ? 0 : 1;
516                         data->pwm_enable[i] =
517                                         ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
518                                                 & 3) + 1;
519                         data->pwm[i] = w83627ehf_read_value(data,
520                                                 W83627EHF_REG_PWM[i]);
521                         data->fan_min_output[i] = w83627ehf_read_value(data,
522                                                 W83627EHF_REG_FAN_MIN_OUTPUT[i]);
523                         data->fan_stop_time[i] = w83627ehf_read_value(data,
524                                                 W83627EHF_REG_FAN_STOP_TIME[i]);
525                         data->target_temp[i] =
526                                 w83627ehf_read_value(data,
527                                         W83627EHF_REG_TARGET[i]) &
528                                         (data->pwm_mode[i] == 1 ? 0x7f : 0xff);
529                         data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0))
530                                                                         & 0x0f;
531                 }
532
533                 /* Measured temperatures and limits */
534                 data->temp1 = w83627ehf_read_value(data,
535                               W83627EHF_REG_TEMP1);
536                 data->temp1_max = w83627ehf_read_value(data,
537                                   W83627EHF_REG_TEMP1_OVER);
538                 data->temp1_max_hyst = w83627ehf_read_value(data,
539                                        W83627EHF_REG_TEMP1_HYST);
540                 for (i = 0; i < 2; i++) {
541                         data->temp[i] = w83627ehf_read_value(data,
542                                         W83627EHF_REG_TEMP[i]);
543                         data->temp_max[i] = w83627ehf_read_value(data,
544                                             W83627EHF_REG_TEMP_OVER[i]);
545                         data->temp_max_hyst[i] = w83627ehf_read_value(data,
546                                                  W83627EHF_REG_TEMP_HYST[i]);
547                 }
548
549                 data->alarms = w83627ehf_read_value(data,
550                                         W83627EHF_REG_ALARM1) |
551                                (w83627ehf_read_value(data,
552                                         W83627EHF_REG_ALARM2) << 8) |
553                                (w83627ehf_read_value(data,
554                                         W83627EHF_REG_ALARM3) << 16);
555
556                 data->last_updated = jiffies;
557                 data->valid = 1;
558         }
559
560         mutex_unlock(&data->update_lock);
561         return data;
562 }
563
564 /*
565  * Sysfs callback functions
566  */
567 #define show_in_reg(reg) \
568 static ssize_t \
569 show_##reg(struct device *dev, struct device_attribute *attr, \
570            char *buf) \
571 { \
572         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
573         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
574         int nr = sensor_attr->index; \
575         return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
576 }
577 show_in_reg(in)
578 show_in_reg(in_min)
579 show_in_reg(in_max)
580
581 #define store_in_reg(REG, reg) \
582 static ssize_t \
583 store_in_##reg (struct device *dev, struct device_attribute *attr, \
584                         const char *buf, size_t count) \
585 { \
586         struct w83627ehf_data *data = dev_get_drvdata(dev); \
587         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
588         int nr = sensor_attr->index; \
589         u32 val = simple_strtoul(buf, NULL, 10); \
590  \
591         mutex_lock(&data->update_lock); \
592         data->in_##reg[nr] = in_to_reg(val, nr); \
593         w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \
594                               data->in_##reg[nr]); \
595         mutex_unlock(&data->update_lock); \
596         return count; \
597 }
598
599 store_in_reg(MIN, min)
600 store_in_reg(MAX, max)
601
602 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
603 {
604         struct w83627ehf_data *data = w83627ehf_update_device(dev);
605         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
606         int nr = sensor_attr->index;
607         return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
608 }
609
610 static struct sensor_device_attribute sda_in_input[] = {
611         SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
612         SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
613         SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
614         SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
615         SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
616         SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
617         SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
618         SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
619         SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
620         SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
621 };
622
623 static struct sensor_device_attribute sda_in_alarm[] = {
624         SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
625         SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
626         SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
627         SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
628         SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
629         SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
630         SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
631         SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
632         SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
633         SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
634 };
635
636 static struct sensor_device_attribute sda_in_min[] = {
637        SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
638        SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
639        SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
640        SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
641        SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
642        SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
643        SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
644        SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
645        SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
646        SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
647 };
648
649 static struct sensor_device_attribute sda_in_max[] = {
650        SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
651        SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
652        SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
653        SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
654        SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
655        SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
656        SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
657        SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
658        SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
659        SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
660 };
661
662 #define show_fan_reg(reg) \
663 static ssize_t \
664 show_##reg(struct device *dev, struct device_attribute *attr, \
665            char *buf) \
666 { \
667         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
668         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
669         int nr = sensor_attr->index; \
670         return sprintf(buf, "%d\n", \
671                        fan_from_reg(data->reg[nr], \
672                                     div_from_reg(data->fan_div[nr]))); \
673 }
674 show_fan_reg(fan);
675 show_fan_reg(fan_min);
676
677 static ssize_t
678 show_fan_div(struct device *dev, struct device_attribute *attr,
679              char *buf)
680 {
681         struct w83627ehf_data *data = w83627ehf_update_device(dev);
682         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
683         int nr = sensor_attr->index;
684         return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
685 }
686
687 static ssize_t
688 store_fan_min(struct device *dev, struct device_attribute *attr,
689               const char *buf, size_t count)
690 {
691         struct w83627ehf_data *data = dev_get_drvdata(dev);
692         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
693         int nr = sensor_attr->index;
694         unsigned int val = simple_strtoul(buf, NULL, 10);
695         unsigned int reg;
696         u8 new_div;
697
698         mutex_lock(&data->update_lock);
699         if (!val) {
700                 /* No min limit, alarm disabled */
701                 data->fan_min[nr] = 255;
702                 new_div = data->fan_div[nr]; /* No change */
703                 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
704         } else if ((reg = 1350000U / val) >= 128 * 255) {
705                 /* Speed below this value cannot possibly be represented,
706                    even with the highest divider (128) */
707                 data->fan_min[nr] = 254;
708                 new_div = 7; /* 128 == (1 << 7) */
709                 dev_warn(dev, "fan%u low limit %u below minimum %u, set to "
710                          "minimum\n", nr + 1, val, fan_from_reg(254, 128));
711         } else if (!reg) {
712                 /* Speed above this value cannot possibly be represented,
713                    even with the lowest divider (1) */
714                 data->fan_min[nr] = 1;
715                 new_div = 0; /* 1 == (1 << 0) */
716                 dev_warn(dev, "fan%u low limit %u above maximum %u, set to "
717                          "maximum\n", nr + 1, val, fan_from_reg(1, 1));
718         } else {
719                 /* Automatically pick the best divider, i.e. the one such
720                    that the min limit will correspond to a register value
721                    in the 96..192 range */
722                 new_div = 0;
723                 while (reg > 192 && new_div < 7) {
724                         reg >>= 1;
725                         new_div++;
726                 }
727                 data->fan_min[nr] = reg;
728         }
729
730         /* Write both the fan clock divider (if it changed) and the new
731            fan min (unconditionally) */
732         if (new_div != data->fan_div[nr]) {
733                 /* Preserve the fan speed reading */
734                 if (data->fan[nr] != 0xff) {
735                         if (new_div > data->fan_div[nr])
736                                 data->fan[nr] >>= new_div - data->fan_div[nr];
737                         else if (data->fan[nr] & 0x80)
738                                 data->fan[nr] = 0xff;
739                         else
740                                 data->fan[nr] <<= data->fan_div[nr] - new_div;
741                 }
742
743                 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
744                         nr + 1, div_from_reg(data->fan_div[nr]),
745                         div_from_reg(new_div));
746                 data->fan_div[nr] = new_div;
747                 w83627ehf_write_fan_div(data, nr);
748                 /* Give the chip time to sample a new speed value */
749                 data->last_updated = jiffies;
750         }
751         w83627ehf_write_value(data, W83627EHF_REG_FAN_MIN[nr],
752                               data->fan_min[nr]);
753         mutex_unlock(&data->update_lock);
754
755         return count;
756 }
757
758 static struct sensor_device_attribute sda_fan_input[] = {
759         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
760         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
761         SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
762         SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
763         SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
764 };
765
766 static struct sensor_device_attribute sda_fan_alarm[] = {
767         SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
768         SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
769         SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
770         SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
771         SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
772 };
773
774 static struct sensor_device_attribute sda_fan_min[] = {
775         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
776                     store_fan_min, 0),
777         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
778                     store_fan_min, 1),
779         SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
780                     store_fan_min, 2),
781         SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
782                     store_fan_min, 3),
783         SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
784                     store_fan_min, 4),
785 };
786
787 static struct sensor_device_attribute sda_fan_div[] = {
788         SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
789         SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
790         SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
791         SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
792         SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
793 };
794
795 #define show_temp1_reg(reg) \
796 static ssize_t \
797 show_##reg(struct device *dev, struct device_attribute *attr, \
798            char *buf) \
799 { \
800         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
801         return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \
802 }
803 show_temp1_reg(temp1);
804 show_temp1_reg(temp1_max);
805 show_temp1_reg(temp1_max_hyst);
806
807 #define store_temp1_reg(REG, reg) \
808 static ssize_t \
809 store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
810                   const char *buf, size_t count) \
811 { \
812         struct w83627ehf_data *data = dev_get_drvdata(dev); \
813         long val = simple_strtol(buf, NULL, 10); \
814  \
815         mutex_lock(&data->update_lock); \
816         data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \
817         w83627ehf_write_value(data, W83627EHF_REG_TEMP1_##REG, \
818                               data->temp1_##reg); \
819         mutex_unlock(&data->update_lock); \
820         return count; \
821 }
822 store_temp1_reg(OVER, max);
823 store_temp1_reg(HYST, max_hyst);
824
825 #define show_temp_reg(reg) \
826 static ssize_t \
827 show_##reg(struct device *dev, struct device_attribute *attr, \
828            char *buf) \
829 { \
830         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
831         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
832         int nr = sensor_attr->index; \
833         return sprintf(buf, "%d\n", \
834                        LM75_TEMP_FROM_REG(data->reg[nr])); \
835 }
836 show_temp_reg(temp);
837 show_temp_reg(temp_max);
838 show_temp_reg(temp_max_hyst);
839
840 #define store_temp_reg(REG, reg) \
841 static ssize_t \
842 store_##reg(struct device *dev, struct device_attribute *attr, \
843             const char *buf, size_t count) \
844 { \
845         struct w83627ehf_data *data = dev_get_drvdata(dev); \
846         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
847         int nr = sensor_attr->index; \
848         long val = simple_strtol(buf, NULL, 10); \
849  \
850         mutex_lock(&data->update_lock); \
851         data->reg[nr] = LM75_TEMP_TO_REG(val); \
852         w83627ehf_write_value(data, W83627EHF_REG_TEMP_##REG[nr], \
853                               data->reg[nr]); \
854         mutex_unlock(&data->update_lock); \
855         return count; \
856 }
857 store_temp_reg(OVER, temp_max);
858 store_temp_reg(HYST, temp_max_hyst);
859
860 static ssize_t
861 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
862 {
863         struct w83627ehf_data *data = w83627ehf_update_device(dev);
864         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
865         int nr = sensor_attr->index;
866         return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
867 }
868
869 static struct sensor_device_attribute sda_temp[] = {
870         SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
871         SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
872         SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
873         SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
874                     store_temp1_max, 0),
875         SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
876                     store_temp_max, 0),
877         SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
878                     store_temp_max, 1),
879         SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
880                     store_temp1_max_hyst, 0),
881         SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
882                     store_temp_max_hyst, 0),
883         SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
884                     store_temp_max_hyst, 1),
885         SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
886         SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
887         SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
888         SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
889         SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
890         SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
891 };
892
893 #define show_pwm_reg(reg) \
894 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
895                                 char *buf) \
896 { \
897         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
898         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
899         int nr = sensor_attr->index; \
900         return sprintf(buf, "%d\n", data->reg[nr]); \
901 }
902
903 show_pwm_reg(pwm_mode)
904 show_pwm_reg(pwm_enable)
905 show_pwm_reg(pwm)
906
907 static ssize_t
908 store_pwm_mode(struct device *dev, struct device_attribute *attr,
909                         const char *buf, size_t count)
910 {
911         struct w83627ehf_data *data = dev_get_drvdata(dev);
912         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
913         int nr = sensor_attr->index;
914         u32 val = simple_strtoul(buf, NULL, 10);
915         u16 reg;
916
917         if (val > 1)
918                 return -EINVAL;
919         mutex_lock(&data->update_lock);
920         reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
921         data->pwm_mode[nr] = val;
922         reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
923         if (!val)
924                 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
925         w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
926         mutex_unlock(&data->update_lock);
927         return count;
928 }
929
930 static ssize_t
931 store_pwm(struct device *dev, struct device_attribute *attr,
932                         const char *buf, size_t count)
933 {
934         struct w83627ehf_data *data = dev_get_drvdata(dev);
935         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
936         int nr = sensor_attr->index;
937         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
938
939         mutex_lock(&data->update_lock);
940         data->pwm[nr] = val;
941         w83627ehf_write_value(data, W83627EHF_REG_PWM[nr], val);
942         mutex_unlock(&data->update_lock);
943         return count;
944 }
945
946 static ssize_t
947 store_pwm_enable(struct device *dev, struct device_attribute *attr,
948                         const char *buf, size_t count)
949 {
950         struct w83627ehf_data *data = dev_get_drvdata(dev);
951         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
952         int nr = sensor_attr->index;
953         u32 val = simple_strtoul(buf, NULL, 10);
954         u16 reg;
955
956         if (!val || (val > 2))  /* only modes 1 and 2 are supported */
957                 return -EINVAL;
958         mutex_lock(&data->update_lock);
959         reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
960         data->pwm_enable[nr] = val;
961         reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
962         reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
963         w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
964         mutex_unlock(&data->update_lock);
965         return count;
966 }
967
968
969 #define show_tol_temp(reg) \
970 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
971                                 char *buf) \
972 { \
973         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
974         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
975         int nr = sensor_attr->index; \
976         return sprintf(buf, "%d\n", temp1_from_reg(data->reg[nr])); \
977 }
978
979 show_tol_temp(tolerance)
980 show_tol_temp(target_temp)
981
982 static ssize_t
983 store_target_temp(struct device *dev, struct device_attribute *attr,
984                         const char *buf, size_t count)
985 {
986         struct w83627ehf_data *data = dev_get_drvdata(dev);
987         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
988         int nr = sensor_attr->index;
989         u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000);
990
991         mutex_lock(&data->update_lock);
992         data->target_temp[nr] = val;
993         w83627ehf_write_value(data, W83627EHF_REG_TARGET[nr], val);
994         mutex_unlock(&data->update_lock);
995         return count;
996 }
997
998 static ssize_t
999 store_tolerance(struct device *dev, struct device_attribute *attr,
1000                         const char *buf, size_t count)
1001 {
1002         struct w83627ehf_data *data = dev_get_drvdata(dev);
1003         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1004         int nr = sensor_attr->index;
1005         u16 reg;
1006         /* Limit the temp to 0C - 15C */
1007         u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000);
1008
1009         mutex_lock(&data->update_lock);
1010         reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
1011         data->tolerance[nr] = val;
1012         if (nr == 1)
1013                 reg = (reg & 0x0f) | (val << 4);
1014         else
1015                 reg = (reg & 0xf0) | val;
1016         w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
1017         mutex_unlock(&data->update_lock);
1018         return count;
1019 }
1020
1021 static struct sensor_device_attribute sda_pwm[] = {
1022         SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
1023         SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
1024         SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
1025         SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
1026 };
1027
1028 static struct sensor_device_attribute sda_pwm_mode[] = {
1029         SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1030                     store_pwm_mode, 0),
1031         SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1032                     store_pwm_mode, 1),
1033         SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1034                     store_pwm_mode, 2),
1035         SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1036                     store_pwm_mode, 3),
1037 };
1038
1039 static struct sensor_device_attribute sda_pwm_enable[] = {
1040         SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1041                     store_pwm_enable, 0),
1042         SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1043                     store_pwm_enable, 1),
1044         SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1045                     store_pwm_enable, 2),
1046         SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1047                     store_pwm_enable, 3),
1048 };
1049
1050 static struct sensor_device_attribute sda_target_temp[] = {
1051         SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1052                     store_target_temp, 0),
1053         SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1054                     store_target_temp, 1),
1055         SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1056                     store_target_temp, 2),
1057         SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1058                     store_target_temp, 3),
1059 };
1060
1061 static struct sensor_device_attribute sda_tolerance[] = {
1062         SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1063                     store_tolerance, 0),
1064         SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1065                     store_tolerance, 1),
1066         SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1067                     store_tolerance, 2),
1068         SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1069                     store_tolerance, 3),
1070 };
1071
1072 /* Smart Fan registers */
1073
1074 #define fan_functions(reg, REG) \
1075 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1076                        char *buf) \
1077 { \
1078         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1079         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1080         int nr = sensor_attr->index; \
1081         return sprintf(buf, "%d\n", data->reg[nr]); \
1082 }\
1083 static ssize_t \
1084 store_##reg(struct device *dev, struct device_attribute *attr, \
1085                             const char *buf, size_t count) \
1086 {\
1087         struct w83627ehf_data *data = dev_get_drvdata(dev); \
1088         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1089         int nr = sensor_attr->index; \
1090         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
1091         mutex_lock(&data->update_lock); \
1092         data->reg[nr] = val; \
1093         w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
1094         mutex_unlock(&data->update_lock); \
1095         return count; \
1096 }
1097
1098 fan_functions(fan_min_output, FAN_MIN_OUTPUT)
1099
1100 #define fan_time_functions(reg, REG) \
1101 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1102                                 char *buf) \
1103 { \
1104         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1105         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1106         int nr = sensor_attr->index; \
1107         return sprintf(buf, "%d\n", \
1108                         step_time_from_reg(data->reg[nr], data->pwm_mode[nr])); \
1109 } \
1110 \
1111 static ssize_t \
1112 store_##reg(struct device *dev, struct device_attribute *attr, \
1113                         const char *buf, size_t count) \
1114 { \
1115         struct w83627ehf_data *data = dev_get_drvdata(dev); \
1116         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1117         int nr = sensor_attr->index; \
1118         u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \
1119                                         data->pwm_mode[nr]); \
1120         mutex_lock(&data->update_lock); \
1121         data->reg[nr] = val; \
1122         w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
1123         mutex_unlock(&data->update_lock); \
1124         return count; \
1125 } \
1126
1127 fan_time_functions(fan_stop_time, FAN_STOP_TIME)
1128
1129 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
1130                          char *buf)
1131 {
1132         struct w83627ehf_data *data = dev_get_drvdata(dev);
1133
1134         return sprintf(buf, "%s\n", data->name);
1135 }
1136 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1137
1138 static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
1139         SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1140                     store_fan_stop_time, 3),
1141         SENSOR_ATTR(pwm4_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1142                     store_fan_min_output, 3),
1143 };
1144
1145 static struct sensor_device_attribute sda_sf3_arrays[] = {
1146         SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1147                     store_fan_stop_time, 0),
1148         SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1149                     store_fan_stop_time, 1),
1150         SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1151                     store_fan_stop_time, 2),
1152         SENSOR_ATTR(pwm1_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1153                     store_fan_min_output, 0),
1154         SENSOR_ATTR(pwm2_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1155                     store_fan_min_output, 1),
1156         SENSOR_ATTR(pwm3_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1157                     store_fan_min_output, 2),
1158 };
1159
1160 static ssize_t
1161 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
1162 {
1163         struct w83627ehf_data *data = dev_get_drvdata(dev);
1164         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1165 }
1166 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
1167
1168 /*
1169  * Driver and device management
1170  */
1171
1172 static void w83627ehf_device_remove_files(struct device *dev)
1173 {
1174         /* some entries in the following arrays may not have been used in
1175          * device_create_file(), but device_remove_file() will ignore them */
1176         int i;
1177         struct w83627ehf_data *data = dev_get_drvdata(dev);
1178
1179         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1180                 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
1181         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1182                 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
1183         for (i = 0; i < data->in_num; i++) {
1184                 device_remove_file(dev, &sda_in_input[i].dev_attr);
1185                 device_remove_file(dev, &sda_in_alarm[i].dev_attr);
1186                 device_remove_file(dev, &sda_in_min[i].dev_attr);
1187                 device_remove_file(dev, &sda_in_max[i].dev_attr);
1188         }
1189         for (i = 0; i < 5; i++) {
1190                 device_remove_file(dev, &sda_fan_input[i].dev_attr);
1191                 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
1192                 device_remove_file(dev, &sda_fan_div[i].dev_attr);
1193                 device_remove_file(dev, &sda_fan_min[i].dev_attr);
1194         }
1195         for (i = 0; i < 4; i++) {
1196                 device_remove_file(dev, &sda_pwm[i].dev_attr);
1197                 device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
1198                 device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
1199                 device_remove_file(dev, &sda_target_temp[i].dev_attr);
1200                 device_remove_file(dev, &sda_tolerance[i].dev_attr);
1201         }
1202         for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
1203                 device_remove_file(dev, &sda_temp[i].dev_attr);
1204
1205         device_remove_file(dev, &dev_attr_name);
1206         device_remove_file(dev, &dev_attr_cpu0_vid);
1207 }
1208
1209 /* Get the monitoring functions started */
1210 static inline void __devinit w83627ehf_init_device(struct w83627ehf_data *data)
1211 {
1212         int i;
1213         u8 tmp, diode;
1214
1215         /* Start monitoring is needed */
1216         tmp = w83627ehf_read_value(data, W83627EHF_REG_CONFIG);
1217         if (!(tmp & 0x01))
1218                 w83627ehf_write_value(data, W83627EHF_REG_CONFIG,
1219                                       tmp | 0x01);
1220
1221         /* Enable temp2 and temp3 if needed */
1222         for (i = 0; i < 2; i++) {
1223                 tmp = w83627ehf_read_value(data,
1224                                            W83627EHF_REG_TEMP_CONFIG[i]);
1225                 if (tmp & 0x01)
1226                         w83627ehf_write_value(data,
1227                                               W83627EHF_REG_TEMP_CONFIG[i],
1228                                               tmp & 0xfe);
1229         }
1230
1231         /* Enable VBAT monitoring if needed */
1232         tmp = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
1233         if (!(tmp & 0x01))
1234                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, tmp | 0x01);
1235
1236         /* Get thermal sensor types */
1237         diode = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
1238         for (i = 0; i < 3; i++) {
1239                 if ((tmp & (0x02 << i)))
1240                         data->temp_type[i] = (diode & (0x10 << i)) ? 1 : 2;
1241                 else
1242                         data->temp_type[i] = 4; /* thermistor */
1243         }
1244 }
1245
1246 static int __devinit w83627ehf_probe(struct platform_device *pdev)
1247 {
1248         struct device *dev = &pdev->dev;
1249         struct w83627ehf_sio_data *sio_data = dev->platform_data;
1250         struct w83627ehf_data *data;
1251         struct resource *res;
1252         u8 fan4pin, fan5pin, en_vrm10;
1253         int i, err = 0;
1254
1255         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1256         if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
1257                 err = -EBUSY;
1258                 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1259                         (unsigned long)res->start,
1260                         (unsigned long)res->start + IOREGION_LENGTH - 1);
1261                 goto exit;
1262         }
1263
1264         if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
1265                 err = -ENOMEM;
1266                 goto exit_release;
1267         }
1268
1269         data->addr = res->start;
1270         mutex_init(&data->lock);
1271         mutex_init(&data->update_lock);
1272         data->name = w83627ehf_device_names[sio_data->kind];
1273         platform_set_drvdata(pdev, data);
1274
1275         /* 627EHG and 627EHF have 10 voltage inputs; DHG has 9 */
1276         data->in_num = (sio_data->kind == w83627dhg) ? 9 : 10;
1277
1278         /* Initialize the chip */
1279         w83627ehf_init_device(data);
1280
1281         data->vrm = vid_which_vrm();
1282         superio_enter(sio_data->sioreg);
1283         /* Read VID value */
1284         superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
1285         if (superio_inb(sio_data->sioreg, SIO_REG_VID_CTRL) & 0x80) {
1286                 /* Set VID input sensibility if needed. In theory the BIOS
1287                    should have set it, but in practice it's not always the
1288                    case. We only do it for the W83627EHF/EHG because the
1289                    W83627DHG is more complex in this respect. */
1290                 if (sio_data->kind == w83627ehf) {
1291                         en_vrm10 = superio_inb(sio_data->sioreg,
1292                                                SIO_REG_EN_VRM10);
1293                         if ((en_vrm10 & 0x08) && data->vrm == 90) {
1294                                 dev_warn(dev, "Setting VID input voltage to "
1295                                          "TTL\n");
1296                                 superio_outb(sio_data->sioreg, SIO_REG_EN_VRM10,
1297                                              en_vrm10 & ~0x08);
1298                         } else if (!(en_vrm10 & 0x08) && data->vrm == 100) {
1299                                 dev_warn(dev, "Setting VID input voltage to "
1300                                          "VRM10\n");
1301                                 superio_outb(sio_data->sioreg, SIO_REG_EN_VRM10,
1302                                              en_vrm10 | 0x08);
1303                         }
1304                 }
1305
1306                 data->vid = superio_inb(sio_data->sioreg, SIO_REG_VID_DATA);
1307                 if (sio_data->kind == w83627ehf) /* 6 VID pins only */
1308                         data->vid &= 0x3f;
1309
1310                 err = device_create_file(dev, &dev_attr_cpu0_vid);
1311                 if (err)
1312                         goto exit_release;
1313         } else {
1314                 dev_info(dev, "VID pins in output mode, CPU VID not "
1315                          "available\n");
1316         }
1317
1318         /* fan4 and fan5 share some pins with the GPIO and serial flash */
1319
1320         fan5pin = superio_inb(sio_data->sioreg, 0x24) & 0x2;
1321         fan4pin = superio_inb(sio_data->sioreg, 0x29) & 0x6;
1322         superio_exit(sio_data->sioreg);
1323
1324         /* It looks like fan4 and fan5 pins can be alternatively used
1325            as fan on/off switches, but fan5 control is write only :/
1326            We assume that if the serial interface is disabled, designers
1327            connected fan5 as input unless they are emitting log 1, which
1328            is not the default. */
1329
1330         data->has_fan = 0x07; /* fan1, fan2 and fan3 */
1331         i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
1332         if ((i & (1 << 2)) && (!fan4pin))
1333                 data->has_fan |= (1 << 3);
1334         if (!(i & (1 << 1)) && (!fan5pin))
1335                 data->has_fan |= (1 << 4);
1336
1337         /* Read fan clock dividers immediately */
1338         w83627ehf_update_fan_div(data);
1339
1340         /* Register sysfs hooks */
1341         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1342                 if ((err = device_create_file(dev,
1343                         &sda_sf3_arrays[i].dev_attr)))
1344                         goto exit_remove;
1345
1346         /* if fan4 is enabled create the sf3 files for it */
1347         if (data->has_fan & (1 << 3))
1348                 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
1349                         if ((err = device_create_file(dev,
1350                                 &sda_sf3_arrays_fan4[i].dev_attr)))
1351                                 goto exit_remove;
1352                 }
1353
1354         for (i = 0; i < data->in_num; i++)
1355                 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
1356                         || (err = device_create_file(dev,
1357                                 &sda_in_alarm[i].dev_attr))
1358                         || (err = device_create_file(dev,
1359                                 &sda_in_min[i].dev_attr))
1360                         || (err = device_create_file(dev,
1361                                 &sda_in_max[i].dev_attr)))
1362                         goto exit_remove;
1363
1364         for (i = 0; i < 5; i++) {
1365                 if (data->has_fan & (1 << i)) {
1366                         if ((err = device_create_file(dev,
1367                                         &sda_fan_input[i].dev_attr))
1368                                 || (err = device_create_file(dev,
1369                                         &sda_fan_alarm[i].dev_attr))
1370                                 || (err = device_create_file(dev,
1371                                         &sda_fan_div[i].dev_attr))
1372                                 || (err = device_create_file(dev,
1373                                         &sda_fan_min[i].dev_attr)))
1374                                 goto exit_remove;
1375                         if (i < 4 && /* w83627ehf only has 4 pwm */
1376                                 ((err = device_create_file(dev,
1377                                         &sda_pwm[i].dev_attr))
1378                                 || (err = device_create_file(dev,
1379                                         &sda_pwm_mode[i].dev_attr))
1380                                 || (err = device_create_file(dev,
1381                                         &sda_pwm_enable[i].dev_attr))
1382                                 || (err = device_create_file(dev,
1383                                         &sda_target_temp[i].dev_attr))
1384                                 || (err = device_create_file(dev,
1385                                         &sda_tolerance[i].dev_attr))))
1386                                 goto exit_remove;
1387                 }
1388         }
1389
1390         for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
1391                 if ((err = device_create_file(dev, &sda_temp[i].dev_attr)))
1392                         goto exit_remove;
1393
1394         err = device_create_file(dev, &dev_attr_name);
1395         if (err)
1396                 goto exit_remove;
1397
1398         data->hwmon_dev = hwmon_device_register(dev);
1399         if (IS_ERR(data->hwmon_dev)) {
1400                 err = PTR_ERR(data->hwmon_dev);
1401                 goto exit_remove;
1402         }
1403
1404         return 0;
1405
1406 exit_remove:
1407         w83627ehf_device_remove_files(dev);
1408         kfree(data);
1409         platform_set_drvdata(pdev, NULL);
1410 exit_release:
1411         release_region(res->start, IOREGION_LENGTH);
1412 exit:
1413         return err;
1414 }
1415
1416 static int __devexit w83627ehf_remove(struct platform_device *pdev)
1417 {
1418         struct w83627ehf_data *data = platform_get_drvdata(pdev);
1419
1420         hwmon_device_unregister(data->hwmon_dev);
1421         w83627ehf_device_remove_files(&pdev->dev);
1422         release_region(data->addr, IOREGION_LENGTH);
1423         platform_set_drvdata(pdev, NULL);
1424         kfree(data);
1425
1426         return 0;
1427 }
1428
1429 static struct platform_driver w83627ehf_driver = {
1430         .driver = {
1431                 .owner  = THIS_MODULE,
1432                 .name   = DRVNAME,
1433         },
1434         .probe          = w83627ehf_probe,
1435         .remove         = __devexit_p(w83627ehf_remove),
1436 };
1437
1438 /* w83627ehf_find() looks for a '627 in the Super-I/O config space */
1439 static int __init w83627ehf_find(int sioaddr, unsigned short *addr,
1440                                  struct w83627ehf_sio_data *sio_data)
1441 {
1442         static const char __initdata sio_name_W83627EHF[] = "W83627EHF";
1443         static const char __initdata sio_name_W83627EHG[] = "W83627EHG";
1444         static const char __initdata sio_name_W83627DHG[] = "W83627DHG";
1445
1446         u16 val;
1447         const char *sio_name;
1448
1449         superio_enter(sioaddr);
1450
1451         if (force_id)
1452                 val = force_id;
1453         else
1454                 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1455                     | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1456         switch (val & SIO_ID_MASK) {
1457         case SIO_W83627EHF_ID:
1458                 sio_data->kind = w83627ehf;
1459                 sio_name = sio_name_W83627EHF;
1460                 break;
1461         case SIO_W83627EHG_ID:
1462                 sio_data->kind = w83627ehf;
1463                 sio_name = sio_name_W83627EHG;
1464                 break;
1465         case SIO_W83627DHG_ID:
1466                 sio_data->kind = w83627dhg;
1467                 sio_name = sio_name_W83627DHG;
1468                 break;
1469         default:
1470                 if (val != 0xffff)
1471                         pr_debug(DRVNAME ": unsupported chip ID: 0x%04x\n",
1472                                  val);
1473                 superio_exit(sioaddr);
1474                 return -ENODEV;
1475         }
1476
1477         /* We have a known chip, find the HWM I/O address */
1478         superio_select(sioaddr, W83627EHF_LD_HWM);
1479         val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
1480             | superio_inb(sioaddr, SIO_REG_ADDR + 1);
1481         *addr = val & IOREGION_ALIGNMENT;
1482         if (*addr == 0) {
1483                 printk(KERN_ERR DRVNAME ": Refusing to enable a Super-I/O "
1484                        "device with a base I/O port 0.\n");
1485                 superio_exit(sioaddr);
1486                 return -ENODEV;
1487         }
1488
1489         /* Activate logical device if needed */
1490         val = superio_inb(sioaddr, SIO_REG_ENABLE);
1491         if (!(val & 0x01)) {
1492                 printk(KERN_WARNING DRVNAME ": Forcibly enabling Super-I/O. "
1493                        "Sensor is probably unusable.\n");
1494                 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
1495         }
1496
1497         superio_exit(sioaddr);
1498         pr_info(DRVNAME ": Found %s chip at %#x\n", sio_name, *addr);
1499         sio_data->sioreg = sioaddr;
1500
1501         return 0;
1502 }
1503
1504 /* when Super-I/O functions move to a separate file, the Super-I/O
1505  * bus will manage the lifetime of the device and this module will only keep
1506  * track of the w83627ehf driver. But since we platform_device_alloc(), we
1507  * must keep track of the device */
1508 static struct platform_device *pdev;
1509
1510 static int __init sensors_w83627ehf_init(void)
1511 {
1512         int err;
1513         unsigned short address;
1514         struct resource res;
1515         struct w83627ehf_sio_data sio_data;
1516
1517         /* initialize sio_data->kind and sio_data->sioreg.
1518          *
1519          * when Super-I/O functions move to a separate file, the Super-I/O
1520          * driver will probe 0x2e and 0x4e and auto-detect the presence of a
1521          * w83627ehf hardware monitor, and call probe() */
1522         if (w83627ehf_find(0x2e, &address, &sio_data) &&
1523             w83627ehf_find(0x4e, &address, &sio_data))
1524                 return -ENODEV;
1525
1526         err = platform_driver_register(&w83627ehf_driver);
1527         if (err)
1528                 goto exit;
1529
1530         if (!(pdev = platform_device_alloc(DRVNAME, address))) {
1531                 err = -ENOMEM;
1532                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1533                 goto exit_unregister;
1534         }
1535
1536         err = platform_device_add_data(pdev, &sio_data,
1537                                        sizeof(struct w83627ehf_sio_data));
1538         if (err) {
1539                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1540                 goto exit_device_put;
1541         }
1542
1543         memset(&res, 0, sizeof(res));
1544         res.name = DRVNAME;
1545         res.start = address + IOREGION_OFFSET;
1546         res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1547         res.flags = IORESOURCE_IO;
1548
1549         err = acpi_check_resource_conflict(&res);
1550         if (err)
1551                 goto exit;
1552
1553         err = platform_device_add_resources(pdev, &res, 1);
1554         if (err) {
1555                 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1556                        "(%d)\n", err);
1557                 goto exit_device_put;
1558         }
1559
1560         /* platform_device_add calls probe() */
1561         err = platform_device_add(pdev);
1562         if (err) {
1563                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1564                        err);
1565                 goto exit_device_put;
1566         }
1567
1568         return 0;
1569
1570 exit_device_put:
1571         platform_device_put(pdev);
1572 exit_unregister:
1573         platform_driver_unregister(&w83627ehf_driver);
1574 exit:
1575         return err;
1576 }
1577
1578 static void __exit sensors_w83627ehf_exit(void)
1579 {
1580         platform_device_unregister(pdev);
1581         platform_driver_unregister(&w83627ehf_driver);
1582 }
1583
1584 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1585 MODULE_DESCRIPTION("W83627EHF driver");
1586 MODULE_LICENSE("GPL");
1587
1588 module_init(sensors_w83627ehf_init);
1589 module_exit(sensors_w83627ehf_exit);