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