2 * nct7802 - Driver for Nuvoton NCT7802Y
4 * Copyright (C) 2014 Guenter Roeck <linux@roeck-us.net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19 #include <linux/err.h>
20 #include <linux/i2c.h>
21 #include <linux/init.h>
22 #include <linux/hwmon.h>
23 #include <linux/hwmon-sysfs.h>
24 #include <linux/jiffies.h>
25 #include <linux/module.h>
26 #include <linux/mutex.h>
27 #include <linux/regmap.h>
28 #include <linux/slab.h>
30 #define DRVNAME "nct7802"
32 static const u8 REG_VOLTAGE
[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e };
34 static const u8 REG_VOLTAGE_LIMIT_LSB
[2][5] = {
35 { 0x40, 0x00, 0x42, 0x44, 0x46 },
36 { 0x3f, 0x00, 0x41, 0x43, 0x45 },
39 static const u8 REG_VOLTAGE_LIMIT_MSB
[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };
41 static const u8 REG_VOLTAGE_LIMIT_MSB_SHIFT
[2][5] = {
47 #define REG_TEMP_LSB 0x05
48 #define REG_TEMP_PECI_LSB 0x08
49 #define REG_VOLTAGE_LOW 0x0f
50 #define REG_FANCOUNT_LOW 0x13
51 #define REG_START 0x21
52 #define REG_MODE 0x22 /* 7.2.32 Mode Selection Register */
53 #define REG_PECI_ENABLE 0x23
54 #define REG_FAN_ENABLE 0x24
55 #define REG_VMON_ENABLE 0x25
56 #define REG_VENDOR_ID 0xfd
57 #define REG_CHIP_ID 0xfe
58 #define REG_VERSION_ID 0xff
61 * Data structures and manipulation thereof
65 struct regmap
*regmap
;
66 struct mutex access_lock
; /* for multi-byte read and write operations */
69 static ssize_t
show_temp_type(struct device
*dev
, struct device_attribute
*attr
,
72 struct nct7802_data
*data
= dev_get_drvdata(dev
);
73 struct sensor_device_attribute
*sattr
= to_sensor_dev_attr(attr
);
77 ret
= regmap_read(data
->regmap
, REG_MODE
, &mode
);
81 return sprintf(buf
, "%u\n", (mode
>> (2 * sattr
->index
) & 3) + 2);
84 static ssize_t
store_temp_type(struct device
*dev
,
85 struct device_attribute
*attr
,
86 const char *buf
, size_t count
)
88 struct nct7802_data
*data
= dev_get_drvdata(dev
);
89 struct sensor_device_attribute
*sattr
= to_sensor_dev_attr(attr
);
93 err
= kstrtouint(buf
, 0, &type
);
96 if (sattr
->index
== 2 && type
!= 4) /* RD3 */
98 if (type
< 3 || type
> 4)
100 err
= regmap_update_bits(data
->regmap
, REG_MODE
,
101 3 << 2 * sattr
->index
, (type
- 2) << 2 * sattr
->index
);
102 return err
? : count
;
105 static ssize_t
show_pwm_mode(struct device
*dev
, struct device_attribute
*attr
,
108 struct sensor_device_attribute
*sattr
= to_sensor_dev_attr(attr
);
109 struct nct7802_data
*data
= dev_get_drvdata(dev
);
113 if (sattr
->index
> 1)
114 return sprintf(buf
, "1\n");
116 ret
= regmap_read(data
->regmap
, 0x5E, ®val
);
120 return sprintf(buf
, "%u\n", !(regval
& (1 << sattr
->index
)));
123 static ssize_t
show_pwm(struct device
*dev
, struct device_attribute
*devattr
,
126 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
127 struct nct7802_data
*data
= dev_get_drvdata(dev
);
131 ret
= regmap_read(data
->regmap
, attr
->index
, &val
);
135 return sprintf(buf
, "%d\n", val
);
138 static ssize_t
store_pwm(struct device
*dev
, struct device_attribute
*devattr
,
139 const char *buf
, size_t count
)
141 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
142 struct nct7802_data
*data
= dev_get_drvdata(dev
);
146 err
= kstrtou8(buf
, 0, &val
);
150 err
= regmap_write(data
->regmap
, attr
->index
, val
);
151 return err
? : count
;
154 static int nct7802_read_temp(struct nct7802_data
*data
,
155 u8 reg_temp
, u8 reg_temp_low
, int *temp
)
157 unsigned int t1
, t2
= 0;
162 mutex_lock(&data
->access_lock
);
163 err
= regmap_read(data
->regmap
, reg_temp
, &t1
);
167 if (reg_temp_low
) { /* 11 bit data */
168 err
= regmap_read(data
->regmap
, reg_temp_low
, &t2
);
173 *temp
= (s16
)t1
/ 32 * 125;
175 mutex_unlock(&data
->access_lock
);
179 static int nct7802_read_fan(struct nct7802_data
*data
, u8 reg_fan
)
184 mutex_lock(&data
->access_lock
);
185 ret
= regmap_read(data
->regmap
, reg_fan
, &f1
);
188 ret
= regmap_read(data
->regmap
, REG_FANCOUNT_LOW
, &f2
);
191 ret
= (f1
<< 5) | (f2
>> 3);
192 /* convert fan count to rpm */
193 if (ret
== 0x1fff) /* maximum value, assume fan is stopped */
196 ret
= DIV_ROUND_CLOSEST(1350000U, ret
);
198 mutex_unlock(&data
->access_lock
);
202 static int nct7802_read_fan_min(struct nct7802_data
*data
, u8 reg_fan_low
,
208 mutex_lock(&data
->access_lock
);
209 ret
= regmap_read(data
->regmap
, reg_fan_low
, &f1
);
212 ret
= regmap_read(data
->regmap
, reg_fan_high
, &f2
);
215 ret
= f1
| ((f2
& 0xf8) << 5);
216 /* convert fan count to rpm */
217 if (ret
== 0x1fff) /* maximum value, assume no limit */
220 ret
= DIV_ROUND_CLOSEST(1350000U, ret
);
222 mutex_unlock(&data
->access_lock
);
226 static int nct7802_write_fan_min(struct nct7802_data
*data
, u8 reg_fan_low
,
227 u8 reg_fan_high
, unsigned int limit
)
232 limit
= DIV_ROUND_CLOSEST(1350000U, limit
);
235 limit
= clamp_val(limit
, 0, 0x1fff);
237 mutex_lock(&data
->access_lock
);
238 err
= regmap_write(data
->regmap
, reg_fan_low
, limit
& 0xff);
242 err
= regmap_write(data
->regmap
, reg_fan_high
, (limit
& 0x1f00) >> 5);
244 mutex_unlock(&data
->access_lock
);
248 static u8 nct7802_vmul
[] = { 4, 2, 2, 2, 2 };
250 static int nct7802_read_voltage(struct nct7802_data
*data
, int nr
, int index
)
255 mutex_lock(&data
->access_lock
);
256 if (index
== 0) { /* voltage */
257 ret
= regmap_read(data
->regmap
, REG_VOLTAGE
[nr
], &v1
);
260 ret
= regmap_read(data
->regmap
, REG_VOLTAGE_LOW
, &v2
);
263 ret
= ((v1
<< 2) | (v2
>> 6)) * nct7802_vmul
[nr
];
265 int shift
= 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT
[index
- 1][nr
];
267 ret
= regmap_read(data
->regmap
,
268 REG_VOLTAGE_LIMIT_LSB
[index
- 1][nr
], &v1
);
271 ret
= regmap_read(data
->regmap
, REG_VOLTAGE_LIMIT_MSB
[nr
],
275 ret
= (v1
| ((v2
<< shift
) & 0x300)) * nct7802_vmul
[nr
];
278 mutex_unlock(&data
->access_lock
);
282 static int nct7802_write_voltage(struct nct7802_data
*data
, int nr
, int index
,
283 unsigned long voltage
)
285 int shift
= 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT
[index
- 1][nr
];
288 voltage
= DIV_ROUND_CLOSEST(voltage
, nct7802_vmul
[nr
]);
289 voltage
= clamp_val(voltage
, 0, 0x3ff);
291 mutex_lock(&data
->access_lock
);
292 err
= regmap_write(data
->regmap
,
293 REG_VOLTAGE_LIMIT_LSB
[index
- 1][nr
],
298 err
= regmap_update_bits(data
->regmap
, REG_VOLTAGE_LIMIT_MSB
[nr
],
299 0x0300 >> shift
, (voltage
& 0x0300) >> shift
);
301 mutex_unlock(&data
->access_lock
);
305 static ssize_t
show_in(struct device
*dev
, struct device_attribute
*attr
,
308 struct sensor_device_attribute_2
*sattr
= to_sensor_dev_attr_2(attr
);
309 struct nct7802_data
*data
= dev_get_drvdata(dev
);
312 voltage
= nct7802_read_voltage(data
, sattr
->nr
, sattr
->index
);
316 return sprintf(buf
, "%d\n", voltage
);
319 static ssize_t
store_in(struct device
*dev
, struct device_attribute
*attr
,
320 const char *buf
, size_t count
)
322 struct sensor_device_attribute_2
*sattr
= to_sensor_dev_attr_2(attr
);
323 struct nct7802_data
*data
= dev_get_drvdata(dev
);
324 int index
= sattr
->index
;
329 err
= kstrtoul(buf
, 10, &val
);
333 err
= nct7802_write_voltage(data
, nr
, index
, val
);
334 return err
? : count
;
337 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*attr
,
340 struct nct7802_data
*data
= dev_get_drvdata(dev
);
341 struct sensor_device_attribute_2
*sattr
= to_sensor_dev_attr_2(attr
);
344 err
= nct7802_read_temp(data
, sattr
->nr
, sattr
->index
, &temp
);
348 return sprintf(buf
, "%d\n", temp
);
351 static ssize_t
store_temp(struct device
*dev
, struct device_attribute
*attr
,
352 const char *buf
, size_t count
)
354 struct sensor_device_attribute_2
*sattr
= to_sensor_dev_attr_2(attr
);
355 struct nct7802_data
*data
= dev_get_drvdata(dev
);
360 err
= kstrtol(buf
, 10, &val
);
364 val
= clamp_val(DIV_ROUND_CLOSEST(val
, 1000), -128, 127);
366 err
= regmap_write(data
->regmap
, nr
, val
& 0xff);
367 return err
? : count
;
370 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*attr
,
373 struct sensor_device_attribute
*sattr
= to_sensor_dev_attr(attr
);
374 struct nct7802_data
*data
= dev_get_drvdata(dev
);
377 speed
= nct7802_read_fan(data
, sattr
->index
);
381 return sprintf(buf
, "%d\n", speed
);
384 static ssize_t
show_fan_min(struct device
*dev
, struct device_attribute
*attr
,
387 struct sensor_device_attribute_2
*sattr
= to_sensor_dev_attr_2(attr
);
388 struct nct7802_data
*data
= dev_get_drvdata(dev
);
391 speed
= nct7802_read_fan_min(data
, sattr
->nr
, sattr
->index
);
395 return sprintf(buf
, "%d\n", speed
);
398 static ssize_t
store_fan_min(struct device
*dev
, struct device_attribute
*attr
,
399 const char *buf
, size_t count
)
401 struct sensor_device_attribute_2
*sattr
= to_sensor_dev_attr_2(attr
);
402 struct nct7802_data
*data
= dev_get_drvdata(dev
);
406 err
= kstrtoul(buf
, 10, &val
);
410 err
= nct7802_write_fan_min(data
, sattr
->nr
, sattr
->index
, val
);
411 return err
? : count
;
414 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*attr
,
417 struct nct7802_data
*data
= dev_get_drvdata(dev
);
418 struct sensor_device_attribute_2
*sattr
= to_sensor_dev_attr_2(attr
);
419 int bit
= sattr
->index
;
423 ret
= regmap_read(data
->regmap
, sattr
->nr
, &val
);
427 return sprintf(buf
, "%u\n", !!(val
& (1 << bit
)));
431 show_beep(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
433 struct sensor_device_attribute_2
*sattr
= to_sensor_dev_attr_2(attr
);
434 struct nct7802_data
*data
= dev_get_drvdata(dev
);
438 err
= regmap_read(data
->regmap
, sattr
->nr
, ®val
);
442 return sprintf(buf
, "%u\n", !!(regval
& (1 << sattr
->index
)));
446 store_beep(struct device
*dev
, struct device_attribute
*attr
, const char *buf
,
449 struct sensor_device_attribute_2
*sattr
= to_sensor_dev_attr_2(attr
);
450 struct nct7802_data
*data
= dev_get_drvdata(dev
);
454 err
= kstrtoul(buf
, 10, &val
);
460 err
= regmap_update_bits(data
->regmap
, sattr
->nr
, 1 << sattr
->index
,
461 val
? 1 << sattr
->index
: 0);
462 return err
? : count
;
465 static SENSOR_DEVICE_ATTR(temp1_type
, S_IRUGO
| S_IWUSR
,
466 show_temp_type
, store_temp_type
, 0);
467 static SENSOR_DEVICE_ATTR_2(temp1_input
, S_IRUGO
, show_temp
, NULL
, 0x01,
469 static SENSOR_DEVICE_ATTR_2(temp1_min
, S_IRUGO
| S_IWUSR
, show_temp
,
470 store_temp
, 0x31, 0);
471 static SENSOR_DEVICE_ATTR_2(temp1_max
, S_IRUGO
| S_IWUSR
, show_temp
,
472 store_temp
, 0x30, 0);
473 static SENSOR_DEVICE_ATTR_2(temp1_crit
, S_IRUGO
| S_IWUSR
, show_temp
,
474 store_temp
, 0x3a, 0);
476 static SENSOR_DEVICE_ATTR(temp2_type
, S_IRUGO
| S_IWUSR
,
477 show_temp_type
, store_temp_type
, 1);
478 static SENSOR_DEVICE_ATTR_2(temp2_input
, S_IRUGO
, show_temp
, NULL
, 0x02,
480 static SENSOR_DEVICE_ATTR_2(temp2_min
, S_IRUGO
| S_IWUSR
, show_temp
,
481 store_temp
, 0x33, 0);
482 static SENSOR_DEVICE_ATTR_2(temp2_max
, S_IRUGO
| S_IWUSR
, show_temp
,
483 store_temp
, 0x32, 0);
484 static SENSOR_DEVICE_ATTR_2(temp2_crit
, S_IRUGO
| S_IWUSR
, show_temp
,
485 store_temp
, 0x3b, 0);
487 static SENSOR_DEVICE_ATTR(temp3_type
, S_IRUGO
| S_IWUSR
,
488 show_temp_type
, store_temp_type
, 2);
489 static SENSOR_DEVICE_ATTR_2(temp3_input
, S_IRUGO
, show_temp
, NULL
, 0x03,
491 static SENSOR_DEVICE_ATTR_2(temp3_min
, S_IRUGO
| S_IWUSR
, show_temp
,
492 store_temp
, 0x35, 0);
493 static SENSOR_DEVICE_ATTR_2(temp3_max
, S_IRUGO
| S_IWUSR
, show_temp
,
494 store_temp
, 0x34, 0);
495 static SENSOR_DEVICE_ATTR_2(temp3_crit
, S_IRUGO
| S_IWUSR
, show_temp
,
496 store_temp
, 0x3c, 0);
498 static SENSOR_DEVICE_ATTR_2(temp4_input
, S_IRUGO
, show_temp
, NULL
, 0x04, 0);
499 static SENSOR_DEVICE_ATTR_2(temp4_min
, S_IRUGO
| S_IWUSR
, show_temp
,
500 store_temp
, 0x37, 0);
501 static SENSOR_DEVICE_ATTR_2(temp4_max
, S_IRUGO
| S_IWUSR
, show_temp
,
502 store_temp
, 0x36, 0);
503 static SENSOR_DEVICE_ATTR_2(temp4_crit
, S_IRUGO
| S_IWUSR
, show_temp
,
504 store_temp
, 0x3d, 0);
506 static SENSOR_DEVICE_ATTR_2(temp5_input
, S_IRUGO
, show_temp
, NULL
, 0x06,
508 static SENSOR_DEVICE_ATTR_2(temp5_min
, S_IRUGO
| S_IWUSR
, show_temp
,
509 store_temp
, 0x39, 0);
510 static SENSOR_DEVICE_ATTR_2(temp5_max
, S_IRUGO
| S_IWUSR
, show_temp
,
511 store_temp
, 0x38, 0);
512 static SENSOR_DEVICE_ATTR_2(temp5_crit
, S_IRUGO
| S_IWUSR
, show_temp
,
513 store_temp
, 0x3e, 0);
515 static SENSOR_DEVICE_ATTR_2(temp6_input
, S_IRUGO
, show_temp
, NULL
, 0x07,
518 static SENSOR_DEVICE_ATTR_2(temp1_min_alarm
, S_IRUGO
, show_alarm
, NULL
,
520 static SENSOR_DEVICE_ATTR_2(temp2_min_alarm
, S_IRUGO
, show_alarm
, NULL
,
522 static SENSOR_DEVICE_ATTR_2(temp3_min_alarm
, S_IRUGO
, show_alarm
, NULL
,
524 static SENSOR_DEVICE_ATTR_2(temp4_min_alarm
, S_IRUGO
, show_alarm
, NULL
,
526 static SENSOR_DEVICE_ATTR_2(temp5_min_alarm
, S_IRUGO
, show_alarm
, NULL
,
529 static SENSOR_DEVICE_ATTR_2(temp1_max_alarm
, S_IRUGO
, show_alarm
, NULL
,
531 static SENSOR_DEVICE_ATTR_2(temp2_max_alarm
, S_IRUGO
, show_alarm
, NULL
,
533 static SENSOR_DEVICE_ATTR_2(temp3_max_alarm
, S_IRUGO
, show_alarm
, NULL
,
535 static SENSOR_DEVICE_ATTR_2(temp4_max_alarm
, S_IRUGO
, show_alarm
, NULL
,
537 static SENSOR_DEVICE_ATTR_2(temp5_max_alarm
, S_IRUGO
, show_alarm
, NULL
,
540 static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm
, S_IRUGO
, show_alarm
, NULL
,
542 static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm
, S_IRUGO
, show_alarm
, NULL
,
544 static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm
, S_IRUGO
, show_alarm
, NULL
,
546 static SENSOR_DEVICE_ATTR_2(temp4_crit_alarm
, S_IRUGO
, show_alarm
, NULL
,
548 static SENSOR_DEVICE_ATTR_2(temp5_crit_alarm
, S_IRUGO
, show_alarm
, NULL
,
551 static SENSOR_DEVICE_ATTR_2(temp1_fault
, S_IRUGO
, show_alarm
, NULL
, 0x17, 0);
552 static SENSOR_DEVICE_ATTR_2(temp2_fault
, S_IRUGO
, show_alarm
, NULL
, 0x17, 1);
553 static SENSOR_DEVICE_ATTR_2(temp3_fault
, S_IRUGO
, show_alarm
, NULL
, 0x17, 2);
555 static SENSOR_DEVICE_ATTR_2(temp1_beep
, S_IRUGO
| S_IWUSR
, show_beep
,
556 store_beep
, 0x5c, 0);
557 static SENSOR_DEVICE_ATTR_2(temp2_beep
, S_IRUGO
| S_IWUSR
, show_beep
,
558 store_beep
, 0x5c, 1);
559 static SENSOR_DEVICE_ATTR_2(temp3_beep
, S_IRUGO
| S_IWUSR
, show_beep
,
560 store_beep
, 0x5c, 2);
561 static SENSOR_DEVICE_ATTR_2(temp4_beep
, S_IRUGO
| S_IWUSR
, show_beep
,
562 store_beep
, 0x5c, 3);
563 static SENSOR_DEVICE_ATTR_2(temp5_beep
, S_IRUGO
| S_IWUSR
, show_beep
,
564 store_beep
, 0x5c, 4);
565 static SENSOR_DEVICE_ATTR_2(temp6_beep
, S_IRUGO
| S_IWUSR
, show_beep
,
566 store_beep
, 0x5c, 5);
568 static struct attribute
*nct7802_temp_attrs
[] = {
569 &sensor_dev_attr_temp1_type
.dev_attr
.attr
,
570 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
571 &sensor_dev_attr_temp1_min
.dev_attr
.attr
,
572 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
573 &sensor_dev_attr_temp1_crit
.dev_attr
.attr
,
574 &sensor_dev_attr_temp1_min_alarm
.dev_attr
.attr
,
575 &sensor_dev_attr_temp1_max_alarm
.dev_attr
.attr
,
576 &sensor_dev_attr_temp1_crit_alarm
.dev_attr
.attr
,
577 &sensor_dev_attr_temp1_fault
.dev_attr
.attr
,
578 &sensor_dev_attr_temp1_beep
.dev_attr
.attr
,
580 &sensor_dev_attr_temp2_type
.dev_attr
.attr
, /* 10 */
581 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
582 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
583 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
584 &sensor_dev_attr_temp2_crit
.dev_attr
.attr
,
585 &sensor_dev_attr_temp2_min_alarm
.dev_attr
.attr
,
586 &sensor_dev_attr_temp2_max_alarm
.dev_attr
.attr
,
587 &sensor_dev_attr_temp2_crit_alarm
.dev_attr
.attr
,
588 &sensor_dev_attr_temp2_fault
.dev_attr
.attr
,
589 &sensor_dev_attr_temp2_beep
.dev_attr
.attr
,
591 &sensor_dev_attr_temp3_type
.dev_attr
.attr
, /* 20 */
592 &sensor_dev_attr_temp3_input
.dev_attr
.attr
,
593 &sensor_dev_attr_temp3_min
.dev_attr
.attr
,
594 &sensor_dev_attr_temp3_max
.dev_attr
.attr
,
595 &sensor_dev_attr_temp3_crit
.dev_attr
.attr
,
596 &sensor_dev_attr_temp3_min_alarm
.dev_attr
.attr
,
597 &sensor_dev_attr_temp3_max_alarm
.dev_attr
.attr
,
598 &sensor_dev_attr_temp3_crit_alarm
.dev_attr
.attr
,
599 &sensor_dev_attr_temp3_fault
.dev_attr
.attr
,
600 &sensor_dev_attr_temp3_beep
.dev_attr
.attr
,
602 &sensor_dev_attr_temp4_input
.dev_attr
.attr
, /* 30 */
603 &sensor_dev_attr_temp4_min
.dev_attr
.attr
,
604 &sensor_dev_attr_temp4_max
.dev_attr
.attr
,
605 &sensor_dev_attr_temp4_crit
.dev_attr
.attr
,
606 &sensor_dev_attr_temp4_min_alarm
.dev_attr
.attr
,
607 &sensor_dev_attr_temp4_max_alarm
.dev_attr
.attr
,
608 &sensor_dev_attr_temp4_crit_alarm
.dev_attr
.attr
,
609 &sensor_dev_attr_temp4_beep
.dev_attr
.attr
,
611 &sensor_dev_attr_temp5_input
.dev_attr
.attr
, /* 38 */
612 &sensor_dev_attr_temp5_min
.dev_attr
.attr
,
613 &sensor_dev_attr_temp5_max
.dev_attr
.attr
,
614 &sensor_dev_attr_temp5_crit
.dev_attr
.attr
,
615 &sensor_dev_attr_temp5_min_alarm
.dev_attr
.attr
,
616 &sensor_dev_attr_temp5_max_alarm
.dev_attr
.attr
,
617 &sensor_dev_attr_temp5_crit_alarm
.dev_attr
.attr
,
618 &sensor_dev_attr_temp5_beep
.dev_attr
.attr
,
620 &sensor_dev_attr_temp6_input
.dev_attr
.attr
, /* 46 */
621 &sensor_dev_attr_temp6_beep
.dev_attr
.attr
,
626 static umode_t
nct7802_temp_is_visible(struct kobject
*kobj
,
627 struct attribute
*attr
, int index
)
629 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
630 struct nct7802_data
*data
= dev_get_drvdata(dev
);
634 err
= regmap_read(data
->regmap
, REG_MODE
, ®
);
639 (reg
& 03) != 0x01 && (reg
& 0x03) != 0x02) /* RD1 */
642 if (index
>= 10 && index
< 20 &&
643 (reg
& 0x0c) != 0x04 && (reg
& 0x0c) != 0x08) /* RD2 */
645 if (index
>= 20 && index
< 30 && (reg
& 0x30) != 0x20) /* RD3 */
648 if (index
>= 30 && index
< 38) /* local */
651 err
= regmap_read(data
->regmap
, REG_PECI_ENABLE
, ®
);
655 if (index
>= 38 && index
< 46 && !(reg
& 0x01)) /* PECI 0 */
658 if (index
>= 0x46 && (!(reg
& 0x02))) /* PECI 1 */
664 static struct attribute_group nct7802_temp_group
= {
665 .attrs
= nct7802_temp_attrs
,
666 .is_visible
= nct7802_temp_is_visible
,
669 static SENSOR_DEVICE_ATTR_2(in0_input
, S_IRUGO
, show_in
, NULL
, 0, 0);
670 static SENSOR_DEVICE_ATTR_2(in0_min
, S_IRUGO
| S_IWUSR
, show_in
, store_in
,
672 static SENSOR_DEVICE_ATTR_2(in0_max
, S_IRUGO
| S_IWUSR
, show_in
, store_in
,
674 static SENSOR_DEVICE_ATTR_2(in0_alarm
, S_IRUGO
, show_alarm
, NULL
, 0x1e, 3);
675 static SENSOR_DEVICE_ATTR_2(in0_beep
, S_IRUGO
| S_IWUSR
, show_beep
, store_beep
,
678 static SENSOR_DEVICE_ATTR_2(in1_input
, S_IRUGO
, show_in
, NULL
, 1, 0);
680 static SENSOR_DEVICE_ATTR_2(in2_input
, S_IRUGO
, show_in
, NULL
, 2, 0);
681 static SENSOR_DEVICE_ATTR_2(in2_min
, S_IRUGO
| S_IWUSR
, show_in
, store_in
,
683 static SENSOR_DEVICE_ATTR_2(in2_max
, S_IRUGO
| S_IWUSR
, show_in
, store_in
,
685 static SENSOR_DEVICE_ATTR_2(in2_alarm
, S_IRUGO
, show_alarm
, NULL
, 0x1e, 0);
686 static SENSOR_DEVICE_ATTR_2(in2_beep
, S_IRUGO
| S_IWUSR
, show_beep
, store_beep
,
689 static SENSOR_DEVICE_ATTR_2(in3_input
, S_IRUGO
, show_in
, NULL
, 3, 0);
690 static SENSOR_DEVICE_ATTR_2(in3_min
, S_IRUGO
| S_IWUSR
, show_in
, store_in
,
692 static SENSOR_DEVICE_ATTR_2(in3_max
, S_IRUGO
| S_IWUSR
, show_in
, store_in
,
694 static SENSOR_DEVICE_ATTR_2(in3_alarm
, S_IRUGO
, show_alarm
, NULL
, 0x1e, 1);
695 static SENSOR_DEVICE_ATTR_2(in3_beep
, S_IRUGO
| S_IWUSR
, show_beep
, store_beep
,
698 static SENSOR_DEVICE_ATTR_2(in4_input
, S_IRUGO
, show_in
, NULL
, 4, 0);
699 static SENSOR_DEVICE_ATTR_2(in4_min
, S_IRUGO
| S_IWUSR
, show_in
, store_in
,
701 static SENSOR_DEVICE_ATTR_2(in4_max
, S_IRUGO
| S_IWUSR
, show_in
, store_in
,
703 static SENSOR_DEVICE_ATTR_2(in4_alarm
, S_IRUGO
, show_alarm
, NULL
, 0x1e, 2);
704 static SENSOR_DEVICE_ATTR_2(in4_beep
, S_IRUGO
| S_IWUSR
, show_beep
, store_beep
,
707 static struct attribute
*nct7802_in_attrs
[] = {
708 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
709 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
710 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
711 &sensor_dev_attr_in0_alarm
.dev_attr
.attr
,
712 &sensor_dev_attr_in0_beep
.dev_attr
.attr
,
714 &sensor_dev_attr_in1_input
.dev_attr
.attr
, /* 5 */
716 &sensor_dev_attr_in2_input
.dev_attr
.attr
, /* 6 */
717 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
718 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
719 &sensor_dev_attr_in2_alarm
.dev_attr
.attr
,
720 &sensor_dev_attr_in2_beep
.dev_attr
.attr
,
722 &sensor_dev_attr_in3_input
.dev_attr
.attr
, /* 11 */
723 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
724 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
725 &sensor_dev_attr_in3_alarm
.dev_attr
.attr
,
726 &sensor_dev_attr_in3_beep
.dev_attr
.attr
,
728 &sensor_dev_attr_in4_input
.dev_attr
.attr
, /* 17 */
729 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
730 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
731 &sensor_dev_attr_in4_alarm
.dev_attr
.attr
,
732 &sensor_dev_attr_in4_beep
.dev_attr
.attr
,
737 static umode_t
nct7802_in_is_visible(struct kobject
*kobj
,
738 struct attribute
*attr
, int index
)
740 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
741 struct nct7802_data
*data
= dev_get_drvdata(dev
);
745 if (index
< 6) /* VCC, VCORE */
748 err
= regmap_read(data
->regmap
, REG_MODE
, ®
);
752 if (index
>= 6 && index
< 11 && (reg
& 0x03) != 0x03) /* VSEN1 */
754 if (index
>= 11 && index
< 17 && (reg
& 0x0c) != 0x0c) /* VSEN2 */
756 if (index
>= 17 && (reg
& 0x30) != 0x30) /* VSEN3 */
762 static struct attribute_group nct7802_in_group
= {
763 .attrs
= nct7802_in_attrs
,
764 .is_visible
= nct7802_in_is_visible
,
767 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0x10);
768 static SENSOR_DEVICE_ATTR_2(fan1_min
, S_IRUGO
| S_IWUSR
, show_fan_min
,
769 store_fan_min
, 0x49, 0x4c);
770 static SENSOR_DEVICE_ATTR_2(fan1_alarm
, S_IRUGO
, show_alarm
, NULL
, 0x1a, 0);
771 static SENSOR_DEVICE_ATTR_2(fan1_beep
, S_IRUGO
| S_IWUSR
, show_beep
, store_beep
,
773 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, show_fan
, NULL
, 0x11);
774 static SENSOR_DEVICE_ATTR_2(fan2_min
, S_IRUGO
| S_IWUSR
, show_fan_min
,
775 store_fan_min
, 0x4a, 0x4d);
776 static SENSOR_DEVICE_ATTR_2(fan2_alarm
, S_IRUGO
, show_alarm
, NULL
, 0x1a, 1);
777 static SENSOR_DEVICE_ATTR_2(fan2_beep
, S_IRUGO
| S_IWUSR
, show_beep
, store_beep
,
779 static SENSOR_DEVICE_ATTR(fan3_input
, S_IRUGO
, show_fan
, NULL
, 0x12);
780 static SENSOR_DEVICE_ATTR_2(fan3_min
, S_IRUGO
| S_IWUSR
, show_fan_min
,
781 store_fan_min
, 0x4b, 0x4e);
782 static SENSOR_DEVICE_ATTR_2(fan3_alarm
, S_IRUGO
, show_alarm
, NULL
, 0x1a, 2);
783 static SENSOR_DEVICE_ATTR_2(fan3_beep
, S_IRUGO
| S_IWUSR
, show_beep
, store_beep
,
786 /* 7.2.89 Fan Control Output Type */
787 static SENSOR_DEVICE_ATTR(pwm1_mode
, S_IRUGO
, show_pwm_mode
, NULL
, 0);
788 static SENSOR_DEVICE_ATTR(pwm2_mode
, S_IRUGO
, show_pwm_mode
, NULL
, 1);
789 static SENSOR_DEVICE_ATTR(pwm3_mode
, S_IRUGO
, show_pwm_mode
, NULL
, 2);
791 /* 7.2.91... Fan Control Output Value */
792 static SENSOR_DEVICE_ATTR(pwm1
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 0x60);
793 static SENSOR_DEVICE_ATTR(pwm2
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 0x61);
794 static SENSOR_DEVICE_ATTR(pwm3
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 0x62);
796 static struct attribute
*nct7802_fan_attrs
[] = {
797 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
798 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
799 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
800 &sensor_dev_attr_fan1_beep
.dev_attr
.attr
,
801 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
802 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
803 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
804 &sensor_dev_attr_fan2_beep
.dev_attr
.attr
,
805 &sensor_dev_attr_fan3_input
.dev_attr
.attr
,
806 &sensor_dev_attr_fan3_min
.dev_attr
.attr
,
807 &sensor_dev_attr_fan3_alarm
.dev_attr
.attr
,
808 &sensor_dev_attr_fan3_beep
.dev_attr
.attr
,
813 static umode_t
nct7802_fan_is_visible(struct kobject
*kobj
,
814 struct attribute
*attr
, int index
)
816 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
817 struct nct7802_data
*data
= dev_get_drvdata(dev
);
818 int fan
= index
/ 4; /* 4 attributes per fan */
822 err
= regmap_read(data
->regmap
, REG_FAN_ENABLE
, ®
);
823 if (err
< 0 || !(reg
& (1 << fan
)))
829 static struct attribute_group nct7802_fan_group
= {
830 .attrs
= nct7802_fan_attrs
,
831 .is_visible
= nct7802_fan_is_visible
,
834 static struct attribute
*nct7802_pwm_attrs
[] = {
835 &sensor_dev_attr_pwm1_mode
.dev_attr
.attr
,
836 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
837 &sensor_dev_attr_pwm2_mode
.dev_attr
.attr
,
838 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
839 &sensor_dev_attr_pwm3_mode
.dev_attr
.attr
,
840 &sensor_dev_attr_pwm3
.dev_attr
.attr
,
844 static struct attribute_group nct7802_pwm_group
= {
845 .attrs
= nct7802_pwm_attrs
,
848 static const struct attribute_group
*nct7802_groups
[] = {
856 static int nct7802_detect(struct i2c_client
*client
,
857 struct i2c_board_info
*info
)
862 * Chip identification registers are only available in bank 0,
863 * so only attempt chip detection if bank 0 is selected
865 reg
= i2c_smbus_read_byte_data(client
, REG_BANK
);
869 reg
= i2c_smbus_read_byte_data(client
, REG_VENDOR_ID
);
873 reg
= i2c_smbus_read_byte_data(client
, REG_CHIP_ID
);
877 reg
= i2c_smbus_read_byte_data(client
, REG_VERSION_ID
);
878 if (reg
< 0 || (reg
& 0xf0) != 0x20)
881 /* Also validate lower bits of voltage and temperature registers */
882 reg
= i2c_smbus_read_byte_data(client
, REG_TEMP_LSB
);
883 if (reg
< 0 || (reg
& 0x1f))
886 reg
= i2c_smbus_read_byte_data(client
, REG_TEMP_PECI_LSB
);
887 if (reg
< 0 || (reg
& 0x3f))
890 reg
= i2c_smbus_read_byte_data(client
, REG_VOLTAGE_LOW
);
891 if (reg
< 0 || (reg
& 0x3f))
894 strlcpy(info
->type
, "nct7802", I2C_NAME_SIZE
);
898 static bool nct7802_regmap_is_volatile(struct device
*dev
, unsigned int reg
)
900 return reg
!= REG_BANK
&& reg
<= 0x20;
903 static const struct regmap_config nct7802_regmap_config
= {
906 .cache_type
= REGCACHE_RBTREE
,
907 .volatile_reg
= nct7802_regmap_is_volatile
,
910 static int nct7802_init_chip(struct nct7802_data
*data
)
915 err
= regmap_update_bits(data
->regmap
, REG_START
, 0x01, 0x01);
919 /* Enable local temperature sensor */
920 err
= regmap_update_bits(data
->regmap
, REG_MODE
, 0x40, 0x40);
924 /* Enable Vcore and VCC voltage monitoring */
925 return regmap_update_bits(data
->regmap
, REG_VMON_ENABLE
, 0x03, 0x03);
928 static int nct7802_probe(struct i2c_client
*client
,
929 const struct i2c_device_id
*id
)
931 struct device
*dev
= &client
->dev
;
932 struct nct7802_data
*data
;
933 struct device
*hwmon_dev
;
936 data
= devm_kzalloc(dev
, sizeof(*data
), GFP_KERNEL
);
940 data
->regmap
= devm_regmap_init_i2c(client
, &nct7802_regmap_config
);
941 if (IS_ERR(data
->regmap
))
942 return PTR_ERR(data
->regmap
);
944 mutex_init(&data
->access_lock
);
946 ret
= nct7802_init_chip(data
);
950 hwmon_dev
= devm_hwmon_device_register_with_groups(dev
, client
->name
,
953 return PTR_ERR_OR_ZERO(hwmon_dev
);
956 static const unsigned short nct7802_address_list
[] = {
957 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END
960 static const struct i2c_device_id nct7802_idtable
[] = {
964 MODULE_DEVICE_TABLE(i2c
, nct7802_idtable
);
966 static struct i2c_driver nct7802_driver
= {
967 .class = I2C_CLASS_HWMON
,
971 .detect
= nct7802_detect
,
972 .probe
= nct7802_probe
,
973 .id_table
= nct7802_idtable
,
974 .address_list
= nct7802_address_list
,
977 module_i2c_driver(nct7802_driver
);
979 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
980 MODULE_DESCRIPTION("NCT7802Y Hardware Monitoring Driver");
981 MODULE_LICENSE("GPL v2");