2 * A hwmon driver for the Analog Devices ADT7462
3 * Copyright (C) 2008 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 const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END };
35 /* Insmod parameters */
36 I2C_CLIENT_INSMOD_1(adt7462);
38 /* ADT7462 registers */
39 #define ADT7462_REG_DEVICE 0x3D
40 #define ADT7462_REG_VENDOR 0x3E
41 #define ADT7462_REG_REVISION 0x3F
43 #define ADT7462_REG_MIN_TEMP_BASE_ADDR 0x44
44 #define ADT7462_REG_MIN_TEMP_MAX_ADDR 0x47
45 #define ADT7462_REG_MAX_TEMP_BASE_ADDR 0x48
46 #define ADT7462_REG_MAX_TEMP_MAX_ADDR 0x4B
47 #define ADT7462_REG_TEMP_BASE_ADDR 0x88
48 #define ADT7462_REG_TEMP_MAX_ADDR 0x8F
50 #define ADT7462_REG_FAN_BASE_ADDR 0x98
51 #define ADT7462_REG_FAN_MAX_ADDR 0x9F
52 #define ADT7462_REG_FAN2_BASE_ADDR 0xA2
53 #define ADT7462_REG_FAN2_MAX_ADDR 0xA9
54 #define ADT7462_REG_FAN_ENABLE 0x07
55 #define ADT7462_REG_FAN_MIN_BASE_ADDR 0x78
56 #define ADT7462_REG_FAN_MIN_MAX_ADDR 0x7F
58 #define ADT7462_REG_CFG2 0x02
59 #define ADT7462_FSPD_MASK 0x20
61 #define ADT7462_REG_PWM_BASE_ADDR 0xAA
62 #define ADT7462_REG_PWM_MAX_ADDR 0xAD
63 #define ADT7462_REG_PWM_MIN_BASE_ADDR 0x28
64 #define ADT7462_REG_PWM_MIN_MAX_ADDR 0x2B
65 #define ADT7462_REG_PWM_MAX 0x2C
66 #define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR 0x5C
67 #define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR 0x5F
68 #define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR 0x60
69 #define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR 0x63
70 #define ADT7462_PWM_HYST_MASK 0x0F
71 #define ADT7462_PWM_RANGE_MASK 0xF0
72 #define ADT7462_PWM_RANGE_SHIFT 4
73 #define ADT7462_REG_PWM_CFG_BASE_ADDR 0x21
74 #define ADT7462_REG_PWM_CFG_MAX_ADDR 0x24
75 #define ADT7462_PWM_CHANNEL_MASK 0xE0
76 #define ADT7462_PWM_CHANNEL_SHIFT 5
78 #define ADT7462_REG_PIN_CFG_BASE_ADDR 0x10
79 #define ADT7462_REG_PIN_CFG_MAX_ADDR 0x13
80 #define ADT7462_PIN7_INPUT 0x01 /* cfg0 */
81 #define ADT7462_DIODE3_INPUT 0x20
82 #define ADT7462_DIODE1_INPUT 0x40
83 #define ADT7462_VID_INPUT 0x80
84 #define ADT7462_PIN22_INPUT 0x04 /* cfg1 */
85 #define ADT7462_PIN21_INPUT 0x08
86 #define ADT7462_PIN19_INPUT 0x10
87 #define ADT7462_PIN15_INPUT 0x20
88 #define ADT7462_PIN13_INPUT 0x40
89 #define ADT7462_PIN8_INPUT 0x80
90 #define ADT7462_PIN23_MASK 0x03
91 #define ADT7462_PIN23_SHIFT 0
92 #define ADT7462_PIN26_MASK 0x0C /* cfg2 */
93 #define ADT7462_PIN26_SHIFT 2
94 #define ADT7462_PIN25_MASK 0x30
95 #define ADT7462_PIN25_SHIFT 4
96 #define ADT7462_PIN24_MASK 0xC0
97 #define ADT7462_PIN24_SHIFT 6
98 #define ADT7462_PIN26_VOLT_INPUT 0x08
99 #define ADT7462_PIN25_VOLT_INPUT 0x20
100 #define ADT7462_PIN28_SHIFT 6 /* cfg3 */
101 #define ADT7462_PIN28_VOLT 0x5
103 #define ADT7462_REG_ALARM1 0xB8
104 #define ADT7462_LT_ALARM 0x02
105 #define ADT7462_R1T_ALARM 0x04
106 #define ADT7462_R2T_ALARM 0x08
107 #define ADT7462_R3T_ALARM 0x10
108 #define ADT7462_REG_ALARM2 0xBB
109 #define ADT7462_V0_ALARM 0x01
110 #define ADT7462_V1_ALARM 0x02
111 #define ADT7462_V2_ALARM 0x04
112 #define ADT7462_V3_ALARM 0x08
113 #define ADT7462_V4_ALARM 0x10
114 #define ADT7462_V5_ALARM 0x20
115 #define ADT7462_V6_ALARM 0x40
116 #define ADT7462_V7_ALARM 0x80
117 #define ADT7462_REG_ALARM3 0xBC
118 #define ADT7462_V8_ALARM 0x08
119 #define ADT7462_V9_ALARM 0x10
120 #define ADT7462_V10_ALARM 0x20
121 #define ADT7462_V11_ALARM 0x40
122 #define ADT7462_V12_ALARM 0x80
123 #define ADT7462_REG_ALARM4 0xBD
124 #define ADT7462_F0_ALARM 0x01
125 #define ADT7462_F1_ALARM 0x02
126 #define ADT7462_F2_ALARM 0x04
127 #define ADT7462_F3_ALARM 0x08
128 #define ADT7462_F4_ALARM 0x10
129 #define ADT7462_F5_ALARM 0x20
130 #define ADT7462_F6_ALARM 0x40
131 #define ADT7462_F7_ALARM 0x80
132 #define ADT7462_ALARM1 0x0000
133 #define ADT7462_ALARM2 0x0100
134 #define ADT7462_ALARM3 0x0200
135 #define ADT7462_ALARM4 0x0300
136 #define ADT7462_ALARM_REG_SHIFT 8
137 #define ADT7462_ALARM_FLAG_MASK 0x0F
139 #define ADT7462_TEMP_COUNT 4
140 #define ADT7462_TEMP_REG(x) (ADT7462_REG_TEMP_BASE_ADDR + (x * 2))
141 #define ADT7462_TEMP_MIN_REG(x) (ADT7462_REG_MIN_TEMP_BASE_ADDR + (x))
142 #define ADT7462_TEMP_MAX_REG(x) (ADT7462_REG_MAX_TEMP_BASE_ADDR + (x))
143 #define TEMP_FRAC_OFFSET 6
145 #define ADT7462_FAN_COUNT 8
146 #define ADT7462_REG_FAN_MIN(x) (ADT7462_REG_FAN_MIN_BASE_ADDR + (x))
148 #define ADT7462_PWM_COUNT 4
149 #define ADT7462_REG_PWM(x) (ADT7462_REG_PWM_BASE_ADDR + (x))
150 #define ADT7462_REG_PWM_MIN(x) (ADT7462_REG_PWM_MIN_BASE_ADDR + (x))
151 #define ADT7462_REG_PWM_TMIN(x) \
152 (ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
153 #define ADT7462_REG_PWM_TRANGE(x) \
154 (ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x))
156 #define ADT7462_PIN_CFG_REG_COUNT 4
157 #define ADT7462_REG_PIN_CFG(x) (ADT7462_REG_PIN_CFG_BASE_ADDR + (x))
158 #define ADT7462_REG_PWM_CFG(x) (ADT7462_REG_PWM_CFG_BASE_ADDR + (x))
160 #define ADT7462_ALARM_REG_COUNT 4
163 * The chip can measure 13 different voltage sources:
166 * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23)
169 * 5. +1.25V/+0.9V (pin 19)
170 * 6. +2.5V/+1.8V (pin 15)
173 * 9. Vbatt/FSB_Vtt (pin 26)
174 * A. +3.3V/+1.2V1 (pin 25)
175 * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24)
176 * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V)
177 * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V)
179 * Each of these 13 has a factor to convert raw to voltage. Even better,
180 * the pins can be connected to other sensors (tach/gpio/hot/etc), which
181 * makes the bookkeeping tricky.
183 * Some, but not all, of these voltages have low/high limits.
185 #define ADT7462_VOLT_COUNT 12
187 #define ADT7462_VENDOR 0x41
188 #define ADT7462_DEVICE 0x62
189 /* datasheet only mentions a revision 4 */
190 #define ADT7462_REVISION 0x04
192 /* How often do we reread sensors values? (In jiffies) */
193 #define SENSOR_REFRESH_INTERVAL (2 * HZ)
195 /* How often do we reread sensor limit values? (In jiffies) */
196 #define LIMIT_REFRESH_INTERVAL (60 * HZ)
198 /* datasheet says to divide this number by the fan reading to get fan rpm */
199 #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
200 #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
201 #define FAN_PERIOD_INVALID 65535
202 #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
204 #define MASK_AND_SHIFT(value, prefix) \
205 (((value) & prefix##_MASK) >> prefix##_SHIFT)
207 struct adt7462_data {
208 struct device *hwmon_dev;
209 struct attribute_group attrs;
213 unsigned long sensors_last_updated; /* In jiffies */
214 unsigned long limits_last_updated; /* In jiffies */
216 u8 temp[ADT7462_TEMP_COUNT];
217 /* bits 6-7 are quarter pieces of temp */
218 u8 temp_frac[ADT7462_TEMP_COUNT];
219 u8 temp_min[ADT7462_TEMP_COUNT];
220 u8 temp_max[ADT7462_TEMP_COUNT];
221 u16 fan[ADT7462_FAN_COUNT];
223 u8 fan_min[ADT7462_FAN_COUNT];
225 u8 pwm[ADT7462_PWM_COUNT];
226 u8 pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
227 u8 voltages[ADT7462_VOLT_COUNT];
228 u8 volt_max[ADT7462_VOLT_COUNT];
229 u8 volt_min[ADT7462_VOLT_COUNT];
230 u8 pwm_min[ADT7462_PWM_COUNT];
231 u8 pwm_tmin[ADT7462_PWM_COUNT];
232 u8 pwm_trange[ADT7462_PWM_COUNT];
233 u8 pwm_max; /* only one per chip */
234 u8 pwm_cfg[ADT7462_PWM_COUNT];
235 u8 alarms[ADT7462_ALARM_REG_COUNT];
238 static int adt7462_probe(struct i2c_client *client,
239 const struct i2c_device_id *id);
240 static int adt7462_detect(struct i2c_client *client, int kind,
241 struct i2c_board_info *info);
242 static int adt7462_remove(struct i2c_client *client);
244 static const struct i2c_device_id adt7462_id[] = {
245 { "adt7462", adt7462 },
248 MODULE_DEVICE_TABLE(i2c, adt7462_id);
250 static struct i2c_driver adt7462_driver = {
251 .class = I2C_CLASS_HWMON,
255 .probe = adt7462_probe,
256 .remove = adt7462_remove,
257 .id_table = adt7462_id,
258 .detect = adt7462_detect,
259 .address_data = &addr_data,
263 * 16-bit registers on the ADT7462 are low-byte first. The data sheet says
264 * that the low byte must be read before the high byte.
266 static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
269 foo = i2c_smbus_read_byte_data(client, reg);
270 foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
274 /* For some reason these registers are not contiguous. */
275 static int ADT7462_REG_FAN(int fan)
278 return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
279 return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
282 /* Voltage registers are scattered everywhere */
283 static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
287 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
293 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
297 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
301 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
305 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
309 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
313 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
317 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
321 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
327 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
328 ADT7462_PIN28_VOLT &&
329 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
333 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
334 ADT7462_PIN28_VOLT &&
335 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
342 static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
346 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
352 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
356 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
360 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
364 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
368 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
372 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
376 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
380 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
386 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
387 ADT7462_PIN28_VOLT &&
388 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
392 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
393 ADT7462_PIN28_VOLT &&
394 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
401 static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
405 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
411 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
415 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
419 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
423 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
427 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
431 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
435 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
439 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
445 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
446 ADT7462_PIN28_VOLT &&
447 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
451 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
452 ADT7462_PIN28_VOLT &&
453 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
460 /* Provide labels for sysfs */
461 static const char *voltage_label(struct adt7462_data *data, int which)
465 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
469 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
480 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
484 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
488 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
489 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
495 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
496 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
502 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
506 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
510 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
518 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
526 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
537 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
538 ADT7462_PIN28_VOLT &&
539 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
543 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
544 ADT7462_PIN28_VOLT &&
545 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
546 return "+1.5V 3GPIO";
552 /* Multipliers are actually in uV, not mV. */
553 static int voltage_multiplier(struct adt7462_data *data, int which)
557 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
561 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
563 if (data->pin_cfg[0] & ADT7462_VID_INPUT)
574 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
578 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
582 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
583 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
589 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
590 if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
596 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
600 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
604 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
612 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
620 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
632 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
633 ADT7462_PIN28_VOLT &&
634 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
640 static int temp_enabled(struct adt7462_data *data, int which)
647 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
651 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
658 static const char *temp_label(struct adt7462_data *data, int which)
664 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
670 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
677 /* Map Trange register values to mC */
678 #define NUM_TRANGE_VALUES 16
679 static const int trange_values[NUM_TRANGE_VALUES] = {
698 static int find_trange_value(int trange)
702 for (i = 0; i < NUM_TRANGE_VALUES; i++)
703 if (trange_values[i] == trange)
709 static struct adt7462_data *adt7462_update_device(struct device *dev)
711 struct i2c_client *client = to_i2c_client(dev);
712 struct adt7462_data *data = i2c_get_clientdata(client);
713 unsigned long local_jiffies = jiffies;
716 mutex_lock(&data->lock);
717 if (time_before(local_jiffies, data->sensors_last_updated +
718 SENSOR_REFRESH_INTERVAL)
719 && data->sensors_valid)
720 goto no_sensor_update;
722 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
724 * Reading the fractional register locks the integral
725 * register until both have been read.
727 data->temp_frac[i] = i2c_smbus_read_byte_data(client,
728 ADT7462_TEMP_REG(i));
729 data->temp[i] = i2c_smbus_read_byte_data(client,
730 ADT7462_TEMP_REG(i) + 1);
733 for (i = 0; i < ADT7462_FAN_COUNT; i++)
734 data->fan[i] = adt7462_read_word_data(client,
737 data->fan_enabled = i2c_smbus_read_byte_data(client,
738 ADT7462_REG_FAN_ENABLE);
740 for (i = 0; i < ADT7462_PWM_COUNT; i++)
741 data->pwm[i] = i2c_smbus_read_byte_data(client,
744 for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
745 data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
746 ADT7462_REG_PIN_CFG(i));
748 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
749 int reg = ADT7462_REG_VOLT(data, i);
751 data->voltages[i] = 0;
753 data->voltages[i] = i2c_smbus_read_byte_data(client,
757 data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
758 data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
759 data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
760 data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
762 data->sensors_last_updated = local_jiffies;
763 data->sensors_valid = 1;
766 if (time_before(local_jiffies, data->limits_last_updated +
767 LIMIT_REFRESH_INTERVAL)
768 && data->limits_valid)
771 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
772 data->temp_min[i] = i2c_smbus_read_byte_data(client,
773 ADT7462_TEMP_MIN_REG(i));
774 data->temp_max[i] = i2c_smbus_read_byte_data(client,
775 ADT7462_TEMP_MAX_REG(i));
778 for (i = 0; i < ADT7462_FAN_COUNT; i++)
779 data->fan_min[i] = i2c_smbus_read_byte_data(client,
780 ADT7462_REG_FAN_MIN(i));
782 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
783 int reg = ADT7462_REG_VOLT_MAX(data, i);
785 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
787 reg = ADT7462_REG_VOLT_MIN(data, i);
789 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
792 for (i = 0; i < ADT7462_PWM_COUNT; i++) {
793 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
794 ADT7462_REG_PWM_MIN(i));
795 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
796 ADT7462_REG_PWM_TMIN(i));
797 data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
798 ADT7462_REG_PWM_TRANGE(i));
799 data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
800 ADT7462_REG_PWM_CFG(i));
803 data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
805 data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
807 data->limits_last_updated = local_jiffies;
808 data->limits_valid = 1;
811 mutex_unlock(&data->lock);
815 static ssize_t show_temp_min(struct device *dev,
816 struct device_attribute *devattr,
819 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
820 struct adt7462_data *data = adt7462_update_device(dev);
822 if (!temp_enabled(data, attr->index))
823 return sprintf(buf, "0\n");
825 return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
828 static ssize_t set_temp_min(struct device *dev,
829 struct device_attribute *devattr,
833 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
834 struct i2c_client *client = to_i2c_client(dev);
835 struct adt7462_data *data = i2c_get_clientdata(client);
838 if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
841 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
842 temp = SENSORS_LIMIT(temp, 0, 255);
844 mutex_lock(&data->lock);
845 data->temp_min[attr->index] = temp;
846 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
848 mutex_unlock(&data->lock);
853 static ssize_t show_temp_max(struct device *dev,
854 struct device_attribute *devattr,
857 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
858 struct adt7462_data *data = adt7462_update_device(dev);
860 if (!temp_enabled(data, attr->index))
861 return sprintf(buf, "0\n");
863 return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
866 static ssize_t set_temp_max(struct device *dev,
867 struct device_attribute *devattr,
871 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
872 struct i2c_client *client = to_i2c_client(dev);
873 struct adt7462_data *data = i2c_get_clientdata(client);
876 if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
879 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
880 temp = SENSORS_LIMIT(temp, 0, 255);
882 mutex_lock(&data->lock);
883 data->temp_max[attr->index] = temp;
884 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
886 mutex_unlock(&data->lock);
891 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
894 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
895 struct adt7462_data *data = adt7462_update_device(dev);
896 u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
898 if (!temp_enabled(data, attr->index))
899 return sprintf(buf, "0\n");
901 return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
905 static ssize_t show_temp_label(struct device *dev,
906 struct device_attribute *devattr,
909 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
910 struct adt7462_data *data = adt7462_update_device(dev);
912 return sprintf(buf, "%s\n", temp_label(data, attr->index));
915 static ssize_t show_volt_max(struct device *dev,
916 struct device_attribute *devattr,
919 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
920 struct adt7462_data *data = adt7462_update_device(dev);
921 int x = voltage_multiplier(data, attr->index);
923 x *= data->volt_max[attr->index];
924 x /= 1000; /* convert from uV to mV */
926 return sprintf(buf, "%d\n", x);
929 static ssize_t set_volt_max(struct device *dev,
930 struct device_attribute *devattr,
934 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
935 struct i2c_client *client = to_i2c_client(dev);
936 struct adt7462_data *data = i2c_get_clientdata(client);
937 int x = voltage_multiplier(data, attr->index);
940 if (strict_strtol(buf, 10, &temp) || !x)
943 temp *= 1000; /* convert mV to uV */
944 temp = DIV_ROUND_CLOSEST(temp, x);
945 temp = SENSORS_LIMIT(temp, 0, 255);
947 mutex_lock(&data->lock);
948 data->volt_max[attr->index] = temp;
949 i2c_smbus_write_byte_data(client,
950 ADT7462_REG_VOLT_MAX(data, attr->index),
952 mutex_unlock(&data->lock);
957 static ssize_t show_volt_min(struct device *dev,
958 struct device_attribute *devattr,
961 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
962 struct adt7462_data *data = adt7462_update_device(dev);
963 int x = voltage_multiplier(data, attr->index);
965 x *= data->volt_min[attr->index];
966 x /= 1000; /* convert from uV to mV */
968 return sprintf(buf, "%d\n", x);
971 static ssize_t set_volt_min(struct device *dev,
972 struct device_attribute *devattr,
976 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
977 struct i2c_client *client = to_i2c_client(dev);
978 struct adt7462_data *data = i2c_get_clientdata(client);
979 int x = voltage_multiplier(data, attr->index);
982 if (strict_strtol(buf, 10, &temp) || !x)
985 temp *= 1000; /* convert mV to uV */
986 temp = DIV_ROUND_CLOSEST(temp, x);
987 temp = SENSORS_LIMIT(temp, 0, 255);
989 mutex_lock(&data->lock);
990 data->volt_min[attr->index] = temp;
991 i2c_smbus_write_byte_data(client,
992 ADT7462_REG_VOLT_MIN(data, attr->index),
994 mutex_unlock(&data->lock);
999 static ssize_t show_voltage(struct device *dev,
1000 struct device_attribute *devattr,
1003 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1004 struct adt7462_data *data = adt7462_update_device(dev);
1005 int x = voltage_multiplier(data, attr->index);
1007 x *= data->voltages[attr->index];
1008 x /= 1000; /* convert from uV to mV */
1010 return sprintf(buf, "%d\n", x);
1013 static ssize_t show_voltage_label(struct device *dev,
1014 struct device_attribute *devattr,
1017 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1018 struct adt7462_data *data = adt7462_update_device(dev);
1020 return sprintf(buf, "%s\n", voltage_label(data, attr->index));
1023 static ssize_t show_alarm(struct device *dev,
1024 struct device_attribute *devattr,
1027 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1028 struct adt7462_data *data = adt7462_update_device(dev);
1029 int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
1030 int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
1032 if (data->alarms[reg] & mask)
1033 return sprintf(buf, "1\n");
1035 return sprintf(buf, "0\n");
1038 static int fan_enabled(struct adt7462_data *data, int fan)
1040 return data->fan_enabled & (1 << fan);
1043 static ssize_t show_fan_min(struct device *dev,
1044 struct device_attribute *devattr,
1047 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1048 struct adt7462_data *data = adt7462_update_device(dev);
1051 /* Only the MSB of the min fan period is stored... */
1052 temp = data->fan_min[attr->index];
1055 if (!fan_enabled(data, attr->index) ||
1056 !FAN_DATA_VALID(temp))
1057 return sprintf(buf, "0\n");
1059 return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
1062 static ssize_t set_fan_min(struct device *dev,
1063 struct device_attribute *devattr,
1064 const char *buf, size_t count)
1066 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1067 struct i2c_client *client = to_i2c_client(dev);
1068 struct adt7462_data *data = i2c_get_clientdata(client);
1071 if (strict_strtol(buf, 10, &temp) || !temp ||
1072 !fan_enabled(data, attr->index))
1075 temp = FAN_RPM_TO_PERIOD(temp);
1077 temp = SENSORS_LIMIT(temp, 1, 255);
1079 mutex_lock(&data->lock);
1080 data->fan_min[attr->index] = temp;
1081 i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
1083 mutex_unlock(&data->lock);
1088 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
1091 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1092 struct adt7462_data *data = adt7462_update_device(dev);
1094 if (!fan_enabled(data, attr->index) ||
1095 !FAN_DATA_VALID(data->fan[attr->index]))
1096 return sprintf(buf, "0\n");
1098 return sprintf(buf, "%d\n",
1099 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
1102 static ssize_t show_force_pwm_max(struct device *dev,
1103 struct device_attribute *devattr,
1106 struct adt7462_data *data = adt7462_update_device(dev);
1107 return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
1110 static ssize_t set_force_pwm_max(struct device *dev,
1111 struct device_attribute *devattr,
1115 struct i2c_client *client = to_i2c_client(dev);
1116 struct adt7462_data *data = i2c_get_clientdata(client);
1120 if (strict_strtol(buf, 10, &temp))
1123 mutex_lock(&data->lock);
1124 reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
1126 reg |= ADT7462_FSPD_MASK;
1128 reg &= ~ADT7462_FSPD_MASK;
1130 i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
1131 mutex_unlock(&data->lock);
1136 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
1139 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1140 struct adt7462_data *data = adt7462_update_device(dev);
1141 return sprintf(buf, "%d\n", data->pwm[attr->index]);
1144 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
1145 const char *buf, size_t count)
1147 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1148 struct i2c_client *client = to_i2c_client(dev);
1149 struct adt7462_data *data = i2c_get_clientdata(client);
1152 if (strict_strtol(buf, 10, &temp))
1155 temp = SENSORS_LIMIT(temp, 0, 255);
1157 mutex_lock(&data->lock);
1158 data->pwm[attr->index] = temp;
1159 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
1160 mutex_unlock(&data->lock);
1165 static ssize_t show_pwm_max(struct device *dev,
1166 struct device_attribute *devattr,
1169 struct adt7462_data *data = adt7462_update_device(dev);
1170 return sprintf(buf, "%d\n", data->pwm_max);
1173 static ssize_t set_pwm_max(struct device *dev,
1174 struct device_attribute *devattr,
1178 struct i2c_client *client = to_i2c_client(dev);
1179 struct adt7462_data *data = i2c_get_clientdata(client);
1182 if (strict_strtol(buf, 10, &temp))
1185 temp = SENSORS_LIMIT(temp, 0, 255);
1187 mutex_lock(&data->lock);
1188 data->pwm_max = temp;
1189 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
1190 mutex_unlock(&data->lock);
1195 static ssize_t show_pwm_min(struct device *dev,
1196 struct device_attribute *devattr,
1199 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1200 struct adt7462_data *data = adt7462_update_device(dev);
1201 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
1204 static ssize_t set_pwm_min(struct device *dev,
1205 struct device_attribute *devattr,
1209 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1210 struct i2c_client *client = to_i2c_client(dev);
1211 struct adt7462_data *data = i2c_get_clientdata(client);
1214 if (strict_strtol(buf, 10, &temp))
1217 temp = SENSORS_LIMIT(temp, 0, 255);
1219 mutex_lock(&data->lock);
1220 data->pwm_min[attr->index] = temp;
1221 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
1223 mutex_unlock(&data->lock);
1228 static ssize_t show_pwm_hyst(struct device *dev,
1229 struct device_attribute *devattr,
1232 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1233 struct adt7462_data *data = adt7462_update_device(dev);
1234 return sprintf(buf, "%d\n", 1000 *
1235 (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
1238 static ssize_t set_pwm_hyst(struct device *dev,
1239 struct device_attribute *devattr,
1243 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1244 struct i2c_client *client = to_i2c_client(dev);
1245 struct adt7462_data *data = i2c_get_clientdata(client);
1248 if (strict_strtol(buf, 10, &temp))
1251 temp = DIV_ROUND_CLOSEST(temp, 1000);
1252 temp = SENSORS_LIMIT(temp, 0, 15);
1254 /* package things up */
1255 temp &= ADT7462_PWM_HYST_MASK;
1256 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
1258 mutex_lock(&data->lock);
1259 data->pwm_trange[attr->index] = temp;
1260 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1262 mutex_unlock(&data->lock);
1267 static ssize_t show_pwm_tmax(struct device *dev,
1268 struct device_attribute *devattr,
1271 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1272 struct adt7462_data *data = adt7462_update_device(dev);
1274 /* tmax = tmin + trange */
1275 int trange = trange_values[data->pwm_trange[attr->index] >>
1276 ADT7462_PWM_RANGE_SHIFT];
1277 int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1279 return sprintf(buf, "%d\n", tmin + trange);
1282 static ssize_t set_pwm_tmax(struct device *dev,
1283 struct device_attribute *devattr,
1288 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1289 struct i2c_client *client = to_i2c_client(dev);
1290 struct adt7462_data *data = i2c_get_clientdata(client);
1291 int tmin, trange_value;
1294 if (strict_strtol(buf, 10, &trange))
1297 /* trange = tmax - tmin */
1298 tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1299 trange_value = find_trange_value(trange - tmin);
1301 if (trange_value < 0)
1304 temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
1305 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
1307 mutex_lock(&data->lock);
1308 data->pwm_trange[attr->index] = temp;
1309 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1311 mutex_unlock(&data->lock);
1316 static ssize_t show_pwm_tmin(struct device *dev,
1317 struct device_attribute *devattr,
1320 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1321 struct adt7462_data *data = adt7462_update_device(dev);
1322 return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
1325 static ssize_t set_pwm_tmin(struct device *dev,
1326 struct device_attribute *devattr,
1330 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1331 struct i2c_client *client = to_i2c_client(dev);
1332 struct adt7462_data *data = i2c_get_clientdata(client);
1335 if (strict_strtol(buf, 10, &temp))
1338 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
1339 temp = SENSORS_LIMIT(temp, 0, 255);
1341 mutex_lock(&data->lock);
1342 data->pwm_tmin[attr->index] = temp;
1343 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
1345 mutex_unlock(&data->lock);
1350 static ssize_t show_pwm_auto(struct device *dev,
1351 struct device_attribute *devattr,
1354 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1355 struct adt7462_data *data = adt7462_update_device(dev);
1356 int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1360 return sprintf(buf, "0\n");
1361 case 7: /* manual */
1362 return sprintf(buf, "1\n");
1363 default: /* automatic */
1364 return sprintf(buf, "2\n");
1368 static void set_pwm_channel(struct i2c_client *client,
1369 struct adt7462_data *data,
1373 int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
1374 temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
1376 mutex_lock(&data->lock);
1377 data->pwm_cfg[which] = temp;
1378 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
1379 mutex_unlock(&data->lock);
1382 static ssize_t set_pwm_auto(struct device *dev,
1383 struct device_attribute *devattr,
1387 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1388 struct i2c_client *client = to_i2c_client(dev);
1389 struct adt7462_data *data = i2c_get_clientdata(client);
1392 if (strict_strtol(buf, 10, &temp))
1397 set_pwm_channel(client, data, attr->index, 4);
1399 case 1: /* manual */
1400 set_pwm_channel(client, data, attr->index, 7);
1407 static ssize_t show_pwm_auto_temp(struct device *dev,
1408 struct device_attribute *devattr,
1411 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1412 struct adt7462_data *data = adt7462_update_device(dev);
1413 int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1416 case 0: /* temp[1234] only */
1420 return sprintf(buf, "%d\n", (1 << channel));
1421 case 5: /* temp1 & temp4 */
1422 return sprintf(buf, "9\n");
1424 return sprintf(buf, "15\n");
1426 return sprintf(buf, "0\n");
1430 static int cvt_auto_temp(int input)
1436 if (input < 1 || !is_power_of_2(input))
1438 return ilog2(input);
1441 static ssize_t set_pwm_auto_temp(struct device *dev,
1442 struct device_attribute *devattr,
1446 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1447 struct i2c_client *client = to_i2c_client(dev);
1448 struct adt7462_data *data = i2c_get_clientdata(client);
1451 if (strict_strtol(buf, 10, &temp))
1454 temp = cvt_auto_temp(temp);
1458 set_pwm_channel(client, data, attr->index, temp);
1463 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
1465 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
1467 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
1469 static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max,
1472 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
1474 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
1476 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
1478 static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min,
1481 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1482 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
1483 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
1484 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
1486 static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0);
1487 static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1);
1488 static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2);
1489 static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3);
1491 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
1492 ADT7462_ALARM1 | ADT7462_LT_ALARM);
1493 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
1494 ADT7462_ALARM1 | ADT7462_R1T_ALARM);
1495 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
1496 ADT7462_ALARM1 | ADT7462_R2T_ALARM);
1497 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL,
1498 ADT7462_ALARM1 | ADT7462_R3T_ALARM);
1500 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, show_volt_max,
1502 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, show_volt_max,
1504 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, show_volt_max,
1506 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, show_volt_max,
1508 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, show_volt_max,
1510 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, show_volt_max,
1512 static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO, show_volt_max,
1514 static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO, show_volt_max,
1516 static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO, show_volt_max,
1518 static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO, show_volt_max,
1520 static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO, show_volt_max,
1522 static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO, show_volt_max,
1524 static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO, show_volt_max,
1527 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, show_volt_min,
1529 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, show_volt_min,
1531 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, show_volt_min,
1533 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, show_volt_min,
1535 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, show_volt_min,
1537 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, show_volt_min,
1539 static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO, show_volt_min,
1541 static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO, show_volt_min,
1543 static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO, show_volt_min,
1545 static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO, show_volt_min,
1547 static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO, show_volt_min,
1549 static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO, show_volt_min,
1551 static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO, show_volt_min,
1554 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_voltage, NULL, 0);
1555 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_voltage, NULL, 1);
1556 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_voltage, NULL, 2);
1557 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_voltage, NULL, 3);
1558 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_voltage, NULL, 4);
1559 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_voltage, NULL, 5);
1560 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_voltage, NULL, 6);
1561 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_voltage, NULL, 7);
1562 static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_voltage, NULL, 8);
1563 static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_voltage, NULL, 9);
1564 static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_voltage, NULL, 10);
1565 static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_voltage, NULL, 11);
1566 static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_voltage, NULL, 12);
1568 static SENSOR_DEVICE_ATTR(in1_label, S_IRUGO, show_voltage_label, NULL, 0);
1569 static SENSOR_DEVICE_ATTR(in2_label, S_IRUGO, show_voltage_label, NULL, 1);
1570 static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, show_voltage_label, NULL, 2);
1571 static SENSOR_DEVICE_ATTR(in4_label, S_IRUGO, show_voltage_label, NULL, 3);
1572 static SENSOR_DEVICE_ATTR(in5_label, S_IRUGO, show_voltage_label, NULL, 4);
1573 static SENSOR_DEVICE_ATTR(in6_label, S_IRUGO, show_voltage_label, NULL, 5);
1574 static SENSOR_DEVICE_ATTR(in7_label, S_IRUGO, show_voltage_label, NULL, 6);
1575 static SENSOR_DEVICE_ATTR(in8_label, S_IRUGO, show_voltage_label, NULL, 7);
1576 static SENSOR_DEVICE_ATTR(in9_label, S_IRUGO, show_voltage_label, NULL, 8);
1577 static SENSOR_DEVICE_ATTR(in10_label, S_IRUGO, show_voltage_label, NULL, 9);
1578 static SENSOR_DEVICE_ATTR(in11_label, S_IRUGO, show_voltage_label, NULL, 10);
1579 static SENSOR_DEVICE_ATTR(in12_label, S_IRUGO, show_voltage_label, NULL, 11);
1580 static SENSOR_DEVICE_ATTR(in13_label, S_IRUGO, show_voltage_label, NULL, 12);
1582 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL,
1583 ADT7462_ALARM2 | ADT7462_V0_ALARM);
1584 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL,
1585 ADT7462_ALARM2 | ADT7462_V7_ALARM);
1586 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL,
1587 ADT7462_ALARM2 | ADT7462_V2_ALARM);
1588 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL,
1589 ADT7462_ALARM2 | ADT7462_V6_ALARM);
1590 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL,
1591 ADT7462_ALARM2 | ADT7462_V5_ALARM);
1592 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL,
1593 ADT7462_ALARM2 | ADT7462_V4_ALARM);
1594 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL,
1595 ADT7462_ALARM2 | ADT7462_V3_ALARM);
1596 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL,
1597 ADT7462_ALARM2 | ADT7462_V1_ALARM);
1598 static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL,
1599 ADT7462_ALARM3 | ADT7462_V10_ALARM);
1600 static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL,
1601 ADT7462_ALARM3 | ADT7462_V9_ALARM);
1602 static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL,
1603 ADT7462_ALARM3 | ADT7462_V8_ALARM);
1604 static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL,
1605 ADT7462_ALARM3 | ADT7462_V11_ALARM);
1606 static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL,
1607 ADT7462_ALARM3 | ADT7462_V12_ALARM);
1609 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1611 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1613 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1615 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1617 static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
1619 static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO, show_fan_min,
1621 static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO, show_fan_min,
1623 static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO, show_fan_min,
1626 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
1627 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
1628 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
1629 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
1630 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4);
1631 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 5);
1632 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 6);
1633 static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan, NULL, 7);
1635 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
1636 ADT7462_ALARM4 | ADT7462_F0_ALARM);
1637 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
1638 ADT7462_ALARM4 | ADT7462_F1_ALARM);
1639 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
1640 ADT7462_ALARM4 | ADT7462_F2_ALARM);
1641 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
1642 ADT7462_ALARM4 | ADT7462_F3_ALARM);
1643 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL,
1644 ADT7462_ALARM4 | ADT7462_F4_ALARM);
1645 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL,
1646 ADT7462_ALARM4 | ADT7462_F5_ALARM);
1647 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL,
1648 ADT7462_ALARM4 | ADT7462_F6_ALARM);
1649 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_alarm, NULL,
1650 ADT7462_ALARM4 | ADT7462_F7_ALARM);
1652 static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO,
1653 show_force_pwm_max, set_force_pwm_max, 0);
1655 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
1656 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
1657 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
1658 static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
1660 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
1661 show_pwm_min, set_pwm_min, 0);
1662 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
1663 show_pwm_min, set_pwm_min, 1);
1664 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
1665 show_pwm_min, set_pwm_min, 2);
1666 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
1667 show_pwm_min, set_pwm_min, 3);
1669 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
1670 show_pwm_max, set_pwm_max, 0);
1671 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
1672 show_pwm_max, set_pwm_max, 1);
1673 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
1674 show_pwm_max, set_pwm_max, 2);
1675 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
1676 show_pwm_max, set_pwm_max, 3);
1678 static SENSOR_DEVICE_ATTR(temp1_auto_point1_hyst, S_IWUSR | S_IRUGO,
1679 show_pwm_hyst, set_pwm_hyst, 0);
1680 static SENSOR_DEVICE_ATTR(temp2_auto_point1_hyst, S_IWUSR | S_IRUGO,
1681 show_pwm_hyst, set_pwm_hyst, 1);
1682 static SENSOR_DEVICE_ATTR(temp3_auto_point1_hyst, S_IWUSR | S_IRUGO,
1683 show_pwm_hyst, set_pwm_hyst, 2);
1684 static SENSOR_DEVICE_ATTR(temp4_auto_point1_hyst, S_IWUSR | S_IRUGO,
1685 show_pwm_hyst, set_pwm_hyst, 3);
1687 static SENSOR_DEVICE_ATTR(temp1_auto_point2_hyst, S_IWUSR | S_IRUGO,
1688 show_pwm_hyst, set_pwm_hyst, 0);
1689 static SENSOR_DEVICE_ATTR(temp2_auto_point2_hyst, S_IWUSR | S_IRUGO,
1690 show_pwm_hyst, set_pwm_hyst, 1);
1691 static SENSOR_DEVICE_ATTR(temp3_auto_point2_hyst, S_IWUSR | S_IRUGO,
1692 show_pwm_hyst, set_pwm_hyst, 2);
1693 static SENSOR_DEVICE_ATTR(temp4_auto_point2_hyst, S_IWUSR | S_IRUGO,
1694 show_pwm_hyst, set_pwm_hyst, 3);
1696 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IWUSR | S_IRUGO,
1697 show_pwm_tmin, set_pwm_tmin, 0);
1698 static SENSOR_DEVICE_ATTR(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
1699 show_pwm_tmin, set_pwm_tmin, 1);
1700 static SENSOR_DEVICE_ATTR(temp3_auto_point1_temp, S_IWUSR | S_IRUGO,
1701 show_pwm_tmin, set_pwm_tmin, 2);
1702 static SENSOR_DEVICE_ATTR(temp4_auto_point1_temp, S_IWUSR | S_IRUGO,
1703 show_pwm_tmin, set_pwm_tmin, 3);
1705 static SENSOR_DEVICE_ATTR(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
1706 show_pwm_tmax, set_pwm_tmax, 0);
1707 static SENSOR_DEVICE_ATTR(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
1708 show_pwm_tmax, set_pwm_tmax, 1);
1709 static SENSOR_DEVICE_ATTR(temp3_auto_point2_temp, S_IWUSR | S_IRUGO,
1710 show_pwm_tmax, set_pwm_tmax, 2);
1711 static SENSOR_DEVICE_ATTR(temp4_auto_point2_temp, S_IWUSR | S_IRUGO,
1712 show_pwm_tmax, set_pwm_tmax, 3);
1714 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1716 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1718 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1720 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1723 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
1724 show_pwm_auto_temp, set_pwm_auto_temp, 0);
1725 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
1726 show_pwm_auto_temp, set_pwm_auto_temp, 1);
1727 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
1728 show_pwm_auto_temp, set_pwm_auto_temp, 2);
1729 static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO,
1730 show_pwm_auto_temp, set_pwm_auto_temp, 3);
1732 static struct attribute *adt7462_attr[] =
1734 &sensor_dev_attr_temp1_max.dev_attr.attr,
1735 &sensor_dev_attr_temp2_max.dev_attr.attr,
1736 &sensor_dev_attr_temp3_max.dev_attr.attr,
1737 &sensor_dev_attr_temp4_max.dev_attr.attr,
1739 &sensor_dev_attr_temp1_min.dev_attr.attr,
1740 &sensor_dev_attr_temp2_min.dev_attr.attr,
1741 &sensor_dev_attr_temp3_min.dev_attr.attr,
1742 &sensor_dev_attr_temp4_min.dev_attr.attr,
1744 &sensor_dev_attr_temp1_input.dev_attr.attr,
1745 &sensor_dev_attr_temp2_input.dev_attr.attr,
1746 &sensor_dev_attr_temp3_input.dev_attr.attr,
1747 &sensor_dev_attr_temp4_input.dev_attr.attr,
1749 &sensor_dev_attr_temp1_label.dev_attr.attr,
1750 &sensor_dev_attr_temp2_label.dev_attr.attr,
1751 &sensor_dev_attr_temp3_label.dev_attr.attr,
1752 &sensor_dev_attr_temp4_label.dev_attr.attr,
1754 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1755 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1756 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1757 &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1759 &sensor_dev_attr_in1_max.dev_attr.attr,
1760 &sensor_dev_attr_in2_max.dev_attr.attr,
1761 &sensor_dev_attr_in3_max.dev_attr.attr,
1762 &sensor_dev_attr_in4_max.dev_attr.attr,
1763 &sensor_dev_attr_in5_max.dev_attr.attr,
1764 &sensor_dev_attr_in6_max.dev_attr.attr,
1765 &sensor_dev_attr_in7_max.dev_attr.attr,
1766 &sensor_dev_attr_in8_max.dev_attr.attr,
1767 &sensor_dev_attr_in9_max.dev_attr.attr,
1768 &sensor_dev_attr_in10_max.dev_attr.attr,
1769 &sensor_dev_attr_in11_max.dev_attr.attr,
1770 &sensor_dev_attr_in12_max.dev_attr.attr,
1771 &sensor_dev_attr_in13_max.dev_attr.attr,
1773 &sensor_dev_attr_in1_min.dev_attr.attr,
1774 &sensor_dev_attr_in2_min.dev_attr.attr,
1775 &sensor_dev_attr_in3_min.dev_attr.attr,
1776 &sensor_dev_attr_in4_min.dev_attr.attr,
1777 &sensor_dev_attr_in5_min.dev_attr.attr,
1778 &sensor_dev_attr_in6_min.dev_attr.attr,
1779 &sensor_dev_attr_in7_min.dev_attr.attr,
1780 &sensor_dev_attr_in8_min.dev_attr.attr,
1781 &sensor_dev_attr_in9_min.dev_attr.attr,
1782 &sensor_dev_attr_in10_min.dev_attr.attr,
1783 &sensor_dev_attr_in11_min.dev_attr.attr,
1784 &sensor_dev_attr_in12_min.dev_attr.attr,
1785 &sensor_dev_attr_in13_min.dev_attr.attr,
1787 &sensor_dev_attr_in1_input.dev_attr.attr,
1788 &sensor_dev_attr_in2_input.dev_attr.attr,
1789 &sensor_dev_attr_in3_input.dev_attr.attr,
1790 &sensor_dev_attr_in4_input.dev_attr.attr,
1791 &sensor_dev_attr_in5_input.dev_attr.attr,
1792 &sensor_dev_attr_in6_input.dev_attr.attr,
1793 &sensor_dev_attr_in7_input.dev_attr.attr,
1794 &sensor_dev_attr_in8_input.dev_attr.attr,
1795 &sensor_dev_attr_in9_input.dev_attr.attr,
1796 &sensor_dev_attr_in10_input.dev_attr.attr,
1797 &sensor_dev_attr_in11_input.dev_attr.attr,
1798 &sensor_dev_attr_in12_input.dev_attr.attr,
1799 &sensor_dev_attr_in13_input.dev_attr.attr,
1801 &sensor_dev_attr_in1_label.dev_attr.attr,
1802 &sensor_dev_attr_in2_label.dev_attr.attr,
1803 &sensor_dev_attr_in3_label.dev_attr.attr,
1804 &sensor_dev_attr_in4_label.dev_attr.attr,
1805 &sensor_dev_attr_in5_label.dev_attr.attr,
1806 &sensor_dev_attr_in6_label.dev_attr.attr,
1807 &sensor_dev_attr_in7_label.dev_attr.attr,
1808 &sensor_dev_attr_in8_label.dev_attr.attr,
1809 &sensor_dev_attr_in9_label.dev_attr.attr,
1810 &sensor_dev_attr_in10_label.dev_attr.attr,
1811 &sensor_dev_attr_in11_label.dev_attr.attr,
1812 &sensor_dev_attr_in12_label.dev_attr.attr,
1813 &sensor_dev_attr_in13_label.dev_attr.attr,
1815 &sensor_dev_attr_in1_alarm.dev_attr.attr,
1816 &sensor_dev_attr_in2_alarm.dev_attr.attr,
1817 &sensor_dev_attr_in3_alarm.dev_attr.attr,
1818 &sensor_dev_attr_in4_alarm.dev_attr.attr,
1819 &sensor_dev_attr_in5_alarm.dev_attr.attr,
1820 &sensor_dev_attr_in6_alarm.dev_attr.attr,
1821 &sensor_dev_attr_in7_alarm.dev_attr.attr,
1822 &sensor_dev_attr_in8_alarm.dev_attr.attr,
1823 &sensor_dev_attr_in9_alarm.dev_attr.attr,
1824 &sensor_dev_attr_in10_alarm.dev_attr.attr,
1825 &sensor_dev_attr_in11_alarm.dev_attr.attr,
1826 &sensor_dev_attr_in12_alarm.dev_attr.attr,
1827 &sensor_dev_attr_in13_alarm.dev_attr.attr,
1829 &sensor_dev_attr_fan1_min.dev_attr.attr,
1830 &sensor_dev_attr_fan2_min.dev_attr.attr,
1831 &sensor_dev_attr_fan3_min.dev_attr.attr,
1832 &sensor_dev_attr_fan4_min.dev_attr.attr,
1833 &sensor_dev_attr_fan5_min.dev_attr.attr,
1834 &sensor_dev_attr_fan6_min.dev_attr.attr,
1835 &sensor_dev_attr_fan7_min.dev_attr.attr,
1836 &sensor_dev_attr_fan8_min.dev_attr.attr,
1838 &sensor_dev_attr_fan1_input.dev_attr.attr,
1839 &sensor_dev_attr_fan2_input.dev_attr.attr,
1840 &sensor_dev_attr_fan3_input.dev_attr.attr,
1841 &sensor_dev_attr_fan4_input.dev_attr.attr,
1842 &sensor_dev_attr_fan5_input.dev_attr.attr,
1843 &sensor_dev_attr_fan6_input.dev_attr.attr,
1844 &sensor_dev_attr_fan7_input.dev_attr.attr,
1845 &sensor_dev_attr_fan8_input.dev_attr.attr,
1847 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1848 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1849 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1850 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1851 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1852 &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1853 &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1854 &sensor_dev_attr_fan8_alarm.dev_attr.attr,
1856 &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1857 &sensor_dev_attr_pwm1.dev_attr.attr,
1858 &sensor_dev_attr_pwm2.dev_attr.attr,
1859 &sensor_dev_attr_pwm3.dev_attr.attr,
1860 &sensor_dev_attr_pwm4.dev_attr.attr,
1862 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1863 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1864 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1865 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1867 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1868 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1869 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1870 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1872 &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
1873 &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
1874 &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
1875 &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
1877 &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
1878 &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
1879 &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
1880 &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
1882 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1883 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1884 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1885 &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
1887 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1888 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1889 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1890 &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
1892 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1893 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1894 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1895 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1897 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1898 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1899 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1900 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1904 /* Return 0 if detection is successful, -ENODEV otherwise */
1905 static int adt7462_detect(struct i2c_client *client, int kind,
1906 struct i2c_board_info *info)
1908 struct i2c_adapter *adapter = client->adapter;
1910 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1914 int vendor, device, revision;
1916 vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
1917 if (vendor != ADT7462_VENDOR)
1920 device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
1921 if (device != ADT7462_DEVICE)
1924 revision = i2c_smbus_read_byte_data(client,
1925 ADT7462_REG_REVISION);
1926 if (revision != ADT7462_REVISION)
1929 dev_dbg(&adapter->dev, "detection forced\n");
1931 strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
1936 static int adt7462_probe(struct i2c_client *client,
1937 const struct i2c_device_id *id)
1939 struct adt7462_data *data;
1942 data = kzalloc(sizeof(struct adt7462_data), GFP_KERNEL);
1948 i2c_set_clientdata(client, data);
1949 mutex_init(&data->lock);
1951 dev_info(&client->dev, "%s chip found\n", client->name);
1953 /* Register sysfs hooks */
1954 data->attrs.attrs = adt7462_attr;
1955 err = sysfs_create_group(&client->dev.kobj, &data->attrs);
1959 data->hwmon_dev = hwmon_device_register(&client->dev);
1960 if (IS_ERR(data->hwmon_dev)) {
1961 err = PTR_ERR(data->hwmon_dev);
1968 sysfs_remove_group(&client->dev.kobj, &data->attrs);
1975 static int adt7462_remove(struct i2c_client *client)
1977 struct adt7462_data *data = i2c_get_clientdata(client);
1979 hwmon_device_unregister(data->hwmon_dev);
1980 sysfs_remove_group(&client->dev.kobj, &data->attrs);
1985 static int __init adt7462_init(void)
1987 return i2c_add_driver(&adt7462_driver);
1990 static void __exit adt7462_exit(void)
1992 i2c_del_driver(&adt7462_driver);
1995 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1996 MODULE_DESCRIPTION("ADT7462 driver");
1997 MODULE_LICENSE("GPL");
1999 module_init(adt7462_init);
2000 module_exit(adt7462_exit);