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)) {
453 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
457 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
461 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
462 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
468 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
469 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
475 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
479 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
483 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
491 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
499 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
511 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
512 ADT7462_PIN28_VOLT &&
513 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
517 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
518 ADT7462_PIN28_VOLT &&
519 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
520 return "+1.5V 3GPIO";
526 /* Multipliers are actually in uV, not mV. */
527 static int voltage_multiplier(struct adt7462_data *data, int which)
531 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
535 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
537 if (data->pin_cfg[0] & ADT7462_VID_INPUT)
549 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
553 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
557 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
558 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
564 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
565 if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
571 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
575 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
579 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
587 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
595 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
608 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
609 ADT7462_PIN28_VOLT &&
610 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
616 static int temp_enabled(struct adt7462_data *data, int which)
623 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
627 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
634 static const char *temp_label(struct adt7462_data *data, int which)
640 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
646 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
653 /* Map Trange register values to mC */
654 #define NUM_TRANGE_VALUES 16
655 static const int trange_values[NUM_TRANGE_VALUES] = {
674 static int find_trange_value(int trange)
678 for (i = 0; i < NUM_TRANGE_VALUES; i++)
679 if (trange_values[i] == trange)
685 static struct adt7462_data *adt7462_update_device(struct device *dev)
687 struct adt7462_data *data = dev_get_drvdata(dev);
688 struct i2c_client *client = data->client;
689 unsigned long local_jiffies = jiffies;
692 mutex_lock(&data->lock);
693 if (time_before(local_jiffies, data->sensors_last_updated +
694 SENSOR_REFRESH_INTERVAL)
695 && data->sensors_valid)
696 goto no_sensor_update;
698 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
700 * Reading the fractional register locks the integral
701 * register until both have been read.
703 data->temp_frac[i] = i2c_smbus_read_byte_data(client,
704 ADT7462_TEMP_REG(i));
705 data->temp[i] = i2c_smbus_read_byte_data(client,
706 ADT7462_TEMP_REG(i) + 1);
709 for (i = 0; i < ADT7462_FAN_COUNT; i++)
710 data->fan[i] = adt7462_read_word_data(client,
713 data->fan_enabled = i2c_smbus_read_byte_data(client,
714 ADT7462_REG_FAN_ENABLE);
716 for (i = 0; i < ADT7462_PWM_COUNT; i++)
717 data->pwm[i] = i2c_smbus_read_byte_data(client,
720 for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
721 data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
722 ADT7462_REG_PIN_CFG(i));
724 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
725 int reg = ADT7462_REG_VOLT(data, i);
727 data->voltages[i] = 0;
729 data->voltages[i] = i2c_smbus_read_byte_data(client,
733 data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
734 data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
735 data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
736 data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
738 data->sensors_last_updated = local_jiffies;
739 data->sensors_valid = 1;
742 if (time_before(local_jiffies, data->limits_last_updated +
743 LIMIT_REFRESH_INTERVAL)
744 && data->limits_valid)
747 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
748 data->temp_min[i] = i2c_smbus_read_byte_data(client,
749 ADT7462_TEMP_MIN_REG(i));
750 data->temp_max[i] = i2c_smbus_read_byte_data(client,
751 ADT7462_TEMP_MAX_REG(i));
754 for (i = 0; i < ADT7462_FAN_COUNT; i++)
755 data->fan_min[i] = i2c_smbus_read_byte_data(client,
756 ADT7462_REG_FAN_MIN(i));
758 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
759 int reg = ADT7462_REG_VOLT_MAX(data, i);
761 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
763 reg = ADT7462_REG_VOLT_MIN(data, i);
765 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
768 for (i = 0; i < ADT7462_PWM_COUNT; i++) {
769 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
770 ADT7462_REG_PWM_MIN(i));
771 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
772 ADT7462_REG_PWM_TMIN(i));
773 data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
774 ADT7462_REG_PWM_TRANGE(i));
775 data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
776 ADT7462_REG_PWM_CFG(i));
779 data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
781 data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
783 data->limits_last_updated = local_jiffies;
784 data->limits_valid = 1;
787 mutex_unlock(&data->lock);
791 static ssize_t temp_min_show(struct device *dev,
792 struct device_attribute *devattr, char *buf)
794 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
795 struct adt7462_data *data = adt7462_update_device(dev);
797 if (!temp_enabled(data, attr->index))
798 return sprintf(buf, "0\n");
800 return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
803 static ssize_t temp_min_store(struct device *dev,
804 struct device_attribute *devattr,
805 const char *buf, size_t count)
807 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
808 struct adt7462_data *data = dev_get_drvdata(dev);
809 struct i2c_client *client = data->client;
812 if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
815 temp = clamp_val(temp, -64000, 191000);
816 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
818 mutex_lock(&data->lock);
819 data->temp_min[attr->index] = temp;
820 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
822 mutex_unlock(&data->lock);
827 static ssize_t temp_max_show(struct device *dev,
828 struct device_attribute *devattr, char *buf)
830 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
831 struct adt7462_data *data = adt7462_update_device(dev);
833 if (!temp_enabled(data, attr->index))
834 return sprintf(buf, "0\n");
836 return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
839 static ssize_t temp_max_store(struct device *dev,
840 struct device_attribute *devattr,
841 const char *buf, size_t count)
843 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
844 struct adt7462_data *data = dev_get_drvdata(dev);
845 struct i2c_client *client = data->client;
848 if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
851 temp = clamp_val(temp, -64000, 191000);
852 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
854 mutex_lock(&data->lock);
855 data->temp_max[attr->index] = temp;
856 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
858 mutex_unlock(&data->lock);
863 static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
866 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
867 struct adt7462_data *data = adt7462_update_device(dev);
868 u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
870 if (!temp_enabled(data, attr->index))
871 return sprintf(buf, "0\n");
873 return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
877 static ssize_t temp_label_show(struct device *dev,
878 struct device_attribute *devattr, char *buf)
880 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
881 struct adt7462_data *data = adt7462_update_device(dev);
883 return sprintf(buf, "%s\n", temp_label(data, attr->index));
886 static ssize_t volt_max_show(struct device *dev,
887 struct device_attribute *devattr, char *buf)
889 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
890 struct adt7462_data *data = adt7462_update_device(dev);
891 int x = voltage_multiplier(data, attr->index);
893 x *= data->volt_max[attr->index];
894 x /= 1000; /* convert from uV to mV */
896 return sprintf(buf, "%d\n", x);
899 static ssize_t volt_max_store(struct device *dev,
900 struct device_attribute *devattr,
901 const char *buf, size_t count)
903 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
904 struct adt7462_data *data = dev_get_drvdata(dev);
905 struct i2c_client *client = data->client;
906 int x = voltage_multiplier(data, attr->index);
909 if (kstrtol(buf, 10, &temp) || !x)
912 temp = clamp_val(temp, 0, 255 * x / 1000);
913 temp *= 1000; /* convert mV to uV */
914 temp = DIV_ROUND_CLOSEST(temp, x);
916 mutex_lock(&data->lock);
917 data->volt_max[attr->index] = temp;
918 i2c_smbus_write_byte_data(client,
919 ADT7462_REG_VOLT_MAX(data, attr->index),
921 mutex_unlock(&data->lock);
926 static ssize_t volt_min_show(struct device *dev,
927 struct device_attribute *devattr, char *buf)
929 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
930 struct adt7462_data *data = adt7462_update_device(dev);
931 int x = voltage_multiplier(data, attr->index);
933 x *= data->volt_min[attr->index];
934 x /= 1000; /* convert from uV to mV */
936 return sprintf(buf, "%d\n", x);
939 static ssize_t volt_min_store(struct device *dev,
940 struct device_attribute *devattr,
941 const char *buf, size_t count)
943 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
944 struct adt7462_data *data = dev_get_drvdata(dev);
945 struct i2c_client *client = data->client;
946 int x = voltage_multiplier(data, attr->index);
949 if (kstrtol(buf, 10, &temp) || !x)
952 temp = clamp_val(temp, 0, 255 * x / 1000);
953 temp *= 1000; /* convert mV to uV */
954 temp = DIV_ROUND_CLOSEST(temp, x);
956 mutex_lock(&data->lock);
957 data->volt_min[attr->index] = temp;
958 i2c_smbus_write_byte_data(client,
959 ADT7462_REG_VOLT_MIN(data, attr->index),
961 mutex_unlock(&data->lock);
966 static ssize_t voltage_show(struct device *dev,
967 struct device_attribute *devattr, char *buf)
969 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
970 struct adt7462_data *data = adt7462_update_device(dev);
971 int x = voltage_multiplier(data, attr->index);
973 x *= data->voltages[attr->index];
974 x /= 1000; /* convert from uV to mV */
976 return sprintf(buf, "%d\n", x);
979 static ssize_t voltage_label_show(struct device *dev,
980 struct device_attribute *devattr, char *buf)
982 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
983 struct adt7462_data *data = adt7462_update_device(dev);
985 return sprintf(buf, "%s\n", voltage_label(data, attr->index));
988 static ssize_t alarm_show(struct device *dev,
989 struct device_attribute *devattr, char *buf)
991 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
992 struct adt7462_data *data = adt7462_update_device(dev);
993 int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
994 int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
996 if (data->alarms[reg] & mask)
997 return sprintf(buf, "1\n");
999 return sprintf(buf, "0\n");
1002 static int fan_enabled(struct adt7462_data *data, int fan)
1004 return data->fan_enabled & (1 << fan);
1007 static ssize_t fan_min_show(struct device *dev,
1008 struct device_attribute *devattr, char *buf)
1010 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1011 struct adt7462_data *data = adt7462_update_device(dev);
1014 /* Only the MSB of the min fan period is stored... */
1015 temp = data->fan_min[attr->index];
1018 if (!fan_enabled(data, attr->index) ||
1019 !FAN_DATA_VALID(temp))
1020 return sprintf(buf, "0\n");
1022 return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
1025 static ssize_t fan_min_store(struct device *dev,
1026 struct device_attribute *devattr,
1027 const char *buf, size_t count)
1029 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1030 struct adt7462_data *data = dev_get_drvdata(dev);
1031 struct i2c_client *client = data->client;
1034 if (kstrtol(buf, 10, &temp) || !temp ||
1035 !fan_enabled(data, attr->index))
1038 temp = FAN_RPM_TO_PERIOD(temp);
1040 temp = clamp_val(temp, 1, 255);
1042 mutex_lock(&data->lock);
1043 data->fan_min[attr->index] = temp;
1044 i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
1046 mutex_unlock(&data->lock);
1051 static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
1054 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1055 struct adt7462_data *data = adt7462_update_device(dev);
1057 if (!fan_enabled(data, attr->index) ||
1058 !FAN_DATA_VALID(data->fan[attr->index]))
1059 return sprintf(buf, "0\n");
1061 return sprintf(buf, "%d\n",
1062 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
1065 static ssize_t force_pwm_max_show(struct device *dev,
1066 struct device_attribute *devattr, char *buf)
1068 struct adt7462_data *data = adt7462_update_device(dev);
1069 return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
1072 static ssize_t force_pwm_max_store(struct device *dev,
1073 struct device_attribute *devattr,
1074 const char *buf, size_t count)
1076 struct adt7462_data *data = dev_get_drvdata(dev);
1077 struct i2c_client *client = data->client;
1081 if (kstrtol(buf, 10, &temp))
1084 mutex_lock(&data->lock);
1085 reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
1087 reg |= ADT7462_FSPD_MASK;
1089 reg &= ~ADT7462_FSPD_MASK;
1091 i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
1092 mutex_unlock(&data->lock);
1097 static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
1100 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1101 struct adt7462_data *data = adt7462_update_device(dev);
1102 return sprintf(buf, "%d\n", data->pwm[attr->index]);
1105 static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
1106 const char *buf, size_t count)
1108 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1109 struct adt7462_data *data = dev_get_drvdata(dev);
1110 struct i2c_client *client = data->client;
1113 if (kstrtol(buf, 10, &temp))
1116 temp = clamp_val(temp, 0, 255);
1118 mutex_lock(&data->lock);
1119 data->pwm[attr->index] = temp;
1120 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
1121 mutex_unlock(&data->lock);
1126 static ssize_t pwm_max_show(struct device *dev,
1127 struct device_attribute *devattr, char *buf)
1129 struct adt7462_data *data = adt7462_update_device(dev);
1130 return sprintf(buf, "%d\n", data->pwm_max);
1133 static ssize_t pwm_max_store(struct device *dev,
1134 struct device_attribute *devattr,
1135 const char *buf, size_t count)
1137 struct adt7462_data *data = dev_get_drvdata(dev);
1138 struct i2c_client *client = data->client;
1141 if (kstrtol(buf, 10, &temp))
1144 temp = clamp_val(temp, 0, 255);
1146 mutex_lock(&data->lock);
1147 data->pwm_max = temp;
1148 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
1149 mutex_unlock(&data->lock);
1154 static ssize_t pwm_min_show(struct device *dev,
1155 struct device_attribute *devattr, char *buf)
1157 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1158 struct adt7462_data *data = adt7462_update_device(dev);
1159 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
1162 static ssize_t pwm_min_store(struct device *dev,
1163 struct device_attribute *devattr,
1164 const char *buf, size_t count)
1166 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1167 struct adt7462_data *data = dev_get_drvdata(dev);
1168 struct i2c_client *client = data->client;
1171 if (kstrtol(buf, 10, &temp))
1174 temp = clamp_val(temp, 0, 255);
1176 mutex_lock(&data->lock);
1177 data->pwm_min[attr->index] = temp;
1178 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
1180 mutex_unlock(&data->lock);
1185 static ssize_t pwm_hyst_show(struct device *dev,
1186 struct device_attribute *devattr, char *buf)
1188 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1189 struct adt7462_data *data = adt7462_update_device(dev);
1190 return sprintf(buf, "%d\n", 1000 *
1191 (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
1194 static ssize_t pwm_hyst_store(struct device *dev,
1195 struct device_attribute *devattr,
1196 const char *buf, size_t count)
1198 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1199 struct adt7462_data *data = dev_get_drvdata(dev);
1200 struct i2c_client *client = data->client;
1203 if (kstrtol(buf, 10, &temp))
1206 temp = clamp_val(temp, 0, 15000);
1207 temp = DIV_ROUND_CLOSEST(temp, 1000);
1209 /* package things up */
1210 temp &= ADT7462_PWM_HYST_MASK;
1211 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
1213 mutex_lock(&data->lock);
1214 data->pwm_trange[attr->index] = temp;
1215 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1217 mutex_unlock(&data->lock);
1222 static ssize_t pwm_tmax_show(struct device *dev,
1223 struct device_attribute *devattr, char *buf)
1225 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1226 struct adt7462_data *data = adt7462_update_device(dev);
1228 /* tmax = tmin + trange */
1229 int trange = trange_values[data->pwm_trange[attr->index] >>
1230 ADT7462_PWM_RANGE_SHIFT];
1231 int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1233 return sprintf(buf, "%d\n", tmin + trange);
1236 static ssize_t pwm_tmax_store(struct device *dev,
1237 struct device_attribute *devattr,
1238 const char *buf, size_t count)
1241 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1242 struct adt7462_data *data = dev_get_drvdata(dev);
1243 struct i2c_client *client = data->client;
1244 int tmin, trange_value;
1247 if (kstrtol(buf, 10, &trange))
1250 /* trange = tmax - tmin */
1251 tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1252 trange_value = find_trange_value(trange - tmin);
1253 if (trange_value < 0)
1254 return trange_value;
1256 temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
1257 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
1259 mutex_lock(&data->lock);
1260 data->pwm_trange[attr->index] = temp;
1261 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1263 mutex_unlock(&data->lock);
1268 static ssize_t pwm_tmin_show(struct device *dev,
1269 struct device_attribute *devattr, char *buf)
1271 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1272 struct adt7462_data *data = adt7462_update_device(dev);
1273 return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
1276 static ssize_t pwm_tmin_store(struct device *dev,
1277 struct device_attribute *devattr,
1278 const char *buf, size_t count)
1280 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1281 struct adt7462_data *data = dev_get_drvdata(dev);
1282 struct i2c_client *client = data->client;
1285 if (kstrtol(buf, 10, &temp))
1288 temp = clamp_val(temp, -64000, 191000);
1289 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
1291 mutex_lock(&data->lock);
1292 data->pwm_tmin[attr->index] = temp;
1293 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
1295 mutex_unlock(&data->lock);
1300 static ssize_t pwm_auto_show(struct device *dev,
1301 struct device_attribute *devattr, char *buf)
1303 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1304 struct adt7462_data *data = adt7462_update_device(dev);
1305 int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1309 return sprintf(buf, "0\n");
1310 case 7: /* manual */
1311 return sprintf(buf, "1\n");
1312 default: /* automatic */
1313 return sprintf(buf, "2\n");
1317 static void set_pwm_channel(struct i2c_client *client,
1318 struct adt7462_data *data,
1322 int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
1323 temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
1325 mutex_lock(&data->lock);
1326 data->pwm_cfg[which] = temp;
1327 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
1328 mutex_unlock(&data->lock);
1331 static ssize_t pwm_auto_store(struct device *dev,
1332 struct device_attribute *devattr,
1333 const char *buf, size_t count)
1335 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1336 struct adt7462_data *data = dev_get_drvdata(dev);
1337 struct i2c_client *client = data->client;
1340 if (kstrtol(buf, 10, &temp))
1345 set_pwm_channel(client, data, attr->index, 4);
1347 case 1: /* manual */
1348 set_pwm_channel(client, data, attr->index, 7);
1355 static ssize_t pwm_auto_temp_show(struct device *dev,
1356 struct device_attribute *devattr, char *buf)
1358 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1359 struct adt7462_data *data = adt7462_update_device(dev);
1360 int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1363 case 0: /* temp[1234] only */
1367 return sprintf(buf, "%d\n", (1 << channel));
1368 case 5: /* temp1 & temp4 */
1369 return sprintf(buf, "9\n");
1371 return sprintf(buf, "15\n");
1373 return sprintf(buf, "0\n");
1377 static int cvt_auto_temp(int input)
1383 if (input < 1 || !is_power_of_2(input))
1385 return ilog2(input);
1388 static ssize_t pwm_auto_temp_store(struct device *dev,
1389 struct device_attribute *devattr,
1390 const char *buf, size_t count)
1392 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1393 struct adt7462_data *data = dev_get_drvdata(dev);
1394 struct i2c_client *client = data->client;
1397 if (kstrtol(buf, 10, &temp))
1400 temp = cvt_auto_temp(temp);
1404 set_pwm_channel(client, data, attr->index, temp);
1409 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
1410 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
1411 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
1412 static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
1414 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
1415 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
1416 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
1417 static SENSOR_DEVICE_ATTR_RW(temp4_min, temp_min, 3);
1419 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
1420 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
1421 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
1422 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
1424 static SENSOR_DEVICE_ATTR_RO(temp1_label, temp_label, 0);
1425 static SENSOR_DEVICE_ATTR_RO(temp2_label, temp_label, 1);
1426 static SENSOR_DEVICE_ATTR_RO(temp3_label, temp_label, 2);
1427 static SENSOR_DEVICE_ATTR_RO(temp4_label, temp_label, 3);
1429 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm,
1430 ADT7462_ALARM1 | ADT7462_LT_ALARM);
1431 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm,
1432 ADT7462_ALARM1 | ADT7462_R1T_ALARM);
1433 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm,
1434 ADT7462_ALARM1 | ADT7462_R2T_ALARM);
1435 static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm,
1436 ADT7462_ALARM1 | ADT7462_R3T_ALARM);
1438 static SENSOR_DEVICE_ATTR_RW(in1_max, volt_max, 0);
1439 static SENSOR_DEVICE_ATTR_RW(in2_max, volt_max, 1);
1440 static SENSOR_DEVICE_ATTR_RW(in3_max, volt_max, 2);
1441 static SENSOR_DEVICE_ATTR_RW(in4_max, volt_max, 3);
1442 static SENSOR_DEVICE_ATTR_RW(in5_max, volt_max, 4);
1443 static SENSOR_DEVICE_ATTR_RW(in6_max, volt_max, 5);
1444 static SENSOR_DEVICE_ATTR_RW(in7_max, volt_max, 6);
1445 static SENSOR_DEVICE_ATTR_RW(in8_max, volt_max, 7);
1446 static SENSOR_DEVICE_ATTR_RW(in9_max, volt_max, 8);
1447 static SENSOR_DEVICE_ATTR_RW(in10_max, volt_max, 9);
1448 static SENSOR_DEVICE_ATTR_RW(in11_max, volt_max, 10);
1449 static SENSOR_DEVICE_ATTR_RW(in12_max, volt_max, 11);
1450 static SENSOR_DEVICE_ATTR_RW(in13_max, volt_max, 12);
1452 static SENSOR_DEVICE_ATTR_RW(in1_min, volt_min, 0);
1453 static SENSOR_DEVICE_ATTR_RW(in2_min, volt_min, 1);
1454 static SENSOR_DEVICE_ATTR_RW(in3_min, volt_min, 2);
1455 static SENSOR_DEVICE_ATTR_RW(in4_min, volt_min, 3);
1456 static SENSOR_DEVICE_ATTR_RW(in5_min, volt_min, 4);
1457 static SENSOR_DEVICE_ATTR_RW(in6_min, volt_min, 5);
1458 static SENSOR_DEVICE_ATTR_RW(in7_min, volt_min, 6);
1459 static SENSOR_DEVICE_ATTR_RW(in8_min, volt_min, 7);
1460 static SENSOR_DEVICE_ATTR_RW(in9_min, volt_min, 8);
1461 static SENSOR_DEVICE_ATTR_RW(in10_min, volt_min, 9);
1462 static SENSOR_DEVICE_ATTR_RW(in11_min, volt_min, 10);
1463 static SENSOR_DEVICE_ATTR_RW(in12_min, volt_min, 11);
1464 static SENSOR_DEVICE_ATTR_RW(in13_min, volt_min, 12);
1466 static SENSOR_DEVICE_ATTR_RO(in1_input, voltage, 0);
1467 static SENSOR_DEVICE_ATTR_RO(in2_input, voltage, 1);
1468 static SENSOR_DEVICE_ATTR_RO(in3_input, voltage, 2);
1469 static SENSOR_DEVICE_ATTR_RO(in4_input, voltage, 3);
1470 static SENSOR_DEVICE_ATTR_RO(in5_input, voltage, 4);
1471 static SENSOR_DEVICE_ATTR_RO(in6_input, voltage, 5);
1472 static SENSOR_DEVICE_ATTR_RO(in7_input, voltage, 6);
1473 static SENSOR_DEVICE_ATTR_RO(in8_input, voltage, 7);
1474 static SENSOR_DEVICE_ATTR_RO(in9_input, voltage, 8);
1475 static SENSOR_DEVICE_ATTR_RO(in10_input, voltage, 9);
1476 static SENSOR_DEVICE_ATTR_RO(in11_input, voltage, 10);
1477 static SENSOR_DEVICE_ATTR_RO(in12_input, voltage, 11);
1478 static SENSOR_DEVICE_ATTR_RO(in13_input, voltage, 12);
1480 static SENSOR_DEVICE_ATTR_RO(in1_label, voltage_label, 0);
1481 static SENSOR_DEVICE_ATTR_RO(in2_label, voltage_label, 1);
1482 static SENSOR_DEVICE_ATTR_RO(in3_label, voltage_label, 2);
1483 static SENSOR_DEVICE_ATTR_RO(in4_label, voltage_label, 3);
1484 static SENSOR_DEVICE_ATTR_RO(in5_label, voltage_label, 4);
1485 static SENSOR_DEVICE_ATTR_RO(in6_label, voltage_label, 5);
1486 static SENSOR_DEVICE_ATTR_RO(in7_label, voltage_label, 6);
1487 static SENSOR_DEVICE_ATTR_RO(in8_label, voltage_label, 7);
1488 static SENSOR_DEVICE_ATTR_RO(in9_label, voltage_label, 8);
1489 static SENSOR_DEVICE_ATTR_RO(in10_label, voltage_label, 9);
1490 static SENSOR_DEVICE_ATTR_RO(in11_label, voltage_label, 10);
1491 static SENSOR_DEVICE_ATTR_RO(in12_label, voltage_label, 11);
1492 static SENSOR_DEVICE_ATTR_RO(in13_label, voltage_label, 12);
1494 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm,
1495 ADT7462_ALARM2 | ADT7462_V0_ALARM);
1496 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm,
1497 ADT7462_ALARM2 | ADT7462_V7_ALARM);
1498 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm,
1499 ADT7462_ALARM2 | ADT7462_V2_ALARM);
1500 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm,
1501 ADT7462_ALARM2 | ADT7462_V6_ALARM);
1502 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm,
1503 ADT7462_ALARM2 | ADT7462_V5_ALARM);
1504 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm,
1505 ADT7462_ALARM2 | ADT7462_V4_ALARM);
1506 static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm,
1507 ADT7462_ALARM2 | ADT7462_V3_ALARM);
1508 static SENSOR_DEVICE_ATTR_RO(in8_alarm, alarm,
1509 ADT7462_ALARM2 | ADT7462_V1_ALARM);
1510 static SENSOR_DEVICE_ATTR_RO(in9_alarm, alarm,
1511 ADT7462_ALARM3 | ADT7462_V10_ALARM);
1512 static SENSOR_DEVICE_ATTR_RO(in10_alarm, alarm,
1513 ADT7462_ALARM3 | ADT7462_V9_ALARM);
1514 static SENSOR_DEVICE_ATTR_RO(in11_alarm, alarm,
1515 ADT7462_ALARM3 | ADT7462_V8_ALARM);
1516 static SENSOR_DEVICE_ATTR_RO(in12_alarm, alarm,
1517 ADT7462_ALARM3 | ADT7462_V11_ALARM);
1518 static SENSOR_DEVICE_ATTR_RO(in13_alarm, alarm,
1519 ADT7462_ALARM3 | ADT7462_V12_ALARM);
1521 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
1522 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
1523 static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
1524 static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
1525 static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4);
1526 static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5);
1527 static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6);
1528 static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7);
1530 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
1531 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
1532 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
1533 static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
1534 static SENSOR_DEVICE_ATTR_RO(fan5_input, fan, 4);
1535 static SENSOR_DEVICE_ATTR_RO(fan6_input, fan, 5);
1536 static SENSOR_DEVICE_ATTR_RO(fan7_input, fan, 6);
1537 static SENSOR_DEVICE_ATTR_RO(fan8_input, fan, 7);
1539 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm,
1540 ADT7462_ALARM4 | ADT7462_F0_ALARM);
1541 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm,
1542 ADT7462_ALARM4 | ADT7462_F1_ALARM);
1543 static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm,
1544 ADT7462_ALARM4 | ADT7462_F2_ALARM);
1545 static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm,
1546 ADT7462_ALARM4 | ADT7462_F3_ALARM);
1547 static SENSOR_DEVICE_ATTR_RO(fan5_alarm, alarm,
1548 ADT7462_ALARM4 | ADT7462_F4_ALARM);
1549 static SENSOR_DEVICE_ATTR_RO(fan6_alarm, alarm,
1550 ADT7462_ALARM4 | ADT7462_F5_ALARM);
1551 static SENSOR_DEVICE_ATTR_RO(fan7_alarm, alarm,
1552 ADT7462_ALARM4 | ADT7462_F6_ALARM);
1553 static SENSOR_DEVICE_ATTR_RO(fan8_alarm, alarm,
1554 ADT7462_ALARM4 | ADT7462_F7_ALARM);
1556 static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0);
1558 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
1559 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
1560 static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);
1561 static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);
1563 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0);
1564 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1);
1565 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2);
1566 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3);
1568 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0);
1569 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1);
1570 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2);
1571 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3);
1573 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_hyst, pwm_hyst, 0);
1574 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_hyst, pwm_hyst, 1);
1575 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_hyst, pwm_hyst, 2);
1576 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_hyst, pwm_hyst, 3);
1578 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_hyst, pwm_hyst, 0);
1579 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_hyst, pwm_hyst, 1);
1580 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_hyst, pwm_hyst, 2);
1581 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_hyst, pwm_hyst, 3);
1583 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_temp, pwm_tmin, 0);
1584 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_temp, pwm_tmin, 1);
1585 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_temp, pwm_tmin, 2);
1586 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_temp, pwm_tmin, 3);
1588 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_temp, pwm_tmax, 0);
1589 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_temp, pwm_tmax, 1);
1590 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_temp, pwm_tmax, 2);
1591 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_temp, pwm_tmax, 3);
1593 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_auto, 0);
1594 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_auto, 1);
1595 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_auto, 2);
1596 static SENSOR_DEVICE_ATTR_RW(pwm4_enable, pwm_auto, 3);
1598 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0);
1599 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1);
1600 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2);
1601 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3);
1603 static struct attribute *adt7462_attrs[] = {
1604 &sensor_dev_attr_temp1_max.dev_attr.attr,
1605 &sensor_dev_attr_temp2_max.dev_attr.attr,
1606 &sensor_dev_attr_temp3_max.dev_attr.attr,
1607 &sensor_dev_attr_temp4_max.dev_attr.attr,
1609 &sensor_dev_attr_temp1_min.dev_attr.attr,
1610 &sensor_dev_attr_temp2_min.dev_attr.attr,
1611 &sensor_dev_attr_temp3_min.dev_attr.attr,
1612 &sensor_dev_attr_temp4_min.dev_attr.attr,
1614 &sensor_dev_attr_temp1_input.dev_attr.attr,
1615 &sensor_dev_attr_temp2_input.dev_attr.attr,
1616 &sensor_dev_attr_temp3_input.dev_attr.attr,
1617 &sensor_dev_attr_temp4_input.dev_attr.attr,
1619 &sensor_dev_attr_temp1_label.dev_attr.attr,
1620 &sensor_dev_attr_temp2_label.dev_attr.attr,
1621 &sensor_dev_attr_temp3_label.dev_attr.attr,
1622 &sensor_dev_attr_temp4_label.dev_attr.attr,
1624 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1625 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1626 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1627 &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1629 &sensor_dev_attr_in1_max.dev_attr.attr,
1630 &sensor_dev_attr_in2_max.dev_attr.attr,
1631 &sensor_dev_attr_in3_max.dev_attr.attr,
1632 &sensor_dev_attr_in4_max.dev_attr.attr,
1633 &sensor_dev_attr_in5_max.dev_attr.attr,
1634 &sensor_dev_attr_in6_max.dev_attr.attr,
1635 &sensor_dev_attr_in7_max.dev_attr.attr,
1636 &sensor_dev_attr_in8_max.dev_attr.attr,
1637 &sensor_dev_attr_in9_max.dev_attr.attr,
1638 &sensor_dev_attr_in10_max.dev_attr.attr,
1639 &sensor_dev_attr_in11_max.dev_attr.attr,
1640 &sensor_dev_attr_in12_max.dev_attr.attr,
1641 &sensor_dev_attr_in13_max.dev_attr.attr,
1643 &sensor_dev_attr_in1_min.dev_attr.attr,
1644 &sensor_dev_attr_in2_min.dev_attr.attr,
1645 &sensor_dev_attr_in3_min.dev_attr.attr,
1646 &sensor_dev_attr_in4_min.dev_attr.attr,
1647 &sensor_dev_attr_in5_min.dev_attr.attr,
1648 &sensor_dev_attr_in6_min.dev_attr.attr,
1649 &sensor_dev_attr_in7_min.dev_attr.attr,
1650 &sensor_dev_attr_in8_min.dev_attr.attr,
1651 &sensor_dev_attr_in9_min.dev_attr.attr,
1652 &sensor_dev_attr_in10_min.dev_attr.attr,
1653 &sensor_dev_attr_in11_min.dev_attr.attr,
1654 &sensor_dev_attr_in12_min.dev_attr.attr,
1655 &sensor_dev_attr_in13_min.dev_attr.attr,
1657 &sensor_dev_attr_in1_input.dev_attr.attr,
1658 &sensor_dev_attr_in2_input.dev_attr.attr,
1659 &sensor_dev_attr_in3_input.dev_attr.attr,
1660 &sensor_dev_attr_in4_input.dev_attr.attr,
1661 &sensor_dev_attr_in5_input.dev_attr.attr,
1662 &sensor_dev_attr_in6_input.dev_attr.attr,
1663 &sensor_dev_attr_in7_input.dev_attr.attr,
1664 &sensor_dev_attr_in8_input.dev_attr.attr,
1665 &sensor_dev_attr_in9_input.dev_attr.attr,
1666 &sensor_dev_attr_in10_input.dev_attr.attr,
1667 &sensor_dev_attr_in11_input.dev_attr.attr,
1668 &sensor_dev_attr_in12_input.dev_attr.attr,
1669 &sensor_dev_attr_in13_input.dev_attr.attr,
1671 &sensor_dev_attr_in1_label.dev_attr.attr,
1672 &sensor_dev_attr_in2_label.dev_attr.attr,
1673 &sensor_dev_attr_in3_label.dev_attr.attr,
1674 &sensor_dev_attr_in4_label.dev_attr.attr,
1675 &sensor_dev_attr_in5_label.dev_attr.attr,
1676 &sensor_dev_attr_in6_label.dev_attr.attr,
1677 &sensor_dev_attr_in7_label.dev_attr.attr,
1678 &sensor_dev_attr_in8_label.dev_attr.attr,
1679 &sensor_dev_attr_in9_label.dev_attr.attr,
1680 &sensor_dev_attr_in10_label.dev_attr.attr,
1681 &sensor_dev_attr_in11_label.dev_attr.attr,
1682 &sensor_dev_attr_in12_label.dev_attr.attr,
1683 &sensor_dev_attr_in13_label.dev_attr.attr,
1685 &sensor_dev_attr_in1_alarm.dev_attr.attr,
1686 &sensor_dev_attr_in2_alarm.dev_attr.attr,
1687 &sensor_dev_attr_in3_alarm.dev_attr.attr,
1688 &sensor_dev_attr_in4_alarm.dev_attr.attr,
1689 &sensor_dev_attr_in5_alarm.dev_attr.attr,
1690 &sensor_dev_attr_in6_alarm.dev_attr.attr,
1691 &sensor_dev_attr_in7_alarm.dev_attr.attr,
1692 &sensor_dev_attr_in8_alarm.dev_attr.attr,
1693 &sensor_dev_attr_in9_alarm.dev_attr.attr,
1694 &sensor_dev_attr_in10_alarm.dev_attr.attr,
1695 &sensor_dev_attr_in11_alarm.dev_attr.attr,
1696 &sensor_dev_attr_in12_alarm.dev_attr.attr,
1697 &sensor_dev_attr_in13_alarm.dev_attr.attr,
1699 &sensor_dev_attr_fan1_min.dev_attr.attr,
1700 &sensor_dev_attr_fan2_min.dev_attr.attr,
1701 &sensor_dev_attr_fan3_min.dev_attr.attr,
1702 &sensor_dev_attr_fan4_min.dev_attr.attr,
1703 &sensor_dev_attr_fan5_min.dev_attr.attr,
1704 &sensor_dev_attr_fan6_min.dev_attr.attr,
1705 &sensor_dev_attr_fan7_min.dev_attr.attr,
1706 &sensor_dev_attr_fan8_min.dev_attr.attr,
1708 &sensor_dev_attr_fan1_input.dev_attr.attr,
1709 &sensor_dev_attr_fan2_input.dev_attr.attr,
1710 &sensor_dev_attr_fan3_input.dev_attr.attr,
1711 &sensor_dev_attr_fan4_input.dev_attr.attr,
1712 &sensor_dev_attr_fan5_input.dev_attr.attr,
1713 &sensor_dev_attr_fan6_input.dev_attr.attr,
1714 &sensor_dev_attr_fan7_input.dev_attr.attr,
1715 &sensor_dev_attr_fan8_input.dev_attr.attr,
1717 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1718 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1719 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1720 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1721 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1722 &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1723 &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1724 &sensor_dev_attr_fan8_alarm.dev_attr.attr,
1726 &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1727 &sensor_dev_attr_pwm1.dev_attr.attr,
1728 &sensor_dev_attr_pwm2.dev_attr.attr,
1729 &sensor_dev_attr_pwm3.dev_attr.attr,
1730 &sensor_dev_attr_pwm4.dev_attr.attr,
1732 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1733 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1734 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1735 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1737 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1738 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1739 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1740 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1742 &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
1743 &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
1744 &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
1745 &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
1747 &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
1748 &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
1749 &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
1750 &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
1752 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1753 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1754 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1755 &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
1757 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1758 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1759 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1760 &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
1762 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1763 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1764 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1765 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1767 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1768 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1769 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1770 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1774 ATTRIBUTE_GROUPS(adt7462);
1776 /* Return 0 if detection is successful, -ENODEV otherwise */
1777 static int adt7462_detect(struct i2c_client *client,
1778 struct i2c_board_info *info)
1780 struct i2c_adapter *adapter = client->adapter;
1781 int vendor, device, revision;
1783 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1786 vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
1787 if (vendor != ADT7462_VENDOR)
1790 device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
1791 if (device != ADT7462_DEVICE)
1794 revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION);
1795 if (revision != ADT7462_REVISION)
1798 strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
1803 static int adt7462_probe(struct i2c_client *client,
1804 const struct i2c_device_id *id)
1806 struct device *dev = &client->dev;
1807 struct adt7462_data *data;
1808 struct device *hwmon_dev;
1810 data = devm_kzalloc(dev, sizeof(struct adt7462_data), GFP_KERNEL);
1814 data->client = client;
1815 mutex_init(&data->lock);
1817 dev_info(&client->dev, "%s chip found\n", client->name);
1819 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1822 return PTR_ERR_OR_ZERO(hwmon_dev);
1825 static const struct i2c_device_id adt7462_id[] = {
1829 MODULE_DEVICE_TABLE(i2c, adt7462_id);
1831 static struct i2c_driver adt7462_driver = {
1832 .class = I2C_CLASS_HWMON,
1836 .probe = adt7462_probe,
1837 .id_table = adt7462_id,
1838 .detect = adt7462_detect,
1839 .address_list = normal_i2c,
1842 module_i2c_driver(adt7462_driver);
1844 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1845 MODULE_DESCRIPTION("ADT7462 driver");
1846 MODULE_LICENSE("GPL");