projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
hwmon: (adt7470) Avoid forward declaration
[deliverable/linux.git] / drivers / hwmon / adt7470.c
CommitLineData
6f9703d0
DW		 1/*
2 * A hwmon driver for the Analog Devices ADT7470
3 * Copyright (C) 2007 IBM
4 *
5407e051 5 * Author: Darrick J. Wong <darrick.wong@oracle.com>
6f9703d0
DW		 6 *
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.
11 *
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.
16 *
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
20 */
21
2e991201
JP		 22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23
6f9703d0
DW		 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>
89fac11c 33#include <linux/kthread.h>
5a0e3ad6 34#include <linux/slab.h>
6f9703d0
DW		 35
36/* Addresses to scan */
25e9c86d 37static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END };
6f9703d0 38
6f9703d0
DW		 39/* ADT7470 registers */
40#define ADT7470_REG_BASE_ADDR 0x20
41#define ADT7470_REG_TEMP_BASE_ADDR 0x20
42#define ADT7470_REG_TEMP_MAX_ADDR 0x29
43#define ADT7470_REG_FAN_BASE_ADDR 0x2A
44#define ADT7470_REG_FAN_MAX_ADDR 0x31
45#define ADT7470_REG_PWM_BASE_ADDR 0x32
46#define ADT7470_REG_PWM_MAX_ADDR 0x35
47#define ADT7470_REG_PWM_MAX_BASE_ADDR 0x38
48#define ADT7470_REG_PWM_MAX_MAX_ADDR 0x3B
49#define ADT7470_REG_CFG 0x40
50#define ADT7470_FSPD_MASK 0x04
51#define ADT7470_REG_ALARM1 0x41
fe03f28c
DW		 52#define ADT7470_R1T_ALARM 0x01
53#define ADT7470_R2T_ALARM 0x02
54#define ADT7470_R3T_ALARM 0x04
55#define ADT7470_R4T_ALARM 0x08
56#define ADT7470_R5T_ALARM 0x10
57#define ADT7470_R6T_ALARM 0x20
58#define ADT7470_R7T_ALARM 0x40
59#define ADT7470_OOL_ALARM 0x80
6f9703d0 60#define ADT7470_REG_ALARM2 0x42
fe03f28c
DW		 61#define ADT7470_R8T_ALARM 0x01
62#define ADT7470_R9T_ALARM 0x02
63#define ADT7470_R10T_ALARM 0x04
64#define ADT7470_FAN1_ALARM 0x10
65#define ADT7470_FAN2_ALARM 0x20
66#define ADT7470_FAN3_ALARM 0x40
67#define ADT7470_FAN4_ALARM 0x80
6f9703d0
DW		 68#define ADT7470_REG_TEMP_LIMITS_BASE_ADDR 0x44
69#define ADT7470_REG_TEMP_LIMITS_MAX_ADDR 0x57
70#define ADT7470_REG_FAN_MIN_BASE_ADDR 0x58
71#define ADT7470_REG_FAN_MIN_MAX_ADDR 0x5F
72#define ADT7470_REG_FAN_MAX_BASE_ADDR 0x60
73#define ADT7470_REG_FAN_MAX_MAX_ADDR 0x67
74#define ADT7470_REG_PWM_CFG_BASE_ADDR 0x68
75#define ADT7470_REG_PWM12_CFG 0x68
76#define ADT7470_PWM2_AUTO_MASK 0x40
77#define ADT7470_PWM1_AUTO_MASK 0x80
2e75a4b7 78#define ADT7470_PWM_AUTO_MASK 0xC0
6f9703d0
DW		 79#define ADT7470_REG_PWM34_CFG 0x69
80#define ADT7470_PWM3_AUTO_MASK 0x40
81#define ADT7470_PWM4_AUTO_MASK 0x80
82#define ADT7470_REG_PWM_MIN_BASE_ADDR 0x6A
83#define ADT7470_REG_PWM_MIN_MAX_ADDR 0x6D
84#define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR 0x6E
85#define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR 0x71
86#define ADT7470_REG_ACOUSTICS12 0x75
87#define ADT7470_REG_ACOUSTICS34 0x76
88#define ADT7470_REG_DEVICE 0x3D
89#define ADT7470_REG_VENDOR 0x3E
90#define ADT7470_REG_REVISION 0x3F
91#define ADT7470_REG_ALARM1_MASK 0x72
92#define ADT7470_REG_ALARM2_MASK 0x73
93#define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR 0x7C
94#define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR 0x7D
95#define ADT7470_REG_MAX_ADDR 0x81
96
97#define ADT7470_TEMP_COUNT 10
98#define ADT7470_TEMP_REG(x) (ADT7470_REG_TEMP_BASE_ADDR + (x))
99#define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
100#define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \
101 ((x) * 2) + 1)
102
103#define ADT7470_FAN_COUNT 4
104#define ADT7470_REG_FAN(x) (ADT7470_REG_FAN_BASE_ADDR + ((x) * 2))
105#define ADT7470_REG_FAN_MIN(x) (ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
106#define ADT7470_REG_FAN_MAX(x) (ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2))
107
108#define ADT7470_PWM_COUNT 4
109#define ADT7470_REG_PWM(x) (ADT7470_REG_PWM_BASE_ADDR + (x))
110#define ADT7470_REG_PWM_MAX(x) (ADT7470_REG_PWM_MAX_BASE_ADDR + (x))
111#define ADT7470_REG_PWM_MIN(x) (ADT7470_REG_PWM_MIN_BASE_ADDR + (x))
112#define ADT7470_REG_PWM_TMIN(x) (ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
113#define ADT7470_REG_PWM_CFG(x) (ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2))
114#define ADT7470_REG_PWM_AUTO_TEMP(x) (ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \
115 ((x) / 2))
116
fe03f28c
DW		 117#define ALARM2(x) ((x) << 8)
118
6f9703d0
DW		 119#define ADT7470_VENDOR 0x41
120#define ADT7470_DEVICE 0x70
121/* datasheet only mentions a revision 2 */
122#define ADT7470_REVISION 0x02
123
124/* "all temps" according to hwmon sysfs interface spec */
125#define ADT7470_PWM_ALL_TEMPS 0x3FF
126
127/* How often do we reread sensors values? (In jiffies) */
128#define SENSOR_REFRESH_INTERVAL (5 * HZ)
129
130/* How often do we reread sensor limit values? (In jiffies) */
131#define LIMIT_REFRESH_INTERVAL (60 * HZ)
132
2f22d5df
DW		 133/* Wait at least 200ms per sensor for 10 sensors */
134#define TEMP_COLLECTION_TIME 2000
6f9703d0 135
89fac11c
DW		 136/* auto update thing won't fire more than every 2s */
137#define AUTO_UPDATE_INTERVAL 2000
138
6f9703d0
DW		 139/* datasheet says to divide this number by the fan reading to get fan rpm */
140#define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
141#define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
142#define FAN_PERIOD_INVALID 65535
143#define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
144
145struct adt7470_data {
1beeffe4 146 struct device *hwmon_dev;
6f9703d0
DW		 147 struct attribute_group attrs;
148 struct mutex lock;
149 char sensors_valid;
150 char limits_valid;
151 unsigned long sensors_last_updated; /* In jiffies */
152 unsigned long limits_last_updated; /* In jiffies */
153
2f22d5df 154 int num_temp_sensors; /* -1 = probe */
89fac11c 155 int temperatures_probed;
2f22d5df 156
6f9703d0
DW		 157 s8 temp[ADT7470_TEMP_COUNT];
158 s8 temp_min[ADT7470_TEMP_COUNT];
159 s8 temp_max[ADT7470_TEMP_COUNT];
160 u16 fan[ADT7470_FAN_COUNT];
161 u16 fan_min[ADT7470_FAN_COUNT];
162 u16 fan_max[ADT7470_FAN_COUNT];
fe03f28c
DW		 163 u16 alarm;
164 u16 alarms_mask;
6f9703d0
DW		 165 u8 force_pwm_max;
166 u8 pwm[ADT7470_PWM_COUNT];
167 u8 pwm_max[ADT7470_PWM_COUNT];
168 u8 pwm_automatic[ADT7470_PWM_COUNT];
169 u8 pwm_min[ADT7470_PWM_COUNT];
170 s8 pwm_tmin[ADT7470_PWM_COUNT];
171 u8 pwm_auto_temp[ADT7470_PWM_COUNT];
89fac11c
DW		 172
173 struct task_struct *auto_update;
174 struct completion auto_update_stop;
175 unsigned int auto_update_interval;
6f9703d0
DW		 176};
177
6f9703d0
DW		 178/*
179 * 16-bit registers on the ADT7470 are low-byte first. The data sheet says
180 * that the low byte must be read before the high byte.
181 */
182static inline int adt7470_read_word_data(struct i2c_client *client, u8 reg)
183{
184 u16 foo;
185 foo = i2c_smbus_read_byte_data(client, reg);
186 foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
187 return foo;
188}
189
190static inline int adt7470_write_word_data(struct i2c_client *client, u8 reg,
191 u16 value)
192{
193 return i2c_smbus_write_byte_data(client, reg, value & 0xFF)
93d783bc 194 || i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
6f9703d0
DW		 195}
196
89fac11c
DW		 197/* Probe for temperature sensors. Assumes lock is held */
198static int adt7470_read_temperatures(struct i2c_client *client,
199 struct adt7470_data *data)
6f9703d0 200{
89fac11c 201 unsigned long res;
6f9703d0 202 int i;
89fac11c 203 u8 cfg, pwm[4], pwm_cfg[2];
6f9703d0 204
2e75a4b7
DW		 205 /* save pwm[1-4] config register */
206 pwm_cfg[0] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM_CFG(0));
207 pwm_cfg[1] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM_CFG(2));
208
209 /* set manual pwm to whatever it is set to now */
210 for (i = 0; i < ADT7470_FAN_COUNT; i++)
211 pwm[i] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM(i));
212
213 /* put pwm in manual mode */
214 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(0),
215 pwm_cfg[0] & ~(ADT7470_PWM_AUTO_MASK));
216 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(2),
217 pwm_cfg[1] & ~(ADT7470_PWM_AUTO_MASK));
218
219 /* write pwm control to whatever it was */
220 for (i = 0; i < ADT7470_FAN_COUNT; i++)
221 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM(i), pwm[i]);
222
6f9703d0
DW		 223 /* start reading temperature sensors */
224 cfg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
225 cfg |= 0x80;
226 i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, cfg);
227
2f22d5df 228 /* Delay is 200ms * number of temp sensors. */
89fac11c
DW		 229 res = msleep_interruptible((data->num_temp_sensors >= 0 ?
230 data->num_temp_sensors * 200 :
231 TEMP_COLLECTION_TIME));
6f9703d0
DW		 232
233 /* done reading temperature sensors */
234 cfg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
235 cfg &= ~0x80;
236 i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, cfg);
237
2e75a4b7
DW		 238 /* restore pwm[1-4] config registers */
239 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(0), pwm_cfg[0]);
240 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(2), pwm_cfg[1]);
241
89fac11c 242 if (res) {
2e991201 243 pr_err("ha ha, interrupted\n");
89fac11c
DW		 244 return -EAGAIN;
245 }
246
247 /* Only count fans if we have to */
248 if (data->num_temp_sensors >= 0)
249 return 0;
250
251 for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
6f9703d0
DW		 252 data->temp[i] = i2c_smbus_read_byte_data(client,
253 ADT7470_TEMP_REG(i));
89fac11c
DW		 254 if (data->temp[i])
255 data->num_temp_sensors = i + 1;
256 }
257 data->temperatures_probed = 1;
258 return 0;
259}
6f9703d0 260
89fac11c
DW		 261static int adt7470_update_thread(void *p)
262{
263 struct i2c_client *client = p;
264 struct adt7470_data *data = i2c_get_clientdata(client);
265
266 while (!kthread_should_stop()) {
267 mutex_lock(&data->lock);
268 adt7470_read_temperatures(client, data);
269 mutex_unlock(&data->lock);
270 if (kthread_should_stop())
271 break;
272 msleep_interruptible(data->auto_update_interval);
273 }
274
275 complete_all(&data->auto_update_stop);
276 return 0;
277}
278
279static struct adt7470_data *adt7470_update_device(struct device *dev)
280{
281 struct i2c_client *client = to_i2c_client(dev);
282 struct adt7470_data *data = i2c_get_clientdata(client);
283 unsigned long local_jiffies = jiffies;
284 u8 cfg;
285 int i;
286 int need_sensors = 1;
287 int need_limits = 1;
288
289 /*
290 * Figure out if we need to update the shadow registers.
291 * Lockless means that we may occasionally report out of
292 * date data.
293 */
294 if (time_before(local_jiffies, data->sensors_last_updated +
295 SENSOR_REFRESH_INTERVAL) &&
296 data->sensors_valid)
297 need_sensors = 0;
298
299 if (time_before(local_jiffies, data->limits_last_updated +
300 LIMIT_REFRESH_INTERVAL) &&
301 data->limits_valid)
302 need_limits = 0;
303
304 if (!need_sensors && !need_limits)
305 return data;
306
307 mutex_lock(&data->lock);
308 if (!need_sensors)
309 goto no_sensor_update;
310
311 if (!data->temperatures_probed)
312 adt7470_read_temperatures(client, data);
313 else
2f22d5df 314 for (i = 0; i < ADT7470_TEMP_COUNT; i++)
89fac11c
DW		 315 data->temp[i] = i2c_smbus_read_byte_data(client,
316 ADT7470_TEMP_REG(i));
2f22d5df 317
6f9703d0
DW		 318 for (i = 0; i < ADT7470_FAN_COUNT; i++)
319 data->fan[i] = adt7470_read_word_data(client,
320 ADT7470_REG_FAN(i));
321
322 for (i = 0; i < ADT7470_PWM_COUNT; i++) {
323 int reg;
324 int reg_mask;
325
326 data->pwm[i] = i2c_smbus_read_byte_data(client,
327 ADT7470_REG_PWM(i));
328
329 if (i % 2)
330 reg_mask = ADT7470_PWM2_AUTO_MASK;
331 else
332 reg_mask = ADT7470_PWM1_AUTO_MASK;
333
334 reg = ADT7470_REG_PWM_CFG(i);
335 if (i2c_smbus_read_byte_data(client, reg) & reg_mask)
336 data->pwm_automatic[i] = 1;
337 else
338 data->pwm_automatic[i] = 0;
339
340 reg = ADT7470_REG_PWM_AUTO_TEMP(i);
341 cfg = i2c_smbus_read_byte_data(client, reg);
342 if (!(i % 2))
343 data->pwm_auto_temp[i] = cfg >> 4;
344 else
345 data->pwm_auto_temp[i] = cfg & 0xF;
346 }
347
348 if (i2c_smbus_read_byte_data(client, ADT7470_REG_CFG) &
349 ADT7470_FSPD_MASK)
350 data->force_pwm_max = 1;
351 else
352 data->force_pwm_max = 0;
353
fe03f28c
DW		 354 data->alarm = i2c_smbus_read_byte_data(client, ADT7470_REG_ALARM1);
355 if (data->alarm & ADT7470_OOL_ALARM)
356 data->alarm |= ALARM2(i2c_smbus_read_byte_data(client,
357 ADT7470_REG_ALARM2));
6f9703d0
DW		 358 data->alarms_mask = adt7470_read_word_data(client,
359 ADT7470_REG_ALARM1_MASK);
360
361 data->sensors_last_updated = local_jiffies;
362 data->sensors_valid = 1;
363
364no_sensor_update:
89fac11c 365 if (!need_limits)
6f9703d0
DW		 366 goto out;
367
368 for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
369 data->temp_min[i] = i2c_smbus_read_byte_data(client,
370 ADT7470_TEMP_MIN_REG(i));
371 data->temp_max[i] = i2c_smbus_read_byte_data(client,
372 ADT7470_TEMP_MAX_REG(i));
373 }
374
375 for (i = 0; i < ADT7470_FAN_COUNT; i++) {
376 data->fan_min[i] = adt7470_read_word_data(client,
377 ADT7470_REG_FAN_MIN(i));
378 data->fan_max[i] = adt7470_read_word_data(client,
379 ADT7470_REG_FAN_MAX(i));
380 }
381
382 for (i = 0; i < ADT7470_PWM_COUNT; i++) {
383 data->pwm_max[i] = i2c_smbus_read_byte_data(client,
384 ADT7470_REG_PWM_MAX(i));
385 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
386 ADT7470_REG_PWM_MIN(i));
387 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
388 ADT7470_REG_PWM_TMIN(i));
389 }
390
391 data->limits_last_updated = local_jiffies;
392 data->limits_valid = 1;
393
394out:
395 mutex_unlock(&data->lock);
396 return data;
397}
398
89fac11c
DW		 399static ssize_t show_auto_update_interval(struct device *dev,
400 struct device_attribute *devattr,
401 char *buf)
402{
403 struct adt7470_data *data = adt7470_update_device(dev);
404 return sprintf(buf, "%d\n", data->auto_update_interval);
405}
406
407static ssize_t set_auto_update_interval(struct device *dev,
408 struct device_attribute *devattr,
409 const char *buf,
410 size_t count)
411{
412 struct i2c_client *client = to_i2c_client(dev);
413 struct adt7470_data *data = i2c_get_clientdata(client);
414 long temp;
415
179c4fdb 416 if (kstrtol(buf, 10, &temp))
89fac11c
DW		 417 return -EINVAL;
418
2a844c14 419 temp = clamp_val(temp, 0, 60000);
89fac11c
DW		 420
421 mutex_lock(&data->lock);
422 data->auto_update_interval = temp;
423 mutex_unlock(&data->lock);
424
425 return count;
426}
427
2f22d5df
DW		 428static ssize_t show_num_temp_sensors(struct device *dev,
429 struct device_attribute *devattr,
430 char *buf)
431{
432 struct adt7470_data *data = adt7470_update_device(dev);
433 return sprintf(buf, "%d\n", data->num_temp_sensors);
434}
435
436static ssize_t set_num_temp_sensors(struct device *dev,
437 struct device_attribute *devattr,
438 const char *buf,
439 size_t count)
440{
441 struct i2c_client *client = to_i2c_client(dev);
442 struct adt7470_data *data = i2c_get_clientdata(client);
443 long temp;
444
179c4fdb 445 if (kstrtol(buf, 10, &temp))
2f22d5df
DW		 446 return -EINVAL;
447
2a844c14 448 temp = clamp_val(temp, -1, 10);
2f22d5df
DW		 449
450 mutex_lock(&data->lock);
451 data->num_temp_sensors = temp;
89fac11c
DW		 452 if (temp < 0)
453 data->temperatures_probed = 0;
2f22d5df
DW		 454 mutex_unlock(&data->lock);
455
456 return count;
457}
458
6f9703d0
DW		 459static ssize_t show_temp_min(struct device *dev,
460 struct device_attribute *devattr,
461 char *buf)
462{
463 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
464 struct adt7470_data *data = adt7470_update_device(dev);
465 return sprintf(buf, "%d\n", 1000 * data->temp_min[attr->index]);
466}
467
468static ssize_t set_temp_min(struct device *dev,
469 struct device_attribute *devattr,
470 const char *buf,
471 size_t count)
472{
473 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
474 struct i2c_client *client = to_i2c_client(dev);
475 struct adt7470_data *data = i2c_get_clientdata(client);
05a9bd46
DW		 476 long temp;
477
179c4fdb 478 if (kstrtol(buf, 10, &temp))
05a9bd46
DW		 479 return -EINVAL;
480
8f8c1fb0 481 temp = DIV_ROUND_CLOSEST(temp, 1000);
de12d6f4 482 temp = clamp_val(temp, -128, 127);
6f9703d0
DW		 483
484 mutex_lock(&data->lock);
485 data->temp_min[attr->index] = temp;
486 i2c_smbus_write_byte_data(client, ADT7470_TEMP_MIN_REG(attr->index),
487 temp);
488 mutex_unlock(&data->lock);
489
490 return count;
491}
492
493static ssize_t show_temp_max(struct device *dev,
494 struct device_attribute *devattr,
495 char *buf)
496{
497 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
498 struct adt7470_data *data = adt7470_update_device(dev);
499 return sprintf(buf, "%d\n", 1000 * data->temp_max[attr->index]);
500}
501
502static ssize_t set_temp_max(struct device *dev,
503 struct device_attribute *devattr,
504 const char *buf,
505 size_t count)
506{
507 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
508 struct i2c_client *client = to_i2c_client(dev);
509 struct adt7470_data *data = i2c_get_clientdata(client);
05a9bd46
DW		 510 long temp;
511
179c4fdb 512 if (kstrtol(buf, 10, &temp))
05a9bd46
DW		 513 return -EINVAL;
514
8f8c1fb0 515 temp = DIV_ROUND_CLOSEST(temp, 1000);
de12d6f4 516 temp = clamp_val(temp, -128, 127);
6f9703d0
DW		 517
518 mutex_lock(&data->lock);
519 data->temp_max[attr->index] = temp;
520 i2c_smbus_write_byte_data(client, ADT7470_TEMP_MAX_REG(attr->index),
521 temp);
522 mutex_unlock(&data->lock);
523
524 return count;
525}
526
527static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
528 char *buf)
529{
530 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
531 struct adt7470_data *data = adt7470_update_device(dev);
532 return sprintf(buf, "%d\n", 1000 * data->temp[attr->index]);
533}
534
fe03f28c 535static ssize_t show_alarm_mask(struct device *dev,
6f9703d0
DW		 536 struct device_attribute *devattr,
537 char *buf)
538{
6f9703d0
DW		 539 struct adt7470_data *data = adt7470_update_device(dev);
540
fe03f28c 541 return sprintf(buf, "%x\n", data->alarms_mask);
6f9703d0
DW		 542}
543
544static ssize_t show_fan_max(struct device *dev,
545 struct device_attribute *devattr,
546 char *buf)
547{
548 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
549 struct adt7470_data *data = adt7470_update_device(dev);
550
551 if (FAN_DATA_VALID(data->fan_max[attr->index]))
552 return sprintf(buf, "%d\n",
553 FAN_PERIOD_TO_RPM(data->fan_max[attr->index]));
554 else
555 return sprintf(buf, "0\n");
556}
557
558static ssize_t set_fan_max(struct device *dev,
559 struct device_attribute *devattr,
560 const char *buf, size_t count)
561{
562 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
563 struct i2c_client *client = to_i2c_client(dev);
564 struct adt7470_data *data = i2c_get_clientdata(client);
05a9bd46 565 long temp;
6f9703d0 566
179c4fdb 567 if (kstrtol(buf, 10, &temp) || !temp)
6f9703d0 568 return -EINVAL;
05a9bd46 569
6f9703d0 570 temp = FAN_RPM_TO_PERIOD(temp);
2a844c14 571 temp = clamp_val(temp, 1, 65534);
6f9703d0
DW		 572
573 mutex_lock(&data->lock);
574 data->fan_max[attr->index] = temp;
575 adt7470_write_word_data(client, ADT7470_REG_FAN_MAX(attr->index), temp);
576 mutex_unlock(&data->lock);
577
578 return count;
579}
580
581static ssize_t show_fan_min(struct device *dev,
582 struct device_attribute *devattr,
583 char *buf)
584{
585 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
586 struct adt7470_data *data = adt7470_update_device(dev);
587
588 if (FAN_DATA_VALID(data->fan_min[attr->index]))
589 return sprintf(buf, "%d\n",
590 FAN_PERIOD_TO_RPM(data->fan_min[attr->index]));
591 else
592 return sprintf(buf, "0\n");
593}
594
595static ssize_t set_fan_min(struct device *dev,
596 struct device_attribute *devattr,
597 const char *buf, size_t count)
598{
599 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
600 struct i2c_client *client = to_i2c_client(dev);
601 struct adt7470_data *data = i2c_get_clientdata(client);
05a9bd46 602 long temp;
6f9703d0 603
179c4fdb 604 if (kstrtol(buf, 10, &temp) || !temp)
6f9703d0 605 return -EINVAL;
05a9bd46 606
6f9703d0 607 temp = FAN_RPM_TO_PERIOD(temp);
2a844c14 608 temp = clamp_val(temp, 1, 65534);
6f9703d0
DW		 609
610 mutex_lock(&data->lock);
611 data->fan_min[attr->index] = temp;
612 adt7470_write_word_data(client, ADT7470_REG_FAN_MIN(attr->index), temp);
613 mutex_unlock(&data->lock);
614
615 return count;
616}
617
618static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
619 char *buf)
620{
621 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
622 struct adt7470_data *data = adt7470_update_device(dev);
623
624 if (FAN_DATA_VALID(data->fan[attr->index]))
625 return sprintf(buf, "%d\n",
626 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
627 else
628 return sprintf(buf, "0\n");
629}
630
631static ssize_t show_force_pwm_max(struct device *dev,
632 struct device_attribute *devattr,
633 char *buf)
634{
635 struct adt7470_data *data = adt7470_update_device(dev);
636 return sprintf(buf, "%d\n", data->force_pwm_max);
637}
638
639static ssize_t set_force_pwm_max(struct device *dev,
640 struct device_attribute *devattr,
641 const char *buf,
642 size_t count)
643{
644 struct i2c_client *client = to_i2c_client(dev);
645 struct adt7470_data *data = i2c_get_clientdata(client);
05a9bd46 646 long temp;
6f9703d0
DW		 647 u8 reg;
648
179c4fdb 649 if (kstrtol(buf, 10, &temp))
05a9bd46
DW		 650 return -EINVAL;
651
6f9703d0
DW		 652 mutex_lock(&data->lock);
653 data->force_pwm_max = temp;
654 reg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
655 if (temp)
656 reg |= ADT7470_FSPD_MASK;
657 else
658 reg &= ~ADT7470_FSPD_MASK;
659 i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, reg);
660 mutex_unlock(&data->lock);
661
662 return count;
663}
664
665static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
666 char *buf)
667{
668 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
669 struct adt7470_data *data = adt7470_update_device(dev);
670 return sprintf(buf, "%d\n", data->pwm[attr->index]);
671}
672
673static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
674 const char *buf, size_t count)
675{
676 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
677 struct i2c_client *client = to_i2c_client(dev);
678 struct adt7470_data *data = i2c_get_clientdata(client);
05a9bd46
DW		 679 long temp;
680
179c4fdb 681 if (kstrtol(buf, 10, &temp))
05a9bd46
DW		 682 return -EINVAL;
683
2a844c14 684 temp = clamp_val(temp, 0, 255);
6f9703d0
DW		 685
686 mutex_lock(&data->lock);
687 data->pwm[attr->index] = temp;
688 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM(attr->index), temp);
689 mutex_unlock(&data->lock);
690
691 return count;
692}
693
694static ssize_t show_pwm_max(struct device *dev,
695 struct device_attribute *devattr,
696 char *buf)
697{
698 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
699 struct adt7470_data *data = adt7470_update_device(dev);
700 return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
701}
702
703static ssize_t set_pwm_max(struct device *dev,
704 struct device_attribute *devattr,
705 const char *buf,
706 size_t count)
707{
708 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
709 struct i2c_client *client = to_i2c_client(dev);
710 struct adt7470_data *data = i2c_get_clientdata(client);
05a9bd46
DW		 711 long temp;
712
179c4fdb 713 if (kstrtol(buf, 10, &temp))
05a9bd46
DW		 714 return -EINVAL;
715
2a844c14 716 temp = clamp_val(temp, 0, 255);
6f9703d0
DW		 717
718 mutex_lock(&data->lock);
719 data->pwm_max[attr->index] = temp;
720 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MAX(attr->index),
721 temp);
722 mutex_unlock(&data->lock);
723
724 return count;
725}
726
727static ssize_t show_pwm_min(struct device *dev,
728 struct device_attribute *devattr,
729 char *buf)
730{
731 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
732 struct adt7470_data *data = adt7470_update_device(dev);
733 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
734}
735
736static ssize_t set_pwm_min(struct device *dev,
737 struct device_attribute *devattr,
738 const char *buf,
739 size_t count)
740{
741 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
742 struct i2c_client *client = to_i2c_client(dev);
743 struct adt7470_data *data = i2c_get_clientdata(client);
05a9bd46
DW		 744 long temp;
745
179c4fdb 746 if (kstrtol(buf, 10, &temp))
05a9bd46
DW		 747 return -EINVAL;
748
2a844c14 749 temp = clamp_val(temp, 0, 255);
6f9703d0
DW		 750
751 mutex_lock(&data->lock);
752 data->pwm_min[attr->index] = temp;
753 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MIN(attr->index),
754 temp);
755 mutex_unlock(&data->lock);
756
757 return count;
758}
759
760static ssize_t show_pwm_tmax(struct device *dev,
761 struct device_attribute *devattr,
762 char *buf)
763{
764 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
765 struct adt7470_data *data = adt7470_update_device(dev);
766 /* the datasheet says that tmax = tmin + 20C */
767 return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
768}
769
770static ssize_t show_pwm_tmin(struct device *dev,
771 struct device_attribute *devattr,
772 char *buf)
773{
774 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
775 struct adt7470_data *data = adt7470_update_device(dev);
776 return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
777}
778
779static ssize_t set_pwm_tmin(struct device *dev,
780 struct device_attribute *devattr,
781 const char *buf,
782 size_t count)
783{
784 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
785 struct i2c_client *client = to_i2c_client(dev);
786 struct adt7470_data *data = i2c_get_clientdata(client);
05a9bd46
DW		 787 long temp;
788
179c4fdb 789 if (kstrtol(buf, 10, &temp))
05a9bd46
DW		 790 return -EINVAL;
791
8f8c1fb0 792 temp = DIV_ROUND_CLOSEST(temp, 1000);
de12d6f4 793 temp = clamp_val(temp, -128, 127);
6f9703d0
DW		 794
795 mutex_lock(&data->lock);
796 data->pwm_tmin[attr->index] = temp;
797 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_TMIN(attr->index),
798 temp);
799 mutex_unlock(&data->lock);
800
801 return count;
802}
803
804static ssize_t show_pwm_auto(struct device *dev,
805 struct device_attribute *devattr,
806 char *buf)
807{
808 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
809 struct adt7470_data *data = adt7470_update_device(dev);
810 return sprintf(buf, "%d\n", 1 + data->pwm_automatic[attr->index]);
811}
812
813static ssize_t set_pwm_auto(struct device *dev,
814 struct device_attribute *devattr,
815 const char *buf,
816 size_t count)
817{
818 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
819 struct i2c_client *client = to_i2c_client(dev);
820 struct adt7470_data *data = i2c_get_clientdata(client);
6f9703d0
DW		 821 int pwm_auto_reg = ADT7470_REG_PWM_CFG(attr->index);
822 int pwm_auto_reg_mask;
05a9bd46 823 long temp;
6f9703d0
DW		 824 u8 reg;
825
179c4fdb 826 if (kstrtol(buf, 10, &temp))
05a9bd46
DW		 827 return -EINVAL;
828
6f9703d0
DW		 829 if (attr->index % 2)
830 pwm_auto_reg_mask = ADT7470_PWM2_AUTO_MASK;
831 else
832 pwm_auto_reg_mask = ADT7470_PWM1_AUTO_MASK;
833
834 if (temp != 2 && temp != 1)
835 return -EINVAL;
836 temp--;
837
838 mutex_lock(&data->lock);
839 data->pwm_automatic[attr->index] = temp;
840 reg = i2c_smbus_read_byte_data(client, pwm_auto_reg);
841 if (temp)
842 reg |= pwm_auto_reg_mask;
843 else
844 reg &= ~pwm_auto_reg_mask;
845 i2c_smbus_write_byte_data(client, pwm_auto_reg, reg);
846 mutex_unlock(&data->lock);
847
848 return count;
849}
850
851static ssize_t show_pwm_auto_temp(struct device *dev,
852 struct device_attribute *devattr,
853 char *buf)
854{
855 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
856 struct adt7470_data *data = adt7470_update_device(dev);
857 u8 ctrl = data->pwm_auto_temp[attr->index];
858
859 if (ctrl)
860 return sprintf(buf, "%d\n", 1 << (ctrl - 1));
861 else
862 return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS);
863}
864
865static int cvt_auto_temp(int input)
866{
867 if (input == ADT7470_PWM_ALL_TEMPS)
868 return 0;
ce9c2f44 869 if (input < 1 || !is_power_of_2(input))
6f9703d0
DW		 870 return -EINVAL;
871 return ilog2(input) + 1;
872}
873
874static ssize_t set_pwm_auto_temp(struct device *dev,
875 struct device_attribute *devattr,
876 const char *buf,
877 size_t count)
878{
879 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
880 struct i2c_client *client = to_i2c_client(dev);
881 struct adt7470_data *data = i2c_get_clientdata(client);
6f9703d0 882 int pwm_auto_reg = ADT7470_REG_PWM_AUTO_TEMP(attr->index);
05a9bd46 883 long temp;
6f9703d0
DW		 884 u8 reg;
885
179c4fdb 886 if (kstrtol(buf, 10, &temp))
05a9bd46
DW		 887 return -EINVAL;
888
889 temp = cvt_auto_temp(temp);
6f9703d0
DW		 890 if (temp < 0)
891 return temp;
892
893 mutex_lock(&data->lock);
894 data->pwm_automatic[attr->index] = temp;
895 reg = i2c_smbus_read_byte_data(client, pwm_auto_reg);
896
897 if (!(attr->index % 2)) {
898 reg &= 0xF;
899 reg |= (temp << 4) & 0xF0;
900 } else {
901 reg &= 0xF0;
902 reg |= temp & 0xF;
903 }
904
905 i2c_smbus_write_byte_data(client, pwm_auto_reg, reg);
906 mutex_unlock(&data->lock);
907
908 return count;
909}
910
fe03f28c
DW		 911static ssize_t show_alarm(struct device *dev,
912 struct device_attribute *devattr,
913 char *buf)
914{
915 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
916 struct adt7470_data *data = adt7470_update_device(dev);
917
918 if (data->alarm & attr->index)
919 return sprintf(buf, "1\n");
920 else
921 return sprintf(buf, "0\n");
922}
923
924static DEVICE_ATTR(alarm_mask, S_IRUGO, show_alarm_mask, NULL);
2f22d5df
DW		 925static DEVICE_ATTR(num_temp_sensors, S_IWUSR | S_IRUGO, show_num_temp_sensors,
926 set_num_temp_sensors);
89fac11c
DW		 927static DEVICE_ATTR(auto_update_interval, S_IWUSR | S_IRUGO,
928 show_auto_update_interval, set_auto_update_interval);
6f9703d0
DW		 929
930static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
931 set_temp_max, 0);
932static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
933 set_temp_max, 1);
934static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
935 set_temp_max, 2);
936static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max,
937 set_temp_max, 3);
938static SENSOR_DEVICE_ATTR(temp5_max, S_IWUSR | S_IRUGO, show_temp_max,
939 set_temp_max, 4);
940static SENSOR_DEVICE_ATTR(temp6_max, S_IWUSR | S_IRUGO, show_temp_max,
941 set_temp_max, 5);
942static SENSOR_DEVICE_ATTR(temp7_max, S_IWUSR | S_IRUGO, show_temp_max,
943 set_temp_max, 6);
944static SENSOR_DEVICE_ATTR(temp8_max, S_IWUSR | S_IRUGO, show_temp_max,
945 set_temp_max, 7);
946static SENSOR_DEVICE_ATTR(temp9_max, S_IWUSR | S_IRUGO, show_temp_max,
947 set_temp_max, 8);
948static SENSOR_DEVICE_ATTR(temp10_max, S_IWUSR | S_IRUGO, show_temp_max,
949 set_temp_max, 9);
950
951static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
952 set_temp_min, 0);
953static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
954 set_temp_min, 1);
955static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
956 set_temp_min, 2);
957static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min,
958 set_temp_min, 3);
959static SENSOR_DEVICE_ATTR(temp5_min, S_IWUSR | S_IRUGO, show_temp_min,
960 set_temp_min, 4);
961static SENSOR_DEVICE_ATTR(temp6_min, S_IWUSR | S_IRUGO, show_temp_min,
962 set_temp_min, 5);
963static SENSOR_DEVICE_ATTR(temp7_min, S_IWUSR | S_IRUGO, show_temp_min,
964 set_temp_min, 6);
965static SENSOR_DEVICE_ATTR(temp8_min, S_IWUSR | S_IRUGO, show_temp_min,
966 set_temp_min, 7);
967static SENSOR_DEVICE_ATTR(temp9_min, S_IWUSR | S_IRUGO, show_temp_min,
968 set_temp_min, 8);
969static SENSOR_DEVICE_ATTR(temp10_min, S_IWUSR | S_IRUGO, show_temp_min,
970 set_temp_min, 9);
971
972static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
973static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
974static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
975static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
976static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4);
977static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp, NULL, 5);
978static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, show_temp, NULL, 6);
979static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, show_temp, NULL, 7);
980static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO, show_temp, NULL, 8);
981static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, show_temp, NULL, 9);
982
fe03f28c
DW		 983static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
984 ADT7470_R1T_ALARM);
985static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
986 ADT7470_R2T_ALARM);
987static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
988 ADT7470_R3T_ALARM);
989static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL,
990 ADT7470_R4T_ALARM);
991static SENSOR_DEVICE_ATTR(temp5_alarm, S_IRUGO, show_alarm, NULL,
992 ADT7470_R5T_ALARM);
993static SENSOR_DEVICE_ATTR(temp6_alarm, S_IRUGO, show_alarm, NULL,
994 ADT7470_R6T_ALARM);
995static SENSOR_DEVICE_ATTR(temp7_alarm, S_IRUGO, show_alarm, NULL,
996 ADT7470_R7T_ALARM);
997static SENSOR_DEVICE_ATTR(temp8_alarm, S_IRUGO, show_alarm, NULL,
998 ALARM2(ADT7470_R8T_ALARM));
999static SENSOR_DEVICE_ATTR(temp9_alarm, S_IRUGO, show_alarm, NULL,
1000 ALARM2(ADT7470_R9T_ALARM));
1001static SENSOR_DEVICE_ATTR(temp10_alarm, S_IRUGO, show_alarm, NULL,
1002 ALARM2(ADT7470_R10T_ALARM));
1003
6f9703d0
DW		 1004static SENSOR_DEVICE_ATTR(fan1_max, S_IWUSR | S_IRUGO, show_fan_max,
1005 set_fan_max, 0);
1006static SENSOR_DEVICE_ATTR(fan2_max, S_IWUSR | S_IRUGO, show_fan_max,
1007 set_fan_max, 1);
1008static SENSOR_DEVICE_ATTR(fan3_max, S_IWUSR | S_IRUGO, show_fan_max,
1009 set_fan_max, 2);
1010static SENSOR_DEVICE_ATTR(fan4_max, S_IWUSR | S_IRUGO, show_fan_max,
1011 set_fan_max, 3);
1012
1013static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1014 set_fan_min, 0);
1015static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1016 set_fan_min, 1);
1017static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1018 set_fan_min, 2);
1019static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1020 set_fan_min, 3);
1021
1022static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
1023static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
1024static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
1025static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
1026
fe03f28c
DW		 1027static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
1028 ALARM2(ADT7470_FAN1_ALARM));
1029static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
1030 ALARM2(ADT7470_FAN2_ALARM));
1031static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
1032 ALARM2(ADT7470_FAN3_ALARM));
1033static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
1034 ALARM2(ADT7470_FAN4_ALARM));
1035
6f9703d0
DW		 1036static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO,
1037 show_force_pwm_max, set_force_pwm_max, 0);
1038
1039static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
1040static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
1041static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
1042static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
1043
1044static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
1045 show_pwm_min, set_pwm_min, 0);
1046static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
1047 show_pwm_min, set_pwm_min, 1);
1048static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
1049 show_pwm_min, set_pwm_min, 2);
1050static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
1051 show_pwm_min, set_pwm_min, 3);
1052
1053static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
1054 show_pwm_max, set_pwm_max, 0);
1055static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
1056 show_pwm_max, set_pwm_max, 1);
1057static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
1058 show_pwm_max, set_pwm_max, 2);
1059static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
1060 show_pwm_max, set_pwm_max, 3);
1061
1062static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp, S_IWUSR | S_IRUGO,
1063 show_pwm_tmin, set_pwm_tmin, 0);
1064static SENSOR_DEVICE_ATTR(pwm2_auto_point1_temp, S_IWUSR | S_IRUGO,
1065 show_pwm_tmin, set_pwm_tmin, 1);
1066static SENSOR_DEVICE_ATTR(pwm3_auto_point1_temp, S_IWUSR | S_IRUGO,
1067 show_pwm_tmin, set_pwm_tmin, 2);
1068static SENSOR_DEVICE_ATTR(pwm4_auto_point1_temp, S_IWUSR | S_IRUGO,
1069 show_pwm_tmin, set_pwm_tmin, 3);
1070
1071static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp, S_IRUGO, show_pwm_tmax,
1072 NULL, 0);
1073static SENSOR_DEVICE_ATTR(pwm2_auto_point2_temp, S_IRUGO, show_pwm_tmax,
1074 NULL, 1);
1075static SENSOR_DEVICE_ATTR(pwm3_auto_point2_temp, S_IRUGO, show_pwm_tmax,
1076 NULL, 2);
1077static SENSOR_DEVICE_ATTR(pwm4_auto_point2_temp, S_IRUGO, show_pwm_tmax,
1078 NULL, 3);
1079
1080static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1081 set_pwm_auto, 0);
1082static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1083 set_pwm_auto, 1);
1084static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1085 set_pwm_auto, 2);
1086static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1087 set_pwm_auto, 3);
1088
1089static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
1090 show_pwm_auto_temp, set_pwm_auto_temp, 0);
1091static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
1092 show_pwm_auto_temp, set_pwm_auto_temp, 1);
1093static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
1094 show_pwm_auto_temp, set_pwm_auto_temp, 2);
1095static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO,
1096 show_pwm_auto_temp, set_pwm_auto_temp, 3);
1097
6b904b62 1098static struct attribute *adt7470_attr[] = {
fe03f28c 1099 &dev_attr_alarm_mask.attr,
2f22d5df 1100 &dev_attr_num_temp_sensors.attr,
89fac11c 1101 &dev_attr_auto_update_interval.attr,
6f9703d0
DW		 1102 &sensor_dev_attr_temp1_max.dev_attr.attr,
1103 &sensor_dev_attr_temp2_max.dev_attr.attr,
1104 &sensor_dev_attr_temp3_max.dev_attr.attr,
1105 &sensor_dev_attr_temp4_max.dev_attr.attr,
1106 &sensor_dev_attr_temp5_max.dev_attr.attr,
1107 &sensor_dev_attr_temp6_max.dev_attr.attr,
1108 &sensor_dev_attr_temp7_max.dev_attr.attr,
1109 &sensor_dev_attr_temp8_max.dev_attr.attr,
1110 &sensor_dev_attr_temp9_max.dev_attr.attr,
1111 &sensor_dev_attr_temp10_max.dev_attr.attr,
1112 &sensor_dev_attr_temp1_min.dev_attr.attr,
1113 &sensor_dev_attr_temp2_min.dev_attr.attr,
1114 &sensor_dev_attr_temp3_min.dev_attr.attr,
1115 &sensor_dev_attr_temp4_min.dev_attr.attr,
1116 &sensor_dev_attr_temp5_min.dev_attr.attr,
1117 &sensor_dev_attr_temp6_min.dev_attr.attr,
1118 &sensor_dev_attr_temp7_min.dev_attr.attr,
1119 &sensor_dev_attr_temp8_min.dev_attr.attr,
1120 &sensor_dev_attr_temp9_min.dev_attr.attr,
1121 &sensor_dev_attr_temp10_min.dev_attr.attr,
1122 &sensor_dev_attr_temp1_input.dev_attr.attr,
1123 &sensor_dev_attr_temp2_input.dev_attr.attr,
1124 &sensor_dev_attr_temp3_input.dev_attr.attr,
1125 &sensor_dev_attr_temp4_input.dev_attr.attr,
1126 &sensor_dev_attr_temp5_input.dev_attr.attr,
1127 &sensor_dev_attr_temp6_input.dev_attr.attr,
1128 &sensor_dev_attr_temp7_input.dev_attr.attr,
1129 &sensor_dev_attr_temp8_input.dev_attr.attr,
1130 &sensor_dev_attr_temp9_input.dev_attr.attr,
1131 &sensor_dev_attr_temp10_input.dev_attr.attr,
fe03f28c
DW		 1132 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1133 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1134 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1135 &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1136 &sensor_dev_attr_temp5_alarm.dev_attr.attr,
1137 &sensor_dev_attr_temp6_alarm.dev_attr.attr,
1138 &sensor_dev_attr_temp7_alarm.dev_attr.attr,
1139 &sensor_dev_attr_temp8_alarm.dev_attr.attr,
1140 &sensor_dev_attr_temp9_alarm.dev_attr.attr,
1141 &sensor_dev_attr_temp10_alarm.dev_attr.attr,
6f9703d0
DW		 1142 &sensor_dev_attr_fan1_max.dev_attr.attr,
1143 &sensor_dev_attr_fan2_max.dev_attr.attr,
1144 &sensor_dev_attr_fan3_max.dev_attr.attr,
1145 &sensor_dev_attr_fan4_max.dev_attr.attr,
1146 &sensor_dev_attr_fan1_min.dev_attr.attr,
1147 &sensor_dev_attr_fan2_min.dev_attr.attr,
1148 &sensor_dev_attr_fan3_min.dev_attr.attr,
1149 &sensor_dev_attr_fan4_min.dev_attr.attr,
1150 &sensor_dev_attr_fan1_input.dev_attr.attr,
1151 &sensor_dev_attr_fan2_input.dev_attr.attr,
1152 &sensor_dev_attr_fan3_input.dev_attr.attr,
1153 &sensor_dev_attr_fan4_input.dev_attr.attr,
fe03f28c
DW		 1154 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1155 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1156 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1157 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
6f9703d0
DW		 1158 &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1159 &sensor_dev_attr_pwm1.dev_attr.attr,
1160 &sensor_dev_attr_pwm2.dev_attr.attr,
1161 &sensor_dev_attr_pwm3.dev_attr.attr,
1162 &sensor_dev_attr_pwm4.dev_attr.attr,
1163 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1164 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1165 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1166 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1167 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1168 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1169 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1170 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1171 &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
1172 &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
1173 &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
1174 &sensor_dev_attr_pwm4_auto_point1_temp.dev_attr.attr,
1175 &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
1176 &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
1177 &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
1178 &sensor_dev_attr_pwm4_auto_point2_temp.dev_attr.attr,
1179 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1180 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1181 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1182 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1183 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1184 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1185 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1186 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1187 NULL
1188};
1189
008f1ca5 1190/* Return 0 if detection is successful, -ENODEV otherwise */
310ec792 1191static int adt7470_detect(struct i2c_client *client,
008f1ca5 1192 struct i2c_board_info *info)
6f9703d0 1193{
008f1ca5 1194 struct i2c_adapter *adapter = client->adapter;
52df6440 1195 int vendor, device, revision;
6f9703d0
DW		 1196
1197 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
008f1ca5 1198 return -ENODEV;
6f9703d0 1199
52df6440
JD		 1200 vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR);
1201 if (vendor != ADT7470_VENDOR)
1202 return -ENODEV;
6f9703d0 1203
52df6440
JD		 1204 device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE);
1205 if (device != ADT7470_DEVICE)
1206 return -ENODEV;
6f9703d0 1207
52df6440
JD		 1208 revision = i2c_smbus_read_byte_data(client, ADT7470_REG_REVISION);
1209 if (revision != ADT7470_REVISION)
1210 return -ENODEV;
6f9703d0 1211
008f1ca5 1212 strlcpy(info->type, "adt7470", I2C_NAME_SIZE);
6f9703d0 1213
008f1ca5
JD		 1214 return 0;
1215}
1216
9027d933
AL		 1217static void adt7470_init_client(struct i2c_client *client)
1218{
1219 int reg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
1220
1221 if (reg < 0) {
1222 dev_err(&client->dev, "cannot read configuration register\n");
1223 } else {
1224 /* start monitoring (and do a self-test) */
1225 i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, reg | 3);
1226 }
1227}
1228
008f1ca5
JD		 1229static int adt7470_probe(struct i2c_client *client,
1230 const struct i2c_device_id *id)
1231{
1232 struct adt7470_data *data;
1233 int err;
1234
9cc7dcc5
GR		 1235 data = devm_kzalloc(&client->dev, sizeof(struct adt7470_data),
1236 GFP_KERNEL);
1237 if (!data)
1238 return -ENOMEM;
008f1ca5 1239
2f22d5df 1240 data->num_temp_sensors = -1;
89fac11c 1241 data->auto_update_interval = AUTO_UPDATE_INTERVAL;
2f22d5df 1242
008f1ca5
JD		 1243 i2c_set_clientdata(client, data);
1244 mutex_init(&data->lock);
6f9703d0
DW		 1245
1246 dev_info(&client->dev, "%s chip found\n", client->name);
1247
1248 /* Initialize the ADT7470 chip */
1249 adt7470_init_client(client);
1250
1251 /* Register sysfs hooks */
1252 data->attrs.attrs = adt7470_attr;
6b904b62
FM		 1253 err = sysfs_create_group(&client->dev.kobj, &data->attrs);
1254 if (err)
9cc7dcc5 1255 return err;
6f9703d0 1256
1beeffe4
TJ		 1257 data->hwmon_dev = hwmon_device_register(&client->dev);
1258 if (IS_ERR(data->hwmon_dev)) {
1259 err = PTR_ERR(data->hwmon_dev);
6f9703d0
DW		 1260 goto exit_remove;
1261 }
1262
89fac11c 1263 init_completion(&data->auto_update_stop);
f170168b 1264 data->auto_update = kthread_run(adt7470_update_thread, client, "%s",
89fac11c 1265 dev_name(data->hwmon_dev));
f7334b4c
AL		 1266 if (IS_ERR(data->auto_update)) {
1267 err = PTR_ERR(data->auto_update);
89fac11c 1268 goto exit_unregister;
f7334b4c 1269 }
89fac11c 1270
6f9703d0
DW		 1271 return 0;
1272
89fac11c
DW		 1273exit_unregister:
1274 hwmon_device_unregister(data->hwmon_dev);
6f9703d0
DW		 1275exit_remove:
1276 sysfs_remove_group(&client->dev.kobj, &data->attrs);
6f9703d0
DW		 1277 return err;
1278}
1279
008f1ca5 1280static int adt7470_remove(struct i2c_client *client)
6f9703d0
DW		 1281{
1282 struct adt7470_data *data = i2c_get_clientdata(client);
1283
89fac11c
DW		 1284 kthread_stop(data->auto_update);
1285 wait_for_completion(&data->auto_update_stop);
1beeffe4 1286 hwmon_device_unregister(data->hwmon_dev);
6f9703d0 1287 sysfs_remove_group(&client->dev.kobj, &data->attrs);
6f9703d0
DW		 1288 return 0;
1289}
1290
9027d933
AL		 1291static const struct i2c_device_id adt7470_id[] = {
1292 { "adt7470", 0 },
1293 { }
1294};
1295MODULE_DEVICE_TABLE(i2c, adt7470_id);
1296
1297static struct i2c_driver adt7470_driver = {
1298 .class = I2C_CLASS_HWMON,
1299 .driver = {
1300 .name = "adt7470",
1301 },
1302 .probe = adt7470_probe,
1303 .remove = adt7470_remove,
1304 .id_table = adt7470_id,
1305 .detect = adt7470_detect,
1306 .address_list = normal_i2c,
1307};
1308
f0967eea 1309module_i2c_driver(adt7470_driver);
6f9703d0 1310
5407e051 1311MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
6f9703d0
DW		 1312MODULE_DESCRIPTION("ADT7470 driver");
1313MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 3.284646 seconds and 5 git commands to generate.