1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * A hwmon driver for the Analog Devices ADT7470
4 * Copyright (C) 2007 IBM
6 * Author: Darrick J. Wong <darrick.wong@oracle.com>
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #include <linux/module.h>
12 #include <linux/jiffies.h>
13 #include <linux/i2c.h>
14 #include <linux/hwmon.h>
15 #include <linux/hwmon-sysfs.h>
16 #include <linux/err.h>
17 #include <linux/mutex.h>
18 #include <linux/delay.h>
19 #include <linux/log2.h>
20 #include <linux/kthread.h>
21 #include <linux/regmap.h>
22 #include <linux/slab.h>
23 #include <linux/util_macros.h>
25 /* Addresses to scan */
26 static const unsigned short normal_i2c
[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END
};
28 /* ADT7470 registers */
29 #define ADT7470_REG_BASE_ADDR 0x20
30 #define ADT7470_REG_TEMP_BASE_ADDR 0x20
31 #define ADT7470_REG_TEMP_MAX_ADDR 0x29
32 #define ADT7470_REG_FAN_BASE_ADDR 0x2A
33 #define ADT7470_REG_FAN_MAX_ADDR 0x31
34 #define ADT7470_REG_PWM_BASE_ADDR 0x32
35 #define ADT7470_REG_PWM_MAX_ADDR 0x35
36 #define ADT7470_REG_PWM_MAX_BASE_ADDR 0x38
37 #define ADT7470_REG_PWM_MAX_MAX_ADDR 0x3B
38 #define ADT7470_REG_CFG 0x40
39 #define ADT7470_STRT_MASK 0x01
40 #define ADT7470_TEST_MASK 0x02
41 #define ADT7470_FSPD_MASK 0x04
42 #define ADT7470_T05_STB_MASK 0x80
43 #define ADT7470_REG_ALARM1 0x41
44 #define ADT7470_R1T_ALARM 0x01
45 #define ADT7470_R2T_ALARM 0x02
46 #define ADT7470_R3T_ALARM 0x04
47 #define ADT7470_R4T_ALARM 0x08
48 #define ADT7470_R5T_ALARM 0x10
49 #define ADT7470_R6T_ALARM 0x20
50 #define ADT7470_R7T_ALARM 0x40
51 #define ADT7470_OOL_ALARM 0x80
52 #define ADT7470_REG_ALARM2 0x42
53 #define ADT7470_R8T_ALARM 0x01
54 #define ADT7470_R9T_ALARM 0x02
55 #define ADT7470_R10T_ALARM 0x04
56 #define ADT7470_FAN1_ALARM 0x10
57 #define ADT7470_FAN2_ALARM 0x20
58 #define ADT7470_FAN3_ALARM 0x40
59 #define ADT7470_FAN4_ALARM 0x80
60 #define ADT7470_REG_TEMP_LIMITS_BASE_ADDR 0x44
61 #define ADT7470_REG_TEMP_LIMITS_MAX_ADDR 0x57
62 #define ADT7470_REG_FAN_MIN_BASE_ADDR 0x58
63 #define ADT7470_REG_FAN_MIN_MAX_ADDR 0x5F
64 #define ADT7470_REG_FAN_MAX_BASE_ADDR 0x60
65 #define ADT7470_REG_FAN_MAX_MAX_ADDR 0x67
66 #define ADT7470_REG_PWM_CFG_BASE_ADDR 0x68
67 #define ADT7470_REG_PWM12_CFG 0x68
68 #define ADT7470_PWM2_AUTO_MASK 0x40
69 #define ADT7470_PWM1_AUTO_MASK 0x80
70 #define ADT7470_PWM_AUTO_MASK 0xC0
71 #define ADT7470_REG_PWM34_CFG 0x69
72 #define ADT7470_PWM3_AUTO_MASK 0x40
73 #define ADT7470_PWM4_AUTO_MASK 0x80
74 #define ADT7470_REG_PWM_MIN_BASE_ADDR 0x6A
75 #define ADT7470_REG_PWM_MIN_MAX_ADDR 0x6D
76 #define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR 0x6E
77 #define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR 0x71
78 #define ADT7470_REG_CFG_2 0x74
79 #define ADT7470_REG_ACOUSTICS12 0x75
80 #define ADT7470_REG_ACOUSTICS34 0x76
81 #define ADT7470_REG_DEVICE 0x3D
82 #define ADT7470_REG_VENDOR 0x3E
83 #define ADT7470_REG_REVISION 0x3F
84 #define ADT7470_REG_ALARM1_MASK 0x72
85 #define ADT7470_REG_ALARM2_MASK 0x73
86 #define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR 0x7C
87 #define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR 0x7D
88 #define ADT7470_REG_MAX_ADDR 0x81
90 #define ADT7470_TEMP_COUNT 10
91 #define ADT7470_TEMP_REG(x) (ADT7470_REG_TEMP_BASE_ADDR + (x))
92 #define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
93 #define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \
96 #define ADT7470_FAN_COUNT 4
97 #define ADT7470_REG_FAN(x) (ADT7470_REG_FAN_BASE_ADDR + ((x) * 2))
98 #define ADT7470_REG_FAN_MIN(x) (ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
99 #define ADT7470_REG_FAN_MAX(x) (ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2))
101 #define ADT7470_PWM_COUNT 4
102 #define ADT7470_REG_PWM(x) (ADT7470_REG_PWM_BASE_ADDR + (x))
103 #define ADT7470_REG_PWM_MAX(x) (ADT7470_REG_PWM_MAX_BASE_ADDR + (x))
104 #define ADT7470_REG_PWM_MIN(x) (ADT7470_REG_PWM_MIN_BASE_ADDR + (x))
105 #define ADT7470_REG_PWM_TMIN(x) (ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
106 #define ADT7470_REG_PWM_CFG(x) (ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2))
107 #define ADT7470_REG_PWM_AUTO_TEMP(x) (ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \
110 #define ALARM2(x) ((x) << 8)
112 #define ADT7470_VENDOR 0x41
113 #define ADT7470_DEVICE 0x70
114 /* datasheet only mentions a revision 2 */
115 #define ADT7470_REVISION 0x02
117 /* "all temps" according to hwmon sysfs interface spec */
118 #define ADT7470_PWM_ALL_TEMPS 0x3FF
120 /* How often do we reread sensors values? (In jiffies) */
121 #define SENSOR_REFRESH_INTERVAL (5 * HZ)
123 /* How often do we reread sensor limit values? (In jiffies) */
124 #define LIMIT_REFRESH_INTERVAL (60 * HZ)
126 /* Wait at least 200ms per sensor for 10 sensors */
127 #define TEMP_COLLECTION_TIME 2000
129 /* auto update thing won't fire more than every 2s */
130 #define AUTO_UPDATE_INTERVAL 2000
132 /* datasheet says to divide this number by the fan reading to get fan rpm */
133 #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
134 #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
135 #define FAN_PERIOD_INVALID 65535
136 #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
138 /* Config registers 1 and 2 include fields for selecting the PWM frequency */
139 #define ADT7470_CFG_LF 0x40
140 #define ADT7470_FREQ_MASK 0x70
141 #define ADT7470_FREQ_SHIFT 4
143 struct adt7470_data
{
144 struct regmap
*regmap
;
148 unsigned long sensors_last_updated
; /* In jiffies */
149 unsigned long limits_last_updated
; /* In jiffies */
151 int num_temp_sensors
; /* -1 = probe */
152 int temperatures_probed
;
154 s8 temp
[ADT7470_TEMP_COUNT
];
155 s8 temp_min
[ADT7470_TEMP_COUNT
];
156 s8 temp_max
[ADT7470_TEMP_COUNT
];
157 u16 fan
[ADT7470_FAN_COUNT
];
158 u16 fan_min
[ADT7470_FAN_COUNT
];
159 u16 fan_max
[ADT7470_FAN_COUNT
];
163 u8 pwm
[ADT7470_PWM_COUNT
];
164 u8 pwm_max
[ADT7470_PWM_COUNT
];
165 u8 pwm_automatic
[ADT7470_PWM_COUNT
];
166 u8 pwm_min
[ADT7470_PWM_COUNT
];
167 s8 pwm_tmin
[ADT7470_PWM_COUNT
];
168 u8 pwm_auto_temp
[ADT7470_PWM_COUNT
];
170 struct task_struct
*auto_update
;
171 unsigned int auto_update_interval
;
175 * 16-bit registers on the ADT7470 are low-byte first. The data sheet says
176 * that the low byte must be read before the high byte.
178 static inline int adt7470_read_word_data(struct adt7470_data
*data
, unsigned int reg
,
184 err
= regmap_bulk_read(data
->regmap
, reg
, ®val
, 2);
188 *val
= regval
[0] | (regval
[1] << 8);
193 static inline int adt7470_write_word_data(struct adt7470_data
*data
, unsigned int reg
,
198 regval
[0] = val
& 0xFF;
199 regval
[1] = val
>> 8;
201 return regmap_bulk_write(data
->regmap
, reg
, ®val
, 2);
204 /* Probe for temperature sensors. Assumes lock is held */
205 static int adt7470_read_temperatures(struct adt7470_data
*data
)
208 unsigned int pwm_cfg
[2];
211 u8 pwm
[ADT7470_FAN_COUNT
];
213 /* save pwm[1-4] config register */
214 err
= regmap_read(data
->regmap
, ADT7470_REG_PWM_CFG(0), &pwm_cfg
[0]);
217 err
= regmap_read(data
->regmap
, ADT7470_REG_PWM_CFG(2), &pwm_cfg
[1]);
221 /* set manual pwm to whatever it is set to now */
222 err
= regmap_bulk_read(data
->regmap
, ADT7470_REG_PWM(0), &pwm
[0],
227 /* put pwm in manual mode */
228 err
= regmap_update_bits(data
->regmap
, ADT7470_REG_PWM_CFG(0),
229 ADT7470_PWM_AUTO_MASK
, 0);
232 err
= regmap_update_bits(data
->regmap
, ADT7470_REG_PWM_CFG(2),
233 ADT7470_PWM_AUTO_MASK
, 0);
237 /* write pwm control to whatever it was */
238 err
= regmap_bulk_write(data
->regmap
, ADT7470_REG_PWM(0), &pwm
[0],
243 /* start reading temperature sensors */
244 err
= regmap_update_bits(data
->regmap
, ADT7470_REG_CFG
,
245 ADT7470_T05_STB_MASK
, ADT7470_T05_STB_MASK
);
249 /* Delay is 200ms * number of temp sensors. */
250 res
= msleep_interruptible((data
->num_temp_sensors
>= 0 ?
251 data
->num_temp_sensors
* 200 :
252 TEMP_COLLECTION_TIME
));
254 /* done reading temperature sensors */
255 err
= regmap_update_bits(data
->regmap
, ADT7470_REG_CFG
,
256 ADT7470_T05_STB_MASK
, 0);
260 /* restore pwm[1-4] config registers */
261 err
= regmap_write(data
->regmap
, ADT7470_REG_PWM_CFG(0), pwm_cfg
[0]);
264 err
= regmap_write(data
->regmap
, ADT7470_REG_PWM_CFG(2), pwm_cfg
[1]);
271 /* Only count fans if we have to */
272 if (data
->num_temp_sensors
>= 0)
275 err
= regmap_bulk_read(data
->regmap
, ADT7470_TEMP_REG(0), &data
->temp
[0],
279 for (i
= 0; i
< ADT7470_TEMP_COUNT
; i
++) {
281 data
->num_temp_sensors
= i
+ 1;
283 data
->temperatures_probed
= 1;
287 static int adt7470_update_thread(void *p
)
289 struct i2c_client
*client
= p
;
290 struct adt7470_data
*data
= i2c_get_clientdata(client
);
292 while (!kthread_should_stop()) {
293 mutex_lock(&data
->lock
);
294 adt7470_read_temperatures(data
);
295 mutex_unlock(&data
->lock
);
297 set_current_state(TASK_INTERRUPTIBLE
);
298 if (kthread_should_stop())
301 schedule_timeout(msecs_to_jiffies(data
->auto_update_interval
));
307 static int adt7470_update_sensors(struct adt7470_data
*data
)
313 if (!data
->temperatures_probed
)
314 err
= adt7470_read_temperatures(data
);
316 err
= regmap_bulk_read(data
->regmap
, ADT7470_TEMP_REG(0), &data
->temp
[0],
321 for (i
= 0; i
< ADT7470_FAN_COUNT
; i
++) {
322 err
= adt7470_read_word_data(data
, ADT7470_REG_FAN(i
), &val
);
328 err
= regmap_bulk_read(data
->regmap
, ADT7470_REG_PWM(0), &data
->pwm
[0], ADT7470_PWM_COUNT
);
332 for (i
= 0; i
< ADT7470_PWM_COUNT
; i
++) {
336 mask
= ADT7470_PWM2_AUTO_MASK
;
338 mask
= ADT7470_PWM1_AUTO_MASK
;
340 err
= regmap_read(data
->regmap
, ADT7470_REG_PWM_CFG(i
), &val
);
343 data
->pwm_automatic
[i
] = !!(val
& mask
);
345 err
= regmap_read(data
->regmap
, ADT7470_REG_PWM_AUTO_TEMP(i
), &val
);
349 data
->pwm_auto_temp
[i
] = val
>> 4;
351 data
->pwm_auto_temp
[i
] = val
& 0xF;
354 err
= regmap_read(data
->regmap
, ADT7470_REG_CFG
, &val
);
357 data
->force_pwm_max
= !!(val
& ADT7470_FSPD_MASK
);
359 err
= regmap_read(data
->regmap
, ADT7470_REG_ALARM1
, &val
);
363 if (data
->alarm
& ADT7470_OOL_ALARM
) {
364 err
= regmap_read(data
->regmap
, ADT7470_REG_ALARM2
, &val
);
367 data
->alarm
|= ALARM2(val
);
370 err
= adt7470_read_word_data(data
, ADT7470_REG_ALARM1_MASK
, &val
);
373 data
->alarms_mask
= val
;
378 static int adt7470_update_limits(struct adt7470_data
*data
)
384 for (i
= 0; i
< ADT7470_TEMP_COUNT
; i
++) {
385 err
= regmap_read(data
->regmap
, ADT7470_TEMP_MIN_REG(i
), &val
);
388 data
->temp_min
[i
] = (s8
)val
;
389 err
= regmap_read(data
->regmap
, ADT7470_TEMP_MAX_REG(i
), &val
);
392 data
->temp_max
[i
] = (s8
)val
;
395 for (i
= 0; i
< ADT7470_FAN_COUNT
; i
++) {
396 err
= adt7470_read_word_data(data
, ADT7470_REG_FAN_MIN(i
), &val
);
399 data
->fan_min
[i
] = val
;
400 err
= adt7470_read_word_data(data
, ADT7470_REG_FAN_MAX(i
), &val
);
403 data
->fan_max
[i
] = val
;
406 for (i
= 0; i
< ADT7470_PWM_COUNT
; i
++) {
407 err
= regmap_read(data
->regmap
, ADT7470_REG_PWM_MAX(i
), &val
);
410 data
->pwm_max
[i
] = val
;
411 err
= regmap_read(data
->regmap
, ADT7470_REG_PWM_MIN(i
), &val
);
414 data
->pwm_min
[i
] = val
;
415 err
= regmap_read(data
->regmap
, ADT7470_REG_PWM_TMIN(i
), &val
);
418 data
->pwm_tmin
[i
] = (s8
)val
;
424 static struct adt7470_data
*adt7470_update_device(struct device
*dev
)
426 struct adt7470_data
*data
= dev_get_drvdata(dev
);
427 unsigned long local_jiffies
= jiffies
;
428 int need_sensors
= 1;
433 * Figure out if we need to update the shadow registers.
434 * Lockless means that we may occasionally report out of
437 if (time_before(local_jiffies
, data
->sensors_last_updated
+
438 SENSOR_REFRESH_INTERVAL
) &&
442 if (time_before(local_jiffies
, data
->limits_last_updated
+
443 LIMIT_REFRESH_INTERVAL
) &&
447 if (!need_sensors
&& !need_limits
)
450 mutex_lock(&data
->lock
);
452 err
= adt7470_update_sensors(data
);
455 data
->sensors_last_updated
= local_jiffies
;
456 data
->sensors_valid
= 1;
460 err
= adt7470_update_limits(data
);
463 data
->limits_last_updated
= local_jiffies
;
464 data
->limits_valid
= 1;
467 mutex_unlock(&data
->lock
);
469 return err
< 0 ? ERR_PTR(err
) : data
;
472 static ssize_t
auto_update_interval_show(struct device
*dev
,
473 struct device_attribute
*devattr
,
476 struct adt7470_data
*data
= adt7470_update_device(dev
);
479 return PTR_ERR(data
);
481 return sprintf(buf
, "%d\n", data
->auto_update_interval
);
484 static ssize_t
auto_update_interval_store(struct device
*dev
,
485 struct device_attribute
*devattr
,
486 const char *buf
, size_t count
)
488 struct adt7470_data
*data
= dev_get_drvdata(dev
);
491 if (kstrtol(buf
, 10, &temp
))
494 temp
= clamp_val(temp
, 0, 60000);
496 mutex_lock(&data
->lock
);
497 data
->auto_update_interval
= temp
;
498 mutex_unlock(&data
->lock
);
503 static ssize_t
num_temp_sensors_show(struct device
*dev
,
504 struct device_attribute
*devattr
,
507 struct adt7470_data
*data
= adt7470_update_device(dev
);
510 return PTR_ERR(data
);
512 return sprintf(buf
, "%d\n", data
->num_temp_sensors
);
515 static ssize_t
num_temp_sensors_store(struct device
*dev
,
516 struct device_attribute
*devattr
,
517 const char *buf
, size_t count
)
519 struct adt7470_data
*data
= dev_get_drvdata(dev
);
522 if (kstrtol(buf
, 10, &temp
))
525 temp
= clamp_val(temp
, -1, 10);
527 mutex_lock(&data
->lock
);
528 data
->num_temp_sensors
= temp
;
530 data
->temperatures_probed
= 0;
531 mutex_unlock(&data
->lock
);
536 static int adt7470_temp_read(struct device
*dev
, u32 attr
, int channel
, long *val
)
538 struct adt7470_data
*data
= adt7470_update_device(dev
);
541 return PTR_ERR(data
);
544 case hwmon_temp_input
:
545 *val
= 1000 * data
->temp
[channel
];
548 *val
= 1000 * data
->temp_min
[channel
];
551 *val
= 1000 * data
->temp_max
[channel
];
553 case hwmon_temp_alarm
:
554 *val
= !!(data
->alarm
& channel
);
563 static int adt7470_temp_write(struct device
*dev
, u32 attr
, int channel
, long val
)
565 struct adt7470_data
*data
= dev_get_drvdata(dev
);
568 val
= clamp_val(val
, -128000, 127000);
569 val
= DIV_ROUND_CLOSEST(val
, 1000);
573 mutex_lock(&data
->lock
);
574 data
->temp_min
[channel
] = val
;
575 err
= regmap_write(data
->regmap
, ADT7470_TEMP_MIN_REG(channel
), val
);
576 mutex_unlock(&data
->lock
);
579 mutex_lock(&data
->lock
);
580 data
->temp_max
[channel
] = val
;
581 err
= regmap_write(data
->regmap
, ADT7470_TEMP_MAX_REG(channel
), val
);
582 mutex_unlock(&data
->lock
);
591 static ssize_t
alarm_mask_show(struct device
*dev
,
592 struct device_attribute
*devattr
, char *buf
)
594 struct adt7470_data
*data
= adt7470_update_device(dev
);
597 return PTR_ERR(data
);
599 return sprintf(buf
, "%x\n", data
->alarms_mask
);
602 static ssize_t
alarm_mask_store(struct device
*dev
,
603 struct device_attribute
*devattr
,
604 const char *buf
, size_t count
)
606 struct adt7470_data
*data
= dev_get_drvdata(dev
);
610 if (kstrtoul(buf
, 0, &mask
))
616 mutex_lock(&data
->lock
);
617 data
->alarms_mask
= mask
;
618 err
= adt7470_write_word_data(data
, ADT7470_REG_ALARM1_MASK
, mask
);
619 mutex_unlock(&data
->lock
);
621 return err
< 0 ? err
: count
;
624 static int adt7470_fan_read(struct device
*dev
, u32 attr
, int channel
, long *val
)
626 struct adt7470_data
*data
= adt7470_update_device(dev
);
629 return PTR_ERR(data
);
632 case hwmon_fan_input
:
633 if (FAN_DATA_VALID(data
->fan
[channel
]))
634 *val
= FAN_PERIOD_TO_RPM(data
->fan
[channel
]);
639 if (FAN_DATA_VALID(data
->fan_min
[channel
]))
640 *val
= FAN_PERIOD_TO_RPM(data
->fan_min
[channel
]);
645 if (FAN_DATA_VALID(data
->fan_max
[channel
]))
646 *val
= FAN_PERIOD_TO_RPM(data
->fan_max
[channel
]);
650 case hwmon_fan_alarm
:
651 *val
= !!(data
->alarm
& (1 << (12 + channel
)));
660 static int adt7470_fan_write(struct device
*dev
, u32 attr
, int channel
, long val
)
662 struct adt7470_data
*data
= dev_get_drvdata(dev
);
668 val
= FAN_RPM_TO_PERIOD(val
);
669 val
= clamp_val(val
, 1, 65534);
673 mutex_lock(&data
->lock
);
674 data
->fan_min
[channel
] = val
;
675 err
= adt7470_write_word_data(data
, ADT7470_REG_FAN_MIN(channel
), val
);
676 mutex_unlock(&data
->lock
);
679 mutex_lock(&data
->lock
);
680 data
->fan_max
[channel
] = val
;
681 err
= adt7470_write_word_data(data
, ADT7470_REG_FAN_MAX(channel
), val
);
682 mutex_unlock(&data
->lock
);
691 static ssize_t
force_pwm_max_show(struct device
*dev
,
692 struct device_attribute
*devattr
, char *buf
)
694 struct adt7470_data
*data
= adt7470_update_device(dev
);
697 return PTR_ERR(data
);
699 return sprintf(buf
, "%d\n", data
->force_pwm_max
);
702 static ssize_t
force_pwm_max_store(struct device
*dev
,
703 struct device_attribute
*devattr
,
704 const char *buf
, size_t count
)
706 struct adt7470_data
*data
= dev_get_drvdata(dev
);
710 if (kstrtol(buf
, 10, &temp
))
713 mutex_lock(&data
->lock
);
714 data
->force_pwm_max
= temp
;
715 err
= regmap_update_bits(data
->regmap
, ADT7470_REG_CFG
,
717 temp
? ADT7470_FSPD_MASK
: 0);
718 mutex_unlock(&data
->lock
);
720 return err
< 0 ? err
: count
;
723 /* These are the valid PWM frequencies to the nearest Hz */
724 static const int adt7470_freq_map
[] = {
725 11, 15, 22, 29, 35, 44, 59, 88, 1400, 22500
728 static int pwm1_freq_get(struct device
*dev
)
730 struct adt7470_data
*data
= dev_get_drvdata(dev
);
731 unsigned int cfg_reg_1
, cfg_reg_2
;
735 mutex_lock(&data
->lock
);
736 err
= regmap_read(data
->regmap
, ADT7470_REG_CFG
, &cfg_reg_1
);
739 err
= regmap_read(data
->regmap
, ADT7470_REG_CFG_2
, &cfg_reg_2
);
742 mutex_unlock(&data
->lock
);
744 index
= (cfg_reg_2
& ADT7470_FREQ_MASK
) >> ADT7470_FREQ_SHIFT
;
745 if (!(cfg_reg_1
& ADT7470_CFG_LF
))
747 if (index
>= ARRAY_SIZE(adt7470_freq_map
))
748 index
= ARRAY_SIZE(adt7470_freq_map
) - 1;
750 return adt7470_freq_map
[index
];
753 mutex_unlock(&data
->lock
);
757 static int adt7470_pwm_read(struct device
*dev
, u32 attr
, int channel
, long *val
)
759 struct adt7470_data
*data
= adt7470_update_device(dev
);
762 return PTR_ERR(data
);
765 case hwmon_pwm_input
:
766 *val
= data
->pwm
[channel
];
768 case hwmon_pwm_enable
:
769 *val
= 1 + data
->pwm_automatic
[channel
];
772 *val
= pwm1_freq_get(dev
);
781 static int pwm1_freq_set(struct device
*dev
, long freq
)
783 struct adt7470_data
*data
= dev_get_drvdata(dev
);
784 unsigned int low_freq
= ADT7470_CFG_LF
;
788 /* Round the user value given to the closest available frequency */
789 index
= find_closest(freq
, adt7470_freq_map
,
790 ARRAY_SIZE(adt7470_freq_map
));
797 mutex_lock(&data
->lock
);
798 /* Configuration Register 1 */
799 err
= regmap_update_bits(data
->regmap
, ADT7470_REG_CFG
,
800 ADT7470_CFG_LF
, low_freq
);
804 /* Configuration Register 2 */
805 err
= regmap_update_bits(data
->regmap
, ADT7470_REG_CFG_2
,
807 index
<< ADT7470_FREQ_SHIFT
);
809 mutex_unlock(&data
->lock
);
814 static int adt7470_pwm_write(struct device
*dev
, u32 attr
, int channel
, long val
)
816 struct adt7470_data
*data
= dev_get_drvdata(dev
);
817 unsigned int pwm_auto_reg_mask
;
821 case hwmon_pwm_input
:
822 val
= clamp_val(val
, 0, 255);
823 mutex_lock(&data
->lock
);
824 data
->pwm
[channel
] = val
;
825 err
= regmap_write(data
->regmap
, ADT7470_REG_PWM(channel
),
827 mutex_unlock(&data
->lock
);
829 case hwmon_pwm_enable
:
831 pwm_auto_reg_mask
= ADT7470_PWM2_AUTO_MASK
;
833 pwm_auto_reg_mask
= ADT7470_PWM1_AUTO_MASK
;
835 if (val
!= 2 && val
!= 1)
839 mutex_lock(&data
->lock
);
840 data
->pwm_automatic
[channel
] = val
;
841 err
= regmap_update_bits(data
->regmap
, ADT7470_REG_PWM_CFG(channel
),
843 val
? pwm_auto_reg_mask
: 0);
844 mutex_unlock(&data
->lock
);
847 err
= pwm1_freq_set(dev
, val
);
856 static ssize_t
pwm_max_show(struct device
*dev
,
857 struct device_attribute
*devattr
, char *buf
)
859 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
860 struct adt7470_data
*data
= adt7470_update_device(dev
);
863 return PTR_ERR(data
);
865 return sprintf(buf
, "%d\n", data
->pwm_max
[attr
->index
]);
868 static ssize_t
pwm_max_store(struct device
*dev
,
869 struct device_attribute
*devattr
,
870 const char *buf
, size_t count
)
872 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
873 struct adt7470_data
*data
= dev_get_drvdata(dev
);
877 if (kstrtol(buf
, 10, &temp
))
880 temp
= clamp_val(temp
, 0, 255);
882 mutex_lock(&data
->lock
);
883 data
->pwm_max
[attr
->index
] = temp
;
884 err
= regmap_write(data
->regmap
, ADT7470_REG_PWM_MAX(attr
->index
),
886 mutex_unlock(&data
->lock
);
888 return err
< 0 ? err
: count
;
891 static ssize_t
pwm_min_show(struct device
*dev
,
892 struct device_attribute
*devattr
, char *buf
)
894 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
895 struct adt7470_data
*data
= adt7470_update_device(dev
);
898 return PTR_ERR(data
);
900 return sprintf(buf
, "%d\n", data
->pwm_min
[attr
->index
]);
903 static ssize_t
pwm_min_store(struct device
*dev
,
904 struct device_attribute
*devattr
,
905 const char *buf
, size_t count
)
907 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
908 struct adt7470_data
*data
= dev_get_drvdata(dev
);
912 if (kstrtol(buf
, 10, &temp
))
915 temp
= clamp_val(temp
, 0, 255);
917 mutex_lock(&data
->lock
);
918 data
->pwm_min
[attr
->index
] = temp
;
919 err
= regmap_write(data
->regmap
, ADT7470_REG_PWM_MIN(attr
->index
),
921 mutex_unlock(&data
->lock
);
923 return err
< 0 ? err
: count
;
926 static ssize_t
pwm_tmax_show(struct device
*dev
,
927 struct device_attribute
*devattr
, char *buf
)
929 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
930 struct adt7470_data
*data
= adt7470_update_device(dev
);
933 return PTR_ERR(data
);
935 /* the datasheet says that tmax = tmin + 20C */
936 return sprintf(buf
, "%d\n", 1000 * (20 + data
->pwm_tmin
[attr
->index
]));
939 static ssize_t
pwm_tmin_show(struct device
*dev
,
940 struct device_attribute
*devattr
, char *buf
)
942 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
943 struct adt7470_data
*data
= adt7470_update_device(dev
);
946 return PTR_ERR(data
);
948 return sprintf(buf
, "%d\n", 1000 * data
->pwm_tmin
[attr
->index
]);
951 static ssize_t
pwm_tmin_store(struct device
*dev
,
952 struct device_attribute
*devattr
,
953 const char *buf
, size_t count
)
955 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
956 struct adt7470_data
*data
= dev_get_drvdata(dev
);
960 if (kstrtol(buf
, 10, &temp
))
963 temp
= clamp_val(temp
, -128000, 127000);
964 temp
= DIV_ROUND_CLOSEST(temp
, 1000);
966 mutex_lock(&data
->lock
);
967 data
->pwm_tmin
[attr
->index
] = temp
;
968 err
= regmap_write(data
->regmap
, ADT7470_REG_PWM_TMIN(attr
->index
),
970 mutex_unlock(&data
->lock
);
972 return err
< 0 ? err
: count
;
975 static ssize_t
pwm_auto_temp_show(struct device
*dev
,
976 struct device_attribute
*devattr
, char *buf
)
978 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
979 struct adt7470_data
*data
= adt7470_update_device(dev
);
983 return PTR_ERR(data
);
985 ctrl
= data
->pwm_auto_temp
[attr
->index
];
987 return sprintf(buf
, "%d\n", 1 << (ctrl
- 1));
989 return sprintf(buf
, "%d\n", ADT7470_PWM_ALL_TEMPS
);
992 static int cvt_auto_temp(int input
)
994 if (input
== ADT7470_PWM_ALL_TEMPS
)
996 if (input
< 1 || !is_power_of_2(input
))
998 return ilog2(input
) + 1;
1001 static ssize_t
pwm_auto_temp_store(struct device
*dev
,
1002 struct device_attribute
*devattr
,
1003 const char *buf
, size_t count
)
1005 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
1006 struct adt7470_data
*data
= dev_get_drvdata(dev
);
1007 int pwm_auto_reg
= ADT7470_REG_PWM_AUTO_TEMP(attr
->index
);
1008 unsigned int mask
, val
;
1012 if (kstrtol(buf
, 10, &temp
))
1015 temp
= cvt_auto_temp(temp
);
1019 mutex_lock(&data
->lock
);
1020 data
->pwm_automatic
[attr
->index
] = temp
;
1022 if (!(attr
->index
% 2)) {
1024 val
= (temp
<< 4) & 0xF0;
1030 err
= regmap_update_bits(data
->regmap
, pwm_auto_reg
, mask
, val
);
1031 mutex_unlock(&data
->lock
);
1033 return err
< 0 ? err
: count
;
1036 static DEVICE_ATTR_RW(alarm_mask
);
1037 static DEVICE_ATTR_RW(num_temp_sensors
);
1038 static DEVICE_ATTR_RW(auto_update_interval
);
1040 static SENSOR_DEVICE_ATTR_RW(force_pwm_max
, force_pwm_max
, 0);
1042 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm
, pwm_min
, 0);
1043 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm
, pwm_min
, 1);
1044 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm
, pwm_min
, 2);
1045 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm
, pwm_min
, 3);
1047 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm
, pwm_max
, 0);
1048 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm
, pwm_max
, 1);
1049 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm
, pwm_max
, 2);
1050 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm
, pwm_max
, 3);
1052 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_temp
, pwm_tmin
, 0);
1053 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_temp
, pwm_tmin
, 1);
1054 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_temp
, pwm_tmin
, 2);
1055 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_temp
, pwm_tmin
, 3);
1057 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point2_temp
, pwm_tmax
, 0);
1058 static SENSOR_DEVICE_ATTR_RO(pwm2_auto_point2_temp
, pwm_tmax
, 1);
1059 static SENSOR_DEVICE_ATTR_RO(pwm3_auto_point2_temp
, pwm_tmax
, 2);
1060 static SENSOR_DEVICE_ATTR_RO(pwm4_auto_point2_temp
, pwm_tmax
, 3);
1062 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp
, pwm_auto_temp
, 0);
1063 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp
, pwm_auto_temp
, 1);
1064 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp
, pwm_auto_temp
, 2);
1065 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp
, pwm_auto_temp
, 3);
1067 static struct attribute
*adt7470_attrs
[] = {
1068 &dev_attr_alarm_mask
.attr
,
1069 &dev_attr_num_temp_sensors
.attr
,
1070 &dev_attr_auto_update_interval
.attr
,
1071 &sensor_dev_attr_force_pwm_max
.dev_attr
.attr
,
1072 &sensor_dev_attr_pwm1_auto_point1_pwm
.dev_attr
.attr
,
1073 &sensor_dev_attr_pwm2_auto_point1_pwm
.dev_attr
.attr
,
1074 &sensor_dev_attr_pwm3_auto_point1_pwm
.dev_attr
.attr
,
1075 &sensor_dev_attr_pwm4_auto_point1_pwm
.dev_attr
.attr
,
1076 &sensor_dev_attr_pwm1_auto_point2_pwm
.dev_attr
.attr
,
1077 &sensor_dev_attr_pwm2_auto_point2_pwm
.dev_attr
.attr
,
1078 &sensor_dev_attr_pwm3_auto_point2_pwm
.dev_attr
.attr
,
1079 &sensor_dev_attr_pwm4_auto_point2_pwm
.dev_attr
.attr
,
1080 &sensor_dev_attr_pwm1_auto_point1_temp
.dev_attr
.attr
,
1081 &sensor_dev_attr_pwm2_auto_point1_temp
.dev_attr
.attr
,
1082 &sensor_dev_attr_pwm3_auto_point1_temp
.dev_attr
.attr
,
1083 &sensor_dev_attr_pwm4_auto_point1_temp
.dev_attr
.attr
,
1084 &sensor_dev_attr_pwm1_auto_point2_temp
.dev_attr
.attr
,
1085 &sensor_dev_attr_pwm2_auto_point2_temp
.dev_attr
.attr
,
1086 &sensor_dev_attr_pwm3_auto_point2_temp
.dev_attr
.attr
,
1087 &sensor_dev_attr_pwm4_auto_point2_temp
.dev_attr
.attr
,
1088 &sensor_dev_attr_pwm1_auto_channels_temp
.dev_attr
.attr
,
1089 &sensor_dev_attr_pwm2_auto_channels_temp
.dev_attr
.attr
,
1090 &sensor_dev_attr_pwm3_auto_channels_temp
.dev_attr
.attr
,
1091 &sensor_dev_attr_pwm4_auto_channels_temp
.dev_attr
.attr
,
1095 ATTRIBUTE_GROUPS(adt7470
);
1097 static int adt7470_read(struct device
*dev
, enum hwmon_sensor_types type
, u32 attr
,
1098 int channel
, long *val
)
1102 return adt7470_temp_read(dev
, attr
, channel
, val
);
1104 return adt7470_fan_read(dev
, attr
, channel
, val
);
1106 return adt7470_pwm_read(dev
, attr
, channel
, val
);
1112 static int adt7470_write(struct device
*dev
, enum hwmon_sensor_types type
, u32 attr
,
1113 int channel
, long val
)
1117 return adt7470_temp_write(dev
, attr
, channel
, val
);
1119 return adt7470_fan_write(dev
, attr
, channel
, val
);
1121 return adt7470_pwm_write(dev
, attr
, channel
, val
);
1127 static umode_t
adt7470_is_visible(const void *_data
, enum hwmon_sensor_types type
,
1128 u32 attr
, int channel
)
1136 case hwmon_temp_alarm
:
1139 case hwmon_temp_min
:
1140 case hwmon_temp_max
:
1149 case hwmon_fan_input
:
1150 case hwmon_fan_alarm
:
1163 case hwmon_pwm_input
:
1164 case hwmon_pwm_enable
:
1167 case hwmon_pwm_freq
:
1184 static const struct hwmon_ops adt7470_hwmon_ops
= {
1185 .is_visible
= adt7470_is_visible
,
1186 .read
= adt7470_read
,
1187 .write
= adt7470_write
,
1190 static const struct hwmon_channel_info
*adt7470_info
[] = {
1191 HWMON_CHANNEL_INFO(temp
,
1192 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
,
1193 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
,
1194 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
,
1195 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
,
1196 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
,
1197 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
,
1198 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
,
1199 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
,
1200 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
,
1201 HWMON_T_INPUT
| HWMON_T_MIN
| HWMON_T_MAX
| HWMON_T_ALARM
),
1202 HWMON_CHANNEL_INFO(fan
,
1203 HWMON_F_INPUT
| HWMON_F_MIN
| HWMON_F_MAX
| HWMON_F_DIV
| HWMON_F_ALARM
,
1204 HWMON_F_INPUT
| HWMON_F_MIN
| HWMON_F_MAX
| HWMON_F_DIV
| HWMON_F_ALARM
,
1205 HWMON_F_INPUT
| HWMON_F_MIN
| HWMON_F_MAX
| HWMON_F_DIV
| HWMON_F_ALARM
,
1206 HWMON_F_INPUT
| HWMON_F_MIN
| HWMON_F_MAX
| HWMON_F_DIV
| HWMON_F_ALARM
),
1207 HWMON_CHANNEL_INFO(pwm
,
1208 HWMON_PWM_INPUT
| HWMON_PWM_ENABLE
| HWMON_PWM_FREQ
,
1209 HWMON_PWM_INPUT
| HWMON_PWM_ENABLE
,
1210 HWMON_PWM_INPUT
| HWMON_PWM_ENABLE
,
1211 HWMON_PWM_INPUT
| HWMON_PWM_ENABLE
),
1215 static const struct hwmon_chip_info adt7470_chip_info
= {
1216 .ops
= &adt7470_hwmon_ops
,
1217 .info
= adt7470_info
,
1220 /* Return 0 if detection is successful, -ENODEV otherwise */
1221 static int adt7470_detect(struct i2c_client
*client
,
1222 struct i2c_board_info
*info
)
1224 struct i2c_adapter
*adapter
= client
->adapter
;
1225 int vendor
, device
, revision
;
1227 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
1230 vendor
= i2c_smbus_read_byte_data(client
, ADT7470_REG_VENDOR
);
1231 if (vendor
!= ADT7470_VENDOR
)
1234 device
= i2c_smbus_read_byte_data(client
, ADT7470_REG_DEVICE
);
1235 if (device
!= ADT7470_DEVICE
)
1238 revision
= i2c_smbus_read_byte_data(client
, ADT7470_REG_REVISION
);
1239 if (revision
!= ADT7470_REVISION
)
1242 strscpy(info
->type
, "adt7470", I2C_NAME_SIZE
);
1247 static const struct regmap_config adt7470_regmap_config
= {
1250 .use_single_read
= true,
1251 .use_single_write
= true,
1254 static int adt7470_probe(struct i2c_client
*client
)
1256 struct device
*dev
= &client
->dev
;
1257 struct adt7470_data
*data
;
1258 struct device
*hwmon_dev
;
1261 data
= devm_kzalloc(dev
, sizeof(struct adt7470_data
), GFP_KERNEL
);
1265 data
->num_temp_sensors
= -1;
1266 data
->auto_update_interval
= AUTO_UPDATE_INTERVAL
;
1267 data
->regmap
= devm_regmap_init_i2c(client
, &adt7470_regmap_config
);
1268 if (IS_ERR(data
->regmap
))
1269 return PTR_ERR(data
->regmap
);
1271 i2c_set_clientdata(client
, data
);
1272 mutex_init(&data
->lock
);
1274 dev_info(&client
->dev
, "%s chip found\n", client
->name
);
1276 /* Initialize the ADT7470 chip */
1277 err
= regmap_update_bits(data
->regmap
, ADT7470_REG_CFG
,
1278 ADT7470_STRT_MASK
| ADT7470_TEST_MASK
,
1279 ADT7470_STRT_MASK
| ADT7470_TEST_MASK
);
1283 /* Register sysfs hooks */
1284 hwmon_dev
= devm_hwmon_device_register_with_info(dev
, client
->name
, data
,
1288 if (IS_ERR(hwmon_dev
))
1289 return PTR_ERR(hwmon_dev
);
1291 data
->auto_update
= kthread_run(adt7470_update_thread
, client
, "%s",
1292 dev_name(hwmon_dev
));
1293 if (IS_ERR(data
->auto_update
))
1294 return PTR_ERR(data
->auto_update
);
1299 static int adt7470_remove(struct i2c_client
*client
)
1301 struct adt7470_data
*data
= i2c_get_clientdata(client
);
1303 kthread_stop(data
->auto_update
);
1307 static const struct i2c_device_id adt7470_id
[] = {
1311 MODULE_DEVICE_TABLE(i2c
, adt7470_id
);
1313 static struct i2c_driver adt7470_driver
= {
1314 .class = I2C_CLASS_HWMON
,
1318 .probe_new
= adt7470_probe
,
1319 .remove
= adt7470_remove
,
1320 .id_table
= adt7470_id
,
1321 .detect
= adt7470_detect
,
1322 .address_list
= normal_i2c
,
1325 module_i2c_driver(adt7470_driver
);
1327 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1328 MODULE_DESCRIPTION("ADT7470 driver");
1329 MODULE_LICENSE("GPL");