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