aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDarrick J. Wong <djwong@us.ibm.com>2008-11-12 16:27:03 -0500
committerLinus Torvalds <torvalds@linux-foundation.org>2008-11-12 20:17:17 -0500
commitc0b4e3ab0c769913438aeb078535ff117eeba5fb (patch)
treeaef089b13f7850971025851dedd958f10bdf928a
parent455fbdd376c3ed3a5be8c039348896fdd87e9930 (diff)
adt7462: new hwmon driver
New driver to play with. As Jean mentioned a couple of years ago, this chip is a beast with odd combinations of 8 fans, 4 temperatures, and 13 voltage sensors. This driver has been tested on an IntelliStation Z30. Signed-off-by: Darrick J. Wong <djwong@us.ibm.com> Cc: Jean Delvare <khali@linux-fr.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Diffstat
-rw-r--r--Documentation/hwmon/adt746267
-rw-r--r--drivers/hwmon/Kconfig10
-rw-r--r--drivers/hwmon/Makefile1
-rw-r--r--drivers/hwmon/adt7462.c2002
4 files changed, 2080 insertions, 0 deletions
diff --git a/Documentation/hwmon/adt7462 b/Documentation/hwmon/adt7462
new file mode 100644
index 000000000000..ec660b328275
--- /dev/null
+++ b/Documentation/hwmon/adt7462
@@ -0,0 +1,67 @@
1Kernel driver adt7462
2======================
3
4Supported chips:
5 * Analog Devices ADT7462
6 Prefix: 'adt7462'
7 Addresses scanned: I2C 0x58, 0x5C
8 Datasheet: Publicly available at the Analog Devices website
9
10Author: Darrick J. Wong
11
12Description
13-----------
14
15This driver implements support for the Analog Devices ADT7462 chip family.
16
17This chip is a bit of a beast. It has 8 counters for measuring fan speed. It
18can also measure 13 voltages or 4 temperatures, or various combinations of the
19two. See the chip documentation for more details about the exact set of
20configurations. This driver does not allow one to configure the chip; that is
21left to the system designer.
22
23A sophisticated control system for the PWM outputs is designed into the ADT7462
24that allows fan speed to be adjusted automatically based on any of the three
25temperature sensors. Each PWM output is individually adjustable and
26programmable. Once configured, the ADT7462 will adjust the PWM outputs in
27response to the measured temperatures without further host intervention. This
28feature can also be disabled for manual control of the PWM's.
29
30Each of the measured inputs (voltage, temperature, fan speed) has
31corresponding high/low limit values. The ADT7462 will signal an ALARM if
32any measured value exceeds either limit.
33
34The ADT7462 samples all inputs continuously. The driver will not read
35the registers more often than once every other second. Further,
36configuration data is only read once per minute.
37
38Special Features
39----------------
40
41The ADT7462 have a 10-bit ADC and can therefore measure temperatures
42with 0.25 degC resolution.
43
44The Analog Devices datasheet is very detailed and describes a procedure for
45determining an optimal configuration for the automatic PWM control.
46
47The driver will report sensor labels when it is able to determine that
48information from the configuration registers.
49
50Configuration Notes
51-------------------
52
53Besides standard interfaces driver adds the following:
54
55* PWM Control
56
57* pwm#_auto_point1_pwm and temp#_auto_point1_temp and
58* pwm#_auto_point2_pwm and temp#_auto_point2_temp -
59
60point1: Set the pwm speed at a lower temperature bound.
61point2: Set the pwm speed at a higher temperature bound.
62
63The ADT7462 will scale the pwm between the lower and higher pwm speed when
64the temperature is between the two temperature boundaries. PWM values range
65from 0 (off) to 255 (full speed). Fan speed will be set to maximum when the
66temperature sensor associated with the PWM control exceeds temp#_max.
67
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 1c44f5c47aab..c709e821f04b 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -159,6 +159,16 @@ config SENSORS_ADM9240
159 This driver can also be built as a module. If so, the module 159 This driver can also be built as a module. If so, the module
160 will be called adm9240. 160 will be called adm9240.
161 161
162config SENSORS_ADT7462
163 tristate "Analog Devices ADT7462"
164 depends on I2C && EXPERIMENTAL
165 help
166 If you say yes here you get support for the Analog Devices
167 ADT7462 temperature monitoring chips.
168
169 This driver can also be built as a module. If so, the module
170 will be called adt7462.
171
162config SENSORS_ADT7470 172config SENSORS_ADT7470
163 tristate "Analog Devices ADT7470" 173 tristate "Analog Devices ADT7470"
164 depends on I2C && EXPERIMENTAL 174 depends on I2C && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index e0d90a68bea0..58fc5be5355d 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -25,6 +25,7 @@ obj-$(CONFIG_SENSORS_ADM1029) += adm1029.o
25obj-$(CONFIG_SENSORS_ADM1031) += adm1031.o 25obj-$(CONFIG_SENSORS_ADM1031) += adm1031.o
26obj-$(CONFIG_SENSORS_ADM9240) += adm9240.o 26obj-$(CONFIG_SENSORS_ADM9240) += adm9240.o
27obj-$(CONFIG_SENSORS_ADS7828) += ads7828.o 27obj-$(CONFIG_SENSORS_ADS7828) += ads7828.o
28obj-$(CONFIG_SENSORS_ADT7462) += adt7462.o
28obj-$(CONFIG_SENSORS_ADT7470) += adt7470.o 29obj-$(CONFIG_SENSORS_ADT7470) += adt7470.o
29obj-$(CONFIG_SENSORS_ADT7473) += adt7473.o 30obj-$(CONFIG_SENSORS_ADT7473) += adt7473.o
30obj-$(CONFIG_SENSORS_APPLESMC) += applesmc.o 31obj-$(CONFIG_SENSORS_APPLESMC) += applesmc.o
diff --git a/drivers/hwmon/adt7462.c b/drivers/hwmon/adt7462.c
new file mode 100644
index 000000000000..66107b4dc12a
--- /dev/null
+++ b/drivers/hwmon/adt7462.c
@@ -0,0 +1,2002 @@
1/*
2 * A hwmon driver for the Analog Devices ADT7462
3 * Copyright (C) 2008 IBM
4 *
5 * Author: Darrick J. Wong <djwong@us.ibm.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22#include <linux/module.h>
23#include <linux/jiffies.h>
24#include <linux/i2c.h>
25#include <linux/hwmon.h>
26#include <linux/hwmon-sysfs.h>
27#include <linux/err.h>
28#include <linux/mutex.h>
29#include <linux/delay.h>
30#include <linux/log2.h>
31
32/* Addresses to scan */
33static const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END };
34
35/* Insmod parameters */
36I2C_CLIENT_INSMOD_1(adt7462);
37
38/* ADT7462 registers */
39#define ADT7462_REG_DEVICE 0x3D
40#define ADT7462_REG_VENDOR 0x3E
41#define ADT7462_REG_REVISION 0x3F
42
43#define ADT7462_REG_MIN_TEMP_BASE_ADDR 0x44
44#define ADT7462_REG_MIN_TEMP_MAX_ADDR 0x47
45#define ADT7462_REG_MAX_TEMP_BASE_ADDR 0x48
46#define ADT7462_REG_MAX_TEMP_MAX_ADDR 0x4B
47#define ADT7462_REG_TEMP_BASE_ADDR 0x88
48#define ADT7462_REG_TEMP_MAX_ADDR 0x8F
49
50#define ADT7462_REG_FAN_BASE_ADDR 0x98
51#define ADT7462_REG_FAN_MAX_ADDR 0x9F
52#define ADT7462_REG_FAN2_BASE_ADDR 0xA2
53#define ADT7462_REG_FAN2_MAX_ADDR 0xA9
54#define ADT7462_REG_FAN_ENABLE 0x07
55#define ADT7462_REG_FAN_MIN_BASE_ADDR 0x78
56#define ADT7462_REG_FAN_MIN_MAX_ADDR 0x7F
57
58#define ADT7462_REG_CFG2 0x02
59#define ADT7462_FSPD_MASK 0x20
60
61#define ADT7462_REG_PWM_BASE_ADDR 0xAA
62#define ADT7462_REG_PWM_MAX_ADDR 0xAD
63#define ADT7462_REG_PWM_MIN_BASE_ADDR 0x28
64#define ADT7462_REG_PWM_MIN_MAX_ADDR 0x2B
65#define ADT7462_REG_PWM_MAX 0x2C
66#define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR 0x5C
67#define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR 0x5F
68#define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR 0x60
69#define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR 0x63
70#define ADT7462_PWM_HYST_MASK 0x0F
71#define ADT7462_PWM_RANGE_MASK 0xF0
72#define ADT7462_PWM_RANGE_SHIFT 4
73#define ADT7462_REG_PWM_CFG_BASE_ADDR 0x21
74#define ADT7462_REG_PWM_CFG_MAX_ADDR 0x24
75#define ADT7462_PWM_CHANNEL_MASK 0xE0
76#define ADT7462_PWM_CHANNEL_SHIFT 5
77
78#define ADT7462_REG_PIN_CFG_BASE_ADDR 0x10
79#define ADT7462_REG_PIN_CFG_MAX_ADDR 0x13
80#define ADT7462_PIN7_INPUT 0x01 /* cfg0 */
81#define ADT7462_DIODE3_INPUT 0x20
82#define ADT7462_DIODE1_INPUT 0x40
83#define ADT7462_VID_INPUT 0x80
84#define ADT7462_PIN22_INPUT 0x04 /* cfg1 */
85#define ADT7462_PIN21_INPUT 0x08
86#define ADT7462_PIN19_INPUT 0x10
87#define ADT7462_PIN15_INPUT 0x20
88#define ADT7462_PIN13_INPUT 0x40
89#define ADT7462_PIN8_INPUT 0x80
90#define ADT7462_PIN23_MASK 0x03
91#define ADT7462_PIN23_SHIFT 0
92#define ADT7462_PIN26_MASK 0x0C /* cfg2 */
93#define ADT7462_PIN26_SHIFT 2
94#define ADT7462_PIN25_MASK 0x30
95#define ADT7462_PIN25_SHIFT 4
96#define ADT7462_PIN24_MASK 0xC0
97#define ADT7462_PIN24_SHIFT 6
98#define ADT7462_PIN26_VOLT_INPUT 0x08
99#define ADT7462_PIN25_VOLT_INPUT 0x20
100#define ADT7462_PIN28_SHIFT 6 /* cfg3 */
101#define ADT7462_PIN28_VOLT 0x5
102
103#define ADT7462_REG_ALARM1 0xB8
104#define ADT7462_LT_ALARM 0x02
105#define ADT7462_R1T_ALARM 0x04
106#define ADT7462_R2T_ALARM 0x08
107#define ADT7462_R3T_ALARM 0x10
108#define ADT7462_REG_ALARM2 0xBB
109#define ADT7462_V0_ALARM 0x01
110#define ADT7462_V1_ALARM 0x02
111#define ADT7462_V2_ALARM 0x04
112#define ADT7462_V3_ALARM 0x08
113#define ADT7462_V4_ALARM 0x10
114#define ADT7462_V5_ALARM 0x20
115#define ADT7462_V6_ALARM 0x40
116#define ADT7462_V7_ALARM 0x80
117#define ADT7462_REG_ALARM3 0xBC
118#define ADT7462_V8_ALARM 0x08
119#define ADT7462_V9_ALARM 0x10
120#define ADT7462_V10_ALARM 0x20
121#define ADT7462_V11_ALARM 0x40
122#define ADT7462_V12_ALARM 0x80
123#define ADT7462_REG_ALARM4 0xBD
124#define ADT7462_F0_ALARM 0x01
125#define ADT7462_F1_ALARM 0x02
126#define ADT7462_F2_ALARM 0x04
127#define ADT7462_F3_ALARM 0x08
128#define ADT7462_F4_ALARM 0x10
129#define ADT7462_F5_ALARM 0x20
130#define ADT7462_F6_ALARM 0x40
131#define ADT7462_F7_ALARM 0x80
132#define ADT7462_ALARM1 0x0000
133#define ADT7462_ALARM2 0x0100
134#define ADT7462_ALARM3 0x0200
135#define ADT7462_ALARM4 0x0300
136#define ADT7462_ALARM_REG_SHIFT 8
137#define ADT7462_ALARM_FLAG_MASK 0x0F
138
139#define ADT7462_TEMP_COUNT 4
140#define ADT7462_TEMP_REG(x) (ADT7462_REG_TEMP_BASE_ADDR + (x * 2))
141#define ADT7462_TEMP_MIN_REG(x) (ADT7462_REG_MIN_TEMP_BASE_ADDR + (x))
142#define ADT7462_TEMP_MAX_REG(x) (ADT7462_REG_MAX_TEMP_BASE_ADDR + (x))
143#define TEMP_FRAC_OFFSET 6
144
145#define ADT7462_FAN_COUNT 8
146#define ADT7462_REG_FAN_MIN(x) (ADT7462_REG_FAN_MIN_BASE_ADDR + (x))
147
148#define ADT7462_PWM_COUNT 4
149#define ADT7462_REG_PWM(x) (ADT7462_REG_PWM_BASE_ADDR + (x))
150#define ADT7462_REG_PWM_MIN(x) (ADT7462_REG_PWM_MIN_BASE_ADDR + (x))
151#define ADT7462_REG_PWM_TMIN(x) \
152 (ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
153#define ADT7462_REG_PWM_TRANGE(x) \
154 (ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x))
155
156#define ADT7462_PIN_CFG_REG_COUNT 4
157#define ADT7462_REG_PIN_CFG(x) (ADT7462_REG_PIN_CFG_BASE_ADDR + (x))
158#define ADT7462_REG_PWM_CFG(x) (ADT7462_REG_PWM_CFG_BASE_ADDR + (x))
159
160#define ADT7462_ALARM_REG_COUNT 4
161
162/*
163 * The chip can measure 13 different voltage sources:
164 *
165 * 1. +12V1 (pin 7)
166 * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23)
167 * 3. +12V3 (pin 22)
168 * 4. +5V (pin 21)
169 * 5. +1.25V/+0.9V (pin 19)
170 * 6. +2.5V/+1.8V (pin 15)
171 * 7. +3.3v (pin 13)
172 * 8. +12V2 (pin 8)
173 * 9. Vbatt/FSB_Vtt (pin 26)
174 * A. +3.3V/+1.2V1 (pin 25)
175 * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24)
176 * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V)
177 * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V)
178 *
179 * Each of these 13 has a factor to convert raw to voltage. Even better,
180 * the pins can be connected to other sensors (tach/gpio/hot/etc), which
181 * makes the bookkeeping tricky.
182 *
183 * Some, but not all, of these voltages have low/high limits.
184 */
185#define ADT7462_VOLT_COUNT 12
186
187#define ADT7462_VENDOR 0x41
188#define ADT7462_DEVICE 0x62
189/* datasheet only mentions a revision 4 */
190#define ADT7462_REVISION 0x04
191
192/* How often do we reread sensors values? (In jiffies) */
193#define SENSOR_REFRESH_INTERVAL (2 * HZ)
194
195/* How often do we reread sensor limit values? (In jiffies) */
196#define LIMIT_REFRESH_INTERVAL (60 * HZ)
197
198/* datasheet says to divide this number by the fan reading to get fan rpm */
199#define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
200#define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
201#define FAN_PERIOD_INVALID 65535
202#define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
203
204#define MASK_AND_SHIFT(value, prefix) \
205 (((value) & prefix##_MASK) >> prefix##_SHIFT)
206
207#define ROUND_DIV(x, divisor) (((x) + ((divisor) / 2)) / (divisor))
208
209struct adt7462_data {
210 struct device *hwmon_dev;
211 struct attribute_group attrs;
212 struct mutex lock;
213 char sensors_valid;
214 char limits_valid;
215 unsigned long sensors_last_updated; /* In jiffies */
216 unsigned long limits_last_updated; /* In jiffies */
217
218 u8 temp[ADT7462_TEMP_COUNT];
219 /* bits 6-7 are quarter pieces of temp */
220 u8 temp_frac[ADT7462_TEMP_COUNT];
221 u8 temp_min[ADT7462_TEMP_COUNT];
222 u8 temp_max[ADT7462_TEMP_COUNT];
223 u16 fan[ADT7462_FAN_COUNT];
224 u8 fan_enabled;
225 u8 fan_min[ADT7462_FAN_COUNT];
226 u8 cfg2;
227 u8 pwm[ADT7462_PWM_COUNT];
228 u8 pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
229 u8 voltages[ADT7462_VOLT_COUNT];
230 u8 volt_max[ADT7462_VOLT_COUNT];
231 u8 volt_min[ADT7462_VOLT_COUNT];
232 u8 pwm_min[ADT7462_PWM_COUNT];
233 u8 pwm_tmin[ADT7462_PWM_COUNT];
234 u8 pwm_trange[ADT7462_PWM_COUNT];
235 u8 pwm_max; /* only one per chip */
236 u8 pwm_cfg[ADT7462_PWM_COUNT];
237 u8 alarms[ADT7462_ALARM_REG_COUNT];
238};
239
240static int adt7462_probe(struct i2c_client *client,
241 const struct i2c_device_id *id);
242static int adt7462_detect(struct i2c_client *client, int kind,
243 struct i2c_board_info *info);
244static int adt7462_remove(struct i2c_client *client);
245
246static const struct i2c_device_id adt7462_id[] = {
247 { "adt7462", adt7462 },
248 { }
249};
250MODULE_DEVICE_TABLE(i2c, adt7462_id);
251
252static struct i2c_driver adt7462_driver = {
253 .class = I2C_CLASS_HWMON,
254 .driver = {
255 .name = "adt7462",
256 },
257 .probe = adt7462_probe,
258 .remove = adt7462_remove,
259 .id_table = adt7462_id,
260 .detect = adt7462_detect,
261 .address_data = &addr_data,
262};
263
264/*
265 * 16-bit registers on the ADT7462 are low-byte first. The data sheet says
266 * that the low byte must be read before the high byte.
267 */
268static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
269{
270 u16 foo;
271 foo = i2c_smbus_read_byte_data(client, reg);
272 foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
273 return foo;
274}
275
276/* For some reason these registers are not contiguous. */
277static int ADT7462_REG_FAN(int fan)
278{
279 if (fan < 4)
280 return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
281 return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
282}
283
284/* Voltage registers are scattered everywhere */
285static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
286{
287 switch (which) {
288 case 0:
289 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
290 return 0x7C;
291 break;
292 case 1:
293 return 0x69;
294 case 2:
295 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
296 return 0x7F;
297 break;
298 case 3:
299 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
300 return 0x7E;
301 break;
302 case 4:
303 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
304 return 0x4B;
305 break;
306 case 5:
307 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
308 return 0x49;
309 break;
310 case 6:
311 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
312 return 0x68;
313 break;
314 case 7:
315 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
316 return 0x7D;
317 break;
318 case 8:
319 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
320 return 0x6C;
321 break;
322 case 9:
323 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
324 return 0x6B;
325 break;
326 case 10:
327 return 0x6A;
328 case 11:
329 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
330 ADT7462_PIN28_VOLT &&
331 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
332 return 0x50;
333 break;
334 case 12:
335 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
336 ADT7462_PIN28_VOLT &&
337 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
338 return 0x4C;
339 break;
340 }
341 return -ENODEV;
342}
343
344static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
345{
346 switch (which) {
347 case 0:
348 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
349 return 0x6D;
350 break;
351 case 1:
352 return 0x72;
353 case 2:
354 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
355 return 0x6F;
356 break;
357 case 3:
358 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
359 return 0x71;
360 break;
361 case 4:
362 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
363 return 0x47;
364 break;
365 case 5:
366 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
367 return 0x45;
368 break;
369 case 6:
370 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
371 return 0x70;
372 break;
373 case 7:
374 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
375 return 0x6E;
376 break;
377 case 8:
378 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
379 return 0x75;
380 break;
381 case 9:
382 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
383 return 0x74;
384 break;
385 case 10:
386 return 0x73;
387 case 11:
388 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
389 ADT7462_PIN28_VOLT &&
390 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
391 return 0x76;
392 break;
393 case 12:
394 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
395 ADT7462_PIN28_VOLT &&
396 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
397 return 0x77;
398 break;
399 }
400 return -ENODEV;
401}
402
403static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
404{
405 switch (which) {
406 case 0:
407 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
408 return 0xA3;
409 break;
410 case 1:
411 return 0x90;
412 case 2:
413 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
414 return 0xA9;
415 break;
416 case 3:
417 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
418 return 0xA7;
419 break;
420 case 4:
421 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
422 return 0x8F;
423 break;
424 case 5:
425 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
426 return 0x8B;
427 break;
428 case 6:
429 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
430 return 0x96;
431 break;
432 case 7:
433 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
434 return 0xA5;
435 break;
436 case 8:
437 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
438 return 0x93;
439 break;
440 case 9:
441 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
442 return 0x92;
443 break;
444 case 10:
445 return 0x91;
446 case 11:
447 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
448 ADT7462_PIN28_VOLT &&
449 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
450 return 0x94;
451 break;
452 case 12:
453 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
454 ADT7462_PIN28_VOLT &&
455 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
456 return 0x95;
457 break;
458 }
459 return -ENODEV;
460}
461
462/* Provide labels for sysfs */
463static const char *voltage_label(struct adt7462_data *data, int which)
464{
465 switch (which) {
466 case 0:
467 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
468 return "+12V1";
469 break;
470 case 1:
471 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
472 case 0:
473 return "Vccp1";
474 case 1:
475 return "+2.5V";
476 case 2:
477 return "+1.8V";
478 case 3:
479 return "+1.5V";
480 }
481 case 2:
482 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
483 return "+12V3";
484 break;
485 case 3:
486 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
487 return "+5V";
488 break;
489 case 4:
490 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
491 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
492 return "+0.9V";
493 return "+1.25V";
494 }
495 break;
496 case 5:
497 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
498 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
499 return "+1.8V";
500 return "+2.5V";
501 }
502 break;
503 case 6:
504 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
505 return "+3.3V";
506 break;
507 case 7:
508 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
509 return "+12V2";
510 break;
511 case 8:
512 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
513 case 0:
514 return "Vbatt";
515 case 1:
516 return "FSB_Vtt";
517 }
518 break;
519 case 9:
520 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
521 case 0:
522 return "+3.3V";
523 case 1:
524 return "+1.2V1";
525 }
526 break;
527 case 10:
528 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
529 case 0:
530 return "Vccp2";
531 case 1:
532 return "+2.5V";
533 case 2:
534 return "+1.8V";
535 case 3:
536 return "+1.5";
537 }
538 case 11:
539 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
540 ADT7462_PIN28_VOLT &&
541 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
542 return "+1.5V ICH";
543 break;
544 case 12:
545 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
546 ADT7462_PIN28_VOLT &&
547 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
548 return "+1.5V 3GPIO";
549 break;
550 }
551 return "N/A";
552}
553
554/* Multipliers are actually in uV, not mV. */
555static int voltage_multiplier(struct adt7462_data *data, int which)
556{
557 switch (which) {
558 case 0:
559 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
560 return 62500;
561 break;
562 case 1:
563 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
564 case 0:
565 if (data->pin_cfg[0] & ADT7462_VID_INPUT)
566 return 12500;
567 return 6250;
568 case 1:
569 return 13000;
570 case 2:
571 return 9400;
572 case 3:
573 return 7800;
574 }
575 case 2:
576 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
577 return 62500;
578 break;
579 case 3:
580 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
581 return 26000;
582 break;
583 case 4:
584 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
585 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
586 return 4690;
587 return 6500;
588 }
589 break;
590 case 5:
591 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
592 if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
593 return 9400;
594 return 13000;
595 }
596 break;
597 case 6:
598 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
599 return 17200;
600 break;
601 case 7:
602 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
603 return 62500;
604 break;
605 case 8:
606 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
607 case 0:
608 return 15600;
609 case 1:
610 return 6250;
611 }
612 break;
613 case 9:
614 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
615 case 0:
616 return 17200;
617 case 1:
618 return 6250;
619 }
620 break;
621 case 10:
622 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
623 case 0:
624 return 6250;
625 case 1:
626 return 13000;
627 case 2:
628 return 9400;
629 case 3:
630 return 7800;
631 }
632 case 11:
633 case 12:
634 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
635 ADT7462_PIN28_VOLT &&
636 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
637 return 7800;
638 }
639 return 0;
640}
641
642static int temp_enabled(struct adt7462_data *data, int which)
643{
644 switch (which) {
645 case 0:
646 case 2:
647 return 1;
648 case 1:
649 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
650 return 1;
651 break;
652 case 3:
653 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
654 return 1;
655 break;
656 }
657 return 0;
658}
659
660static const char *temp_label(struct adt7462_data *data, int which)
661{
662 switch (which) {
663 case 0:
664 return "local";
665 case 1:
666 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
667 return "remote1";
668 break;
669 case 2:
670 return "remote2";
671 case 3:
672 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
673 return "remote3";
674 break;
675 }
676 return "N/A";
677}
678
679/* Map Trange register values to mC */
680#define NUM_TRANGE_VALUES 16
681static const int trange_values[NUM_TRANGE_VALUES] = {
682 2000,
683 2500,
684 3300,
685 4000,
686 5000,
687 6700,
688 8000,
689 10000,
690 13300,
691 16000,
692 20000,
693 26700,
694 32000,
695 40000,
696 53300,
697 80000
698};
699
700static int find_trange_value(int trange)
701{
702 int i;
703
704 for (i = 0; i < NUM_TRANGE_VALUES; i++)
705 if (trange_values[i] == trange)
706 return i;
707
708 return -ENODEV;
709}
710
711static struct adt7462_data *adt7462_update_device(struct device *dev)
712{
713 struct i2c_client *client = to_i2c_client(dev);
714 struct adt7462_data *data = i2c_get_clientdata(client);
715 unsigned long local_jiffies = jiffies;
716 int i;
717
718 mutex_lock(&data->lock);
719 if (time_before(local_jiffies, data->sensors_last_updated +
720 SENSOR_REFRESH_INTERVAL)
721 && data->sensors_valid)
722 goto no_sensor_update;
723
724 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
725 /*
726 * Reading the fractional register locks the integral
727 * register until both have been read.
728 */
729 data->temp_frac[i] = i2c_smbus_read_byte_data(client,
730 ADT7462_TEMP_REG(i));
731 data->temp[i] = i2c_smbus_read_byte_data(client,
732 ADT7462_TEMP_REG(i) + 1);
733 }
734
735 for (i = 0; i < ADT7462_FAN_COUNT; i++)
736 data->fan[i] = adt7462_read_word_data(client,
737 ADT7462_REG_FAN(i));
738
739 data->fan_enabled = i2c_smbus_read_byte_data(client,
740 ADT7462_REG_FAN_ENABLE);
741
742 for (i = 0; i < ADT7462_PWM_COUNT; i++)
743 data->pwm[i] = i2c_smbus_read_byte_data(client,
744 ADT7462_REG_PWM(i));
745
746 for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
747 data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
748 ADT7462_REG_PIN_CFG(i));
749
750 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
751 int reg = ADT7462_REG_VOLT(data, i);
752 if (!reg)
753 data->voltages[i] = 0;
754 else
755 data->voltages[i] = i2c_smbus_read_byte_data(client,
756 reg);
757 }
758
759 data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
760 data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
761 data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
762 data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
763
764 data->sensors_last_updated = local_jiffies;
765 data->sensors_valid = 1;
766
767no_sensor_update:
768 if (time_before(local_jiffies, data->limits_last_updated +
769 LIMIT_REFRESH_INTERVAL)
770 && data->limits_valid)
771 goto out;
772
773 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
774 data->temp_min[i] = i2c_smbus_read_byte_data(client,
775 ADT7462_TEMP_MIN_REG(i));
776 data->temp_max[i] = i2c_smbus_read_byte_data(client,
777 ADT7462_TEMP_MAX_REG(i));
778 }
779
780 for (i = 0; i < ADT7462_FAN_COUNT; i++)
781 data->fan_min[i] = i2c_smbus_read_byte_data(client,
782 ADT7462_REG_FAN_MIN(i));
783
784 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
785 int reg = ADT7462_REG_VOLT_MAX(data, i);
786 data->volt_max[i] =
787 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
788
789 reg = ADT7462_REG_VOLT_MIN(data, i);
790 data->volt_min[i] =
791 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
792 }
793
794 for (i = 0; i < ADT7462_PWM_COUNT; i++) {
795 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
796 ADT7462_REG_PWM_MIN(i));
797 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
798 ADT7462_REG_PWM_TMIN(i));
799 data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
800 ADT7462_REG_PWM_TRANGE(i));
801 data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
802 ADT7462_REG_PWM_CFG(i));
803 }
804
805 data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
806
807 data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
808
809 data->limits_last_updated = local_jiffies;
810 data->limits_valid = 1;
811
812out:
813 mutex_unlock(&data->lock);
814 return data;
815}
816
817static ssize_t show_temp_min(struct device *dev,
818 struct device_attribute *devattr,
819 char *buf)
820{
821 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
822 struct adt7462_data *data = adt7462_update_device(dev);
823
824 if (!temp_enabled(data, attr->index))
825 return sprintf(buf, "0\n");
826
827 return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
828}
829
830static ssize_t set_temp_min(struct device *dev,
831 struct device_attribute *devattr,
832 const char *buf,
833 size_t count)
834{
835 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
836 struct i2c_client *client = to_i2c_client(dev);
837 struct adt7462_data *data = i2c_get_clientdata(client);
838 long temp;
839
840 if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
841 return -EINVAL;
842
843 temp = ROUND_DIV(temp, 1000) + 64;
844 temp = SENSORS_LIMIT(temp, 0, 255);
845
846 mutex_lock(&data->lock);
847 data->temp_min[attr->index] = temp;
848 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
849 temp);
850 mutex_unlock(&data->lock);
851
852 return count;
853}
854
855static ssize_t show_temp_max(struct device *dev,
856 struct device_attribute *devattr,
857 char *buf)
858{
859 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
860 struct adt7462_data *data = adt7462_update_device(dev);
861
862 if (!temp_enabled(data, attr->index))
863 return sprintf(buf, "0\n");
864
865 return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
866}
867
868static ssize_t set_temp_max(struct device *dev,
869 struct device_attribute *devattr,
870 const char *buf,
871 size_t count)
872{
873 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
874 struct i2c_client *client = to_i2c_client(dev);
875 struct adt7462_data *data = i2c_get_clientdata(client);
876 long temp;
877
878 if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
879 return -EINVAL;
880
881 temp = ROUND_DIV(temp, 1000) + 64;
882 temp = SENSORS_LIMIT(temp, 0, 255);
883
884 mutex_lock(&data->lock);
885 data->temp_max[attr->index] = temp;
886 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
887 temp);
888 mutex_unlock(&data->lock);
889
890 return count;
891}
892
893static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
894 char *buf)
895{
896 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
897 struct adt7462_data *data = adt7462_update_device(dev);
898 u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
899
900 if (!temp_enabled(data, attr->index))
901 return sprintf(buf, "0\n");
902
903 return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
904 250 * frac);
905}
906
907static ssize_t show_temp_label(struct device *dev,
908 struct device_attribute *devattr,
909 char *buf)
910{
911 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
912 struct adt7462_data *data = adt7462_update_device(dev);
913
914 return sprintf(buf, "%s\n", temp_label(data, attr->index));
915}
916
917static ssize_t show_volt_max(struct device *dev,
918 struct device_attribute *devattr,
919 char *buf)
920{
921 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
922 struct adt7462_data *data = adt7462_update_device(dev);
923 int x = voltage_multiplier(data, attr->index);
924
925 x *= data->volt_max[attr->index];
926 x /= 1000; /* convert from uV to mV */
927
928 return sprintf(buf, "%d\n", x);
929}
930
931static ssize_t set_volt_max(struct device *dev,
932 struct device_attribute *devattr,
933 const char *buf,
934 size_t count)
935{
936 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
937 struct i2c_client *client = to_i2c_client(dev);
938 struct adt7462_data *data = i2c_get_clientdata(client);
939 int x = voltage_multiplier(data, attr->index);
940 long temp;
941
942 if (strict_strtol(buf, 10, &temp) || !x)
943 return -EINVAL;
944
945 temp *= 1000; /* convert mV to uV */
946 temp = ROUND_DIV(temp, x);
947 temp = SENSORS_LIMIT(temp, 0, 255);
948
949 mutex_lock(&data->lock);
950 data->volt_max[attr->index] = temp;
951 i2c_smbus_write_byte_data(client,
952 ADT7462_REG_VOLT_MAX(data, attr->index),
953 temp);
954 mutex_unlock(&data->lock);
955
956 return count;
957}
958
959static ssize_t show_volt_min(struct device *dev,
960 struct device_attribute *devattr,
961 char *buf)
962{
963 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
964 struct adt7462_data *data = adt7462_update_device(dev);
965 int x = voltage_multiplier(data, attr->index);
966
967 x *= data->volt_min[attr->index];
968 x /= 1000; /* convert from uV to mV */
969
970 return sprintf(buf, "%d\n", x);
971}
972
973static ssize_t set_volt_min(struct device *dev,
974 struct device_attribute *devattr,
975 const char *buf,
976 size_t count)
977{
978 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
979 struct i2c_client *client = to_i2c_client(dev);
980 struct adt7462_data *data = i2c_get_clientdata(client);
981 int x = voltage_multiplier(data, attr->index);
982 long temp;
983
984 if (strict_strtol(buf, 10, &temp) || !x)
985 return -EINVAL;
986
987 temp *= 1000; /* convert mV to uV */
988 temp = ROUND_DIV(temp, x);
989 temp = SENSORS_LIMIT(temp, 0, 255);
990
991 mutex_lock(&data->lock);
992 data->volt_min[attr->index] = temp;
993 i2c_smbus_write_byte_data(client,
994 ADT7462_REG_VOLT_MIN(data, attr->index),
995 temp);
996 mutex_unlock(&data->lock);
997
998 return count;
999}
1000
1001static ssize_t show_voltage(struct device *dev,
1002 struct device_attribute *devattr,
1003 char *buf)
1004{
1005 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1006 struct adt7462_data *data = adt7462_update_device(dev);
1007 int x = voltage_multiplier(data, attr->index);
1008
1009 x *= data->voltages[attr->index];
1010 x /= 1000; /* convert from uV to mV */
1011
1012 return sprintf(buf, "%d\n", x);
1013}
1014
1015static ssize_t show_voltage_label(struct device *dev,
1016 struct device_attribute *devattr,
1017 char *buf)
1018{
1019 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1020 struct adt7462_data *data = adt7462_update_device(dev);
1021
1022 return sprintf(buf, "%s\n", voltage_label(data, attr->index));
1023}
1024
1025static ssize_t show_alarm(struct device *dev,
1026 struct device_attribute *devattr,
1027 char *buf)
1028{
1029 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1030 struct adt7462_data *data = adt7462_update_device(dev);
1031 int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
1032 int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
1033
1034 if (data->alarms[reg] & mask)
1035 return sprintf(buf, "1\n");
1036 else
1037 return sprintf(buf, "0\n");
1038}
1039
1040static int fan_enabled(struct adt7462_data *data, int fan)
1041{
1042 return data->fan_enabled & (1 << fan);
1043}
1044
1045static ssize_t show_fan_min(struct device *dev,
1046 struct device_attribute *devattr,
1047 char *buf)
1048{
1049 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1050 struct adt7462_data *data = adt7462_update_device(dev);
1051 u16 temp;
1052
1053 /* Only the MSB of the min fan period is stored... */
1054 temp = data->fan_min[attr->index];
1055 temp <<= 8;
1056
1057 if (!fan_enabled(data, attr->index) ||
1058 !FAN_DATA_VALID(temp))
1059 return sprintf(buf, "0\n");
1060
1061 return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
1062}
1063
1064static ssize_t set_fan_min(struct device *dev,
1065 struct device_attribute *devattr,
1066 const char *buf, size_t count)
1067{
1068 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1069 struct i2c_client *client = to_i2c_client(dev);
1070 struct adt7462_data *data = i2c_get_clientdata(client);
1071 long temp;
1072
1073 if (strict_strtol(buf, 10, &temp) || !temp ||
1074 !fan_enabled(data, attr->index))
1075 return -EINVAL;
1076
1077 temp = FAN_RPM_TO_PERIOD(temp);
1078 temp >>= 8;
1079 temp = SENSORS_LIMIT(temp, 1, 255);
1080
1081 mutex_lock(&data->lock);
1082 data->fan_min[attr->index] = temp;
1083 i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
1084 temp);
1085 mutex_unlock(&data->lock);
1086
1087 return count;
1088}
1089
1090static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
1091 char *buf)
1092{
1093 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1094 struct adt7462_data *data = adt7462_update_device(dev);
1095
1096 if (!fan_enabled(data, attr->index) ||
1097 !FAN_DATA_VALID(data->fan[attr->index]))
1098 return sprintf(buf, "0\n");
1099
1100 return sprintf(buf, "%d\n",
1101 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
1102}
1103
1104static ssize_t show_force_pwm_max(struct device *dev,
1105 struct device_attribute *devattr,
1106 char *buf)
1107{
1108 struct adt7462_data *data = adt7462_update_device(dev);
1109 return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
1110}
1111
1112static ssize_t set_force_pwm_max(struct device *dev,
1113 struct device_attribute *devattr,
1114 const char *buf,
1115 size_t count)
1116{
1117 struct i2c_client *client = to_i2c_client(dev);
1118 struct adt7462_data *data = i2c_get_clientdata(client);
1119 long temp;
1120 u8 reg;
1121
1122 if (strict_strtol(buf, 10, &temp))
1123 return -EINVAL;
1124
1125 mutex_lock(&data->lock);
1126 reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
1127 if (temp)
1128 reg |= ADT7462_FSPD_MASK;
1129 else
1130 reg &= ~ADT7462_FSPD_MASK;
1131 data->cfg2 = reg;
1132 i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
1133 mutex_unlock(&data->lock);
1134
1135 return count;
1136}
1137
1138static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
1139 char *buf)
1140{
1141 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1142 struct adt7462_data *data = adt7462_update_device(dev);
1143 return sprintf(buf, "%d\n", data->pwm[attr->index]);
1144}
1145
1146static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
1147 const char *buf, size_t count)
1148{
1149 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1150 struct i2c_client *client = to_i2c_client(dev);
1151 struct adt7462_data *data = i2c_get_clientdata(client);
1152 long temp;
1153
1154 if (strict_strtol(buf, 10, &temp))
1155 return -EINVAL;
1156
1157 temp = SENSORS_LIMIT(temp, 0, 255);
1158
1159 mutex_lock(&data->lock);
1160 data->pwm[attr->index] = temp;
1161 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
1162 mutex_unlock(&data->lock);
1163
1164 return count;
1165}
1166
1167static ssize_t show_pwm_max(struct device *dev,
1168 struct device_attribute *devattr,
1169 char *buf)
1170{
1171 struct adt7462_data *data = adt7462_update_device(dev);
1172 return sprintf(buf, "%d\n", data->pwm_max);
1173}
1174
1175static ssize_t set_pwm_max(struct device *dev,
1176 struct device_attribute *devattr,
1177 const char *buf,
1178 size_t count)
1179{
1180 struct i2c_client *client = to_i2c_client(dev);
1181 struct adt7462_data *data = i2c_get_clientdata(client);
1182 long temp;
1183
1184 if (strict_strtol(buf, 10, &temp))
1185 return -EINVAL;
1186
1187 temp = SENSORS_LIMIT(temp, 0, 255);
1188
1189 mutex_lock(&data->lock);
1190 data->pwm_max = temp;
1191 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
1192 mutex_unlock(&data->lock);
1193
1194 return count;
1195}
1196
1197static ssize_t show_pwm_min(struct device *dev,
1198 struct device_attribute *devattr,
1199 char *buf)
1200{
1201 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1202 struct adt7462_data *data = adt7462_update_device(dev);
1203 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
1204}
1205
1206static ssize_t set_pwm_min(struct device *dev,
1207 struct device_attribute *devattr,
1208 const char *buf,
1209 size_t count)
1210{
1211 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1212 struct i2c_client *client = to_i2c_client(dev);
1213 struct adt7462_data *data = i2c_get_clientdata(client);
1214 long temp;
1215
1216 if (strict_strtol(buf, 10, &temp))
1217 return -EINVAL;
1218
1219 temp = SENSORS_LIMIT(temp, 0, 255);
1220
1221 mutex_lock(&data->lock);
1222 data->pwm_min[attr->index] = temp;
1223 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
1224 temp);
1225 mutex_unlock(&data->lock);
1226
1227 return count;
1228}
1229
1230static ssize_t show_pwm_hyst(struct device *dev,
1231 struct device_attribute *devattr,
1232 char *buf)
1233{
1234 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1235 struct adt7462_data *data = adt7462_update_device(dev);
1236 return sprintf(buf, "%d\n", 1000 *
1237 (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
1238}
1239
1240static ssize_t set_pwm_hyst(struct device *dev,
1241 struct device_attribute *devattr,
1242 const char *buf,
1243 size_t count)
1244{
1245 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1246 struct i2c_client *client = to_i2c_client(dev);
1247 struct adt7462_data *data = i2c_get_clientdata(client);
1248 long temp;
1249
1250 if (strict_strtol(buf, 10, &temp))
1251 return -EINVAL;
1252
1253 temp = ROUND_DIV(temp, 1000);
1254 temp = SENSORS_LIMIT(temp, 0, 15);
1255
1256 /* package things up */
1257 temp &= ADT7462_PWM_HYST_MASK;
1258 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
1259
1260 mutex_lock(&data->lock);
1261 data->pwm_trange[attr->index] = temp;
1262 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1263 temp);
1264 mutex_unlock(&data->lock);
1265
1266 return count;
1267}
1268
1269static ssize_t show_pwm_tmax(struct device *dev,
1270 struct device_attribute *devattr,
1271 char *buf)
1272{
1273 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1274 struct adt7462_data *data = adt7462_update_device(dev);
1275
1276 /* tmax = tmin + trange */
1277 int trange = trange_values[data->pwm_trange[attr->index] >>
1278 ADT7462_PWM_RANGE_SHIFT];
1279 int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1280
1281 return sprintf(buf, "%d\n", tmin + trange);
1282}
1283
1284static ssize_t set_pwm_tmax(struct device *dev,
1285 struct device_attribute *devattr,
1286 const char *buf,
1287 size_t count)
1288{
1289 int temp;
1290 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1291 struct i2c_client *client = to_i2c_client(dev);
1292 struct adt7462_data *data = i2c_get_clientdata(client);
1293 int tmin, trange_value;
1294 long trange;
1295
1296 if (strict_strtol(buf, 10, &trange))
1297 return -EINVAL;
1298
1299 /* trange = tmax - tmin */
1300 tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1301 trange_value = find_trange_value(trange - tmin);
1302
1303 if (trange_value < 0)
1304 return -EINVAL;
1305
1306 temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
1307 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
1308
1309 mutex_lock(&data->lock);
1310 data->pwm_trange[attr->index] = temp;
1311 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1312 temp);
1313 mutex_unlock(&data->lock);
1314
1315 return count;
1316}
1317
1318static ssize_t show_pwm_tmin(struct device *dev,
1319 struct device_attribute *devattr,
1320 char *buf)
1321{
1322 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1323 struct adt7462_data *data = adt7462_update_device(dev);
1324 return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
1325}
1326
1327static ssize_t set_pwm_tmin(struct device *dev,
1328 struct device_attribute *devattr,
1329 const char *buf,
1330 size_t count)
1331{
1332 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1333 struct i2c_client *client = to_i2c_client(dev);
1334 struct adt7462_data *data = i2c_get_clientdata(client);
1335 long temp;
1336
1337 if (strict_strtol(buf, 10, &temp))
1338 return -EINVAL;
1339
1340 temp = ROUND_DIV(temp, 1000) + 64;
1341 temp = SENSORS_LIMIT(temp, 0, 255);
1342
1343 mutex_lock(&data->lock);
1344 data->pwm_tmin[attr->index] = temp;
1345 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
1346 temp);
1347 mutex_unlock(&data->lock);
1348
1349 return count;
1350}
1351
1352static ssize_t show_pwm_auto(struct device *dev,
1353 struct device_attribute *devattr,
1354 char *buf)
1355{
1356 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1357 struct adt7462_data *data = adt7462_update_device(dev);
1358 int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1359
1360 switch (cfg) {
1361 case 4: /* off */
1362 return sprintf(buf, "0\n");
1363 case 7: /* manual */
1364 return sprintf(buf, "1\n");
1365 default: /* automatic */
1366 return sprintf(buf, "2\n");
1367 }
1368}
1369
1370static void set_pwm_channel(struct i2c_client *client,
1371 struct adt7462_data *data,
1372 int which,
1373 int value)
1374{
1375 int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
1376 temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
1377
1378 mutex_lock(&data->lock);
1379 data->pwm_cfg[which] = temp;
1380 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
1381 mutex_unlock(&data->lock);
1382}
1383
1384static ssize_t set_pwm_auto(struct device *dev,
1385 struct device_attribute *devattr,
1386 const char *buf,
1387 size_t count)
1388{
1389 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1390 struct i2c_client *client = to_i2c_client(dev);
1391 struct adt7462_data *data = i2c_get_clientdata(client);
1392 long temp;
1393
1394 if (strict_strtol(buf, 10, &temp))
1395 return -EINVAL;
1396
1397 switch (temp) {
1398 case 0: /* off */
1399 set_pwm_channel(client, data, attr->index, 4);
1400 return count;
1401 case 1: /* manual */
1402 set_pwm_channel(client, data, attr->index, 7);
1403 return count;
1404 default:
1405 return -EINVAL;
1406 }
1407}
1408
1409static ssize_t show_pwm_auto_temp(struct device *dev,
1410 struct device_attribute *devattr,
1411 char *buf)
1412{
1413 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1414 struct adt7462_data *data = adt7462_update_device(dev);
1415 int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1416
1417 switch (channel) {
1418 case 0: /* temp[1234] only */
1419 case 1:
1420 case 2:
1421 case 3:
1422 return sprintf(buf, "%d\n", (1 << channel));
1423 case 5: /* temp1 & temp4 */
1424 return sprintf(buf, "9\n");
1425 case 6:
1426 return sprintf(buf, "15\n");
1427 default:
1428 return sprintf(buf, "0\n");
1429 }
1430}
1431
1432static int cvt_auto_temp(int input)
1433{
1434 if (input == 0xF)
1435 return 6;
1436 if (input == 0x9)
1437 return 5;
1438 if (input < 1 || !is_power_of_2(input))
1439 return -EINVAL;
1440 return ilog2(input);
1441}
1442
1443static ssize_t set_pwm_auto_temp(struct device *dev,
1444 struct device_attribute *devattr,
1445 const char *buf,
1446 size_t count)
1447{
1448 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1449 struct i2c_client *client = to_i2c_client(dev);
1450 struct adt7462_data *data = i2c_get_clientdata(client);
1451 long temp;
1452
1453 if (strict_strtol(buf, 10, &temp))
1454 return -EINVAL;
1455
1456 temp = cvt_auto_temp(temp);
1457 if (temp < 0)
1458 return temp;
1459
1460 set_pwm_channel(client, data, attr->index, temp);
1461
1462 return count;
1463}
1464
1465static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
1466 set_temp_max, 0);
1467static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
1468 set_temp_max, 1);
1469static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
1470 set_temp_max, 2);
1471static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max,
1472 set_temp_max, 3);
1473
1474static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
1475 set_temp_min, 0);
1476static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
1477 set_temp_min, 1);
1478static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
1479 set_temp_min, 2);
1480static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min,
1481 set_temp_min, 3);
1482
1483static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1484static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
1485static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
1486static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
1487
1488static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0);
1489static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1);
1490static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2);
1491static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3);
1492
1493static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
1494 ADT7462_ALARM1 | ADT7462_LT_ALARM);
1495static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
1496 ADT7462_ALARM1 | ADT7462_R1T_ALARM);
1497static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
1498 ADT7462_ALARM1 | ADT7462_R2T_ALARM);
1499static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL,
1500 ADT7462_ALARM1 | ADT7462_R3T_ALARM);
1501
1502static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, show_volt_max,
1503 set_volt_max, 0);
1504static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, show_volt_max,
1505 set_volt_max, 1);
1506static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, show_volt_max,
1507 set_volt_max, 2);
1508static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, show_volt_max,
1509 set_volt_max, 3);
1510static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, show_volt_max,
1511 set_volt_max, 4);
1512static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, show_volt_max,
1513 set_volt_max, 5);
1514static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO, show_volt_max,
1515 set_volt_max, 6);
1516static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO, show_volt_max,
1517 set_volt_max, 7);
1518static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO, show_volt_max,
1519 set_volt_max, 8);
1520static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO, show_volt_max,
1521 set_volt_max, 9);
1522static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO, show_volt_max,
1523 set_volt_max, 10);
1524static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO, show_volt_max,
1525 set_volt_max, 11);
1526static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO, show_volt_max,
1527 set_volt_max, 12);
1528
1529static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, show_volt_min,
1530 set_volt_min, 0);
1531static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, show_volt_min,
1532 set_volt_min, 1);
1533static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, show_volt_min,
1534 set_volt_min, 2);
1535static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, show_volt_min,
1536 set_volt_min, 3);
1537static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, show_volt_min,
1538 set_volt_min, 4);
1539static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, show_volt_min,
1540 set_volt_min, 5);
1541static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO, show_volt_min,
1542 set_volt_min, 6);
1543static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO, show_volt_min,
1544 set_volt_min, 7);
1545static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO, show_volt_min,
1546 set_volt_min, 8);
1547static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO, show_volt_min,
1548 set_volt_min, 9);
1549static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO, show_volt_min,
1550 set_volt_min, 10);
1551static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO, show_volt_min,
1552 set_volt_min, 11);
1553static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO, show_volt_min,
1554 set_volt_min, 12);
1555
1556static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_voltage, NULL, 0);
1557static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_voltage, NULL, 1);
1558static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_voltage, NULL, 2);
1559static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_voltage, NULL, 3);
1560static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_voltage, NULL, 4);
1561static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_voltage, NULL, 5);
1562static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_voltage, NULL, 6);
1563static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_voltage, NULL, 7);
1564static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_voltage, NULL, 8);
1565static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_voltage, NULL, 9);
1566static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_voltage, NULL, 10);
1567static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_voltage, NULL, 11);
1568static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_voltage, NULL, 12);
1569
1570static SENSOR_DEVICE_ATTR(in1_label, S_IRUGO, show_voltage_label, NULL, 0);
1571static SENSOR_DEVICE_ATTR(in2_label, S_IRUGO, show_voltage_label, NULL, 1);
1572static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, show_voltage_label, NULL, 2);
1573static SENSOR_DEVICE_ATTR(in4_label, S_IRUGO, show_voltage_label, NULL, 3);
1574static SENSOR_DEVICE_ATTR(in5_label, S_IRUGO, show_voltage_label, NULL, 4);
1575static SENSOR_DEVICE_ATTR(in6_label, S_IRUGO, show_voltage_label, NULL, 5);
1576static SENSOR_DEVICE_ATTR(in7_label, S_IRUGO, show_voltage_label, NULL, 6);
1577static SENSOR_DEVICE_ATTR(in8_label, S_IRUGO, show_voltage_label, NULL, 7);
1578static SENSOR_DEVICE_ATTR(in9_label, S_IRUGO, show_voltage_label, NULL, 8);
1579static SENSOR_DEVICE_ATTR(in10_label, S_IRUGO, show_voltage_label, NULL, 9);
1580static SENSOR_DEVICE_ATTR(in11_label, S_IRUGO, show_voltage_label, NULL, 10);
1581static SENSOR_DEVICE_ATTR(in12_label, S_IRUGO, show_voltage_label, NULL, 11);
1582static SENSOR_DEVICE_ATTR(in13_label, S_IRUGO, show_voltage_label, NULL, 12);
1583
1584static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL,
1585 ADT7462_ALARM2 | ADT7462_V0_ALARM);
1586static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL,
1587 ADT7462_ALARM2 | ADT7462_V7_ALARM);
1588static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL,
1589 ADT7462_ALARM2 | ADT7462_V2_ALARM);
1590static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL,
1591 ADT7462_ALARM2 | ADT7462_V6_ALARM);
1592static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL,
1593 ADT7462_ALARM2 | ADT7462_V5_ALARM);
1594static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL,
1595 ADT7462_ALARM2 | ADT7462_V4_ALARM);
1596static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL,
1597 ADT7462_ALARM2 | ADT7462_V3_ALARM);
1598static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL,
1599 ADT7462_ALARM2 | ADT7462_V1_ALARM);
1600static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL,
1601 ADT7462_ALARM3 | ADT7462_V10_ALARM);
1602static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL,
1603 ADT7462_ALARM3 | ADT7462_V9_ALARM);
1604static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL,
1605 ADT7462_ALARM3 | ADT7462_V8_ALARM);
1606static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL,
1607 ADT7462_ALARM3 | ADT7462_V11_ALARM);
1608static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL,
1609 ADT7462_ALARM3 | ADT7462_V12_ALARM);
1610
1611static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1612 set_fan_min, 0);
1613static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1614 set_fan_min, 1);
1615static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1616 set_fan_min, 2);
1617static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1618 set_fan_min, 3);
1619static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
1620 set_fan_min, 4);
1621static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO, show_fan_min,
1622 set_fan_min, 5);
1623static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO, show_fan_min,
1624 set_fan_min, 6);
1625static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO, show_fan_min,
1626 set_fan_min, 7);
1627
1628static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
1629static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
1630static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
1631static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
1632static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4);
1633static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 5);
1634static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 6);
1635static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan, NULL, 7);
1636
1637static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
1638 ADT7462_ALARM4 | ADT7462_F0_ALARM);
1639static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
1640 ADT7462_ALARM4 | ADT7462_F1_ALARM);
1641static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
1642 ADT7462_ALARM4 | ADT7462_F2_ALARM);
1643static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
1644 ADT7462_ALARM4 | ADT7462_F3_ALARM);
1645static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL,
1646 ADT7462_ALARM4 | ADT7462_F4_ALARM);
1647static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL,
1648 ADT7462_ALARM4 | ADT7462_F5_ALARM);
1649static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL,
1650 ADT7462_ALARM4 | ADT7462_F6_ALARM);
1651static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_alarm, NULL,
1652 ADT7462_ALARM4 | ADT7462_F7_ALARM);
1653
1654static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO,
1655 show_force_pwm_max, set_force_pwm_max, 0);
1656
1657static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
1658static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
1659static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
1660static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
1661
1662static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
1663 show_pwm_min, set_pwm_min, 0);
1664static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
1665 show_pwm_min, set_pwm_min, 1);
1666static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
1667 show_pwm_min, set_pwm_min, 2);
1668static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
1669 show_pwm_min, set_pwm_min, 3);
1670
1671static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
1672 show_pwm_max, set_pwm_max, 0);
1673static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
1674 show_pwm_max, set_pwm_max, 1);
1675static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
1676 show_pwm_max, set_pwm_max, 2);
1677static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
1678 show_pwm_max, set_pwm_max, 3);
1679
1680static SENSOR_DEVICE_ATTR(temp1_auto_point1_hyst, S_IWUSR | S_IRUGO,
1681 show_pwm_hyst, set_pwm_hyst, 0);
1682static SENSOR_DEVICE_ATTR(temp2_auto_point1_hyst, S_IWUSR | S_IRUGO,
1683 show_pwm_hyst, set_pwm_hyst, 1);
1684static SENSOR_DEVICE_ATTR(temp3_auto_point1_hyst, S_IWUSR | S_IRUGO,
1685 show_pwm_hyst, set_pwm_hyst, 2);
1686static SENSOR_DEVICE_ATTR(temp4_auto_point1_hyst, S_IWUSR | S_IRUGO,
1687 show_pwm_hyst, set_pwm_hyst, 3);
1688
1689static SENSOR_DEVICE_ATTR(temp1_auto_point2_hyst, S_IWUSR | S_IRUGO,
1690 show_pwm_hyst, set_pwm_hyst, 0);
1691static SENSOR_DEVICE_ATTR(temp2_auto_point2_hyst, S_IWUSR | S_IRUGO,
1692 show_pwm_hyst, set_pwm_hyst, 1);
1693static SENSOR_DEVICE_ATTR(temp3_auto_point2_hyst, S_IWUSR | S_IRUGO,
1694 show_pwm_hyst, set_pwm_hyst, 2);
1695static SENSOR_DEVICE_ATTR(temp4_auto_point2_hyst, S_IWUSR | S_IRUGO,
1696 show_pwm_hyst, set_pwm_hyst, 3);
1697
1698static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IWUSR | S_IRUGO,
1699 show_pwm_tmin, set_pwm_tmin, 0);
1700static SENSOR_DEVICE_ATTR(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
1701 show_pwm_tmin, set_pwm_tmin, 1);
1702static SENSOR_DEVICE_ATTR(temp3_auto_point1_temp, S_IWUSR | S_IRUGO,
1703 show_pwm_tmin, set_pwm_tmin, 2);
1704static SENSOR_DEVICE_ATTR(temp4_auto_point1_temp, S_IWUSR | S_IRUGO,
1705 show_pwm_tmin, set_pwm_tmin, 3);
1706
1707static SENSOR_DEVICE_ATTR(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
1708 show_pwm_tmax, set_pwm_tmax, 0);
1709static SENSOR_DEVICE_ATTR(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
1710 show_pwm_tmax, set_pwm_tmax, 1);
1711static SENSOR_DEVICE_ATTR(temp3_auto_point2_temp, S_IWUSR | S_IRUGO,
1712 show_pwm_tmax, set_pwm_tmax, 2);
1713static SENSOR_DEVICE_ATTR(temp4_auto_point2_temp, S_IWUSR | S_IRUGO,
1714 show_pwm_tmax, set_pwm_tmax, 3);
1715
1716static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1717 set_pwm_auto, 0);
1718static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1719 set_pwm_auto, 1);
1720static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1721 set_pwm_auto, 2);
1722static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1723 set_pwm_auto, 3);
1724
1725static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
1726 show_pwm_auto_temp, set_pwm_auto_temp, 0);
1727static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
1728 show_pwm_auto_temp, set_pwm_auto_temp, 1);
1729static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
1730 show_pwm_auto_temp, set_pwm_auto_temp, 2);
1731static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO,
1732 show_pwm_auto_temp, set_pwm_auto_temp, 3);
1733
1734static struct attribute *adt7462_attr[] =
1735{
1736 &sensor_dev_attr_temp1_max.dev_attr.attr,
1737 &sensor_dev_attr_temp2_max.dev_attr.attr,
1738 &sensor_dev_attr_temp3_max.dev_attr.attr,
1739 &sensor_dev_attr_temp4_max.dev_attr.attr,
1740
1741 &sensor_dev_attr_temp1_min.dev_attr.attr,
1742 &sensor_dev_attr_temp2_min.dev_attr.attr,
1743 &sensor_dev_attr_temp3_min.dev_attr.attr,
1744 &sensor_dev_attr_temp4_min.dev_attr.attr,
1745
1746 &sensor_dev_attr_temp1_input.dev_attr.attr,
1747 &sensor_dev_attr_temp2_input.dev_attr.attr,
1748 &sensor_dev_attr_temp3_input.dev_attr.attr,
1749 &sensor_dev_attr_temp4_input.dev_attr.attr,
1750
1751 &sensor_dev_attr_temp1_label.dev_attr.attr,
1752 &sensor_dev_attr_temp2_label.dev_attr.attr,
1753 &sensor_dev_attr_temp3_label.dev_attr.attr,
1754 &sensor_dev_attr_temp4_label.dev_attr.attr,
1755
1756 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1757 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1758 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1759 &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1760
1761 &sensor_dev_attr_in1_max.dev_attr.attr,
1762 &sensor_dev_attr_in2_max.dev_attr.attr,
1763 &sensor_dev_attr_in3_max.dev_attr.attr,
1764 &sensor_dev_attr_in4_max.dev_attr.attr,
1765 &sensor_dev_attr_in5_max.dev_attr.attr,
1766 &sensor_dev_attr_in6_max.dev_attr.attr,
1767 &sensor_dev_attr_in7_max.dev_attr.attr,
1768 &sensor_dev_attr_in8_max.dev_attr.attr,
1769 &sensor_dev_attr_in9_max.dev_attr.attr,
1770 &sensor_dev_attr_in10_max.dev_attr.attr,
1771 &sensor_dev_attr_in11_max.dev_attr.attr,
1772 &sensor_dev_attr_in12_max.dev_attr.attr,
1773 &sensor_dev_attr_in13_max.dev_attr.attr,
1774
1775 &sensor_dev_attr_in1_min.dev_attr.attr,
1776 &sensor_dev_attr_in2_min.dev_attr.attr,
1777 &sensor_dev_attr_in3_min.dev_attr.attr,
1778 &sensor_dev_attr_in4_min.dev_attr.attr,
1779 &sensor_dev_attr_in5_min.dev_attr.attr,
1780 &sensor_dev_attr_in6_min.dev_attr.attr,
1781 &sensor_dev_attr_in7_min.dev_attr.attr,
1782 &sensor_dev_attr_in8_min.dev_attr.attr,
1783 &sensor_dev_attr_in9_min.dev_attr.attr,
1784 &sensor_dev_attr_in10_min.dev_attr.attr,
1785 &sensor_dev_attr_in11_min.dev_attr.attr,
1786 &sensor_dev_attr_in12_min.dev_attr.attr,
1787 &sensor_dev_attr_in13_min.dev_attr.attr,
1788
1789 &sensor_dev_attr_in1_input.dev_attr.attr,
1790 &sensor_dev_attr_in2_input.dev_attr.attr,
1791 &sensor_dev_attr_in3_input.dev_attr.attr,
1792 &sensor_dev_attr_in4_input.dev_attr.attr,
1793 &sensor_dev_attr_in5_input.dev_attr.attr,
1794 &sensor_dev_attr_in6_input.dev_attr.attr,
1795 &sensor_dev_attr_in7_input.dev_attr.attr,
1796 &sensor_dev_attr_in8_input.dev_attr.attr,
1797 &sensor_dev_attr_in9_input.dev_attr.attr,
1798 &sensor_dev_attr_in10_input.dev_attr.attr,
1799 &sensor_dev_attr_in11_input.dev_attr.attr,
1800 &sensor_dev_attr_in12_input.dev_attr.attr,
1801 &sensor_dev_attr_in13_input.dev_attr.attr,
1802
1803 &sensor_dev_attr_in1_label.dev_attr.attr,
1804 &sensor_dev_attr_in2_label.dev_attr.attr,
1805 &sensor_dev_attr_in3_label.dev_attr.attr,
1806 &sensor_dev_attr_in4_label.dev_attr.attr,
1807 &sensor_dev_attr_in5_label.dev_attr.attr,
1808 &sensor_dev_attr_in6_label.dev_attr.attr,
1809 &sensor_dev_attr_in7_label.dev_attr.attr,
1810 &sensor_dev_attr_in8_label.dev_attr.attr,
1811 &sensor_dev_attr_in9_label.dev_attr.attr,
1812 &sensor_dev_attr_in10_label.dev_attr.attr,
1813 &sensor_dev_attr_in11_label.dev_attr.attr,
1814 &sensor_dev_attr_in12_label.dev_attr.attr,
1815 &sensor_dev_attr_in13_label.dev_attr.attr,
1816
1817 &sensor_dev_attr_in1_alarm.dev_attr.attr,
1818 &sensor_dev_attr_in2_alarm.dev_attr.attr,
1819 &sensor_dev_attr_in3_alarm.dev_attr.attr,
1820 &sensor_dev_attr_in4_alarm.dev_attr.attr,
1821 &sensor_dev_attr_in5_alarm.dev_attr.attr,
1822 &sensor_dev_attr_in6_alarm.dev_attr.attr,
1823 &sensor_dev_attr_in7_alarm.dev_attr.attr,
1824 &sensor_dev_attr_in8_alarm.dev_attr.attr,
1825 &sensor_dev_attr_in9_alarm.dev_attr.attr,
1826 &sensor_dev_attr_in10_alarm.dev_attr.attr,
1827 &sensor_dev_attr_in11_alarm.dev_attr.attr,
1828 &sensor_dev_attr_in12_alarm.dev_attr.attr,
1829 &sensor_dev_attr_in13_alarm.dev_attr.attr,
1830
1831 &sensor_dev_attr_fan1_min.dev_attr.attr,
1832 &sensor_dev_attr_fan2_min.dev_attr.attr,
1833 &sensor_dev_attr_fan3_min.dev_attr.attr,
1834 &sensor_dev_attr_fan4_min.dev_attr.attr,
1835 &sensor_dev_attr_fan5_min.dev_attr.attr,
1836 &sensor_dev_attr_fan6_min.dev_attr.attr,
1837 &sensor_dev_attr_fan7_min.dev_attr.attr,
1838 &sensor_dev_attr_fan8_min.dev_attr.attr,
1839
1840 &sensor_dev_attr_fan1_input.dev_attr.attr,
1841 &sensor_dev_attr_fan2_input.dev_attr.attr,
1842 &sensor_dev_attr_fan3_input.dev_attr.attr,
1843 &sensor_dev_attr_fan4_input.dev_attr.attr,
1844 &sensor_dev_attr_fan5_input.dev_attr.attr,
1845 &sensor_dev_attr_fan6_input.dev_attr.attr,
1846 &sensor_dev_attr_fan7_input.dev_attr.attr,
1847 &sensor_dev_attr_fan8_input.dev_attr.attr,
1848
1849 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1850 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1851 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1852 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1853 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1854 &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1855 &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1856 &sensor_dev_attr_fan8_alarm.dev_attr.attr,
1857
1858 &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1859 &sensor_dev_attr_pwm1.dev_attr.attr,
1860 &sensor_dev_attr_pwm2.dev_attr.attr,
1861 &sensor_dev_attr_pwm3.dev_attr.attr,
1862 &sensor_dev_attr_pwm4.dev_attr.attr,
1863
1864 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1865 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1866 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1867 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1868
1869 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1870 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1871 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1872 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1873
1874 &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
1875 &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
1876 &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
1877 &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
1878
1879 &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
1880 &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
1881 &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
1882 &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
1883
1884 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1885 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1886 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1887 &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
1888
1889 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1890 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1891 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1892 &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
1893
1894 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1895 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1896 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1897 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1898
1899 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1900 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1901 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1902 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1903 NULL
1904};
1905
1906/* Return 0 if detection is successful, -ENODEV otherwise */
1907static int adt7462_detect(struct i2c_client *client, int kind,
1908 struct i2c_board_info *info)
1909{
1910 struct i2c_adapter *adapter = client->adapter;
1911
1912 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1913 return -ENODEV;
1914
1915 if (kind <= 0) {
1916 int vendor, device, revision;
1917
1918 vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
1919 if (vendor != ADT7462_VENDOR)
1920 return -ENODEV;
1921
1922 device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
1923 if (device != ADT7462_DEVICE)
1924 return -ENODEV;
1925
1926 revision = i2c_smbus_read_byte_data(client,
1927 ADT7462_REG_REVISION);
1928 if (revision != ADT7462_REVISION)
1929 return -ENODEV;
1930 } else
1931 dev_dbg(&adapter->dev, "detection forced\n");
1932
1933 strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
1934
1935 return 0;
1936}
1937
1938static int adt7462_probe(struct i2c_client *client,
1939 const struct i2c_device_id *id)
1940{
1941 struct adt7462_data *data;
1942 int err;
1943
1944 data = kzalloc(sizeof(struct adt7462_data), GFP_KERNEL);
1945 if (!data) {
1946 err = -ENOMEM;
1947 goto exit;
1948 }
1949
1950 i2c_set_clientdata(client, data);
1951 mutex_init(&data->lock);
1952
1953 dev_info(&client->dev, "%s chip found\n", client->name);
1954
1955 /* Register sysfs hooks */
1956 data->attrs.attrs = adt7462_attr;
1957 err = sysfs_create_group(&client->dev.kobj, &data->attrs);
1958 if (err)
1959 goto exit_free;
1960
1961 data->hwmon_dev = hwmon_device_register(&client->dev);
1962 if (IS_ERR(data->hwmon_dev)) {
1963 err = PTR_ERR(data->hwmon_dev);
1964 goto exit_remove;
1965 }
1966
1967 return 0;
1968
1969exit_remove:
1970 sysfs_remove_group(&client->dev.kobj, &data->attrs);
1971exit_free:
1972 kfree(data);
1973exit:
1974 return err;
1975}
1976
1977static int adt7462_remove(struct i2c_client *client)
1978{
1979 struct adt7462_data *data = i2c_get_clientdata(client);
1980
1981 hwmon_device_unregister(data->hwmon_dev);
1982 sysfs_remove_group(&client->dev.kobj, &data->attrs);
1983 kfree(data);
1984 return 0;
1985}
1986
1987static int __init adt7462_init(void)
1988{
1989 return i2c_add_driver(&adt7462_driver);
1990}
1991
1992static void __exit adt7462_exit(void)
1993{
1994 i2c_del_driver(&adt7462_driver);
1995}
1996
1997MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1998MODULE_DESCRIPTION("ADT7462 driver");
1999MODULE_LICENSE("GPL");
2000
2001module_init(adt7462_init);
2002module_exit(adt7462_exit);
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-30 16:00:50 -0500