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