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