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