pcmcia: do not use io_req_t after call to pcmcia_request_io()
[linux-2.6.git] / drivers / hwmon / adm1031.c
1 /*
2   adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
3   monitoring
4   Based on lm75.c and lm85.c
5   Supports adm1030 / adm1031
6   Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
7   Reworked by Jean Delvare <khali@linux-fr.org>
8
9   This program is free software; you can redistribute it and/or modify
10   it under the terms of the GNU General Public License as published by
11   the Free Software Foundation; either version 2 of the License, or
12   (at your option) any later version.
13
14   This program is distributed in the hope that it will be useful,
15   but WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17   GNU General Public License for more details.
18
19   You should have received a copy of the GNU General Public License
20   along with this program; if not, write to the Free Software
21   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <linux/jiffies.h>
28 #include <linux/i2c.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
31 #include <linux/err.h>
32 #include <linux/mutex.h>
33
34 /* Following macros takes channel parameter starting from 0 to 2 */
35 #define ADM1031_REG_FAN_SPEED(nr)       (0x08 + (nr))
36 #define ADM1031_REG_FAN_DIV(nr)         (0x20 + (nr))
37 #define ADM1031_REG_PWM                 (0x22)
38 #define ADM1031_REG_FAN_MIN(nr)         (0x10 + (nr))
39 #define ADM1031_REG_FAN_FILTER          (0x23)
40
41 #define ADM1031_REG_TEMP_OFFSET(nr)     (0x0d + (nr))
42 #define ADM1031_REG_TEMP_MAX(nr)        (0x14 + 4 * (nr))
43 #define ADM1031_REG_TEMP_MIN(nr)        (0x15 + 4 * (nr))
44 #define ADM1031_REG_TEMP_CRIT(nr)       (0x16 + 4 * (nr))
45
46 #define ADM1031_REG_TEMP(nr)            (0x0a + (nr))
47 #define ADM1031_REG_AUTO_TEMP(nr)       (0x24 + (nr))
48
49 #define ADM1031_REG_STATUS(nr)          (0x2 + (nr))
50
51 #define ADM1031_REG_CONF1               0x00
52 #define ADM1031_REG_CONF2               0x01
53 #define ADM1031_REG_EXT_TEMP            0x06
54
55 #define ADM1031_CONF1_MONITOR_ENABLE    0x01    /* Monitoring enable */
56 #define ADM1031_CONF1_PWM_INVERT        0x08    /* PWM Invert */
57 #define ADM1031_CONF1_AUTO_MODE         0x80    /* Auto FAN */
58
59 #define ADM1031_CONF2_PWM1_ENABLE       0x01
60 #define ADM1031_CONF2_PWM2_ENABLE       0x02
61 #define ADM1031_CONF2_TACH1_ENABLE      0x04
62 #define ADM1031_CONF2_TACH2_ENABLE      0x08
63 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
64
65 #define ADM1031_UPDATE_RATE_MASK        0x1c
66 #define ADM1031_UPDATE_RATE_SHIFT       2
67
68 /* Addresses to scan */
69 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
70
71 enum chips { adm1030, adm1031 };
72
73 typedef u8 auto_chan_table_t[8][2];
74
75 /* Each client has this additional data */
76 struct adm1031_data {
77         struct device *hwmon_dev;
78         struct mutex update_lock;
79         int chip_type;
80         char valid;             /* !=0 if following fields are valid */
81         unsigned long last_updated;     /* In jiffies */
82         unsigned int update_rate;       /* In milliseconds */
83         /* The chan_select_table contains the possible configurations for
84          * auto fan control.
85          */
86         const auto_chan_table_t *chan_select_table;
87         u16 alarm;
88         u8 conf1;
89         u8 conf2;
90         u8 fan[2];
91         u8 fan_div[2];
92         u8 fan_min[2];
93         u8 pwm[2];
94         u8 old_pwm[2];
95         s8 temp[3];
96         u8 ext_temp[3];
97         u8 auto_temp[3];
98         u8 auto_temp_min[3];
99         u8 auto_temp_off[3];
100         u8 auto_temp_max[3];
101         s8 temp_offset[3];
102         s8 temp_min[3];
103         s8 temp_max[3];
104         s8 temp_crit[3];
105 };
106
107 static int adm1031_probe(struct i2c_client *client,
108                          const struct i2c_device_id *id);
109 static int adm1031_detect(struct i2c_client *client,
110                           struct i2c_board_info *info);
111 static void adm1031_init_client(struct i2c_client *client);
112 static int adm1031_remove(struct i2c_client *client);
113 static struct adm1031_data *adm1031_update_device(struct device *dev);
114
115 static const struct i2c_device_id adm1031_id[] = {
116         { "adm1030", adm1030 },
117         { "adm1031", adm1031 },
118         { }
119 };
120 MODULE_DEVICE_TABLE(i2c, adm1031_id);
121
122 /* This is the driver that will be inserted */
123 static struct i2c_driver adm1031_driver = {
124         .class          = I2C_CLASS_HWMON,
125         .driver = {
126                 .name = "adm1031",
127         },
128         .probe          = adm1031_probe,
129         .remove         = adm1031_remove,
130         .id_table       = adm1031_id,
131         .detect         = adm1031_detect,
132         .address_list   = normal_i2c,
133 };
134
135 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
136 {
137         return i2c_smbus_read_byte_data(client, reg);
138 }
139
140 static inline int
141 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
142 {
143         return i2c_smbus_write_byte_data(client, reg, value);
144 }
145
146
147 #define TEMP_TO_REG(val)                (((val) < 0 ? ((val - 500) / 1000) : \
148                                         ((val + 500) / 1000)))
149
150 #define TEMP_FROM_REG(val)              ((val) * 1000)
151
152 #define TEMP_FROM_REG_EXT(val, ext)     (TEMP_FROM_REG(val) + (ext) * 125)
153
154 #define TEMP_OFFSET_TO_REG(val)         (TEMP_TO_REG(val) & 0x8f)
155 #define TEMP_OFFSET_FROM_REG(val)       TEMP_FROM_REG((val) < 0 ? \
156                                                       (val) | 0x70 : (val))
157
158 #define FAN_FROM_REG(reg, div)          ((reg) ? (11250 * 60) / ((reg) * (div)) : 0)
159
160 static int FAN_TO_REG(int reg, int div)
161 {
162         int tmp;
163         tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div);
164         return tmp > 255 ? 255 : tmp;
165 }
166
167 #define FAN_DIV_FROM_REG(reg)           (1<<(((reg)&0xc0)>>6))
168
169 #define PWM_TO_REG(val)                 (SENSORS_LIMIT((val), 0, 255) >> 4)
170 #define PWM_FROM_REG(val)               ((val) << 4)
171
172 #define FAN_CHAN_FROM_REG(reg)          (((reg) >> 5) & 7)
173 #define FAN_CHAN_TO_REG(val, reg)       \
174         (((reg) & 0x1F) | (((val) << 5) & 0xe0))
175
176 #define AUTO_TEMP_MIN_TO_REG(val, reg)  \
177         ((((val)/500) & 0xf8)|((reg) & 0x7))
178 #define AUTO_TEMP_RANGE_FROM_REG(reg)   (5000 * (1<< ((reg)&0x7)))
179 #define AUTO_TEMP_MIN_FROM_REG(reg)     (1000 * ((((reg) >> 3) & 0x1f) << 2))
180
181 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
182
183 #define AUTO_TEMP_OFF_FROM_REG(reg)             \
184         (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
185
186 #define AUTO_TEMP_MAX_FROM_REG(reg)             \
187         (AUTO_TEMP_RANGE_FROM_REG(reg) +        \
188         AUTO_TEMP_MIN_FROM_REG(reg))
189
190 static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
191 {
192         int ret;
193         int range = val - AUTO_TEMP_MIN_FROM_REG(reg);
194
195         range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm);
196         ret = ((reg & 0xf8) |
197                (range < 10000 ? 0 :
198                 range < 20000 ? 1 :
199                 range < 40000 ? 2 : range < 80000 ? 3 : 4));
200         return ret;
201 }
202
203 /* FAN auto control */
204 #define GET_FAN_AUTO_BITFIELD(data, idx)        \
205         (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx%2]
206
207 /* The tables below contains the possible values for the auto fan
208  * control bitfields. the index in the table is the register value.
209  * MSb is the auto fan control enable bit, so the four first entries
210  * in the table disables auto fan control when both bitfields are zero.
211  */
212 static const auto_chan_table_t auto_channel_select_table_adm1031 = {
213         { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
214         { 2 /* 0b010 */ , 4 /* 0b100 */ },
215         { 2 /* 0b010 */ , 2 /* 0b010 */ },
216         { 4 /* 0b100 */ , 4 /* 0b100 */ },
217         { 7 /* 0b111 */ , 7 /* 0b111 */ },
218 };
219
220 static const auto_chan_table_t auto_channel_select_table_adm1030 = {
221         { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
222         { 2 /* 0b10 */          , 0 },
223         { 0xff /* invalid */    , 0 },
224         { 0xff /* invalid */    , 0 },
225         { 3 /* 0b11 */          , 0 },
226 };
227
228 /* That function checks if a bitfield is valid and returns the other bitfield
229  * nearest match if no exact match where found.
230  */
231 static int
232 get_fan_auto_nearest(struct adm1031_data *data,
233                      int chan, u8 val, u8 reg, u8 * new_reg)
234 {
235         int i;
236         int first_match = -1, exact_match = -1;
237         u8 other_reg_val =
238             (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
239
240         if (val == 0) {
241                 *new_reg = 0;
242                 return 0;
243         }
244
245         for (i = 0; i < 8; i++) {
246                 if ((val == (*data->chan_select_table)[i][chan]) &&
247                     ((*data->chan_select_table)[i][chan ? 0 : 1] ==
248                      other_reg_val)) {
249                         /* We found an exact match */
250                         exact_match = i;
251                         break;
252                 } else if (val == (*data->chan_select_table)[i][chan] &&
253                            first_match == -1) {
254                         /* Save the first match in case of an exact match has
255                          * not been found
256                          */
257                         first_match = i;
258                 }
259         }
260
261         if (exact_match >= 0) {
262                 *new_reg = exact_match;
263         } else if (first_match >= 0) {
264                 *new_reg = first_match;
265         } else {
266                 return -EINVAL;
267         }
268         return 0;
269 }
270
271 static ssize_t show_fan_auto_channel(struct device *dev,
272                                      struct device_attribute *attr, char *buf)
273 {
274         int nr = to_sensor_dev_attr(attr)->index;
275         struct adm1031_data *data = adm1031_update_device(dev);
276         return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
277 }
278
279 static ssize_t
280 set_fan_auto_channel(struct device *dev, struct device_attribute *attr,
281                      const char *buf, size_t count)
282 {
283         struct i2c_client *client = to_i2c_client(dev);
284         struct adm1031_data *data = i2c_get_clientdata(client);
285         int nr = to_sensor_dev_attr(attr)->index;
286         int val = simple_strtol(buf, NULL, 10);
287         u8 reg;
288         int ret;
289         u8 old_fan_mode;
290
291         old_fan_mode = data->conf1;
292
293         mutex_lock(&data->update_lock);
294
295         if ((ret = get_fan_auto_nearest(data, nr, val, data->conf1, &reg))) {
296                 mutex_unlock(&data->update_lock);
297                 return ret;
298         }
299         data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
300         if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
301             (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
302                 if (data->conf1 & ADM1031_CONF1_AUTO_MODE){
303                         /* Switch to Auto Fan Mode
304                          * Save PWM registers
305                          * Set PWM registers to 33% Both */
306                         data->old_pwm[0] = data->pwm[0];
307                         data->old_pwm[1] = data->pwm[1];
308                         adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
309                 } else {
310                         /* Switch to Manual Mode */
311                         data->pwm[0] = data->old_pwm[0];
312                         data->pwm[1] = data->old_pwm[1];
313                         /* Restore PWM registers */
314                         adm1031_write_value(client, ADM1031_REG_PWM,
315                                             data->pwm[0] | (data->pwm[1] << 4));
316                 }
317         }
318         data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
319         adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
320         mutex_unlock(&data->update_lock);
321         return count;
322 }
323
324 static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR,
325                 show_fan_auto_channel, set_fan_auto_channel, 0);
326 static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR,
327                 show_fan_auto_channel, set_fan_auto_channel, 1);
328
329 /* Auto Temps */
330 static ssize_t show_auto_temp_off(struct device *dev,
331                                   struct device_attribute *attr, char *buf)
332 {
333         int nr = to_sensor_dev_attr(attr)->index;
334         struct adm1031_data *data = adm1031_update_device(dev);
335         return sprintf(buf, "%d\n",
336                        AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
337 }
338 static ssize_t show_auto_temp_min(struct device *dev,
339                                   struct device_attribute *attr, char *buf)
340 {
341         int nr = to_sensor_dev_attr(attr)->index;
342         struct adm1031_data *data = adm1031_update_device(dev);
343         return sprintf(buf, "%d\n",
344                        AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
345 }
346 static ssize_t
347 set_auto_temp_min(struct device *dev, struct device_attribute *attr,
348                   const char *buf, size_t count)
349 {
350         struct i2c_client *client = to_i2c_client(dev);
351         struct adm1031_data *data = i2c_get_clientdata(client);
352         int nr = to_sensor_dev_attr(attr)->index;
353         int val = simple_strtol(buf, NULL, 10);
354
355         mutex_lock(&data->update_lock);
356         data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
357         adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
358                             data->auto_temp[nr]);
359         mutex_unlock(&data->update_lock);
360         return count;
361 }
362 static ssize_t show_auto_temp_max(struct device *dev,
363                                   struct device_attribute *attr, char *buf)
364 {
365         int nr = to_sensor_dev_attr(attr)->index;
366         struct adm1031_data *data = adm1031_update_device(dev);
367         return sprintf(buf, "%d\n",
368                        AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
369 }
370 static ssize_t
371 set_auto_temp_max(struct device *dev, struct device_attribute *attr,
372                   const char *buf, size_t count)
373 {
374         struct i2c_client *client = to_i2c_client(dev);
375         struct adm1031_data *data = i2c_get_clientdata(client);
376         int nr = to_sensor_dev_attr(attr)->index;
377         int val = simple_strtol(buf, NULL, 10);
378
379         mutex_lock(&data->update_lock);
380         data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], data->pwm[nr]);
381         adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
382                             data->temp_max[nr]);
383         mutex_unlock(&data->update_lock);
384         return count;
385 }
386
387 #define auto_temp_reg(offset)                                           \
388 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO,             \
389                 show_auto_temp_off, NULL, offset - 1);                  \
390 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR,   \
391                 show_auto_temp_min, set_auto_temp_min, offset - 1);     \
392 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR,   \
393                 show_auto_temp_max, set_auto_temp_max, offset - 1)
394
395 auto_temp_reg(1);
396 auto_temp_reg(2);
397 auto_temp_reg(3);
398
399 /* pwm */
400 static ssize_t show_pwm(struct device *dev,
401                         struct device_attribute *attr, char *buf)
402 {
403         int nr = to_sensor_dev_attr(attr)->index;
404         struct adm1031_data *data = adm1031_update_device(dev);
405         return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
406 }
407 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
408                        const char *buf, size_t count)
409 {
410         struct i2c_client *client = to_i2c_client(dev);
411         struct adm1031_data *data = i2c_get_clientdata(client);
412         int nr = to_sensor_dev_attr(attr)->index;
413         int val = simple_strtol(buf, NULL, 10);
414         int reg;
415
416         mutex_lock(&data->update_lock);
417         if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
418             (((val>>4) & 0xf) != 5)) {
419                 /* In automatic mode, the only PWM accepted is 33% */
420                 mutex_unlock(&data->update_lock);
421                 return -EINVAL;
422         }
423         data->pwm[nr] = PWM_TO_REG(val);
424         reg = adm1031_read_value(client, ADM1031_REG_PWM);
425         adm1031_write_value(client, ADM1031_REG_PWM,
426                             nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
427                             : (data->pwm[nr] & 0xf) | (reg & 0xf0));
428         mutex_unlock(&data->update_lock);
429         return count;
430 }
431
432 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
433 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
434 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
435                 show_pwm, set_pwm, 0);
436 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR,
437                 show_pwm, set_pwm, 1);
438
439 /* Fans */
440
441 /*
442  * That function checks the cases where the fan reading is not
443  * relevant.  It is used to provide 0 as fan reading when the fan is
444  * not supposed to run
445  */
446 static int trust_fan_readings(struct adm1031_data *data, int chan)
447 {
448         int res = 0;
449
450         if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
451                 switch (data->conf1 & 0x60) {
452                 case 0x00:      /* remote temp1 controls fan1 remote temp2 controls fan2 */
453                         res = data->temp[chan+1] >=
454                               AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
455                         break;
456                 case 0x20:      /* remote temp1 controls both fans */
457                         res =
458                             data->temp[1] >=
459                             AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
460                         break;
461                 case 0x40:      /* remote temp2 controls both fans */
462                         res =
463                             data->temp[2] >=
464                             AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
465                         break;
466                 case 0x60:      /* max controls both fans */
467                         res =
468                             data->temp[0] >=
469                             AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
470                             || data->temp[1] >=
471                             AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
472                             || (data->chip_type == adm1031
473                                 && data->temp[2] >=
474                                 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
475                         break;
476                 }
477         } else {
478                 res = data->pwm[chan] > 0;
479         }
480         return res;
481 }
482
483
484 static ssize_t show_fan(struct device *dev,
485                         struct device_attribute *attr, char *buf)
486 {
487         int nr = to_sensor_dev_attr(attr)->index;
488         struct adm1031_data *data = adm1031_update_device(dev);
489         int value;
490
491         value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
492                                  FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
493         return sprintf(buf, "%d\n", value);
494 }
495
496 static ssize_t show_fan_div(struct device *dev,
497                             struct device_attribute *attr, char *buf)
498 {
499         int nr = to_sensor_dev_attr(attr)->index;
500         struct adm1031_data *data = adm1031_update_device(dev);
501         return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
502 }
503 static ssize_t show_fan_min(struct device *dev,
504                             struct device_attribute *attr, char *buf)
505 {
506         int nr = to_sensor_dev_attr(attr)->index;
507         struct adm1031_data *data = adm1031_update_device(dev);
508         return sprintf(buf, "%d\n",
509                        FAN_FROM_REG(data->fan_min[nr],
510                                     FAN_DIV_FROM_REG(data->fan_div[nr])));
511 }
512 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
513                            const char *buf, size_t count)
514 {
515         struct i2c_client *client = to_i2c_client(dev);
516         struct adm1031_data *data = i2c_get_clientdata(client);
517         int nr = to_sensor_dev_attr(attr)->index;
518         int val = simple_strtol(buf, NULL, 10);
519
520         mutex_lock(&data->update_lock);
521         if (val) {
522                 data->fan_min[nr] =
523                         FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
524         } else {
525                 data->fan_min[nr] = 0xff;
526         }
527         adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
528         mutex_unlock(&data->update_lock);
529         return count;
530 }
531 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
532                            const char *buf, size_t count)
533 {
534         struct i2c_client *client = to_i2c_client(dev);
535         struct adm1031_data *data = i2c_get_clientdata(client);
536         int nr = to_sensor_dev_attr(attr)->index;
537         int val = simple_strtol(buf, NULL, 10);
538         u8 tmp;
539         int old_div;
540         int new_min;
541
542         tmp = val == 8 ? 0xc0 :
543               val == 4 ? 0x80 :
544               val == 2 ? 0x40 :
545               val == 1 ? 0x00 :
546               0xff;
547         if (tmp == 0xff)
548                 return -EINVAL;
549
550         mutex_lock(&data->update_lock);
551         /* Get fresh readings */
552         data->fan_div[nr] = adm1031_read_value(client,
553                                                ADM1031_REG_FAN_DIV(nr));
554         data->fan_min[nr] = adm1031_read_value(client,
555                                                ADM1031_REG_FAN_MIN(nr));
556
557         /* Write the new clock divider and fan min */
558         old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
559         data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
560         new_min = data->fan_min[nr] * old_div / val;
561         data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
562
563         adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
564                             data->fan_div[nr]);
565         adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
566                             data->fan_min[nr]);
567
568         /* Invalidate the cache: fan speed is no longer valid */
569         data->valid = 0;
570         mutex_unlock(&data->update_lock);
571         return count;
572 }
573
574 #define fan_offset(offset)                                              \
575 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                 \
576                 show_fan, NULL, offset - 1);                            \
577 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
578                 show_fan_min, set_fan_min, offset - 1);                 \
579 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
580                 show_fan_div, set_fan_div, offset - 1)
581
582 fan_offset(1);
583 fan_offset(2);
584
585
586 /* Temps */
587 static ssize_t show_temp(struct device *dev,
588                          struct device_attribute *attr, char *buf)
589 {
590         int nr = to_sensor_dev_attr(attr)->index;
591         struct adm1031_data *data = adm1031_update_device(dev);
592         int ext;
593         ext = nr == 0 ?
594             ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
595             (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
596         return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
597 }
598 static ssize_t show_temp_offset(struct device *dev,
599                                 struct device_attribute *attr, char *buf)
600 {
601         int nr = to_sensor_dev_attr(attr)->index;
602         struct adm1031_data *data = adm1031_update_device(dev);
603         return sprintf(buf, "%d\n",
604                        TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
605 }
606 static ssize_t show_temp_min(struct device *dev,
607                              struct device_attribute *attr, char *buf)
608 {
609         int nr = to_sensor_dev_attr(attr)->index;
610         struct adm1031_data *data = adm1031_update_device(dev);
611         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
612 }
613 static ssize_t show_temp_max(struct device *dev,
614                              struct device_attribute *attr, char *buf)
615 {
616         int nr = to_sensor_dev_attr(attr)->index;
617         struct adm1031_data *data = adm1031_update_device(dev);
618         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
619 }
620 static ssize_t show_temp_crit(struct device *dev,
621                               struct device_attribute *attr, char *buf)
622 {
623         int nr = to_sensor_dev_attr(attr)->index;
624         struct adm1031_data *data = adm1031_update_device(dev);
625         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
626 }
627 static ssize_t set_temp_offset(struct device *dev,
628                                struct device_attribute *attr, const char *buf,
629                                size_t count)
630 {
631         struct i2c_client *client = to_i2c_client(dev);
632         struct adm1031_data *data = i2c_get_clientdata(client);
633         int nr = to_sensor_dev_attr(attr)->index;
634         int val;
635
636         val = simple_strtol(buf, NULL, 10);
637         val = SENSORS_LIMIT(val, -15000, 15000);
638         mutex_lock(&data->update_lock);
639         data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
640         adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
641                             data->temp_offset[nr]);
642         mutex_unlock(&data->update_lock);
643         return count;
644 }
645 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
646                             const char *buf, size_t count)
647 {
648         struct i2c_client *client = to_i2c_client(dev);
649         struct adm1031_data *data = i2c_get_clientdata(client);
650         int nr = to_sensor_dev_attr(attr)->index;
651         int val;
652
653         val = simple_strtol(buf, NULL, 10);
654         val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
655         mutex_lock(&data->update_lock);
656         data->temp_min[nr] = TEMP_TO_REG(val);
657         adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
658                             data->temp_min[nr]);
659         mutex_unlock(&data->update_lock);
660         return count;
661 }
662 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
663                             const char *buf, size_t count)
664 {
665         struct i2c_client *client = to_i2c_client(dev);
666         struct adm1031_data *data = i2c_get_clientdata(client);
667         int nr = to_sensor_dev_attr(attr)->index;
668         int val;
669
670         val = simple_strtol(buf, NULL, 10);
671         val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
672         mutex_lock(&data->update_lock);
673         data->temp_max[nr] = TEMP_TO_REG(val);
674         adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
675                             data->temp_max[nr]);
676         mutex_unlock(&data->update_lock);
677         return count;
678 }
679 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
680                              const char *buf, size_t count)
681 {
682         struct i2c_client *client = to_i2c_client(dev);
683         struct adm1031_data *data = i2c_get_clientdata(client);
684         int nr = to_sensor_dev_attr(attr)->index;
685         int val;
686
687         val = simple_strtol(buf, NULL, 10);
688         val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
689         mutex_lock(&data->update_lock);
690         data->temp_crit[nr] = TEMP_TO_REG(val);
691         adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
692                             data->temp_crit[nr]);
693         mutex_unlock(&data->update_lock);
694         return count;
695 }
696
697 #define temp_reg(offset)                                                \
698 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
699                 show_temp, NULL, offset - 1);                           \
700 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR,     \
701                 show_temp_offset, set_temp_offset, offset - 1);         \
702 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR,        \
703                 show_temp_min, set_temp_min, offset - 1);               \
704 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
705                 show_temp_max, set_temp_max, offset - 1);               \
706 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR,       \
707                 show_temp_crit, set_temp_crit, offset - 1)
708
709 temp_reg(1);
710 temp_reg(2);
711 temp_reg(3);
712
713 /* Alarms */
714 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
715 {
716         struct adm1031_data *data = adm1031_update_device(dev);
717         return sprintf(buf, "%d\n", data->alarm);
718 }
719
720 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
721
722 static ssize_t show_alarm(struct device *dev,
723                           struct device_attribute *attr, char *buf)
724 {
725         int bitnr = to_sensor_dev_attr(attr)->index;
726         struct adm1031_data *data = adm1031_update_device(dev);
727         return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
728 }
729
730 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
731 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
732 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
733 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
734 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
735 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
736 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
737 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
738 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
739 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
740 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
741 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
742 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
743 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
744 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
745
746 /* Update Rate */
747 static const unsigned int update_rates[] = {
748         16000, 8000, 4000, 2000, 1000, 500, 250, 125,
749 };
750
751 static ssize_t show_update_rate(struct device *dev,
752                                 struct device_attribute *attr, char *buf)
753 {
754         struct i2c_client *client = to_i2c_client(dev);
755         struct adm1031_data *data = i2c_get_clientdata(client);
756
757         return sprintf(buf, "%u\n", data->update_rate);
758 }
759
760 static ssize_t set_update_rate(struct device *dev,
761                                struct device_attribute *attr,
762                                const char *buf, size_t count)
763 {
764         struct i2c_client *client = to_i2c_client(dev);
765         struct adm1031_data *data = i2c_get_clientdata(client);
766         unsigned long val;
767         int i, err;
768         u8 reg;
769
770         err = strict_strtoul(buf, 10, &val);
771         if (err)
772                 return err;
773
774         /* find the nearest update rate from the table */
775         for (i = 0; i < ARRAY_SIZE(update_rates) - 1; i++) {
776                 if (val >= update_rates[i])
777                         break;
778         }
779         /* if not found, we point to the last entry (lowest update rate) */
780
781         /* set the new update rate while preserving other settings */
782         reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
783         reg &= ~ADM1031_UPDATE_RATE_MASK;
784         reg |= i << ADM1031_UPDATE_RATE_SHIFT;
785         adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
786
787         mutex_lock(&data->update_lock);
788         data->update_rate = update_rates[i];
789         mutex_unlock(&data->update_lock);
790
791         return count;
792 }
793
794 static DEVICE_ATTR(update_rate, S_IRUGO | S_IWUSR, show_update_rate,
795                    set_update_rate);
796
797 static struct attribute *adm1031_attributes[] = {
798         &sensor_dev_attr_fan1_input.dev_attr.attr,
799         &sensor_dev_attr_fan1_div.dev_attr.attr,
800         &sensor_dev_attr_fan1_min.dev_attr.attr,
801         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
802         &sensor_dev_attr_fan1_fault.dev_attr.attr,
803         &sensor_dev_attr_pwm1.dev_attr.attr,
804         &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
805         &sensor_dev_attr_temp1_input.dev_attr.attr,
806         &sensor_dev_attr_temp1_offset.dev_attr.attr,
807         &sensor_dev_attr_temp1_min.dev_attr.attr,
808         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
809         &sensor_dev_attr_temp1_max.dev_attr.attr,
810         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
811         &sensor_dev_attr_temp1_crit.dev_attr.attr,
812         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
813         &sensor_dev_attr_temp2_input.dev_attr.attr,
814         &sensor_dev_attr_temp2_offset.dev_attr.attr,
815         &sensor_dev_attr_temp2_min.dev_attr.attr,
816         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
817         &sensor_dev_attr_temp2_max.dev_attr.attr,
818         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
819         &sensor_dev_attr_temp2_crit.dev_attr.attr,
820         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
821         &sensor_dev_attr_temp2_fault.dev_attr.attr,
822
823         &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
824         &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
825         &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
826
827         &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
828         &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
829         &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
830
831         &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
832
833         &dev_attr_update_rate.attr,
834         &dev_attr_alarms.attr,
835
836         NULL
837 };
838
839 static const struct attribute_group adm1031_group = {
840         .attrs = adm1031_attributes,
841 };
842
843 static struct attribute *adm1031_attributes_opt[] = {
844         &sensor_dev_attr_fan2_input.dev_attr.attr,
845         &sensor_dev_attr_fan2_div.dev_attr.attr,
846         &sensor_dev_attr_fan2_min.dev_attr.attr,
847         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
848         &sensor_dev_attr_fan2_fault.dev_attr.attr,
849         &sensor_dev_attr_pwm2.dev_attr.attr,
850         &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
851         &sensor_dev_attr_temp3_input.dev_attr.attr,
852         &sensor_dev_attr_temp3_offset.dev_attr.attr,
853         &sensor_dev_attr_temp3_min.dev_attr.attr,
854         &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
855         &sensor_dev_attr_temp3_max.dev_attr.attr,
856         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
857         &sensor_dev_attr_temp3_crit.dev_attr.attr,
858         &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
859         &sensor_dev_attr_temp3_fault.dev_attr.attr,
860         &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
861         &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
862         &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
863         &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
864         NULL
865 };
866
867 static const struct attribute_group adm1031_group_opt = {
868         .attrs = adm1031_attributes_opt,
869 };
870
871 /* Return 0 if detection is successful, -ENODEV otherwise */
872 static int adm1031_detect(struct i2c_client *client,
873                           struct i2c_board_info *info)
874 {
875         struct i2c_adapter *adapter = client->adapter;
876         const char *name;
877         int id, co;
878
879         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
880                 return -ENODEV;
881
882         id = i2c_smbus_read_byte_data(client, 0x3d);
883         co = i2c_smbus_read_byte_data(client, 0x3e);
884
885         if (!((id == 0x31 || id == 0x30) && co == 0x41))
886                 return -ENODEV;
887         name = (id == 0x30) ? "adm1030" : "adm1031";
888
889         strlcpy(info->type, name, I2C_NAME_SIZE);
890
891         return 0;
892 }
893
894 static int adm1031_probe(struct i2c_client *client,
895                          const struct i2c_device_id *id)
896 {
897         struct adm1031_data *data;
898         int err;
899
900         data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL);
901         if (!data) {
902                 err = -ENOMEM;
903                 goto exit;
904         }
905
906         i2c_set_clientdata(client, data);
907         data->chip_type = id->driver_data;
908         mutex_init(&data->update_lock);
909
910         if (data->chip_type == adm1030)
911                 data->chan_select_table = &auto_channel_select_table_adm1030;
912         else
913                 data->chan_select_table = &auto_channel_select_table_adm1031;
914
915         /* Initialize the ADM1031 chip */
916         adm1031_init_client(client);
917
918         /* Register sysfs hooks */
919         if ((err = sysfs_create_group(&client->dev.kobj, &adm1031_group)))
920                 goto exit_free;
921
922         if (data->chip_type == adm1031) {
923                 if ((err = sysfs_create_group(&client->dev.kobj,
924                                                 &adm1031_group_opt)))
925                         goto exit_remove;
926         }
927
928         data->hwmon_dev = hwmon_device_register(&client->dev);
929         if (IS_ERR(data->hwmon_dev)) {
930                 err = PTR_ERR(data->hwmon_dev);
931                 goto exit_remove;
932         }
933
934         return 0;
935
936 exit_remove:
937         sysfs_remove_group(&client->dev.kobj, &adm1031_group);
938         sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
939 exit_free:
940         kfree(data);
941 exit:
942         return err;
943 }
944
945 static int adm1031_remove(struct i2c_client *client)
946 {
947         struct adm1031_data *data = i2c_get_clientdata(client);
948
949         hwmon_device_unregister(data->hwmon_dev);
950         sysfs_remove_group(&client->dev.kobj, &adm1031_group);
951         sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
952         kfree(data);
953         return 0;
954 }
955
956 static void adm1031_init_client(struct i2c_client *client)
957 {
958         unsigned int read_val;
959         unsigned int mask;
960         int i;
961         struct adm1031_data *data = i2c_get_clientdata(client);
962
963         mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
964         if (data->chip_type == adm1031) {
965                 mask |= (ADM1031_CONF2_PWM2_ENABLE |
966                         ADM1031_CONF2_TACH2_ENABLE);
967         }
968         /* Initialize the ADM1031 chip (enables fan speed reading ) */
969         read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
970         if ((read_val | mask) != read_val) {
971             adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
972         }
973
974         read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
975         if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
976             adm1031_write_value(client, ADM1031_REG_CONF1, read_val |
977                                 ADM1031_CONF1_MONITOR_ENABLE);
978         }
979
980         /* Read the chip's update rate */
981         mask = ADM1031_UPDATE_RATE_MASK;
982         read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
983         i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
984         data->update_rate = update_rates[i];
985 }
986
987 static struct adm1031_data *adm1031_update_device(struct device *dev)
988 {
989         struct i2c_client *client = to_i2c_client(dev);
990         struct adm1031_data *data = i2c_get_clientdata(client);
991         unsigned long next_update;
992         int chan;
993
994         mutex_lock(&data->update_lock);
995
996         next_update = data->last_updated + msecs_to_jiffies(data->update_rate);
997         if (time_after(jiffies, next_update) || !data->valid) {
998
999                 dev_dbg(&client->dev, "Starting adm1031 update\n");
1000                 for (chan = 0;
1001                      chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
1002                         u8 oldh, newh;
1003
1004                         oldh =
1005                             adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1006                         data->ext_temp[chan] =
1007                             adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
1008                         newh =
1009                             adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1010                         if (newh != oldh) {
1011                                 data->ext_temp[chan] =
1012                                     adm1031_read_value(client,
1013                                                        ADM1031_REG_EXT_TEMP);
1014 #ifdef DEBUG
1015                                 oldh =
1016                                     adm1031_read_value(client,
1017                                                        ADM1031_REG_TEMP(chan));
1018
1019                                 /* oldh is actually newer */
1020                                 if (newh != oldh)
1021                                         dev_warn(&client->dev,
1022                                                  "Remote temperature may be "
1023                                                  "wrong.\n");
1024 #endif
1025                         }
1026                         data->temp[chan] = newh;
1027
1028                         data->temp_offset[chan] =
1029                             adm1031_read_value(client,
1030                                                ADM1031_REG_TEMP_OFFSET(chan));
1031                         data->temp_min[chan] =
1032                             adm1031_read_value(client,
1033                                                ADM1031_REG_TEMP_MIN(chan));
1034                         data->temp_max[chan] =
1035                             adm1031_read_value(client,
1036                                                ADM1031_REG_TEMP_MAX(chan));
1037                         data->temp_crit[chan] =
1038                             adm1031_read_value(client,
1039                                                ADM1031_REG_TEMP_CRIT(chan));
1040                         data->auto_temp[chan] =
1041                             adm1031_read_value(client,
1042                                                ADM1031_REG_AUTO_TEMP(chan));
1043
1044                 }
1045
1046                 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
1047                 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
1048
1049                 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
1050                              | (adm1031_read_value(client, ADM1031_REG_STATUS(1))
1051                                 << 8);
1052                 if (data->chip_type == adm1030) {
1053                         data->alarm &= 0xc0ff;
1054                 }
1055
1056                 for (chan=0; chan<(data->chip_type == adm1030 ? 1 : 2); chan++) {
1057                         data->fan_div[chan] =
1058                             adm1031_read_value(client, ADM1031_REG_FAN_DIV(chan));
1059                         data->fan_min[chan] =
1060                             adm1031_read_value(client, ADM1031_REG_FAN_MIN(chan));
1061                         data->fan[chan] =
1062                             adm1031_read_value(client, ADM1031_REG_FAN_SPEED(chan));
1063                         data->pwm[chan] =
1064                             0xf & (adm1031_read_value(client, ADM1031_REG_PWM) >>
1065                                    (4*chan));
1066                 }
1067                 data->last_updated = jiffies;
1068                 data->valid = 1;
1069         }
1070
1071         mutex_unlock(&data->update_lock);
1072
1073         return data;
1074 }
1075
1076 static int __init sensors_adm1031_init(void)
1077 {
1078         return i2c_add_driver(&adm1031_driver);
1079 }
1080
1081 static void __exit sensors_adm1031_exit(void)
1082 {
1083         i2c_del_driver(&adm1031_driver);
1084 }
1085
1086 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1087 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1088 MODULE_LICENSE("GPL");
1089
1090 module_init(sensors_adm1031_init);
1091 module_exit(sensors_adm1031_exit);