]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/hwmon/adt7462.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
timekeeping: Repair ktime_get_coarse*() granularity
[mirror_ubuntu-jammy-kernel.git] / drivers / hwmon / adt7462.c
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 */
33 static 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
204 struct 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 */
238 static 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. */
247 static 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 */
255 static 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
314 static 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
373 static 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 */
433 static 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 /* fall through */
452 case 2:
453 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
454 return "+12V3";
455 break;
456 case 3:
457 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
458 return "+5V";
459 break;
460 case 4:
461 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
462 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
463 return "+0.9V";
464 return "+1.25V";
465 }
466 break;
467 case 5:
468 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
469 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
470 return "+1.8V";
471 return "+2.5V";
472 }
473 break;
474 case 6:
475 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
476 return "+3.3V";
477 break;
478 case 7:
479 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
480 return "+12V2";
481 break;
482 case 8:
483 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
484 case 0:
485 return "Vbatt";
486 case 1:
487 return "FSB_Vtt";
488 }
489 break;
490 case 9:
491 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
492 case 0:
493 return "+3.3V";
494 case 1:
495 return "+1.2V1";
496 }
497 break;
498 case 10:
499 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
500 case 0:
501 return "Vccp2";
502 case 1:
503 return "+2.5V";
504 case 2:
505 return "+1.8V";
506 case 3:
507 return "+1.5";
508 }
509 /* fall through */
510 case 11:
511 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
512 ADT7462_PIN28_VOLT &&
513 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
514 return "+1.5V ICH";
515 break;
516 case 12:
517 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
518 ADT7462_PIN28_VOLT &&
519 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
520 return "+1.5V 3GPIO";
521 break;
522 }
523 return "N/A";
524 }
525
526 /* Multipliers are actually in uV, not mV. */
527 static int voltage_multiplier(struct adt7462_data *data, int which)
528 {
529 switch (which) {
530 case 0:
531 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
532 return 62500;
533 break;
534 case 1:
535 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
536 case 0:
537 if (data->pin_cfg[0] & ADT7462_VID_INPUT)
538 return 12500;
539 return 6250;
540 case 1:
541 return 13000;
542 case 2:
543 return 9400;
544 case 3:
545 return 7800;
546 }
547 /* fall through */
548 case 2:
549 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
550 return 62500;
551 break;
552 case 3:
553 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
554 return 26000;
555 break;
556 case 4:
557 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
558 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
559 return 4690;
560 return 6500;
561 }
562 break;
563 case 5:
564 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
565 if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
566 return 9400;
567 return 13000;
568 }
569 break;
570 case 6:
571 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
572 return 17200;
573 break;
574 case 7:
575 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
576 return 62500;
577 break;
578 case 8:
579 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
580 case 0:
581 return 15600;
582 case 1:
583 return 6250;
584 }
585 break;
586 case 9:
587 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
588 case 0:
589 return 17200;
590 case 1:
591 return 6250;
592 }
593 break;
594 case 10:
595 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
596 case 0:
597 return 6250;
598 case 1:
599 return 13000;
600 case 2:
601 return 9400;
602 case 3:
603 return 7800;
604 }
605 /* fall through */
606 case 11:
607 case 12:
608 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
609 ADT7462_PIN28_VOLT &&
610 !(data->pin_cfg[0] & ADT7462_VID_INPUT))
611 return 7800;
612 }
613 return 0;
614 }
615
616 static int temp_enabled(struct adt7462_data *data, int which)
617 {
618 switch (which) {
619 case 0:
620 case 2:
621 return 1;
622 case 1:
623 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
624 return 1;
625 break;
626 case 3:
627 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
628 return 1;
629 break;
630 }
631 return 0;
632 }
633
634 static const char *temp_label(struct adt7462_data *data, int which)
635 {
636 switch (which) {
637 case 0:
638 return "local";
639 case 1:
640 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
641 return "remote1";
642 break;
643 case 2:
644 return "remote2";
645 case 3:
646 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
647 return "remote3";
648 break;
649 }
650 return "N/A";
651 }
652
653 /* Map Trange register values to mC */
654 #define NUM_TRANGE_VALUES 16
655 static const int trange_values[NUM_TRANGE_VALUES] = {
656 2000,
657 2500,
658 3300,
659 4000,
660 5000,
661 6700,
662 8000,
663 10000,
664 13300,
665 16000,
666 20000,
667 26700,
668 32000,
669 40000,
670 53300,
671 80000
672 };
673
674 static int find_trange_value(int trange)
675 {
676 int i;
677
678 for (i = 0; i < NUM_TRANGE_VALUES; i++)
679 if (trange_values[i] == trange)
680 return i;
681
682 return -EINVAL;
683 }
684
685 static struct adt7462_data *adt7462_update_device(struct device *dev)
686 {
687 struct adt7462_data *data = dev_get_drvdata(dev);
688 struct i2c_client *client = data->client;
689 unsigned long local_jiffies = jiffies;
690 int i;
691
692 mutex_lock(&data->lock);
693 if (time_before(local_jiffies, data->sensors_last_updated +
694 SENSOR_REFRESH_INTERVAL)
695 && data->sensors_valid)
696 goto no_sensor_update;
697
698 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
699 /*
700 * Reading the fractional register locks the integral
701 * register until both have been read.
702 */
703 data->temp_frac[i] = i2c_smbus_read_byte_data(client,
704 ADT7462_TEMP_REG(i));
705 data->temp[i] = i2c_smbus_read_byte_data(client,
706 ADT7462_TEMP_REG(i) + 1);
707 }
708
709 for (i = 0; i < ADT7462_FAN_COUNT; i++)
710 data->fan[i] = adt7462_read_word_data(client,
711 ADT7462_REG_FAN(i));
712
713 data->fan_enabled = i2c_smbus_read_byte_data(client,
714 ADT7462_REG_FAN_ENABLE);
715
716 for (i = 0; i < ADT7462_PWM_COUNT; i++)
717 data->pwm[i] = i2c_smbus_read_byte_data(client,
718 ADT7462_REG_PWM(i));
719
720 for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
721 data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
722 ADT7462_REG_PIN_CFG(i));
723
724 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
725 int reg = ADT7462_REG_VOLT(data, i);
726 if (!reg)
727 data->voltages[i] = 0;
728 else
729 data->voltages[i] = i2c_smbus_read_byte_data(client,
730 reg);
731 }
732
733 data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
734 data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
735 data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
736 data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
737
738 data->sensors_last_updated = local_jiffies;
739 data->sensors_valid = 1;
740
741 no_sensor_update:
742 if (time_before(local_jiffies, data->limits_last_updated +
743 LIMIT_REFRESH_INTERVAL)
744 && data->limits_valid)
745 goto out;
746
747 for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
748 data->temp_min[i] = i2c_smbus_read_byte_data(client,
749 ADT7462_TEMP_MIN_REG(i));
750 data->temp_max[i] = i2c_smbus_read_byte_data(client,
751 ADT7462_TEMP_MAX_REG(i));
752 }
753
754 for (i = 0; i < ADT7462_FAN_COUNT; i++)
755 data->fan_min[i] = i2c_smbus_read_byte_data(client,
756 ADT7462_REG_FAN_MIN(i));
757
758 for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
759 int reg = ADT7462_REG_VOLT_MAX(data, i);
760 data->volt_max[i] =
761 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
762
763 reg = ADT7462_REG_VOLT_MIN(data, i);
764 data->volt_min[i] =
765 (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
766 }
767
768 for (i = 0; i < ADT7462_PWM_COUNT; i++) {
769 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
770 ADT7462_REG_PWM_MIN(i));
771 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
772 ADT7462_REG_PWM_TMIN(i));
773 data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
774 ADT7462_REG_PWM_TRANGE(i));
775 data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
776 ADT7462_REG_PWM_CFG(i));
777 }
778
779 data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
780
781 data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
782
783 data->limits_last_updated = local_jiffies;
784 data->limits_valid = 1;
785
786 out:
787 mutex_unlock(&data->lock);
788 return data;
789 }
790
791 static ssize_t temp_min_show(struct device *dev,
792 struct device_attribute *devattr, char *buf)
793 {
794 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
795 struct adt7462_data *data = adt7462_update_device(dev);
796
797 if (!temp_enabled(data, attr->index))
798 return sprintf(buf, "0\n");
799
800 return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
801 }
802
803 static ssize_t temp_min_store(struct device *dev,
804 struct device_attribute *devattr,
805 const char *buf, size_t count)
806 {
807 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
808 struct adt7462_data *data = dev_get_drvdata(dev);
809 struct i2c_client *client = data->client;
810 long temp;
811
812 if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
813 return -EINVAL;
814
815 temp = clamp_val(temp, -64000, 191000);
816 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
817
818 mutex_lock(&data->lock);
819 data->temp_min[attr->index] = temp;
820 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
821 temp);
822 mutex_unlock(&data->lock);
823
824 return count;
825 }
826
827 static ssize_t temp_max_show(struct device *dev,
828 struct device_attribute *devattr, char *buf)
829 {
830 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
831 struct adt7462_data *data = adt7462_update_device(dev);
832
833 if (!temp_enabled(data, attr->index))
834 return sprintf(buf, "0\n");
835
836 return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
837 }
838
839 static ssize_t temp_max_store(struct device *dev,
840 struct device_attribute *devattr,
841 const char *buf, 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
863 static ssize_t temp_show(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
877 static ssize_t temp_label_show(struct device *dev,
878 struct device_attribute *devattr, char *buf)
879 {
880 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
881 struct adt7462_data *data = adt7462_update_device(dev);
882
883 return sprintf(buf, "%s\n", temp_label(data, attr->index));
884 }
885
886 static ssize_t volt_max_show(struct device *dev,
887 struct device_attribute *devattr, char *buf)
888 {
889 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
890 struct adt7462_data *data = adt7462_update_device(dev);
891 int x = voltage_multiplier(data, attr->index);
892
893 x *= data->volt_max[attr->index];
894 x /= 1000; /* convert from uV to mV */
895
896 return sprintf(buf, "%d\n", x);
897 }
898
899 static ssize_t volt_max_store(struct device *dev,
900 struct device_attribute *devattr,
901 const char *buf, size_t count)
902 {
903 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
904 struct adt7462_data *data = dev_get_drvdata(dev);
905 struct i2c_client *client = data->client;
906 int x = voltage_multiplier(data, attr->index);
907 long temp;
908
909 if (kstrtol(buf, 10, &temp) || !x)
910 return -EINVAL;
911
912 temp = clamp_val(temp, 0, 255 * x / 1000);
913 temp *= 1000; /* convert mV to uV */
914 temp = DIV_ROUND_CLOSEST(temp, x);
915
916 mutex_lock(&data->lock);
917 data->volt_max[attr->index] = temp;
918 i2c_smbus_write_byte_data(client,
919 ADT7462_REG_VOLT_MAX(data, attr->index),
920 temp);
921 mutex_unlock(&data->lock);
922
923 return count;
924 }
925
926 static ssize_t volt_min_show(struct device *dev,
927 struct device_attribute *devattr, char *buf)
928 {
929 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
930 struct adt7462_data *data = adt7462_update_device(dev);
931 int x = voltage_multiplier(data, attr->index);
932
933 x *= data->volt_min[attr->index];
934 x /= 1000; /* convert from uV to mV */
935
936 return sprintf(buf, "%d\n", x);
937 }
938
939 static ssize_t volt_min_store(struct device *dev,
940 struct device_attribute *devattr,
941 const char *buf, size_t count)
942 {
943 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
944 struct adt7462_data *data = dev_get_drvdata(dev);
945 struct i2c_client *client = data->client;
946 int x = voltage_multiplier(data, attr->index);
947 long temp;
948
949 if (kstrtol(buf, 10, &temp) || !x)
950 return -EINVAL;
951
952 temp = clamp_val(temp, 0, 255 * x / 1000);
953 temp *= 1000; /* convert mV to uV */
954 temp = DIV_ROUND_CLOSEST(temp, x);
955
956 mutex_lock(&data->lock);
957 data->volt_min[attr->index] = temp;
958 i2c_smbus_write_byte_data(client,
959 ADT7462_REG_VOLT_MIN(data, attr->index),
960 temp);
961 mutex_unlock(&data->lock);
962
963 return count;
964 }
965
966 static ssize_t voltage_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 int x = voltage_multiplier(data, attr->index);
972
973 x *= data->voltages[attr->index];
974 x /= 1000; /* convert from uV to mV */
975
976 return sprintf(buf, "%d\n", x);
977 }
978
979 static ssize_t voltage_label_show(struct device *dev,
980 struct device_attribute *devattr, char *buf)
981 {
982 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
983 struct adt7462_data *data = adt7462_update_device(dev);
984
985 return sprintf(buf, "%s\n", voltage_label(data, attr->index));
986 }
987
988 static ssize_t alarm_show(struct device *dev,
989 struct device_attribute *devattr, char *buf)
990 {
991 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
992 struct adt7462_data *data = adt7462_update_device(dev);
993 int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
994 int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
995
996 if (data->alarms[reg] & mask)
997 return sprintf(buf, "1\n");
998 else
999 return sprintf(buf, "0\n");
1000 }
1001
1002 static int fan_enabled(struct adt7462_data *data, int fan)
1003 {
1004 return data->fan_enabled & (1 << fan);
1005 }
1006
1007 static ssize_t fan_min_show(struct device *dev,
1008 struct device_attribute *devattr, char *buf)
1009 {
1010 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1011 struct adt7462_data *data = adt7462_update_device(dev);
1012 u16 temp;
1013
1014 /* Only the MSB of the min fan period is stored... */
1015 temp = data->fan_min[attr->index];
1016 temp <<= 8;
1017
1018 if (!fan_enabled(data, attr->index) ||
1019 !FAN_DATA_VALID(temp))
1020 return sprintf(buf, "0\n");
1021
1022 return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
1023 }
1024
1025 static ssize_t fan_min_store(struct device *dev,
1026 struct device_attribute *devattr,
1027 const char *buf, size_t count)
1028 {
1029 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1030 struct adt7462_data *data = dev_get_drvdata(dev);
1031 struct i2c_client *client = data->client;
1032 long temp;
1033
1034 if (kstrtol(buf, 10, &temp) || !temp ||
1035 !fan_enabled(data, attr->index))
1036 return -EINVAL;
1037
1038 temp = FAN_RPM_TO_PERIOD(temp);
1039 temp >>= 8;
1040 temp = clamp_val(temp, 1, 255);
1041
1042 mutex_lock(&data->lock);
1043 data->fan_min[attr->index] = temp;
1044 i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
1045 temp);
1046 mutex_unlock(&data->lock);
1047
1048 return count;
1049 }
1050
1051 static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
1052 char *buf)
1053 {
1054 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1055 struct adt7462_data *data = adt7462_update_device(dev);
1056
1057 if (!fan_enabled(data, attr->index) ||
1058 !FAN_DATA_VALID(data->fan[attr->index]))
1059 return sprintf(buf, "0\n");
1060
1061 return sprintf(buf, "%d\n",
1062 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
1063 }
1064
1065 static ssize_t force_pwm_max_show(struct device *dev,
1066 struct device_attribute *devattr, char *buf)
1067 {
1068 struct adt7462_data *data = adt7462_update_device(dev);
1069 return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
1070 }
1071
1072 static ssize_t force_pwm_max_store(struct device *dev,
1073 struct device_attribute *devattr,
1074 const char *buf, size_t count)
1075 {
1076 struct adt7462_data *data = dev_get_drvdata(dev);
1077 struct i2c_client *client = data->client;
1078 long temp;
1079 u8 reg;
1080
1081 if (kstrtol(buf, 10, &temp))
1082 return -EINVAL;
1083
1084 mutex_lock(&data->lock);
1085 reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
1086 if (temp)
1087 reg |= ADT7462_FSPD_MASK;
1088 else
1089 reg &= ~ADT7462_FSPD_MASK;
1090 data->cfg2 = reg;
1091 i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
1092 mutex_unlock(&data->lock);
1093
1094 return count;
1095 }
1096
1097 static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
1098 char *buf)
1099 {
1100 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1101 struct adt7462_data *data = adt7462_update_device(dev);
1102 return sprintf(buf, "%d\n", data->pwm[attr->index]);
1103 }
1104
1105 static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
1106 const char *buf, size_t count)
1107 {
1108 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1109 struct adt7462_data *data = dev_get_drvdata(dev);
1110 struct i2c_client *client = data->client;
1111 long temp;
1112
1113 if (kstrtol(buf, 10, &temp))
1114 return -EINVAL;
1115
1116 temp = clamp_val(temp, 0, 255);
1117
1118 mutex_lock(&data->lock);
1119 data->pwm[attr->index] = temp;
1120 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
1121 mutex_unlock(&data->lock);
1122
1123 return count;
1124 }
1125
1126 static ssize_t pwm_max_show(struct device *dev,
1127 struct device_attribute *devattr, char *buf)
1128 {
1129 struct adt7462_data *data = adt7462_update_device(dev);
1130 return sprintf(buf, "%d\n", data->pwm_max);
1131 }
1132
1133 static ssize_t pwm_max_store(struct device *dev,
1134 struct device_attribute *devattr,
1135 const char *buf, size_t count)
1136 {
1137 struct adt7462_data *data = dev_get_drvdata(dev);
1138 struct i2c_client *client = data->client;
1139 long temp;
1140
1141 if (kstrtol(buf, 10, &temp))
1142 return -EINVAL;
1143
1144 temp = clamp_val(temp, 0, 255);
1145
1146 mutex_lock(&data->lock);
1147 data->pwm_max = temp;
1148 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
1149 mutex_unlock(&data->lock);
1150
1151 return count;
1152 }
1153
1154 static ssize_t pwm_min_show(struct device *dev,
1155 struct device_attribute *devattr, char *buf)
1156 {
1157 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1158 struct adt7462_data *data = adt7462_update_device(dev);
1159 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
1160 }
1161
1162 static ssize_t pwm_min_store(struct device *dev,
1163 struct device_attribute *devattr,
1164 const char *buf, size_t count)
1165 {
1166 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1167 struct adt7462_data *data = dev_get_drvdata(dev);
1168 struct i2c_client *client = data->client;
1169 long temp;
1170
1171 if (kstrtol(buf, 10, &temp))
1172 return -EINVAL;
1173
1174 temp = clamp_val(temp, 0, 255);
1175
1176 mutex_lock(&data->lock);
1177 data->pwm_min[attr->index] = temp;
1178 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
1179 temp);
1180 mutex_unlock(&data->lock);
1181
1182 return count;
1183 }
1184
1185 static ssize_t pwm_hyst_show(struct device *dev,
1186 struct device_attribute *devattr, char *buf)
1187 {
1188 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1189 struct adt7462_data *data = adt7462_update_device(dev);
1190 return sprintf(buf, "%d\n", 1000 *
1191 (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
1192 }
1193
1194 static ssize_t pwm_hyst_store(struct device *dev,
1195 struct device_attribute *devattr,
1196 const char *buf, size_t count)
1197 {
1198 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1199 struct adt7462_data *data = dev_get_drvdata(dev);
1200 struct i2c_client *client = data->client;
1201 long temp;
1202
1203 if (kstrtol(buf, 10, &temp))
1204 return -EINVAL;
1205
1206 temp = clamp_val(temp, 0, 15000);
1207 temp = DIV_ROUND_CLOSEST(temp, 1000);
1208
1209 /* package things up */
1210 temp &= ADT7462_PWM_HYST_MASK;
1211 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
1212
1213 mutex_lock(&data->lock);
1214 data->pwm_trange[attr->index] = temp;
1215 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1216 temp);
1217 mutex_unlock(&data->lock);
1218
1219 return count;
1220 }
1221
1222 static ssize_t pwm_tmax_show(struct device *dev,
1223 struct device_attribute *devattr, char *buf)
1224 {
1225 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1226 struct adt7462_data *data = adt7462_update_device(dev);
1227
1228 /* tmax = tmin + trange */
1229 int trange = trange_values[data->pwm_trange[attr->index] >>
1230 ADT7462_PWM_RANGE_SHIFT];
1231 int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1232
1233 return sprintf(buf, "%d\n", tmin + trange);
1234 }
1235
1236 static ssize_t pwm_tmax_store(struct device *dev,
1237 struct device_attribute *devattr,
1238 const char *buf, size_t count)
1239 {
1240 int temp;
1241 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1242 struct adt7462_data *data = dev_get_drvdata(dev);
1243 struct i2c_client *client = data->client;
1244 int tmin, trange_value;
1245 long trange;
1246
1247 if (kstrtol(buf, 10, &trange))
1248 return -EINVAL;
1249
1250 /* trange = tmax - tmin */
1251 tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1252 trange_value = find_trange_value(trange - tmin);
1253 if (trange_value < 0)
1254 return trange_value;
1255
1256 temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
1257 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
1258
1259 mutex_lock(&data->lock);
1260 data->pwm_trange[attr->index] = temp;
1261 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1262 temp);
1263 mutex_unlock(&data->lock);
1264
1265 return count;
1266 }
1267
1268 static ssize_t pwm_tmin_show(struct device *dev,
1269 struct device_attribute *devattr, char *buf)
1270 {
1271 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1272 struct adt7462_data *data = adt7462_update_device(dev);
1273 return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
1274 }
1275
1276 static ssize_t pwm_tmin_store(struct device *dev,
1277 struct device_attribute *devattr,
1278 const char *buf, size_t count)
1279 {
1280 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1281 struct adt7462_data *data = dev_get_drvdata(dev);
1282 struct i2c_client *client = data->client;
1283 long temp;
1284
1285 if (kstrtol(buf, 10, &temp))
1286 return -EINVAL;
1287
1288 temp = clamp_val(temp, -64000, 191000);
1289 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
1290
1291 mutex_lock(&data->lock);
1292 data->pwm_tmin[attr->index] = temp;
1293 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
1294 temp);
1295 mutex_unlock(&data->lock);
1296
1297 return count;
1298 }
1299
1300 static ssize_t pwm_auto_show(struct device *dev,
1301 struct device_attribute *devattr, char *buf)
1302 {
1303 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1304 struct adt7462_data *data = adt7462_update_device(dev);
1305 int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1306
1307 switch (cfg) {
1308 case 4: /* off */
1309 return sprintf(buf, "0\n");
1310 case 7: /* manual */
1311 return sprintf(buf, "1\n");
1312 default: /* automatic */
1313 return sprintf(buf, "2\n");
1314 }
1315 }
1316
1317 static void set_pwm_channel(struct i2c_client *client,
1318 struct adt7462_data *data,
1319 int which,
1320 int value)
1321 {
1322 int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
1323 temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
1324
1325 mutex_lock(&data->lock);
1326 data->pwm_cfg[which] = temp;
1327 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
1328 mutex_unlock(&data->lock);
1329 }
1330
1331 static ssize_t pwm_auto_store(struct device *dev,
1332 struct device_attribute *devattr,
1333 const char *buf, size_t count)
1334 {
1335 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1336 struct adt7462_data *data = dev_get_drvdata(dev);
1337 struct i2c_client *client = data->client;
1338 long temp;
1339
1340 if (kstrtol(buf, 10, &temp))
1341 return -EINVAL;
1342
1343 switch (temp) {
1344 case 0: /* off */
1345 set_pwm_channel(client, data, attr->index, 4);
1346 return count;
1347 case 1: /* manual */
1348 set_pwm_channel(client, data, attr->index, 7);
1349 return count;
1350 default:
1351 return -EINVAL;
1352 }
1353 }
1354
1355 static ssize_t pwm_auto_temp_show(struct device *dev,
1356 struct device_attribute *devattr, char *buf)
1357 {
1358 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1359 struct adt7462_data *data = adt7462_update_device(dev);
1360 int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1361
1362 switch (channel) {
1363 case 0: /* temp[1234] only */
1364 case 1:
1365 case 2:
1366 case 3:
1367 return sprintf(buf, "%d\n", (1 << channel));
1368 case 5: /* temp1 & temp4 */
1369 return sprintf(buf, "9\n");
1370 case 6:
1371 return sprintf(buf, "15\n");
1372 default:
1373 return sprintf(buf, "0\n");
1374 }
1375 }
1376
1377 static int cvt_auto_temp(int input)
1378 {
1379 if (input == 0xF)
1380 return 6;
1381 if (input == 0x9)
1382 return 5;
1383 if (input < 1 || !is_power_of_2(input))
1384 return -EINVAL;
1385 return ilog2(input);
1386 }
1387
1388 static ssize_t pwm_auto_temp_store(struct device *dev,
1389 struct device_attribute *devattr,
1390 const char *buf, size_t count)
1391 {
1392 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1393 struct adt7462_data *data = dev_get_drvdata(dev);
1394 struct i2c_client *client = data->client;
1395 long temp;
1396
1397 if (kstrtol(buf, 10, &temp))
1398 return -EINVAL;
1399
1400 temp = cvt_auto_temp(temp);
1401 if (temp < 0)
1402 return temp;
1403
1404 set_pwm_channel(client, data, attr->index, temp);
1405
1406 return count;
1407 }
1408
1409 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
1410 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
1411 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
1412 static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
1413
1414 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
1415 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
1416 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
1417 static SENSOR_DEVICE_ATTR_RW(temp4_min, temp_min, 3);
1418
1419 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
1420 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
1421 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
1422 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
1423
1424 static SENSOR_DEVICE_ATTR_RO(temp1_label, temp_label, 0);
1425 static SENSOR_DEVICE_ATTR_RO(temp2_label, temp_label, 1);
1426 static SENSOR_DEVICE_ATTR_RO(temp3_label, temp_label, 2);
1427 static SENSOR_DEVICE_ATTR_RO(temp4_label, temp_label, 3);
1428
1429 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm,
1430 ADT7462_ALARM1 | ADT7462_LT_ALARM);
1431 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm,
1432 ADT7462_ALARM1 | ADT7462_R1T_ALARM);
1433 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm,
1434 ADT7462_ALARM1 | ADT7462_R2T_ALARM);
1435 static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm,
1436 ADT7462_ALARM1 | ADT7462_R3T_ALARM);
1437
1438 static SENSOR_DEVICE_ATTR_RW(in1_max, volt_max, 0);
1439 static SENSOR_DEVICE_ATTR_RW(in2_max, volt_max, 1);
1440 static SENSOR_DEVICE_ATTR_RW(in3_max, volt_max, 2);
1441 static SENSOR_DEVICE_ATTR_RW(in4_max, volt_max, 3);
1442 static SENSOR_DEVICE_ATTR_RW(in5_max, volt_max, 4);
1443 static SENSOR_DEVICE_ATTR_RW(in6_max, volt_max, 5);
1444 static SENSOR_DEVICE_ATTR_RW(in7_max, volt_max, 6);
1445 static SENSOR_DEVICE_ATTR_RW(in8_max, volt_max, 7);
1446 static SENSOR_DEVICE_ATTR_RW(in9_max, volt_max, 8);
1447 static SENSOR_DEVICE_ATTR_RW(in10_max, volt_max, 9);
1448 static SENSOR_DEVICE_ATTR_RW(in11_max, volt_max, 10);
1449 static SENSOR_DEVICE_ATTR_RW(in12_max, volt_max, 11);
1450 static SENSOR_DEVICE_ATTR_RW(in13_max, volt_max, 12);
1451
1452 static SENSOR_DEVICE_ATTR_RW(in1_min, volt_min, 0);
1453 static SENSOR_DEVICE_ATTR_RW(in2_min, volt_min, 1);
1454 static SENSOR_DEVICE_ATTR_RW(in3_min, volt_min, 2);
1455 static SENSOR_DEVICE_ATTR_RW(in4_min, volt_min, 3);
1456 static SENSOR_DEVICE_ATTR_RW(in5_min, volt_min, 4);
1457 static SENSOR_DEVICE_ATTR_RW(in6_min, volt_min, 5);
1458 static SENSOR_DEVICE_ATTR_RW(in7_min, volt_min, 6);
1459 static SENSOR_DEVICE_ATTR_RW(in8_min, volt_min, 7);
1460 static SENSOR_DEVICE_ATTR_RW(in9_min, volt_min, 8);
1461 static SENSOR_DEVICE_ATTR_RW(in10_min, volt_min, 9);
1462 static SENSOR_DEVICE_ATTR_RW(in11_min, volt_min, 10);
1463 static SENSOR_DEVICE_ATTR_RW(in12_min, volt_min, 11);
1464 static SENSOR_DEVICE_ATTR_RW(in13_min, volt_min, 12);
1465
1466 static SENSOR_DEVICE_ATTR_RO(in1_input, voltage, 0);
1467 static SENSOR_DEVICE_ATTR_RO(in2_input, voltage, 1);
1468 static SENSOR_DEVICE_ATTR_RO(in3_input, voltage, 2);
1469 static SENSOR_DEVICE_ATTR_RO(in4_input, voltage, 3);
1470 static SENSOR_DEVICE_ATTR_RO(in5_input, voltage, 4);
1471 static SENSOR_DEVICE_ATTR_RO(in6_input, voltage, 5);
1472 static SENSOR_DEVICE_ATTR_RO(in7_input, voltage, 6);
1473 static SENSOR_DEVICE_ATTR_RO(in8_input, voltage, 7);
1474 static SENSOR_DEVICE_ATTR_RO(in9_input, voltage, 8);
1475 static SENSOR_DEVICE_ATTR_RO(in10_input, voltage, 9);
1476 static SENSOR_DEVICE_ATTR_RO(in11_input, voltage, 10);
1477 static SENSOR_DEVICE_ATTR_RO(in12_input, voltage, 11);
1478 static SENSOR_DEVICE_ATTR_RO(in13_input, voltage, 12);
1479
1480 static SENSOR_DEVICE_ATTR_RO(in1_label, voltage_label, 0);
1481 static SENSOR_DEVICE_ATTR_RO(in2_label, voltage_label, 1);
1482 static SENSOR_DEVICE_ATTR_RO(in3_label, voltage_label, 2);
1483 static SENSOR_DEVICE_ATTR_RO(in4_label, voltage_label, 3);
1484 static SENSOR_DEVICE_ATTR_RO(in5_label, voltage_label, 4);
1485 static SENSOR_DEVICE_ATTR_RO(in6_label, voltage_label, 5);
1486 static SENSOR_DEVICE_ATTR_RO(in7_label, voltage_label, 6);
1487 static SENSOR_DEVICE_ATTR_RO(in8_label, voltage_label, 7);
1488 static SENSOR_DEVICE_ATTR_RO(in9_label, voltage_label, 8);
1489 static SENSOR_DEVICE_ATTR_RO(in10_label, voltage_label, 9);
1490 static SENSOR_DEVICE_ATTR_RO(in11_label, voltage_label, 10);
1491 static SENSOR_DEVICE_ATTR_RO(in12_label, voltage_label, 11);
1492 static SENSOR_DEVICE_ATTR_RO(in13_label, voltage_label, 12);
1493
1494 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm,
1495 ADT7462_ALARM2 | ADT7462_V0_ALARM);
1496 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm,
1497 ADT7462_ALARM2 | ADT7462_V7_ALARM);
1498 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm,
1499 ADT7462_ALARM2 | ADT7462_V2_ALARM);
1500 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm,
1501 ADT7462_ALARM2 | ADT7462_V6_ALARM);
1502 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm,
1503 ADT7462_ALARM2 | ADT7462_V5_ALARM);
1504 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm,
1505 ADT7462_ALARM2 | ADT7462_V4_ALARM);
1506 static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm,
1507 ADT7462_ALARM2 | ADT7462_V3_ALARM);
1508 static SENSOR_DEVICE_ATTR_RO(in8_alarm, alarm,
1509 ADT7462_ALARM2 | ADT7462_V1_ALARM);
1510 static SENSOR_DEVICE_ATTR_RO(in9_alarm, alarm,
1511 ADT7462_ALARM3 | ADT7462_V10_ALARM);
1512 static SENSOR_DEVICE_ATTR_RO(in10_alarm, alarm,
1513 ADT7462_ALARM3 | ADT7462_V9_ALARM);
1514 static SENSOR_DEVICE_ATTR_RO(in11_alarm, alarm,
1515 ADT7462_ALARM3 | ADT7462_V8_ALARM);
1516 static SENSOR_DEVICE_ATTR_RO(in12_alarm, alarm,
1517 ADT7462_ALARM3 | ADT7462_V11_ALARM);
1518 static SENSOR_DEVICE_ATTR_RO(in13_alarm, alarm,
1519 ADT7462_ALARM3 | ADT7462_V12_ALARM);
1520
1521 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
1522 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
1523 static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
1524 static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
1525 static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4);
1526 static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5);
1527 static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6);
1528 static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7);
1529
1530 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
1531 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
1532 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
1533 static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
1534 static SENSOR_DEVICE_ATTR_RO(fan5_input, fan, 4);
1535 static SENSOR_DEVICE_ATTR_RO(fan6_input, fan, 5);
1536 static SENSOR_DEVICE_ATTR_RO(fan7_input, fan, 6);
1537 static SENSOR_DEVICE_ATTR_RO(fan8_input, fan, 7);
1538
1539 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm,
1540 ADT7462_ALARM4 | ADT7462_F0_ALARM);
1541 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm,
1542 ADT7462_ALARM4 | ADT7462_F1_ALARM);
1543 static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm,
1544 ADT7462_ALARM4 | ADT7462_F2_ALARM);
1545 static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm,
1546 ADT7462_ALARM4 | ADT7462_F3_ALARM);
1547 static SENSOR_DEVICE_ATTR_RO(fan5_alarm, alarm,
1548 ADT7462_ALARM4 | ADT7462_F4_ALARM);
1549 static SENSOR_DEVICE_ATTR_RO(fan6_alarm, alarm,
1550 ADT7462_ALARM4 | ADT7462_F5_ALARM);
1551 static SENSOR_DEVICE_ATTR_RO(fan7_alarm, alarm,
1552 ADT7462_ALARM4 | ADT7462_F6_ALARM);
1553 static SENSOR_DEVICE_ATTR_RO(fan8_alarm, alarm,
1554 ADT7462_ALARM4 | ADT7462_F7_ALARM);
1555
1556 static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0);
1557
1558 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
1559 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
1560 static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);
1561 static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);
1562
1563 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0);
1564 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1);
1565 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2);
1566 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3);
1567
1568 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0);
1569 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1);
1570 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2);
1571 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3);
1572
1573 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_hyst, pwm_hyst, 0);
1574 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_hyst, pwm_hyst, 1);
1575 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_hyst, pwm_hyst, 2);
1576 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_hyst, pwm_hyst, 3);
1577
1578 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_hyst, pwm_hyst, 0);
1579 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_hyst, pwm_hyst, 1);
1580 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_hyst, pwm_hyst, 2);
1581 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_hyst, pwm_hyst, 3);
1582
1583 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_temp, pwm_tmin, 0);
1584 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_temp, pwm_tmin, 1);
1585 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_temp, pwm_tmin, 2);
1586 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_temp, pwm_tmin, 3);
1587
1588 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_temp, pwm_tmax, 0);
1589 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_temp, pwm_tmax, 1);
1590 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_temp, pwm_tmax, 2);
1591 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_temp, pwm_tmax, 3);
1592
1593 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_auto, 0);
1594 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_auto, 1);
1595 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_auto, 2);
1596 static SENSOR_DEVICE_ATTR_RW(pwm4_enable, pwm_auto, 3);
1597
1598 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0);
1599 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1);
1600 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2);
1601 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3);
1602
1603 static struct attribute *adt7462_attrs[] = {
1604 &sensor_dev_attr_temp1_max.dev_attr.attr,
1605 &sensor_dev_attr_temp2_max.dev_attr.attr,
1606 &sensor_dev_attr_temp3_max.dev_attr.attr,
1607 &sensor_dev_attr_temp4_max.dev_attr.attr,
1608
1609 &sensor_dev_attr_temp1_min.dev_attr.attr,
1610 &sensor_dev_attr_temp2_min.dev_attr.attr,
1611 &sensor_dev_attr_temp3_min.dev_attr.attr,
1612 &sensor_dev_attr_temp4_min.dev_attr.attr,
1613
1614 &sensor_dev_attr_temp1_input.dev_attr.attr,
1615 &sensor_dev_attr_temp2_input.dev_attr.attr,
1616 &sensor_dev_attr_temp3_input.dev_attr.attr,
1617 &sensor_dev_attr_temp4_input.dev_attr.attr,
1618
1619 &sensor_dev_attr_temp1_label.dev_attr.attr,
1620 &sensor_dev_attr_temp2_label.dev_attr.attr,
1621 &sensor_dev_attr_temp3_label.dev_attr.attr,
1622 &sensor_dev_attr_temp4_label.dev_attr.attr,
1623
1624 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1625 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1626 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1627 &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1628
1629 &sensor_dev_attr_in1_max.dev_attr.attr,
1630 &sensor_dev_attr_in2_max.dev_attr.attr,
1631 &sensor_dev_attr_in3_max.dev_attr.attr,
1632 &sensor_dev_attr_in4_max.dev_attr.attr,
1633 &sensor_dev_attr_in5_max.dev_attr.attr,
1634 &sensor_dev_attr_in6_max.dev_attr.attr,
1635 &sensor_dev_attr_in7_max.dev_attr.attr,
1636 &sensor_dev_attr_in8_max.dev_attr.attr,
1637 &sensor_dev_attr_in9_max.dev_attr.attr,
1638 &sensor_dev_attr_in10_max.dev_attr.attr,
1639 &sensor_dev_attr_in11_max.dev_attr.attr,
1640 &sensor_dev_attr_in12_max.dev_attr.attr,
1641 &sensor_dev_attr_in13_max.dev_attr.attr,
1642
1643 &sensor_dev_attr_in1_min.dev_attr.attr,
1644 &sensor_dev_attr_in2_min.dev_attr.attr,
1645 &sensor_dev_attr_in3_min.dev_attr.attr,
1646 &sensor_dev_attr_in4_min.dev_attr.attr,
1647 &sensor_dev_attr_in5_min.dev_attr.attr,
1648 &sensor_dev_attr_in6_min.dev_attr.attr,
1649 &sensor_dev_attr_in7_min.dev_attr.attr,
1650 &sensor_dev_attr_in8_min.dev_attr.attr,
1651 &sensor_dev_attr_in9_min.dev_attr.attr,
1652 &sensor_dev_attr_in10_min.dev_attr.attr,
1653 &sensor_dev_attr_in11_min.dev_attr.attr,
1654 &sensor_dev_attr_in12_min.dev_attr.attr,
1655 &sensor_dev_attr_in13_min.dev_attr.attr,
1656
1657 &sensor_dev_attr_in1_input.dev_attr.attr,
1658 &sensor_dev_attr_in2_input.dev_attr.attr,
1659 &sensor_dev_attr_in3_input.dev_attr.attr,
1660 &sensor_dev_attr_in4_input.dev_attr.attr,
1661 &sensor_dev_attr_in5_input.dev_attr.attr,
1662 &sensor_dev_attr_in6_input.dev_attr.attr,
1663 &sensor_dev_attr_in7_input.dev_attr.attr,
1664 &sensor_dev_attr_in8_input.dev_attr.attr,
1665 &sensor_dev_attr_in9_input.dev_attr.attr,
1666 &sensor_dev_attr_in10_input.dev_attr.attr,
1667 &sensor_dev_attr_in11_input.dev_attr.attr,
1668 &sensor_dev_attr_in12_input.dev_attr.attr,
1669 &sensor_dev_attr_in13_input.dev_attr.attr,
1670
1671 &sensor_dev_attr_in1_label.dev_attr.attr,
1672 &sensor_dev_attr_in2_label.dev_attr.attr,
1673 &sensor_dev_attr_in3_label.dev_attr.attr,
1674 &sensor_dev_attr_in4_label.dev_attr.attr,
1675 &sensor_dev_attr_in5_label.dev_attr.attr,
1676 &sensor_dev_attr_in6_label.dev_attr.attr,
1677 &sensor_dev_attr_in7_label.dev_attr.attr,
1678 &sensor_dev_attr_in8_label.dev_attr.attr,
1679 &sensor_dev_attr_in9_label.dev_attr.attr,
1680 &sensor_dev_attr_in10_label.dev_attr.attr,
1681 &sensor_dev_attr_in11_label.dev_attr.attr,
1682 &sensor_dev_attr_in12_label.dev_attr.attr,
1683 &sensor_dev_attr_in13_label.dev_attr.attr,
1684
1685 &sensor_dev_attr_in1_alarm.dev_attr.attr,
1686 &sensor_dev_attr_in2_alarm.dev_attr.attr,
1687 &sensor_dev_attr_in3_alarm.dev_attr.attr,
1688 &sensor_dev_attr_in4_alarm.dev_attr.attr,
1689 &sensor_dev_attr_in5_alarm.dev_attr.attr,
1690 &sensor_dev_attr_in6_alarm.dev_attr.attr,
1691 &sensor_dev_attr_in7_alarm.dev_attr.attr,
1692 &sensor_dev_attr_in8_alarm.dev_attr.attr,
1693 &sensor_dev_attr_in9_alarm.dev_attr.attr,
1694 &sensor_dev_attr_in10_alarm.dev_attr.attr,
1695 &sensor_dev_attr_in11_alarm.dev_attr.attr,
1696 &sensor_dev_attr_in12_alarm.dev_attr.attr,
1697 &sensor_dev_attr_in13_alarm.dev_attr.attr,
1698
1699 &sensor_dev_attr_fan1_min.dev_attr.attr,
1700 &sensor_dev_attr_fan2_min.dev_attr.attr,
1701 &sensor_dev_attr_fan3_min.dev_attr.attr,
1702 &sensor_dev_attr_fan4_min.dev_attr.attr,
1703 &sensor_dev_attr_fan5_min.dev_attr.attr,
1704 &sensor_dev_attr_fan6_min.dev_attr.attr,
1705 &sensor_dev_attr_fan7_min.dev_attr.attr,
1706 &sensor_dev_attr_fan8_min.dev_attr.attr,
1707
1708 &sensor_dev_attr_fan1_input.dev_attr.attr,
1709 &sensor_dev_attr_fan2_input.dev_attr.attr,
1710 &sensor_dev_attr_fan3_input.dev_attr.attr,
1711 &sensor_dev_attr_fan4_input.dev_attr.attr,
1712 &sensor_dev_attr_fan5_input.dev_attr.attr,
1713 &sensor_dev_attr_fan6_input.dev_attr.attr,
1714 &sensor_dev_attr_fan7_input.dev_attr.attr,
1715 &sensor_dev_attr_fan8_input.dev_attr.attr,
1716
1717 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1718 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1719 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1720 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1721 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1722 &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1723 &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1724 &sensor_dev_attr_fan8_alarm.dev_attr.attr,
1725
1726 &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1727 &sensor_dev_attr_pwm1.dev_attr.attr,
1728 &sensor_dev_attr_pwm2.dev_attr.attr,
1729 &sensor_dev_attr_pwm3.dev_attr.attr,
1730 &sensor_dev_attr_pwm4.dev_attr.attr,
1731
1732 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1733 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1734 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1735 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1736
1737 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1738 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1739 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1740 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1741
1742 &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
1743 &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
1744 &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
1745 &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
1746
1747 &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
1748 &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
1749 &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
1750 &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
1751
1752 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1753 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1754 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1755 &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
1756
1757 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1758 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1759 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1760 &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
1761
1762 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1763 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1764 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1765 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1766
1767 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1768 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1769 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1770 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1771 NULL
1772 };
1773
1774 ATTRIBUTE_GROUPS(adt7462);
1775
1776 /* Return 0 if detection is successful, -ENODEV otherwise */
1777 static int adt7462_detect(struct i2c_client *client,
1778 struct i2c_board_info *info)
1779 {
1780 struct i2c_adapter *adapter = client->adapter;
1781 int vendor, device, revision;
1782
1783 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1784 return -ENODEV;
1785
1786 vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
1787 if (vendor != ADT7462_VENDOR)
1788 return -ENODEV;
1789
1790 device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
1791 if (device != ADT7462_DEVICE)
1792 return -ENODEV;
1793
1794 revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION);
1795 if (revision != ADT7462_REVISION)
1796 return -ENODEV;
1797
1798 strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
1799
1800 return 0;
1801 }
1802
1803 static int adt7462_probe(struct i2c_client *client,
1804 const struct i2c_device_id *id)
1805 {
1806 struct device *dev = &client->dev;
1807 struct adt7462_data *data;
1808 struct device *hwmon_dev;
1809
1810 data = devm_kzalloc(dev, sizeof(struct adt7462_data), GFP_KERNEL);
1811 if (!data)
1812 return -ENOMEM;
1813
1814 data->client = client;
1815 mutex_init(&data->lock);
1816
1817 dev_info(&client->dev, "%s chip found\n", client->name);
1818
1819 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1820 data,
1821 adt7462_groups);
1822 return PTR_ERR_OR_ZERO(hwmon_dev);
1823 }
1824
1825 static const struct i2c_device_id adt7462_id[] = {
1826 { "adt7462", 0 },
1827 { }
1828 };
1829 MODULE_DEVICE_TABLE(i2c, adt7462_id);
1830
1831 static struct i2c_driver adt7462_driver = {
1832 .class = I2C_CLASS_HWMON,
1833 .driver = {
1834 .name = "adt7462",
1835 },
1836 .probe = adt7462_probe,
1837 .id_table = adt7462_id,
1838 .detect = adt7462_detect,
1839 .address_list = normal_i2c,
1840 };
1841
1842 module_i2c_driver(adt7462_driver);
1843
1844 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1845 MODULE_DESCRIPTION("ADT7462 driver");
1846 MODULE_LICENSE("GPL");
Ubuntu Jammy Linux kernel mirror