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/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
31 #include <linux/err.h>
32 #include <linux/mutex.h>
34 /* Following macros takes channel parameter starting from 0 to 2 */
35 #define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr))
36 #define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr))
37 #define ADM1031_REG_PWM (0x22)
38 #define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr))
39 #define ADM1031_REG_FAN_FILTER (0x23)
41 #define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr))
42 #define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr))
43 #define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr))
44 #define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr))
46 #define ADM1031_REG_TEMP(nr) (0x0a + (nr))
47 #define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr))
49 #define ADM1031_REG_STATUS(nr) (0x2 + (nr))
51 #define ADM1031_REG_CONF1 0x00
52 #define ADM1031_REG_CONF2 0x01
53 #define ADM1031_REG_EXT_TEMP 0x06
55 #define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */
56 #define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */
57 #define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */
59 #define ADM1031_CONF2_PWM1_ENABLE 0x01
60 #define ADM1031_CONF2_PWM2_ENABLE 0x02
61 #define ADM1031_CONF2_TACH1_ENABLE 0x04
62 #define ADM1031_CONF2_TACH2_ENABLE 0x08
63 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
65 #define ADM1031_UPDATE_RATE_MASK 0x1c
66 #define ADM1031_UPDATE_RATE_SHIFT 2
68 /* Addresses to scan */
69 static const unsigned short normal_i2c
[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END
};
71 enum chips
{ adm1030
, adm1031
};
73 typedef u8 auto_chan_table_t
[8][2];
75 /* Each client has this additional data */
77 struct device
*hwmon_dev
;
78 struct mutex update_lock
;
80 char valid
; /* !=0 if following fields are valid */
81 unsigned long last_updated
; /* In jiffies */
82 unsigned int update_interval
; /* In milliseconds */
84 * The chan_select_table contains the possible configurations for
87 const auto_chan_table_t
*chan_select_table
;
108 static int adm1031_probe(struct i2c_client
*client
,
109 const struct i2c_device_id
*id
);
110 static int adm1031_detect(struct i2c_client
*client
,
111 struct i2c_board_info
*info
);
112 static void adm1031_init_client(struct i2c_client
*client
);
113 static int adm1031_remove(struct i2c_client
*client
);
114 static struct adm1031_data
*adm1031_update_device(struct device
*dev
);
116 static const struct i2c_device_id adm1031_id
[] = {
117 { "adm1030", adm1030
},
118 { "adm1031", adm1031
},
121 MODULE_DEVICE_TABLE(i2c
, adm1031_id
);
123 /* This is the driver that will be inserted */
124 static struct i2c_driver adm1031_driver
= {
125 .class = I2C_CLASS_HWMON
,
129 .probe
= adm1031_probe
,
130 .remove
= adm1031_remove
,
131 .id_table
= adm1031_id
,
132 .detect
= adm1031_detect
,
133 .address_list
= normal_i2c
,
136 static inline u8
adm1031_read_value(struct i2c_client
*client
, u8 reg
)
138 return i2c_smbus_read_byte_data(client
, reg
);
142 adm1031_write_value(struct i2c_client
*client
, u8 reg
, unsigned int value
)
144 return i2c_smbus_write_byte_data(client
, reg
, value
);
148 #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
149 ((val + 500) / 1000)))
151 #define TEMP_FROM_REG(val) ((val) * 1000)
153 #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
155 #define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f)
156 #define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \
157 (val) | 0x70 : (val))
159 #define FAN_FROM_REG(reg, div) ((reg) ? \
160 (11250 * 60) / ((reg) * (div)) : 0)
162 static int FAN_TO_REG(int reg
, int div
)
165 tmp
= FAN_FROM_REG(SENSORS_LIMIT(reg
, 0, 65535), div
);
166 return tmp
> 255 ? 255 : tmp
;
169 #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
171 #define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4)
172 #define PWM_FROM_REG(val) ((val) << 4)
174 #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7)
175 #define FAN_CHAN_TO_REG(val, reg) \
176 (((reg) & 0x1F) | (((val) << 5) & 0xe0))
178 #define AUTO_TEMP_MIN_TO_REG(val, reg) \
179 ((((val) / 500) & 0xf8) | ((reg) & 0x7))
180 #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1 << ((reg) & 0x7)))
181 #define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2))
183 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
185 #define AUTO_TEMP_OFF_FROM_REG(reg) \
186 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
188 #define AUTO_TEMP_MAX_FROM_REG(reg) \
189 (AUTO_TEMP_RANGE_FROM_REG(reg) + \
190 AUTO_TEMP_MIN_FROM_REG(reg))
192 static int AUTO_TEMP_MAX_TO_REG(int val
, int reg
, int pwm
)
195 int range
= val
- AUTO_TEMP_MIN_FROM_REG(reg
);
197 range
= ((val
- AUTO_TEMP_MIN_FROM_REG(reg
))*10)/(16 - pwm
);
198 ret
= ((reg
& 0xf8) |
201 range
< 40000 ? 2 : range
< 80000 ? 3 : 4));
205 /* FAN auto control */
206 #define GET_FAN_AUTO_BITFIELD(data, idx) \
207 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2]
210 * The tables below contains the possible values for the auto fan
211 * control bitfields. the index in the table is the register value.
212 * MSb is the auto fan control enable bit, so the four first entries
213 * in the table disables auto fan control when both bitfields are zero.
215 static const auto_chan_table_t auto_channel_select_table_adm1031
= {
216 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
217 { 2 /* 0b010 */ , 4 /* 0b100 */ },
218 { 2 /* 0b010 */ , 2 /* 0b010 */ },
219 { 4 /* 0b100 */ , 4 /* 0b100 */ },
220 { 7 /* 0b111 */ , 7 /* 0b111 */ },
223 static const auto_chan_table_t auto_channel_select_table_adm1030
= {
224 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
225 { 2 /* 0b10 */ , 0 },
226 { 0xff /* invalid */ , 0 },
227 { 0xff /* invalid */ , 0 },
228 { 3 /* 0b11 */ , 0 },
232 * That function checks if a bitfield is valid and returns the other bitfield
233 * nearest match if no exact match where found.
236 get_fan_auto_nearest(struct adm1031_data
*data
,
237 int chan
, u8 val
, u8 reg
, u8
*new_reg
)
240 int first_match
= -1, exact_match
= -1;
242 (*data
->chan_select_table
)[FAN_CHAN_FROM_REG(reg
)][chan
? 0 : 1];
249 for (i
= 0; i
< 8; i
++) {
250 if ((val
== (*data
->chan_select_table
)[i
][chan
]) &&
251 ((*data
->chan_select_table
)[i
][chan
? 0 : 1] ==
253 /* We found an exact match */
256 } else if (val
== (*data
->chan_select_table
)[i
][chan
] &&
259 * Save the first match in case of an exact match has
266 if (exact_match
>= 0)
267 *new_reg
= exact_match
;
268 else if (first_match
>= 0)
269 *new_reg
= first_match
;
276 static ssize_t
show_fan_auto_channel(struct device
*dev
,
277 struct device_attribute
*attr
, char *buf
)
279 int nr
= to_sensor_dev_attr(attr
)->index
;
280 struct adm1031_data
*data
= adm1031_update_device(dev
);
281 return sprintf(buf
, "%d\n", GET_FAN_AUTO_BITFIELD(data
, nr
));
285 set_fan_auto_channel(struct device
*dev
, struct device_attribute
*attr
,
286 const char *buf
, size_t count
)
288 struct i2c_client
*client
= to_i2c_client(dev
);
289 struct adm1031_data
*data
= i2c_get_clientdata(client
);
290 int nr
= to_sensor_dev_attr(attr
)->index
;
296 ret
= kstrtol(buf
, 10, &val
);
300 old_fan_mode
= data
->conf1
;
302 mutex_lock(&data
->update_lock
);
304 ret
= get_fan_auto_nearest(data
, nr
, val
, data
->conf1
, ®
);
306 mutex_unlock(&data
->update_lock
);
309 data
->conf1
= FAN_CHAN_TO_REG(reg
, data
->conf1
);
310 if ((data
->conf1
& ADM1031_CONF1_AUTO_MODE
) ^
311 (old_fan_mode
& ADM1031_CONF1_AUTO_MODE
)) {
312 if (data
->conf1
& ADM1031_CONF1_AUTO_MODE
) {
314 * Switch to Auto Fan Mode
316 * Set PWM registers to 33% Both
318 data
->old_pwm
[0] = data
->pwm
[0];
319 data
->old_pwm
[1] = data
->pwm
[1];
320 adm1031_write_value(client
, ADM1031_REG_PWM
, 0x55);
322 /* Switch to Manual Mode */
323 data
->pwm
[0] = data
->old_pwm
[0];
324 data
->pwm
[1] = data
->old_pwm
[1];
325 /* Restore PWM registers */
326 adm1031_write_value(client
, ADM1031_REG_PWM
,
327 data
->pwm
[0] | (data
->pwm
[1] << 4));
330 data
->conf1
= FAN_CHAN_TO_REG(reg
, data
->conf1
);
331 adm1031_write_value(client
, ADM1031_REG_CONF1
, data
->conf1
);
332 mutex_unlock(&data
->update_lock
);
336 static SENSOR_DEVICE_ATTR(auto_fan1_channel
, S_IRUGO
| S_IWUSR
,
337 show_fan_auto_channel
, set_fan_auto_channel
, 0);
338 static SENSOR_DEVICE_ATTR(auto_fan2_channel
, S_IRUGO
| S_IWUSR
,
339 show_fan_auto_channel
, set_fan_auto_channel
, 1);
342 static ssize_t
show_auto_temp_off(struct device
*dev
,
343 struct device_attribute
*attr
, char *buf
)
345 int nr
= to_sensor_dev_attr(attr
)->index
;
346 struct adm1031_data
*data
= adm1031_update_device(dev
);
347 return sprintf(buf
, "%d\n",
348 AUTO_TEMP_OFF_FROM_REG(data
->auto_temp
[nr
]));
350 static ssize_t
show_auto_temp_min(struct device
*dev
,
351 struct device_attribute
*attr
, char *buf
)
353 int nr
= to_sensor_dev_attr(attr
)->index
;
354 struct adm1031_data
*data
= adm1031_update_device(dev
);
355 return sprintf(buf
, "%d\n",
356 AUTO_TEMP_MIN_FROM_REG(data
->auto_temp
[nr
]));
359 set_auto_temp_min(struct device
*dev
, struct device_attribute
*attr
,
360 const char *buf
, size_t count
)
362 struct i2c_client
*client
= to_i2c_client(dev
);
363 struct adm1031_data
*data
= i2c_get_clientdata(client
);
364 int nr
= to_sensor_dev_attr(attr
)->index
;
368 ret
= kstrtol(buf
, 10, &val
);
372 mutex_lock(&data
->update_lock
);
373 data
->auto_temp
[nr
] = AUTO_TEMP_MIN_TO_REG(val
, data
->auto_temp
[nr
]);
374 adm1031_write_value(client
, ADM1031_REG_AUTO_TEMP(nr
),
375 data
->auto_temp
[nr
]);
376 mutex_unlock(&data
->update_lock
);
379 static ssize_t
show_auto_temp_max(struct device
*dev
,
380 struct device_attribute
*attr
, char *buf
)
382 int nr
= to_sensor_dev_attr(attr
)->index
;
383 struct adm1031_data
*data
= adm1031_update_device(dev
);
384 return sprintf(buf
, "%d\n",
385 AUTO_TEMP_MAX_FROM_REG(data
->auto_temp
[nr
]));
388 set_auto_temp_max(struct device
*dev
, struct device_attribute
*attr
,
389 const char *buf
, size_t count
)
391 struct i2c_client
*client
= to_i2c_client(dev
);
392 struct adm1031_data
*data
= i2c_get_clientdata(client
);
393 int nr
= to_sensor_dev_attr(attr
)->index
;
397 ret
= kstrtol(buf
, 10, &val
);
401 mutex_lock(&data
->update_lock
);
402 data
->temp_max
[nr
] = AUTO_TEMP_MAX_TO_REG(val
, data
->auto_temp
[nr
],
404 adm1031_write_value(client
, ADM1031_REG_AUTO_TEMP(nr
),
406 mutex_unlock(&data
->update_lock
);
410 #define auto_temp_reg(offset) \
411 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \
412 show_auto_temp_off, NULL, offset - 1); \
413 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \
414 show_auto_temp_min, set_auto_temp_min, offset - 1); \
415 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \
416 show_auto_temp_max, set_auto_temp_max, offset - 1)
423 static ssize_t
show_pwm(struct device
*dev
,
424 struct device_attribute
*attr
, char *buf
)
426 int nr
= to_sensor_dev_attr(attr
)->index
;
427 struct adm1031_data
*data
= adm1031_update_device(dev
);
428 return sprintf(buf
, "%d\n", PWM_FROM_REG(data
->pwm
[nr
]));
430 static ssize_t
set_pwm(struct device
*dev
, struct device_attribute
*attr
,
431 const char *buf
, size_t count
)
433 struct i2c_client
*client
= to_i2c_client(dev
);
434 struct adm1031_data
*data
= i2c_get_clientdata(client
);
435 int nr
= to_sensor_dev_attr(attr
)->index
;
439 ret
= kstrtol(buf
, 10, &val
);
443 mutex_lock(&data
->update_lock
);
444 if ((data
->conf1
& ADM1031_CONF1_AUTO_MODE
) &&
445 (((val
>>4) & 0xf) != 5)) {
446 /* In automatic mode, the only PWM accepted is 33% */
447 mutex_unlock(&data
->update_lock
);
450 data
->pwm
[nr
] = PWM_TO_REG(val
);
451 reg
= adm1031_read_value(client
, ADM1031_REG_PWM
);
452 adm1031_write_value(client
, ADM1031_REG_PWM
,
453 nr
? ((data
->pwm
[nr
] << 4) & 0xf0) | (reg
& 0xf)
454 : (data
->pwm
[nr
] & 0xf) | (reg
& 0xf0));
455 mutex_unlock(&data
->update_lock
);
459 static SENSOR_DEVICE_ATTR(pwm1
, S_IRUGO
| S_IWUSR
, show_pwm
, set_pwm
, 0);
460 static SENSOR_DEVICE_ATTR(pwm2
, S_IRUGO
| S_IWUSR
, show_pwm
, set_pwm
, 1);
461 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm
, S_IRUGO
| S_IWUSR
,
462 show_pwm
, set_pwm
, 0);
463 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm
, S_IRUGO
| S_IWUSR
,
464 show_pwm
, set_pwm
, 1);
469 * That function checks the cases where the fan reading is not
470 * relevant. It is used to provide 0 as fan reading when the fan is
471 * not supposed to run
473 static int trust_fan_readings(struct adm1031_data
*data
, int chan
)
477 if (data
->conf1
& ADM1031_CONF1_AUTO_MODE
) {
478 switch (data
->conf1
& 0x60) {
481 * remote temp1 controls fan1,
482 * remote temp2 controls fan2
484 res
= data
->temp
[chan
+1] >=
485 AUTO_TEMP_MIN_FROM_REG_DEG(data
->auto_temp
[chan
+1]);
487 case 0x20: /* remote temp1 controls both fans */
490 AUTO_TEMP_MIN_FROM_REG_DEG(data
->auto_temp
[1]);
492 case 0x40: /* remote temp2 controls both fans */
495 AUTO_TEMP_MIN_FROM_REG_DEG(data
->auto_temp
[2]);
497 case 0x60: /* max controls both fans */
500 AUTO_TEMP_MIN_FROM_REG_DEG(data
->auto_temp
[0])
502 AUTO_TEMP_MIN_FROM_REG_DEG(data
->auto_temp
[1])
503 || (data
->chip_type
== adm1031
505 AUTO_TEMP_MIN_FROM_REG_DEG(data
->auto_temp
[2]));
509 res
= data
->pwm
[chan
] > 0;
515 static ssize_t
show_fan(struct device
*dev
,
516 struct device_attribute
*attr
, char *buf
)
518 int nr
= to_sensor_dev_attr(attr
)->index
;
519 struct adm1031_data
*data
= adm1031_update_device(dev
);
522 value
= trust_fan_readings(data
, nr
) ? FAN_FROM_REG(data
->fan
[nr
],
523 FAN_DIV_FROM_REG(data
->fan_div
[nr
])) : 0;
524 return sprintf(buf
, "%d\n", value
);
527 static ssize_t
show_fan_div(struct device
*dev
,
528 struct device_attribute
*attr
, char *buf
)
530 int nr
= to_sensor_dev_attr(attr
)->index
;
531 struct adm1031_data
*data
= adm1031_update_device(dev
);
532 return sprintf(buf
, "%d\n", FAN_DIV_FROM_REG(data
->fan_div
[nr
]));
534 static ssize_t
show_fan_min(struct device
*dev
,
535 struct device_attribute
*attr
, char *buf
)
537 int nr
= to_sensor_dev_attr(attr
)->index
;
538 struct adm1031_data
*data
= adm1031_update_device(dev
);
539 return sprintf(buf
, "%d\n",
540 FAN_FROM_REG(data
->fan_min
[nr
],
541 FAN_DIV_FROM_REG(data
->fan_div
[nr
])));
543 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*attr
,
544 const char *buf
, size_t count
)
546 struct i2c_client
*client
= to_i2c_client(dev
);
547 struct adm1031_data
*data
= i2c_get_clientdata(client
);
548 int nr
= to_sensor_dev_attr(attr
)->index
;
552 ret
= kstrtol(buf
, 10, &val
);
556 mutex_lock(&data
->update_lock
);
559 FAN_TO_REG(val
, FAN_DIV_FROM_REG(data
->fan_div
[nr
]));
561 data
->fan_min
[nr
] = 0xff;
563 adm1031_write_value(client
, ADM1031_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
564 mutex_unlock(&data
->update_lock
);
567 static ssize_t
set_fan_div(struct device
*dev
, struct device_attribute
*attr
,
568 const char *buf
, size_t count
)
570 struct i2c_client
*client
= to_i2c_client(dev
);
571 struct adm1031_data
*data
= i2c_get_clientdata(client
);
572 int nr
= to_sensor_dev_attr(attr
)->index
;
579 ret
= kstrtol(buf
, 10, &val
);
583 tmp
= val
== 8 ? 0xc0 :
591 mutex_lock(&data
->update_lock
);
592 /* Get fresh readings */
593 data
->fan_div
[nr
] = adm1031_read_value(client
,
594 ADM1031_REG_FAN_DIV(nr
));
595 data
->fan_min
[nr
] = adm1031_read_value(client
,
596 ADM1031_REG_FAN_MIN(nr
));
598 /* Write the new clock divider and fan min */
599 old_div
= FAN_DIV_FROM_REG(data
->fan_div
[nr
]);
600 data
->fan_div
[nr
] = tmp
| (0x3f & data
->fan_div
[nr
]);
601 new_min
= data
->fan_min
[nr
] * old_div
/ val
;
602 data
->fan_min
[nr
] = new_min
> 0xff ? 0xff : new_min
;
604 adm1031_write_value(client
, ADM1031_REG_FAN_DIV(nr
),
606 adm1031_write_value(client
, ADM1031_REG_FAN_MIN(nr
),
609 /* Invalidate the cache: fan speed is no longer valid */
611 mutex_unlock(&data
->update_lock
);
615 #define fan_offset(offset) \
616 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
617 show_fan, NULL, offset - 1); \
618 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
619 show_fan_min, set_fan_min, offset - 1); \
620 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
621 show_fan_div, set_fan_div, offset - 1)
628 static ssize_t
show_temp(struct device
*dev
,
629 struct device_attribute
*attr
, char *buf
)
631 int nr
= to_sensor_dev_attr(attr
)->index
;
632 struct adm1031_data
*data
= adm1031_update_device(dev
);
635 ((data
->ext_temp
[nr
] >> 6) & 0x3) * 2 :
636 (((data
->ext_temp
[nr
] >> ((nr
- 1) * 3)) & 7));
637 return sprintf(buf
, "%d\n", TEMP_FROM_REG_EXT(data
->temp
[nr
], ext
));
639 static ssize_t
show_temp_offset(struct device
*dev
,
640 struct device_attribute
*attr
, char *buf
)
642 int nr
= to_sensor_dev_attr(attr
)->index
;
643 struct adm1031_data
*data
= adm1031_update_device(dev
);
644 return sprintf(buf
, "%d\n",
645 TEMP_OFFSET_FROM_REG(data
->temp_offset
[nr
]));
647 static ssize_t
show_temp_min(struct device
*dev
,
648 struct device_attribute
*attr
, char *buf
)
650 int nr
= to_sensor_dev_attr(attr
)->index
;
651 struct adm1031_data
*data
= adm1031_update_device(dev
);
652 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_min
[nr
]));
654 static ssize_t
show_temp_max(struct device
*dev
,
655 struct device_attribute
*attr
, char *buf
)
657 int nr
= to_sensor_dev_attr(attr
)->index
;
658 struct adm1031_data
*data
= adm1031_update_device(dev
);
659 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_max
[nr
]));
661 static ssize_t
show_temp_crit(struct device
*dev
,
662 struct device_attribute
*attr
, char *buf
)
664 int nr
= to_sensor_dev_attr(attr
)->index
;
665 struct adm1031_data
*data
= adm1031_update_device(dev
);
666 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_crit
[nr
]));
668 static ssize_t
set_temp_offset(struct device
*dev
,
669 struct device_attribute
*attr
, const char *buf
,
672 struct i2c_client
*client
= to_i2c_client(dev
);
673 struct adm1031_data
*data
= i2c_get_clientdata(client
);
674 int nr
= to_sensor_dev_attr(attr
)->index
;
678 ret
= kstrtol(buf
, 10, &val
);
682 val
= SENSORS_LIMIT(val
, -15000, 15000);
683 mutex_lock(&data
->update_lock
);
684 data
->temp_offset
[nr
] = TEMP_OFFSET_TO_REG(val
);
685 adm1031_write_value(client
, ADM1031_REG_TEMP_OFFSET(nr
),
686 data
->temp_offset
[nr
]);
687 mutex_unlock(&data
->update_lock
);
690 static ssize_t
set_temp_min(struct device
*dev
, struct device_attribute
*attr
,
691 const char *buf
, size_t count
)
693 struct i2c_client
*client
= to_i2c_client(dev
);
694 struct adm1031_data
*data
= i2c_get_clientdata(client
);
695 int nr
= to_sensor_dev_attr(attr
)->index
;
699 ret
= kstrtol(buf
, 10, &val
);
703 val
= SENSORS_LIMIT(val
, -55000, nr
== 0 ? 127750 : 127875);
704 mutex_lock(&data
->update_lock
);
705 data
->temp_min
[nr
] = TEMP_TO_REG(val
);
706 adm1031_write_value(client
, ADM1031_REG_TEMP_MIN(nr
),
708 mutex_unlock(&data
->update_lock
);
711 static ssize_t
set_temp_max(struct device
*dev
, struct device_attribute
*attr
,
712 const char *buf
, size_t count
)
714 struct i2c_client
*client
= to_i2c_client(dev
);
715 struct adm1031_data
*data
= i2c_get_clientdata(client
);
716 int nr
= to_sensor_dev_attr(attr
)->index
;
720 ret
= kstrtol(buf
, 10, &val
);
724 val
= SENSORS_LIMIT(val
, -55000, nr
== 0 ? 127750 : 127875);
725 mutex_lock(&data
->update_lock
);
726 data
->temp_max
[nr
] = TEMP_TO_REG(val
);
727 adm1031_write_value(client
, ADM1031_REG_TEMP_MAX(nr
),
729 mutex_unlock(&data
->update_lock
);
732 static ssize_t
set_temp_crit(struct device
*dev
, struct device_attribute
*attr
,
733 const char *buf
, size_t count
)
735 struct i2c_client
*client
= to_i2c_client(dev
);
736 struct adm1031_data
*data
= i2c_get_clientdata(client
);
737 int nr
= to_sensor_dev_attr(attr
)->index
;
741 ret
= kstrtol(buf
, 10, &val
);
745 val
= SENSORS_LIMIT(val
, -55000, nr
== 0 ? 127750 : 127875);
746 mutex_lock(&data
->update_lock
);
747 data
->temp_crit
[nr
] = TEMP_TO_REG(val
);
748 adm1031_write_value(client
, ADM1031_REG_TEMP_CRIT(nr
),
749 data
->temp_crit
[nr
]);
750 mutex_unlock(&data
->update_lock
);
754 #define temp_reg(offset) \
755 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
756 show_temp, NULL, offset - 1); \
757 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \
758 show_temp_offset, set_temp_offset, offset - 1); \
759 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
760 show_temp_min, set_temp_min, offset - 1); \
761 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
762 show_temp_max, set_temp_max, offset - 1); \
763 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \
764 show_temp_crit, set_temp_crit, offset - 1)
771 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
,
774 struct adm1031_data
*data
= adm1031_update_device(dev
);
775 return sprintf(buf
, "%d\n", data
->alarm
);
778 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
780 static ssize_t
show_alarm(struct device
*dev
,
781 struct device_attribute
*attr
, char *buf
)
783 int bitnr
= to_sensor_dev_attr(attr
)->index
;
784 struct adm1031_data
*data
= adm1031_update_device(dev
);
785 return sprintf(buf
, "%d\n", (data
->alarm
>> bitnr
) & 1);
788 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
789 static SENSOR_DEVICE_ATTR(fan1_fault
, S_IRUGO
, show_alarm
, NULL
, 1);
790 static SENSOR_DEVICE_ATTR(temp2_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 2);
791 static SENSOR_DEVICE_ATTR(temp2_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
792 static SENSOR_DEVICE_ATTR(temp2_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
793 static SENSOR_DEVICE_ATTR(temp2_fault
, S_IRUGO
, show_alarm
, NULL
, 5);
794 static SENSOR_DEVICE_ATTR(temp1_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
795 static SENSOR_DEVICE_ATTR(temp1_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 7);
796 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, show_alarm
, NULL
, 8);
797 static SENSOR_DEVICE_ATTR(fan2_fault
, S_IRUGO
, show_alarm
, NULL
, 9);
798 static SENSOR_DEVICE_ATTR(temp3_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 10);
799 static SENSOR_DEVICE_ATTR(temp3_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 11);
800 static SENSOR_DEVICE_ATTR(temp3_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 12);
801 static SENSOR_DEVICE_ATTR(temp3_fault
, S_IRUGO
, show_alarm
, NULL
, 13);
802 static SENSOR_DEVICE_ATTR(temp1_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 14);
804 /* Update Interval */
805 static const unsigned int update_intervals
[] = {
806 16000, 8000, 4000, 2000, 1000, 500, 250, 125,
809 static ssize_t
show_update_interval(struct device
*dev
,
810 struct device_attribute
*attr
, char *buf
)
812 struct i2c_client
*client
= to_i2c_client(dev
);
813 struct adm1031_data
*data
= i2c_get_clientdata(client
);
815 return sprintf(buf
, "%u\n", data
->update_interval
);
818 static ssize_t
set_update_interval(struct device
*dev
,
819 struct device_attribute
*attr
,
820 const char *buf
, size_t count
)
822 struct i2c_client
*client
= to_i2c_client(dev
);
823 struct adm1031_data
*data
= i2c_get_clientdata(client
);
828 err
= kstrtoul(buf
, 10, &val
);
833 * Find the nearest update interval from the table.
834 * Use it to determine the matching update rate.
836 for (i
= 0; i
< ARRAY_SIZE(update_intervals
) - 1; i
++) {
837 if (val
>= update_intervals
[i
])
840 /* if not found, we point to the last entry (lowest update interval) */
842 /* set the new update rate while preserving other settings */
843 reg
= adm1031_read_value(client
, ADM1031_REG_FAN_FILTER
);
844 reg
&= ~ADM1031_UPDATE_RATE_MASK
;
845 reg
|= i
<< ADM1031_UPDATE_RATE_SHIFT
;
846 adm1031_write_value(client
, ADM1031_REG_FAN_FILTER
, reg
);
848 mutex_lock(&data
->update_lock
);
849 data
->update_interval
= update_intervals
[i
];
850 mutex_unlock(&data
->update_lock
);
855 static DEVICE_ATTR(update_interval
, S_IRUGO
| S_IWUSR
, show_update_interval
,
856 set_update_interval
);
858 static struct attribute
*adm1031_attributes
[] = {
859 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
860 &sensor_dev_attr_fan1_div
.dev_attr
.attr
,
861 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
862 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
863 &sensor_dev_attr_fan1_fault
.dev_attr
.attr
,
864 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
865 &sensor_dev_attr_auto_fan1_channel
.dev_attr
.attr
,
866 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
867 &sensor_dev_attr_temp1_offset
.dev_attr
.attr
,
868 &sensor_dev_attr_temp1_min
.dev_attr
.attr
,
869 &sensor_dev_attr_temp1_min_alarm
.dev_attr
.attr
,
870 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
871 &sensor_dev_attr_temp1_max_alarm
.dev_attr
.attr
,
872 &sensor_dev_attr_temp1_crit
.dev_attr
.attr
,
873 &sensor_dev_attr_temp1_crit_alarm
.dev_attr
.attr
,
874 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
875 &sensor_dev_attr_temp2_offset
.dev_attr
.attr
,
876 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
877 &sensor_dev_attr_temp2_min_alarm
.dev_attr
.attr
,
878 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
879 &sensor_dev_attr_temp2_max_alarm
.dev_attr
.attr
,
880 &sensor_dev_attr_temp2_crit
.dev_attr
.attr
,
881 &sensor_dev_attr_temp2_crit_alarm
.dev_attr
.attr
,
882 &sensor_dev_attr_temp2_fault
.dev_attr
.attr
,
884 &sensor_dev_attr_auto_temp1_off
.dev_attr
.attr
,
885 &sensor_dev_attr_auto_temp1_min
.dev_attr
.attr
,
886 &sensor_dev_attr_auto_temp1_max
.dev_attr
.attr
,
888 &sensor_dev_attr_auto_temp2_off
.dev_attr
.attr
,
889 &sensor_dev_attr_auto_temp2_min
.dev_attr
.attr
,
890 &sensor_dev_attr_auto_temp2_max
.dev_attr
.attr
,
892 &sensor_dev_attr_auto_fan1_min_pwm
.dev_attr
.attr
,
894 &dev_attr_update_interval
.attr
,
895 &dev_attr_alarms
.attr
,
900 static const struct attribute_group adm1031_group
= {
901 .attrs
= adm1031_attributes
,
904 static struct attribute
*adm1031_attributes_opt
[] = {
905 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
906 &sensor_dev_attr_fan2_div
.dev_attr
.attr
,
907 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
908 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
909 &sensor_dev_attr_fan2_fault
.dev_attr
.attr
,
910 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
911 &sensor_dev_attr_auto_fan2_channel
.dev_attr
.attr
,
912 &sensor_dev_attr_temp3_input
.dev_attr
.attr
,
913 &sensor_dev_attr_temp3_offset
.dev_attr
.attr
,
914 &sensor_dev_attr_temp3_min
.dev_attr
.attr
,
915 &sensor_dev_attr_temp3_min_alarm
.dev_attr
.attr
,
916 &sensor_dev_attr_temp3_max
.dev_attr
.attr
,
917 &sensor_dev_attr_temp3_max_alarm
.dev_attr
.attr
,
918 &sensor_dev_attr_temp3_crit
.dev_attr
.attr
,
919 &sensor_dev_attr_temp3_crit_alarm
.dev_attr
.attr
,
920 &sensor_dev_attr_temp3_fault
.dev_attr
.attr
,
921 &sensor_dev_attr_auto_temp3_off
.dev_attr
.attr
,
922 &sensor_dev_attr_auto_temp3_min
.dev_attr
.attr
,
923 &sensor_dev_attr_auto_temp3_max
.dev_attr
.attr
,
924 &sensor_dev_attr_auto_fan2_min_pwm
.dev_attr
.attr
,
928 static const struct attribute_group adm1031_group_opt
= {
929 .attrs
= adm1031_attributes_opt
,
932 /* Return 0 if detection is successful, -ENODEV otherwise */
933 static int adm1031_detect(struct i2c_client
*client
,
934 struct i2c_board_info
*info
)
936 struct i2c_adapter
*adapter
= client
->adapter
;
940 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
943 id
= i2c_smbus_read_byte_data(client
, 0x3d);
944 co
= i2c_smbus_read_byte_data(client
, 0x3e);
946 if (!((id
== 0x31 || id
== 0x30) && co
== 0x41))
948 name
= (id
== 0x30) ? "adm1030" : "adm1031";
950 strlcpy(info
->type
, name
, I2C_NAME_SIZE
);
955 static int adm1031_probe(struct i2c_client
*client
,
956 const struct i2c_device_id
*id
)
958 struct adm1031_data
*data
;
961 data
= kzalloc(sizeof(struct adm1031_data
), GFP_KERNEL
);
967 i2c_set_clientdata(client
, data
);
968 data
->chip_type
= id
->driver_data
;
969 mutex_init(&data
->update_lock
);
971 if (data
->chip_type
== adm1030
)
972 data
->chan_select_table
= &auto_channel_select_table_adm1030
;
974 data
->chan_select_table
= &auto_channel_select_table_adm1031
;
976 /* Initialize the ADM1031 chip */
977 adm1031_init_client(client
);
979 /* Register sysfs hooks */
980 err
= sysfs_create_group(&client
->dev
.kobj
, &adm1031_group
);
984 if (data
->chip_type
== adm1031
) {
985 err
= sysfs_create_group(&client
->dev
.kobj
, &adm1031_group_opt
);
990 data
->hwmon_dev
= hwmon_device_register(&client
->dev
);
991 if (IS_ERR(data
->hwmon_dev
)) {
992 err
= PTR_ERR(data
->hwmon_dev
);
999 sysfs_remove_group(&client
->dev
.kobj
, &adm1031_group
);
1000 sysfs_remove_group(&client
->dev
.kobj
, &adm1031_group_opt
);
1007 static int adm1031_remove(struct i2c_client
*client
)
1009 struct adm1031_data
*data
= i2c_get_clientdata(client
);
1011 hwmon_device_unregister(data
->hwmon_dev
);
1012 sysfs_remove_group(&client
->dev
.kobj
, &adm1031_group
);
1013 sysfs_remove_group(&client
->dev
.kobj
, &adm1031_group_opt
);
1018 static void adm1031_init_client(struct i2c_client
*client
)
1020 unsigned int read_val
;
1023 struct adm1031_data
*data
= i2c_get_clientdata(client
);
1025 mask
= (ADM1031_CONF2_PWM1_ENABLE
| ADM1031_CONF2_TACH1_ENABLE
);
1026 if (data
->chip_type
== adm1031
) {
1027 mask
|= (ADM1031_CONF2_PWM2_ENABLE
|
1028 ADM1031_CONF2_TACH2_ENABLE
);
1030 /* Initialize the ADM1031 chip (enables fan speed reading ) */
1031 read_val
= adm1031_read_value(client
, ADM1031_REG_CONF2
);
1032 if ((read_val
| mask
) != read_val
)
1033 adm1031_write_value(client
, ADM1031_REG_CONF2
, read_val
| mask
);
1035 read_val
= adm1031_read_value(client
, ADM1031_REG_CONF1
);
1036 if ((read_val
| ADM1031_CONF1_MONITOR_ENABLE
) != read_val
) {
1037 adm1031_write_value(client
, ADM1031_REG_CONF1
,
1038 read_val
| ADM1031_CONF1_MONITOR_ENABLE
);
1041 /* Read the chip's update rate */
1042 mask
= ADM1031_UPDATE_RATE_MASK
;
1043 read_val
= adm1031_read_value(client
, ADM1031_REG_FAN_FILTER
);
1044 i
= (read_val
& mask
) >> ADM1031_UPDATE_RATE_SHIFT
;
1045 /* Save it as update interval */
1046 data
->update_interval
= update_intervals
[i
];
1049 static struct adm1031_data
*adm1031_update_device(struct device
*dev
)
1051 struct i2c_client
*client
= to_i2c_client(dev
);
1052 struct adm1031_data
*data
= i2c_get_clientdata(client
);
1053 unsigned long next_update
;
1056 mutex_lock(&data
->update_lock
);
1058 next_update
= data
->last_updated
1059 + msecs_to_jiffies(data
->update_interval
);
1060 if (time_after(jiffies
, next_update
) || !data
->valid
) {
1062 dev_dbg(&client
->dev
, "Starting adm1031 update\n");
1064 chan
< ((data
->chip_type
== adm1031
) ? 3 : 2); chan
++) {
1068 adm1031_read_value(client
, ADM1031_REG_TEMP(chan
));
1069 data
->ext_temp
[chan
] =
1070 adm1031_read_value(client
, ADM1031_REG_EXT_TEMP
);
1072 adm1031_read_value(client
, ADM1031_REG_TEMP(chan
));
1074 data
->ext_temp
[chan
] =
1075 adm1031_read_value(client
,
1076 ADM1031_REG_EXT_TEMP
);
1079 adm1031_read_value(client
,
1080 ADM1031_REG_TEMP(chan
));
1082 /* oldh is actually newer */
1084 dev_warn(&client
->dev
,
1085 "Remote temperature may be wrong.\n");
1088 data
->temp
[chan
] = newh
;
1090 data
->temp_offset
[chan
] =
1091 adm1031_read_value(client
,
1092 ADM1031_REG_TEMP_OFFSET(chan
));
1093 data
->temp_min
[chan
] =
1094 adm1031_read_value(client
,
1095 ADM1031_REG_TEMP_MIN(chan
));
1096 data
->temp_max
[chan
] =
1097 adm1031_read_value(client
,
1098 ADM1031_REG_TEMP_MAX(chan
));
1099 data
->temp_crit
[chan
] =
1100 adm1031_read_value(client
,
1101 ADM1031_REG_TEMP_CRIT(chan
));
1102 data
->auto_temp
[chan
] =
1103 adm1031_read_value(client
,
1104 ADM1031_REG_AUTO_TEMP(chan
));
1108 data
->conf1
= adm1031_read_value(client
, ADM1031_REG_CONF1
);
1109 data
->conf2
= adm1031_read_value(client
, ADM1031_REG_CONF2
);
1111 data
->alarm
= adm1031_read_value(client
, ADM1031_REG_STATUS(0))
1112 | (adm1031_read_value(client
, ADM1031_REG_STATUS(1)) << 8);
1113 if (data
->chip_type
== adm1030
)
1114 data
->alarm
&= 0xc0ff;
1116 for (chan
= 0; chan
< (data
->chip_type
== adm1030
? 1 : 2);
1118 data
->fan_div
[chan
] =
1119 adm1031_read_value(client
,
1120 ADM1031_REG_FAN_DIV(chan
));
1121 data
->fan_min
[chan
] =
1122 adm1031_read_value(client
,
1123 ADM1031_REG_FAN_MIN(chan
));
1125 adm1031_read_value(client
,
1126 ADM1031_REG_FAN_SPEED(chan
));
1128 (adm1031_read_value(client
,
1129 ADM1031_REG_PWM
) >> (4 * chan
)) & 0x0f;
1131 data
->last_updated
= jiffies
;
1135 mutex_unlock(&data
->update_lock
);
1140 module_i2c_driver(adm1031_driver
);
1142 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1143 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1144 MODULE_LICENSE("GPL");