2 * A hwmon driver for the Analog Devices ADT7470
3 * Copyright (C) 2007 IBM
5 * Author: Darrick J. Wong <djwong@us.ibm.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 #include <linux/module.h>
23 #include <linux/jiffies.h>
24 #include <linux/i2c.h>
25 #include <linux/hwmon.h>
26 #include <linux/hwmon-sysfs.h>
27 #include <linux/err.h>
28 #include <linux/mutex.h>
29 #include <linux/delay.h>
30 #include <linux/log2.h>
32 /* Addresses to scan */
33 static unsigned short normal_i2c
[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END
};
35 /* Insmod parameters */
36 I2C_CLIENT_INSMOD_1(adt7470
);
38 /* ADT7470 registers */
39 #define ADT7470_REG_BASE_ADDR 0x20
40 #define ADT7470_REG_TEMP_BASE_ADDR 0x20
41 #define ADT7470_REG_TEMP_MAX_ADDR 0x29
42 #define ADT7470_REG_FAN_BASE_ADDR 0x2A
43 #define ADT7470_REG_FAN_MAX_ADDR 0x31
44 #define ADT7470_REG_PWM_BASE_ADDR 0x32
45 #define ADT7470_REG_PWM_MAX_ADDR 0x35
46 #define ADT7470_REG_PWM_MAX_BASE_ADDR 0x38
47 #define ADT7470_REG_PWM_MAX_MAX_ADDR 0x3B
48 #define ADT7470_REG_CFG 0x40
49 #define ADT7470_FSPD_MASK 0x04
50 #define ADT7470_REG_ALARM1 0x41
51 #define ADT7470_REG_ALARM2 0x42
52 #define ADT7470_REG_TEMP_LIMITS_BASE_ADDR 0x44
53 #define ADT7470_REG_TEMP_LIMITS_MAX_ADDR 0x57
54 #define ADT7470_REG_FAN_MIN_BASE_ADDR 0x58
55 #define ADT7470_REG_FAN_MIN_MAX_ADDR 0x5F
56 #define ADT7470_REG_FAN_MAX_BASE_ADDR 0x60
57 #define ADT7470_REG_FAN_MAX_MAX_ADDR 0x67
58 #define ADT7470_REG_PWM_CFG_BASE_ADDR 0x68
59 #define ADT7470_REG_PWM12_CFG 0x68
60 #define ADT7470_PWM2_AUTO_MASK 0x40
61 #define ADT7470_PWM1_AUTO_MASK 0x80
62 #define ADT7470_REG_PWM34_CFG 0x69
63 #define ADT7470_PWM3_AUTO_MASK 0x40
64 #define ADT7470_PWM4_AUTO_MASK 0x80
65 #define ADT7470_REG_PWM_MIN_BASE_ADDR 0x6A
66 #define ADT7470_REG_PWM_MIN_MAX_ADDR 0x6D
67 #define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR 0x6E
68 #define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR 0x71
69 #define ADT7470_REG_ACOUSTICS12 0x75
70 #define ADT7470_REG_ACOUSTICS34 0x76
71 #define ADT7470_REG_DEVICE 0x3D
72 #define ADT7470_REG_VENDOR 0x3E
73 #define ADT7470_REG_REVISION 0x3F
74 #define ADT7470_REG_ALARM1_MASK 0x72
75 #define ADT7470_REG_ALARM2_MASK 0x73
76 #define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR 0x7C
77 #define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR 0x7D
78 #define ADT7470_REG_MAX_ADDR 0x81
80 #define ADT7470_TEMP_COUNT 10
81 #define ADT7470_TEMP_REG(x) (ADT7470_REG_TEMP_BASE_ADDR + (x))
82 #define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
83 #define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \
86 #define ADT7470_FAN_COUNT 4
87 #define ADT7470_REG_FAN(x) (ADT7470_REG_FAN_BASE_ADDR + ((x) * 2))
88 #define ADT7470_REG_FAN_MIN(x) (ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
89 #define ADT7470_REG_FAN_MAX(x) (ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2))
91 #define ADT7470_PWM_COUNT 4
92 #define ADT7470_REG_PWM(x) (ADT7470_REG_PWM_BASE_ADDR + (x))
93 #define ADT7470_REG_PWM_MAX(x) (ADT7470_REG_PWM_MAX_BASE_ADDR + (x))
94 #define ADT7470_REG_PWM_MIN(x) (ADT7470_REG_PWM_MIN_BASE_ADDR + (x))
95 #define ADT7470_REG_PWM_TMIN(x) (ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
96 #define ADT7470_REG_PWM_CFG(x) (ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2))
97 #define ADT7470_REG_PWM_AUTO_TEMP(x) (ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \
100 #define ADT7470_VENDOR 0x41
101 #define ADT7470_DEVICE 0x70
102 /* datasheet only mentions a revision 2 */
103 #define ADT7470_REVISION 0x02
105 /* "all temps" according to hwmon sysfs interface spec */
106 #define ADT7470_PWM_ALL_TEMPS 0x3FF
108 /* How often do we reread sensors values? (In jiffies) */
109 #define SENSOR_REFRESH_INTERVAL (5 * HZ)
111 /* How often do we reread sensor limit values? (In jiffies) */
112 #define LIMIT_REFRESH_INTERVAL (60 * HZ)
114 /* sleep 1s while gathering temperature data */
115 #define TEMP_COLLECTION_TIME 1000
117 /* datasheet says to divide this number by the fan reading to get fan rpm */
118 #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
119 #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
120 #define FAN_PERIOD_INVALID 65535
121 #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
123 struct adt7470_data
{
124 struct i2c_client client
;
125 struct device
*hwmon_dev
;
126 struct attribute_group attrs
;
130 unsigned long sensors_last_updated
; /* In jiffies */
131 unsigned long limits_last_updated
; /* In jiffies */
133 s8 temp
[ADT7470_TEMP_COUNT
];
134 s8 temp_min
[ADT7470_TEMP_COUNT
];
135 s8 temp_max
[ADT7470_TEMP_COUNT
];
136 u16 fan
[ADT7470_FAN_COUNT
];
137 u16 fan_min
[ADT7470_FAN_COUNT
];
138 u16 fan_max
[ADT7470_FAN_COUNT
];
139 u16 alarms
, alarms_mask
;
141 u8 pwm
[ADT7470_PWM_COUNT
];
142 u8 pwm_max
[ADT7470_PWM_COUNT
];
143 u8 pwm_automatic
[ADT7470_PWM_COUNT
];
144 u8 pwm_min
[ADT7470_PWM_COUNT
];
145 s8 pwm_tmin
[ADT7470_PWM_COUNT
];
146 u8 pwm_auto_temp
[ADT7470_PWM_COUNT
];
149 static int adt7470_attach_adapter(struct i2c_adapter
*adapter
);
150 static int adt7470_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
151 static int adt7470_detach_client(struct i2c_client
*client
);
153 static struct i2c_driver adt7470_driver
= {
157 .attach_adapter
= adt7470_attach_adapter
,
158 .detach_client
= adt7470_detach_client
,
162 * 16-bit registers on the ADT7470 are low-byte first. The data sheet says
163 * that the low byte must be read before the high byte.
165 static inline int adt7470_read_word_data(struct i2c_client
*client
, u8 reg
)
168 foo
= i2c_smbus_read_byte_data(client
, reg
);
169 foo
|= ((u16
)i2c_smbus_read_byte_data(client
, reg
+ 1) << 8);
173 static inline int adt7470_write_word_data(struct i2c_client
*client
, u8 reg
,
176 return i2c_smbus_write_byte_data(client
, reg
, value
& 0xFF)
177 && i2c_smbus_write_byte_data(client
, reg
+ 1, value
>> 8);
180 static void adt7470_init_client(struct i2c_client
*client
)
182 int reg
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
);
185 dev_err(&client
->dev
, "cannot read configuration register\n");
187 /* start monitoring (and do a self-test) */
188 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG
, reg
| 3);
192 static struct adt7470_data
*adt7470_update_device(struct device
*dev
)
194 struct i2c_client
*client
= to_i2c_client(dev
);
195 struct adt7470_data
*data
= i2c_get_clientdata(client
);
196 unsigned long local_jiffies
= jiffies
;
200 mutex_lock(&data
->lock
);
201 if (time_before(local_jiffies
, data
->sensors_last_updated
+
202 SENSOR_REFRESH_INTERVAL
)
203 && data
->sensors_valid
)
204 goto no_sensor_update
;
206 /* start reading temperature sensors */
207 cfg
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
);
209 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG
, cfg
);
212 * Delay is 200ms * number of tmp05 sensors. Too bad
213 * there's no way to figure out how many are connected.
214 * For now, assume 1s will work.
216 msleep(TEMP_COLLECTION_TIME
);
218 /* done reading temperature sensors */
219 cfg
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
);
221 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG
, cfg
);
223 for (i
= 0; i
< ADT7470_TEMP_COUNT
; i
++)
224 data
->temp
[i
] = i2c_smbus_read_byte_data(client
,
225 ADT7470_TEMP_REG(i
));
227 for (i
= 0; i
< ADT7470_FAN_COUNT
; i
++)
228 data
->fan
[i
] = adt7470_read_word_data(client
,
231 for (i
= 0; i
< ADT7470_PWM_COUNT
; i
++) {
235 data
->pwm
[i
] = i2c_smbus_read_byte_data(client
,
239 reg_mask
= ADT7470_PWM2_AUTO_MASK
;
241 reg_mask
= ADT7470_PWM1_AUTO_MASK
;
243 reg
= ADT7470_REG_PWM_CFG(i
);
244 if (i2c_smbus_read_byte_data(client
, reg
) & reg_mask
)
245 data
->pwm_automatic
[i
] = 1;
247 data
->pwm_automatic
[i
] = 0;
249 reg
= ADT7470_REG_PWM_AUTO_TEMP(i
);
250 cfg
= i2c_smbus_read_byte_data(client
, reg
);
252 data
->pwm_auto_temp
[i
] = cfg
>> 4;
254 data
->pwm_auto_temp
[i
] = cfg
& 0xF;
257 if (i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
) &
259 data
->force_pwm_max
= 1;
261 data
->force_pwm_max
= 0;
263 data
->alarms
= adt7470_read_word_data(client
, ADT7470_REG_ALARM1
);
264 data
->alarms_mask
= adt7470_read_word_data(client
,
265 ADT7470_REG_ALARM1_MASK
);
267 data
->sensors_last_updated
= local_jiffies
;
268 data
->sensors_valid
= 1;
271 if (time_before(local_jiffies
, data
->limits_last_updated
+
272 LIMIT_REFRESH_INTERVAL
)
273 && data
->limits_valid
)
276 for (i
= 0; i
< ADT7470_TEMP_COUNT
; i
++) {
277 data
->temp_min
[i
] = i2c_smbus_read_byte_data(client
,
278 ADT7470_TEMP_MIN_REG(i
));
279 data
->temp_max
[i
] = i2c_smbus_read_byte_data(client
,
280 ADT7470_TEMP_MAX_REG(i
));
283 for (i
= 0; i
< ADT7470_FAN_COUNT
; i
++) {
284 data
->fan_min
[i
] = adt7470_read_word_data(client
,
285 ADT7470_REG_FAN_MIN(i
));
286 data
->fan_max
[i
] = adt7470_read_word_data(client
,
287 ADT7470_REG_FAN_MAX(i
));
290 for (i
= 0; i
< ADT7470_PWM_COUNT
; i
++) {
291 data
->pwm_max
[i
] = i2c_smbus_read_byte_data(client
,
292 ADT7470_REG_PWM_MAX(i
));
293 data
->pwm_min
[i
] = i2c_smbus_read_byte_data(client
,
294 ADT7470_REG_PWM_MIN(i
));
295 data
->pwm_tmin
[i
] = i2c_smbus_read_byte_data(client
,
296 ADT7470_REG_PWM_TMIN(i
));
299 data
->limits_last_updated
= local_jiffies
;
300 data
->limits_valid
= 1;
303 mutex_unlock(&data
->lock
);
307 static ssize_t
show_temp_min(struct device
*dev
,
308 struct device_attribute
*devattr
,
311 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
312 struct adt7470_data
*data
= adt7470_update_device(dev
);
313 return sprintf(buf
, "%d\n", 1000 * data
->temp_min
[attr
->index
]);
316 static ssize_t
set_temp_min(struct device
*dev
,
317 struct device_attribute
*devattr
,
321 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
322 struct i2c_client
*client
= to_i2c_client(dev
);
323 struct adt7470_data
*data
= i2c_get_clientdata(client
);
324 int temp
= simple_strtol(buf
, NULL
, 10) / 1000;
326 mutex_lock(&data
->lock
);
327 data
->temp_min
[attr
->index
] = temp
;
328 i2c_smbus_write_byte_data(client
, ADT7470_TEMP_MIN_REG(attr
->index
),
330 mutex_unlock(&data
->lock
);
335 static ssize_t
show_temp_max(struct device
*dev
,
336 struct device_attribute
*devattr
,
339 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
340 struct adt7470_data
*data
= adt7470_update_device(dev
);
341 return sprintf(buf
, "%d\n", 1000 * data
->temp_max
[attr
->index
]);
344 static ssize_t
set_temp_max(struct device
*dev
,
345 struct device_attribute
*devattr
,
349 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
350 struct i2c_client
*client
= to_i2c_client(dev
);
351 struct adt7470_data
*data
= i2c_get_clientdata(client
);
352 int temp
= simple_strtol(buf
, NULL
, 10) / 1000;
354 mutex_lock(&data
->lock
);
355 data
->temp_max
[attr
->index
] = temp
;
356 i2c_smbus_write_byte_data(client
, ADT7470_TEMP_MAX_REG(attr
->index
),
358 mutex_unlock(&data
->lock
);
363 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*devattr
,
366 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
367 struct adt7470_data
*data
= adt7470_update_device(dev
);
368 return sprintf(buf
, "%d\n", 1000 * data
->temp
[attr
->index
]);
371 static ssize_t
show_alarms(struct device
*dev
,
372 struct device_attribute
*devattr
,
375 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
376 struct adt7470_data
*data
= adt7470_update_device(dev
);
379 return sprintf(buf
, "%x\n", data
->alarms
);
381 return sprintf(buf
, "%x\n", data
->alarms_mask
);
384 static ssize_t
show_fan_max(struct device
*dev
,
385 struct device_attribute
*devattr
,
388 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
389 struct adt7470_data
*data
= adt7470_update_device(dev
);
391 if (FAN_DATA_VALID(data
->fan_max
[attr
->index
]))
392 return sprintf(buf
, "%d\n",
393 FAN_PERIOD_TO_RPM(data
->fan_max
[attr
->index
]));
395 return sprintf(buf
, "0\n");
398 static ssize_t
set_fan_max(struct device
*dev
,
399 struct device_attribute
*devattr
,
400 const char *buf
, size_t count
)
402 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
403 struct i2c_client
*client
= to_i2c_client(dev
);
404 struct adt7470_data
*data
= i2c_get_clientdata(client
);
405 int temp
= simple_strtol(buf
, NULL
, 10);
409 temp
= FAN_RPM_TO_PERIOD(temp
);
411 mutex_lock(&data
->lock
);
412 data
->fan_max
[attr
->index
] = temp
;
413 adt7470_write_word_data(client
, ADT7470_REG_FAN_MAX(attr
->index
), temp
);
414 mutex_unlock(&data
->lock
);
419 static ssize_t
show_fan_min(struct device
*dev
,
420 struct device_attribute
*devattr
,
423 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
424 struct adt7470_data
*data
= adt7470_update_device(dev
);
426 if (FAN_DATA_VALID(data
->fan_min
[attr
->index
]))
427 return sprintf(buf
, "%d\n",
428 FAN_PERIOD_TO_RPM(data
->fan_min
[attr
->index
]));
430 return sprintf(buf
, "0\n");
433 static ssize_t
set_fan_min(struct device
*dev
,
434 struct device_attribute
*devattr
,
435 const char *buf
, size_t count
)
437 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
438 struct i2c_client
*client
= to_i2c_client(dev
);
439 struct adt7470_data
*data
= i2c_get_clientdata(client
);
440 int temp
= simple_strtol(buf
, NULL
, 10);
444 temp
= FAN_RPM_TO_PERIOD(temp
);
446 mutex_lock(&data
->lock
);
447 data
->fan_min
[attr
->index
] = temp
;
448 adt7470_write_word_data(client
, ADT7470_REG_FAN_MIN(attr
->index
), temp
);
449 mutex_unlock(&data
->lock
);
454 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*devattr
,
457 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
458 struct adt7470_data
*data
= adt7470_update_device(dev
);
460 if (FAN_DATA_VALID(data
->fan
[attr
->index
]))
461 return sprintf(buf
, "%d\n",
462 FAN_PERIOD_TO_RPM(data
->fan
[attr
->index
]));
464 return sprintf(buf
, "0\n");
467 static ssize_t
show_force_pwm_max(struct device
*dev
,
468 struct device_attribute
*devattr
,
471 struct adt7470_data
*data
= adt7470_update_device(dev
);
472 return sprintf(buf
, "%d\n", data
->force_pwm_max
);
475 static ssize_t
set_force_pwm_max(struct device
*dev
,
476 struct device_attribute
*devattr
,
480 struct i2c_client
*client
= to_i2c_client(dev
);
481 struct adt7470_data
*data
= i2c_get_clientdata(client
);
482 int temp
= simple_strtol(buf
, NULL
, 10);
485 mutex_lock(&data
->lock
);
486 data
->force_pwm_max
= temp
;
487 reg
= i2c_smbus_read_byte_data(client
, ADT7470_REG_CFG
);
489 reg
|= ADT7470_FSPD_MASK
;
491 reg
&= ~ADT7470_FSPD_MASK
;
492 i2c_smbus_write_byte_data(client
, ADT7470_REG_CFG
, reg
);
493 mutex_unlock(&data
->lock
);
498 static ssize_t
show_pwm(struct device
*dev
, struct device_attribute
*devattr
,
501 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
502 struct adt7470_data
*data
= adt7470_update_device(dev
);
503 return sprintf(buf
, "%d\n", data
->pwm
[attr
->index
]);
506 static ssize_t
set_pwm(struct device
*dev
, struct device_attribute
*devattr
,
507 const char *buf
, size_t count
)
509 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
510 struct i2c_client
*client
= to_i2c_client(dev
);
511 struct adt7470_data
*data
= i2c_get_clientdata(client
);
512 int temp
= simple_strtol(buf
, NULL
, 10);
514 mutex_lock(&data
->lock
);
515 data
->pwm
[attr
->index
] = temp
;
516 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM(attr
->index
), temp
);
517 mutex_unlock(&data
->lock
);
522 static ssize_t
show_pwm_max(struct device
*dev
,
523 struct device_attribute
*devattr
,
526 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
527 struct adt7470_data
*data
= adt7470_update_device(dev
);
528 return sprintf(buf
, "%d\n", data
->pwm_max
[attr
->index
]);
531 static ssize_t
set_pwm_max(struct device
*dev
,
532 struct device_attribute
*devattr
,
536 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
537 struct i2c_client
*client
= to_i2c_client(dev
);
538 struct adt7470_data
*data
= i2c_get_clientdata(client
);
539 int temp
= simple_strtol(buf
, NULL
, 10);
541 mutex_lock(&data
->lock
);
542 data
->pwm_max
[attr
->index
] = temp
;
543 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_MAX(attr
->index
),
545 mutex_unlock(&data
->lock
);
550 static ssize_t
show_pwm_min(struct device
*dev
,
551 struct device_attribute
*devattr
,
554 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
555 struct adt7470_data
*data
= adt7470_update_device(dev
);
556 return sprintf(buf
, "%d\n", data
->pwm_min
[attr
->index
]);
559 static ssize_t
set_pwm_min(struct device
*dev
,
560 struct device_attribute
*devattr
,
564 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
565 struct i2c_client
*client
= to_i2c_client(dev
);
566 struct adt7470_data
*data
= i2c_get_clientdata(client
);
567 int temp
= simple_strtol(buf
, NULL
, 10);
569 mutex_lock(&data
->lock
);
570 data
->pwm_min
[attr
->index
] = temp
;
571 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_MIN(attr
->index
),
573 mutex_unlock(&data
->lock
);
578 static ssize_t
show_pwm_tmax(struct device
*dev
,
579 struct device_attribute
*devattr
,
582 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
583 struct adt7470_data
*data
= adt7470_update_device(dev
);
584 /* the datasheet says that tmax = tmin + 20C */
585 return sprintf(buf
, "%d\n", 1000 * (20 + data
->pwm_tmin
[attr
->index
]));
588 static ssize_t
show_pwm_tmin(struct device
*dev
,
589 struct device_attribute
*devattr
,
592 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
593 struct adt7470_data
*data
= adt7470_update_device(dev
);
594 return sprintf(buf
, "%d\n", 1000 * data
->pwm_tmin
[attr
->index
]);
597 static ssize_t
set_pwm_tmin(struct device
*dev
,
598 struct device_attribute
*devattr
,
602 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
603 struct i2c_client
*client
= to_i2c_client(dev
);
604 struct adt7470_data
*data
= i2c_get_clientdata(client
);
605 int temp
= simple_strtol(buf
, NULL
, 10) / 1000;
607 mutex_lock(&data
->lock
);
608 data
->pwm_tmin
[attr
->index
] = temp
;
609 i2c_smbus_write_byte_data(client
, ADT7470_REG_PWM_TMIN(attr
->index
),
611 mutex_unlock(&data
->lock
);
616 static ssize_t
show_pwm_auto(struct device
*dev
,
617 struct device_attribute
*devattr
,
620 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
621 struct adt7470_data
*data
= adt7470_update_device(dev
);
622 return sprintf(buf
, "%d\n", 1 + data
->pwm_automatic
[attr
->index
]);
625 static ssize_t
set_pwm_auto(struct device
*dev
,
626 struct device_attribute
*devattr
,
630 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
631 struct i2c_client
*client
= to_i2c_client(dev
);
632 struct adt7470_data
*data
= i2c_get_clientdata(client
);
633 int temp
= simple_strtol(buf
, NULL
, 10);
634 int pwm_auto_reg
= ADT7470_REG_PWM_CFG(attr
->index
);
635 int pwm_auto_reg_mask
;
639 pwm_auto_reg_mask
= ADT7470_PWM2_AUTO_MASK
;
641 pwm_auto_reg_mask
= ADT7470_PWM1_AUTO_MASK
;
643 if (temp
!= 2 && temp
!= 1)
647 mutex_lock(&data
->lock
);
648 data
->pwm_automatic
[attr
->index
] = temp
;
649 reg
= i2c_smbus_read_byte_data(client
, pwm_auto_reg
);
651 reg
|= pwm_auto_reg_mask
;
653 reg
&= ~pwm_auto_reg_mask
;
654 i2c_smbus_write_byte_data(client
, pwm_auto_reg
, reg
);
655 mutex_unlock(&data
->lock
);
660 static ssize_t
show_pwm_auto_temp(struct device
*dev
,
661 struct device_attribute
*devattr
,
664 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
665 struct adt7470_data
*data
= adt7470_update_device(dev
);
666 u8 ctrl
= data
->pwm_auto_temp
[attr
->index
];
669 return sprintf(buf
, "%d\n", 1 << (ctrl
- 1));
671 return sprintf(buf
, "%d\n", ADT7470_PWM_ALL_TEMPS
);
674 static int cvt_auto_temp(int input
)
676 if (input
== ADT7470_PWM_ALL_TEMPS
)
678 if (input
< 1 || !is_power_of_2(input
))
680 return ilog2(input
) + 1;
683 static ssize_t
set_pwm_auto_temp(struct device
*dev
,
684 struct device_attribute
*devattr
,
688 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
689 struct i2c_client
*client
= to_i2c_client(dev
);
690 struct adt7470_data
*data
= i2c_get_clientdata(client
);
691 int temp
= cvt_auto_temp(simple_strtol(buf
, NULL
, 10));
692 int pwm_auto_reg
= ADT7470_REG_PWM_AUTO_TEMP(attr
->index
);
698 mutex_lock(&data
->lock
);
699 data
->pwm_automatic
[attr
->index
] = temp
;
700 reg
= i2c_smbus_read_byte_data(client
, pwm_auto_reg
);
702 if (!(attr
->index
% 2)) {
704 reg
|= (temp
<< 4) & 0xF0;
710 i2c_smbus_write_byte_data(client
, pwm_auto_reg
, reg
);
711 mutex_unlock(&data
->lock
);
716 static SENSOR_DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
, 0);
717 static SENSOR_DEVICE_ATTR(alarm_mask
, S_IRUGO
, show_alarms
, NULL
, 1);
719 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
721 static SENSOR_DEVICE_ATTR(temp2_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
723 static SENSOR_DEVICE_ATTR(temp3_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
725 static SENSOR_DEVICE_ATTR(temp4_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
727 static SENSOR_DEVICE_ATTR(temp5_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
729 static SENSOR_DEVICE_ATTR(temp6_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
731 static SENSOR_DEVICE_ATTR(temp7_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
733 static SENSOR_DEVICE_ATTR(temp8_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
735 static SENSOR_DEVICE_ATTR(temp9_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
737 static SENSOR_DEVICE_ATTR(temp10_max
, S_IWUSR
| S_IRUGO
, show_temp_max
,
740 static SENSOR_DEVICE_ATTR(temp1_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
742 static SENSOR_DEVICE_ATTR(temp2_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
744 static SENSOR_DEVICE_ATTR(temp3_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
746 static SENSOR_DEVICE_ATTR(temp4_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
748 static SENSOR_DEVICE_ATTR(temp5_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
750 static SENSOR_DEVICE_ATTR(temp6_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
752 static SENSOR_DEVICE_ATTR(temp7_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
754 static SENSOR_DEVICE_ATTR(temp8_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
756 static SENSOR_DEVICE_ATTR(temp9_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
758 static SENSOR_DEVICE_ATTR(temp10_min
, S_IWUSR
| S_IRUGO
, show_temp_min
,
761 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
, 0);
762 static SENSOR_DEVICE_ATTR(temp2_input
, S_IRUGO
, show_temp
, NULL
, 1);
763 static SENSOR_DEVICE_ATTR(temp3_input
, S_IRUGO
, show_temp
, NULL
, 2);
764 static SENSOR_DEVICE_ATTR(temp4_input
, S_IRUGO
, show_temp
, NULL
, 3);
765 static SENSOR_DEVICE_ATTR(temp5_input
, S_IRUGO
, show_temp
, NULL
, 4);
766 static SENSOR_DEVICE_ATTR(temp6_input
, S_IRUGO
, show_temp
, NULL
, 5);
767 static SENSOR_DEVICE_ATTR(temp7_input
, S_IRUGO
, show_temp
, NULL
, 6);
768 static SENSOR_DEVICE_ATTR(temp8_input
, S_IRUGO
, show_temp
, NULL
, 7);
769 static SENSOR_DEVICE_ATTR(temp9_input
, S_IRUGO
, show_temp
, NULL
, 8);
770 static SENSOR_DEVICE_ATTR(temp10_input
, S_IRUGO
, show_temp
, NULL
, 9);
772 static SENSOR_DEVICE_ATTR(fan1_max
, S_IWUSR
| S_IRUGO
, show_fan_max
,
774 static SENSOR_DEVICE_ATTR(fan2_max
, S_IWUSR
| S_IRUGO
, show_fan_max
,
776 static SENSOR_DEVICE_ATTR(fan3_max
, S_IWUSR
| S_IRUGO
, show_fan_max
,
778 static SENSOR_DEVICE_ATTR(fan4_max
, S_IWUSR
| S_IRUGO
, show_fan_max
,
781 static SENSOR_DEVICE_ATTR(fan1_min
, S_IWUSR
| S_IRUGO
, show_fan_min
,
783 static SENSOR_DEVICE_ATTR(fan2_min
, S_IWUSR
| S_IRUGO
, show_fan_min
,
785 static SENSOR_DEVICE_ATTR(fan3_min
, S_IWUSR
| S_IRUGO
, show_fan_min
,
787 static SENSOR_DEVICE_ATTR(fan4_min
, S_IWUSR
| S_IRUGO
, show_fan_min
,
790 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0);
791 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, show_fan
, NULL
, 1);
792 static SENSOR_DEVICE_ATTR(fan3_input
, S_IRUGO
, show_fan
, NULL
, 2);
793 static SENSOR_DEVICE_ATTR(fan4_input
, S_IRUGO
, show_fan
, NULL
, 3);
795 static SENSOR_DEVICE_ATTR(force_pwm_max
, S_IWUSR
| S_IRUGO
,
796 show_force_pwm_max
, set_force_pwm_max
, 0);
798 static SENSOR_DEVICE_ATTR(pwm1
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 0);
799 static SENSOR_DEVICE_ATTR(pwm2
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 1);
800 static SENSOR_DEVICE_ATTR(pwm3
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 2);
801 static SENSOR_DEVICE_ATTR(pwm4
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 3);
803 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm
, S_IWUSR
| S_IRUGO
,
804 show_pwm_min
, set_pwm_min
, 0);
805 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm
, S_IWUSR
| S_IRUGO
,
806 show_pwm_min
, set_pwm_min
, 1);
807 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm
, S_IWUSR
| S_IRUGO
,
808 show_pwm_min
, set_pwm_min
, 2);
809 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm
, S_IWUSR
| S_IRUGO
,
810 show_pwm_min
, set_pwm_min
, 3);
812 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm
, S_IWUSR
| S_IRUGO
,
813 show_pwm_max
, set_pwm_max
, 0);
814 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm
, S_IWUSR
| S_IRUGO
,
815 show_pwm_max
, set_pwm_max
, 1);
816 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm
, S_IWUSR
| S_IRUGO
,
817 show_pwm_max
, set_pwm_max
, 2);
818 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm
, S_IWUSR
| S_IRUGO
,
819 show_pwm_max
, set_pwm_max
, 3);
821 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp
, S_IWUSR
| S_IRUGO
,
822 show_pwm_tmin
, set_pwm_tmin
, 0);
823 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_temp
, S_IWUSR
| S_IRUGO
,
824 show_pwm_tmin
, set_pwm_tmin
, 1);
825 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_temp
, S_IWUSR
| S_IRUGO
,
826 show_pwm_tmin
, set_pwm_tmin
, 2);
827 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_temp
, S_IWUSR
| S_IRUGO
,
828 show_pwm_tmin
, set_pwm_tmin
, 3);
830 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp
, S_IRUGO
, show_pwm_tmax
,
832 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_temp
, S_IRUGO
, show_pwm_tmax
,
834 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_temp
, S_IRUGO
, show_pwm_tmax
,
836 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_temp
, S_IRUGO
, show_pwm_tmax
,
839 static SENSOR_DEVICE_ATTR(pwm1_enable
, S_IWUSR
| S_IRUGO
, show_pwm_auto
,
841 static SENSOR_DEVICE_ATTR(pwm2_enable
, S_IWUSR
| S_IRUGO
, show_pwm_auto
,
843 static SENSOR_DEVICE_ATTR(pwm3_enable
, S_IWUSR
| S_IRUGO
, show_pwm_auto
,
845 static SENSOR_DEVICE_ATTR(pwm4_enable
, S_IWUSR
| S_IRUGO
, show_pwm_auto
,
848 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp
, S_IWUSR
| S_IRUGO
,
849 show_pwm_auto_temp
, set_pwm_auto_temp
, 0);
850 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp
, S_IWUSR
| S_IRUGO
,
851 show_pwm_auto_temp
, set_pwm_auto_temp
, 1);
852 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp
, S_IWUSR
| S_IRUGO
,
853 show_pwm_auto_temp
, set_pwm_auto_temp
, 2);
854 static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp
, S_IWUSR
| S_IRUGO
,
855 show_pwm_auto_temp
, set_pwm_auto_temp
, 3);
857 static struct attribute
*adt7470_attr
[] =
859 &sensor_dev_attr_alarms
.dev_attr
.attr
,
860 &sensor_dev_attr_alarm_mask
.dev_attr
.attr
,
861 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
862 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
863 &sensor_dev_attr_temp3_max
.dev_attr
.attr
,
864 &sensor_dev_attr_temp4_max
.dev_attr
.attr
,
865 &sensor_dev_attr_temp5_max
.dev_attr
.attr
,
866 &sensor_dev_attr_temp6_max
.dev_attr
.attr
,
867 &sensor_dev_attr_temp7_max
.dev_attr
.attr
,
868 &sensor_dev_attr_temp8_max
.dev_attr
.attr
,
869 &sensor_dev_attr_temp9_max
.dev_attr
.attr
,
870 &sensor_dev_attr_temp10_max
.dev_attr
.attr
,
871 &sensor_dev_attr_temp1_min
.dev_attr
.attr
,
872 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
873 &sensor_dev_attr_temp3_min
.dev_attr
.attr
,
874 &sensor_dev_attr_temp4_min
.dev_attr
.attr
,
875 &sensor_dev_attr_temp5_min
.dev_attr
.attr
,
876 &sensor_dev_attr_temp6_min
.dev_attr
.attr
,
877 &sensor_dev_attr_temp7_min
.dev_attr
.attr
,
878 &sensor_dev_attr_temp8_min
.dev_attr
.attr
,
879 &sensor_dev_attr_temp9_min
.dev_attr
.attr
,
880 &sensor_dev_attr_temp10_min
.dev_attr
.attr
,
881 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
882 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
883 &sensor_dev_attr_temp3_input
.dev_attr
.attr
,
884 &sensor_dev_attr_temp4_input
.dev_attr
.attr
,
885 &sensor_dev_attr_temp5_input
.dev_attr
.attr
,
886 &sensor_dev_attr_temp6_input
.dev_attr
.attr
,
887 &sensor_dev_attr_temp7_input
.dev_attr
.attr
,
888 &sensor_dev_attr_temp8_input
.dev_attr
.attr
,
889 &sensor_dev_attr_temp9_input
.dev_attr
.attr
,
890 &sensor_dev_attr_temp10_input
.dev_attr
.attr
,
891 &sensor_dev_attr_fan1_max
.dev_attr
.attr
,
892 &sensor_dev_attr_fan2_max
.dev_attr
.attr
,
893 &sensor_dev_attr_fan3_max
.dev_attr
.attr
,
894 &sensor_dev_attr_fan4_max
.dev_attr
.attr
,
895 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
896 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
897 &sensor_dev_attr_fan3_min
.dev_attr
.attr
,
898 &sensor_dev_attr_fan4_min
.dev_attr
.attr
,
899 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
900 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
901 &sensor_dev_attr_fan3_input
.dev_attr
.attr
,
902 &sensor_dev_attr_fan4_input
.dev_attr
.attr
,
903 &sensor_dev_attr_force_pwm_max
.dev_attr
.attr
,
904 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
905 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
906 &sensor_dev_attr_pwm3
.dev_attr
.attr
,
907 &sensor_dev_attr_pwm4
.dev_attr
.attr
,
908 &sensor_dev_attr_pwm1_auto_point1_pwm
.dev_attr
.attr
,
909 &sensor_dev_attr_pwm2_auto_point1_pwm
.dev_attr
.attr
,
910 &sensor_dev_attr_pwm3_auto_point1_pwm
.dev_attr
.attr
,
911 &sensor_dev_attr_pwm4_auto_point1_pwm
.dev_attr
.attr
,
912 &sensor_dev_attr_pwm1_auto_point2_pwm
.dev_attr
.attr
,
913 &sensor_dev_attr_pwm2_auto_point2_pwm
.dev_attr
.attr
,
914 &sensor_dev_attr_pwm3_auto_point2_pwm
.dev_attr
.attr
,
915 &sensor_dev_attr_pwm4_auto_point2_pwm
.dev_attr
.attr
,
916 &sensor_dev_attr_pwm1_auto_point1_temp
.dev_attr
.attr
,
917 &sensor_dev_attr_pwm2_auto_point1_temp
.dev_attr
.attr
,
918 &sensor_dev_attr_pwm3_auto_point1_temp
.dev_attr
.attr
,
919 &sensor_dev_attr_pwm4_auto_point1_temp
.dev_attr
.attr
,
920 &sensor_dev_attr_pwm1_auto_point2_temp
.dev_attr
.attr
,
921 &sensor_dev_attr_pwm2_auto_point2_temp
.dev_attr
.attr
,
922 &sensor_dev_attr_pwm3_auto_point2_temp
.dev_attr
.attr
,
923 &sensor_dev_attr_pwm4_auto_point2_temp
.dev_attr
.attr
,
924 &sensor_dev_attr_pwm1_enable
.dev_attr
.attr
,
925 &sensor_dev_attr_pwm2_enable
.dev_attr
.attr
,
926 &sensor_dev_attr_pwm3_enable
.dev_attr
.attr
,
927 &sensor_dev_attr_pwm4_enable
.dev_attr
.attr
,
928 &sensor_dev_attr_pwm1_auto_channels_temp
.dev_attr
.attr
,
929 &sensor_dev_attr_pwm2_auto_channels_temp
.dev_attr
.attr
,
930 &sensor_dev_attr_pwm3_auto_channels_temp
.dev_attr
.attr
,
931 &sensor_dev_attr_pwm4_auto_channels_temp
.dev_attr
.attr
,
935 static int adt7470_attach_adapter(struct i2c_adapter
*adapter
)
937 if (!(adapter
->class & I2C_CLASS_HWMON
))
939 return i2c_probe(adapter
, &addr_data
, adt7470_detect
);
942 static int adt7470_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
944 struct i2c_client
*client
;
945 struct adt7470_data
*data
;
948 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
951 if (!(data
= kzalloc(sizeof(struct adt7470_data
), GFP_KERNEL
))) {
956 client
= &data
->client
;
957 client
->addr
= address
;
958 client
->adapter
= adapter
;
959 client
->driver
= &adt7470_driver
;
961 i2c_set_clientdata(client
, data
);
963 mutex_init(&data
->lock
);
966 int vendor
, device
, revision
;
968 vendor
= i2c_smbus_read_byte_data(client
, ADT7470_REG_VENDOR
);
969 if (vendor
!= ADT7470_VENDOR
) {
974 device
= i2c_smbus_read_byte_data(client
, ADT7470_REG_DEVICE
);
975 if (device
!= ADT7470_DEVICE
) {
980 revision
= i2c_smbus_read_byte_data(client
,
981 ADT7470_REG_REVISION
);
982 if (revision
!= ADT7470_REVISION
) {
987 dev_dbg(&adapter
->dev
, "detection forced\n");
989 strlcpy(client
->name
, "adt7470", I2C_NAME_SIZE
);
991 if ((err
= i2c_attach_client(client
)))
994 dev_info(&client
->dev
, "%s chip found\n", client
->name
);
996 /* Initialize the ADT7470 chip */
997 adt7470_init_client(client
);
999 /* Register sysfs hooks */
1000 data
->attrs
.attrs
= adt7470_attr
;
1001 if ((err
= sysfs_create_group(&client
->dev
.kobj
, &data
->attrs
)))
1004 data
->hwmon_dev
= hwmon_device_register(&client
->dev
);
1005 if (IS_ERR(data
->hwmon_dev
)) {
1006 err
= PTR_ERR(data
->hwmon_dev
);
1013 sysfs_remove_group(&client
->dev
.kobj
, &data
->attrs
);
1015 i2c_detach_client(client
);
1022 static int adt7470_detach_client(struct i2c_client
*client
)
1024 struct adt7470_data
*data
= i2c_get_clientdata(client
);
1026 hwmon_device_unregister(data
->hwmon_dev
);
1027 sysfs_remove_group(&client
->dev
.kobj
, &data
->attrs
);
1028 i2c_detach_client(client
);
1033 static int __init
adt7470_init(void)
1035 return i2c_add_driver(&adt7470_driver
);
1038 static void __exit
adt7470_exit(void)
1040 i2c_del_driver(&adt7470_driver
);
1043 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1044 MODULE_DESCRIPTION("ADT7470 driver");
1045 MODULE_LICENSE("GPL");
1047 module_init(adt7470_init
);
1048 module_exit(adt7470_exit
);