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