2 * A hwmon driver for the Analog Devices ADT7462
3 * Copyright (C) 2008 IBM
5 * Author: Darrick J. Wong <darrick.wong@oracle.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #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/log2.h>
30 #include <linux/slab.h>
32 /* Addresses to scan */
33 static const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END };
35 /* ADT7462 registers */
36 #define ADT7462_REG_DEVICE 0x3D
37 #define ADT7462_REG_VENDOR 0x3E
38 #define ADT7462_REG_REVISION 0x3F
40 #define ADT7462_REG_MIN_TEMP_BASE_ADDR 0x44
41 #define ADT7462_REG_MIN_TEMP_MAX_ADDR 0x47
42 #define ADT7462_REG_MAX_TEMP_BASE_ADDR 0x48
43 #define ADT7462_REG_MAX_TEMP_MAX_ADDR 0x4B
44 #define ADT7462_REG_TEMP_BASE_ADDR 0x88
45 #define ADT7462_REG_TEMP_MAX_ADDR 0x8F
47 #define ADT7462_REG_FAN_BASE_ADDR 0x98
48 #define ADT7462_REG_FAN_MAX_ADDR 0x9F
49 #define ADT7462_REG_FAN2_BASE_ADDR 0xA2
50 #define ADT7462_REG_FAN2_MAX_ADDR 0xA9
51 #define ADT7462_REG_FAN_ENABLE 0x07
52 #define ADT7462_REG_FAN_MIN_BASE_ADDR 0x78
53 #define ADT7462_REG_FAN_MIN_MAX_ADDR 0x7F
55 #define ADT7462_REG_CFG2 0x02
56 #define ADT7462_FSPD_MASK 0x20
58 #define ADT7462_REG_PWM_BASE_ADDR 0xAA
59 #define ADT7462_REG_PWM_MAX_ADDR 0xAD
60 #define ADT7462_REG_PWM_MIN_BASE_ADDR 0x28
61 #define ADT7462_REG_PWM_MIN_MAX_ADDR 0x2B
62 #define ADT7462_REG_PWM_MAX 0x2C
63 #define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR 0x5C
64 #define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR 0x5F
65 #define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR 0x60
66 #define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR 0x63
67 #define ADT7462_PWM_HYST_MASK 0x0F
68 #define ADT7462_PWM_RANGE_MASK 0xF0
69 #define ADT7462_PWM_RANGE_SHIFT 4
70 #define ADT7462_REG_PWM_CFG_BASE_ADDR 0x21
71 #define ADT7462_REG_PWM_CFG_MAX_ADDR 0x24
72 #define ADT7462_PWM_CHANNEL_MASK 0xE0
73 #define ADT7462_PWM_CHANNEL_SHIFT 5
75 #define ADT7462_REG_PIN_CFG_BASE_ADDR 0x10
76 #define ADT7462_REG_PIN_CFG_MAX_ADDR 0x13
77 #define ADT7462_PIN7_INPUT 0x01 /* cfg0 */
78 #define ADT7462_DIODE3_INPUT 0x20
79 #define ADT7462_DIODE1_INPUT 0x40
80 #define ADT7462_VID_INPUT 0x80
81 #define ADT7462_PIN22_INPUT 0x04 /* cfg1 */
82 #define ADT7462_PIN21_INPUT 0x08
83 #define ADT7462_PIN19_INPUT 0x10
84 #define ADT7462_PIN15_INPUT 0x20
85 #define ADT7462_PIN13_INPUT 0x40
86 #define ADT7462_PIN8_INPUT 0x80
87 #define ADT7462_PIN23_MASK 0x03
88 #define ADT7462_PIN23_SHIFT 0
89 #define ADT7462_PIN26_MASK 0x0C /* cfg2 */
90 #define ADT7462_PIN26_SHIFT 2
91 #define ADT7462_PIN25_MASK 0x30
92 #define ADT7462_PIN25_SHIFT 4
93 #define ADT7462_PIN24_MASK 0xC0
94 #define ADT7462_PIN24_SHIFT 6
95 #define ADT7462_PIN26_VOLT_INPUT 0x08
96 #define ADT7462_PIN25_VOLT_INPUT 0x20
97 #define ADT7462_PIN28_SHIFT 4 /* cfg3 */
98 #define ADT7462_PIN28_VOLT 0x5
100 #define ADT7462_REG_ALARM1 0xB8
101 #define ADT7462_LT_ALARM 0x02
102 #define ADT7462_R1T_ALARM 0x04
103 #define ADT7462_R2T_ALARM 0x08
104 #define ADT7462_R3T_ALARM 0x10
105 #define ADT7462_REG_ALARM2 0xBB
106 #define ADT7462_V0_ALARM 0x01
107 #define ADT7462_V1_ALARM 0x02
108 #define ADT7462_V2_ALARM 0x04
109 #define ADT7462_V3_ALARM 0x08
110 #define ADT7462_V4_ALARM 0x10
111 #define ADT7462_V5_ALARM 0x20
112 #define ADT7462_V6_ALARM 0x40
113 #define ADT7462_V7_ALARM 0x80
114 #define ADT7462_REG_ALARM3 0xBC
115 #define ADT7462_V8_ALARM 0x08
116 #define ADT7462_V9_ALARM 0x10
117 #define ADT7462_V10_ALARM 0x20
118 #define ADT7462_V11_ALARM 0x40
119 #define ADT7462_V12_ALARM 0x80
120 #define ADT7462_REG_ALARM4 0xBD
121 #define ADT7462_F0_ALARM 0x01
122 #define ADT7462_F1_ALARM 0x02
123 #define ADT7462_F2_ALARM 0x04
124 #define ADT7462_F3_ALARM 0x08
125 #define ADT7462_F4_ALARM 0x10
126 #define ADT7462_F5_ALARM 0x20
127 #define ADT7462_F6_ALARM 0x40
128 #define ADT7462_F7_ALARM 0x80
129 #define ADT7462_ALARM1 0x0000
130 #define ADT7462_ALARM2 0x0100
131 #define ADT7462_ALARM3 0x0200
132 #define ADT7462_ALARM4 0x0300
133 #define ADT7462_ALARM_REG_SHIFT 8
134 #define ADT7462_ALARM_FLAG_MASK 0x0F
136 #define ADT7462_TEMP_COUNT 4
137 #define ADT7462_TEMP_REG(x) (ADT7462_REG_TEMP_BASE_ADDR + ((x) * 2))
138 #define ADT7462_TEMP_MIN_REG(x) (ADT7462_REG_MIN_TEMP_BASE_ADDR + (x))
139 #define ADT7462_TEMP_MAX_REG(x) (ADT7462_REG_MAX_TEMP_BASE_ADDR + (x))
140 #define TEMP_FRAC_OFFSET 6
142 #define ADT7462_FAN_COUNT 8
143 #define ADT7462_REG_FAN_MIN(x) (ADT7462_REG_FAN_MIN_BASE_ADDR + (x))
145 #define ADT7462_PWM_COUNT 4
146 #define ADT7462_REG_PWM(x) (ADT7462_REG_PWM_BASE_ADDR + (x))
147 #define ADT7462_REG_PWM_MIN(x) (ADT7462_REG_PWM_MIN_BASE_ADDR + (x))
148 #define ADT7462_REG_PWM_TMIN(x) \
149 (ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
150 #define ADT7462_REG_PWM_TRANGE(x) \
151 (ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x))
153 #define ADT7462_PIN_CFG_REG_COUNT 4
154 #define ADT7462_REG_PIN_CFG(x) (ADT7462_REG_PIN_CFG_BASE_ADDR + (x))
155 #define ADT7462_REG_PWM_CFG(x) (ADT7462_REG_PWM_CFG_BASE_ADDR + (x))
157 #define ADT7462_ALARM_REG_COUNT 4
160 * The chip can measure 13 different voltage sources:
163 * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23)
166 * 5. +1.25V/+0.9V (pin 19)
167 * 6. +2.5V/+1.8V (pin 15)
170 * 9. Vbatt/FSB_Vtt (pin 26)
171 * A. +3.3V/+1.2V1 (pin 25)
172 * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24)
173 * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V)
174 * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V)
176 * Each of these 13 has a factor to convert raw to voltage. Even better,
177 * the pins can be connected to other sensors (tach/gpio/hot/etc), which
178 * makes the bookkeeping tricky.
180 * Some, but not all, of these voltages have low/high limits.
182 #define ADT7462_VOLT_COUNT 13
184 #define ADT7462_VENDOR 0x41
185 #define ADT7462_DEVICE 0x62
186 /* datasheet only mentions a revision 4 */
187 #define ADT7462_REVISION 0x04
189 /* How often do we reread sensors values? (In jiffies) */
190 #define SENSOR_REFRESH_INTERVAL (2 * HZ)
192 /* How often do we reread sensor limit values? (In jiffies) */
193 #define LIMIT_REFRESH_INTERVAL (60 * HZ)
195 /* datasheet says to divide this number by the fan reading to get fan rpm */
196 #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
197 #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
198 #define FAN_PERIOD_INVALID 65535
199 #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
201 #define MASK_AND_SHIFT(value, prefix) \
202 (((value) & prefix##_MASK) >> prefix##_SHIFT)
204 struct adt7462_data {
205 struct i2c_client *client;
209 unsigned long sensors_last_updated; /* In jiffies */
210 unsigned long limits_last_updated; /* In jiffies */
212 u8 temp[ADT7462_TEMP_COUNT];
213 /* bits 6-7 are quarter pieces of temp */
214 u8 temp_frac[ADT7462_TEMP_COUNT];
215 u8 temp_min[ADT7462_TEMP_COUNT];
216 u8 temp_max[ADT7462_TEMP_COUNT];
217 u16 fan[ADT7462_FAN_COUNT];
219 u8 fan_min[ADT7462_FAN_COUNT];
221 u8 pwm[ADT7462_PWM_COUNT];
222 u8 pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
223 u8 voltages[ADT7462_VOLT_COUNT];
224 u8 volt_max[ADT7462_VOLT_COUNT];
225 u8 volt_min[ADT7462_VOLT_COUNT];
226 u8 pwm_min[ADT7462_PWM_COUNT];
227 u8 pwm_tmin[ADT7462_PWM_COUNT];
228 u8 pwm_trange[ADT7462_PWM_COUNT];
229 u8 pwm_max; /* only one per chip */
230 u8 pwm_cfg[ADT7462_PWM_COUNT];
231 u8 alarms[ADT7462_ALARM_REG_COUNT];
235 * 16-bit registers on the ADT7462 are low-byte first. The data sheet says
236 * that the low byte must be read before the high byte.
238 static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
241 foo = i2c_smbus_read_byte_data(client, reg);
242 foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
246 /* For some reason these registers are not contiguous. */
247 static int ADT7462_REG_FAN(int fan)
250 return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
251 return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
254 /* Voltage registers are scattered everywhere */
255 static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
259 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
265 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
269 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
273 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
277 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
281 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
285 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
289 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
293 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
299 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
300 ADT7462_PIN28_VOLT &&
301 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
305 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
306 ADT7462_PIN28_VOLT &&
307 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
314 static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
318 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
324 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
328 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
332 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
336 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
340 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
344 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
348 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
352 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
358 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
359 ADT7462_PIN28_VOLT &&
360 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
364 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
365 ADT7462_PIN28_VOLT &&
366 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
373 static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
377 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
383 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
387 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
391 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
395 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
399 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
403 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
407 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
411 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
417 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
418 ADT7462_PIN28_VOLT &&
419 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
423 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
424 ADT7462_PIN28_VOLT &&
425 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
432 /* Provide labels for sysfs */
433 static const char *voltage_label(struct adt7462_data *data, int which)
437 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
441 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
452 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
456 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
460 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
461 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
467 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
468 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
474 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
478 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
482 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
490 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
498 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
509 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
510 ADT7462_PIN28_VOLT &&
511 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
515 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
516 ADT7462_PIN28_VOLT &&
517 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
518 return "+1.5V 3GPIO";
524 /* Multipliers are actually in uV, not mV. */
525 static int voltage_multiplier(struct adt7462_data *data, int which)
529 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
533 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
535 if (data->pin_cfg[0] & ADT7462_VID_INPUT)
546 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
550 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
554 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
555 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
561 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
562 if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
568 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
572 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
576 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
584 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
592 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
604 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
605 ADT7462_PIN28_VOLT &&
606 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
612 static int temp_enabled(struct adt7462_data *data, int which)
619 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
623 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
630 static const char *temp_label(struct adt7462_data *data, int which)
636 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
642 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
649 /* Map Trange register values to mC */
650 #define NUM_TRANGE_VALUES 16
651 static const int trange_values[NUM_TRANGE_VALUES] = {
670 static int find_trange_value(int trange)
674 for (i = 0; i < NUM_TRANGE_VALUES; i++)
675 if (trange_values[i] == trange)
681 static struct adt7462_data *adt7462_update_device(struct device *dev)
683 struct adt7462_data *data = dev_get_drvdata(dev);
684 struct i2c_client *client = data->client;
685 unsigned long local_jiffies = jiffies;
688 mutex_lock(&data->lock);
689 if (time_before(local_jiffies, data->sensors_last_updated +
690 SENSOR_REFRESH_INTERVAL)
691 && data->sensors_valid)
692 goto no_sensor_update;
694 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
696 * Reading the fractional register locks the integral
697 * register until both have been read.
699 data->temp_frac[i] = i2c_smbus_read_byte_data(client,
700 ADT7462_TEMP_REG(i));
701 data->temp[i] = i2c_smbus_read_byte_data(client,
702 ADT7462_TEMP_REG(i) + 1);
705 for (i = 0; i < ADT7462_FAN_COUNT; i++)
706 data->fan[i] = adt7462_read_word_data(client,
709 data->fan_enabled = i2c_smbus_read_byte_data(client,
710 ADT7462_REG_FAN_ENABLE);
712 for (i = 0; i < ADT7462_PWM_COUNT; i++)
713 data->pwm[i] = i2c_smbus_read_byte_data(client,
716 for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
717 data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
718 ADT7462_REG_PIN_CFG(i));
720 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
721 int reg = ADT7462_REG_VOLT(data, i);
723 data->voltages[i] = 0;
725 data->voltages[i] = i2c_smbus_read_byte_data(client,
729 data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
730 data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
731 data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
732 data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
734 data->sensors_last_updated = local_jiffies;
735 data->sensors_valid = 1;
738 if (time_before(local_jiffies, data->limits_last_updated +
739 LIMIT_REFRESH_INTERVAL)
740 && data->limits_valid)
743 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
744 data->temp_min[i] = i2c_smbus_read_byte_data(client,
745 ADT7462_TEMP_MIN_REG(i));
746 data->temp_max[i] = i2c_smbus_read_byte_data(client,
747 ADT7462_TEMP_MAX_REG(i));
750 for (i = 0; i < ADT7462_FAN_COUNT; i++)
751 data->fan_min[i] = i2c_smbus_read_byte_data(client,
752 ADT7462_REG_FAN_MIN(i));
754 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
755 int reg = ADT7462_REG_VOLT_MAX(data, i);
757 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
759 reg = ADT7462_REG_VOLT_MIN(data, i);
761 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
764 for (i = 0; i < ADT7462_PWM_COUNT; i++) {
765 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
766 ADT7462_REG_PWM_MIN(i));
767 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
768 ADT7462_REG_PWM_TMIN(i));
769 data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
770 ADT7462_REG_PWM_TRANGE(i));
771 data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
772 ADT7462_REG_PWM_CFG(i));
775 data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
777 data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
779 data->limits_last_updated = local_jiffies;
780 data->limits_valid = 1;
783 mutex_unlock(&data->lock);
787 static ssize_t temp_min_show(struct device *dev,
788 struct device_attribute *devattr, char *buf)
790 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
791 struct adt7462_data *data = adt7462_update_device(dev);
793 if (!temp_enabled(data, attr->index))
794 return sprintf(buf, "0\n");
796 return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
799 static ssize_t temp_min_store(struct device *dev,
800 struct device_attribute *devattr,
801 const char *buf, size_t count)
803 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
804 struct adt7462_data *data = dev_get_drvdata(dev);
805 struct i2c_client *client = data->client;
808 if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
811 temp = clamp_val(temp, -64000, 191000);
812 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
814 mutex_lock(&data->lock);
815 data->temp_min[attr->index] = temp;
816 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
818 mutex_unlock(&data->lock);
823 static ssize_t temp_max_show(struct device *dev,
824 struct device_attribute *devattr, char *buf)
826 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
827 struct adt7462_data *data = adt7462_update_device(dev);
829 if (!temp_enabled(data, attr->index))
830 return sprintf(buf, "0\n");
832 return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
835 static ssize_t temp_max_store(struct device *dev,
836 struct device_attribute *devattr,
837 const char *buf, size_t count)
839 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
840 struct adt7462_data *data = dev_get_drvdata(dev);
841 struct i2c_client *client = data->client;
844 if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
847 temp = clamp_val(temp, -64000, 191000);
848 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
850 mutex_lock(&data->lock);
851 data->temp_max[attr->index] = temp;
852 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
854 mutex_unlock(&data->lock);
859 static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
862 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
863 struct adt7462_data *data = adt7462_update_device(dev);
864 u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
866 if (!temp_enabled(data, attr->index))
867 return sprintf(buf, "0\n");
869 return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
873 static ssize_t temp_label_show(struct device *dev,
874 struct device_attribute *devattr, char *buf)
876 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
877 struct adt7462_data *data = adt7462_update_device(dev);
879 return sprintf(buf, "%s\n", temp_label(data, attr->index));
882 static ssize_t volt_max_show(struct device *dev,
883 struct device_attribute *devattr, char *buf)
885 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
886 struct adt7462_data *data = adt7462_update_device(dev);
887 int x = voltage_multiplier(data, attr->index);
889 x *= data->volt_max[attr->index];
890 x /= 1000; /* convert from uV to mV */
892 return sprintf(buf, "%d\n", x);
895 static ssize_t volt_max_store(struct device *dev,
896 struct device_attribute *devattr,
897 const char *buf, size_t count)
899 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
900 struct adt7462_data *data = dev_get_drvdata(dev);
901 struct i2c_client *client = data->client;
902 int x = voltage_multiplier(data, attr->index);
905 if (kstrtol(buf, 10, &temp) || !x)
908 temp = clamp_val(temp, 0, 255 * x / 1000);
909 temp *= 1000; /* convert mV to uV */
910 temp = DIV_ROUND_CLOSEST(temp, x);
912 mutex_lock(&data->lock);
913 data->volt_max[attr->index] = temp;
914 i2c_smbus_write_byte_data(client,
915 ADT7462_REG_VOLT_MAX(data, attr->index),
917 mutex_unlock(&data->lock);
922 static ssize_t volt_min_show(struct device *dev,
923 struct device_attribute *devattr, char *buf)
925 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
926 struct adt7462_data *data = adt7462_update_device(dev);
927 int x = voltage_multiplier(data, attr->index);
929 x *= data->volt_min[attr->index];
930 x /= 1000; /* convert from uV to mV */
932 return sprintf(buf, "%d\n", x);
935 static ssize_t volt_min_store(struct device *dev,
936 struct device_attribute *devattr,
937 const char *buf, size_t count)
939 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
940 struct adt7462_data *data = dev_get_drvdata(dev);
941 struct i2c_client *client = data->client;
942 int x = voltage_multiplier(data, attr->index);
945 if (kstrtol(buf, 10, &temp) || !x)
948 temp = clamp_val(temp, 0, 255 * x / 1000);
949 temp *= 1000; /* convert mV to uV */
950 temp = DIV_ROUND_CLOSEST(temp, x);
952 mutex_lock(&data->lock);
953 data->volt_min[attr->index] = temp;
954 i2c_smbus_write_byte_data(client,
955 ADT7462_REG_VOLT_MIN(data, attr->index),
957 mutex_unlock(&data->lock);
962 static ssize_t voltage_show(struct device *dev,
963 struct device_attribute *devattr, char *buf)
965 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
966 struct adt7462_data *data = adt7462_update_device(dev);
967 int x = voltage_multiplier(data, attr->index);
969 x *= data->voltages[attr->index];
970 x /= 1000; /* convert from uV to mV */
972 return sprintf(buf, "%d\n", x);
975 static ssize_t voltage_label_show(struct device *dev,
976 struct device_attribute *devattr, char *buf)
978 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
979 struct adt7462_data *data = adt7462_update_device(dev);
981 return sprintf(buf, "%s\n", voltage_label(data, attr->index));
984 static ssize_t alarm_show(struct device *dev,
985 struct device_attribute *devattr, char *buf)
987 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
988 struct adt7462_data *data = adt7462_update_device(dev);
989 int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
990 int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
992 if (data->alarms[reg] & mask)
993 return sprintf(buf, "1\n");
995 return sprintf(buf, "0\n");
998 static int fan_enabled(struct adt7462_data *data, int fan)
1000 return data->fan_enabled & (1 << fan);
1003 static ssize_t fan_min_show(struct device *dev,
1004 struct device_attribute *devattr, char *buf)
1006 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1007 struct adt7462_data *data = adt7462_update_device(dev);
1010 /* Only the MSB of the min fan period is stored... */
1011 temp = data->fan_min[attr->index];
1014 if (!fan_enabled(data, attr->index) ||
1015 !FAN_DATA_VALID(temp))
1016 return sprintf(buf, "0\n");
1018 return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
1021 static ssize_t fan_min_store(struct device *dev,
1022 struct device_attribute *devattr,
1023 const char *buf, size_t count)
1025 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1026 struct adt7462_data *data = dev_get_drvdata(dev);
1027 struct i2c_client *client = data->client;
1030 if (kstrtol(buf, 10, &temp) || !temp ||
1031 !fan_enabled(data, attr->index))
1034 temp = FAN_RPM_TO_PERIOD(temp);
1036 temp = clamp_val(temp, 1, 255);
1038 mutex_lock(&data->lock);
1039 data->fan_min[attr->index] = temp;
1040 i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
1042 mutex_unlock(&data->lock);
1047 static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
1050 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1051 struct adt7462_data *data = adt7462_update_device(dev);
1053 if (!fan_enabled(data, attr->index) ||
1054 !FAN_DATA_VALID(data->fan[attr->index]))
1055 return sprintf(buf, "0\n");
1057 return sprintf(buf, "%d\n",
1058 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
1061 static ssize_t force_pwm_max_show(struct device *dev,
1062 struct device_attribute *devattr, char *buf)
1064 struct adt7462_data *data = adt7462_update_device(dev);
1065 return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
1068 static ssize_t force_pwm_max_store(struct device *dev,
1069 struct device_attribute *devattr,
1070 const char *buf, size_t count)
1072 struct adt7462_data *data = dev_get_drvdata(dev);
1073 struct i2c_client *client = data->client;
1077 if (kstrtol(buf, 10, &temp))
1080 mutex_lock(&data->lock);
1081 reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
1083 reg |= ADT7462_FSPD_MASK;
1085 reg &= ~ADT7462_FSPD_MASK;
1087 i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
1088 mutex_unlock(&data->lock);
1093 static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
1096 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1097 struct adt7462_data *data = adt7462_update_device(dev);
1098 return sprintf(buf, "%d\n", data->pwm[attr->index]);
1101 static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
1102 const char *buf, size_t count)
1104 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1105 struct adt7462_data *data = dev_get_drvdata(dev);
1106 struct i2c_client *client = data->client;
1109 if (kstrtol(buf, 10, &temp))
1112 temp = clamp_val(temp, 0, 255);
1114 mutex_lock(&data->lock);
1115 data->pwm[attr->index] = temp;
1116 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
1117 mutex_unlock(&data->lock);
1122 static ssize_t pwm_max_show(struct device *dev,
1123 struct device_attribute *devattr, char *buf)
1125 struct adt7462_data *data = adt7462_update_device(dev);
1126 return sprintf(buf, "%d\n", data->pwm_max);
1129 static ssize_t pwm_max_store(struct device *dev,
1130 struct device_attribute *devattr,
1131 const char *buf, size_t count)
1133 struct adt7462_data *data = dev_get_drvdata(dev);
1134 struct i2c_client *client = data->client;
1137 if (kstrtol(buf, 10, &temp))
1140 temp = clamp_val(temp, 0, 255);
1142 mutex_lock(&data->lock);
1143 data->pwm_max = temp;
1144 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
1145 mutex_unlock(&data->lock);
1150 static ssize_t pwm_min_show(struct device *dev,
1151 struct device_attribute *devattr, char *buf)
1153 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1154 struct adt7462_data *data = adt7462_update_device(dev);
1155 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
1158 static ssize_t pwm_min_store(struct device *dev,
1159 struct device_attribute *devattr,
1160 const char *buf, size_t count)
1162 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1163 struct adt7462_data *data = dev_get_drvdata(dev);
1164 struct i2c_client *client = data->client;
1167 if (kstrtol(buf, 10, &temp))
1170 temp = clamp_val(temp, 0, 255);
1172 mutex_lock(&data->lock);
1173 data->pwm_min[attr->index] = temp;
1174 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
1176 mutex_unlock(&data->lock);
1181 static ssize_t pwm_hyst_show(struct device *dev,
1182 struct device_attribute *devattr, char *buf)
1184 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1185 struct adt7462_data *data = adt7462_update_device(dev);
1186 return sprintf(buf, "%d\n", 1000 *
1187 (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
1190 static ssize_t pwm_hyst_store(struct device *dev,
1191 struct device_attribute *devattr,
1192 const char *buf, size_t count)
1194 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1195 struct adt7462_data *data = dev_get_drvdata(dev);
1196 struct i2c_client *client = data->client;
1199 if (kstrtol(buf, 10, &temp))
1202 temp = clamp_val(temp, 0, 15000);
1203 temp = DIV_ROUND_CLOSEST(temp, 1000);
1205 /* package things up */
1206 temp &= ADT7462_PWM_HYST_MASK;
1207 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
1209 mutex_lock(&data->lock);
1210 data->pwm_trange[attr->index] = temp;
1211 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1213 mutex_unlock(&data->lock);
1218 static ssize_t pwm_tmax_show(struct device *dev,
1219 struct device_attribute *devattr, char *buf)
1221 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1222 struct adt7462_data *data = adt7462_update_device(dev);
1224 /* tmax = tmin + trange */
1225 int trange = trange_values[data->pwm_trange[attr->index] >>
1226 ADT7462_PWM_RANGE_SHIFT];
1227 int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1229 return sprintf(buf, "%d\n", tmin + trange);
1232 static ssize_t pwm_tmax_store(struct device *dev,
1233 struct device_attribute *devattr,
1234 const char *buf, size_t count)
1237 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1238 struct adt7462_data *data = dev_get_drvdata(dev);
1239 struct i2c_client *client = data->client;
1240 int tmin, trange_value;
1243 if (kstrtol(buf, 10, &trange))
1246 /* trange = tmax - tmin */
1247 tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1248 trange_value = find_trange_value(trange - tmin);
1249 if (trange_value < 0)
1250 return trange_value;
1252 temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
1253 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
1255 mutex_lock(&data->lock);
1256 data->pwm_trange[attr->index] = temp;
1257 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1259 mutex_unlock(&data->lock);
1264 static ssize_t pwm_tmin_show(struct device *dev,
1265 struct device_attribute *devattr, char *buf)
1267 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1268 struct adt7462_data *data = adt7462_update_device(dev);
1269 return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
1272 static ssize_t pwm_tmin_store(struct device *dev,
1273 struct device_attribute *devattr,
1274 const char *buf, size_t count)
1276 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1277 struct adt7462_data *data = dev_get_drvdata(dev);
1278 struct i2c_client *client = data->client;
1281 if (kstrtol(buf, 10, &temp))
1284 temp = clamp_val(temp, -64000, 191000);
1285 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
1287 mutex_lock(&data->lock);
1288 data->pwm_tmin[attr->index] = temp;
1289 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
1291 mutex_unlock(&data->lock);
1296 static ssize_t pwm_auto_show(struct device *dev,
1297 struct device_attribute *devattr, char *buf)
1299 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1300 struct adt7462_data *data = adt7462_update_device(dev);
1301 int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1305 return sprintf(buf, "0\n");
1306 case 7: /* manual */
1307 return sprintf(buf, "1\n");
1308 default: /* automatic */
1309 return sprintf(buf, "2\n");
1313 static void set_pwm_channel(struct i2c_client *client,
1314 struct adt7462_data *data,
1318 int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
1319 temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
1321 mutex_lock(&data->lock);
1322 data->pwm_cfg[which] = temp;
1323 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
1324 mutex_unlock(&data->lock);
1327 static ssize_t pwm_auto_store(struct device *dev,
1328 struct device_attribute *devattr,
1329 const char *buf, size_t count)
1331 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1332 struct adt7462_data *data = dev_get_drvdata(dev);
1333 struct i2c_client *client = data->client;
1336 if (kstrtol(buf, 10, &temp))
1341 set_pwm_channel(client, data, attr->index, 4);
1343 case 1: /* manual */
1344 set_pwm_channel(client, data, attr->index, 7);
1351 static ssize_t pwm_auto_temp_show(struct device *dev,
1352 struct device_attribute *devattr, char *buf)
1354 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1355 struct adt7462_data *data = adt7462_update_device(dev);
1356 int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1359 case 0: /* temp[1234] only */
1363 return sprintf(buf, "%d\n", (1 << channel));
1364 case 5: /* temp1 & temp4 */
1365 return sprintf(buf, "9\n");
1367 return sprintf(buf, "15\n");
1369 return sprintf(buf, "0\n");
1373 static int cvt_auto_temp(int input)
1379 if (input < 1 || !is_power_of_2(input))
1381 return ilog2(input);
1384 static ssize_t pwm_auto_temp_store(struct device *dev,
1385 struct device_attribute *devattr,
1386 const char *buf, size_t count)
1388 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1389 struct adt7462_data *data = dev_get_drvdata(dev);
1390 struct i2c_client *client = data->client;
1393 if (kstrtol(buf, 10, &temp))
1396 temp = cvt_auto_temp(temp);
1400 set_pwm_channel(client, data, attr->index, temp);
1405 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
1406 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
1407 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
1408 static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
1410 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
1411 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
1412 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
1413 static SENSOR_DEVICE_ATTR_RW(temp4_min, temp_min, 3);
1415 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
1416 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
1417 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
1418 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
1420 static SENSOR_DEVICE_ATTR_RO(temp1_label, temp_label, 0);
1421 static SENSOR_DEVICE_ATTR_RO(temp2_label, temp_label, 1);
1422 static SENSOR_DEVICE_ATTR_RO(temp3_label, temp_label, 2);
1423 static SENSOR_DEVICE_ATTR_RO(temp4_label, temp_label, 3);
1425 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm,
1426 ADT7462_ALARM1 | ADT7462_LT_ALARM);
1427 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm,
1428 ADT7462_ALARM1 | ADT7462_R1T_ALARM);
1429 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm,
1430 ADT7462_ALARM1 | ADT7462_R2T_ALARM);
1431 static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm,
1432 ADT7462_ALARM1 | ADT7462_R3T_ALARM);
1434 static SENSOR_DEVICE_ATTR_RW(in1_max, volt_max, 0);
1435 static SENSOR_DEVICE_ATTR_RW(in2_max, volt_max, 1);
1436 static SENSOR_DEVICE_ATTR_RW(in3_max, volt_max, 2);
1437 static SENSOR_DEVICE_ATTR_RW(in4_max, volt_max, 3);
1438 static SENSOR_DEVICE_ATTR_RW(in5_max, volt_max, 4);
1439 static SENSOR_DEVICE_ATTR_RW(in6_max, volt_max, 5);
1440 static SENSOR_DEVICE_ATTR_RW(in7_max, volt_max, 6);
1441 static SENSOR_DEVICE_ATTR_RW(in8_max, volt_max, 7);
1442 static SENSOR_DEVICE_ATTR_RW(in9_max, volt_max, 8);
1443 static SENSOR_DEVICE_ATTR_RW(in10_max, volt_max, 9);
1444 static SENSOR_DEVICE_ATTR_RW(in11_max, volt_max, 10);
1445 static SENSOR_DEVICE_ATTR_RW(in12_max, volt_max, 11);
1446 static SENSOR_DEVICE_ATTR_RW(in13_max, volt_max, 12);
1448 static SENSOR_DEVICE_ATTR_RW(in1_min, volt_min, 0);
1449 static SENSOR_DEVICE_ATTR_RW(in2_min, volt_min, 1);
1450 static SENSOR_DEVICE_ATTR_RW(in3_min, volt_min, 2);
1451 static SENSOR_DEVICE_ATTR_RW(in4_min, volt_min, 3);
1452 static SENSOR_DEVICE_ATTR_RW(in5_min, volt_min, 4);
1453 static SENSOR_DEVICE_ATTR_RW(in6_min, volt_min, 5);
1454 static SENSOR_DEVICE_ATTR_RW(in7_min, volt_min, 6);
1455 static SENSOR_DEVICE_ATTR_RW(in8_min, volt_min, 7);
1456 static SENSOR_DEVICE_ATTR_RW(in9_min, volt_min, 8);
1457 static SENSOR_DEVICE_ATTR_RW(in10_min, volt_min, 9);
1458 static SENSOR_DEVICE_ATTR_RW(in11_min, volt_min, 10);
1459 static SENSOR_DEVICE_ATTR_RW(in12_min, volt_min, 11);
1460 static SENSOR_DEVICE_ATTR_RW(in13_min, volt_min, 12);
1462 static SENSOR_DEVICE_ATTR_RO(in1_input, voltage, 0);
1463 static SENSOR_DEVICE_ATTR_RO(in2_input, voltage, 1);
1464 static SENSOR_DEVICE_ATTR_RO(in3_input, voltage, 2);
1465 static SENSOR_DEVICE_ATTR_RO(in4_input, voltage, 3);
1466 static SENSOR_DEVICE_ATTR_RO(in5_input, voltage, 4);
1467 static SENSOR_DEVICE_ATTR_RO(in6_input, voltage, 5);
1468 static SENSOR_DEVICE_ATTR_RO(in7_input, voltage, 6);
1469 static SENSOR_DEVICE_ATTR_RO(in8_input, voltage, 7);
1470 static SENSOR_DEVICE_ATTR_RO(in9_input, voltage, 8);
1471 static SENSOR_DEVICE_ATTR_RO(in10_input, voltage, 9);
1472 static SENSOR_DEVICE_ATTR_RO(in11_input, voltage, 10);
1473 static SENSOR_DEVICE_ATTR_RO(in12_input, voltage, 11);
1474 static SENSOR_DEVICE_ATTR_RO(in13_input, voltage, 12);
1476 static SENSOR_DEVICE_ATTR_RO(in1_label, voltage_label, 0);
1477 static SENSOR_DEVICE_ATTR_RO(in2_label, voltage_label, 1);
1478 static SENSOR_DEVICE_ATTR_RO(in3_label, voltage_label, 2);
1479 static SENSOR_DEVICE_ATTR_RO(in4_label, voltage_label, 3);
1480 static SENSOR_DEVICE_ATTR_RO(in5_label, voltage_label, 4);
1481 static SENSOR_DEVICE_ATTR_RO(in6_label, voltage_label, 5);
1482 static SENSOR_DEVICE_ATTR_RO(in7_label, voltage_label, 6);
1483 static SENSOR_DEVICE_ATTR_RO(in8_label, voltage_label, 7);
1484 static SENSOR_DEVICE_ATTR_RO(in9_label, voltage_label, 8);
1485 static SENSOR_DEVICE_ATTR_RO(in10_label, voltage_label, 9);
1486 static SENSOR_DEVICE_ATTR_RO(in11_label, voltage_label, 10);
1487 static SENSOR_DEVICE_ATTR_RO(in12_label, voltage_label, 11);
1488 static SENSOR_DEVICE_ATTR_RO(in13_label, voltage_label, 12);
1490 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm,
1491 ADT7462_ALARM2 | ADT7462_V0_ALARM);
1492 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm,
1493 ADT7462_ALARM2 | ADT7462_V7_ALARM);
1494 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm,
1495 ADT7462_ALARM2 | ADT7462_V2_ALARM);
1496 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm,
1497 ADT7462_ALARM2 | ADT7462_V6_ALARM);
1498 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm,
1499 ADT7462_ALARM2 | ADT7462_V5_ALARM);
1500 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm,
1501 ADT7462_ALARM2 | ADT7462_V4_ALARM);
1502 static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm,
1503 ADT7462_ALARM2 | ADT7462_V3_ALARM);
1504 static SENSOR_DEVICE_ATTR_RO(in8_alarm, alarm,
1505 ADT7462_ALARM2 | ADT7462_V1_ALARM);
1506 static SENSOR_DEVICE_ATTR_RO(in9_alarm, alarm,
1507 ADT7462_ALARM3 | ADT7462_V10_ALARM);
1508 static SENSOR_DEVICE_ATTR_RO(in10_alarm, alarm,
1509 ADT7462_ALARM3 | ADT7462_V9_ALARM);
1510 static SENSOR_DEVICE_ATTR_RO(in11_alarm, alarm,
1511 ADT7462_ALARM3 | ADT7462_V8_ALARM);
1512 static SENSOR_DEVICE_ATTR_RO(in12_alarm, alarm,
1513 ADT7462_ALARM3 | ADT7462_V11_ALARM);
1514 static SENSOR_DEVICE_ATTR_RO(in13_alarm, alarm,
1515 ADT7462_ALARM3 | ADT7462_V12_ALARM);
1517 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
1518 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
1519 static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
1520 static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
1521 static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4);
1522 static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5);
1523 static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6);
1524 static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7);
1526 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
1527 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
1528 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
1529 static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
1530 static SENSOR_DEVICE_ATTR_RO(fan5_input, fan, 4);
1531 static SENSOR_DEVICE_ATTR_RO(fan6_input, fan, 5);
1532 static SENSOR_DEVICE_ATTR_RO(fan7_input, fan, 6);
1533 static SENSOR_DEVICE_ATTR_RO(fan8_input, fan, 7);
1535 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm,
1536 ADT7462_ALARM4 | ADT7462_F0_ALARM);
1537 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm,
1538 ADT7462_ALARM4 | ADT7462_F1_ALARM);
1539 static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm,
1540 ADT7462_ALARM4 | ADT7462_F2_ALARM);
1541 static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm,
1542 ADT7462_ALARM4 | ADT7462_F3_ALARM);
1543 static SENSOR_DEVICE_ATTR_RO(fan5_alarm, alarm,
1544 ADT7462_ALARM4 | ADT7462_F4_ALARM);
1545 static SENSOR_DEVICE_ATTR_RO(fan6_alarm, alarm,
1546 ADT7462_ALARM4 | ADT7462_F5_ALARM);
1547 static SENSOR_DEVICE_ATTR_RO(fan7_alarm, alarm,
1548 ADT7462_ALARM4 | ADT7462_F6_ALARM);
1549 static SENSOR_DEVICE_ATTR_RO(fan8_alarm, alarm,
1550 ADT7462_ALARM4 | ADT7462_F7_ALARM);
1552 static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0);
1554 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
1555 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
1556 static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);
1557 static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);
1559 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0);
1560 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1);
1561 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2);
1562 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3);
1564 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0);
1565 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1);
1566 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2);
1567 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3);
1569 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_hyst, pwm_hyst, 0);
1570 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_hyst, pwm_hyst, 1);
1571 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_hyst, pwm_hyst, 2);
1572 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_hyst, pwm_hyst, 3);
1574 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_hyst, pwm_hyst, 0);
1575 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_hyst, pwm_hyst, 1);
1576 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_hyst, pwm_hyst, 2);
1577 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_hyst, pwm_hyst, 3);
1579 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_temp, pwm_tmin, 0);
1580 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_temp, pwm_tmin, 1);
1581 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_temp, pwm_tmin, 2);
1582 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_temp, pwm_tmin, 3);
1584 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_temp, pwm_tmax, 0);
1585 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_temp, pwm_tmax, 1);
1586 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_temp, pwm_tmax, 2);
1587 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_temp, pwm_tmax, 3);
1589 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_auto, 0);
1590 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_auto, 1);
1591 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_auto, 2);
1592 static SENSOR_DEVICE_ATTR_RW(pwm4_enable, pwm_auto, 3);
1594 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0);
1595 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1);
1596 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2);
1597 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3);
1599 static struct attribute *adt7462_attrs[] = {
1600 &sensor_dev_attr_temp1_max.dev_attr.attr,
1601 &sensor_dev_attr_temp2_max.dev_attr.attr,
1602 &sensor_dev_attr_temp3_max.dev_attr.attr,
1603 &sensor_dev_attr_temp4_max.dev_attr.attr,
1605 &sensor_dev_attr_temp1_min.dev_attr.attr,
1606 &sensor_dev_attr_temp2_min.dev_attr.attr,
1607 &sensor_dev_attr_temp3_min.dev_attr.attr,
1608 &sensor_dev_attr_temp4_min.dev_attr.attr,
1610 &sensor_dev_attr_temp1_input.dev_attr.attr,
1611 &sensor_dev_attr_temp2_input.dev_attr.attr,
1612 &sensor_dev_attr_temp3_input.dev_attr.attr,
1613 &sensor_dev_attr_temp4_input.dev_attr.attr,
1615 &sensor_dev_attr_temp1_label.dev_attr.attr,
1616 &sensor_dev_attr_temp2_label.dev_attr.attr,
1617 &sensor_dev_attr_temp3_label.dev_attr.attr,
1618 &sensor_dev_attr_temp4_label.dev_attr.attr,
1620 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1621 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1622 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1623 &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1625 &sensor_dev_attr_in1_max.dev_attr.attr,
1626 &sensor_dev_attr_in2_max.dev_attr.attr,
1627 &sensor_dev_attr_in3_max.dev_attr.attr,
1628 &sensor_dev_attr_in4_max.dev_attr.attr,
1629 &sensor_dev_attr_in5_max.dev_attr.attr,
1630 &sensor_dev_attr_in6_max.dev_attr.attr,
1631 &sensor_dev_attr_in7_max.dev_attr.attr,
1632 &sensor_dev_attr_in8_max.dev_attr.attr,
1633 &sensor_dev_attr_in9_max.dev_attr.attr,
1634 &sensor_dev_attr_in10_max.dev_attr.attr,
1635 &sensor_dev_attr_in11_max.dev_attr.attr,
1636 &sensor_dev_attr_in12_max.dev_attr.attr,
1637 &sensor_dev_attr_in13_max.dev_attr.attr,
1639 &sensor_dev_attr_in1_min.dev_attr.attr,
1640 &sensor_dev_attr_in2_min.dev_attr.attr,
1641 &sensor_dev_attr_in3_min.dev_attr.attr,
1642 &sensor_dev_attr_in4_min.dev_attr.attr,
1643 &sensor_dev_attr_in5_min.dev_attr.attr,
1644 &sensor_dev_attr_in6_min.dev_attr.attr,
1645 &sensor_dev_attr_in7_min.dev_attr.attr,
1646 &sensor_dev_attr_in8_min.dev_attr.attr,
1647 &sensor_dev_attr_in9_min.dev_attr.attr,
1648 &sensor_dev_attr_in10_min.dev_attr.attr,
1649 &sensor_dev_attr_in11_min.dev_attr.attr,
1650 &sensor_dev_attr_in12_min.dev_attr.attr,
1651 &sensor_dev_attr_in13_min.dev_attr.attr,
1653 &sensor_dev_attr_in1_input.dev_attr.attr,
1654 &sensor_dev_attr_in2_input.dev_attr.attr,
1655 &sensor_dev_attr_in3_input.dev_attr.attr,
1656 &sensor_dev_attr_in4_input.dev_attr.attr,
1657 &sensor_dev_attr_in5_input.dev_attr.attr,
1658 &sensor_dev_attr_in6_input.dev_attr.attr,
1659 &sensor_dev_attr_in7_input.dev_attr.attr,
1660 &sensor_dev_attr_in8_input.dev_attr.attr,
1661 &sensor_dev_attr_in9_input.dev_attr.attr,
1662 &sensor_dev_attr_in10_input.dev_attr.attr,
1663 &sensor_dev_attr_in11_input.dev_attr.attr,
1664 &sensor_dev_attr_in12_input.dev_attr.attr,
1665 &sensor_dev_attr_in13_input.dev_attr.attr,
1667 &sensor_dev_attr_in1_label.dev_attr.attr,
1668 &sensor_dev_attr_in2_label.dev_attr.attr,
1669 &sensor_dev_attr_in3_label.dev_attr.attr,
1670 &sensor_dev_attr_in4_label.dev_attr.attr,
1671 &sensor_dev_attr_in5_label.dev_attr.attr,
1672 &sensor_dev_attr_in6_label.dev_attr.attr,
1673 &sensor_dev_attr_in7_label.dev_attr.attr,
1674 &sensor_dev_attr_in8_label.dev_attr.attr,
1675 &sensor_dev_attr_in9_label.dev_attr.attr,
1676 &sensor_dev_attr_in10_label.dev_attr.attr,
1677 &sensor_dev_attr_in11_label.dev_attr.attr,
1678 &sensor_dev_attr_in12_label.dev_attr.attr,
1679 &sensor_dev_attr_in13_label.dev_attr.attr,
1681 &sensor_dev_attr_in1_alarm.dev_attr.attr,
1682 &sensor_dev_attr_in2_alarm.dev_attr.attr,
1683 &sensor_dev_attr_in3_alarm.dev_attr.attr,
1684 &sensor_dev_attr_in4_alarm.dev_attr.attr,
1685 &sensor_dev_attr_in5_alarm.dev_attr.attr,
1686 &sensor_dev_attr_in6_alarm.dev_attr.attr,
1687 &sensor_dev_attr_in7_alarm.dev_attr.attr,
1688 &sensor_dev_attr_in8_alarm.dev_attr.attr,
1689 &sensor_dev_attr_in9_alarm.dev_attr.attr,
1690 &sensor_dev_attr_in10_alarm.dev_attr.attr,
1691 &sensor_dev_attr_in11_alarm.dev_attr.attr,
1692 &sensor_dev_attr_in12_alarm.dev_attr.attr,
1693 &sensor_dev_attr_in13_alarm.dev_attr.attr,
1695 &sensor_dev_attr_fan1_min.dev_attr.attr,
1696 &sensor_dev_attr_fan2_min.dev_attr.attr,
1697 &sensor_dev_attr_fan3_min.dev_attr.attr,
1698 &sensor_dev_attr_fan4_min.dev_attr.attr,
1699 &sensor_dev_attr_fan5_min.dev_attr.attr,
1700 &sensor_dev_attr_fan6_min.dev_attr.attr,
1701 &sensor_dev_attr_fan7_min.dev_attr.attr,
1702 &sensor_dev_attr_fan8_min.dev_attr.attr,
1704 &sensor_dev_attr_fan1_input.dev_attr.attr,
1705 &sensor_dev_attr_fan2_input.dev_attr.attr,
1706 &sensor_dev_attr_fan3_input.dev_attr.attr,
1707 &sensor_dev_attr_fan4_input.dev_attr.attr,
1708 &sensor_dev_attr_fan5_input.dev_attr.attr,
1709 &sensor_dev_attr_fan6_input.dev_attr.attr,
1710 &sensor_dev_attr_fan7_input.dev_attr.attr,
1711 &sensor_dev_attr_fan8_input.dev_attr.attr,
1713 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1714 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1715 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1716 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1717 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1718 &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1719 &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1720 &sensor_dev_attr_fan8_alarm.dev_attr.attr,
1722 &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1723 &sensor_dev_attr_pwm1.dev_attr.attr,
1724 &sensor_dev_attr_pwm2.dev_attr.attr,
1725 &sensor_dev_attr_pwm3.dev_attr.attr,
1726 &sensor_dev_attr_pwm4.dev_attr.attr,
1728 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1729 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1730 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1731 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1733 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1734 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1735 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1736 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1738 &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
1739 &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
1740 &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
1741 &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
1743 &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
1744 &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
1745 &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
1746 &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
1748 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1749 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1750 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1751 &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
1753 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1754 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1755 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1756 &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
1758 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1759 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1760 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1761 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1763 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1764 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1765 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1766 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1770 ATTRIBUTE_GROUPS(adt7462);
1772 /* Return 0 if detection is successful, -ENODEV otherwise */
1773 static int adt7462_detect(struct i2c_client *client,
1774 struct i2c_board_info *info)
1776 struct i2c_adapter *adapter = client->adapter;
1777 int vendor, device, revision;
1779 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1782 vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
1783 if (vendor != ADT7462_VENDOR)
1786 device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
1787 if (device != ADT7462_DEVICE)
1790 revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION);
1791 if (revision != ADT7462_REVISION)
1794 strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
1799 static int adt7462_probe(struct i2c_client *client,
1800 const struct i2c_device_id *id)
1802 struct device *dev = &client->dev;
1803 struct adt7462_data *data;
1804 struct device *hwmon_dev;
1806 data = devm_kzalloc(dev, sizeof(struct adt7462_data), GFP_KERNEL);
1810 data->client = client;
1811 mutex_init(&data->lock);
1813 dev_info(&client->dev, "%s chip found\n", client->name);
1815 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1818 return PTR_ERR_OR_ZERO(hwmon_dev);
1821 static const struct i2c_device_id adt7462_id[] = {
1825 MODULE_DEVICE_TABLE(i2c, adt7462_id);
1827 static struct i2c_driver adt7462_driver = {
1828 .class = I2C_CLASS_HWMON,
1832 .probe = adt7462_probe,
1833 .id_table = adt7462_id,
1834 .detect = adt7462_detect,
1835 .address_list = normal_i2c,
1838 module_i2c_driver(adt7462_driver);
1840 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1841 MODULE_DESCRIPTION("ADT7462 driver");
1842 MODULE_LICENSE("GPL");