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