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 */
83 /* The chan_select_table contains the possible configurations for
86 const auto_chan_table_t *chan_select_table;
107 static int adm1031_probe(struct i2c_client *client,
108 const struct i2c_device_id *id);
109 static int adm1031_detect(struct i2c_client *client,
110 struct i2c_board_info *info);
111 static void adm1031_init_client(struct i2c_client *client);
112 static int adm1031_remove(struct i2c_client *client);
113 static struct adm1031_data *adm1031_update_device(struct device *dev);
115 static const struct i2c_device_id adm1031_id[] = {
116 { "adm1030", adm1030 },
117 { "adm1031", adm1031 },
120 MODULE_DEVICE_TABLE(i2c, adm1031_id);
122 /* This is the driver that will be inserted */
123 static struct i2c_driver adm1031_driver = {
124 .class = I2C_CLASS_HWMON,
128 .probe = adm1031_probe,
129 .remove = adm1031_remove,
130 .id_table = adm1031_id,
131 .detect = adm1031_detect,
132 .address_list = normal_i2c,
135 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
137 return i2c_smbus_read_byte_data(client, reg);
141 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
143 return i2c_smbus_write_byte_data(client, reg, value);
147 #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
148 ((val + 500) / 1000)))
150 #define TEMP_FROM_REG(val) ((val) * 1000)
152 #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
154 #define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f)
155 #define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \
156 (val) | 0x70 : (val))
158 #define FAN_FROM_REG(reg, div) ((reg) ? (11250 * 60) / ((reg) * (div)) : 0)
160 static int FAN_TO_REG(int reg, int div)
163 tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div);
164 return tmp > 255 ? 255 : tmp;
167 #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
169 #define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4)
170 #define PWM_FROM_REG(val) ((val) << 4)
172 #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7)
173 #define FAN_CHAN_TO_REG(val, reg) \
174 (((reg) & 0x1F) | (((val) << 5) & 0xe0))
176 #define AUTO_TEMP_MIN_TO_REG(val, reg) \
177 ((((val)/500) & 0xf8)|((reg) & 0x7))
178 #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1<< ((reg)&0x7)))
179 #define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2))
181 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
183 #define AUTO_TEMP_OFF_FROM_REG(reg) \
184 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
186 #define AUTO_TEMP_MAX_FROM_REG(reg) \
187 (AUTO_TEMP_RANGE_FROM_REG(reg) + \
188 AUTO_TEMP_MIN_FROM_REG(reg))
190 static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
193 int range = val - AUTO_TEMP_MIN_FROM_REG(reg);
195 range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm);
196 ret = ((reg & 0xf8) |
199 range < 40000 ? 2 : range < 80000 ? 3 : 4));
203 /* FAN auto control */
204 #define GET_FAN_AUTO_BITFIELD(data, idx) \
205 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx%2]
207 /* The tables below contains the possible values for the auto fan
208 * control bitfields. the index in the table is the register value.
209 * MSb is the auto fan control enable bit, so the four first entries
210 * in the table disables auto fan control when both bitfields are zero.
212 static const auto_chan_table_t auto_channel_select_table_adm1031 = {
213 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
214 { 2 /* 0b010 */ , 4 /* 0b100 */ },
215 { 2 /* 0b010 */ , 2 /* 0b010 */ },
216 { 4 /* 0b100 */ , 4 /* 0b100 */ },
217 { 7 /* 0b111 */ , 7 /* 0b111 */ },
220 static const auto_chan_table_t auto_channel_select_table_adm1030 = {
221 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
222 { 2 /* 0b10 */ , 0 },
223 { 0xff /* invalid */ , 0 },
224 { 0xff /* invalid */ , 0 },
225 { 3 /* 0b11 */ , 0 },
228 /* That function checks if a bitfield is valid and returns the other bitfield
229 * nearest match if no exact match where found.
232 get_fan_auto_nearest(struct adm1031_data *data,
233 int chan, u8 val, u8 reg, u8 * new_reg)
236 int first_match = -1, exact_match = -1;
238 (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
245 for (i = 0; i < 8; i++) {
246 if ((val == (*data->chan_select_table)[i][chan]) &&
247 ((*data->chan_select_table)[i][chan ? 0 : 1] ==
249 /* We found an exact match */
252 } else if (val == (*data->chan_select_table)[i][chan] &&
254 /* Save the first match in case of an exact match has
261 if (exact_match >= 0) {
262 *new_reg = exact_match;
263 } else if (first_match >= 0) {
264 *new_reg = first_match;
271 static ssize_t show_fan_auto_channel(struct device *dev,
272 struct device_attribute *attr, char *buf)
274 int nr = to_sensor_dev_attr(attr)->index;
275 struct adm1031_data *data = adm1031_update_device(dev);
276 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
280 set_fan_auto_channel(struct device *dev, struct device_attribute *attr,
281 const char *buf, size_t count)
283 struct i2c_client *client = to_i2c_client(dev);
284 struct adm1031_data *data = i2c_get_clientdata(client);
285 int nr = to_sensor_dev_attr(attr)->index;
286 int val = simple_strtol(buf, NULL, 10);
291 old_fan_mode = data->conf1;
293 mutex_lock(&data->update_lock);
295 if ((ret = get_fan_auto_nearest(data, nr, val, data->conf1, ®))) {
296 mutex_unlock(&data->update_lock);
299 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
300 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
301 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
302 if (data->conf1 & ADM1031_CONF1_AUTO_MODE){
303 /* Switch to Auto Fan Mode
305 * Set PWM registers to 33% Both */
306 data->old_pwm[0] = data->pwm[0];
307 data->old_pwm[1] = data->pwm[1];
308 adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
310 /* Switch to Manual Mode */
311 data->pwm[0] = data->old_pwm[0];
312 data->pwm[1] = data->old_pwm[1];
313 /* Restore PWM registers */
314 adm1031_write_value(client, ADM1031_REG_PWM,
315 data->pwm[0] | (data->pwm[1] << 4));
318 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
319 adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
320 mutex_unlock(&data->update_lock);
324 static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR,
325 show_fan_auto_channel, set_fan_auto_channel, 0);
326 static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR,
327 show_fan_auto_channel, set_fan_auto_channel, 1);
330 static ssize_t show_auto_temp_off(struct device *dev,
331 struct device_attribute *attr, char *buf)
333 int nr = to_sensor_dev_attr(attr)->index;
334 struct adm1031_data *data = adm1031_update_device(dev);
335 return sprintf(buf, "%d\n",
336 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
338 static ssize_t show_auto_temp_min(struct device *dev,
339 struct device_attribute *attr, char *buf)
341 int nr = to_sensor_dev_attr(attr)->index;
342 struct adm1031_data *data = adm1031_update_device(dev);
343 return sprintf(buf, "%d\n",
344 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
347 set_auto_temp_min(struct device *dev, struct device_attribute *attr,
348 const char *buf, size_t count)
350 struct i2c_client *client = to_i2c_client(dev);
351 struct adm1031_data *data = i2c_get_clientdata(client);
352 int nr = to_sensor_dev_attr(attr)->index;
353 int val = simple_strtol(buf, NULL, 10);
355 val = clamp_val(val, 0, 127000);
356 mutex_lock(&data->update_lock);
357 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
358 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
359 data->auto_temp[nr]);
360 mutex_unlock(&data->update_lock);
363 static ssize_t show_auto_temp_max(struct device *dev,
364 struct device_attribute *attr, char *buf)
366 int nr = to_sensor_dev_attr(attr)->index;
367 struct adm1031_data *data = adm1031_update_device(dev);
368 return sprintf(buf, "%d\n",
369 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
372 set_auto_temp_max(struct device *dev, struct device_attribute *attr,
373 const char *buf, size_t count)
375 struct i2c_client *client = to_i2c_client(dev);
376 struct adm1031_data *data = i2c_get_clientdata(client);
377 int nr = to_sensor_dev_attr(attr)->index;
378 int val = simple_strtol(buf, NULL, 10);
380 val = clamp_val(val, 0, 127000);
381 mutex_lock(&data->update_lock);
382 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], data->pwm[nr]);
383 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
385 mutex_unlock(&data->update_lock);
389 #define auto_temp_reg(offset) \
390 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \
391 show_auto_temp_off, NULL, offset - 1); \
392 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \
393 show_auto_temp_min, set_auto_temp_min, offset - 1); \
394 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \
395 show_auto_temp_max, set_auto_temp_max, offset - 1)
402 static ssize_t show_pwm(struct device *dev,
403 struct device_attribute *attr, char *buf)
405 int nr = to_sensor_dev_attr(attr)->index;
406 struct adm1031_data *data = adm1031_update_device(dev);
407 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
409 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
410 const char *buf, size_t count)
412 struct i2c_client *client = to_i2c_client(dev);
413 struct adm1031_data *data = i2c_get_clientdata(client);
414 int nr = to_sensor_dev_attr(attr)->index;
415 int val = simple_strtol(buf, NULL, 10);
418 mutex_lock(&data->update_lock);
419 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
420 (((val>>4) & 0xf) != 5)) {
421 /* In automatic mode, the only PWM accepted is 33% */
422 mutex_unlock(&data->update_lock);
425 data->pwm[nr] = PWM_TO_REG(val);
426 reg = adm1031_read_value(client, ADM1031_REG_PWM);
427 adm1031_write_value(client, ADM1031_REG_PWM,
428 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
429 : (data->pwm[nr] & 0xf) | (reg & 0xf0));
430 mutex_unlock(&data->update_lock);
434 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
435 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
436 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
437 show_pwm, set_pwm, 0);
438 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR,
439 show_pwm, set_pwm, 1);
444 * That function checks the cases where the fan reading is not
445 * relevant. It is used to provide 0 as fan reading when the fan is
446 * not supposed to run
448 static int trust_fan_readings(struct adm1031_data *data, int chan)
452 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
453 switch (data->conf1 & 0x60) {
454 case 0x00: /* remote temp1 controls fan1 remote temp2 controls fan2 */
455 res = data->temp[chan+1] >=
456 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
458 case 0x20: /* remote temp1 controls both fans */
461 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
463 case 0x40: /* remote temp2 controls both fans */
466 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
468 case 0x60: /* max controls both fans */
471 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
473 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
474 || (data->chip_type == adm1031
476 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
480 res = data->pwm[chan] > 0;
486 static ssize_t show_fan(struct device *dev,
487 struct device_attribute *attr, char *buf)
489 int nr = to_sensor_dev_attr(attr)->index;
490 struct adm1031_data *data = adm1031_update_device(dev);
493 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
494 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
495 return sprintf(buf, "%d\n", value);
498 static ssize_t show_fan_div(struct device *dev,
499 struct device_attribute *attr, char *buf)
501 int nr = to_sensor_dev_attr(attr)->index;
502 struct adm1031_data *data = adm1031_update_device(dev);
503 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
505 static ssize_t show_fan_min(struct device *dev,
506 struct device_attribute *attr, char *buf)
508 int nr = to_sensor_dev_attr(attr)->index;
509 struct adm1031_data *data = adm1031_update_device(dev);
510 return sprintf(buf, "%d\n",
511 FAN_FROM_REG(data->fan_min[nr],
512 FAN_DIV_FROM_REG(data->fan_div[nr])));
514 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
515 const char *buf, size_t count)
517 struct i2c_client *client = to_i2c_client(dev);
518 struct adm1031_data *data = i2c_get_clientdata(client);
519 int nr = to_sensor_dev_attr(attr)->index;
520 int val = simple_strtol(buf, NULL, 10);
522 mutex_lock(&data->update_lock);
525 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
527 data->fan_min[nr] = 0xff;
529 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
530 mutex_unlock(&data->update_lock);
533 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
534 const char *buf, size_t count)
536 struct i2c_client *client = to_i2c_client(dev);
537 struct adm1031_data *data = i2c_get_clientdata(client);
538 int nr = to_sensor_dev_attr(attr)->index;
539 int val = simple_strtol(buf, NULL, 10);
544 tmp = val == 8 ? 0xc0 :
552 mutex_lock(&data->update_lock);
553 /* Get fresh readings */
554 data->fan_div[nr] = adm1031_read_value(client,
555 ADM1031_REG_FAN_DIV(nr));
556 data->fan_min[nr] = adm1031_read_value(client,
557 ADM1031_REG_FAN_MIN(nr));
559 /* Write the new clock divider and fan min */
560 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
561 data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
562 new_min = data->fan_min[nr] * old_div / val;
563 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
565 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
567 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
570 /* Invalidate the cache: fan speed is no longer valid */
572 mutex_unlock(&data->update_lock);
576 #define fan_offset(offset) \
577 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
578 show_fan, NULL, offset - 1); \
579 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
580 show_fan_min, set_fan_min, offset - 1); \
581 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
582 show_fan_div, set_fan_div, offset - 1)
589 static ssize_t show_temp(struct device *dev,
590 struct device_attribute *attr, char *buf)
592 int nr = to_sensor_dev_attr(attr)->index;
593 struct adm1031_data *data = adm1031_update_device(dev);
596 ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
597 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
598 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
600 static ssize_t show_temp_offset(struct device *dev,
601 struct device_attribute *attr, char *buf)
603 int nr = to_sensor_dev_attr(attr)->index;
604 struct adm1031_data *data = adm1031_update_device(dev);
605 return sprintf(buf, "%d\n",
606 TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
608 static ssize_t show_temp_min(struct device *dev,
609 struct device_attribute *attr, char *buf)
611 int nr = to_sensor_dev_attr(attr)->index;
612 struct adm1031_data *data = adm1031_update_device(dev);
613 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
615 static ssize_t show_temp_max(struct device *dev,
616 struct device_attribute *attr, char *buf)
618 int nr = to_sensor_dev_attr(attr)->index;
619 struct adm1031_data *data = adm1031_update_device(dev);
620 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
622 static ssize_t show_temp_crit(struct device *dev,
623 struct device_attribute *attr, char *buf)
625 int nr = to_sensor_dev_attr(attr)->index;
626 struct adm1031_data *data = adm1031_update_device(dev);
627 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
629 static ssize_t set_temp_offset(struct device *dev,
630 struct device_attribute *attr, const char *buf,
633 struct i2c_client *client = to_i2c_client(dev);
634 struct adm1031_data *data = i2c_get_clientdata(client);
635 int nr = to_sensor_dev_attr(attr)->index;
638 val = simple_strtol(buf, NULL, 10);
639 val = SENSORS_LIMIT(val, -15000, 15000);
640 mutex_lock(&data->update_lock);
641 data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
642 adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
643 data->temp_offset[nr]);
644 mutex_unlock(&data->update_lock);
647 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
648 const char *buf, size_t count)
650 struct i2c_client *client = to_i2c_client(dev);
651 struct adm1031_data *data = i2c_get_clientdata(client);
652 int nr = to_sensor_dev_attr(attr)->index;
655 val = simple_strtol(buf, NULL, 10);
656 val = clamp_val(val, -55000, 127000);
657 mutex_lock(&data->update_lock);
658 data->temp_min[nr] = TEMP_TO_REG(val);
659 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
661 mutex_unlock(&data->update_lock);
664 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
665 const char *buf, size_t count)
667 struct i2c_client *client = to_i2c_client(dev);
668 struct adm1031_data *data = i2c_get_clientdata(client);
669 int nr = to_sensor_dev_attr(attr)->index;
672 val = simple_strtol(buf, NULL, 10);
673 val = clamp_val(val, -55000, 127000);
674 mutex_lock(&data->update_lock);
675 data->temp_max[nr] = TEMP_TO_REG(val);
676 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
678 mutex_unlock(&data->update_lock);
681 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
682 const char *buf, size_t count)
684 struct i2c_client *client = to_i2c_client(dev);
685 struct adm1031_data *data = i2c_get_clientdata(client);
686 int nr = to_sensor_dev_attr(attr)->index;
689 val = simple_strtol(buf, NULL, 10);
690 val = clamp_val(val, -55000, 127000);
691 mutex_lock(&data->update_lock);
692 data->temp_crit[nr] = TEMP_TO_REG(val);
693 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
694 data->temp_crit[nr]);
695 mutex_unlock(&data->update_lock);
699 #define temp_reg(offset) \
700 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
701 show_temp, NULL, offset - 1); \
702 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \
703 show_temp_offset, set_temp_offset, offset - 1); \
704 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
705 show_temp_min, set_temp_min, offset - 1); \
706 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
707 show_temp_max, set_temp_max, offset - 1); \
708 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \
709 show_temp_crit, set_temp_crit, offset - 1)
716 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
718 struct adm1031_data *data = adm1031_update_device(dev);
719 return sprintf(buf, "%d\n", data->alarm);
722 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
724 static ssize_t show_alarm(struct device *dev,
725 struct device_attribute *attr, char *buf)
727 int bitnr = to_sensor_dev_attr(attr)->index;
728 struct adm1031_data *data = adm1031_update_device(dev);
729 return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
732 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
733 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
734 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
735 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
736 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
737 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
738 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
739 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
740 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
741 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
742 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
743 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
744 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
745 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
746 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
748 /* Update Interval */
749 static const unsigned int update_intervals[] = {
750 16000, 8000, 4000, 2000, 1000, 500, 250, 125,
753 static ssize_t show_update_interval(struct device *dev,
754 struct device_attribute *attr, char *buf)
756 struct i2c_client *client = to_i2c_client(dev);
757 struct adm1031_data *data = i2c_get_clientdata(client);
759 return sprintf(buf, "%u\n", data->update_interval);
762 static ssize_t set_update_interval(struct device *dev,
763 struct device_attribute *attr,
764 const char *buf, size_t count)
766 struct i2c_client *client = to_i2c_client(dev);
767 struct adm1031_data *data = i2c_get_clientdata(client);
772 err = strict_strtoul(buf, 10, &val);
777 * Find the nearest update interval from the table.
778 * Use it to determine the matching update rate.
780 for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
781 if (val >= update_intervals[i])
784 /* if not found, we point to the last entry (lowest update interval) */
786 /* set the new update rate while preserving other settings */
787 reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
788 reg &= ~ADM1031_UPDATE_RATE_MASK;
789 reg |= i << ADM1031_UPDATE_RATE_SHIFT;
790 adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
792 mutex_lock(&data->update_lock);
793 data->update_interval = update_intervals[i];
794 mutex_unlock(&data->update_lock);
799 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
800 set_update_interval);
802 static struct attribute *adm1031_attributes[] = {
803 &sensor_dev_attr_fan1_input.dev_attr.attr,
804 &sensor_dev_attr_fan1_div.dev_attr.attr,
805 &sensor_dev_attr_fan1_min.dev_attr.attr,
806 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
807 &sensor_dev_attr_fan1_fault.dev_attr.attr,
808 &sensor_dev_attr_pwm1.dev_attr.attr,
809 &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
810 &sensor_dev_attr_temp1_input.dev_attr.attr,
811 &sensor_dev_attr_temp1_offset.dev_attr.attr,
812 &sensor_dev_attr_temp1_min.dev_attr.attr,
813 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
814 &sensor_dev_attr_temp1_max.dev_attr.attr,
815 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
816 &sensor_dev_attr_temp1_crit.dev_attr.attr,
817 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
818 &sensor_dev_attr_temp2_input.dev_attr.attr,
819 &sensor_dev_attr_temp2_offset.dev_attr.attr,
820 &sensor_dev_attr_temp2_min.dev_attr.attr,
821 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
822 &sensor_dev_attr_temp2_max.dev_attr.attr,
823 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
824 &sensor_dev_attr_temp2_crit.dev_attr.attr,
825 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
826 &sensor_dev_attr_temp2_fault.dev_attr.attr,
828 &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
829 &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
830 &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
832 &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
833 &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
834 &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
836 &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
838 &dev_attr_update_interval.attr,
839 &dev_attr_alarms.attr,
844 static const struct attribute_group adm1031_group = {
845 .attrs = adm1031_attributes,
848 static struct attribute *adm1031_attributes_opt[] = {
849 &sensor_dev_attr_fan2_input.dev_attr.attr,
850 &sensor_dev_attr_fan2_div.dev_attr.attr,
851 &sensor_dev_attr_fan2_min.dev_attr.attr,
852 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
853 &sensor_dev_attr_fan2_fault.dev_attr.attr,
854 &sensor_dev_attr_pwm2.dev_attr.attr,
855 &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
856 &sensor_dev_attr_temp3_input.dev_attr.attr,
857 &sensor_dev_attr_temp3_offset.dev_attr.attr,
858 &sensor_dev_attr_temp3_min.dev_attr.attr,
859 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
860 &sensor_dev_attr_temp3_max.dev_attr.attr,
861 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
862 &sensor_dev_attr_temp3_crit.dev_attr.attr,
863 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
864 &sensor_dev_attr_temp3_fault.dev_attr.attr,
865 &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
866 &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
867 &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
868 &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
872 static const struct attribute_group adm1031_group_opt = {
873 .attrs = adm1031_attributes_opt,
876 /* Return 0 if detection is successful, -ENODEV otherwise */
877 static int adm1031_detect(struct i2c_client *client,
878 struct i2c_board_info *info)
880 struct i2c_adapter *adapter = client->adapter;
884 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
887 id = i2c_smbus_read_byte_data(client, 0x3d);
888 co = i2c_smbus_read_byte_data(client, 0x3e);
890 if (!((id == 0x31 || id == 0x30) && co == 0x41))
892 name = (id == 0x30) ? "adm1030" : "adm1031";
894 strlcpy(info->type, name, I2C_NAME_SIZE);
899 static int adm1031_probe(struct i2c_client *client,
900 const struct i2c_device_id *id)
902 struct adm1031_data *data;
905 data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL);
911 i2c_set_clientdata(client, data);
912 data->chip_type = id->driver_data;
913 mutex_init(&data->update_lock);
915 if (data->chip_type == adm1030)
916 data->chan_select_table = &auto_channel_select_table_adm1030;
918 data->chan_select_table = &auto_channel_select_table_adm1031;
920 /* Initialize the ADM1031 chip */
921 adm1031_init_client(client);
923 /* Register sysfs hooks */
924 if ((err = sysfs_create_group(&client->dev.kobj, &adm1031_group)))
927 if (data->chip_type == adm1031) {
928 if ((err = sysfs_create_group(&client->dev.kobj,
929 &adm1031_group_opt)))
933 data->hwmon_dev = hwmon_device_register(&client->dev);
934 if (IS_ERR(data->hwmon_dev)) {
935 err = PTR_ERR(data->hwmon_dev);
942 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
943 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
950 static int adm1031_remove(struct i2c_client *client)
952 struct adm1031_data *data = i2c_get_clientdata(client);
954 hwmon_device_unregister(data->hwmon_dev);
955 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
956 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
961 static void adm1031_init_client(struct i2c_client *client)
963 unsigned int read_val;
966 struct adm1031_data *data = i2c_get_clientdata(client);
968 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
969 if (data->chip_type == adm1031) {
970 mask |= (ADM1031_CONF2_PWM2_ENABLE |
971 ADM1031_CONF2_TACH2_ENABLE);
973 /* Initialize the ADM1031 chip (enables fan speed reading ) */
974 read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
975 if ((read_val | mask) != read_val) {
976 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
979 read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
980 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
981 adm1031_write_value(client, ADM1031_REG_CONF1, read_val |
982 ADM1031_CONF1_MONITOR_ENABLE);
985 /* Read the chip's update rate */
986 mask = ADM1031_UPDATE_RATE_MASK;
987 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
988 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
989 /* Save it as update interval */
990 data->update_interval = update_intervals[i];
993 static struct adm1031_data *adm1031_update_device(struct device *dev)
995 struct i2c_client *client = to_i2c_client(dev);
996 struct adm1031_data *data = i2c_get_clientdata(client);
997 unsigned long next_update;
1000 mutex_lock(&data->update_lock);
1002 next_update = data->last_updated
1003 + msecs_to_jiffies(data->update_interval);
1004 if (time_after(jiffies, next_update) || !data->valid) {
1006 dev_dbg(&client->dev, "Starting adm1031 update\n");
1008 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
1012 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1013 data->ext_temp[chan] =
1014 adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
1016 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1018 data->ext_temp[chan] =
1019 adm1031_read_value(client,
1020 ADM1031_REG_EXT_TEMP);
1023 adm1031_read_value(client,
1024 ADM1031_REG_TEMP(chan));
1026 /* oldh is actually newer */
1028 dev_warn(&client->dev,
1029 "Remote temperature may be "
1033 data->temp[chan] = newh;
1035 data->temp_offset[chan] =
1036 adm1031_read_value(client,
1037 ADM1031_REG_TEMP_OFFSET(chan));
1038 data->temp_min[chan] =
1039 adm1031_read_value(client,
1040 ADM1031_REG_TEMP_MIN(chan));
1041 data->temp_max[chan] =
1042 adm1031_read_value(client,
1043 ADM1031_REG_TEMP_MAX(chan));
1044 data->temp_crit[chan] =
1045 adm1031_read_value(client,
1046 ADM1031_REG_TEMP_CRIT(chan));
1047 data->auto_temp[chan] =
1048 adm1031_read_value(client,
1049 ADM1031_REG_AUTO_TEMP(chan));
1053 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
1054 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
1056 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
1057 | (adm1031_read_value(client, ADM1031_REG_STATUS(1))
1059 if (data->chip_type == adm1030) {
1060 data->alarm &= 0xc0ff;
1063 for (chan=0; chan<(data->chip_type == adm1030 ? 1 : 2); chan++) {
1064 data->fan_div[chan] =
1065 adm1031_read_value(client, ADM1031_REG_FAN_DIV(chan));
1066 data->fan_min[chan] =
1067 adm1031_read_value(client, ADM1031_REG_FAN_MIN(chan));
1069 adm1031_read_value(client, ADM1031_REG_FAN_SPEED(chan));
1071 0xf & (adm1031_read_value(client, ADM1031_REG_PWM) >>
1074 data->last_updated = jiffies;
1078 mutex_unlock(&data->update_lock);
1083 static int __init sensors_adm1031_init(void)
1085 return i2c_add_driver(&adm1031_driver);
1088 static void __exit sensors_adm1031_exit(void)
1090 i2c_del_driver(&adm1031_driver);
1093 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1094 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1095 MODULE_LICENSE("GPL");
1097 module_init(sensors_adm1031_init);
1098 module_exit(sensors_adm1031_exit);