xref: /openbmc/linux/drivers/hwmon/nct6683.c (revision 7c415ed8)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * nct6683 - Driver for the hardware monitoring functionality of
4  *	     Nuvoton NCT6683D/NCT6686D/NCT6687D eSIO
5  *
6  * Copyright (C) 2013  Guenter Roeck <linux@roeck-us.net>
7  *
8  * Derived from nct6775 driver
9  * Copyright (C) 2012, 2013  Guenter Roeck <linux@roeck-us.net>
10  *
11  * Supports the following chips:
12  *
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
17  *
18  * Notes:
19  *	(1) Total number of vin and temp inputs is 32.
20  */
21 
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23 
24 #include <linux/acpi.h>
25 #include <linux/delay.h>
26 #include <linux/err.h>
27 #include <linux/init.h>
28 #include <linux/io.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>
36 
37 enum kinds { nct6683, nct6686, nct6687 };
38 
39 static bool force;
40 module_param(force, bool, 0);
41 MODULE_PARM_DESC(force, "Set to one to enable support for unknown vendors");
42 
43 static const char * const nct6683_device_names[] = {
44 	"nct6683",
45 	"nct6686",
46 	"nct6687",
47 };
48 
49 static const char * const nct6683_chip_names[] = {
50 	"NCT6683D",
51 	"NCT6686D",
52 	"NCT6687D",
53 };
54 
55 #define DRVNAME "nct6683"
56 
57 /*
58  * Super-I/O constants and functions
59  */
60 
61 #define NCT6683_LD_ACPI		0x0a
62 #define NCT6683_LD_HWM		0x0b
63 #define NCT6683_LD_VID		0x0d
64 
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) */
69 
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
75 
76 static inline void
superio_outb(int ioreg,int reg,int val)77 superio_outb(int ioreg, int reg, int val)
78 {
79 	outb(reg, ioreg);
80 	outb(val, ioreg + 1);
81 }
82 
83 static inline int
superio_inb(int ioreg,int reg)84 superio_inb(int ioreg, int reg)
85 {
86 	outb(reg, ioreg);
87 	return inb(ioreg + 1);
88 }
89 
90 static inline void
superio_select(int ioreg,int ld)91 superio_select(int ioreg, int ld)
92 {
93 	outb(SIO_REG_LDSEL, ioreg);
94 	outb(ld, ioreg + 1);
95 }
96 
97 static inline int
superio_enter(int ioreg)98 superio_enter(int ioreg)
99 {
100 	/*
101 	 * Try to reserve <ioreg> and <ioreg + 1> for exclusive access.
102 	 */
103 	if (!request_muxed_region(ioreg, 2, DRVNAME))
104 		return -EBUSY;
105 
106 	outb(0x87, ioreg);
107 	outb(0x87, ioreg);
108 
109 	return 0;
110 }
111 
112 static inline void
superio_exit(int ioreg)113 superio_exit(int ioreg)
114 {
115 	outb(0xaa, ioreg);
116 	outb(0x02, ioreg);
117 	outb(0x02, ioreg + 1);
118 	release_region(ioreg, 2);
119 }
120 
121 /*
122  * ISA constants
123  */
124 
125 #define IOREGION_ALIGNMENT	(~7)
126 #define IOREGION_OFFSET		4	/* Use EC port 1 */
127 #define IOREGION_LENGTH		4
128 
129 #define EC_PAGE_REG		0
130 #define EC_INDEX_REG		1
131 #define EC_DATA_REG		2
132 #define EC_EVENT_REG		3
133 
134 /* Common and NCT6683 specific data */
135 
136 #define NCT6683_NUM_REG_MON		32
137 #define NCT6683_NUM_REG_FAN		16
138 #define NCT6683_NUM_REG_PWM		8
139 
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))
144 
145 #define NCT6683_REG_MON_STS(x)		(0x174 + (x))
146 #define NCT6683_REG_IDLE(x)		(0x178 + (x))
147 
148 #define NCT6683_REG_FAN_STS(x)		(0x17c + (x))
149 #define NCT6683_REG_FAN_ERRSTS		0x17e
150 #define NCT6683_REG_FAN_INITSTS		0x17f
151 
152 #define NCT6683_HWM_CFG			0x180
153 
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))
157 
158 #define NCT6683_REG_INTEL_TEMP_MAX(x)	(0x901 + (x) * 16)
159 #define NCT6683_REG_INTEL_TEMP_CRIT(x)	(0x90d + (x) * 16)
160 
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 */
165 
166 #define NCT6683_REG_FAN_MIN(x)		(0x3b8 + (x) * 2)	/* 16 bit */
167 
168 #define NCT6683_REG_FAN_CFG_CTRL	0xa01
169 #define NCT6683_FAN_CFG_REQ		0x80
170 #define NCT6683_FAN_CFG_DONE		0x40
171 
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_MSI2	0x200
177 #define NCT6683_CUSTOMER_ID_ASROCK		0xe2c
178 #define NCT6683_CUSTOMER_ID_ASROCK2	0xe1b
179 
180 #define NCT6683_REG_BUILD_YEAR		0x604
181 #define NCT6683_REG_BUILD_MONTH		0x605
182 #define NCT6683_REG_BUILD_DAY		0x606
183 #define NCT6683_REG_SERIAL		0x607
184 #define NCT6683_REG_VERSION_HI		0x608
185 #define NCT6683_REG_VERSION_LO		0x609
186 
187 #define NCT6683_REG_CR_CASEOPEN		0xe8
188 #define NCT6683_CR_CASEOPEN_MASK	(1 << 7)
189 
190 #define NCT6683_REG_CR_BEEP		0xe0
191 #define NCT6683_CR_BEEP_MASK		(1 << 6)
192 
193 static const char *const nct6683_mon_label[] = {
194 	NULL,	/* disabled */
195 	"Local",
196 	"Diode 0 (curr)",
197 	"Diode 1 (curr)",
198 	"Diode 2 (curr)",
199 	"Diode 0 (volt)",
200 	"Diode 1 (volt)",
201 	"Diode 2 (volt)",
202 	"Thermistor 14",
203 	"Thermistor 15",
204 	"Thermistor 16",
205 	"Thermistor 0",
206 	"Thermistor 1",
207 	"Thermistor 2",
208 	"Thermistor 3",
209 	"Thermistor 4",
210 	"Thermistor 5",		/* 0x10 */
211 	"Thermistor 6",
212 	"Thermistor 7",
213 	"Thermistor 8",
214 	"Thermistor 9",
215 	"Thermistor 10",
216 	"Thermistor 11",
217 	"Thermistor 12",
218 	"Thermistor 13",
219 	NULL, NULL, NULL, NULL, NULL, NULL, NULL,
220 	"PECI 0.0",		/* 0x20 */
221 	"PECI 1.0",
222 	"PECI 2.0",
223 	"PECI 3.0",
224 	"PECI 0.1",
225 	"PECI 1.1",
226 	"PECI 2.1",
227 	"PECI 3.1",
228 	"PECI DIMM 0",
229 	"PECI DIMM 1",
230 	"PECI DIMM 2",
231 	"PECI DIMM 3",
232 	NULL, NULL, NULL, NULL,
233 	"PCH CPU",		/* 0x30 */
234 	"PCH CHIP",
235 	"PCH CHIP CPU MAX",
236 	"PCH MCH",
237 	"PCH DIMM 0",
238 	"PCH DIMM 1",
239 	"PCH DIMM 2",
240 	"PCH DIMM 3",
241 	"SMBus 0",
242 	"SMBus 1",
243 	"SMBus 2",
244 	"SMBus 3",
245 	"SMBus 4",
246 	"SMBus 5",
247 	"DIMM 0",
248 	"DIMM 1",
249 	"DIMM 2",		/* 0x40 */
250 	"DIMM 3",
251 	"AMD TSI Addr 90h",
252 	"AMD TSI Addr 92h",
253 	"AMD TSI Addr 94h",
254 	"AMD TSI Addr 96h",
255 	"AMD TSI Addr 98h",
256 	"AMD TSI Addr 9ah",
257 	"AMD TSI Addr 9ch",
258 	"AMD TSI Addr 9dh",
259 	NULL, NULL, NULL, NULL, NULL, NULL,
260 	"Virtual 0",		/* 0x50 */
261 	"Virtual 1",
262 	"Virtual 2",
263 	"Virtual 3",
264 	"Virtual 4",
265 	"Virtual 5",
266 	"Virtual 6",
267 	"Virtual 7",
268 	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
269 	"VCC",			/* 0x60 voltage sensors */
270 	"VSB",
271 	"AVSB",
272 	"VTT",
273 	"VBAT",
274 	"VREF",
275 	"VIN0",
276 	"VIN1",
277 	"VIN2",
278 	"VIN3",
279 	"VIN4",
280 	"VIN5",
281 	"VIN6",
282 	"VIN7",
283 	"VIN8",
284 	"VIN9",
285 	"VIN10",
286 	"VIN11",
287 	"VIN12",
288 	"VIN13",
289 	"VIN14",
290 	"VIN15",
291 	"VIN16",
292 };
293 
294 #define NUM_MON_LABELS		ARRAY_SIZE(nct6683_mon_label)
295 #define MON_VOLTAGE_START	0x60
296 
297 /* ------------------------------------------------------- */
298 
299 struct nct6683_data {
300 	int addr;		/* IO base of EC space */
301 	int sioreg;		/* SIO register */
302 	enum kinds kind;
303 	u16 customer_id;
304 
305 	struct device *hwmon_dev;
306 	const struct attribute_group *groups[6];
307 
308 	int temp_num;			/* number of temperature attributes */
309 	u8 temp_index[NCT6683_NUM_REG_MON];
310 	u8 temp_src[NCT6683_NUM_REG_MON];
311 
312 	u8 in_num;			/* number of voltage attributes */
313 	u8 in_index[NCT6683_NUM_REG_MON];
314 	u8 in_src[NCT6683_NUM_REG_MON];
315 
316 	struct mutex update_lock;	/* used to protect sensor updates */
317 	bool valid;			/* true if following fields are valid */
318 	unsigned long last_updated;	/* In jiffies */
319 
320 	/* Voltage attribute values */
321 	u8 in[3][NCT6683_NUM_REG_MON];	/* [0]=in, [1]=in_max, [2]=in_min */
322 
323 	/* Temperature attribute values */
324 	s16 temp_in[NCT6683_NUM_REG_MON];
325 	s8 temp[4][NCT6683_NUM_REG_MON];/* [0]=min, [1]=max, [2]=hyst,
326 					 * [3]=crit
327 					 */
328 
329 	/* Fan attribute values */
330 	unsigned int rpm[NCT6683_NUM_REG_FAN];
331 	u16 fan_min[NCT6683_NUM_REG_FAN];
332 	u8 fanin_cfg[NCT6683_NUM_REG_FAN];
333 	u8 fanout_cfg[NCT6683_NUM_REG_FAN];
334 	u16 have_fan;			/* some fan inputs can be disabled */
335 
336 	u8 have_pwm;
337 	u8 pwm[NCT6683_NUM_REG_PWM];
338 
339 #ifdef CONFIG_PM
340 	/* Remember extra register values over suspend/resume */
341 	u8 hwm_cfg;
342 #endif
343 };
344 
345 struct nct6683_sio_data {
346 	int sioreg;
347 	enum kinds kind;
348 };
349 
350 struct sensor_device_template {
351 	struct device_attribute dev_attr;
352 	union {
353 		struct {
354 			u8 nr;
355 			u8 index;
356 		} s;
357 		int index;
358 	} u;
359 	bool s2;	/* true if both index and nr are used */
360 };
361 
362 struct sensor_device_attr_u {
363 	union {
364 		struct sensor_device_attribute a1;
365 		struct sensor_device_attribute_2 a2;
366 	} u;
367 	char name[32];
368 };
369 
370 #define __TEMPLATE_ATTR(_template, _mode, _show, _store) {	\
371 	.attr = {.name = _template, .mode = _mode },		\
372 	.show	= _show,					\
373 	.store	= _store,					\
374 }
375 
376 #define SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, _index)	\
377 	{ .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store),	\
378 	  .u.index = _index,						\
379 	  .s2 = false }
380 
381 #define SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store,	\
382 				 _nr, _index)				\
383 	{ .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store),	\
384 	  .u.s.index = _index,						\
385 	  .u.s.nr = _nr,						\
386 	  .s2 = true }
387 
388 #define SENSOR_TEMPLATE(_name, _template, _mode, _show, _store, _index)	\
389 static struct sensor_device_template sensor_dev_template_##_name	\
390 	= SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store,	\
391 				 _index)
392 
393 #define SENSOR_TEMPLATE_2(_name, _template, _mode, _show, _store,	\
394 			  _nr, _index)					\
395 static struct sensor_device_template sensor_dev_template_##_name	\
396 	= SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store,	\
397 				 _nr, _index)
398 
399 struct sensor_template_group {
400 	struct sensor_device_template **templates;
401 	umode_t (*is_visible)(struct kobject *, struct attribute *, int);
402 	int base;
403 };
404 
405 static struct attribute_group *
nct6683_create_attr_group(struct device * dev,const struct sensor_template_group * tg,int repeat)406 nct6683_create_attr_group(struct device *dev,
407 			  const struct sensor_template_group *tg,
408 			  int repeat)
409 {
410 	struct sensor_device_attribute_2 *a2;
411 	struct sensor_device_attribute *a;
412 	struct sensor_device_template **t;
413 	struct sensor_device_attr_u *su;
414 	struct attribute_group *group;
415 	struct attribute **attrs;
416 	int i, count;
417 
418 	if (repeat <= 0)
419 		return ERR_PTR(-EINVAL);
420 
421 	t = tg->templates;
422 	for (count = 0; *t; t++, count++)
423 		;
424 
425 	if (count == 0)
426 		return ERR_PTR(-EINVAL);
427 
428 	group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL);
429 	if (group == NULL)
430 		return ERR_PTR(-ENOMEM);
431 
432 	attrs = devm_kcalloc(dev, repeat * count + 1, sizeof(*attrs),
433 			     GFP_KERNEL);
434 	if (attrs == NULL)
435 		return ERR_PTR(-ENOMEM);
436 
437 	su = devm_kzalloc(dev, array3_size(repeat, count, sizeof(*su)),
438 			  GFP_KERNEL);
439 	if (su == NULL)
440 		return ERR_PTR(-ENOMEM);
441 
442 	group->attrs = attrs;
443 	group->is_visible = tg->is_visible;
444 
445 	for (i = 0; i < repeat; i++) {
446 		t = tg->templates;
447 		while (*t) {
448 			snprintf(su->name, sizeof(su->name),
449 				 (*t)->dev_attr.attr.name, tg->base + i);
450 			if ((*t)->s2) {
451 				a2 = &su->u.a2;
452 				sysfs_attr_init(&a2->dev_attr.attr);
453 				a2->dev_attr.attr.name = su->name;
454 				a2->nr = (*t)->u.s.nr + i;
455 				a2->index = (*t)->u.s.index;
456 				a2->dev_attr.attr.mode =
457 				  (*t)->dev_attr.attr.mode;
458 				a2->dev_attr.show = (*t)->dev_attr.show;
459 				a2->dev_attr.store = (*t)->dev_attr.store;
460 				*attrs = &a2->dev_attr.attr;
461 			} else {
462 				a = &su->u.a1;
463 				sysfs_attr_init(&a->dev_attr.attr);
464 				a->dev_attr.attr.name = su->name;
465 				a->index = (*t)->u.index + i;
466 				a->dev_attr.attr.mode =
467 				  (*t)->dev_attr.attr.mode;
468 				a->dev_attr.show = (*t)->dev_attr.show;
469 				a->dev_attr.store = (*t)->dev_attr.store;
470 				*attrs = &a->dev_attr.attr;
471 			}
472 			attrs++;
473 			su++;
474 			t++;
475 		}
476 	}
477 
478 	return group;
479 }
480 
481 /* LSB is 16 mV, except for the following sources, where it is 32 mV */
482 #define MON_SRC_VCC	0x60
483 #define MON_SRC_VSB	0x61
484 #define MON_SRC_AVSB	0x62
485 #define MON_SRC_VBAT	0x64
486 
in_from_reg(u16 reg,u8 src)487 static inline long in_from_reg(u16 reg, u8 src)
488 {
489 	int scale = 16;
490 
491 	if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB ||
492 	    src == MON_SRC_VBAT)
493 		scale <<= 1;
494 	return reg * scale;
495 }
496 
nct6683_read(struct nct6683_data * data,u16 reg)497 static u16 nct6683_read(struct nct6683_data *data, u16 reg)
498 {
499 	int res;
500 
501 	outb_p(0xff, data->addr + EC_PAGE_REG);		/* unlock */
502 	outb_p(reg >> 8, data->addr + EC_PAGE_REG);
503 	outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
504 	res = inb_p(data->addr + EC_DATA_REG);
505 	return res;
506 }
507 
nct6683_read16(struct nct6683_data * data,u16 reg)508 static u16 nct6683_read16(struct nct6683_data *data, u16 reg)
509 {
510 	return (nct6683_read(data, reg) << 8) | nct6683_read(data, reg + 1);
511 }
512 
nct6683_write(struct nct6683_data * data,u16 reg,u16 value)513 static void nct6683_write(struct nct6683_data *data, u16 reg, u16 value)
514 {
515 	outb_p(0xff, data->addr + EC_PAGE_REG);		/* unlock */
516 	outb_p(reg >> 8, data->addr + EC_PAGE_REG);
517 	outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
518 	outb_p(value & 0xff, data->addr + EC_DATA_REG);
519 }
520 
get_in_reg(struct nct6683_data * data,int nr,int index)521 static int get_in_reg(struct nct6683_data *data, int nr, int index)
522 {
523 	int ch = data->in_index[index];
524 	int reg = -EINVAL;
525 
526 	switch (nr) {
527 	case 0:
528 		reg = NCT6683_REG_MON(ch);
529 		break;
530 	case 1:
531 		if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
532 			reg = NCT6683_REG_MON_LOW(ch);
533 		break;
534 	case 2:
535 		if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
536 			reg = NCT6683_REG_MON_HIGH(ch);
537 		break;
538 	default:
539 		break;
540 	}
541 	return reg;
542 }
543 
get_temp_reg(struct nct6683_data * data,int nr,int index)544 static int get_temp_reg(struct nct6683_data *data, int nr, int index)
545 {
546 	int ch = data->temp_index[index];
547 	int reg = -EINVAL;
548 
549 	switch (data->customer_id) {
550 	case NCT6683_CUSTOMER_ID_INTEL:
551 		switch (nr) {
552 		default:
553 		case 1:	/* max */
554 			reg = NCT6683_REG_INTEL_TEMP_MAX(ch);
555 			break;
556 		case 3:	/* crit */
557 			reg = NCT6683_REG_INTEL_TEMP_CRIT(ch);
558 			break;
559 		}
560 		break;
561 	case NCT6683_CUSTOMER_ID_MITAC:
562 	default:
563 		switch (nr) {
564 		default:
565 		case 0:	/* min */
566 			reg = NCT6683_REG_MON_LOW(ch);
567 			break;
568 		case 1:	/* max */
569 			reg = NCT6683_REG_TEMP_MAX(ch);
570 			break;
571 		case 2:	/* hyst */
572 			reg = NCT6683_REG_TEMP_HYST(ch);
573 			break;
574 		case 3:	/* crit */
575 			reg = NCT6683_REG_MON_HIGH(ch);
576 			break;
577 		}
578 		break;
579 	}
580 	return reg;
581 }
582 
nct6683_update_pwm(struct device * dev)583 static void nct6683_update_pwm(struct device *dev)
584 {
585 	struct nct6683_data *data = dev_get_drvdata(dev);
586 	int i;
587 
588 	for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
589 		if (!(data->have_pwm & (1 << i)))
590 			continue;
591 		data->pwm[i] = nct6683_read(data, NCT6683_REG_PWM(i));
592 	}
593 }
594 
nct6683_update_device(struct device * dev)595 static struct nct6683_data *nct6683_update_device(struct device *dev)
596 {
597 	struct nct6683_data *data = dev_get_drvdata(dev);
598 	int i, j;
599 
600 	mutex_lock(&data->update_lock);
601 
602 	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
603 		/* Measured voltages and limits */
604 		for (i = 0; i < data->in_num; i++) {
605 			for (j = 0; j < 3; j++) {
606 				int reg = get_in_reg(data, j, i);
607 
608 				if (reg >= 0)
609 					data->in[j][i] =
610 						nct6683_read(data, reg);
611 			}
612 		}
613 
614 		/* Measured temperatures and limits */
615 		for (i = 0; i < data->temp_num; i++) {
616 			u8 ch = data->temp_index[i];
617 
618 			data->temp_in[i] = nct6683_read16(data,
619 							  NCT6683_REG_MON(ch));
620 			for (j = 0; j < 4; j++) {
621 				int reg = get_temp_reg(data, j, i);
622 
623 				if (reg >= 0)
624 					data->temp[j][i] =
625 						nct6683_read(data, reg);
626 			}
627 		}
628 
629 		/* Measured fan speeds and limits */
630 		for (i = 0; i < ARRAY_SIZE(data->rpm); i++) {
631 			if (!(data->have_fan & (1 << i)))
632 				continue;
633 
634 			data->rpm[i] = nct6683_read16(data,
635 						NCT6683_REG_FAN_RPM(i));
636 			data->fan_min[i] = nct6683_read16(data,
637 						NCT6683_REG_FAN_MIN(i));
638 		}
639 
640 		nct6683_update_pwm(dev);
641 
642 		data->last_updated = jiffies;
643 		data->valid = true;
644 	}
645 
646 	mutex_unlock(&data->update_lock);
647 	return data;
648 }
649 
650 /*
651  * Sysfs callback functions
652  */
653 static ssize_t
show_in_label(struct device * dev,struct device_attribute * attr,char * buf)654 show_in_label(struct device *dev, struct device_attribute *attr, char *buf)
655 {
656 	struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
657 	struct nct6683_data *data = nct6683_update_device(dev);
658 	int nr = sattr->index;
659 
660 	return sprintf(buf, "%s\n", nct6683_mon_label[data->in_src[nr]]);
661 }
662 
663 static ssize_t
show_in_reg(struct device * dev,struct device_attribute * attr,char * buf)664 show_in_reg(struct device *dev, struct device_attribute *attr, char *buf)
665 {
666 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
667 	struct nct6683_data *data = nct6683_update_device(dev);
668 	int index = sattr->index;
669 	int nr = sattr->nr;
670 
671 	return sprintf(buf, "%ld\n",
672 		       in_from_reg(data->in[index][nr], data->in_index[index]));
673 }
674 
nct6683_in_is_visible(struct kobject * kobj,struct attribute * attr,int index)675 static umode_t nct6683_in_is_visible(struct kobject *kobj,
676 				     struct attribute *attr, int index)
677 {
678 	struct device *dev = kobj_to_dev(kobj);
679 	struct nct6683_data *data = dev_get_drvdata(dev);
680 	int nr = index % 4;	/* attribute */
681 
682 	/*
683 	 * Voltage limits exist for Intel boards,
684 	 * but register location and encoding is unknown
685 	 */
686 	if ((nr == 2 || nr == 3) &&
687 	    data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
688 		return 0;
689 
690 	return attr->mode;
691 }
692 
693 SENSOR_TEMPLATE(in_label, "in%d_label", S_IRUGO, show_in_label, NULL, 0);
694 SENSOR_TEMPLATE_2(in_input, "in%d_input", S_IRUGO, show_in_reg, NULL, 0, 0);
695 SENSOR_TEMPLATE_2(in_min, "in%d_min", S_IRUGO, show_in_reg, NULL, 0, 1);
696 SENSOR_TEMPLATE_2(in_max, "in%d_max", S_IRUGO, show_in_reg, NULL, 0, 2);
697 
698 static struct sensor_device_template *nct6683_attributes_in_template[] = {
699 	&sensor_dev_template_in_label,
700 	&sensor_dev_template_in_input,
701 	&sensor_dev_template_in_min,
702 	&sensor_dev_template_in_max,
703 	NULL
704 };
705 
706 static const struct sensor_template_group nct6683_in_template_group = {
707 	.templates = nct6683_attributes_in_template,
708 	.is_visible = nct6683_in_is_visible,
709 };
710 
711 static ssize_t
show_fan(struct device * dev,struct device_attribute * attr,char * buf)712 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
713 {
714 	struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
715 	struct nct6683_data *data = nct6683_update_device(dev);
716 
717 	return sprintf(buf, "%d\n", data->rpm[sattr->index]);
718 }
719 
720 static ssize_t
show_fan_min(struct device * dev,struct device_attribute * attr,char * buf)721 show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
722 {
723 	struct nct6683_data *data = nct6683_update_device(dev);
724 	struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
725 	int nr = sattr->index;
726 
727 	return sprintf(buf, "%d\n", data->fan_min[nr]);
728 }
729 
730 static ssize_t
show_fan_pulses(struct device * dev,struct device_attribute * attr,char * buf)731 show_fan_pulses(struct device *dev, struct device_attribute *attr, char *buf)
732 {
733 	struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
734 	struct nct6683_data *data = nct6683_update_device(dev);
735 
736 	return sprintf(buf, "%d\n",
737 		       ((data->fanin_cfg[sattr->index] >> 5) & 0x03) + 1);
738 }
739 
nct6683_fan_is_visible(struct kobject * kobj,struct attribute * attr,int index)740 static umode_t nct6683_fan_is_visible(struct kobject *kobj,
741 				      struct attribute *attr, int index)
742 {
743 	struct device *dev = kobj_to_dev(kobj);
744 	struct nct6683_data *data = dev_get_drvdata(dev);
745 	int fan = index / 3;	/* fan index */
746 	int nr = index % 3;	/* attribute index */
747 
748 	if (!(data->have_fan & (1 << fan)))
749 		return 0;
750 
751 	/*
752 	 * Intel may have minimum fan speed limits,
753 	 * but register location and encoding are unknown.
754 	 */
755 	if (nr == 2 && data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
756 		return 0;
757 
758 	return attr->mode;
759 }
760 
761 SENSOR_TEMPLATE(fan_input, "fan%d_input", S_IRUGO, show_fan, NULL, 0);
762 SENSOR_TEMPLATE(fan_pulses, "fan%d_pulses", S_IRUGO, show_fan_pulses, NULL, 0);
763 SENSOR_TEMPLATE(fan_min, "fan%d_min", S_IRUGO, show_fan_min, NULL, 0);
764 
765 /*
766  * nct6683_fan_is_visible uses the index into the following array
767  * to determine if attributes should be created or not.
768  * Any change in order or content must be matched.
769  */
770 static struct sensor_device_template *nct6683_attributes_fan_template[] = {
771 	&sensor_dev_template_fan_input,
772 	&sensor_dev_template_fan_pulses,
773 	&sensor_dev_template_fan_min,
774 	NULL
775 };
776 
777 static const struct sensor_template_group nct6683_fan_template_group = {
778 	.templates = nct6683_attributes_fan_template,
779 	.is_visible = nct6683_fan_is_visible,
780 	.base = 1,
781 };
782 
783 static ssize_t
show_temp_label(struct device * dev,struct device_attribute * attr,char * buf)784 show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
785 {
786 	struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
787 	struct nct6683_data *data = nct6683_update_device(dev);
788 	int nr = sattr->index;
789 
790 	return sprintf(buf, "%s\n", nct6683_mon_label[data->temp_src[nr]]);
791 }
792 
793 static ssize_t
show_temp8(struct device * dev,struct device_attribute * attr,char * buf)794 show_temp8(struct device *dev, struct device_attribute *attr, char *buf)
795 {
796 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
797 	struct nct6683_data *data = nct6683_update_device(dev);
798 	int index = sattr->index;
799 	int nr = sattr->nr;
800 
801 	return sprintf(buf, "%d\n", data->temp[index][nr] * 1000);
802 }
803 
804 static ssize_t
show_temp_hyst(struct device * dev,struct device_attribute * attr,char * buf)805 show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
806 {
807 	struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
808 	struct nct6683_data *data = nct6683_update_device(dev);
809 	int nr = sattr->index;
810 	int temp = data->temp[1][nr] - data->temp[2][nr];
811 
812 	return sprintf(buf, "%d\n", temp * 1000);
813 }
814 
815 static ssize_t
show_temp16(struct device * dev,struct device_attribute * attr,char * buf)816 show_temp16(struct device *dev, struct device_attribute *attr, char *buf)
817 {
818 	struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
819 	struct nct6683_data *data = nct6683_update_device(dev);
820 	int index = sattr->index;
821 
822 	return sprintf(buf, "%d\n", (data->temp_in[index] / 128) * 500);
823 }
824 
825 /*
826  * Temperature sensor type is determined by temperature source
827  * and can not be modified.
828  * 0x02..0x07: Thermal diode
829  * 0x08..0x18: Thermistor
830  * 0x20..0x2b: Intel PECI
831  * 0x42..0x49: AMD TSI
832  * Others are unspecified (not visible)
833  */
834 
get_temp_type(u8 src)835 static int get_temp_type(u8 src)
836 {
837 	if (src >= 0x02 && src <= 0x07)
838 		return 3;	/* thermal diode */
839 	else if (src >= 0x08 && src <= 0x18)
840 		return 4;	/* thermistor */
841 	else if (src >= 0x20 && src <= 0x2b)
842 		return 6;	/* PECI */
843 	else if (src >= 0x42 && src <= 0x49)
844 		return 5;
845 
846 	return 0;
847 }
848 
849 static ssize_t
show_temp_type(struct device * dev,struct device_attribute * attr,char * buf)850 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
851 {
852 	struct nct6683_data *data = nct6683_update_device(dev);
853 	struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
854 	int nr = sattr->index;
855 	return sprintf(buf, "%d\n", get_temp_type(data->temp_src[nr]));
856 }
857 
nct6683_temp_is_visible(struct kobject * kobj,struct attribute * attr,int index)858 static umode_t nct6683_temp_is_visible(struct kobject *kobj,
859 				       struct attribute *attr, int index)
860 {
861 	struct device *dev = kobj_to_dev(kobj);
862 	struct nct6683_data *data = dev_get_drvdata(dev);
863 	int temp = index / 7;	/* temp index */
864 	int nr = index % 7;	/* attribute index */
865 
866 	/*
867 	 * Intel does not have low temperature limits or temperature hysteresis
868 	 * registers, or at least register location and encoding is unknown.
869 	 */
870 	if ((nr == 2 || nr == 4) &&
871 	    data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
872 		return 0;
873 
874 	if (nr == 6 && get_temp_type(data->temp_src[temp]) == 0)
875 		return 0;				/* type */
876 
877 	return attr->mode;
878 }
879 
880 SENSOR_TEMPLATE(temp_input, "temp%d_input", S_IRUGO, show_temp16, NULL, 0);
881 SENSOR_TEMPLATE(temp_label, "temp%d_label", S_IRUGO, show_temp_label, NULL, 0);
882 SENSOR_TEMPLATE_2(temp_min, "temp%d_min", S_IRUGO, show_temp8, NULL, 0, 0);
883 SENSOR_TEMPLATE_2(temp_max, "temp%d_max", S_IRUGO, show_temp8, NULL, 0, 1);
884 SENSOR_TEMPLATE(temp_max_hyst, "temp%d_max_hyst", S_IRUGO, show_temp_hyst, NULL,
885 		0);
886 SENSOR_TEMPLATE_2(temp_crit, "temp%d_crit", S_IRUGO, show_temp8, NULL, 0, 3);
887 SENSOR_TEMPLATE(temp_type, "temp%d_type", S_IRUGO, show_temp_type, NULL, 0);
888 
889 /*
890  * nct6683_temp_is_visible uses the index into the following array
891  * to determine if attributes should be created or not.
892  * Any change in order or content must be matched.
893  */
894 static struct sensor_device_template *nct6683_attributes_temp_template[] = {
895 	&sensor_dev_template_temp_input,
896 	&sensor_dev_template_temp_label,
897 	&sensor_dev_template_temp_min,		/* 2 */
898 	&sensor_dev_template_temp_max,		/* 3 */
899 	&sensor_dev_template_temp_max_hyst,	/* 4 */
900 	&sensor_dev_template_temp_crit,		/* 5 */
901 	&sensor_dev_template_temp_type,		/* 6 */
902 	NULL
903 };
904 
905 static const struct sensor_template_group nct6683_temp_template_group = {
906 	.templates = nct6683_attributes_temp_template,
907 	.is_visible = nct6683_temp_is_visible,
908 	.base = 1,
909 };
910 
911 static ssize_t
show_pwm(struct device * dev,struct device_attribute * attr,char * buf)912 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
913 {
914 	struct nct6683_data *data = nct6683_update_device(dev);
915 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
916 	int index = sattr->index;
917 
918 	return sprintf(buf, "%d\n", data->pwm[index]);
919 }
920 
921 static ssize_t
store_pwm(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)922 store_pwm(struct device *dev, struct device_attribute *attr, const char *buf,
923 	  size_t count)
924 {
925 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
926 	struct nct6683_data *data = dev_get_drvdata(dev);
927 	int index = sattr->index;
928 	unsigned long val;
929 
930 	if (kstrtoul(buf, 10, &val) || val > 255)
931 		return -EINVAL;
932 
933 	mutex_lock(&data->update_lock);
934 	nct6683_write(data, NCT6683_REG_FAN_CFG_CTRL, NCT6683_FAN_CFG_REQ);
935 	usleep_range(1000, 2000);
936 	nct6683_write(data, NCT6683_REG_PWM_WRITE(index), val);
937 	nct6683_write(data, NCT6683_REG_FAN_CFG_CTRL, NCT6683_FAN_CFG_DONE);
938 	mutex_unlock(&data->update_lock);
939 
940 	return count;
941 }
942 
943 SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, store_pwm, 0);
944 
nct6683_pwm_is_visible(struct kobject * kobj,struct attribute * attr,int index)945 static umode_t nct6683_pwm_is_visible(struct kobject *kobj,
946 				      struct attribute *attr, int index)
947 {
948 	struct device *dev = kobj_to_dev(kobj);
949 	struct nct6683_data *data = dev_get_drvdata(dev);
950 	int pwm = index;	/* pwm index */
951 
952 	if (!(data->have_pwm & (1 << pwm)))
953 		return 0;
954 
955 	/* Only update pwm values for Mitac boards */
956 	if (data->customer_id == NCT6683_CUSTOMER_ID_MITAC)
957 		return attr->mode | S_IWUSR;
958 
959 	return attr->mode;
960 }
961 
962 static struct sensor_device_template *nct6683_attributes_pwm_template[] = {
963 	&sensor_dev_template_pwm,
964 	NULL
965 };
966 
967 static const struct sensor_template_group nct6683_pwm_template_group = {
968 	.templates = nct6683_attributes_pwm_template,
969 	.is_visible = nct6683_pwm_is_visible,
970 	.base = 1,
971 };
972 
973 static ssize_t
beep_enable_show(struct device * dev,struct device_attribute * attr,char * buf)974 beep_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
975 {
976 	struct nct6683_data *data = dev_get_drvdata(dev);
977 	int ret;
978 	u8 reg;
979 
980 	mutex_lock(&data->update_lock);
981 
982 	ret = superio_enter(data->sioreg);
983 	if (ret)
984 		goto error;
985 	superio_select(data->sioreg, NCT6683_LD_HWM);
986 	reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
987 	superio_exit(data->sioreg);
988 
989 	mutex_unlock(&data->update_lock);
990 
991 	return sprintf(buf, "%u\n", !!(reg & NCT6683_CR_BEEP_MASK));
992 
993 error:
994 	mutex_unlock(&data->update_lock);
995 	return ret;
996 }
997 
998 static ssize_t
beep_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)999 beep_enable_store(struct device *dev, struct device_attribute *attr,
1000 		  const char *buf, size_t count)
1001 {
1002 	struct nct6683_data *data = dev_get_drvdata(dev);
1003 	unsigned long val;
1004 	u8 reg;
1005 	int ret;
1006 
1007 	if (kstrtoul(buf, 10, &val) || (val != 0 && val != 1))
1008 		return -EINVAL;
1009 
1010 	mutex_lock(&data->update_lock);
1011 
1012 	ret = superio_enter(data->sioreg);
1013 	if (ret) {
1014 		count = ret;
1015 		goto error;
1016 	}
1017 
1018 	superio_select(data->sioreg, NCT6683_LD_HWM);
1019 	reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
1020 	if (val)
1021 		reg |= NCT6683_CR_BEEP_MASK;
1022 	else
1023 		reg &= ~NCT6683_CR_BEEP_MASK;
1024 	superio_outb(data->sioreg, NCT6683_REG_CR_BEEP, reg);
1025 	superio_exit(data->sioreg);
1026 error:
1027 	mutex_unlock(&data->update_lock);
1028 	return count;
1029 }
1030 
1031 /* Case open detection */
1032 
1033 static ssize_t
intrusion0_alarm_show(struct device * dev,struct device_attribute * attr,char * buf)1034 intrusion0_alarm_show(struct device *dev, struct device_attribute *attr,
1035 		      char *buf)
1036 {
1037 	struct nct6683_data *data = dev_get_drvdata(dev);
1038 	int ret;
1039 	u8 reg;
1040 
1041 	mutex_lock(&data->update_lock);
1042 
1043 	ret = superio_enter(data->sioreg);
1044 	if (ret)
1045 		goto error;
1046 	superio_select(data->sioreg, NCT6683_LD_ACPI);
1047 	reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1048 	superio_exit(data->sioreg);
1049 
1050 	mutex_unlock(&data->update_lock);
1051 
1052 	return sprintf(buf, "%u\n", !(reg & NCT6683_CR_CASEOPEN_MASK));
1053 
1054 error:
1055 	mutex_unlock(&data->update_lock);
1056 	return ret;
1057 }
1058 
1059 static ssize_t
intrusion0_alarm_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1060 intrusion0_alarm_store(struct device *dev, struct device_attribute *attr,
1061 		       const char *buf, size_t count)
1062 {
1063 	struct nct6683_data *data = dev_get_drvdata(dev);
1064 	unsigned long val;
1065 	u8 reg;
1066 	int ret;
1067 
1068 	if (kstrtoul(buf, 10, &val) || val != 0)
1069 		return -EINVAL;
1070 
1071 	mutex_lock(&data->update_lock);
1072 
1073 	/*
1074 	 * Use CR registers to clear caseopen status.
1075 	 * Caseopen is activ low, clear by writing 1 into the register.
1076 	 */
1077 
1078 	ret = superio_enter(data->sioreg);
1079 	if (ret) {
1080 		count = ret;
1081 		goto error;
1082 	}
1083 
1084 	superio_select(data->sioreg, NCT6683_LD_ACPI);
1085 	reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1086 	reg |= NCT6683_CR_CASEOPEN_MASK;
1087 	superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1088 	reg &= ~NCT6683_CR_CASEOPEN_MASK;
1089 	superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1090 	superio_exit(data->sioreg);
1091 
1092 	data->valid = false;	/* Force cache refresh */
1093 error:
1094 	mutex_unlock(&data->update_lock);
1095 	return count;
1096 }
1097 
1098 static DEVICE_ATTR_RW(intrusion0_alarm);
1099 static DEVICE_ATTR_RW(beep_enable);
1100 
1101 static struct attribute *nct6683_attributes_other[] = {
1102 	&dev_attr_intrusion0_alarm.attr,
1103 	&dev_attr_beep_enable.attr,
1104 	NULL
1105 };
1106 
1107 static const struct attribute_group nct6683_group_other = {
1108 	.attrs = nct6683_attributes_other,
1109 };
1110 
1111 /* Get the monitoring functions started */
nct6683_init_device(struct nct6683_data * data)1112 static inline void nct6683_init_device(struct nct6683_data *data)
1113 {
1114 	u8 tmp;
1115 
1116 	/* Start hardware monitoring if needed */
1117 	tmp = nct6683_read(data, NCT6683_HWM_CFG);
1118 	if (!(tmp & 0x80))
1119 		nct6683_write(data, NCT6683_HWM_CFG, tmp | 0x80);
1120 }
1121 
1122 /*
1123  * There are a total of 24 fan inputs. Each can be configured as input
1124  * or as output. A maximum of 16 inputs and 8 outputs is configurable.
1125  */
1126 static void
nct6683_setup_fans(struct nct6683_data * data)1127 nct6683_setup_fans(struct nct6683_data *data)
1128 {
1129 	int i;
1130 	u8 reg;
1131 
1132 	for (i = 0; i < NCT6683_NUM_REG_FAN; i++) {
1133 		reg = nct6683_read(data, NCT6683_REG_FANIN_CFG(i));
1134 		if (reg & 0x80)
1135 			data->have_fan |= 1 << i;
1136 		data->fanin_cfg[i] = reg;
1137 	}
1138 	for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
1139 		reg = nct6683_read(data, NCT6683_REG_FANOUT_CFG(i));
1140 		if (reg & 0x80)
1141 			data->have_pwm |= 1 << i;
1142 		data->fanout_cfg[i] = reg;
1143 	}
1144 }
1145 
1146 /*
1147  * Translation from monitoring register to temperature and voltage attributes
1148  * ==========================================================================
1149  *
1150  * There are a total of 32 monitoring registers. Each can be assigned to either
1151  * a temperature or voltage monitoring source.
1152  * NCT6683_REG_MON_CFG(x) defines assignment for each monitoring source.
1153  *
1154  * Temperature and voltage attribute mapping is determined by walking through
1155  * the NCT6683_REG_MON_CFG registers. If the assigned source is
1156  * a temperature, temp_index[n] is set to the monitor register index, and
1157  * temp_src[n] is set to the temperature source. If the assigned source is
1158  * a voltage, the respective values are stored in in_index[] and in_src[],
1159  * respectively.
1160  */
1161 
nct6683_setup_sensors(struct nct6683_data * data)1162 static void nct6683_setup_sensors(struct nct6683_data *data)
1163 {
1164 	u8 reg;
1165 	int i;
1166 
1167 	data->temp_num = 0;
1168 	data->in_num = 0;
1169 	for (i = 0; i < NCT6683_NUM_REG_MON; i++) {
1170 		reg = nct6683_read(data, NCT6683_REG_MON_CFG(i)) & 0x7f;
1171 		/* Ignore invalid assignments */
1172 		if (reg >= NUM_MON_LABELS)
1173 			continue;
1174 		/* Skip if disabled or reserved */
1175 		if (nct6683_mon_label[reg] == NULL)
1176 			continue;
1177 		if (reg < MON_VOLTAGE_START) {
1178 			data->temp_index[data->temp_num] = i;
1179 			data->temp_src[data->temp_num] = reg;
1180 			data->temp_num++;
1181 		} else {
1182 			data->in_index[data->in_num] = i;
1183 			data->in_src[data->in_num] = reg;
1184 			data->in_num++;
1185 		}
1186 	}
1187 }
1188 
nct6683_probe(struct platform_device * pdev)1189 static int nct6683_probe(struct platform_device *pdev)
1190 {
1191 	struct device *dev = &pdev->dev;
1192 	struct nct6683_sio_data *sio_data = dev->platform_data;
1193 	struct attribute_group *group;
1194 	struct nct6683_data *data;
1195 	struct device *hwmon_dev;
1196 	struct resource *res;
1197 	int groups = 0;
1198 	char build[16];
1199 
1200 	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1201 	if (!devm_request_region(dev, res->start, IOREGION_LENGTH, DRVNAME))
1202 		return -EBUSY;
1203 
1204 	data = devm_kzalloc(dev, sizeof(struct nct6683_data), GFP_KERNEL);
1205 	if (!data)
1206 		return -ENOMEM;
1207 
1208 	data->kind = sio_data->kind;
1209 	data->sioreg = sio_data->sioreg;
1210 	data->addr = res->start;
1211 	mutex_init(&data->update_lock);
1212 	platform_set_drvdata(pdev, data);
1213 
1214 	data->customer_id = nct6683_read16(data, NCT6683_REG_CUSTOMER_ID);
1215 
1216 	/* By default only instantiate driver if the customer ID is known */
1217 	switch (data->customer_id) {
1218 	case NCT6683_CUSTOMER_ID_INTEL:
1219 		break;
1220 	case NCT6683_CUSTOMER_ID_MITAC:
1221 		break;
1222 	case NCT6683_CUSTOMER_ID_MSI:
1223 		break;
1224 	case NCT6683_CUSTOMER_ID_MSI2:
1225 		break;
1226 	case NCT6683_CUSTOMER_ID_ASROCK:
1227 		break;
1228 	case NCT6683_CUSTOMER_ID_ASROCK2:
1229 		break;
1230 	default:
1231 		if (!force)
1232 			return -ENODEV;
1233 	}
1234 
1235 	nct6683_init_device(data);
1236 	nct6683_setup_fans(data);
1237 	nct6683_setup_sensors(data);
1238 
1239 	/* Register sysfs hooks */
1240 
1241 	if (data->have_pwm) {
1242 		group = nct6683_create_attr_group(dev,
1243 						  &nct6683_pwm_template_group,
1244 						  fls(data->have_pwm));
1245 		if (IS_ERR(group))
1246 			return PTR_ERR(group);
1247 		data->groups[groups++] = group;
1248 	}
1249 
1250 	if (data->in_num) {
1251 		group = nct6683_create_attr_group(dev,
1252 						  &nct6683_in_template_group,
1253 						  data->in_num);
1254 		if (IS_ERR(group))
1255 			return PTR_ERR(group);
1256 		data->groups[groups++] = group;
1257 	}
1258 
1259 	if (data->have_fan) {
1260 		group = nct6683_create_attr_group(dev,
1261 						  &nct6683_fan_template_group,
1262 						  fls(data->have_fan));
1263 		if (IS_ERR(group))
1264 			return PTR_ERR(group);
1265 		data->groups[groups++] = group;
1266 	}
1267 
1268 	if (data->temp_num) {
1269 		group = nct6683_create_attr_group(dev,
1270 						  &nct6683_temp_template_group,
1271 						  data->temp_num);
1272 		if (IS_ERR(group))
1273 			return PTR_ERR(group);
1274 		data->groups[groups++] = group;
1275 	}
1276 	data->groups[groups++] = &nct6683_group_other;
1277 
1278 	if (data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
1279 		scnprintf(build, sizeof(build), "%02x/%02x/%02x",
1280 			  nct6683_read(data, NCT6683_REG_BUILD_MONTH),
1281 			  nct6683_read(data, NCT6683_REG_BUILD_DAY),
1282 			  nct6683_read(data, NCT6683_REG_BUILD_YEAR));
1283 	else
1284 		scnprintf(build, sizeof(build), "%02d/%02d/%02d",
1285 			  nct6683_read(data, NCT6683_REG_BUILD_MONTH),
1286 			  nct6683_read(data, NCT6683_REG_BUILD_DAY),
1287 			  nct6683_read(data, NCT6683_REG_BUILD_YEAR));
1288 
1289 	dev_info(dev, "%s EC firmware version %d.%d build %s\n",
1290 		 nct6683_chip_names[data->kind],
1291 		 nct6683_read(data, NCT6683_REG_VERSION_HI),
1292 		 nct6683_read(data, NCT6683_REG_VERSION_LO),
1293 		 build);
1294 
1295 	hwmon_dev = devm_hwmon_device_register_with_groups(dev,
1296 			nct6683_device_names[data->kind], data, data->groups);
1297 	return PTR_ERR_OR_ZERO(hwmon_dev);
1298 }
1299 
1300 #ifdef CONFIG_PM
nct6683_suspend(struct device * dev)1301 static int nct6683_suspend(struct device *dev)
1302 {
1303 	struct nct6683_data *data = nct6683_update_device(dev);
1304 
1305 	mutex_lock(&data->update_lock);
1306 	data->hwm_cfg = nct6683_read(data, NCT6683_HWM_CFG);
1307 	mutex_unlock(&data->update_lock);
1308 
1309 	return 0;
1310 }
1311 
nct6683_resume(struct device * dev)1312 static int nct6683_resume(struct device *dev)
1313 {
1314 	struct nct6683_data *data = dev_get_drvdata(dev);
1315 
1316 	mutex_lock(&data->update_lock);
1317 
1318 	nct6683_write(data, NCT6683_HWM_CFG, data->hwm_cfg);
1319 
1320 	/* Force re-reading all values */
1321 	data->valid = false;
1322 	mutex_unlock(&data->update_lock);
1323 
1324 	return 0;
1325 }
1326 
1327 static const struct dev_pm_ops nct6683_dev_pm_ops = {
1328 	.suspend = nct6683_suspend,
1329 	.resume = nct6683_resume,
1330 	.freeze = nct6683_suspend,
1331 	.restore = nct6683_resume,
1332 };
1333 
1334 #define NCT6683_DEV_PM_OPS	(&nct6683_dev_pm_ops)
1335 #else
1336 #define NCT6683_DEV_PM_OPS	NULL
1337 #endif /* CONFIG_PM */
1338 
1339 static struct platform_driver nct6683_driver = {
1340 	.driver = {
1341 		.name	= DRVNAME,
1342 		.pm	= NCT6683_DEV_PM_OPS,
1343 	},
1344 	.probe		= nct6683_probe,
1345 };
1346 
nct6683_find(int sioaddr,struct nct6683_sio_data * sio_data)1347 static int __init nct6683_find(int sioaddr, struct nct6683_sio_data *sio_data)
1348 {
1349 	int addr;
1350 	u16 val;
1351 	int err;
1352 
1353 	err = superio_enter(sioaddr);
1354 	if (err)
1355 		return err;
1356 
1357 	val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1358 	       | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1359 
1360 	switch (val & SIO_ID_MASK) {
1361 	case SIO_NCT6683_ID:
1362 		sio_data->kind = nct6683;
1363 		break;
1364 	case SIO_NCT6686_ID:
1365 		sio_data->kind = nct6686;
1366 		break;
1367 	case SIO_NCT6687_ID:
1368 		sio_data->kind = nct6687;
1369 		break;
1370 	default:
1371 		if (val != 0xffff)
1372 			pr_debug("unsupported chip ID: 0x%04x\n", val);
1373 		goto fail;
1374 	}
1375 
1376 	/* We have a known chip, find the HWM I/O address */
1377 	superio_select(sioaddr, NCT6683_LD_HWM);
1378 	val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
1379 	    | superio_inb(sioaddr, SIO_REG_ADDR + 1);
1380 	addr = val & IOREGION_ALIGNMENT;
1381 	if (addr == 0) {
1382 		pr_err("EC base I/O port unconfigured\n");
1383 		goto fail;
1384 	}
1385 
1386 	/* Activate logical device if needed */
1387 	val = superio_inb(sioaddr, SIO_REG_ENABLE);
1388 	if (!(val & 0x01)) {
1389 		pr_warn("Forcibly enabling EC access. Data may be unusable.\n");
1390 		superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
1391 	}
1392 
1393 	superio_exit(sioaddr);
1394 	pr_info("Found %s or compatible chip at %#x:%#x\n",
1395 		nct6683_chip_names[sio_data->kind], sioaddr, addr);
1396 	sio_data->sioreg = sioaddr;
1397 
1398 	return addr;
1399 
1400 fail:
1401 	superio_exit(sioaddr);
1402 	return -ENODEV;
1403 }
1404 
1405 /*
1406  * when Super-I/O functions move to a separate file, the Super-I/O
1407  * bus will manage the lifetime of the device and this module will only keep
1408  * track of the nct6683 driver. But since we use platform_device_alloc(), we
1409  * must keep track of the device
1410  */
1411 static struct platform_device *pdev[2];
1412 
sensors_nct6683_init(void)1413 static int __init sensors_nct6683_init(void)
1414 {
1415 	struct nct6683_sio_data sio_data;
1416 	int sioaddr[2] = { 0x2e, 0x4e };
1417 	struct resource res;
1418 	bool found = false;
1419 	int address;
1420 	int i, err;
1421 
1422 	err = platform_driver_register(&nct6683_driver);
1423 	if (err)
1424 		return err;
1425 
1426 	/*
1427 	 * initialize sio_data->kind and sio_data->sioreg.
1428 	 *
1429 	 * when Super-I/O functions move to a separate file, the Super-I/O
1430 	 * driver will probe 0x2e and 0x4e and auto-detect the presence of a
1431 	 * nct6683 hardware monitor, and call probe()
1432 	 */
1433 	for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1434 		address = nct6683_find(sioaddr[i], &sio_data);
1435 		if (address <= 0)
1436 			continue;
1437 
1438 		found = true;
1439 
1440 		pdev[i] = platform_device_alloc(DRVNAME, address);
1441 		if (!pdev[i]) {
1442 			err = -ENOMEM;
1443 			goto exit_device_unregister;
1444 		}
1445 
1446 		err = platform_device_add_data(pdev[i], &sio_data,
1447 					       sizeof(struct nct6683_sio_data));
1448 		if (err)
1449 			goto exit_device_put;
1450 
1451 		memset(&res, 0, sizeof(res));
1452 		res.name = DRVNAME;
1453 		res.start = address + IOREGION_OFFSET;
1454 		res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1455 		res.flags = IORESOURCE_IO;
1456 
1457 		err = acpi_check_resource_conflict(&res);
1458 		if (err) {
1459 			platform_device_put(pdev[i]);
1460 			pdev[i] = NULL;
1461 			continue;
1462 		}
1463 
1464 		err = platform_device_add_resources(pdev[i], &res, 1);
1465 		if (err)
1466 			goto exit_device_put;
1467 
1468 		/* platform_device_add calls probe() */
1469 		err = platform_device_add(pdev[i]);
1470 		if (err)
1471 			goto exit_device_put;
1472 	}
1473 	if (!found) {
1474 		err = -ENODEV;
1475 		goto exit_unregister;
1476 	}
1477 
1478 	return 0;
1479 
1480 exit_device_put:
1481 	platform_device_put(pdev[i]);
1482 exit_device_unregister:
1483 	while (--i >= 0) {
1484 		if (pdev[i])
1485 			platform_device_unregister(pdev[i]);
1486 	}
1487 exit_unregister:
1488 	platform_driver_unregister(&nct6683_driver);
1489 	return err;
1490 }
1491 
sensors_nct6683_exit(void)1492 static void __exit sensors_nct6683_exit(void)
1493 {
1494 	int i;
1495 
1496 	for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1497 		if (pdev[i])
1498 			platform_device_unregister(pdev[i]);
1499 	}
1500 	platform_driver_unregister(&nct6683_driver);
1501 }
1502 
1503 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
1504 MODULE_DESCRIPTION("NCT6683D driver");
1505 MODULE_LICENSE("GPL");
1506 
1507 module_init(sensors_nct6683_init);
1508 module_exit(sensors_nct6683_exit);
1509