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