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