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