2 * A hwmon driver for the Analog Devices ADT7470
3 * Copyright (C) 2007 IBM
5 * Author: Darrick J. Wong <darrick.wong@oracle.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 #include <linux/module.h>
25 #include <linux/jiffies.h>
26 #include <linux/i2c.h>
27 #include <linux/hwmon.h>
28 #include <linux/hwmon-sysfs.h>
29 #include <linux/err.h>
30 #include <linux/mutex.h>
31 #include <linux/delay.h>
32 #include <linux/log2.h>
33 #include <linux/kthread.h>
34 #include <linux/slab.h>
35 #include <linux/util_macros.h>
37 /* Addresses to scan */
38 static const unsigned short normal_i2c
[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END
};
40 /* ADT7470 registers */
41 #define ADT7470_REG_BASE_ADDR 0x20
42 #define ADT7470_REG_TEMP_BASE_ADDR 0x20
43 #define ADT7470_REG_TEMP_MAX_ADDR 0x29
44 #define ADT7470_REG_FAN_BASE_ADDR 0x2A
45 #define ADT7470_REG_FAN_MAX_ADDR 0x31
46 #define ADT7470_REG_PWM_BASE_ADDR 0x32
47 #define ADT7470_REG_PWM_MAX_ADDR 0x35
48 #define ADT7470_REG_PWM_MAX_BASE_ADDR 0x38
49 #define ADT7470_REG_PWM_MAX_MAX_ADDR 0x3B
50 #define ADT7470_REG_CFG 0x40
51 #define ADT7470_FSPD_MASK 0x04
52 #define ADT7470_REG_ALARM1 0x41
53 #define ADT7470_R1T_ALARM 0x01
54 #define ADT7470_R2T_ALARM 0x02
55 #define ADT7470_R3T_ALARM 0x04
56 #define ADT7470_R4T_ALARM 0x08
57 #define ADT7470_R5T_ALARM 0x10
58 #define ADT7470_R6T_ALARM 0x20
59 #define ADT7470_R7T_ALARM 0x40
60 #define ADT7470_OOL_ALARM 0x80
61 #define ADT7470_REG_ALARM2 0x42
62 #define ADT7470_R8T_ALARM 0x01
63 #define ADT7470_R9T_ALARM 0x02
64 #define ADT7470_R10T_ALARM 0x04
65 #define ADT7470_FAN1_ALARM 0x10
66 #define ADT7470_FAN2_ALARM 0x20
67 #define ADT7470_FAN3_ALARM 0x40
68 #define ADT7470_FAN4_ALARM 0x80
69 #define ADT7470_REG_TEMP_LIMITS_BASE_ADDR 0x44
70 #define ADT7470_REG_TEMP_LIMITS_MAX_ADDR 0x57
71 #define ADT7470_REG_FAN_MIN_BASE_ADDR 0x58
72 #define ADT7470_REG_FAN_MIN_MAX_ADDR 0x5F
73 #define ADT7470_REG_FAN_MAX_BASE_ADDR 0x60
74 #define ADT7470_REG_FAN_MAX_MAX_ADDR 0x67
75 #define ADT7470_REG_PWM_CFG_BASE_ADDR 0x68
76 #define ADT7470_REG_PWM12_CFG 0x68
77 #define ADT7470_PWM2_AUTO_MASK 0x40
78 #define ADT7470_PWM1_AUTO_MASK 0x80
79 #define ADT7470_PWM_AUTO_MASK 0xC0
80 #define ADT7470_REG_PWM34_CFG 0x69
81 #define ADT7470_PWM3_AUTO_MASK 0x40
82 #define ADT7470_PWM4_AUTO_MASK 0x80
83 #define ADT7470_REG_PWM_MIN_BASE_ADDR 0x6A
84 #define ADT7470_REG_PWM_MIN_MAX_ADDR 0x6D
85 #define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR 0x6E
86 #define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR 0x71
87 #define ADT7470_REG_CFG_2 0x74
88 #define ADT7470_REG_ACOUSTICS12 0x75
89 #define ADT7470_REG_ACOUSTICS34 0x76
90 #define ADT7470_REG_DEVICE 0x3D
91 #define ADT7470_REG_VENDOR 0x3E
92 #define ADT7470_REG_REVISION 0x3F
93 #define ADT7470_REG_ALARM1_MASK 0x72
94 #define ADT7470_REG_ALARM2_MASK 0x73
95 #define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR 0x7C
96 #define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR 0x7D
97 #define ADT7470_REG_MAX_ADDR 0x81
99 #define ADT7470_TEMP_COUNT 10
100 #define ADT7470_TEMP_REG(x) (ADT7470_REG_TEMP_BASE_ADDR + (x))
101 #define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
102 #define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \
105 #define ADT7470_FAN_COUNT 4
106 #define ADT7470_REG_FAN(x) (ADT7470_REG_FAN_BASE_ADDR + ((x) * 2))
107 #define ADT7470_REG_FAN_MIN(x) (ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
108 #define ADT7470_REG_FAN_MAX(x) (ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2))
110 #define ADT7470_PWM_COUNT 4
111 #define ADT7470_REG_PWM(x) (ADT7470_REG_PWM_BASE_ADDR + (x))
112 #define ADT7470_REG_PWM_MAX(x) (ADT7470_REG_PWM_MAX_BASE_ADDR + (x))
113 #define ADT7470_REG_PWM_MIN(x) (ADT7470_REG_PWM_MIN_BASE_ADDR + (x))
114 #define ADT7470_REG_PWM_TMIN(x) (ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
115 #define ADT7470_REG_PWM_CFG(x) (ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2))
116 #define ADT7470_REG_PWM_AUTO_TEMP(x) (ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \
119 #define ALARM2(x) ((x) << 8)
121 #define ADT7470_VENDOR 0x41
122 #define ADT7470_DEVICE 0x70
123 /* datasheet only mentions a revision 2 */
124 #define ADT7470_REVISION 0x02
126 /* "all temps" according to hwmon sysfs interface spec */
127 #define ADT7470_PWM_ALL_TEMPS 0x3FF
129 /* How often do we reread sensors values? (In jiffies) */
130 #define SENSOR_REFRESH_INTERVAL (5 * HZ)
132 /* How often do we reread sensor limit values? (In jiffies) */
133 #define LIMIT_REFRESH_INTERVAL (60 * HZ)
135 /* Wait at least 200ms per sensor for 10 sensors */
136 #define TEMP_COLLECTION_TIME 2000
138 /* auto update thing won't fire more than every 2s */
139 #define AUTO_UPDATE_INTERVAL 2000
141 /* datasheet says to divide this number by the fan reading to get fan rpm */
142 #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
143 #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
144 #define FAN_PERIOD_INVALID 65535
145 #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
147 /* Config registers 1 and 2 include fields for selecting the PWM frequency */
148 #define ADT7470_CFG_LF 0x40
149 #define ADT7470_FREQ_MASK 0x70
150 #define ADT7470_FREQ_SHIFT 4
152 struct adt7470_data
{
153 struct i2c_client
*client
;
157 unsigned long sensors_last_updated
; /* In jiffies */
158 unsigned long limits_last_updated
; /* In jiffies */
160 int num_temp_sensors
; /* -1 = probe */
161 int temperatures_probed
;
163 s8 temp
[ADT7470_TEMP_COUNT
];
164 s8 temp_min
[ADT7470_TEMP_COUNT
];
165 s8 temp_max
[ADT7470_TEMP_COUNT
];
166 u16 fan
[ADT7470_FAN_COUNT
];
167 u16 fan_min
[ADT7470_FAN_COUNT
];
168 u16 fan_max
[ADT7470_FAN_COUNT
];
172 u8 pwm
[ADT7470_PWM_COUNT
];
173 u8 pwm_max
[ADT7470_PWM_COUNT
];
174 u8 pwm_automatic
[ADT7470_PWM_COUNT
];
175 u8 pwm_min
[ADT7470_PWM_COUNT
];
176 s8 pwm_tmin
[ADT7470_PWM_COUNT
];
177 u8 pwm_auto_temp
[ADT7470_PWM_COUNT
];
179 struct task_struct
*auto_update
;
180 struct completion auto_update_stop
;
181 unsigned int auto_update_interval
;
185 * 16-bit registers on the ADT7470 are low-byte first. The data sheet says
186 * that the low byte must be read before the high byte.
188 static inline int adt7470_read_word_data(struct i2c_client
*client
, u8 reg
)
191 foo
= i2c_smbus_read_byte_data(client
, reg
);
192 foo
|= ((u16
)i2c_smbus_read_byte_data(client
, reg
+ 1) << 8);
196 static inline int adt7470_write_word_data(struct i2c_client
*client
, u8 reg
,
199 return i2c_smbus_write_byte_data(client
, reg
, value
& 0xFF)
200 || i2c_smbus_write_byte_data(client
, reg
+ 1, value
>> 8);
203 /* Probe for temperature sensors. Assumes lock is held */
204 static int adt7470_read_temperatures(struct i2c_client
*client
,
205 struct adt7470_data
*data
)
209 u8 cfg
, pwm
[4], pwm_cfg
[2];
211 /* save pwm[1-4] config register */
212 pwm_cfg
[0] = i2c_smbus_read_byte_data(client
, ADT7470_REG_PWM_CFG(0));
213 pwm_cfg
[1] = i2c_smbus_read_byte_data(client
, ADT7470_REG_PWM_CFG(2));
215 /* set manual pwm to whatever it is set to now */
216 for (i
= 0; i
< ADT7470_FAN_COUNT
; i
++)
217 pwm
[i
] = i2c_smbus_read_byte_data(client
, ADT7470_REG_PWM(i
));
219 /* put pwm in manual mode */
220 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_CFG(0),
221 pwm_cfg
[0] & ~(ADT7470_PWM_AUTO_MASK
));
222 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_CFG(2),
223 pwm_cfg
[1] & ~(ADT7470_PWM_AUTO_MASK
));
225 /* write pwm control to whatever it was */
226 for (i
= 0; i
< ADT7470_FAN_COUNT
; i
++)
227 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM(i
), pwm
[i
]);
229 /* start reading temperature sensors */
230 cfg
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
);
232 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG
, cfg
);
234 /* Delay is 200ms * number of temp sensors. */
235 res
= msleep_interruptible((data
->num_temp_sensors
>= 0 ?
236 data
->num_temp_sensors
* 200 :
237 TEMP_COLLECTION_TIME
));
239 /* done reading temperature sensors */
240 cfg
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
);
242 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG
, cfg
);
244 /* restore pwm[1-4] config registers */
245 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_CFG(0), pwm_cfg
[0]);
246 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_CFG(2), pwm_cfg
[1]);
249 pr_err("ha ha, interrupted\n");
253 /* Only count fans if we have to */
254 if (data
->num_temp_sensors
>= 0)
257 for (i
= 0; i
< ADT7470_TEMP_COUNT
; i
++) {
258 data
->temp
[i
] = i2c_smbus_read_byte_data(client
,
259 ADT7470_TEMP_REG(i
));
261 data
->num_temp_sensors
= i
+ 1;
263 data
->temperatures_probed
= 1;
267 static int adt7470_update_thread(void *p
)
269 struct i2c_client
*client
= p
;
270 struct adt7470_data
*data
= i2c_get_clientdata(client
);
272 while (!kthread_should_stop()) {
273 mutex_lock(&data
->lock
);
274 adt7470_read_temperatures(client
, data
);
275 mutex_unlock(&data
->lock
);
277 set_current_state(TASK_INTERRUPTIBLE
);
278 if (kthread_should_stop())
281 schedule_timeout(msecs_to_jiffies(data
->auto_update_interval
));
284 complete_all(&data
->auto_update_stop
);
288 static struct adt7470_data
*adt7470_update_device(struct device
*dev
)
290 struct adt7470_data
*data
= dev_get_drvdata(dev
);
291 struct i2c_client
*client
= data
->client
;
292 unsigned long local_jiffies
= jiffies
;
295 int need_sensors
= 1;
299 * Figure out if we need to update the shadow registers.
300 * Lockless means that we may occasionally report out of
303 if (time_before(local_jiffies
, data
->sensors_last_updated
+
304 SENSOR_REFRESH_INTERVAL
) &&
308 if (time_before(local_jiffies
, data
->limits_last_updated
+
309 LIMIT_REFRESH_INTERVAL
) &&
313 if (!need_sensors
&& !need_limits
)
316 mutex_lock(&data
->lock
);
318 goto no_sensor_update
;
320 if (!data
->temperatures_probed
)
321 adt7470_read_temperatures(client
, data
);
323 for (i
= 0; i
< ADT7470_TEMP_COUNT
; i
++)
324 data
->temp
[i
] = i2c_smbus_read_byte_data(client
,
325 ADT7470_TEMP_REG(i
));
327 for (i
= 0; i
< ADT7470_FAN_COUNT
; i
++)
328 data
->fan
[i
] = adt7470_read_word_data(client
,
331 for (i
= 0; i
< ADT7470_PWM_COUNT
; i
++) {
335 data
->pwm
[i
] = i2c_smbus_read_byte_data(client
,
339 reg_mask
= ADT7470_PWM2_AUTO_MASK
;
341 reg_mask
= ADT7470_PWM1_AUTO_MASK
;
343 reg
= ADT7470_REG_PWM_CFG(i
);
344 if (i2c_smbus_read_byte_data(client
, reg
) & reg_mask
)
345 data
->pwm_automatic
[i
] = 1;
347 data
->pwm_automatic
[i
] = 0;
349 reg
= ADT7470_REG_PWM_AUTO_TEMP(i
);
350 cfg
= i2c_smbus_read_byte_data(client
, reg
);
352 data
->pwm_auto_temp
[i
] = cfg
>> 4;
354 data
->pwm_auto_temp
[i
] = cfg
& 0xF;
357 if (i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
) &
359 data
->force_pwm_max
= 1;
361 data
->force_pwm_max
= 0;
363 data
->alarm
= i2c_smbus_read_byte_data(client
, ADT7470_REG_ALARM1
);
364 if (data
->alarm
& ADT7470_OOL_ALARM
)
365 data
->alarm
|= ALARM2(i2c_smbus_read_byte_data(client
,
366 ADT7470_REG_ALARM2
));
367 data
->alarms_mask
= adt7470_read_word_data(client
,
368 ADT7470_REG_ALARM1_MASK
);
370 data
->sensors_last_updated
= local_jiffies
;
371 data
->sensors_valid
= 1;
377 for (i
= 0; i
< ADT7470_TEMP_COUNT
; i
++) {
378 data
->temp_min
[i
] = i2c_smbus_read_byte_data(client
,
379 ADT7470_TEMP_MIN_REG(i
));
380 data
->temp_max
[i
] = i2c_smbus_read_byte_data(client
,
381 ADT7470_TEMP_MAX_REG(i
));
384 for (i
= 0; i
< ADT7470_FAN_COUNT
; i
++) {
385 data
->fan_min
[i
] = adt7470_read_word_data(client
,
386 ADT7470_REG_FAN_MIN(i
));
387 data
->fan_max
[i
] = adt7470_read_word_data(client
,
388 ADT7470_REG_FAN_MAX(i
));
391 for (i
= 0; i
< ADT7470_PWM_COUNT
; i
++) {
392 data
->pwm_max
[i
] = i2c_smbus_read_byte_data(client
,
393 ADT7470_REG_PWM_MAX(i
));
394 data
->pwm_min
[i
] = i2c_smbus_read_byte_data(client
,
395 ADT7470_REG_PWM_MIN(i
));
396 data
->pwm_tmin
[i
] = i2c_smbus_read_byte_data(client
,
397 ADT7470_REG_PWM_TMIN(i
));
400 data
->limits_last_updated
= local_jiffies
;
401 data
->limits_valid
= 1;
404 mutex_unlock(&data
->lock
);
408 static ssize_t
show_auto_update_interval(struct device
*dev
,
409 struct device_attribute
*devattr
,
412 struct adt7470_data
*data
= adt7470_update_device(dev
);
413 return sprintf(buf
, "%d\n", data
->auto_update_interval
);
416 static ssize_t
set_auto_update_interval(struct device
*dev
,
417 struct device_attribute
*devattr
,
421 struct adt7470_data
*data
= dev_get_drvdata(dev
);
424 if (kstrtol(buf
, 10, &temp
))
427 temp
= clamp_val(temp
, 0, 60000);
429 mutex_lock(&data
->lock
);
430 data
->auto_update_interval
= temp
;
431 mutex_unlock(&data
->lock
);
436 static ssize_t
show_num_temp_sensors(struct device
*dev
,
437 struct device_attribute
*devattr
,
440 struct adt7470_data
*data
= adt7470_update_device(dev
);
441 return sprintf(buf
, "%d\n", data
->num_temp_sensors
);
444 static ssize_t
set_num_temp_sensors(struct device
*dev
,
445 struct device_attribute
*devattr
,
449 struct adt7470_data
*data
= dev_get_drvdata(dev
);
452 if (kstrtol(buf
, 10, &temp
))
455 temp
= clamp_val(temp
, -1, 10);
457 mutex_lock(&data
->lock
);
458 data
->num_temp_sensors
= temp
;
460 data
->temperatures_probed
= 0;
461 mutex_unlock(&data
->lock
);
466 static ssize_t
show_temp_min(struct device
*dev
,
467 struct device_attribute
*devattr
,
470 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
471 struct adt7470_data
*data
= adt7470_update_device(dev
);
472 return sprintf(buf
, "%d\n", 1000 * data
->temp_min
[attr
->index
]);
475 static ssize_t
set_temp_min(struct device
*dev
,
476 struct device_attribute
*devattr
,
480 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
481 struct adt7470_data
*data
= dev_get_drvdata(dev
);
482 struct i2c_client
*client
= data
->client
;
485 if (kstrtol(buf
, 10, &temp
))
488 temp
= DIV_ROUND_CLOSEST(temp
, 1000);
489 temp
= clamp_val(temp
, -128, 127);
491 mutex_lock(&data
->lock
);
492 data
->temp_min
[attr
->index
] = temp
;
493 i2c_smbus_write_byte_data(client
, ADT7470_TEMP_MIN_REG(attr
->index
),
495 mutex_unlock(&data
->lock
);
500 static ssize_t
show_temp_max(struct device
*dev
,
501 struct device_attribute
*devattr
,
504 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
505 struct adt7470_data
*data
= adt7470_update_device(dev
);
506 return sprintf(buf
, "%d\n", 1000 * data
->temp_max
[attr
->index
]);
509 static ssize_t
set_temp_max(struct device
*dev
,
510 struct device_attribute
*devattr
,
514 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
515 struct adt7470_data
*data
= dev_get_drvdata(dev
);
516 struct i2c_client
*client
= data
->client
;
519 if (kstrtol(buf
, 10, &temp
))
522 temp
= DIV_ROUND_CLOSEST(temp
, 1000);
523 temp
= clamp_val(temp
, -128, 127);
525 mutex_lock(&data
->lock
);
526 data
->temp_max
[attr
->index
] = temp
;
527 i2c_smbus_write_byte_data(client
, ADT7470_TEMP_MAX_REG(attr
->index
),
529 mutex_unlock(&data
->lock
);
534 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*devattr
,
537 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
538 struct adt7470_data
*data
= adt7470_update_device(dev
);
539 return sprintf(buf
, "%d\n", 1000 * data
->temp
[attr
->index
]);
542 static ssize_t
show_alarm_mask(struct device
*dev
,
543 struct device_attribute
*devattr
,
546 struct adt7470_data
*data
= adt7470_update_device(dev
);
548 return sprintf(buf
, "%x\n", data
->alarms_mask
);
551 static ssize_t
set_alarm_mask(struct device
*dev
,
552 struct device_attribute
*devattr
,
556 struct adt7470_data
*data
= dev_get_drvdata(dev
);
559 if (kstrtoul(buf
, 0, &mask
))
565 mutex_lock(&data
->lock
);
566 data
->alarms_mask
= mask
;
567 adt7470_write_word_data(data
->client
, ADT7470_REG_ALARM1_MASK
, mask
);
568 mutex_unlock(&data
->lock
);
573 static ssize_t
show_fan_max(struct device
*dev
,
574 struct device_attribute
*devattr
,
577 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
578 struct adt7470_data
*data
= adt7470_update_device(dev
);
580 if (FAN_DATA_VALID(data
->fan_max
[attr
->index
]))
581 return sprintf(buf
, "%d\n",
582 FAN_PERIOD_TO_RPM(data
->fan_max
[attr
->index
]));
584 return sprintf(buf
, "0\n");
587 static ssize_t
set_fan_max(struct device
*dev
,
588 struct device_attribute
*devattr
,
589 const char *buf
, size_t count
)
591 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
592 struct adt7470_data
*data
= dev_get_drvdata(dev
);
593 struct i2c_client
*client
= data
->client
;
596 if (kstrtol(buf
, 10, &temp
) || !temp
)
599 temp
= FAN_RPM_TO_PERIOD(temp
);
600 temp
= clamp_val(temp
, 1, 65534);
602 mutex_lock(&data
->lock
);
603 data
->fan_max
[attr
->index
] = temp
;
604 adt7470_write_word_data(client
, ADT7470_REG_FAN_MAX(attr
->index
), temp
);
605 mutex_unlock(&data
->lock
);
610 static ssize_t
show_fan_min(struct device
*dev
,
611 struct device_attribute
*devattr
,
614 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
615 struct adt7470_data
*data
= adt7470_update_device(dev
);
617 if (FAN_DATA_VALID(data
->fan_min
[attr
->index
]))
618 return sprintf(buf
, "%d\n",
619 FAN_PERIOD_TO_RPM(data
->fan_min
[attr
->index
]));
621 return sprintf(buf
, "0\n");
624 static ssize_t
set_fan_min(struct device
*dev
,
625 struct device_attribute
*devattr
,
626 const char *buf
, size_t count
)
628 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
629 struct adt7470_data
*data
= dev_get_drvdata(dev
);
630 struct i2c_client
*client
= data
->client
;
633 if (kstrtol(buf
, 10, &temp
) || !temp
)
636 temp
= FAN_RPM_TO_PERIOD(temp
);
637 temp
= clamp_val(temp
, 1, 65534);
639 mutex_lock(&data
->lock
);
640 data
->fan_min
[attr
->index
] = temp
;
641 adt7470_write_word_data(client
, ADT7470_REG_FAN_MIN(attr
->index
), temp
);
642 mutex_unlock(&data
->lock
);
647 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*devattr
,
650 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
651 struct adt7470_data
*data
= adt7470_update_device(dev
);
653 if (FAN_DATA_VALID(data
->fan
[attr
->index
]))
654 return sprintf(buf
, "%d\n",
655 FAN_PERIOD_TO_RPM(data
->fan
[attr
->index
]));
657 return sprintf(buf
, "0\n");
660 static ssize_t
show_force_pwm_max(struct device
*dev
,
661 struct device_attribute
*devattr
,
664 struct adt7470_data
*data
= adt7470_update_device(dev
);
665 return sprintf(buf
, "%d\n", data
->force_pwm_max
);
668 static ssize_t
set_force_pwm_max(struct device
*dev
,
669 struct device_attribute
*devattr
,
673 struct adt7470_data
*data
= dev_get_drvdata(dev
);
674 struct i2c_client
*client
= data
->client
;
678 if (kstrtol(buf
, 10, &temp
))
681 mutex_lock(&data
->lock
);
682 data
->force_pwm_max
= temp
;
683 reg
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
);
685 reg
|= ADT7470_FSPD_MASK
;
687 reg
&= ~ADT7470_FSPD_MASK
;
688 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG
, reg
);
689 mutex_unlock(&data
->lock
);
694 static ssize_t
show_pwm(struct device
*dev
, struct device_attribute
*devattr
,
697 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
698 struct adt7470_data
*data
= adt7470_update_device(dev
);
699 return sprintf(buf
, "%d\n", data
->pwm
[attr
->index
]);
702 static ssize_t
set_pwm(struct device
*dev
, struct device_attribute
*devattr
,
703 const char *buf
, size_t count
)
705 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
706 struct adt7470_data
*data
= dev_get_drvdata(dev
);
707 struct i2c_client
*client
= data
->client
;
710 if (kstrtol(buf
, 10, &temp
))
713 temp
= clamp_val(temp
, 0, 255);
715 mutex_lock(&data
->lock
);
716 data
->pwm
[attr
->index
] = temp
;
717 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM(attr
->index
), temp
);
718 mutex_unlock(&data
->lock
);
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 ssize_t
show_pwm_freq(struct device
*dev
,
729 struct device_attribute
*devattr
, char *buf
)
731 struct adt7470_data
*data
= adt7470_update_device(dev
);
732 unsigned char cfg_reg_1
;
733 unsigned char cfg_reg_2
;
736 mutex_lock(&data
->lock
);
737 cfg_reg_1
= i2c_smbus_read_byte_data(data
->client
, ADT7470_REG_CFG
);
738 cfg_reg_2
= i2c_smbus_read_byte_data(data
->client
, ADT7470_REG_CFG_2
);
739 mutex_unlock(&data
->lock
);
741 index
= (cfg_reg_2
& ADT7470_FREQ_MASK
) >> ADT7470_FREQ_SHIFT
;
742 if (!(cfg_reg_1
& ADT7470_CFG_LF
))
744 if (index
>= ARRAY_SIZE(adt7470_freq_map
))
745 index
= ARRAY_SIZE(adt7470_freq_map
) - 1;
747 return scnprintf(buf
, PAGE_SIZE
, "%d\n", adt7470_freq_map
[index
]);
750 static ssize_t
set_pwm_freq(struct device
*dev
,
751 struct device_attribute
*devattr
,
752 const char *buf
, size_t count
)
754 struct adt7470_data
*data
= dev_get_drvdata(dev
);
755 struct i2c_client
*client
= data
->client
;
758 int low_freq
= ADT7470_CFG_LF
;
761 if (kstrtol(buf
, 10, &freq
))
764 /* Round the user value given to the closest available frequency */
765 index
= find_closest(freq
, adt7470_freq_map
,
766 ARRAY_SIZE(adt7470_freq_map
));
773 mutex_lock(&data
->lock
);
774 /* Configuration Register 1 */
775 val
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
);
776 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG
,
777 (val
& ~ADT7470_CFG_LF
) | low_freq
);
778 /* Configuration Register 2 */
779 val
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG_2
);
780 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG_2
,
781 (val
& ~ADT7470_FREQ_MASK
) | (index
<< ADT7470_FREQ_SHIFT
));
782 mutex_unlock(&data
->lock
);
787 static ssize_t
show_pwm_max(struct device
*dev
,
788 struct device_attribute
*devattr
,
791 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
792 struct adt7470_data
*data
= adt7470_update_device(dev
);
793 return sprintf(buf
, "%d\n", data
->pwm_max
[attr
->index
]);
796 static ssize_t
set_pwm_max(struct device
*dev
,
797 struct device_attribute
*devattr
,
801 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
802 struct adt7470_data
*data
= dev_get_drvdata(dev
);
803 struct i2c_client
*client
= data
->client
;
806 if (kstrtol(buf
, 10, &temp
))
809 temp
= clamp_val(temp
, 0, 255);
811 mutex_lock(&data
->lock
);
812 data
->pwm_max
[attr
->index
] = temp
;
813 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_MAX(attr
->index
),
815 mutex_unlock(&data
->lock
);
820 static ssize_t
show_pwm_min(struct device
*dev
,
821 struct device_attribute
*devattr
,
824 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
825 struct adt7470_data
*data
= adt7470_update_device(dev
);
826 return sprintf(buf
, "%d\n", data
->pwm_min
[attr
->index
]);
829 static ssize_t
set_pwm_min(struct device
*dev
,
830 struct device_attribute
*devattr
,
834 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
835 struct adt7470_data
*data
= dev_get_drvdata(dev
);
836 struct i2c_client
*client
= data
->client
;
839 if (kstrtol(buf
, 10, &temp
))
842 temp
= clamp_val(temp
, 0, 255);
844 mutex_lock(&data
->lock
);
845 data
->pwm_min
[attr
->index
] = temp
;
846 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_MIN(attr
->index
),
848 mutex_unlock(&data
->lock
);
853 static ssize_t
show_pwm_tmax(struct device
*dev
,
854 struct device_attribute
*devattr
,
857 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
858 struct adt7470_data
*data
= adt7470_update_device(dev
);
859 /* the datasheet says that tmax = tmin + 20C */
860 return sprintf(buf
, "%d\n", 1000 * (20 + data
->pwm_tmin
[attr
->index
]));
863 static ssize_t
show_pwm_tmin(struct device
*dev
,
864 struct device_attribute
*devattr
,
867 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
868 struct adt7470_data
*data
= adt7470_update_device(dev
);
869 return sprintf(buf
, "%d\n", 1000 * data
->pwm_tmin
[attr
->index
]);
872 static ssize_t
set_pwm_tmin(struct device
*dev
,
873 struct device_attribute
*devattr
,
877 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
878 struct adt7470_data
*data
= dev_get_drvdata(dev
);
879 struct i2c_client
*client
= data
->client
;
882 if (kstrtol(buf
, 10, &temp
))
885 temp
= DIV_ROUND_CLOSEST(temp
, 1000);
886 temp
= clamp_val(temp
, -128, 127);
888 mutex_lock(&data
->lock
);
889 data
->pwm_tmin
[attr
->index
] = temp
;
890 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_TMIN(attr
->index
),
892 mutex_unlock(&data
->lock
);
897 static ssize_t
show_pwm_auto(struct device
*dev
,
898 struct device_attribute
*devattr
,
901 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
902 struct adt7470_data
*data
= adt7470_update_device(dev
);
903 return sprintf(buf
, "%d\n", 1 + data
->pwm_automatic
[attr
->index
]);
906 static ssize_t
set_pwm_auto(struct device
*dev
,
907 struct device_attribute
*devattr
,
911 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
912 struct adt7470_data
*data
= dev_get_drvdata(dev
);
913 struct i2c_client
*client
= data
->client
;
914 int pwm_auto_reg
= ADT7470_REG_PWM_CFG(attr
->index
);
915 int pwm_auto_reg_mask
;
919 if (kstrtol(buf
, 10, &temp
))
923 pwm_auto_reg_mask
= ADT7470_PWM2_AUTO_MASK
;
925 pwm_auto_reg_mask
= ADT7470_PWM1_AUTO_MASK
;
927 if (temp
!= 2 && temp
!= 1)
931 mutex_lock(&data
->lock
);
932 data
->pwm_automatic
[attr
->index
] = temp
;
933 reg
= i2c_smbus_read_byte_data(client
, pwm_auto_reg
);
935 reg
|= pwm_auto_reg_mask
;
937 reg
&= ~pwm_auto_reg_mask
;
938 i2c_smbus_write_byte_data(client
, pwm_auto_reg
, reg
);
939 mutex_unlock(&data
->lock
);
944 static ssize_t
show_pwm_auto_temp(struct device
*dev
,
945 struct device_attribute
*devattr
,
948 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
949 struct adt7470_data
*data
= adt7470_update_device(dev
);
950 u8 ctrl
= data
->pwm_auto_temp
[attr
->index
];
953 return sprintf(buf
, "%d\n", 1 << (ctrl
- 1));
955 return sprintf(buf
, "%d\n", ADT7470_PWM_ALL_TEMPS
);
958 static int cvt_auto_temp(int input
)
960 if (input
== ADT7470_PWM_ALL_TEMPS
)
962 if (input
< 1 || !is_power_of_2(input
))
964 return ilog2(input
) + 1;
967 static ssize_t
set_pwm_auto_temp(struct device
*dev
,
968 struct device_attribute
*devattr
,
972 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
973 struct adt7470_data
*data
= dev_get_drvdata(dev
);
974 struct i2c_client
*client
= data
->client
;
975 int pwm_auto_reg
= ADT7470_REG_PWM_AUTO_TEMP(attr
->index
);
979 if (kstrtol(buf
, 10, &temp
))
982 temp
= cvt_auto_temp(temp
);
986 mutex_lock(&data
->lock
);
987 data
->pwm_automatic
[attr
->index
] = temp
;
988 reg
= i2c_smbus_read_byte_data(client
, pwm_auto_reg
);
990 if (!(attr
->index
% 2)) {
992 reg
|= (temp
<< 4) & 0xF0;
998 i2c_smbus_write_byte_data(client
, pwm_auto_reg
, reg
);
999 mutex_unlock(&data
->lock
);
1004 static ssize_t
show_alarm(struct device
*dev
,
1005 struct device_attribute
*devattr
,
1008 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
1009 struct adt7470_data
*data
= adt7470_update_device(dev
);
1011 if (data
->alarm
& attr
->index
)
1012 return sprintf(buf
, "1\n");
1014 return sprintf(buf
, "0\n");
1017 static DEVICE_ATTR(alarm_mask
, S_IWUSR
| S_IRUGO
, show_alarm_mask
,
1019 static DEVICE_ATTR(num_temp_sensors
, S_IWUSR
| S_IRUGO
, show_num_temp_sensors
,
1020 set_num_temp_sensors
);
1021 static DEVICE_ATTR(auto_update_interval
, S_IWUSR
| S_IRUGO
,
1022 show_auto_update_interval
, set_auto_update_interval
);
1024 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1026 static SENSOR_DEVICE_ATTR(temp2_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1028 static SENSOR_DEVICE_ATTR(temp3_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1030 static SENSOR_DEVICE_ATTR(temp4_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1032 static SENSOR_DEVICE_ATTR(temp5_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1034 static SENSOR_DEVICE_ATTR(temp6_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1036 static SENSOR_DEVICE_ATTR(temp7_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1038 static SENSOR_DEVICE_ATTR(temp8_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1040 static SENSOR_DEVICE_ATTR(temp9_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1042 static SENSOR_DEVICE_ATTR(temp10_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
1045 static SENSOR_DEVICE_ATTR(temp1_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1047 static SENSOR_DEVICE_ATTR(temp2_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1049 static SENSOR_DEVICE_ATTR(temp3_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1051 static SENSOR_DEVICE_ATTR(temp4_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1053 static SENSOR_DEVICE_ATTR(temp5_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1055 static SENSOR_DEVICE_ATTR(temp6_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1057 static SENSOR_DEVICE_ATTR(temp7_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1059 static SENSOR_DEVICE_ATTR(temp8_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1061 static SENSOR_DEVICE_ATTR(temp9_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1063 static SENSOR_DEVICE_ATTR(temp10_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
1066 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
, 0);
1067 static SENSOR_DEVICE_ATTR(temp2_input
, S_IRUGO
, show_temp
, NULL
, 1);
1068 static SENSOR_DEVICE_ATTR(temp3_input
, S_IRUGO
, show_temp
, NULL
, 2);
1069 static SENSOR_DEVICE_ATTR(temp4_input
, S_IRUGO
, show_temp
, NULL
, 3);
1070 static SENSOR_DEVICE_ATTR(temp5_input
, S_IRUGO
, show_temp
, NULL
, 4);
1071 static SENSOR_DEVICE_ATTR(temp6_input
, S_IRUGO
, show_temp
, NULL
, 5);
1072 static SENSOR_DEVICE_ATTR(temp7_input
, S_IRUGO
, show_temp
, NULL
, 6);
1073 static SENSOR_DEVICE_ATTR(temp8_input
, S_IRUGO
, show_temp
, NULL
, 7);
1074 static SENSOR_DEVICE_ATTR(temp9_input
, S_IRUGO
, show_temp
, NULL
, 8);
1075 static SENSOR_DEVICE_ATTR(temp10_input
, S_IRUGO
, show_temp
, NULL
, 9);
1077 static SENSOR_DEVICE_ATTR(temp1_alarm
, S_IRUGO
, show_alarm
, NULL
,
1079 static SENSOR_DEVICE_ATTR(temp2_alarm
, S_IRUGO
, show_alarm
, NULL
,
1081 static SENSOR_DEVICE_ATTR(temp3_alarm
, S_IRUGO
, show_alarm
, NULL
,
1083 static SENSOR_DEVICE_ATTR(temp4_alarm
, S_IRUGO
, show_alarm
, NULL
,
1085 static SENSOR_DEVICE_ATTR(temp5_alarm
, S_IRUGO
, show_alarm
, NULL
,
1087 static SENSOR_DEVICE_ATTR(temp6_alarm
, S_IRUGO
, show_alarm
, NULL
,
1089 static SENSOR_DEVICE_ATTR(temp7_alarm
, S_IRUGO
, show_alarm
, NULL
,
1091 static SENSOR_DEVICE_ATTR(temp8_alarm
, S_IRUGO
, show_alarm
, NULL
,
1092 ALARM2(ADT7470_R8T_ALARM
));
1093 static SENSOR_DEVICE_ATTR(temp9_alarm
, S_IRUGO
, show_alarm
, NULL
,
1094 ALARM2(ADT7470_R9T_ALARM
));
1095 static SENSOR_DEVICE_ATTR(temp10_alarm
, S_IRUGO
, show_alarm
, NULL
,
1096 ALARM2(ADT7470_R10T_ALARM
));
1098 static SENSOR_DEVICE_ATTR(fan1_max
, S_IWUSR
| S_IRUGO
, show_fan_max
,
1100 static SENSOR_DEVICE_ATTR(fan2_max
, S_IWUSR
| S_IRUGO
, show_fan_max
,
1102 static SENSOR_DEVICE_ATTR(fan3_max
, S_IWUSR
| S_IRUGO
, show_fan_max
,
1104 static SENSOR_DEVICE_ATTR(fan4_max
, S_IWUSR
| S_IRUGO
, show_fan_max
,
1107 static SENSOR_DEVICE_ATTR(fan1_min
, S_IWUSR
| S_IRUGO
, show_fan_min
,
1109 static SENSOR_DEVICE_ATTR(fan2_min
, S_IWUSR
| S_IRUGO
, show_fan_min
,
1111 static SENSOR_DEVICE_ATTR(fan3_min
, S_IWUSR
| S_IRUGO
, show_fan_min
,
1113 static SENSOR_DEVICE_ATTR(fan4_min
, S_IWUSR
| S_IRUGO
, show_fan_min
,
1116 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0);
1117 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, show_fan
, NULL
, 1);
1118 static SENSOR_DEVICE_ATTR(fan3_input
, S_IRUGO
, show_fan
, NULL
, 2);
1119 static SENSOR_DEVICE_ATTR(fan4_input
, S_IRUGO
, show_fan
, NULL
, 3);
1121 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_alarm
, NULL
,
1122 ALARM2(ADT7470_FAN1_ALARM
));
1123 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, show_alarm
, NULL
,
1124 ALARM2(ADT7470_FAN2_ALARM
));
1125 static SENSOR_DEVICE_ATTR(fan3_alarm
, S_IRUGO
, show_alarm
, NULL
,
1126 ALARM2(ADT7470_FAN3_ALARM
));
1127 static SENSOR_DEVICE_ATTR(fan4_alarm
, S_IRUGO
, show_alarm
, NULL
,
1128 ALARM2(ADT7470_FAN4_ALARM
));
1130 static SENSOR_DEVICE_ATTR(force_pwm_max
, S_IWUSR
| S_IRUGO
,
1131 show_force_pwm_max
, set_force_pwm_max
, 0);
1133 static SENSOR_DEVICE_ATTR(pwm1
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 0);
1134 static SENSOR_DEVICE_ATTR(pwm2
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 1);
1135 static SENSOR_DEVICE_ATTR(pwm3
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 2);
1136 static SENSOR_DEVICE_ATTR(pwm4
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 3);
1138 static DEVICE_ATTR(pwm1_freq
, S_IWUSR
| S_IRUGO
, show_pwm_freq
, set_pwm_freq
);
1140 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm
, S_IWUSR
| S_IRUGO
,
1141 show_pwm_min
, set_pwm_min
, 0);
1142 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm
, S_IWUSR
| S_IRUGO
,
1143 show_pwm_min
, set_pwm_min
, 1);
1144 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm
, S_IWUSR
| S_IRUGO
,
1145 show_pwm_min
, set_pwm_min
, 2);
1146 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm
, S_IWUSR
| S_IRUGO
,
1147 show_pwm_min
, set_pwm_min
, 3);
1149 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm
, S_IWUSR
| S_IRUGO
,
1150 show_pwm_max
, set_pwm_max
, 0);
1151 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm
, S_IWUSR
| S_IRUGO
,
1152 show_pwm_max
, set_pwm_max
, 1);
1153 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm
, S_IWUSR
| S_IRUGO
,
1154 show_pwm_max
, set_pwm_max
, 2);
1155 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm
, S_IWUSR
| S_IRUGO
,
1156 show_pwm_max
, set_pwm_max
, 3);
1158 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp
, S_IWUSR
| S_IRUGO
,
1159 show_pwm_tmin
, set_pwm_tmin
, 0);
1160 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_temp
, S_IWUSR
| S_IRUGO
,
1161 show_pwm_tmin
, set_pwm_tmin
, 1);
1162 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_temp
, S_IWUSR
| S_IRUGO
,
1163 show_pwm_tmin
, set_pwm_tmin
, 2);
1164 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_temp
, S_IWUSR
| S_IRUGO
,
1165 show_pwm_tmin
, set_pwm_tmin
, 3);
1167 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp
, S_IRUGO
, show_pwm_tmax
,
1169 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_temp
, S_IRUGO
, show_pwm_tmax
,
1171 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_temp
, S_IRUGO
, show_pwm_tmax
,
1173 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_temp
, S_IRUGO
, show_pwm_tmax
,
1176 static SENSOR_DEVICE_ATTR(pwm1_enable
, S_IWUSR
| S_IRUGO
, show_pwm_auto
,
1178 static SENSOR_DEVICE_ATTR(pwm2_enable
, S_IWUSR
| S_IRUGO
, show_pwm_auto
,
1180 static SENSOR_DEVICE_ATTR(pwm3_enable
, S_IWUSR
| S_IRUGO
, show_pwm_auto
,
1182 static SENSOR_DEVICE_ATTR(pwm4_enable
, S_IWUSR
| S_IRUGO
, show_pwm_auto
,
1185 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp
, S_IWUSR
| S_IRUGO
,
1186 show_pwm_auto_temp
, set_pwm_auto_temp
, 0);
1187 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp
, S_IWUSR
| S_IRUGO
,
1188 show_pwm_auto_temp
, set_pwm_auto_temp
, 1);
1189 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp
, S_IWUSR
| S_IRUGO
,
1190 show_pwm_auto_temp
, set_pwm_auto_temp
, 2);
1191 static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp
, S_IWUSR
| S_IRUGO
,
1192 show_pwm_auto_temp
, set_pwm_auto_temp
, 3);
1194 static struct attribute
*adt7470_attrs
[] = {
1195 &dev_attr_alarm_mask
.attr
,
1196 &dev_attr_num_temp_sensors
.attr
,
1197 &dev_attr_auto_update_interval
.attr
,
1198 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
1199 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
1200 &sensor_dev_attr_temp3_max
.dev_attr
.attr
,
1201 &sensor_dev_attr_temp4_max
.dev_attr
.attr
,
1202 &sensor_dev_attr_temp5_max
.dev_attr
.attr
,
1203 &sensor_dev_attr_temp6_max
.dev_attr
.attr
,
1204 &sensor_dev_attr_temp7_max
.dev_attr
.attr
,
1205 &sensor_dev_attr_temp8_max
.dev_attr
.attr
,
1206 &sensor_dev_attr_temp9_max
.dev_attr
.attr
,
1207 &sensor_dev_attr_temp10_max
.dev_attr
.attr
,
1208 &sensor_dev_attr_temp1_min
.dev_attr
.attr
,
1209 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
1210 &sensor_dev_attr_temp3_min
.dev_attr
.attr
,
1211 &sensor_dev_attr_temp4_min
.dev_attr
.attr
,
1212 &sensor_dev_attr_temp5_min
.dev_attr
.attr
,
1213 &sensor_dev_attr_temp6_min
.dev_attr
.attr
,
1214 &sensor_dev_attr_temp7_min
.dev_attr
.attr
,
1215 &sensor_dev_attr_temp8_min
.dev_attr
.attr
,
1216 &sensor_dev_attr_temp9_min
.dev_attr
.attr
,
1217 &sensor_dev_attr_temp10_min
.dev_attr
.attr
,
1218 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
1219 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
1220 &sensor_dev_attr_temp3_input
.dev_attr
.attr
,
1221 &sensor_dev_attr_temp4_input
.dev_attr
.attr
,
1222 &sensor_dev_attr_temp5_input
.dev_attr
.attr
,
1223 &sensor_dev_attr_temp6_input
.dev_attr
.attr
,
1224 &sensor_dev_attr_temp7_input
.dev_attr
.attr
,
1225 &sensor_dev_attr_temp8_input
.dev_attr
.attr
,
1226 &sensor_dev_attr_temp9_input
.dev_attr
.attr
,
1227 &sensor_dev_attr_temp10_input
.dev_attr
.attr
,
1228 &sensor_dev_attr_temp1_alarm
.dev_attr
.attr
,
1229 &sensor_dev_attr_temp2_alarm
.dev_attr
.attr
,
1230 &sensor_dev_attr_temp3_alarm
.dev_attr
.attr
,
1231 &sensor_dev_attr_temp4_alarm
.dev_attr
.attr
,
1232 &sensor_dev_attr_temp5_alarm
.dev_attr
.attr
,
1233 &sensor_dev_attr_temp6_alarm
.dev_attr
.attr
,
1234 &sensor_dev_attr_temp7_alarm
.dev_attr
.attr
,
1235 &sensor_dev_attr_temp8_alarm
.dev_attr
.attr
,
1236 &sensor_dev_attr_temp9_alarm
.dev_attr
.attr
,
1237 &sensor_dev_attr_temp10_alarm
.dev_attr
.attr
,
1238 &sensor_dev_attr_fan1_max
.dev_attr
.attr
,
1239 &sensor_dev_attr_fan2_max
.dev_attr
.attr
,
1240 &sensor_dev_attr_fan3_max
.dev_attr
.attr
,
1241 &sensor_dev_attr_fan4_max
.dev_attr
.attr
,
1242 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
1243 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
1244 &sensor_dev_attr_fan3_min
.dev_attr
.attr
,
1245 &sensor_dev_attr_fan4_min
.dev_attr
.attr
,
1246 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
1247 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
1248 &sensor_dev_attr_fan3_input
.dev_attr
.attr
,
1249 &sensor_dev_attr_fan4_input
.dev_attr
.attr
,
1250 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
1251 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
1252 &sensor_dev_attr_fan3_alarm
.dev_attr
.attr
,
1253 &sensor_dev_attr_fan4_alarm
.dev_attr
.attr
,
1254 &sensor_dev_attr_force_pwm_max
.dev_attr
.attr
,
1255 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
1256 &dev_attr_pwm1_freq
.attr
,
1257 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
1258 &sensor_dev_attr_pwm3
.dev_attr
.attr
,
1259 &sensor_dev_attr_pwm4
.dev_attr
.attr
,
1260 &sensor_dev_attr_pwm1_auto_point1_pwm
.dev_attr
.attr
,
1261 &sensor_dev_attr_pwm2_auto_point1_pwm
.dev_attr
.attr
,
1262 &sensor_dev_attr_pwm3_auto_point1_pwm
.dev_attr
.attr
,
1263 &sensor_dev_attr_pwm4_auto_point1_pwm
.dev_attr
.attr
,
1264 &sensor_dev_attr_pwm1_auto_point2_pwm
.dev_attr
.attr
,
1265 &sensor_dev_attr_pwm2_auto_point2_pwm
.dev_attr
.attr
,
1266 &sensor_dev_attr_pwm3_auto_point2_pwm
.dev_attr
.attr
,
1267 &sensor_dev_attr_pwm4_auto_point2_pwm
.dev_attr
.attr
,
1268 &sensor_dev_attr_pwm1_auto_point1_temp
.dev_attr
.attr
,
1269 &sensor_dev_attr_pwm2_auto_point1_temp
.dev_attr
.attr
,
1270 &sensor_dev_attr_pwm3_auto_point1_temp
.dev_attr
.attr
,
1271 &sensor_dev_attr_pwm4_auto_point1_temp
.dev_attr
.attr
,
1272 &sensor_dev_attr_pwm1_auto_point2_temp
.dev_attr
.attr
,
1273 &sensor_dev_attr_pwm2_auto_point2_temp
.dev_attr
.attr
,
1274 &sensor_dev_attr_pwm3_auto_point2_temp
.dev_attr
.attr
,
1275 &sensor_dev_attr_pwm4_auto_point2_temp
.dev_attr
.attr
,
1276 &sensor_dev_attr_pwm1_enable
.dev_attr
.attr
,
1277 &sensor_dev_attr_pwm2_enable
.dev_attr
.attr
,
1278 &sensor_dev_attr_pwm3_enable
.dev_attr
.attr
,
1279 &sensor_dev_attr_pwm4_enable
.dev_attr
.attr
,
1280 &sensor_dev_attr_pwm1_auto_channels_temp
.dev_attr
.attr
,
1281 &sensor_dev_attr_pwm2_auto_channels_temp
.dev_attr
.attr
,
1282 &sensor_dev_attr_pwm3_auto_channels_temp
.dev_attr
.attr
,
1283 &sensor_dev_attr_pwm4_auto_channels_temp
.dev_attr
.attr
,
1287 ATTRIBUTE_GROUPS(adt7470
);
1289 /* Return 0 if detection is successful, -ENODEV otherwise */
1290 static int adt7470_detect(struct i2c_client
*client
,
1291 struct i2c_board_info
*info
)
1293 struct i2c_adapter
*adapter
= client
->adapter
;
1294 int vendor
, device
, revision
;
1296 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
1299 vendor
= i2c_smbus_read_byte_data(client
, ADT7470_REG_VENDOR
);
1300 if (vendor
!= ADT7470_VENDOR
)
1303 device
= i2c_smbus_read_byte_data(client
, ADT7470_REG_DEVICE
);
1304 if (device
!= ADT7470_DEVICE
)
1307 revision
= i2c_smbus_read_byte_data(client
, ADT7470_REG_REVISION
);
1308 if (revision
!= ADT7470_REVISION
)
1311 strlcpy(info
->type
, "adt7470", I2C_NAME_SIZE
);
1316 static void adt7470_init_client(struct i2c_client
*client
)
1318 int reg
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
);
1321 dev_err(&client
->dev
, "cannot read configuration register\n");
1323 /* start monitoring (and do a self-test) */
1324 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG
, reg
| 3);
1328 static int adt7470_probe(struct i2c_client
*client
,
1329 const struct i2c_device_id
*id
)
1331 struct device
*dev
= &client
->dev
;
1332 struct adt7470_data
*data
;
1333 struct device
*hwmon_dev
;
1335 data
= devm_kzalloc(dev
, sizeof(struct adt7470_data
), GFP_KERNEL
);
1339 data
->num_temp_sensors
= -1;
1340 data
->auto_update_interval
= AUTO_UPDATE_INTERVAL
;
1342 i2c_set_clientdata(client
, data
);
1343 data
->client
= client
;
1344 mutex_init(&data
->lock
);
1346 dev_info(&client
->dev
, "%s chip found\n", client
->name
);
1348 /* Initialize the ADT7470 chip */
1349 adt7470_init_client(client
);
1351 /* Register sysfs hooks */
1352 hwmon_dev
= devm_hwmon_device_register_with_groups(dev
, client
->name
,
1356 if (IS_ERR(hwmon_dev
))
1357 return PTR_ERR(hwmon_dev
);
1359 init_completion(&data
->auto_update_stop
);
1360 data
->auto_update
= kthread_run(adt7470_update_thread
, client
, "%s",
1361 dev_name(hwmon_dev
));
1362 if (IS_ERR(data
->auto_update
)) {
1363 return PTR_ERR(data
->auto_update
);
1369 static int adt7470_remove(struct i2c_client
*client
)
1371 struct adt7470_data
*data
= i2c_get_clientdata(client
);
1373 kthread_stop(data
->auto_update
);
1374 wait_for_completion(&data
->auto_update_stop
);
1378 static const struct i2c_device_id adt7470_id
[] = {
1382 MODULE_DEVICE_TABLE(i2c
, adt7470_id
);
1384 static struct i2c_driver adt7470_driver
= {
1385 .class = I2C_CLASS_HWMON
,
1389 .probe
= adt7470_probe
,
1390 .remove
= adt7470_remove
,
1391 .id_table
= adt7470_id
,
1392 .detect
= adt7470_detect
,
1393 .address_list
= normal_i2c
,
1396 module_i2c_driver(adt7470_driver
);
1398 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1399 MODULE_DESCRIPTION("ADT7470 driver");
1400 MODULE_LICENSE("GPL");