]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/hwmon/nct6683.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] tveeprom: Remove two unused fields from struct
[mirror_ubuntu-artful-kernel.git] / drivers / hwmon / nct6683.c
1 /*
2 * nct6683 - Driver for the hardware monitoring functionality of
3 * Nuvoton NCT6683D eSIO
4 *
5 * Copyright (C) 2013 Guenter Roeck <linux@roeck-us.net>
6 *
7 * Derived from nct6775 driver
8 * Copyright (C) 2012, 2013 Guenter Roeck <linux@roeck-us.net>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * Supports the following chips:
21 *
22 * Chip #vin #fan #pwm #temp chip ID
23 * nct6683d 21(1) 16 8 32(1) 0xc730
24 *
25 * Notes:
26 * (1) Total number of vin and temp inputs is 32.
27 */
28
29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30
31 #include <linux/acpi.h>
32 #include <linux/dmi.h>
33 #include <linux/err.h>
34 #include <linux/init.h>
35 #include <linux/io.h>
36 #include <linux/jiffies.h>
37 #include <linux/hwmon.h>
38 #include <linux/hwmon-sysfs.h>
39 #include <linux/module.h>
40 #include <linux/mutex.h>
41 #include <linux/platform_device.h>
42 #include <linux/slab.h>
43
44 enum kinds { nct6683 };
45
46 static bool force;
47 module_param(force, bool, 0);
48 MODULE_PARM_DESC(force, "Set to one to enable detection on non-Intel boards");
49
50 static const char * const nct6683_device_names[] = {
51 "nct6683",
52 };
53
54 static const char * const nct6683_chip_names[] = {
55 "NCT6683D",
56 };
57
58 #define DRVNAME "nct6683"
59
60 /*
61 * Super-I/O constants and functions
62 */
63
64 #define NCT6683_LD_ACPI 0x0a
65 #define NCT6683_LD_HWM 0x0b
66 #define NCT6683_LD_VID 0x0d
67
68 #define SIO_REG_LDSEL 0x07 /* Logical device select */
69 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
70 #define SIO_REG_ENABLE 0x30 /* Logical device enable */
71 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
72
73 #define SIO_NCT6681_ID 0xb270 /* for later */
74 #define SIO_NCT6683_ID 0xc730
75 #define SIO_ID_MASK 0xFFF0
76
77 static inline void
78 superio_outb(int ioreg, int reg, int val)
79 {
80 outb(reg, ioreg);
81 outb(val, ioreg + 1);
82 }
83
84 static inline int
85 superio_inb(int ioreg, int reg)
86 {
87 outb(reg, ioreg);
88 return inb(ioreg + 1);
89 }
90
91 static inline void
92 superio_select(int ioreg, int ld)
93 {
94 outb(SIO_REG_LDSEL, ioreg);
95 outb(ld, ioreg + 1);
96 }
97
98 static inline int
99 superio_enter(int ioreg)
100 {
101 /*
102 * Try to reserve <ioreg> and <ioreg + 1> for exclusive access.
103 */
104 if (!request_muxed_region(ioreg, 2, DRVNAME))
105 return -EBUSY;
106
107 outb(0x87, ioreg);
108 outb(0x87, ioreg);
109
110 return 0;
111 }
112
113 static inline void
114 superio_exit(int ioreg)
115 {
116 outb(0xaa, ioreg);
117 outb(0x02, ioreg);
118 outb(0x02, ioreg + 1);
119 release_region(ioreg, 2);
120 }
121
122 /*
123 * ISA constants
124 */
125
126 #define IOREGION_ALIGNMENT (~7)
127 #define IOREGION_OFFSET 4 /* Use EC port 1 */
128 #define IOREGION_LENGTH 4
129
130 #define EC_PAGE_REG 0
131 #define EC_INDEX_REG 1
132 #define EC_DATA_REG 2
133 #define EC_EVENT_REG 3
134
135 /* Common and NCT6683 specific data */
136
137 #define NCT6683_NUM_REG_MON 32
138 #define NCT6683_NUM_REG_FAN 16
139 #define NCT6683_NUM_REG_PWM 8
140
141 #define NCT6683_REG_MON(x) (0x100 + (x) * 2)
142 #define NCT6683_REG_FAN_RPM(x) (0x140 + (x) * 2)
143 #define NCT6683_REG_PWM(x) (0x160 + (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_CUSTOMER_ID 0x602
169 #define NCT6683_CUSTOMER_ID_INTEL 0x805
170
171 #define NCT6683_REG_BUILD_YEAR 0x604
172 #define NCT6683_REG_BUILD_MONTH 0x605
173 #define NCT6683_REG_BUILD_DAY 0x606
174 #define NCT6683_REG_SERIAL 0x607
175 #define NCT6683_REG_VERSION_HI 0x608
176 #define NCT6683_REG_VERSION_LO 0x609
177
178 #define NCT6683_REG_CR_CASEOPEN 0xe8
179 #define NCT6683_CR_CASEOPEN_MASK (1 << 7)
180
181 #define NCT6683_REG_CR_BEEP 0xe0
182 #define NCT6683_CR_BEEP_MASK (1 << 6)
183
184 static const char *const nct6683_mon_label[] = {
185 NULL, /* disabled */
186 "Local",
187 "Diode 0 (curr)",
188 "Diode 1 (curr)",
189 "Diode 2 (curr)",
190 "Diode 0 (volt)",
191 "Diode 1 (volt)",
192 "Diode 2 (volt)",
193 "Thermistor 14",
194 "Thermistor 15",
195 "Thermistor 16",
196 "Thermistor 0",
197 "Thermistor 1",
198 "Thermistor 2",
199 "Thermistor 3",
200 "Thermistor 4",
201 "Thermistor 5", /* 0x10 */
202 "Thermistor 6",
203 "Thermistor 7",
204 "Thermistor 8",
205 "Thermistor 9",
206 "Thermistor 10",
207 "Thermistor 11",
208 "Thermistor 12",
209 "Thermistor 13",
210 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
211 "PECI 0.0", /* 0x20 */
212 "PECI 1.0",
213 "PECI 2.0",
214 "PECI 3.0",
215 "PECI 0.1",
216 "PECI 1.1",
217 "PECI 2.1",
218 "PECI 3.1",
219 "PECI DIMM 0",
220 "PECI DIMM 1",
221 "PECI DIMM 2",
222 "PECI DIMM 3",
223 NULL, NULL, NULL, NULL,
224 "PCH CPU", /* 0x30 */
225 "PCH CHIP",
226 "PCH CHIP CPU MAX",
227 "PCH MCH",
228 "PCH DIMM 0",
229 "PCH DIMM 1",
230 "PCH DIMM 2",
231 "PCH DIMM 3",
232 "SMBus 0",
233 "SMBus 1",
234 "SMBus 2",
235 "SMBus 3",
236 "SMBus 4",
237 "SMBus 5",
238 "DIMM 0",
239 "DIMM 1",
240 "DIMM 2", /* 0x40 */
241 "DIMM 3",
242 "AMD TSI Addr 90h",
243 "AMD TSI Addr 92h",
244 "AMD TSI Addr 94h",
245 "AMD TSI Addr 96h",
246 "AMD TSI Addr 98h",
247 "AMD TSI Addr 9ah",
248 "AMD TSI Addr 9ch",
249 "AMD TSI Addr 9dh",
250 NULL, NULL, NULL, NULL, NULL, NULL,
251 "Virtual 0", /* 0x50 */
252 "Virtual 1",
253 "Virtual 2",
254 "Virtual 3",
255 "Virtual 4",
256 "Virtual 5",
257 "Virtual 6",
258 "Virtual 7",
259 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
260 "VCC", /* 0x60 voltage sensors */
261 "VSB",
262 "AVSB",
263 "VTT",
264 "VBAT",
265 "VREF",
266 "VIN0",
267 "VIN1",
268 "VIN2",
269 "VIN3",
270 "VIN4",
271 "VIN5",
272 "VIN6",
273 "VIN7",
274 "VIN8",
275 "VIN9",
276 "VIN10",
277 "VIN11",
278 "VIN12",
279 "VIN13",
280 "VIN14",
281 "VIN15",
282 "VIN16",
283 };
284
285 #define NUM_MON_LABELS ARRAY_SIZE(nct6683_mon_label)
286 #define MON_VOLTAGE_START 0x60
287
288 /* ------------------------------------------------------- */
289
290 struct nct6683_data {
291 int addr; /* IO base of EC space */
292 int sioreg; /* SIO register */
293 enum kinds kind;
294 u16 customer_id;
295
296 struct device *hwmon_dev;
297 const struct attribute_group *groups[6];
298
299 int temp_num; /* number of temperature attributes */
300 u8 temp_index[NCT6683_NUM_REG_MON];
301 u8 temp_src[NCT6683_NUM_REG_MON];
302
303 u8 in_num; /* number of voltage attributes */
304 u8 in_index[NCT6683_NUM_REG_MON];
305 u8 in_src[NCT6683_NUM_REG_MON];
306
307 struct mutex update_lock; /* used to protect sensor updates */
308 bool valid; /* true if following fields are valid */
309 unsigned long last_updated; /* In jiffies */
310
311 /* Voltage attribute values */
312 u8 in[3][NCT6683_NUM_REG_MON]; /* [0]=in, [1]=in_max, [2]=in_min */
313
314 /* Temperature attribute values */
315 s16 temp_in[NCT6683_NUM_REG_MON];
316 s8 temp[4][NCT6683_NUM_REG_MON];/* [0]=min, [1]=max, [2]=hyst,
317 * [3]=crit
318 */
319
320 /* Fan attribute values */
321 unsigned int rpm[NCT6683_NUM_REG_FAN];
322 u16 fan_min[NCT6683_NUM_REG_FAN];
323 u8 fanin_cfg[NCT6683_NUM_REG_FAN];
324 u8 fanout_cfg[NCT6683_NUM_REG_FAN];
325 u16 have_fan; /* some fan inputs can be disabled */
326
327 u8 have_pwm;
328 u8 pwm[NCT6683_NUM_REG_PWM];
329
330 #ifdef CONFIG_PM
331 /* Remember extra register values over suspend/resume */
332 u8 hwm_cfg;
333 #endif
334 };
335
336 struct nct6683_sio_data {
337 int sioreg;
338 enum kinds kind;
339 };
340
341 struct sensor_device_template {
342 struct device_attribute dev_attr;
343 union {
344 struct {
345 u8 nr;
346 u8 index;
347 } s;
348 int index;
349 } u;
350 bool s2; /* true if both index and nr are used */
351 };
352
353 struct sensor_device_attr_u {
354 union {
355 struct sensor_device_attribute a1;
356 struct sensor_device_attribute_2 a2;
357 } u;
358 char name[32];
359 };
360
361 #define __TEMPLATE_ATTR(_template, _mode, _show, _store) { \
362 .attr = {.name = _template, .mode = _mode }, \
363 .show = _show, \
364 .store = _store, \
365 }
366
367 #define SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, _index) \
368 { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
369 .u.index = _index, \
370 .s2 = false }
371
372 #define SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store, \
373 _nr, _index) \
374 { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
375 .u.s.index = _index, \
376 .u.s.nr = _nr, \
377 .s2 = true }
378
379 #define SENSOR_TEMPLATE(_name, _template, _mode, _show, _store, _index) \
380 static struct sensor_device_template sensor_dev_template_##_name \
381 = SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, \
382 _index)
383
384 #define SENSOR_TEMPLATE_2(_name, _template, _mode, _show, _store, \
385 _nr, _index) \
386 static struct sensor_device_template sensor_dev_template_##_name \
387 = SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store, \
388 _nr, _index)
389
390 struct sensor_template_group {
391 struct sensor_device_template **templates;
392 umode_t (*is_visible)(struct kobject *, struct attribute *, int);
393 int base;
394 };
395
396 static struct attribute_group *
397 nct6683_create_attr_group(struct device *dev, struct sensor_template_group *tg,
398 int repeat)
399 {
400 struct sensor_device_attribute_2 *a2;
401 struct sensor_device_attribute *a;
402 struct sensor_device_template **t;
403 struct sensor_device_attr_u *su;
404 struct attribute_group *group;
405 struct attribute **attrs;
406 int i, j, count;
407
408 if (repeat <= 0)
409 return ERR_PTR(-EINVAL);
410
411 t = tg->templates;
412 for (count = 0; *t; t++, count++)
413 ;
414
415 if (count == 0)
416 return ERR_PTR(-EINVAL);
417
418 group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL);
419 if (group == NULL)
420 return ERR_PTR(-ENOMEM);
421
422 attrs = devm_kzalloc(dev, sizeof(*attrs) * (repeat * count + 1),
423 GFP_KERNEL);
424 if (attrs == NULL)
425 return ERR_PTR(-ENOMEM);
426
427 su = devm_kzalloc(dev, sizeof(*su) * repeat * count,
428 GFP_KERNEL);
429 if (su == NULL)
430 return ERR_PTR(-ENOMEM);
431
432 group->attrs = attrs;
433 group->is_visible = tg->is_visible;
434
435 for (i = 0; i < repeat; i++) {
436 t = tg->templates;
437 for (j = 0; *t != NULL; j++) {
438 snprintf(su->name, sizeof(su->name),
439 (*t)->dev_attr.attr.name, tg->base + i);
440 if ((*t)->s2) {
441 a2 = &su->u.a2;
442 sysfs_attr_init(&a2->dev_attr.attr);
443 a2->dev_attr.attr.name = su->name;
444 a2->nr = (*t)->u.s.nr + i;
445 a2->index = (*t)->u.s.index;
446 a2->dev_attr.attr.mode =
447 (*t)->dev_attr.attr.mode;
448 a2->dev_attr.show = (*t)->dev_attr.show;
449 a2->dev_attr.store = (*t)->dev_attr.store;
450 *attrs = &a2->dev_attr.attr;
451 } else {
452 a = &su->u.a1;
453 sysfs_attr_init(&a->dev_attr.attr);
454 a->dev_attr.attr.name = su->name;
455 a->index = (*t)->u.index + i;
456 a->dev_attr.attr.mode =
457 (*t)->dev_attr.attr.mode;
458 a->dev_attr.show = (*t)->dev_attr.show;
459 a->dev_attr.store = (*t)->dev_attr.store;
460 *attrs = &a->dev_attr.attr;
461 }
462 attrs++;
463 su++;
464 t++;
465 }
466 }
467
468 return group;
469 }
470
471 /* LSB is 16 mV, except for the following sources, where it is 32 mV */
472 #define MON_SRC_VCC 0x60
473 #define MON_SRC_VSB 0x61
474 #define MON_SRC_AVSB 0x62
475 #define MON_SRC_VBAT 0x64
476
477 static inline long in_from_reg(u16 reg, u8 src)
478 {
479 int scale = 16;
480
481 if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB ||
482 src == MON_SRC_VBAT)
483 scale <<= 1;
484 return reg * scale;
485 }
486
487 static inline u16 in_to_reg(u32 val, 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
495 return clamp_val(DIV_ROUND_CLOSEST(val, scale), 0, 127);
496 }
497
498 static u16 nct6683_read(struct nct6683_data *data, u16 reg)
499 {
500 int res;
501
502 outb_p(0xff, data->addr + EC_PAGE_REG); /* unlock */
503 outb_p(reg >> 8, data->addr + EC_PAGE_REG);
504 outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
505 res = inb_p(data->addr + EC_DATA_REG);
506 return res;
507 }
508
509 static u16 nct6683_read16(struct nct6683_data *data, u16 reg)
510 {
511 return (nct6683_read(data, reg) << 8) | nct6683_read(data, reg + 1);
512 }
513
514 static void nct6683_write(struct nct6683_data *data, u16 reg, u16 value)
515 {
516 outb_p(0xff, data->addr + EC_PAGE_REG); /* unlock */
517 outb_p(reg >> 8, data->addr + EC_PAGE_REG);
518 outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
519 outb_p(value & 0xff, data->addr + EC_DATA_REG);
520 }
521
522 static int get_in_reg(struct nct6683_data *data, int nr, int index)
523 {
524 int ch = data->in_index[index];
525 int reg = -EINVAL;
526
527 switch (nr) {
528 case 0:
529 reg = NCT6683_REG_MON(ch);
530 break;
531 case 1:
532 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
533 reg = NCT6683_REG_MON_LOW(ch);
534 break;
535 case 2:
536 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
537 reg = NCT6683_REG_MON_HIGH(ch);
538 break;
539 default:
540 break;
541 }
542 return reg;
543 }
544
545 static int get_temp_reg(struct nct6683_data *data, int nr, int index)
546 {
547 int ch = data->temp_index[index];
548 int reg = -EINVAL;
549
550 switch (data->customer_id) {
551 case NCT6683_CUSTOMER_ID_INTEL:
552 switch (nr) {
553 default:
554 case 1: /* max */
555 reg = NCT6683_REG_INTEL_TEMP_MAX(ch);
556 break;
557 case 3: /* crit */
558 reg = NCT6683_REG_INTEL_TEMP_CRIT(ch);
559 break;
560 }
561 break;
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
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
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
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
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
675 static umode_t nct6683_in_is_visible(struct kobject *kobj,
676 struct attribute *attr, int index)
677 {
678 struct device *dev = container_of(kobj, struct device, 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 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
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
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
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
740 static umode_t nct6683_fan_is_visible(struct kobject *kobj,
741 struct attribute *attr, int index)
742 {
743 struct device *dev = container_of(kobj, struct device, 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 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
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
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
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
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
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
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
858 static umode_t nct6683_temp_is_visible(struct kobject *kobj,
859 struct attribute *attr, int index)
860 {
861 struct device *dev = container_of(kobj, struct device, 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 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
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 SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, NULL, 0);
922
923 static umode_t nct6683_pwm_is_visible(struct kobject *kobj,
924 struct attribute *attr, int index)
925 {
926 struct device *dev = container_of(kobj, struct device, kobj);
927 struct nct6683_data *data = dev_get_drvdata(dev);
928 int pwm = index; /* pwm index */
929
930 if (!(data->have_pwm & (1 << pwm)))
931 return 0;
932
933 return attr->mode;
934 }
935
936 static struct sensor_device_template *nct6683_attributes_pwm_template[] = {
937 &sensor_dev_template_pwm,
938 NULL
939 };
940
941 static struct sensor_template_group nct6683_pwm_template_group = {
942 .templates = nct6683_attributes_pwm_template,
943 .is_visible = nct6683_pwm_is_visible,
944 .base = 1,
945 };
946
947 static ssize_t
948 show_global_beep(struct device *dev, struct device_attribute *attr, char *buf)
949 {
950 struct nct6683_data *data = dev_get_drvdata(dev);
951 int ret;
952 u8 reg;
953
954 mutex_lock(&data->update_lock);
955
956 ret = superio_enter(data->sioreg);
957 if (ret)
958 goto error;
959 superio_select(data->sioreg, NCT6683_LD_HWM);
960 reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
961 superio_exit(data->sioreg);
962
963 mutex_unlock(&data->update_lock);
964
965 return sprintf(buf, "%u\n", !!(reg & NCT6683_CR_BEEP_MASK));
966
967 error:
968 mutex_unlock(&data->update_lock);
969 return ret;
970 }
971
972 static ssize_t
973 store_global_beep(struct device *dev, struct device_attribute *attr,
974 const char *buf, size_t count)
975 {
976 struct nct6683_data *data = dev_get_drvdata(dev);
977 unsigned long val;
978 u8 reg;
979 int ret;
980
981 if (kstrtoul(buf, 10, &val) || (val != 0 && val != 1))
982 return -EINVAL;
983
984 mutex_lock(&data->update_lock);
985
986 ret = superio_enter(data->sioreg);
987 if (ret) {
988 count = ret;
989 goto error;
990 }
991
992 superio_select(data->sioreg, NCT6683_LD_HWM);
993 reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
994 if (val)
995 reg |= NCT6683_CR_BEEP_MASK;
996 else
997 reg &= ~NCT6683_CR_BEEP_MASK;
998 superio_outb(data->sioreg, NCT6683_REG_CR_BEEP, reg);
999 superio_exit(data->sioreg);
1000 error:
1001 mutex_unlock(&data->update_lock);
1002 return count;
1003 }
1004
1005 /* Case open detection */
1006
1007 static ssize_t
1008 show_caseopen(struct device *dev, struct device_attribute *attr, char *buf)
1009 {
1010 struct nct6683_data *data = dev_get_drvdata(dev);
1011 int ret;
1012 u8 reg;
1013
1014 mutex_lock(&data->update_lock);
1015
1016 ret = superio_enter(data->sioreg);
1017 if (ret)
1018 goto error;
1019 superio_select(data->sioreg, NCT6683_LD_ACPI);
1020 reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1021 superio_exit(data->sioreg);
1022
1023 mutex_unlock(&data->update_lock);
1024
1025 return sprintf(buf, "%u\n", !(reg & NCT6683_CR_CASEOPEN_MASK));
1026
1027 error:
1028 mutex_unlock(&data->update_lock);
1029 return ret;
1030 }
1031
1032 static ssize_t
1033 clear_caseopen(struct device *dev, struct device_attribute *attr,
1034 const char *buf, size_t count)
1035 {
1036 struct nct6683_data *data = dev_get_drvdata(dev);
1037 unsigned long val;
1038 u8 reg;
1039 int ret;
1040
1041 if (kstrtoul(buf, 10, &val) || val != 0)
1042 return -EINVAL;
1043
1044 mutex_lock(&data->update_lock);
1045
1046 /*
1047 * Use CR registers to clear caseopen status.
1048 * Caseopen is activ low, clear by writing 1 into the register.
1049 */
1050
1051 ret = superio_enter(data->sioreg);
1052 if (ret) {
1053 count = ret;
1054 goto error;
1055 }
1056
1057 superio_select(data->sioreg, NCT6683_LD_ACPI);
1058 reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1059 reg |= NCT6683_CR_CASEOPEN_MASK;
1060 superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1061 reg &= ~NCT6683_CR_CASEOPEN_MASK;
1062 superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1063 superio_exit(data->sioreg);
1064
1065 data->valid = false; /* Force cache refresh */
1066 error:
1067 mutex_unlock(&data->update_lock);
1068 return count;
1069 }
1070
1071 static DEVICE_ATTR(intrusion0_alarm, S_IWUSR | S_IRUGO, show_caseopen,
1072 clear_caseopen);
1073 static DEVICE_ATTR(beep_enable, S_IWUSR | S_IRUGO, show_global_beep,
1074 store_global_beep);
1075
1076 static struct attribute *nct6683_attributes_other[] = {
1077 &dev_attr_intrusion0_alarm.attr,
1078 &dev_attr_beep_enable.attr,
1079 NULL
1080 };
1081
1082 static const struct attribute_group nct6683_group_other = {
1083 .attrs = nct6683_attributes_other,
1084 };
1085
1086 /* Get the monitoring functions started */
1087 static inline void nct6683_init_device(struct nct6683_data *data)
1088 {
1089 u8 tmp;
1090
1091 /* Start hardware monitoring if needed */
1092 tmp = nct6683_read(data, NCT6683_HWM_CFG);
1093 if (!(tmp & 0x80))
1094 nct6683_write(data, NCT6683_HWM_CFG, tmp | 0x80);
1095 }
1096
1097 /*
1098 * There are a total of 24 fan inputs. Each can be configured as input
1099 * or as output. A maximum of 16 inputs and 8 outputs is configurable.
1100 */
1101 static void
1102 nct6683_setup_fans(struct nct6683_data *data)
1103 {
1104 int i;
1105 u8 reg;
1106
1107 for (i = 0; i < NCT6683_NUM_REG_FAN; i++) {
1108 reg = nct6683_read(data, NCT6683_REG_FANIN_CFG(i));
1109 if (reg & 0x80)
1110 data->have_fan |= 1 << i;
1111 data->fanin_cfg[i] = reg;
1112 }
1113 for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
1114 reg = nct6683_read(data, NCT6683_REG_FANOUT_CFG(i));
1115 if (reg & 0x80)
1116 data->have_pwm |= 1 << i;
1117 data->fanout_cfg[i] = reg;
1118 }
1119 }
1120
1121 /*
1122 * Translation from monitoring register to temperature and voltage attributes
1123 * ==========================================================================
1124 *
1125 * There are a total of 32 monitoring registers. Each can be assigned to either
1126 * a temperature or voltage monitoring source.
1127 * NCT6683_REG_MON_CFG(x) defines assignment for each monitoring source.
1128 *
1129 * Temperature and voltage attribute mapping is determined by walking through
1130 * the NCT6683_REG_MON_CFG registers. If the assigned source is
1131 * a temperature, temp_index[n] is set to the monitor register index, and
1132 * temp_src[n] is set to the temperature source. If the assigned source is
1133 * a voltage, the respective values are stored in in_index[] and in_src[],
1134 * respectively.
1135 */
1136
1137 static void nct6683_setup_sensors(struct nct6683_data *data)
1138 {
1139 u8 reg;
1140 int i;
1141
1142 data->temp_num = 0;
1143 data->in_num = 0;
1144 for (i = 0; i < NCT6683_NUM_REG_MON; i++) {
1145 reg = nct6683_read(data, NCT6683_REG_MON_CFG(i)) & 0x7f;
1146 /* Ignore invalid assignments */
1147 if (reg >= NUM_MON_LABELS)
1148 continue;
1149 /* Skip if disabled or reserved */
1150 if (nct6683_mon_label[reg] == NULL)
1151 continue;
1152 if (reg < MON_VOLTAGE_START) {
1153 data->temp_index[data->temp_num] = i;
1154 data->temp_src[data->temp_num] = reg;
1155 data->temp_num++;
1156 } else {
1157 data->in_index[data->in_num] = i;
1158 data->in_src[data->in_num] = reg;
1159 data->in_num++;
1160 }
1161 }
1162 }
1163
1164 static int nct6683_probe(struct platform_device *pdev)
1165 {
1166 struct device *dev = &pdev->dev;
1167 struct nct6683_sio_data *sio_data = dev->platform_data;
1168 struct attribute_group *group;
1169 struct nct6683_data *data;
1170 struct device *hwmon_dev;
1171 struct resource *res;
1172 int groups = 0;
1173
1174 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1175 if (!devm_request_region(dev, res->start, IOREGION_LENGTH, DRVNAME))
1176 return -EBUSY;
1177
1178 data = devm_kzalloc(dev, sizeof(struct nct6683_data), GFP_KERNEL);
1179 if (!data)
1180 return -ENOMEM;
1181
1182 data->kind = sio_data->kind;
1183 data->sioreg = sio_data->sioreg;
1184 data->addr = res->start;
1185 mutex_init(&data->update_lock);
1186 platform_set_drvdata(pdev, data);
1187
1188 data->customer_id = nct6683_read16(data, NCT6683_REG_CUSTOMER_ID);
1189
1190 nct6683_init_device(data);
1191 nct6683_setup_fans(data);
1192 nct6683_setup_sensors(data);
1193
1194 /* Register sysfs hooks */
1195
1196 if (data->have_pwm) {
1197 group = nct6683_create_attr_group(dev,
1198 &nct6683_pwm_template_group,
1199 fls(data->have_pwm));
1200 if (IS_ERR(group))
1201 return PTR_ERR(group);
1202 data->groups[groups++] = group;
1203 }
1204
1205 if (data->in_num) {
1206 group = nct6683_create_attr_group(dev,
1207 &nct6683_in_template_group,
1208 data->in_num);
1209 if (IS_ERR(group))
1210 return PTR_ERR(group);
1211 data->groups[groups++] = group;
1212 }
1213
1214 if (data->have_fan) {
1215 group = nct6683_create_attr_group(dev,
1216 &nct6683_fan_template_group,
1217 fls(data->have_fan));
1218 if (IS_ERR(group))
1219 return PTR_ERR(group);
1220 data->groups[groups++] = group;
1221 }
1222
1223 if (data->temp_num) {
1224 group = nct6683_create_attr_group(dev,
1225 &nct6683_temp_template_group,
1226 data->temp_num);
1227 if (IS_ERR(group))
1228 return PTR_ERR(group);
1229 data->groups[groups++] = group;
1230 }
1231 data->groups[groups++] = &nct6683_group_other;
1232
1233 dev_info(dev, "%s EC firmware version %d.%d build %02x/%02x/%02x\n",
1234 nct6683_chip_names[data->kind],
1235 nct6683_read(data, NCT6683_REG_VERSION_HI),
1236 nct6683_read(data, NCT6683_REG_VERSION_LO),
1237 nct6683_read(data, NCT6683_REG_BUILD_MONTH),
1238 nct6683_read(data, NCT6683_REG_BUILD_DAY),
1239 nct6683_read(data, NCT6683_REG_BUILD_YEAR));
1240
1241 hwmon_dev = devm_hwmon_device_register_with_groups(dev,
1242 nct6683_device_names[data->kind], data, data->groups);
1243 return PTR_ERR_OR_ZERO(hwmon_dev);
1244 }
1245
1246 #ifdef CONFIG_PM
1247 static int nct6683_suspend(struct device *dev)
1248 {
1249 struct nct6683_data *data = nct6683_update_device(dev);
1250
1251 mutex_lock(&data->update_lock);
1252 data->hwm_cfg = nct6683_read(data, NCT6683_HWM_CFG);
1253 mutex_unlock(&data->update_lock);
1254
1255 return 0;
1256 }
1257
1258 static int nct6683_resume(struct device *dev)
1259 {
1260 struct nct6683_data *data = dev_get_drvdata(dev);
1261
1262 mutex_lock(&data->update_lock);
1263
1264 nct6683_write(data, NCT6683_HWM_CFG, data->hwm_cfg);
1265
1266 /* Force re-reading all values */
1267 data->valid = false;
1268 mutex_unlock(&data->update_lock);
1269
1270 return 0;
1271 }
1272
1273 static const struct dev_pm_ops nct6683_dev_pm_ops = {
1274 .suspend = nct6683_suspend,
1275 .resume = nct6683_resume,
1276 .freeze = nct6683_suspend,
1277 .restore = nct6683_resume,
1278 };
1279
1280 #define NCT6683_DEV_PM_OPS (&nct6683_dev_pm_ops)
1281 #else
1282 #define NCT6683_DEV_PM_OPS NULL
1283 #endif /* CONFIG_PM */
1284
1285 static struct platform_driver nct6683_driver = {
1286 .driver = {
1287 .name = DRVNAME,
1288 .pm = NCT6683_DEV_PM_OPS,
1289 },
1290 .probe = nct6683_probe,
1291 };
1292
1293 static int __init nct6683_find(int sioaddr, struct nct6683_sio_data *sio_data)
1294 {
1295 const char *board_vendor;
1296 int addr;
1297 u16 val;
1298 int err;
1299
1300 /*
1301 * Only run on Intel boards unless the 'force' module parameter is set
1302 */
1303 if (!force) {
1304 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1305 if (!board_vendor || strcmp(board_vendor, "Intel Corporation"))
1306 return -ENODEV;
1307 }
1308
1309 err = superio_enter(sioaddr);
1310 if (err)
1311 return err;
1312
1313 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1314 | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1315
1316 switch (val & SIO_ID_MASK) {
1317 case SIO_NCT6683_ID:
1318 sio_data->kind = nct6683;
1319 break;
1320 default:
1321 if (val != 0xffff)
1322 pr_debug("unsupported chip ID: 0x%04x\n", val);
1323 goto fail;
1324 }
1325
1326 /* We have a known chip, find the HWM I/O address */
1327 superio_select(sioaddr, NCT6683_LD_HWM);
1328 val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
1329 | superio_inb(sioaddr, SIO_REG_ADDR + 1);
1330 addr = val & IOREGION_ALIGNMENT;
1331 if (addr == 0) {
1332 pr_err("EC base I/O port unconfigured\n");
1333 goto fail;
1334 }
1335
1336 /* Activate logical device if needed */
1337 val = superio_inb(sioaddr, SIO_REG_ENABLE);
1338 if (!(val & 0x01)) {
1339 pr_err("EC is disabled\n");
1340 goto fail;
1341 }
1342
1343 superio_exit(sioaddr);
1344 pr_info("Found %s or compatible chip at %#x:%#x\n",
1345 nct6683_chip_names[sio_data->kind], sioaddr, addr);
1346 sio_data->sioreg = sioaddr;
1347
1348 return addr;
1349
1350 fail:
1351 superio_exit(sioaddr);
1352 return -ENODEV;
1353 }
1354
1355 /*
1356 * when Super-I/O functions move to a separate file, the Super-I/O
1357 * bus will manage the lifetime of the device and this module will only keep
1358 * track of the nct6683 driver. But since we use platform_device_alloc(), we
1359 * must keep track of the device
1360 */
1361 static struct platform_device *pdev[2];
1362
1363 static int __init sensors_nct6683_init(void)
1364 {
1365 struct nct6683_sio_data sio_data;
1366 int sioaddr[2] = { 0x2e, 0x4e };
1367 struct resource res;
1368 bool found = false;
1369 int address;
1370 int i, err;
1371
1372 err = platform_driver_register(&nct6683_driver);
1373 if (err)
1374 return err;
1375
1376 /*
1377 * initialize sio_data->kind and sio_data->sioreg.
1378 *
1379 * when Super-I/O functions move to a separate file, the Super-I/O
1380 * driver will probe 0x2e and 0x4e and auto-detect the presence of a
1381 * nct6683 hardware monitor, and call probe()
1382 */
1383 for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1384 address = nct6683_find(sioaddr[i], &sio_data);
1385 if (address <= 0)
1386 continue;
1387
1388 found = true;
1389
1390 pdev[i] = platform_device_alloc(DRVNAME, address);
1391 if (!pdev[i]) {
1392 err = -ENOMEM;
1393 goto exit_device_unregister;
1394 }
1395
1396 err = platform_device_add_data(pdev[i], &sio_data,
1397 sizeof(struct nct6683_sio_data));
1398 if (err)
1399 goto exit_device_put;
1400
1401 memset(&res, 0, sizeof(res));
1402 res.name = DRVNAME;
1403 res.start = address + IOREGION_OFFSET;
1404 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1405 res.flags = IORESOURCE_IO;
1406
1407 err = acpi_check_resource_conflict(&res);
1408 if (err) {
1409 platform_device_put(pdev[i]);
1410 pdev[i] = NULL;
1411 continue;
1412 }
1413
1414 err = platform_device_add_resources(pdev[i], &res, 1);
1415 if (err)
1416 goto exit_device_put;
1417
1418 /* platform_device_add calls probe() */
1419 err = platform_device_add(pdev[i]);
1420 if (err)
1421 goto exit_device_put;
1422 }
1423 if (!found) {
1424 err = -ENODEV;
1425 goto exit_unregister;
1426 }
1427
1428 return 0;
1429
1430 exit_device_put:
1431 platform_device_put(pdev[i]);
1432 exit_device_unregister:
1433 while (--i >= 0) {
1434 if (pdev[i])
1435 platform_device_unregister(pdev[i]);
1436 }
1437 exit_unregister:
1438 platform_driver_unregister(&nct6683_driver);
1439 return err;
1440 }
1441
1442 static void __exit sensors_nct6683_exit(void)
1443 {
1444 int i;
1445
1446 for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1447 if (pdev[i])
1448 platform_device_unregister(pdev[i]);
1449 }
1450 platform_driver_unregister(&nct6683_driver);
1451 }
1452
1453 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
1454 MODULE_DESCRIPTION("NCT6683D driver");
1455 MODULE_LICENSE("GPL");
1456
1457 module_init(sensors_nct6683_init);
1458 module_exit(sensors_nct6683_exit);
Ubuntu Artful kernel mirror