2 adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
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>
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.
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.
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.
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/i2c-sensor.h>
30 #include <linux/hwmon.h>
31 #include <linux/err.h>
33 /* Following macros takes channel parameter starting from 0 to 2 */
34 #define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr))
35 #define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr))
36 #define ADM1031_REG_PWM (0x22)
37 #define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr))
39 #define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4*(nr))
40 #define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4*(nr))
41 #define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4*(nr))
43 #define ADM1031_REG_TEMP(nr) (0xa + (nr))
44 #define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr))
46 #define ADM1031_REG_STATUS(nr) (0x2 + (nr))
48 #define ADM1031_REG_CONF1 0x0
49 #define ADM1031_REG_CONF2 0x1
50 #define ADM1031_REG_EXT_TEMP 0x6
52 #define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */
53 #define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */
54 #define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */
56 #define ADM1031_CONF2_PWM1_ENABLE 0x01
57 #define ADM1031_CONF2_PWM2_ENABLE 0x02
58 #define ADM1031_CONF2_TACH1_ENABLE 0x04
59 #define ADM1031_CONF2_TACH2_ENABLE 0x08
60 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
62 /* Addresses to scan */
63 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
64 static unsigned int normal_isa[] = { I2C_CLIENT_ISA_END };
66 /* Insmod parameters */
67 SENSORS_INSMOD_2(adm1030, adm1031);
69 typedef u8 auto_chan_table_t[8][2];
71 /* Each client has this additional data */
73 struct i2c_client client;
74 struct class_device *class_dev;
75 struct semaphore update_lock;
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
82 auto_chan_table_t *chan_select_table;
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);
108 /* This is the driver that will be inserted */
109 static struct i2c_driver adm1031_driver = {
110 .owner = THIS_MODULE,
112 .flags = I2C_DF_NOTIFY,
113 .attach_adapter = adm1031_attach_adapter,
114 .detach_client = adm1031_detach_client,
117 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
119 return i2c_smbus_read_byte_data(client, reg);
123 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
125 return i2c_smbus_write_byte_data(client, reg, value);
129 #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
130 ((val + 500) / 1000)))
132 #define TEMP_FROM_REG(val) ((val) * 1000)
134 #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
136 #define FAN_FROM_REG(reg, div) ((reg) ? (11250 * 60) / ((reg) * (div)) : 0)
138 static int FAN_TO_REG(int reg, int div)
141 tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div);
142 return tmp > 255 ? 255 : tmp;
145 #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
147 #define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4)
148 #define PWM_FROM_REG(val) ((val) << 4)
150 #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7)
151 #define FAN_CHAN_TO_REG(val, reg) \
152 (((reg) & 0x1F) | (((val) << 5) & 0xe0))
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))
159 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
161 #define AUTO_TEMP_OFF_FROM_REG(reg) \
162 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
164 #define AUTO_TEMP_MAX_FROM_REG(reg) \
165 (AUTO_TEMP_RANGE_FROM_REG(reg) + \
166 AUTO_TEMP_MIN_FROM_REG(reg))
168 static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
171 int range = val - AUTO_TEMP_MIN_FROM_REG(reg);
173 range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm);
174 ret = ((reg & 0xf8) |
177 range < 40000 ? 2 : range < 80000 ? 3 : 4));
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]
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.
190 static 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 */ },
198 static auto_chan_table_t auto_channel_select_table_adm1030 = {
199 {0, 0}, {0, 0}, {0, 0}, {0, 0},
201 {0xff /*invalid */ , 0},
202 {0xff /*invalid */ , 0},
206 /* That function checks if a bitfield is valid and returns the other bitfield
207 * nearest match if no exact match where found.
210 get_fan_auto_nearest(struct adm1031_data *data,
211 int chan, u8 val, u8 reg, u8 * new_reg)
214 int first_match = -1, exact_match = -1;
216 (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
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] ==
227 /* We found an exact match */
230 } else if (val == (*data->chan_select_table)[i][chan] &&
232 /* Save the first match in case of an exact match has not been
239 if (exact_match >= 0) {
240 *new_reg = exact_match;
241 } else if (first_match >= 0) {
242 *new_reg = first_match;
249 static ssize_t show_fan_auto_channel(struct device *dev, char *buf, int nr)
251 struct adm1031_data *data = adm1031_update_device(dev);
252 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
256 set_fan_auto_channel(struct device *dev, const char *buf, size_t count, int nr)
258 struct i2c_client *client = to_i2c_client(dev);
259 struct adm1031_data *data = i2c_get_clientdata(client);
260 int val = simple_strtol(buf, NULL, 10);
265 old_fan_mode = data->conf1;
267 down(&data->update_lock);
269 if ((ret = get_fan_auto_nearest(data, nr, val, data->conf1, ®))) {
270 up(&data->update_lock);
273 if (((data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1)) & ADM1031_CONF1_AUTO_MODE) ^
274 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
275 if (data->conf1 & ADM1031_CONF1_AUTO_MODE){
276 /* Switch to Auto Fan Mode
278 * Set PWM registers to 33% Both */
279 data->old_pwm[0] = data->pwm[0];
280 data->old_pwm[1] = data->pwm[1];
281 adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
283 /* Switch to Manual Mode */
284 data->pwm[0] = data->old_pwm[0];
285 data->pwm[1] = data->old_pwm[1];
286 /* Restore PWM registers */
287 adm1031_write_value(client, ADM1031_REG_PWM,
288 data->pwm[0] | (data->pwm[1] << 4));
291 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
292 adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
293 up(&data->update_lock);
297 #define fan_auto_channel_offset(offset) \
298 static ssize_t show_fan_auto_channel_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
300 return show_fan_auto_channel(dev, buf, offset - 1); \
302 static ssize_t set_fan_auto_channel_##offset (struct device *dev, struct device_attribute *attr, \
303 const char *buf, size_t count) \
305 return set_fan_auto_channel(dev, buf, count, offset - 1); \
307 static DEVICE_ATTR(auto_fan##offset##_channel, S_IRUGO | S_IWUSR, \
308 show_fan_auto_channel_##offset, \
309 set_fan_auto_channel_##offset)
311 fan_auto_channel_offset(1);
312 fan_auto_channel_offset(2);
315 static ssize_t show_auto_temp_off(struct device *dev, char *buf, int nr)
317 struct adm1031_data *data = adm1031_update_device(dev);
318 return sprintf(buf, "%d\n",
319 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
321 static ssize_t show_auto_temp_min(struct device *dev, char *buf, int nr)
323 struct adm1031_data *data = adm1031_update_device(dev);
324 return sprintf(buf, "%d\n",
325 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
328 set_auto_temp_min(struct device *dev, const char *buf, size_t count, int nr)
330 struct i2c_client *client = to_i2c_client(dev);
331 struct adm1031_data *data = i2c_get_clientdata(client);
332 int val = simple_strtol(buf, NULL, 10);
334 down(&data->update_lock);
335 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
336 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
337 data->auto_temp[nr]);
338 up(&data->update_lock);
341 static ssize_t show_auto_temp_max(struct device *dev, char *buf, int nr)
343 struct adm1031_data *data = adm1031_update_device(dev);
344 return sprintf(buf, "%d\n",
345 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
348 set_auto_temp_max(struct device *dev, const char *buf, size_t count, int nr)
350 struct i2c_client *client = to_i2c_client(dev);
351 struct adm1031_data *data = i2c_get_clientdata(client);
352 int val = simple_strtol(buf, NULL, 10);
354 down(&data->update_lock);
355 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], data->pwm[nr]);
356 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
358 up(&data->update_lock);
362 #define auto_temp_reg(offset) \
363 static ssize_t show_auto_temp_##offset##_off (struct device *dev, struct device_attribute *attr, char *buf) \
365 return show_auto_temp_off(dev, buf, offset - 1); \
367 static ssize_t show_auto_temp_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
369 return show_auto_temp_min(dev, buf, offset - 1); \
371 static ssize_t show_auto_temp_##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \
373 return show_auto_temp_max(dev, buf, offset - 1); \
375 static ssize_t set_auto_temp_##offset##_min (struct device *dev, struct device_attribute *attr, \
376 const char *buf, size_t count) \
378 return set_auto_temp_min(dev, buf, count, offset - 1); \
380 static ssize_t set_auto_temp_##offset##_max (struct device *dev, struct device_attribute *attr, \
381 const char *buf, size_t count) \
383 return set_auto_temp_max(dev, buf, count, offset - 1); \
385 static DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \
386 show_auto_temp_##offset##_off, NULL); \
387 static DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \
388 show_auto_temp_##offset##_min, set_auto_temp_##offset##_min);\
389 static DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \
390 show_auto_temp_##offset##_max, set_auto_temp_##offset##_max)
397 static ssize_t show_pwm(struct device *dev, char *buf, int nr)
399 struct adm1031_data *data = adm1031_update_device(dev);
400 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
403 set_pwm(struct device *dev, const char *buf, size_t count, int nr)
405 struct i2c_client *client = to_i2c_client(dev);
406 struct adm1031_data *data = i2c_get_clientdata(client);
407 int val = simple_strtol(buf, NULL, 10);
410 down(&data->update_lock);
411 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
412 (((val>>4) & 0xf) != 5)) {
413 /* In automatic mode, the only PWM accepted is 33% */
414 up(&data->update_lock);
417 data->pwm[nr] = PWM_TO_REG(val);
418 reg = adm1031_read_value(client, ADM1031_REG_PWM);
419 adm1031_write_value(client, ADM1031_REG_PWM,
420 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
421 : (data->pwm[nr] & 0xf) | (reg & 0xf0));
422 up(&data->update_lock);
426 #define pwm_reg(offset) \
427 static ssize_t show_pwm_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
429 return show_pwm(dev, buf, offset - 1); \
431 static ssize_t set_pwm_##offset (struct device *dev, struct device_attribute *attr, \
432 const char *buf, size_t count) \
434 return set_pwm(dev, buf, count, offset - 1); \
436 static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
437 show_pwm_##offset, set_pwm_##offset)
445 * That function checks the cases where the fan reading is not
446 * relevant. It is used to provide 0 as fan reading when the fan is
447 * not supposed to run
449 static int trust_fan_readings(struct adm1031_data *data, int chan)
453 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
454 switch (data->conf1 & 0x60) {
455 case 0x00: /* remote temp1 controls fan1 remote temp2 controls fan2 */
456 res = data->temp[chan+1] >=
457 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
459 case 0x20: /* remote temp1 controls both fans */
462 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
464 case 0x40: /* remote temp2 controls both fans */
467 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
469 case 0x60: /* max controls both fans */
472 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
474 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
475 || (data->chip_type == adm1031
477 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
481 res = data->pwm[chan] > 0;
487 static ssize_t show_fan(struct device *dev, char *buf, int nr)
489 struct adm1031_data *data = adm1031_update_device(dev);
492 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
493 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
494 return sprintf(buf, "%d\n", value);
497 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
499 struct adm1031_data *data = adm1031_update_device(dev);
500 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
502 static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
504 struct adm1031_data *data = adm1031_update_device(dev);
505 return sprintf(buf, "%d\n",
506 FAN_FROM_REG(data->fan_min[nr],
507 FAN_DIV_FROM_REG(data->fan_div[nr])));
510 set_fan_min(struct device *dev, const char *buf, size_t count, int nr)
512 struct i2c_client *client = to_i2c_client(dev);
513 struct adm1031_data *data = i2c_get_clientdata(client);
514 int val = simple_strtol(buf, NULL, 10);
516 down(&data->update_lock);
519 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
521 data->fan_min[nr] = 0xff;
523 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
524 up(&data->update_lock);
528 set_fan_div(struct device *dev, const char *buf, size_t count, int nr)
530 struct i2c_client *client = to_i2c_client(dev);
531 struct adm1031_data *data = i2c_get_clientdata(client);
532 int val = simple_strtol(buf, NULL, 10);
537 tmp = val == 8 ? 0xc0 :
545 down(&data->update_lock);
546 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
547 data->fan_div[nr] = (tmp & 0xC0) | (0x3f & data->fan_div[nr]);
548 new_min = data->fan_min[nr] * old_div /
549 FAN_DIV_FROM_REG(data->fan_div[nr]);
550 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
551 data->fan[nr] = data->fan[nr] * old_div /
552 FAN_DIV_FROM_REG(data->fan_div[nr]);
554 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
556 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
558 up(&data->update_lock);
562 #define fan_offset(offset) \
563 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
565 return show_fan(dev, buf, offset - 1); \
567 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
569 return show_fan_min(dev, buf, offset - 1); \
571 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \
573 return show_fan_div(dev, buf, offset - 1); \
575 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr, \
576 const char *buf, size_t count) \
578 return set_fan_min(dev, buf, count, offset - 1); \
580 static ssize_t set_fan_##offset##_div (struct device *dev, struct device_attribute *attr, \
581 const char *buf, size_t count) \
583 return set_fan_div(dev, buf, count, offset - 1); \
585 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, \
587 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
588 show_fan_##offset##_min, set_fan_##offset##_min); \
589 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
590 show_fan_##offset##_div, set_fan_##offset##_div); \
591 static DEVICE_ATTR(auto_fan##offset##_min_pwm, S_IRUGO | S_IWUSR, \
592 show_pwm_##offset, set_pwm_##offset)
599 static ssize_t show_temp(struct device *dev, char *buf, int nr)
601 struct adm1031_data *data = adm1031_update_device(dev);
604 ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
605 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
606 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
608 static ssize_t show_temp_min(struct device *dev, char *buf, int nr)
610 struct adm1031_data *data = adm1031_update_device(dev);
611 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
613 static ssize_t show_temp_max(struct device *dev, char *buf, int nr)
615 struct adm1031_data *data = adm1031_update_device(dev);
616 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
618 static ssize_t show_temp_crit(struct device *dev, char *buf, int nr)
620 struct adm1031_data *data = adm1031_update_device(dev);
621 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
624 set_temp_min(struct device *dev, const char *buf, size_t count, int nr)
626 struct i2c_client *client = to_i2c_client(dev);
627 struct adm1031_data *data = i2c_get_clientdata(client);
630 val = simple_strtol(buf, NULL, 10);
631 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
632 down(&data->update_lock);
633 data->temp_min[nr] = TEMP_TO_REG(val);
634 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
636 up(&data->update_lock);
640 set_temp_max(struct device *dev, const char *buf, size_t count, int nr)
642 struct i2c_client *client = to_i2c_client(dev);
643 struct adm1031_data *data = i2c_get_clientdata(client);
646 val = simple_strtol(buf, NULL, 10);
647 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
648 down(&data->update_lock);
649 data->temp_max[nr] = TEMP_TO_REG(val);
650 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
652 up(&data->update_lock);
656 set_temp_crit(struct device *dev, const char *buf, size_t count, int nr)
658 struct i2c_client *client = to_i2c_client(dev);
659 struct adm1031_data *data = i2c_get_clientdata(client);
662 val = simple_strtol(buf, NULL, 10);
663 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
664 down(&data->update_lock);
665 data->temp_crit[nr] = TEMP_TO_REG(val);
666 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
667 data->temp_crit[nr]);
668 up(&data->update_lock);
672 #define temp_reg(offset) \
673 static ssize_t show_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
675 return show_temp(dev, buf, offset - 1); \
677 static ssize_t show_temp_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
679 return show_temp_min(dev, buf, offset - 1); \
681 static ssize_t show_temp_##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \
683 return show_temp_max(dev, buf, offset - 1); \
685 static ssize_t show_temp_##offset##_crit (struct device *dev, struct device_attribute *attr, char *buf) \
687 return show_temp_crit(dev, buf, offset - 1); \
689 static ssize_t set_temp_##offset##_min (struct device *dev, struct device_attribute *attr, \
690 const char *buf, size_t count) \
692 return set_temp_min(dev, buf, count, offset - 1); \
694 static ssize_t set_temp_##offset##_max (struct device *dev, struct device_attribute *attr, \
695 const char *buf, size_t count) \
697 return set_temp_max(dev, buf, count, offset - 1); \
699 static ssize_t set_temp_##offset##_crit (struct device *dev, struct device_attribute *attr, \
700 const char *buf, size_t count) \
702 return set_temp_crit(dev, buf, count, offset - 1); \
704 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp_##offset, \
706 static DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
707 show_temp_##offset##_min, set_temp_##offset##_min); \
708 static DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
709 show_temp_##offset##_max, set_temp_##offset##_max); \
710 static DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \
711 show_temp_##offset##_crit, set_temp_##offset##_crit)
718 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
720 struct adm1031_data *data = adm1031_update_device(dev);
721 return sprintf(buf, "%d\n", data->alarm);
724 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
727 static int adm1031_attach_adapter(struct i2c_adapter *adapter)
729 if (!(adapter->class & I2C_CLASS_HWMON))
731 return i2c_detect(adapter, &addr_data, adm1031_detect);
734 /* This function is called by i2c_detect */
735 static int adm1031_detect(struct i2c_adapter *adapter, int address, int kind)
737 struct i2c_client *new_client;
738 struct adm1031_data *data;
740 const char *name = "";
742 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
745 if (!(data = kmalloc(sizeof(struct adm1031_data), GFP_KERNEL))) {
749 memset(data, 0, sizeof(struct adm1031_data));
751 new_client = &data->client;
752 i2c_set_clientdata(new_client, data);
753 new_client->addr = address;
754 new_client->adapter = adapter;
755 new_client->driver = &adm1031_driver;
756 new_client->flags = 0;
760 id = i2c_smbus_read_byte_data(new_client, 0x3d);
761 co = i2c_smbus_read_byte_data(new_client, 0x3e);
763 if (!((id == 0x31 || id == 0x30) && co == 0x41))
765 kind = (id == 0x30) ? adm1030 : adm1031;
771 /* Given the detected chip type, set the chip name and the
772 * auto fan control helper table. */
773 if (kind == adm1030) {
775 data->chan_select_table = &auto_channel_select_table_adm1030;
776 } else if (kind == adm1031) {
778 data->chan_select_table = &auto_channel_select_table_adm1031;
780 data->chip_type = kind;
782 strlcpy(new_client->name, name, I2C_NAME_SIZE);
784 init_MUTEX(&data->update_lock);
786 /* Tell the I2C layer a new client has arrived */
787 if ((err = i2c_attach_client(new_client)))
790 /* Initialize the ADM1031 chip */
791 adm1031_init_client(new_client);
793 /* Register sysfs hooks */
794 data->class_dev = hwmon_device_register(&new_client->dev);
795 if (IS_ERR(data->class_dev)) {
796 err = PTR_ERR(data->class_dev);
800 device_create_file(&new_client->dev, &dev_attr_fan1_input);
801 device_create_file(&new_client->dev, &dev_attr_fan1_div);
802 device_create_file(&new_client->dev, &dev_attr_fan1_min);
803 device_create_file(&new_client->dev, &dev_attr_pwm1);
804 device_create_file(&new_client->dev, &dev_attr_auto_fan1_channel);
805 device_create_file(&new_client->dev, &dev_attr_temp1_input);
806 device_create_file(&new_client->dev, &dev_attr_temp1_min);
807 device_create_file(&new_client->dev, &dev_attr_temp1_max);
808 device_create_file(&new_client->dev, &dev_attr_temp1_crit);
809 device_create_file(&new_client->dev, &dev_attr_temp2_input);
810 device_create_file(&new_client->dev, &dev_attr_temp2_min);
811 device_create_file(&new_client->dev, &dev_attr_temp2_max);
812 device_create_file(&new_client->dev, &dev_attr_temp2_crit);
814 device_create_file(&new_client->dev, &dev_attr_auto_temp1_off);
815 device_create_file(&new_client->dev, &dev_attr_auto_temp1_min);
816 device_create_file(&new_client->dev, &dev_attr_auto_temp1_max);
818 device_create_file(&new_client->dev, &dev_attr_auto_temp2_off);
819 device_create_file(&new_client->dev, &dev_attr_auto_temp2_min);
820 device_create_file(&new_client->dev, &dev_attr_auto_temp2_max);
822 device_create_file(&new_client->dev, &dev_attr_auto_fan1_min_pwm);
824 device_create_file(&new_client->dev, &dev_attr_alarms);
826 if (kind == adm1031) {
827 device_create_file(&new_client->dev, &dev_attr_fan2_input);
828 device_create_file(&new_client->dev, &dev_attr_fan2_div);
829 device_create_file(&new_client->dev, &dev_attr_fan2_min);
830 device_create_file(&new_client->dev, &dev_attr_pwm2);
831 device_create_file(&new_client->dev,
832 &dev_attr_auto_fan2_channel);
833 device_create_file(&new_client->dev, &dev_attr_temp3_input);
834 device_create_file(&new_client->dev, &dev_attr_temp3_min);
835 device_create_file(&new_client->dev, &dev_attr_temp3_max);
836 device_create_file(&new_client->dev, &dev_attr_temp3_crit);
837 device_create_file(&new_client->dev, &dev_attr_auto_temp3_off);
838 device_create_file(&new_client->dev, &dev_attr_auto_temp3_min);
839 device_create_file(&new_client->dev, &dev_attr_auto_temp3_max);
840 device_create_file(&new_client->dev, &dev_attr_auto_fan2_min_pwm);
846 i2c_detach_client(new_client);
853 static int adm1031_detach_client(struct i2c_client *client)
855 struct adm1031_data *data = i2c_get_clientdata(client);
858 hwmon_device_unregister(data->class_dev);
859 if ((ret = i2c_detach_client(client)) != 0) {
866 static void adm1031_init_client(struct i2c_client *client)
868 unsigned int read_val;
870 struct adm1031_data *data = i2c_get_clientdata(client);
872 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
873 if (data->chip_type == adm1031) {
874 mask |= (ADM1031_CONF2_PWM2_ENABLE |
875 ADM1031_CONF2_TACH2_ENABLE);
877 /* Initialize the ADM1031 chip (enables fan speed reading ) */
878 read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
879 if ((read_val | mask) != read_val) {
880 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
883 read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
884 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
885 adm1031_write_value(client, ADM1031_REG_CONF1, read_val |
886 ADM1031_CONF1_MONITOR_ENABLE);
891 static struct adm1031_data *adm1031_update_device(struct device *dev)
893 struct i2c_client *client = to_i2c_client(dev);
894 struct adm1031_data *data = i2c_get_clientdata(client);
897 down(&data->update_lock);
899 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
902 dev_dbg(&client->dev, "Starting adm1031 update\n");
904 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
908 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
909 data->ext_temp[chan] =
910 adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
912 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
914 data->ext_temp[chan] =
915 adm1031_read_value(client,
916 ADM1031_REG_EXT_TEMP);
919 adm1031_read_value(client,
920 ADM1031_REG_TEMP(chan));
922 /* oldh is actually newer */
924 dev_warn(&client->dev,
925 "Remote temperature may be "
929 data->temp[chan] = newh;
931 data->temp_min[chan] =
932 adm1031_read_value(client,
933 ADM1031_REG_TEMP_MIN(chan));
934 data->temp_max[chan] =
935 adm1031_read_value(client,
936 ADM1031_REG_TEMP_MAX(chan));
937 data->temp_crit[chan] =
938 adm1031_read_value(client,
939 ADM1031_REG_TEMP_CRIT(chan));
940 data->auto_temp[chan] =
941 adm1031_read_value(client,
942 ADM1031_REG_AUTO_TEMP(chan));
946 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
947 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
949 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
950 | (adm1031_read_value(client, ADM1031_REG_STATUS(1))
952 if (data->chip_type == adm1030) {
953 data->alarm &= 0xc0ff;
956 for (chan=0; chan<(data->chip_type == adm1030 ? 1 : 2); chan++) {
957 data->fan_div[chan] =
958 adm1031_read_value(client, ADM1031_REG_FAN_DIV(chan));
959 data->fan_min[chan] =
960 adm1031_read_value(client, ADM1031_REG_FAN_MIN(chan));
962 adm1031_read_value(client, ADM1031_REG_FAN_SPEED(chan));
964 0xf & (adm1031_read_value(client, ADM1031_REG_PWM) >>
967 data->last_updated = jiffies;
971 up(&data->update_lock);
976 static int __init sensors_adm1031_init(void)
978 return i2c_add_driver(&adm1031_driver);
981 static void __exit sensors_adm1031_exit(void)
983 i2c_del_driver(&adm1031_driver);
986 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
987 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
988 MODULE_LICENSE("GPL");
990 module_init(sensors_adm1031_init);
991 module_exit(sensors_adm1031_exit);