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_ASROCK 0xe2c
177
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
184
185 #define NCT6683_REG_CR_CASEOPEN 0xe8
186 #define NCT6683_CR_CASEOPEN_MASK (1 << 7)
187
188 #define NCT6683_REG_CR_BEEP 0xe0
189 #define NCT6683_CR_BEEP_MASK (1 << 6)
190
191 static const char *const nct6683_mon_label[] = {
192 NULL, /* disabled */
193 "Local",
194 "Diode 0 (curr)",
195 "Diode 1 (curr)",
196 "Diode 2 (curr)",
197 "Diode 0 (volt)",
198 "Diode 1 (volt)",
199 "Diode 2 (volt)",
200 "Thermistor 14",
201 "Thermistor 15",
202 "Thermistor 16",
203 "Thermistor 0",
204 "Thermistor 1",
205 "Thermistor 2",
206 "Thermistor 3",
207 "Thermistor 4",
208 "Thermistor 5", /* 0x10 */
209 "Thermistor 6",
210 "Thermistor 7",
211 "Thermistor 8",
212 "Thermistor 9",
213 "Thermistor 10",
214 "Thermistor 11",
215 "Thermistor 12",
216 "Thermistor 13",
217 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
218 "PECI 0.0", /* 0x20 */
219 "PECI 1.0",
220 "PECI 2.0",
221 "PECI 3.0",
222 "PECI 0.1",
223 "PECI 1.1",
224 "PECI 2.1",
225 "PECI 3.1",
226 "PECI DIMM 0",
227 "PECI DIMM 1",
228 "PECI DIMM 2",
229 "PECI DIMM 3",
230 NULL, NULL, NULL, NULL,
231 "PCH CPU", /* 0x30 */
232 "PCH CHIP",
233 "PCH CHIP CPU MAX",
234 "PCH MCH",
235 "PCH DIMM 0",
236 "PCH DIMM 1",
237 "PCH DIMM 2",
238 "PCH DIMM 3",
239 "SMBus 0",
240 "SMBus 1",
241 "SMBus 2",
242 "SMBus 3",
243 "SMBus 4",
244 "SMBus 5",
245 "DIMM 0",
246 "DIMM 1",
247 "DIMM 2", /* 0x40 */
248 "DIMM 3",
249 "AMD TSI Addr 90h",
250 "AMD TSI Addr 92h",
251 "AMD TSI Addr 94h",
252 "AMD TSI Addr 96h",
253 "AMD TSI Addr 98h",
254 "AMD TSI Addr 9ah",
255 "AMD TSI Addr 9ch",
256 "AMD TSI Addr 9dh",
257 NULL, NULL, NULL, NULL, NULL, NULL,
258 "Virtual 0", /* 0x50 */
259 "Virtual 1",
260 "Virtual 2",
261 "Virtual 3",
262 "Virtual 4",
263 "Virtual 5",
264 "Virtual 6",
265 "Virtual 7",
266 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
267 "VCC", /* 0x60 voltage sensors */
268 "VSB",
269 "AVSB",
270 "VTT",
271 "VBAT",
272 "VREF",
273 "VIN0",
274 "VIN1",
275 "VIN2",
276 "VIN3",
277 "VIN4",
278 "VIN5",
279 "VIN6",
280 "VIN7",
281 "VIN8",
282 "VIN9",
283 "VIN10",
284 "VIN11",
285 "VIN12",
286 "VIN13",
287 "VIN14",
288 "VIN15",
289 "VIN16",
290 };
291
292 #define NUM_MON_LABELS ARRAY_SIZE(nct6683_mon_label)
293 #define MON_VOLTAGE_START 0x60
294
295 /* ------------------------------------------------------- */
296
297 struct nct6683_data {
298 int addr; /* IO base of EC space */
299 int sioreg; /* SIO register */
300 enum kinds kind;
301 u16 customer_id;
302
303 struct device *hwmon_dev;
304 const struct attribute_group *groups[6];
305
306 int temp_num; /* number of temperature attributes */
307 u8 temp_index[NCT6683_NUM_REG_MON];
308 u8 temp_src[NCT6683_NUM_REG_MON];
309
310 u8 in_num; /* number of voltage attributes */
311 u8 in_index[NCT6683_NUM_REG_MON];
312 u8 in_src[NCT6683_NUM_REG_MON];
313
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 */
317
318 /* Voltage attribute values */
319 u8 in[3][NCT6683_NUM_REG_MON]; /* [0]=in, [1]=in_max, [2]=in_min */
320
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,
324 * [3]=crit
325 */
326
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 */
333
334 u8 have_pwm;
335 u8 pwm[NCT6683_NUM_REG_PWM];
336
337 #ifdef CONFIG_PM
338 /* Remember extra register values over suspend/resume */
339 u8 hwm_cfg;
340 #endif
341 };
342
343 struct nct6683_sio_data {
344 int sioreg;
345 enum kinds kind;
346 };
347
348 struct sensor_device_template {
349 struct device_attribute dev_attr;
350 union {
351 struct {
352 u8 nr;
353 u8 index;
354 } s;
355 int index;
356 } u;
357 bool s2; /* true if both index and nr are used */
358 };
359
360 struct sensor_device_attr_u {
361 union {
362 struct sensor_device_attribute a1;
363 struct sensor_device_attribute_2 a2;
364 } u;
365 char name[32];
366 };
367
368 #define __TEMPLATE_ATTR(_template, _mode, _show, _store) { \
369 .attr = {.name = _template, .mode = _mode }, \
370 .show = _show, \
371 .store = _store, \
372 }
373
374 #define SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, _index) \
375 { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
376 .u.index = _index, \
377 .s2 = false }
378
379 #define SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store, \
380 _nr, _index) \
381 { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
382 .u.s.index = _index, \
383 .u.s.nr = _nr, \
384 .s2 = true }
385
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, \
389 _index)
390
391 #define SENSOR_TEMPLATE_2(_name, _template, _mode, _show, _store, \
392 _nr, _index) \
393 static struct sensor_device_template sensor_dev_template_##_name \
394 = SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store, \
395 _nr, _index)
396
397 struct sensor_template_group {
398 struct sensor_device_template **templates;
399 umode_t (*is_visible)(struct kobject *, struct attribute *, int);
400 int base;
401 };
402
403 static struct attribute_group *
nct6683_create_attr_group(struct device * dev,const struct sensor_template_group * tg,int repeat)404 nct6683_create_attr_group(struct device *dev,
405 const struct sensor_template_group *tg,
406 int repeat)
407 {
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;
414 int i, j, count;
415
416 if (repeat <= 0)
417 return ERR_PTR(-EINVAL);
418
419 t = tg->templates;
420 for (count = 0; *t; t++, count++)
421 ;
422
423 if (count == 0)
424 return ERR_PTR(-EINVAL);
425
426 group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL);
427 if (group == NULL)
428 return ERR_PTR(-ENOMEM);
429
430 attrs = devm_kcalloc(dev, repeat * count + 1, sizeof(*attrs),
431 GFP_KERNEL);
432 if (attrs == NULL)
433 return ERR_PTR(-ENOMEM);
434
435 su = devm_kzalloc(dev, array3_size(repeat, count, sizeof(*su)),
436 GFP_KERNEL);
437 if (su == NULL)
438 return ERR_PTR(-ENOMEM);
439
440 group->attrs = attrs;
441 group->is_visible = tg->is_visible;
442
443 for (i = 0; i < repeat; i++) {
444 t = tg->templates;
445 for (j = 0; *t != NULL; j++) {
446 snprintf(su->name, sizeof(su->name),
447 (*t)->dev_attr.attr.name, tg->base + i);
448 if ((*t)->s2) {
449 a2 = &su->u.a2;
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;
459 } else {
460 a = &su->u.a1;
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;
469 }
470 attrs++;
471 su++;
472 t++;
473 }
474 }
475
476 return group;
477 }
478
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
484
in_from_reg(u16 reg,u8 src)485 static inline long in_from_reg(u16 reg, u8 src)
486 {
487 int scale = 16;
488
489 if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB ||
490 src == MON_SRC_VBAT)
491 scale <<= 1;
492 return reg * scale;
493 }
494
nct6683_read(struct nct6683_data * data,u16 reg)495 static u16 nct6683_read(struct nct6683_data *data, u16 reg)
496 {
497 int res;
498
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);
503 return res;
504 }
505
nct6683_read16(struct nct6683_data * data,u16 reg)506 static u16 nct6683_read16(struct nct6683_data *data, u16 reg)
507 {
508 return (nct6683_read(data, reg) << 8) | nct6683_read(data, reg + 1);
509 }
510
nct6683_write(struct nct6683_data * data,u16 reg,u16 value)511 static void nct6683_write(struct nct6683_data *data, u16 reg, u16 value)
512 {
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);
517 }
518
get_in_reg(struct nct6683_data * data,int nr,int index)519 static int get_in_reg(struct nct6683_data *data, int nr, int index)
520 {
521 int ch = data->in_index[index];
522 int reg = -EINVAL;
523
524 switch (nr) {
525 case 0:
526 reg = NCT6683_REG_MON(ch);
527 break;
528 case 1:
529 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
530 reg = NCT6683_REG_MON_LOW(ch);
531 break;
532 case 2:
533 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
534 reg = NCT6683_REG_MON_HIGH(ch);
535 break;
536 default:
537 break;
538 }
539 return reg;
540 }
541
get_temp_reg(struct nct6683_data * data,int nr,int index)542 static int get_temp_reg(struct nct6683_data *data, int nr, int index)
543 {
544 int ch = data->temp_index[index];
545 int reg = -EINVAL;
546
547 switch (data->customer_id) {
548 case NCT6683_CUSTOMER_ID_INTEL:
549 switch (nr) {
550 default:
551 case 1: /* max */
552 reg = NCT6683_REG_INTEL_TEMP_MAX(ch);
553 break;
554 case 3: /* crit */
555 reg = NCT6683_REG_INTEL_TEMP_CRIT(ch);
556 break;
557 }
558 break;
559 case NCT6683_CUSTOMER_ID_MITAC:
560 default:
561 switch (nr) {
562 default:
563 case 0: /* min */
564 reg = NCT6683_REG_MON_LOW(ch);
565 break;
566 case 1: /* max */
567 reg = NCT6683_REG_TEMP_MAX(ch);
568 break;
569 case 2: /* hyst */
570 reg = NCT6683_REG_TEMP_HYST(ch);
571 break;
572 case 3: /* crit */
573 reg = NCT6683_REG_MON_HIGH(ch);
574 break;
575 }
576 break;
577 }
578 return reg;
579 }
580
nct6683_update_pwm(struct device * dev)581 static void nct6683_update_pwm(struct device *dev)
582 {
583 struct nct6683_data *data = dev_get_drvdata(dev);
584 int i;
585
586 for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
587 if (!(data->have_pwm & (1 << i)))
588 continue;
589 data->pwm[i] = nct6683_read(data, NCT6683_REG_PWM(i));
590 }
591 }
592
nct6683_update_device(struct device * dev)593 static struct nct6683_data *nct6683_update_device(struct device *dev)
594 {
595 struct nct6683_data *data = dev_get_drvdata(dev);
596 int i, j;
597
598 mutex_lock(&data->update_lock);
599
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);
605
606 if (reg >= 0)
607 data->in[j][i] =
608 nct6683_read(data, reg);
609 }
610 }
611
612 /* Measured temperatures and limits */
613 for (i = 0; i < data->temp_num; i++) {
614 u8 ch = data->temp_index[i];
615
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);
620
621 if (reg >= 0)
622 data->temp[j][i] =
623 nct6683_read(data, reg);
624 }
625 }
626
627 /* Measured fan speeds and limits */
628 for (i = 0; i < ARRAY_SIZE(data->rpm); i++) {
629 if (!(data->have_fan & (1 << i)))
630 continue;
631
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));
636 }
637
638 nct6683_update_pwm(dev);
639
640 data->last_updated = jiffies;
641 data->valid = true;
642 }
643
644 mutex_unlock(&data->update_lock);
645 return data;
646 }
647
648 /*
649 * Sysfs callback functions
650 */
651 static ssize_t
show_in_label(struct device * dev,struct device_attribute * attr,char * buf)652 show_in_label(struct device *dev, struct device_attribute *attr, char *buf)
653 {
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;
657
658 return sprintf(buf, "%s\n", nct6683_mon_label[data->in_src[nr]]);
659 }
660
661 static ssize_t
show_in_reg(struct device * dev,struct device_attribute * attr,char * buf)662 show_in_reg(struct device *dev, struct device_attribute *attr, char *buf)
663 {
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;
667 int nr = sattr->nr;
668
669 return sprintf(buf, "%ld\n",
670 in_from_reg(data->in[index][nr], data->in_index[index]));
671 }
672
nct6683_in_is_visible(struct kobject * kobj,struct attribute * attr,int index)673 static umode_t nct6683_in_is_visible(struct kobject *kobj,
674 struct attribute *attr, int index)
675 {
676 struct device *dev = kobj_to_dev(kobj);
677 struct nct6683_data *data = dev_get_drvdata(dev);
678 int nr = index % 4; /* attribute */
679
680 /*
681 * Voltage limits exist for Intel boards,
682 * but register location and encoding is unknown
683 */
684 if ((nr == 2 || nr == 3) &&
685 data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
686 return 0;
687
688 return attr->mode;
689 }
690
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);
695
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,
701 NULL
702 };
703
704 static const struct sensor_template_group nct6683_in_template_group = {
705 .templates = nct6683_attributes_in_template,
706 .is_visible = nct6683_in_is_visible,
707 };
708
709 static ssize_t
show_fan(struct device * dev,struct device_attribute * attr,char * buf)710 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
711 {
712 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
713 struct nct6683_data *data = nct6683_update_device(dev);
714
715 return sprintf(buf, "%d\n", data->rpm[sattr->index]);
716 }
717
718 static ssize_t
show_fan_min(struct device * dev,struct device_attribute * attr,char * buf)719 show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
720 {
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;
724
725 return sprintf(buf, "%d\n", data->fan_min[nr]);
726 }
727
728 static ssize_t
show_fan_pulses(struct device * dev,struct device_attribute * attr,char * buf)729 show_fan_pulses(struct device *dev, struct device_attribute *attr, char *buf)
730 {
731 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
732 struct nct6683_data *data = nct6683_update_device(dev);
733
734 return sprintf(buf, "%d\n",
735 ((data->fanin_cfg[sattr->index] >> 5) & 0x03) + 1);
736 }
737
nct6683_fan_is_visible(struct kobject * kobj,struct attribute * attr,int index)738 static umode_t nct6683_fan_is_visible(struct kobject *kobj,
739 struct attribute *attr, int index)
740 {
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 */
745
746 if (!(data->have_fan & (1 << fan)))
747 return 0;
748
749 /*
750 * Intel may have minimum fan speed limits,
751 * but register location and encoding are unknown.
752 */
753 if (nr == 2 && data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
754 return 0;
755
756 return attr->mode;
757 }
758
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);
762
763 /*
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.
767 */
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,
772 NULL
773 };
774
775 static const struct sensor_template_group nct6683_fan_template_group = {
776 .templates = nct6683_attributes_fan_template,
777 .is_visible = nct6683_fan_is_visible,
778 .base = 1,
779 };
780
781 static ssize_t
show_temp_label(struct device * dev,struct device_attribute * attr,char * buf)782 show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
783 {
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;
787
788 return sprintf(buf, "%s\n", nct6683_mon_label[data->temp_src[nr]]);
789 }
790
791 static ssize_t
show_temp8(struct device * dev,struct device_attribute * attr,char * buf)792 show_temp8(struct device *dev, struct device_attribute *attr, char *buf)
793 {
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;
797 int nr = sattr->nr;
798
799 return sprintf(buf, "%d\n", data->temp[index][nr] * 1000);
800 }
801
802 static ssize_t
show_temp_hyst(struct device * dev,struct device_attribute * attr,char * buf)803 show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
804 {
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];
809
810 return sprintf(buf, "%d\n", temp * 1000);
811 }
812
813 static ssize_t
show_temp16(struct device * dev,struct device_attribute * attr,char * buf)814 show_temp16(struct device *dev, struct device_attribute *attr, char *buf)
815 {
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;
819
820 return sprintf(buf, "%d\n", (data->temp_in[index] / 128) * 500);
821 }
822
823 /*
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)
831 */
832
get_temp_type(u8 src)833 static int get_temp_type(u8 src)
834 {
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)
840 return 6; /* PECI */
841 else if (src >= 0x42 && src <= 0x49)
842 return 5;
843
844 return 0;
845 }
846
847 static ssize_t
show_temp_type(struct device * dev,struct device_attribute * attr,char * buf)848 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
849 {
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]));
854 }
855
nct6683_temp_is_visible(struct kobject * kobj,struct attribute * attr,int index)856 static umode_t nct6683_temp_is_visible(struct kobject *kobj,
857 struct attribute *attr, int index)
858 {
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 */
863
864 /*
865 * Intel does not have low temperature limits or temperature hysteresis
866 * registers, or at least register location and encoding is unknown.
867 */
868 if ((nr == 2 || nr == 4) &&
869 data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
870 return 0;
871
872 if (nr == 6 && get_temp_type(data->temp_src[temp]) == 0)
873 return 0; /* type */
874
875 return attr->mode;
876 }
877
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,
883 0);
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);
886
887 /*
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.
891 */
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 */
900 NULL
901 };
902
903 static const struct sensor_template_group nct6683_temp_template_group = {
904 .templates = nct6683_attributes_temp_template,
905 .is_visible = nct6683_temp_is_visible,
906 .base = 1,
907 };
908
909 static ssize_t
show_pwm(struct device * dev,struct device_attribute * attr,char * buf)910 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
911 {
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;
915
916 return sprintf(buf, "%d\n", data->pwm[index]);
917 }
918
919 static ssize_t
store_pwm(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)920 store_pwm(struct device *dev, struct device_attribute *attr, const char *buf,
921 size_t count)
922 {
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;
926 unsigned long val;
927
928 if (kstrtoul(buf, 10, &val) || val > 255)
929 return -EINVAL;
930
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);
937
938 return count;
939 }
940
941 SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, store_pwm, 0);
942
nct6683_pwm_is_visible(struct kobject * kobj,struct attribute * attr,int index)943 static umode_t nct6683_pwm_is_visible(struct kobject *kobj,
944 struct attribute *attr, int index)
945 {
946 struct device *dev = kobj_to_dev(kobj);
947 struct nct6683_data *data = dev_get_drvdata(dev);
948 int pwm = index; /* pwm index */
949
950 if (!(data->have_pwm & (1 << pwm)))
951 return 0;
952
953 /* Only update pwm values for Mitac boards */
954 if (data->customer_id == NCT6683_CUSTOMER_ID_MITAC)
955 return attr->mode | S_IWUSR;
956
957 return attr->mode;
958 }
959
960 static struct sensor_device_template *nct6683_attributes_pwm_template[] = {
961 &sensor_dev_template_pwm,
962 NULL
963 };
964
965 static const struct sensor_template_group nct6683_pwm_template_group = {
966 .templates = nct6683_attributes_pwm_template,
967 .is_visible = nct6683_pwm_is_visible,
968 .base = 1,
969 };
970
971 static ssize_t
beep_enable_show(struct device * dev,struct device_attribute * attr,char * buf)972 beep_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
973 {
974 struct nct6683_data *data = dev_get_drvdata(dev);
975 int ret;
976 u8 reg;
977
978 mutex_lock(&data->update_lock);
979
980 ret = superio_enter(data->sioreg);
981 if (ret)
982 goto error;
983 superio_select(data->sioreg, NCT6683_LD_HWM);
984 reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
985 superio_exit(data->sioreg);
986
987 mutex_unlock(&data->update_lock);
988
989 return sprintf(buf, "%u\n", !!(reg & NCT6683_CR_BEEP_MASK));
990
991 error:
992 mutex_unlock(&data->update_lock);
993 return ret;
994 }
995
996 static ssize_t
beep_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)997 beep_enable_store(struct device *dev, struct device_attribute *attr,
998 const char *buf, size_t count)
999 {
1000 struct nct6683_data *data = dev_get_drvdata(dev);
1001 unsigned long val;
1002 u8 reg;
1003 int ret;
1004
1005 if (kstrtoul(buf, 10, &val) || (val != 0 && val != 1))
1006 return -EINVAL;
1007
1008 mutex_lock(&data->update_lock);
1009
1010 ret = superio_enter(data->sioreg);
1011 if (ret) {
1012 count = ret;
1013 goto error;
1014 }
1015
1016 superio_select(data->sioreg, NCT6683_LD_HWM);
1017 reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
1018 if (val)
1019 reg |= NCT6683_CR_BEEP_MASK;
1020 else
1021 reg &= ~NCT6683_CR_BEEP_MASK;
1022 superio_outb(data->sioreg, NCT6683_REG_CR_BEEP, reg);
1023 superio_exit(data->sioreg);
1024 error:
1025 mutex_unlock(&data->update_lock);
1026 return count;
1027 }
1028
1029 /* Case open detection */
1030
1031 static ssize_t
intrusion0_alarm_show(struct device * dev,struct device_attribute * attr,char * buf)1032 intrusion0_alarm_show(struct device *dev, struct device_attribute *attr,
1033 char *buf)
1034 {
1035 struct nct6683_data *data = dev_get_drvdata(dev);
1036 int ret;
1037 u8 reg;
1038
1039 mutex_lock(&data->update_lock);
1040
1041 ret = superio_enter(data->sioreg);
1042 if (ret)
1043 goto error;
1044 superio_select(data->sioreg, NCT6683_LD_ACPI);
1045 reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1046 superio_exit(data->sioreg);
1047
1048 mutex_unlock(&data->update_lock);
1049
1050 return sprintf(buf, "%u\n", !(reg & NCT6683_CR_CASEOPEN_MASK));
1051
1052 error:
1053 mutex_unlock(&data->update_lock);
1054 return ret;
1055 }
1056
1057 static ssize_t
intrusion0_alarm_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1058 intrusion0_alarm_store(struct device *dev, struct device_attribute *attr,
1059 const char *buf, size_t count)
1060 {
1061 struct nct6683_data *data = dev_get_drvdata(dev);
1062 unsigned long val;
1063 u8 reg;
1064 int ret;
1065
1066 if (kstrtoul(buf, 10, &val) || val != 0)
1067 return -EINVAL;
1068
1069 mutex_lock(&data->update_lock);
1070
1071 /*
1072 * Use CR registers to clear caseopen status.
1073 * Caseopen is activ low, clear by writing 1 into the register.
1074 */
1075
1076 ret = superio_enter(data->sioreg);
1077 if (ret) {
1078 count = ret;
1079 goto error;
1080 }
1081
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);
1089
1090 data->valid = false; /* Force cache refresh */
1091 error:
1092 mutex_unlock(&data->update_lock);
1093 return count;
1094 }
1095
1096 static DEVICE_ATTR_RW(intrusion0_alarm);
1097 static DEVICE_ATTR_RW(beep_enable);
1098
1099 static struct attribute *nct6683_attributes_other[] = {
1100 &dev_attr_intrusion0_alarm.attr,
1101 &dev_attr_beep_enable.attr,
1102 NULL
1103 };
1104
1105 static const struct attribute_group nct6683_group_other = {
1106 .attrs = nct6683_attributes_other,
1107 };
1108
1109 /* Get the monitoring functions started */
nct6683_init_device(struct nct6683_data * data)1110 static inline void nct6683_init_device(struct nct6683_data *data)
1111 {
1112 u8 tmp;
1113
1114 /* Start hardware monitoring if needed */
1115 tmp = nct6683_read(data, NCT6683_HWM_CFG);
1116 if (!(tmp & 0x80))
1117 nct6683_write(data, NCT6683_HWM_CFG, tmp | 0x80);
1118 }
1119
1120 /*
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.
1123 */
1124 static void
nct6683_setup_fans(struct nct6683_data * data)1125 nct6683_setup_fans(struct nct6683_data *data)
1126 {
1127 int i;
1128 u8 reg;
1129
1130 for (i = 0; i < NCT6683_NUM_REG_FAN; i++) {
1131 reg = nct6683_read(data, NCT6683_REG_FANIN_CFG(i));
1132 if (reg & 0x80)
1133 data->have_fan |= 1 << i;
1134 data->fanin_cfg[i] = reg;
1135 }
1136 for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
1137 reg = nct6683_read(data, NCT6683_REG_FANOUT_CFG(i));
1138 if (reg & 0x80)
1139 data->have_pwm |= 1 << i;
1140 data->fanout_cfg[i] = reg;
1141 }
1142 }
1143
1144 /*
1145 * Translation from monitoring register to temperature and voltage attributes
1146 * ==========================================================================
1147 *
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.
1151 *
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[],
1157 * respectively.
1158 */
1159
nct6683_setup_sensors(struct nct6683_data * data)1160 static void nct6683_setup_sensors(struct nct6683_data *data)
1161 {
1162 u8 reg;
1163 int i;
1164
1165 data->temp_num = 0;
1166 data->in_num = 0;
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)
1171 continue;
1172 /* Skip if disabled or reserved */
1173 if (nct6683_mon_label[reg] == NULL)
1174 continue;
1175 if (reg < MON_VOLTAGE_START) {
1176 data->temp_index[data->temp_num] = i;
1177 data->temp_src[data->temp_num] = reg;
1178 data->temp_num++;
1179 } else {
1180 data->in_index[data->in_num] = i;
1181 data->in_src[data->in_num] = reg;
1182 data->in_num++;
1183 }
1184 }
1185 }
1186
nct6683_probe(struct platform_device * pdev)1187 static int nct6683_probe(struct platform_device *pdev)
1188 {
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;
1195 int groups = 0;
1196 char build[16];
1197
1198 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1199 if (!devm_request_region(dev, res->start, IOREGION_LENGTH, DRVNAME))
1200 return -EBUSY;
1201
1202 data = devm_kzalloc(dev, sizeof(struct nct6683_data), GFP_KERNEL);
1203 if (!data)
1204 return -ENOMEM;
1205
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);
1211
1212 data->customer_id = nct6683_read16(data, NCT6683_REG_CUSTOMER_ID);
1213
1214 /* By default only instantiate driver if the customer ID is known */
1215 switch (data->customer_id) {
1216 case NCT6683_CUSTOMER_ID_INTEL:
1217 break;
1218 case NCT6683_CUSTOMER_ID_MITAC:
1219 break;
1220 case NCT6683_CUSTOMER_ID_MSI:
1221 break;
1222 case NCT6683_CUSTOMER_ID_ASROCK:
1223 break;
1224 default:
1225 if (!force)
1226 return -ENODEV;
1227 }
1228
1229 nct6683_init_device(data);
1230 nct6683_setup_fans(data);
1231 nct6683_setup_sensors(data);
1232
1233 /* Register sysfs hooks */
1234
1235 if (data->have_pwm) {
1236 group = nct6683_create_attr_group(dev,
1237 &nct6683_pwm_template_group,
1238 fls(data->have_pwm));
1239 if (IS_ERR(group))
1240 return PTR_ERR(group);
1241 data->groups[groups++] = group;
1242 }
1243
1244 if (data->in_num) {
1245 group = nct6683_create_attr_group(dev,
1246 &nct6683_in_template_group,
1247 data->in_num);
1248 if (IS_ERR(group))
1249 return PTR_ERR(group);
1250 data->groups[groups++] = group;
1251 }
1252
1253 if (data->have_fan) {
1254 group = nct6683_create_attr_group(dev,
1255 &nct6683_fan_template_group,
1256 fls(data->have_fan));
1257 if (IS_ERR(group))
1258 return PTR_ERR(group);
1259 data->groups[groups++] = group;
1260 }
1261
1262 if (data->temp_num) {
1263 group = nct6683_create_attr_group(dev,
1264 &nct6683_temp_template_group,
1265 data->temp_num);
1266 if (IS_ERR(group))
1267 return PTR_ERR(group);
1268 data->groups[groups++] = group;
1269 }
1270 data->groups[groups++] = &nct6683_group_other;
1271
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));
1277 else
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));
1282
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),
1287 build);
1288
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);
1292 }
1293
1294 #ifdef CONFIG_PM
nct6683_suspend(struct device * dev)1295 static int nct6683_suspend(struct device *dev)
1296 {
1297 struct nct6683_data *data = nct6683_update_device(dev);
1298
1299 mutex_lock(&data->update_lock);
1300 data->hwm_cfg = nct6683_read(data, NCT6683_HWM_CFG);
1301 mutex_unlock(&data->update_lock);
1302
1303 return 0;
1304 }
1305
nct6683_resume(struct device * dev)1306 static int nct6683_resume(struct device *dev)
1307 {
1308 struct nct6683_data *data = dev_get_drvdata(dev);
1309
1310 mutex_lock(&data->update_lock);
1311
1312 nct6683_write(data, NCT6683_HWM_CFG, data->hwm_cfg);
1313
1314 /* Force re-reading all values */
1315 data->valid = false;
1316 mutex_unlock(&data->update_lock);
1317
1318 return 0;
1319 }
1320
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,
1326 };
1327
1328 #define NCT6683_DEV_PM_OPS (&nct6683_dev_pm_ops)
1329 #else
1330 #define NCT6683_DEV_PM_OPS NULL
1331 #endif /* CONFIG_PM */
1332
1333 static struct platform_driver nct6683_driver = {
1334 .driver = {
1335 .name = DRVNAME,
1336 .pm = NCT6683_DEV_PM_OPS,
1337 },
1338 .probe = nct6683_probe,
1339 };
1340
nct6683_find(int sioaddr,struct nct6683_sio_data * sio_data)1341 static int __init nct6683_find(int sioaddr, struct nct6683_sio_data *sio_data)
1342 {
1343 int addr;
1344 u16 val;
1345 int err;
1346
1347 err = superio_enter(sioaddr);
1348 if (err)
1349 return err;
1350
1351 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1352 | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1353
1354 switch (val & SIO_ID_MASK) {
1355 case SIO_NCT6683_ID:
1356 sio_data->kind = nct6683;
1357 break;
1358 case SIO_NCT6686_ID:
1359 sio_data->kind = nct6686;
1360 break;
1361 case SIO_NCT6687_ID:
1362 sio_data->kind = nct6687;
1363 break;
1364 default:
1365 if (val != 0xffff)
1366 pr_debug("unsupported chip ID: 0x%04x\n", val);
1367 goto fail;
1368 }
1369
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;
1375 if (addr == 0) {
1376 pr_err("EC base I/O port unconfigured\n");
1377 goto fail;
1378 }
1379
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);
1385 }
1386
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;
1391
1392 return addr;
1393
1394 fail:
1395 superio_exit(sioaddr);
1396 return -ENODEV;
1397 }
1398
1399 /*
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
1404 */
1405 static struct platform_device *pdev[2];
1406
sensors_nct6683_init(void)1407 static int __init sensors_nct6683_init(void)
1408 {
1409 struct nct6683_sio_data sio_data;
1410 int sioaddr[2] = { 0x2e, 0x4e };
1411 struct resource res;
1412 bool found = false;
1413 int address;
1414 int i, err;
1415
1416 err = platform_driver_register(&nct6683_driver);
1417 if (err)
1418 return err;
1419
1420 /*
1421 * initialize sio_data->kind and sio_data->sioreg.
1422 *
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()
1426 */
1427 for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1428 address = nct6683_find(sioaddr[i], &sio_data);
1429 if (address <= 0)
1430 continue;
1431
1432 found = true;
1433
1434 pdev[i] = platform_device_alloc(DRVNAME, address);
1435 if (!pdev[i]) {
1436 err = -ENOMEM;
1437 goto exit_device_unregister;
1438 }
1439
1440 err = platform_device_add_data(pdev[i], &sio_data,
1441 sizeof(struct nct6683_sio_data));
1442 if (err)
1443 goto exit_device_put;
1444
1445 memset(&res, 0, sizeof(res));
1446 res.name = DRVNAME;
1447 res.start = address + IOREGION_OFFSET;
1448 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1449 res.flags = IORESOURCE_IO;
1450
1451 err = acpi_check_resource_conflict(&res);
1452 if (err) {
1453 platform_device_put(pdev[i]);
1454 pdev[i] = NULL;
1455 continue;
1456 }
1457
1458 err = platform_device_add_resources(pdev[i], &res, 1);
1459 if (err)
1460 goto exit_device_put;
1461
1462 /* platform_device_add calls probe() */
1463 err = platform_device_add(pdev[i]);
1464 if (err)
1465 goto exit_device_put;
1466 }
1467 if (!found) {
1468 err = -ENODEV;
1469 goto exit_unregister;
1470 }
1471
1472 return 0;
1473
1474 exit_device_put:
1475 platform_device_put(pdev[i]);
1476 exit_device_unregister:
1477 while (--i >= 0) {
1478 if (pdev[i])
1479 platform_device_unregister(pdev[i]);
1480 }
1481 exit_unregister:
1482 platform_driver_unregister(&nct6683_driver);
1483 return err;
1484 }
1485
sensors_nct6683_exit(void)1486 static void __exit sensors_nct6683_exit(void)
1487 {
1488 int i;
1489
1490 for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1491 if (pdev[i])
1492 platform_device_unregister(pdev[i]);
1493 }
1494 platform_driver_unregister(&nct6683_driver);
1495 }
1496
1497 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
1498 MODULE_DESCRIPTION("NCT6683D driver");
1499 MODULE_LICENSE("GPL");
1500
1501 module_init(sensors_nct6683_init);
1502 module_exit(sensors_nct6683_exit);
1503