hwmon: tegra: tsensor: lp0 save/restore configuration
[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_interval;   /* 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 Interval */
747 static const unsigned int update_intervals[] = {
748         16000, 8000, 4000, 2000, 1000, 500, 250, 125,
749 };
750
751 static ssize_t show_update_interval(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_interval);
758 }
759
760 static ssize_t set_update_interval(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         /*
775          * Find the nearest update interval from the table.
776          * Use it to determine the matching update rate.
777          */
778         for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
779                 if (val >= update_intervals[i])
780                         break;
781         }
782         /* if not found, we point to the last entry (lowest update interval) */
783
784         /* set the new update rate while preserving other settings */
785         reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
786         reg &= ~ADM1031_UPDATE_RATE_MASK;
787         reg |= i << ADM1031_UPDATE_RATE_SHIFT;
788         adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
789
790         mutex_lock(&data->update_lock);
791         data->update_interval = update_intervals[i];
792         mutex_unlock(&data->update_lock);
793
794         return count;
795 }
796
797 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
798                    set_update_interval);
799
800 static struct attribute *adm1031_attributes[] = {
801         &sensor_dev_attr_fan1_input.dev_attr.attr,
802         &sensor_dev_attr_fan1_div.dev_attr.attr,
803         &sensor_dev_attr_fan1_min.dev_attr.attr,
804         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
805         &sensor_dev_attr_fan1_fault.dev_attr.attr,
806         &sensor_dev_attr_pwm1.dev_attr.attr,
807         &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
808         &sensor_dev_attr_temp1_input.dev_attr.attr,
809         &sensor_dev_attr_temp1_offset.dev_attr.attr,
810         &sensor_dev_attr_temp1_min.dev_attr.attr,
811         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
812         &sensor_dev_attr_temp1_max.dev_attr.attr,
813         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
814         &sensor_dev_attr_temp1_crit.dev_attr.attr,
815         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
816         &sensor_dev_attr_temp2_input.dev_attr.attr,
817         &sensor_dev_attr_temp2_offset.dev_attr.attr,
818         &sensor_dev_attr_temp2_min.dev_attr.attr,
819         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
820         &sensor_dev_attr_temp2_max.dev_attr.attr,
821         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
822         &sensor_dev_attr_temp2_crit.dev_attr.attr,
823         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
824         &sensor_dev_attr_temp2_fault.dev_attr.attr,
825
826         &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
827         &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
828         &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
829
830         &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
831         &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
832         &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
833
834         &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
835
836         &dev_attr_update_interval.attr,
837         &dev_attr_alarms.attr,
838
839         NULL
840 };
841
842 static const struct attribute_group adm1031_group = {
843         .attrs = adm1031_attributes,
844 };
845
846 static struct attribute *adm1031_attributes_opt[] = {
847         &sensor_dev_attr_fan2_input.dev_attr.attr,
848         &sensor_dev_attr_fan2_div.dev_attr.attr,
849         &sensor_dev_attr_fan2_min.dev_attr.attr,
850         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
851         &sensor_dev_attr_fan2_fault.dev_attr.attr,
852         &sensor_dev_attr_pwm2.dev_attr.attr,
853         &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
854         &sensor_dev_attr_temp3_input.dev_attr.attr,
855         &sensor_dev_attr_temp3_offset.dev_attr.attr,
856         &sensor_dev_attr_temp3_min.dev_attr.attr,
857         &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
858         &sensor_dev_attr_temp3_max.dev_attr.attr,
859         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
860         &sensor_dev_attr_temp3_crit.dev_attr.attr,
861         &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
862         &sensor_dev_attr_temp3_fault.dev_attr.attr,
863         &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
864         &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
865         &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
866         &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
867         NULL
868 };
869
870 static const struct attribute_group adm1031_group_opt = {
871         .attrs = adm1031_attributes_opt,
872 };
873
874 /* Return 0 if detection is successful, -ENODEV otherwise */
875 static int adm1031_detect(struct i2c_client *client,
876                           struct i2c_board_info *info)
877 {
878         struct i2c_adapter *adapter = client->adapter;
879         const char *name;
880         int id, co;
881
882         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
883                 return -ENODEV;
884
885         id = i2c_smbus_read_byte_data(client, 0x3d);
886         co = i2c_smbus_read_byte_data(client, 0x3e);
887
888         if (!((id == 0x31 || id == 0x30) && co == 0x41))
889                 return -ENODEV;
890         name = (id == 0x30) ? "adm1030" : "adm1031";
891
892         strlcpy(info->type, name, I2C_NAME_SIZE);
893
894         return 0;
895 }
896
897 static int adm1031_probe(struct i2c_client *client,
898                          const struct i2c_device_id *id)
899 {
900         struct adm1031_data *data;
901         int err;
902
903         data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL);
904         if (!data) {
905                 err = -ENOMEM;
906                 goto exit;
907         }
908
909         i2c_set_clientdata(client, data);
910         data->chip_type = id->driver_data;
911         mutex_init(&data->update_lock);
912
913         if (data->chip_type == adm1030)
914                 data->chan_select_table = &auto_channel_select_table_adm1030;
915         else
916                 data->chan_select_table = &auto_channel_select_table_adm1031;
917
918         /* Initialize the ADM1031 chip */
919         adm1031_init_client(client);
920
921         /* Register sysfs hooks */
922         if ((err = sysfs_create_group(&client->dev.kobj, &adm1031_group)))
923                 goto exit_free;
924
925         if (data->chip_type == adm1031) {
926                 if ((err = sysfs_create_group(&client->dev.kobj,
927                                                 &adm1031_group_opt)))
928                         goto exit_remove;
929         }
930
931         data->hwmon_dev = hwmon_device_register(&client->dev);
932         if (IS_ERR(data->hwmon_dev)) {
933                 err = PTR_ERR(data->hwmon_dev);
934                 goto exit_remove;
935         }
936
937         return 0;
938
939 exit_remove:
940         sysfs_remove_group(&client->dev.kobj, &adm1031_group);
941         sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
942 exit_free:
943         kfree(data);
944 exit:
945         return err;
946 }
947
948 static int adm1031_remove(struct i2c_client *client)
949 {
950         struct adm1031_data *data = i2c_get_clientdata(client);
951
952         hwmon_device_unregister(data->hwmon_dev);
953         sysfs_remove_group(&client->dev.kobj, &adm1031_group);
954         sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
955         kfree(data);
956         return 0;
957 }
958
959 static void adm1031_init_client(struct i2c_client *client)
960 {
961         unsigned int read_val;
962         unsigned int mask;
963         int i;
964         struct adm1031_data *data = i2c_get_clientdata(client);
965
966         mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
967         if (data->chip_type == adm1031) {
968                 mask |= (ADM1031_CONF2_PWM2_ENABLE |
969                         ADM1031_CONF2_TACH2_ENABLE);
970         }
971         /* Initialize the ADM1031 chip (enables fan speed reading ) */
972         read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
973         if ((read_val | mask) != read_val) {
974             adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
975         }
976
977         read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
978         if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
979             adm1031_write_value(client, ADM1031_REG_CONF1, read_val |
980                                 ADM1031_CONF1_MONITOR_ENABLE);
981         }
982
983         /* Read the chip's update rate */
984         mask = ADM1031_UPDATE_RATE_MASK;
985         read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
986         i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
987         /* Save it as update interval */
988         data->update_interval = update_intervals[i];
989 }
990
991 static struct adm1031_data *adm1031_update_device(struct device *dev)
992 {
993         struct i2c_client *client = to_i2c_client(dev);
994         struct adm1031_data *data = i2c_get_clientdata(client);
995         unsigned long next_update;
996         int chan;
997
998         mutex_lock(&data->update_lock);
999
1000         next_update = data->last_updated
1001           + msecs_to_jiffies(data->update_interval);
1002         if (time_after(jiffies, next_update) || !data->valid) {
1003
1004                 dev_dbg(&client->dev, "Starting adm1031 update\n");
1005                 for (chan = 0;
1006                      chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
1007                         u8 oldh, newh;
1008
1009                         oldh =
1010                             adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1011                         data->ext_temp[chan] =
1012                             adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
1013                         newh =
1014                             adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1015                         if (newh != oldh) {
1016                                 data->ext_temp[chan] =
1017                                     adm1031_read_value(client,
1018                                                        ADM1031_REG_EXT_TEMP);
1019 #ifdef DEBUG
1020                                 oldh =
1021                                     adm1031_read_value(client,
1022                                                        ADM1031_REG_TEMP(chan));
1023
1024                                 /* oldh is actually newer */
1025                                 if (newh != oldh)
1026                                         dev_warn(&client->dev,
1027                                                  "Remote temperature may be "
1028                                                  "wrong.\n");
1029 #endif
1030                         }
1031                         data->temp[chan] = newh;
1032
1033                         data->temp_offset[chan] =
1034                             adm1031_read_value(client,
1035                                                ADM1031_REG_TEMP_OFFSET(chan));
1036                         data->temp_min[chan] =
1037                             adm1031_read_value(client,
1038                                                ADM1031_REG_TEMP_MIN(chan));
1039                         data->temp_max[chan] =
1040                             adm1031_read_value(client,
1041                                                ADM1031_REG_TEMP_MAX(chan));
1042                         data->temp_crit[chan] =
1043                             adm1031_read_value(client,
1044                                                ADM1031_REG_TEMP_CRIT(chan));
1045                         data->auto_temp[chan] =
1046                             adm1031_read_value(client,
1047                                                ADM1031_REG_AUTO_TEMP(chan));
1048
1049                 }
1050
1051                 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
1052                 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
1053
1054                 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
1055                              | (adm1031_read_value(client, ADM1031_REG_STATUS(1))
1056                                 << 8);
1057                 if (data->chip_type == adm1030) {
1058                         data->alarm &= 0xc0ff;
1059                 }
1060
1061                 for (chan=0; chan<(data->chip_type == adm1030 ? 1 : 2); chan++) {
1062                         data->fan_div[chan] =
1063                             adm1031_read_value(client, ADM1031_REG_FAN_DIV(chan));
1064                         data->fan_min[chan] =
1065                             adm1031_read_value(client, ADM1031_REG_FAN_MIN(chan));
1066                         data->fan[chan] =
1067                             adm1031_read_value(client, ADM1031_REG_FAN_SPEED(chan));
1068                         data->pwm[chan] =
1069                             0xf & (adm1031_read_value(client, ADM1031_REG_PWM) >>
1070                                    (4*chan));
1071                 }
1072                 data->last_updated = jiffies;
1073                 data->valid = 1;
1074         }
1075
1076         mutex_unlock(&data->update_lock);
1077
1078         return data;
1079 }
1080
1081 static int __init sensors_adm1031_init(void)
1082 {
1083         return i2c_add_driver(&adm1031_driver);
1084 }
1085
1086 static void __exit sensors_adm1031_exit(void)
1087 {
1088         i2c_del_driver(&adm1031_driver);
1089 }
1090
1091 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1092 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1093 MODULE_LICENSE("GPL");
1094
1095 module_init(sensors_adm1031_init);
1096 module_exit(sensors_adm1031_exit);