1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * nct6683 - Driver for the hardware monitoring functionality of
4 * Nuvoton NCT6683D/NCT6686D/NCT6687D eSIO
6 * Copyright (C) 2013 Guenter Roeck <linux@roeck-us.net>
8 * Derived from nct6775 driver
9 * Copyright (C) 2012, 2013 Guenter Roeck <linux@roeck-us.net>
11 * Supports the following chips:
13 * Chip #vin #fan #pwm #temp chip ID
14 * nct6683d 21(1) 16 8 32(1) 0xc730
15 * nct6686d 21(1) 16 8 32(1) 0xd440
16 * nct6687d 21(1) 16 8 32(1) 0xd590
19 * (1) Total number of vin and temp inputs is 32.
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 #include <linux/acpi.h>
25 #include <linux/delay.h>
26 #include <linux/err.h>
27 #include <linux/init.h>
29 #include <linux/jiffies.h>
30 #include <linux/hwmon.h>
31 #include <linux/hwmon-sysfs.h>
32 #include <linux/module.h>
33 #include <linux/mutex.h>
34 #include <linux/platform_device.h>
35 #include <linux/slab.h>
37 enum kinds { nct6683, nct6686, nct6687 };
40 module_param(force, bool, 0);
41 MODULE_PARM_DESC(force, "Set to one to enable support for unknown vendors");
43 static const char * const nct6683_device_names[] = {
49 static const char * const nct6683_chip_names[] = {
55 #define DRVNAME "nct6683"
58 * Super-I/O constants and functions
61 #define NCT6683_LD_ACPI 0x0a
62 #define NCT6683_LD_HWM 0x0b
63 #define NCT6683_LD_VID 0x0d
65 #define SIO_REG_LDSEL 0x07 /* Logical device select */
66 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
67 #define SIO_REG_ENABLE 0x30 /* Logical device enable */
68 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
70 #define SIO_NCT6681_ID 0xb270 /* for later */
71 #define SIO_NCT6683_ID 0xc730
72 #define SIO_NCT6686_ID 0xd440
73 #define SIO_NCT6687_ID 0xd590
74 #define SIO_ID_MASK 0xFFF0
77 superio_outb(int ioreg, int reg, int val)
84 superio_inb(int ioreg, int reg)
87 return inb(ioreg + 1);
91 superio_select(int ioreg, int ld)
93 outb(SIO_REG_LDSEL, ioreg);
98 superio_enter(int ioreg)
101 * Try to reserve <ioreg> and <ioreg + 1> for exclusive access.
103 if (!request_muxed_region(ioreg, 2, DRVNAME))
113 superio_exit(int ioreg)
117 outb(0x02, ioreg + 1);
118 release_region(ioreg, 2);
125 #define IOREGION_ALIGNMENT (~7)
126 #define IOREGION_OFFSET 4 /* Use EC port 1 */
127 #define IOREGION_LENGTH 4
129 #define EC_PAGE_REG 0
130 #define EC_INDEX_REG 1
131 #define EC_DATA_REG 2
132 #define EC_EVENT_REG 3
134 /* Common and NCT6683 specific data */
136 #define NCT6683_NUM_REG_MON 32
137 #define NCT6683_NUM_REG_FAN 16
138 #define NCT6683_NUM_REG_PWM 8
140 #define NCT6683_REG_MON(x) (0x100 + (x) * 2)
141 #define NCT6683_REG_FAN_RPM(x) (0x140 + (x) * 2)
142 #define NCT6683_REG_PWM(x) (0x160 + (x))
143 #define NCT6683_REG_PWM_WRITE(x) (0xa28 + (x))
145 #define NCT6683_REG_MON_STS(x) (0x174 + (x))
146 #define NCT6683_REG_IDLE(x) (0x178 + (x))
148 #define NCT6683_REG_FAN_STS(x) (0x17c + (x))
149 #define NCT6683_REG_FAN_ERRSTS 0x17e
150 #define NCT6683_REG_FAN_INITSTS 0x17f
152 #define NCT6683_HWM_CFG 0x180
154 #define NCT6683_REG_MON_CFG(x) (0x1a0 + (x))
155 #define NCT6683_REG_FANIN_CFG(x) (0x1c0 + (x))
156 #define NCT6683_REG_FANOUT_CFG(x) (0x1d0 + (x))
158 #define NCT6683_REG_INTEL_TEMP_MAX(x) (0x901 + (x) * 16)
159 #define NCT6683_REG_INTEL_TEMP_CRIT(x) (0x90d + (x) * 16)
161 #define NCT6683_REG_TEMP_HYST(x) (0x330 + (x)) /* 8 bit */
162 #define NCT6683_REG_TEMP_MAX(x) (0x350 + (x)) /* 8 bit */
163 #define NCT6683_REG_MON_HIGH(x) (0x370 + (x) * 2) /* 8 bit */
164 #define NCT6683_REG_MON_LOW(x) (0x371 + (x) * 2) /* 8 bit */
166 #define NCT6683_REG_FAN_MIN(x) (0x3b8 + (x) * 2) /* 16 bit */
168 #define NCT6683_REG_FAN_CFG_CTRL 0xa01
169 #define NCT6683_FAN_CFG_REQ 0x80
170 #define NCT6683_FAN_CFG_DONE 0x40
172 #define NCT6683_REG_CUSTOMER_ID 0x602
173 #define NCT6683_CUSTOMER_ID_INTEL 0x805
174 #define NCT6683_CUSTOMER_ID_MITAC 0xa0e
175 #define NCT6683_CUSTOMER_ID_MSI 0x201
176 #define NCT6683_CUSTOMER_ID_ASROCK 0xe2c
178 #define NCT6683_REG_BUILD_YEAR 0x604
179 #define NCT6683_REG_BUILD_MONTH 0x605
180 #define NCT6683_REG_BUILD_DAY 0x606
181 #define NCT6683_REG_SERIAL 0x607
182 #define NCT6683_REG_VERSION_HI 0x608
183 #define NCT6683_REG_VERSION_LO 0x609
185 #define NCT6683_REG_CR_CASEOPEN 0xe8
186 #define NCT6683_CR_CASEOPEN_MASK (1 << 7)
188 #define NCT6683_REG_CR_BEEP 0xe0
189 #define NCT6683_CR_BEEP_MASK (1 << 6)
191 static const char *const nct6683_mon_label[] = {
208 "Thermistor 5", /* 0x10 */
217 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
218 "PECI 0.0", /* 0x20 */
230 NULL, NULL, NULL, NULL,
231 "PCH CPU", /* 0x30 */
257 NULL, NULL, NULL, NULL, NULL, NULL,
258 "Virtual 0", /* 0x50 */
266 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
267 "VCC", /* 0x60 voltage sensors */
292 #define NUM_MON_LABELS ARRAY_SIZE(nct6683_mon_label)
293 #define MON_VOLTAGE_START 0x60
295 /* ------------------------------------------------------- */
297 struct nct6683_data {
298 int addr; /* IO base of EC space */
299 int sioreg; /* SIO register */
303 struct device *hwmon_dev;
304 const struct attribute_group *groups[6];
306 int temp_num; /* number of temperature attributes */
307 u8 temp_index[NCT6683_NUM_REG_MON];
308 u8 temp_src[NCT6683_NUM_REG_MON];
310 u8 in_num; /* number of voltage attributes */
311 u8 in_index[NCT6683_NUM_REG_MON];
312 u8 in_src[NCT6683_NUM_REG_MON];
314 struct mutex update_lock; /* used to protect sensor updates */
315 bool valid; /* true if following fields are valid */
316 unsigned long last_updated; /* In jiffies */
318 /* Voltage attribute values */
319 u8 in[3][NCT6683_NUM_REG_MON]; /* [0]=in, [1]=in_max, [2]=in_min */
321 /* Temperature attribute values */
322 s16 temp_in[NCT6683_NUM_REG_MON];
323 s8 temp[4][NCT6683_NUM_REG_MON];/* [0]=min, [1]=max, [2]=hyst,
327 /* Fan attribute values */
328 unsigned int rpm[NCT6683_NUM_REG_FAN];
329 u16 fan_min[NCT6683_NUM_REG_FAN];
330 u8 fanin_cfg[NCT6683_NUM_REG_FAN];
331 u8 fanout_cfg[NCT6683_NUM_REG_FAN];
332 u16 have_fan; /* some fan inputs can be disabled */
335 u8 pwm[NCT6683_NUM_REG_PWM];
338 /* Remember extra register values over suspend/resume */
343 struct nct6683_sio_data {
348 struct sensor_device_template {
349 struct device_attribute dev_attr;
357 bool s2; /* true if both index and nr are used */
360 struct sensor_device_attr_u {
362 struct sensor_device_attribute a1;
363 struct sensor_device_attribute_2 a2;
368 #define __TEMPLATE_ATTR(_template, _mode, _show, _store) { \
369 .attr = {.name = _template, .mode = _mode }, \
374 #define SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, _index) \
375 { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
379 #define SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store, \
381 { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
382 .u.s.index = _index, \
386 #define SENSOR_TEMPLATE(_name, _template, _mode, _show, _store, _index) \
387 static struct sensor_device_template sensor_dev_template_##_name \
388 = SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, \
391 #define SENSOR_TEMPLATE_2(_name, _template, _mode, _show, _store, \
393 static struct sensor_device_template sensor_dev_template_##_name \
394 = SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store, \
397 struct sensor_template_group {
398 struct sensor_device_template **templates;
399 umode_t (*is_visible)(struct kobject *, struct attribute *, int);
403 static struct attribute_group *
404 nct6683_create_attr_group(struct device *dev,
405 const struct sensor_template_group *tg,
408 struct sensor_device_attribute_2 *a2;
409 struct sensor_device_attribute *a;
410 struct sensor_device_template **t;
411 struct sensor_device_attr_u *su;
412 struct attribute_group *group;
413 struct attribute **attrs;
417 return ERR_PTR(-EINVAL);
420 for (count = 0; *t; t++, count++)
424 return ERR_PTR(-EINVAL);
426 group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL);
428 return ERR_PTR(-ENOMEM);
430 attrs = devm_kcalloc(dev, repeat * count + 1, sizeof(*attrs),
433 return ERR_PTR(-ENOMEM);
435 su = devm_kzalloc(dev, array3_size(repeat, count, sizeof(*su)),
438 return ERR_PTR(-ENOMEM);
440 group->attrs = attrs;
441 group->is_visible = tg->is_visible;
443 for (i = 0; i < repeat; i++) {
445 for (j = 0; *t != NULL; j++) {
446 snprintf(su->name, sizeof(su->name),
447 (*t)->dev_attr.attr.name, tg->base + i);
450 sysfs_attr_init(&a2->dev_attr.attr);
451 a2->dev_attr.attr.name = su->name;
452 a2->nr = (*t)->u.s.nr + i;
453 a2->index = (*t)->u.s.index;
454 a2->dev_attr.attr.mode =
455 (*t)->dev_attr.attr.mode;
456 a2->dev_attr.show = (*t)->dev_attr.show;
457 a2->dev_attr.store = (*t)->dev_attr.store;
458 *attrs = &a2->dev_attr.attr;
461 sysfs_attr_init(&a->dev_attr.attr);
462 a->dev_attr.attr.name = su->name;
463 a->index = (*t)->u.index + i;
464 a->dev_attr.attr.mode =
465 (*t)->dev_attr.attr.mode;
466 a->dev_attr.show = (*t)->dev_attr.show;
467 a->dev_attr.store = (*t)->dev_attr.store;
468 *attrs = &a->dev_attr.attr;
479 /* LSB is 16 mV, except for the following sources, where it is 32 mV */
480 #define MON_SRC_VCC 0x60
481 #define MON_SRC_VSB 0x61
482 #define MON_SRC_AVSB 0x62
483 #define MON_SRC_VBAT 0x64
485 static inline long in_from_reg(u16 reg, u8 src)
489 if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB ||
495 static u16 nct6683_read(struct nct6683_data *data, u16 reg)
499 outb_p(0xff, data->addr + EC_PAGE_REG); /* unlock */
500 outb_p(reg >> 8, data->addr + EC_PAGE_REG);
501 outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
502 res = inb_p(data->addr + EC_DATA_REG);
506 static u16 nct6683_read16(struct nct6683_data *data, u16 reg)
508 return (nct6683_read(data, reg) << 8) | nct6683_read(data, reg + 1);
511 static void nct6683_write(struct nct6683_data *data, u16 reg, u16 value)
513 outb_p(0xff, data->addr + EC_PAGE_REG); /* unlock */
514 outb_p(reg >> 8, data->addr + EC_PAGE_REG);
515 outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
516 outb_p(value & 0xff, data->addr + EC_DATA_REG);
519 static int get_in_reg(struct nct6683_data *data, int nr, int index)
521 int ch = data->in_index[index];
526 reg = NCT6683_REG_MON(ch);
529 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
530 reg = NCT6683_REG_MON_LOW(ch);
533 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
534 reg = NCT6683_REG_MON_HIGH(ch);
542 static int get_temp_reg(struct nct6683_data *data, int nr, int index)
544 int ch = data->temp_index[index];
547 switch (data->customer_id) {
548 case NCT6683_CUSTOMER_ID_INTEL:
552 reg = NCT6683_REG_INTEL_TEMP_MAX(ch);
555 reg = NCT6683_REG_INTEL_TEMP_CRIT(ch);
559 case NCT6683_CUSTOMER_ID_MITAC:
564 reg = NCT6683_REG_MON_LOW(ch);
567 reg = NCT6683_REG_TEMP_MAX(ch);
570 reg = NCT6683_REG_TEMP_HYST(ch);
573 reg = NCT6683_REG_MON_HIGH(ch);
581 static void nct6683_update_pwm(struct device *dev)
583 struct nct6683_data *data = dev_get_drvdata(dev);
586 for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
587 if (!(data->have_pwm & (1 << i)))
589 data->pwm[i] = nct6683_read(data, NCT6683_REG_PWM(i));
593 static struct nct6683_data *nct6683_update_device(struct device *dev)
595 struct nct6683_data *data = dev_get_drvdata(dev);
598 mutex_lock(&data->update_lock);
600 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
601 /* Measured voltages and limits */
602 for (i = 0; i < data->in_num; i++) {
603 for (j = 0; j < 3; j++) {
604 int reg = get_in_reg(data, j, i);
608 nct6683_read(data, reg);
612 /* Measured temperatures and limits */
613 for (i = 0; i < data->temp_num; i++) {
614 u8 ch = data->temp_index[i];
616 data->temp_in[i] = nct6683_read16(data,
617 NCT6683_REG_MON(ch));
618 for (j = 0; j < 4; j++) {
619 int reg = get_temp_reg(data, j, i);
623 nct6683_read(data, reg);
627 /* Measured fan speeds and limits */
628 for (i = 0; i < ARRAY_SIZE(data->rpm); i++) {
629 if (!(data->have_fan & (1 << i)))
632 data->rpm[i] = nct6683_read16(data,
633 NCT6683_REG_FAN_RPM(i));
634 data->fan_min[i] = nct6683_read16(data,
635 NCT6683_REG_FAN_MIN(i));
638 nct6683_update_pwm(dev);
640 data->last_updated = jiffies;
644 mutex_unlock(&data->update_lock);
649 * Sysfs callback functions
652 show_in_label(struct device *dev, struct device_attribute *attr, char *buf)
654 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
655 struct nct6683_data *data = nct6683_update_device(dev);
656 int nr = sattr->index;
658 return sprintf(buf, "%s\n", nct6683_mon_label[data->in_src[nr]]);
662 show_in_reg(struct device *dev, struct device_attribute *attr, char *buf)
664 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
665 struct nct6683_data *data = nct6683_update_device(dev);
666 int index = sattr->index;
669 return sprintf(buf, "%ld\n",
670 in_from_reg(data->in[index][nr], data->in_index[index]));
673 static umode_t nct6683_in_is_visible(struct kobject *kobj,
674 struct attribute *attr, int index)
676 struct device *dev = kobj_to_dev(kobj);
677 struct nct6683_data *data = dev_get_drvdata(dev);
678 int nr = index % 4; /* attribute */
681 * Voltage limits exist for Intel boards,
682 * but register location and encoding is unknown
684 if ((nr == 2 || nr == 3) &&
685 data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
691 SENSOR_TEMPLATE(in_label, "in%d_label", S_IRUGO, show_in_label, NULL, 0);
692 SENSOR_TEMPLATE_2(in_input, "in%d_input", S_IRUGO, show_in_reg, NULL, 0, 0);
693 SENSOR_TEMPLATE_2(in_min, "in%d_min", S_IRUGO, show_in_reg, NULL, 0, 1);
694 SENSOR_TEMPLATE_2(in_max, "in%d_max", S_IRUGO, show_in_reg, NULL, 0, 2);
696 static struct sensor_device_template *nct6683_attributes_in_template[] = {
697 &sensor_dev_template_in_label,
698 &sensor_dev_template_in_input,
699 &sensor_dev_template_in_min,
700 &sensor_dev_template_in_max,
704 static const struct sensor_template_group nct6683_in_template_group = {
705 .templates = nct6683_attributes_in_template,
706 .is_visible = nct6683_in_is_visible,
710 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
712 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
713 struct nct6683_data *data = nct6683_update_device(dev);
715 return sprintf(buf, "%d\n", data->rpm[sattr->index]);
719 show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
721 struct nct6683_data *data = nct6683_update_device(dev);
722 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
723 int nr = sattr->index;
725 return sprintf(buf, "%d\n", data->fan_min[nr]);
729 show_fan_pulses(struct device *dev, struct device_attribute *attr, char *buf)
731 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
732 struct nct6683_data *data = nct6683_update_device(dev);
734 return sprintf(buf, "%d\n",
735 ((data->fanin_cfg[sattr->index] >> 5) & 0x03) + 1);
738 static umode_t nct6683_fan_is_visible(struct kobject *kobj,
739 struct attribute *attr, int index)
741 struct device *dev = kobj_to_dev(kobj);
742 struct nct6683_data *data = dev_get_drvdata(dev);
743 int fan = index / 3; /* fan index */
744 int nr = index % 3; /* attribute index */
746 if (!(data->have_fan & (1 << fan)))
750 * Intel may have minimum fan speed limits,
751 * but register location and encoding are unknown.
753 if (nr == 2 && data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
759 SENSOR_TEMPLATE(fan_input, "fan%d_input", S_IRUGO, show_fan, NULL, 0);
760 SENSOR_TEMPLATE(fan_pulses, "fan%d_pulses", S_IRUGO, show_fan_pulses, NULL, 0);
761 SENSOR_TEMPLATE(fan_min, "fan%d_min", S_IRUGO, show_fan_min, NULL, 0);
764 * nct6683_fan_is_visible uses the index into the following array
765 * to determine if attributes should be created or not.
766 * Any change in order or content must be matched.
768 static struct sensor_device_template *nct6683_attributes_fan_template[] = {
769 &sensor_dev_template_fan_input,
770 &sensor_dev_template_fan_pulses,
771 &sensor_dev_template_fan_min,
775 static const struct sensor_template_group nct6683_fan_template_group = {
776 .templates = nct6683_attributes_fan_template,
777 .is_visible = nct6683_fan_is_visible,
782 show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
784 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
785 struct nct6683_data *data = nct6683_update_device(dev);
786 int nr = sattr->index;
788 return sprintf(buf, "%s\n", nct6683_mon_label[data->temp_src[nr]]);
792 show_temp8(struct device *dev, struct device_attribute *attr, char *buf)
794 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
795 struct nct6683_data *data = nct6683_update_device(dev);
796 int index = sattr->index;
799 return sprintf(buf, "%d\n", data->temp[index][nr] * 1000);
803 show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
805 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
806 struct nct6683_data *data = nct6683_update_device(dev);
807 int nr = sattr->index;
808 int temp = data->temp[1][nr] - data->temp[2][nr];
810 return sprintf(buf, "%d\n", temp * 1000);
814 show_temp16(struct device *dev, struct device_attribute *attr, char *buf)
816 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
817 struct nct6683_data *data = nct6683_update_device(dev);
818 int index = sattr->index;
820 return sprintf(buf, "%d\n", (data->temp_in[index] / 128) * 500);
824 * Temperature sensor type is determined by temperature source
825 * and can not be modified.
826 * 0x02..0x07: Thermal diode
827 * 0x08..0x18: Thermistor
828 * 0x20..0x2b: Intel PECI
829 * 0x42..0x49: AMD TSI
830 * Others are unspecified (not visible)
833 static int get_temp_type(u8 src)
835 if (src >= 0x02 && src <= 0x07)
836 return 3; /* thermal diode */
837 else if (src >= 0x08 && src <= 0x18)
838 return 4; /* thermistor */
839 else if (src >= 0x20 && src <= 0x2b)
841 else if (src >= 0x42 && src <= 0x49)
848 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
850 struct nct6683_data *data = nct6683_update_device(dev);
851 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
852 int nr = sattr->index;
853 return sprintf(buf, "%d\n", get_temp_type(data->temp_src[nr]));
856 static umode_t nct6683_temp_is_visible(struct kobject *kobj,
857 struct attribute *attr, int index)
859 struct device *dev = kobj_to_dev(kobj);
860 struct nct6683_data *data = dev_get_drvdata(dev);
861 int temp = index / 7; /* temp index */
862 int nr = index % 7; /* attribute index */
865 * Intel does not have low temperature limits or temperature hysteresis
866 * registers, or at least register location and encoding is unknown.
868 if ((nr == 2 || nr == 4) &&
869 data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
872 if (nr == 6 && get_temp_type(data->temp_src[temp]) == 0)
878 SENSOR_TEMPLATE(temp_input, "temp%d_input", S_IRUGO, show_temp16, NULL, 0);
879 SENSOR_TEMPLATE(temp_label, "temp%d_label", S_IRUGO, show_temp_label, NULL, 0);
880 SENSOR_TEMPLATE_2(temp_min, "temp%d_min", S_IRUGO, show_temp8, NULL, 0, 0);
881 SENSOR_TEMPLATE_2(temp_max, "temp%d_max", S_IRUGO, show_temp8, NULL, 0, 1);
882 SENSOR_TEMPLATE(temp_max_hyst, "temp%d_max_hyst", S_IRUGO, show_temp_hyst, NULL,
884 SENSOR_TEMPLATE_2(temp_crit, "temp%d_crit", S_IRUGO, show_temp8, NULL, 0, 3);
885 SENSOR_TEMPLATE(temp_type, "temp%d_type", S_IRUGO, show_temp_type, NULL, 0);
888 * nct6683_temp_is_visible uses the index into the following array
889 * to determine if attributes should be created or not.
890 * Any change in order or content must be matched.
892 static struct sensor_device_template *nct6683_attributes_temp_template[] = {
893 &sensor_dev_template_temp_input,
894 &sensor_dev_template_temp_label,
895 &sensor_dev_template_temp_min, /* 2 */
896 &sensor_dev_template_temp_max, /* 3 */
897 &sensor_dev_template_temp_max_hyst, /* 4 */
898 &sensor_dev_template_temp_crit, /* 5 */
899 &sensor_dev_template_temp_type, /* 6 */
903 static const struct sensor_template_group nct6683_temp_template_group = {
904 .templates = nct6683_attributes_temp_template,
905 .is_visible = nct6683_temp_is_visible,
910 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
912 struct nct6683_data *data = nct6683_update_device(dev);
913 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
914 int index = sattr->index;
916 return sprintf(buf, "%d\n", data->pwm[index]);
920 store_pwm(struct device *dev, struct device_attribute *attr, const char *buf,
923 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
924 struct nct6683_data *data = dev_get_drvdata(dev);
925 int index = sattr->index;
928 if (kstrtoul(buf, 10, &val) || val > 255)
931 mutex_lock(&data->update_lock);
932 nct6683_write(data, NCT6683_REG_FAN_CFG_CTRL, NCT6683_FAN_CFG_REQ);
933 usleep_range(1000, 2000);
934 nct6683_write(data, NCT6683_REG_PWM_WRITE(index), val);
935 nct6683_write(data, NCT6683_REG_FAN_CFG_CTRL, NCT6683_FAN_CFG_DONE);
936 mutex_unlock(&data->update_lock);
941 SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, store_pwm, 0);
943 static umode_t nct6683_pwm_is_visible(struct kobject *kobj,
944 struct attribute *attr, int index)
946 struct device *dev = kobj_to_dev(kobj);
947 struct nct6683_data *data = dev_get_drvdata(dev);
948 int pwm = index; /* pwm index */
950 if (!(data->have_pwm & (1 << pwm)))
953 /* Only update pwm values for Mitac boards */
954 if (data->customer_id == NCT6683_CUSTOMER_ID_MITAC)
955 return attr->mode | S_IWUSR;
960 static struct sensor_device_template *nct6683_attributes_pwm_template[] = {
961 &sensor_dev_template_pwm,
965 static const struct sensor_template_group nct6683_pwm_template_group = {
966 .templates = nct6683_attributes_pwm_template,
967 .is_visible = nct6683_pwm_is_visible,
972 beep_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
974 struct nct6683_data *data = dev_get_drvdata(dev);
978 mutex_lock(&data->update_lock);
980 ret = superio_enter(data->sioreg);
983 superio_select(data->sioreg, NCT6683_LD_HWM);
984 reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
985 superio_exit(data->sioreg);
987 mutex_unlock(&data->update_lock);
989 return sprintf(buf, "%u\n", !!(reg & NCT6683_CR_BEEP_MASK));
992 mutex_unlock(&data->update_lock);
997 beep_enable_store(struct device *dev, struct device_attribute *attr,
998 const char *buf, size_t count)
1000 struct nct6683_data *data = dev_get_drvdata(dev);
1005 if (kstrtoul(buf, 10, &val) || (val != 0 && val != 1))
1008 mutex_lock(&data->update_lock);
1010 ret = superio_enter(data->sioreg);
1016 superio_select(data->sioreg, NCT6683_LD_HWM);
1017 reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
1019 reg |= NCT6683_CR_BEEP_MASK;
1021 reg &= ~NCT6683_CR_BEEP_MASK;
1022 superio_outb(data->sioreg, NCT6683_REG_CR_BEEP, reg);
1023 superio_exit(data->sioreg);
1025 mutex_unlock(&data->update_lock);
1029 /* Case open detection */
1032 intrusion0_alarm_show(struct device *dev, struct device_attribute *attr,
1035 struct nct6683_data *data = dev_get_drvdata(dev);
1039 mutex_lock(&data->update_lock);
1041 ret = superio_enter(data->sioreg);
1044 superio_select(data->sioreg, NCT6683_LD_ACPI);
1045 reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1046 superio_exit(data->sioreg);
1048 mutex_unlock(&data->update_lock);
1050 return sprintf(buf, "%u\n", !(reg & NCT6683_CR_CASEOPEN_MASK));
1053 mutex_unlock(&data->update_lock);
1058 intrusion0_alarm_store(struct device *dev, struct device_attribute *attr,
1059 const char *buf, size_t count)
1061 struct nct6683_data *data = dev_get_drvdata(dev);
1066 if (kstrtoul(buf, 10, &val) || val != 0)
1069 mutex_lock(&data->update_lock);
1072 * Use CR registers to clear caseopen status.
1073 * Caseopen is activ low, clear by writing 1 into the register.
1076 ret = superio_enter(data->sioreg);
1082 superio_select(data->sioreg, NCT6683_LD_ACPI);
1083 reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1084 reg |= NCT6683_CR_CASEOPEN_MASK;
1085 superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1086 reg &= ~NCT6683_CR_CASEOPEN_MASK;
1087 superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1088 superio_exit(data->sioreg);
1090 data->valid = false; /* Force cache refresh */
1092 mutex_unlock(&data->update_lock);
1096 static DEVICE_ATTR_RW(intrusion0_alarm);
1097 static DEVICE_ATTR_RW(beep_enable);
1099 static struct attribute *nct6683_attributes_other[] = {
1100 &dev_attr_intrusion0_alarm.attr,
1101 &dev_attr_beep_enable.attr,
1105 static const struct attribute_group nct6683_group_other = {
1106 .attrs = nct6683_attributes_other,
1109 /* Get the monitoring functions started */
1110 static inline void nct6683_init_device(struct nct6683_data *data)
1114 /* Start hardware monitoring if needed */
1115 tmp = nct6683_read(data, NCT6683_HWM_CFG);
1117 nct6683_write(data, NCT6683_HWM_CFG, tmp | 0x80);
1121 * There are a total of 24 fan inputs. Each can be configured as input
1122 * or as output. A maximum of 16 inputs and 8 outputs is configurable.
1125 nct6683_setup_fans(struct nct6683_data *data)
1130 for (i = 0; i < NCT6683_NUM_REG_FAN; i++) {
1131 reg = nct6683_read(data, NCT6683_REG_FANIN_CFG(i));
1133 data->have_fan |= 1 << i;
1134 data->fanin_cfg[i] = reg;
1136 for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
1137 reg = nct6683_read(data, NCT6683_REG_FANOUT_CFG(i));
1139 data->have_pwm |= 1 << i;
1140 data->fanout_cfg[i] = reg;
1145 * Translation from monitoring register to temperature and voltage attributes
1146 * ==========================================================================
1148 * There are a total of 32 monitoring registers. Each can be assigned to either
1149 * a temperature or voltage monitoring source.
1150 * NCT6683_REG_MON_CFG(x) defines assignment for each monitoring source.
1152 * Temperature and voltage attribute mapping is determined by walking through
1153 * the NCT6683_REG_MON_CFG registers. If the assigned source is
1154 * a temperature, temp_index[n] is set to the monitor register index, and
1155 * temp_src[n] is set to the temperature source. If the assigned source is
1156 * a voltage, the respective values are stored in in_index[] and in_src[],
1160 static void nct6683_setup_sensors(struct nct6683_data *data)
1167 for (i = 0; i < NCT6683_NUM_REG_MON; i++) {
1168 reg = nct6683_read(data, NCT6683_REG_MON_CFG(i)) & 0x7f;
1169 /* Ignore invalid assignments */
1170 if (reg >= NUM_MON_LABELS)
1172 /* Skip if disabled or reserved */
1173 if (nct6683_mon_label[reg] == NULL)
1175 if (reg < MON_VOLTAGE_START) {
1176 data->temp_index[data->temp_num] = i;
1177 data->temp_src[data->temp_num] = reg;
1180 data->in_index[data->in_num] = i;
1181 data->in_src[data->in_num] = reg;
1187 static int nct6683_probe(struct platform_device *pdev)
1189 struct device *dev = &pdev->dev;
1190 struct nct6683_sio_data *sio_data = dev->platform_data;
1191 struct attribute_group *group;
1192 struct nct6683_data *data;
1193 struct device *hwmon_dev;
1194 struct resource *res;
1198 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1199 if (!devm_request_region(dev, res->start, IOREGION_LENGTH, DRVNAME))
1202 data = devm_kzalloc(dev, sizeof(struct nct6683_data), GFP_KERNEL);
1206 data->kind = sio_data->kind;
1207 data->sioreg = sio_data->sioreg;
1208 data->addr = res->start;
1209 mutex_init(&data->update_lock);
1210 platform_set_drvdata(pdev, data);
1212 data->customer_id = nct6683_read16(data, NCT6683_REG_CUSTOMER_ID);
1214 /* By default only instantiate driver if the customer ID is known */
1215 switch (data->customer_id) {
1216 case NCT6683_CUSTOMER_ID_INTEL:
1218 case NCT6683_CUSTOMER_ID_MITAC:
1220 case NCT6683_CUSTOMER_ID_MSI:
1222 case NCT6683_CUSTOMER_ID_ASROCK:
1229 nct6683_init_device(data);
1230 nct6683_setup_fans(data);
1231 nct6683_setup_sensors(data);
1233 /* Register sysfs hooks */
1235 if (data->have_pwm) {
1236 group = nct6683_create_attr_group(dev,
1237 &nct6683_pwm_template_group,
1238 fls(data->have_pwm));
1240 return PTR_ERR(group);
1241 data->groups[groups++] = group;
1245 group = nct6683_create_attr_group(dev,
1246 &nct6683_in_template_group,
1249 return PTR_ERR(group);
1250 data->groups[groups++] = group;
1253 if (data->have_fan) {
1254 group = nct6683_create_attr_group(dev,
1255 &nct6683_fan_template_group,
1256 fls(data->have_fan));
1258 return PTR_ERR(group);
1259 data->groups[groups++] = group;
1262 if (data->temp_num) {
1263 group = nct6683_create_attr_group(dev,
1264 &nct6683_temp_template_group,
1267 return PTR_ERR(group);
1268 data->groups[groups++] = group;
1270 data->groups[groups++] = &nct6683_group_other;
1272 if (data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
1273 scnprintf(build, sizeof(build), "%02x/%02x/%02x",
1274 nct6683_read(data, NCT6683_REG_BUILD_MONTH),
1275 nct6683_read(data, NCT6683_REG_BUILD_DAY),
1276 nct6683_read(data, NCT6683_REG_BUILD_YEAR));
1278 scnprintf(build, sizeof(build), "%02d/%02d/%02d",
1279 nct6683_read(data, NCT6683_REG_BUILD_MONTH),
1280 nct6683_read(data, NCT6683_REG_BUILD_DAY),
1281 nct6683_read(data, NCT6683_REG_BUILD_YEAR));
1283 dev_info(dev, "%s EC firmware version %d.%d build %s\n",
1284 nct6683_chip_names[data->kind],
1285 nct6683_read(data, NCT6683_REG_VERSION_HI),
1286 nct6683_read(data, NCT6683_REG_VERSION_LO),
1289 hwmon_dev = devm_hwmon_device_register_with_groups(dev,
1290 nct6683_device_names[data->kind], data, data->groups);
1291 return PTR_ERR_OR_ZERO(hwmon_dev);
1295 static int nct6683_suspend(struct device *dev)
1297 struct nct6683_data *data = nct6683_update_device(dev);
1299 mutex_lock(&data->update_lock);
1300 data->hwm_cfg = nct6683_read(data, NCT6683_HWM_CFG);
1301 mutex_unlock(&data->update_lock);
1306 static int nct6683_resume(struct device *dev)
1308 struct nct6683_data *data = dev_get_drvdata(dev);
1310 mutex_lock(&data->update_lock);
1312 nct6683_write(data, NCT6683_HWM_CFG, data->hwm_cfg);
1314 /* Force re-reading all values */
1315 data->valid = false;
1316 mutex_unlock(&data->update_lock);
1321 static const struct dev_pm_ops nct6683_dev_pm_ops = {
1322 .suspend = nct6683_suspend,
1323 .resume = nct6683_resume,
1324 .freeze = nct6683_suspend,
1325 .restore = nct6683_resume,
1328 #define NCT6683_DEV_PM_OPS (&nct6683_dev_pm_ops)
1330 #define NCT6683_DEV_PM_OPS NULL
1331 #endif /* CONFIG_PM */
1333 static struct platform_driver nct6683_driver = {
1336 .pm = NCT6683_DEV_PM_OPS,
1338 .probe = nct6683_probe,
1341 static int __init nct6683_find(int sioaddr, struct nct6683_sio_data *sio_data)
1347 err = superio_enter(sioaddr);
1351 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1352 | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1354 switch (val & SIO_ID_MASK) {
1355 case SIO_NCT6683_ID:
1356 sio_data->kind = nct6683;
1358 case SIO_NCT6686_ID:
1359 sio_data->kind = nct6686;
1361 case SIO_NCT6687_ID:
1362 sio_data->kind = nct6687;
1366 pr_debug("unsupported chip ID: 0x%04x\n", val);
1370 /* We have a known chip, find the HWM I/O address */
1371 superio_select(sioaddr, NCT6683_LD_HWM);
1372 val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
1373 | superio_inb(sioaddr, SIO_REG_ADDR + 1);
1374 addr = val & IOREGION_ALIGNMENT;
1376 pr_err("EC base I/O port unconfigured\n");
1380 /* Activate logical device if needed */
1381 val = superio_inb(sioaddr, SIO_REG_ENABLE);
1382 if (!(val & 0x01)) {
1383 pr_warn("Forcibly enabling EC access. Data may be unusable.\n");
1384 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
1387 superio_exit(sioaddr);
1388 pr_info("Found %s or compatible chip at %#x:%#x\n",
1389 nct6683_chip_names[sio_data->kind], sioaddr, addr);
1390 sio_data->sioreg = sioaddr;
1395 superio_exit(sioaddr);
1400 * when Super-I/O functions move to a separate file, the Super-I/O
1401 * bus will manage the lifetime of the device and this module will only keep
1402 * track of the nct6683 driver. But since we use platform_device_alloc(), we
1403 * must keep track of the device
1405 static struct platform_device *pdev[2];
1407 static int __init sensors_nct6683_init(void)
1409 struct nct6683_sio_data sio_data;
1410 int sioaddr[2] = { 0x2e, 0x4e };
1411 struct resource res;
1416 err = platform_driver_register(&nct6683_driver);
1421 * initialize sio_data->kind and sio_data->sioreg.
1423 * when Super-I/O functions move to a separate file, the Super-I/O
1424 * driver will probe 0x2e and 0x4e and auto-detect the presence of a
1425 * nct6683 hardware monitor, and call probe()
1427 for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1428 address = nct6683_find(sioaddr[i], &sio_data);
1434 pdev[i] = platform_device_alloc(DRVNAME, address);
1437 goto exit_device_unregister;
1440 err = platform_device_add_data(pdev[i], &sio_data,
1441 sizeof(struct nct6683_sio_data));
1443 goto exit_device_put;
1445 memset(&res, 0, sizeof(res));
1447 res.start = address + IOREGION_OFFSET;
1448 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1449 res.flags = IORESOURCE_IO;
1451 err = acpi_check_resource_conflict(&res);
1453 platform_device_put(pdev[i]);
1458 err = platform_device_add_resources(pdev[i], &res, 1);
1460 goto exit_device_put;
1462 /* platform_device_add calls probe() */
1463 err = platform_device_add(pdev[i]);
1465 goto exit_device_put;
1469 goto exit_unregister;
1475 platform_device_put(pdev[i]);
1476 exit_device_unregister:
1479 platform_device_unregister(pdev[i]);
1482 platform_driver_unregister(&nct6683_driver);
1486 static void __exit sensors_nct6683_exit(void)
1490 for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1492 platform_device_unregister(pdev[i]);
1494 platform_driver_unregister(&nct6683_driver);
1497 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
1498 MODULE_DESCRIPTION("NCT6683D driver");
1499 MODULE_LICENSE("GPL");
1501 module_init(sensors_nct6683_init);
1502 module_exit(sensors_nct6683_exit);