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; | |
442 | a2->dev_attr.attr.name = su->name; | |
443 | a2->nr = (*t)->u.s.nr + i; | |
444 | a2->index = (*t)->u.s.index; | |
445 | a2->dev_attr.attr.mode = | |
446 | (*t)->dev_attr.attr.mode; | |
447 | a2->dev_attr.show = (*t)->dev_attr.show; | |
448 | a2->dev_attr.store = (*t)->dev_attr.store; | |
449 | *attrs = &a2->dev_attr.attr; | |
450 | } else { | |
451 | a = &su->u.a1; | |
452 | a->dev_attr.attr.name = su->name; | |
453 | a->index = (*t)->u.index + i; | |
454 | a->dev_attr.attr.mode = | |
455 | (*t)->dev_attr.attr.mode; | |
456 | a->dev_attr.show = (*t)->dev_attr.show; | |
457 | a->dev_attr.store = (*t)->dev_attr.store; | |
458 | *attrs = &a->dev_attr.attr; | |
459 | } | |
460 | attrs++; | |
461 | su++; | |
462 | t++; | |
463 | } | |
464 | } | |
465 | ||
466 | return group; | |
467 | } | |
468 | ||
469 | /* LSB is 16 mV, except for the following sources, where it is 32 mV */ | |
470 | #define MON_SRC_VCC 0x60 | |
471 | #define MON_SRC_VSB 0x61 | |
472 | #define MON_SRC_AVSB 0x62 | |
473 | #define MON_SRC_VBAT 0x64 | |
474 | ||
475 | static inline long in_from_reg(u16 reg, u8 src) | |
476 | { | |
477 | int scale = 16; | |
478 | ||
479 | if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB || | |
480 | src == MON_SRC_VBAT) | |
481 | scale <<= 1; | |
482 | return reg * scale; | |
483 | } | |
484 | ||
485 | static inline u16 in_to_reg(u32 val, u8 src) | |
486 | { | |
487 | int scale = 16; | |
488 | ||
489 | if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB || | |
490 | src == MON_SRC_VBAT) | |
491 | scale <<= 1; | |
492 | ||
493 | return clamp_val(DIV_ROUND_CLOSEST(val, scale), 0, 127); | |
494 | } | |
495 | ||
496 | static u16 nct6683_read(struct nct6683_data *data, u16 reg) | |
497 | { | |
498 | int res; | |
499 | ||
500 | outb_p(0xff, data->addr + EC_PAGE_REG); /* unlock */ | |
501 | outb_p(reg >> 8, data->addr + EC_PAGE_REG); | |
502 | outb_p(reg & 0xff, data->addr + EC_INDEX_REG); | |
503 | res = inb_p(data->addr + EC_DATA_REG); | |
504 | return res; | |
505 | } | |
506 | ||
507 | static u16 nct6683_read16(struct nct6683_data *data, u16 reg) | |
508 | { | |
509 | return (nct6683_read(data, reg) << 8) | nct6683_read(data, reg + 1); | |
510 | } | |
511 | ||
512 | static void nct6683_write(struct nct6683_data *data, u16 reg, u16 value) | |
513 | { | |
514 | outb_p(0xff, data->addr + EC_PAGE_REG); /* unlock */ | |
515 | outb_p(reg >> 8, data->addr + EC_PAGE_REG); | |
516 | outb_p(reg & 0xff, data->addr + EC_INDEX_REG); | |
517 | outb_p(value & 0xff, data->addr + EC_DATA_REG); | |
518 | } | |
519 | ||
520 | static int get_in_reg(struct nct6683_data *data, int nr, int index) | |
521 | { | |
522 | int ch = data->in_index[index]; | |
523 | int reg = -EINVAL; | |
524 | ||
525 | switch (nr) { | |
526 | case 0: | |
527 | reg = NCT6683_REG_MON(ch); | |
528 | break; | |
529 | case 1: | |
530 | if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL) | |
531 | reg = NCT6683_REG_MON_LOW(ch); | |
532 | break; | |
533 | case 2: | |
534 | if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL) | |
535 | reg = NCT6683_REG_MON_HIGH(ch); | |
536 | break; | |
537 | default: | |
538 | break; | |
539 | } | |
540 | return reg; | |
541 | } | |
542 | ||
543 | static int get_temp_reg(struct nct6683_data *data, int nr, int index) | |
544 | { | |
545 | int ch = data->temp_index[index]; | |
546 | int reg = -EINVAL; | |
547 | ||
548 | switch (data->customer_id) { | |
549 | case NCT6683_CUSTOMER_ID_INTEL: | |
550 | switch (nr) { | |
551 | default: | |
552 | case 1: /* max */ | |
553 | reg = NCT6683_REG_INTEL_TEMP_MAX(ch); | |
554 | break; | |
555 | case 3: /* crit */ | |
556 | reg = NCT6683_REG_INTEL_TEMP_CRIT(ch); | |
557 | break; | |
558 | } | |
559 | break; | |
560 | default: | |
561 | switch (nr) { | |
562 | default: | |
563 | case 0: /* min */ | |
564 | reg = NCT6683_REG_MON_LOW(ch); | |
565 | break; | |
566 | case 1: /* max */ | |
567 | reg = NCT6683_REG_TEMP_MAX(ch); | |
568 | break; | |
569 | case 2: /* hyst */ | |
570 | reg = NCT6683_REG_TEMP_HYST(ch); | |
571 | break; | |
572 | case 3: /* crit */ | |
573 | reg = NCT6683_REG_MON_HIGH(ch); | |
574 | break; | |
575 | } | |
576 | break; | |
577 | } | |
578 | return reg; | |
579 | } | |
580 | ||
581 | static void nct6683_update_pwm(struct device *dev) | |
582 | { | |
583 | struct nct6683_data *data = dev_get_drvdata(dev); | |
584 | int i; | |
585 | ||
586 | for (i = 0; i < NCT6683_NUM_REG_PWM; i++) { | |
587 | if (!(data->have_pwm & (1 << i))) | |
588 | continue; | |
589 | data->pwm[i] = nct6683_read(data, NCT6683_REG_PWM(i)); | |
590 | } | |
591 | } | |
592 | ||
593 | static struct nct6683_data *nct6683_update_device(struct device *dev) | |
594 | { | |
595 | struct nct6683_data *data = dev_get_drvdata(dev); | |
596 | int i, j; | |
597 | ||
598 | mutex_lock(&data->update_lock); | |
599 | ||
600 | if (time_after(jiffies, data->last_updated + HZ) || !data->valid) { | |
601 | /* Measured voltages and limits */ | |
602 | for (i = 0; i < data->in_num; i++) { | |
603 | for (j = 0; j < 3; j++) { | |
604 | int reg = get_in_reg(data, j, i); | |
605 | ||
606 | if (reg >= 0) | |
607 | data->in[j][i] = | |
608 | nct6683_read(data, reg); | |
609 | } | |
610 | } | |
611 | ||
612 | /* Measured temperatures and limits */ | |
613 | for (i = 0; i < data->temp_num; i++) { | |
614 | u8 ch = data->temp_index[i]; | |
615 | ||
616 | data->temp_in[i] = nct6683_read16(data, | |
617 | NCT6683_REG_MON(ch)); | |
618 | for (j = 0; j < 4; j++) { | |
619 | int reg = get_temp_reg(data, j, i); | |
620 | ||
621 | if (reg >= 0) | |
622 | data->temp[j][i] = | |
623 | nct6683_read(data, reg); | |
624 | } | |
625 | } | |
626 | ||
627 | /* Measured fan speeds and limits */ | |
628 | for (i = 0; i < ARRAY_SIZE(data->rpm); i++) { | |
629 | if (!(data->have_fan & (1 << i))) | |
630 | continue; | |
631 | ||
632 | data->rpm[i] = nct6683_read16(data, | |
633 | NCT6683_REG_FAN_RPM(i)); | |
634 | data->fan_min[i] = nct6683_read16(data, | |
635 | NCT6683_REG_FAN_MIN(i)); | |
636 | } | |
637 | ||
638 | nct6683_update_pwm(dev); | |
639 | ||
640 | data->last_updated = jiffies; | |
641 | data->valid = true; | |
642 | } | |
643 | ||
644 | mutex_unlock(&data->update_lock); | |
645 | return data; | |
646 | } | |
647 | ||
648 | /* | |
649 | * Sysfs callback functions | |
650 | */ | |
651 | static ssize_t | |
652 | show_in_label(struct device *dev, struct device_attribute *attr, char *buf) | |
653 | { | |
654 | struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); | |
655 | struct nct6683_data *data = nct6683_update_device(dev); | |
656 | int nr = sattr->index; | |
657 | ||
658 | return sprintf(buf, "%s\n", nct6683_mon_label[data->in_src[nr]]); | |
659 | } | |
660 | ||
661 | static ssize_t | |
662 | show_in_reg(struct device *dev, struct device_attribute *attr, char *buf) | |
663 | { | |
664 | struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); | |
665 | struct nct6683_data *data = nct6683_update_device(dev); | |
666 | int index = sattr->index; | |
667 | int nr = sattr->nr; | |
668 | ||
669 | return sprintf(buf, "%ld\n", | |
670 | in_from_reg(data->in[index][nr], data->in_index[index])); | |
671 | } | |
672 | ||
673 | static umode_t nct6683_in_is_visible(struct kobject *kobj, | |
674 | struct attribute *attr, int index) | |
675 | { | |
676 | struct device *dev = container_of(kobj, struct device, kobj); | |
677 | struct nct6683_data *data = dev_get_drvdata(dev); | |
678 | int nr = index % 4; /* attribute */ | |
679 | ||
680 | /* | |
681 | * Voltage limits exist for Intel boards, | |
682 | * but register location and encoding is unknown | |
683 | */ | |
684 | if ((nr == 2 || nr == 3) && | |
685 | data->customer_id == NCT6683_CUSTOMER_ID_INTEL) | |
686 | return 0; | |
687 | ||
688 | return attr->mode; | |
689 | } | |
690 | ||
691 | SENSOR_TEMPLATE(in_label, "in%d_label", S_IRUGO, show_in_label, NULL, 0); | |
692 | SENSOR_TEMPLATE_2(in_input, "in%d_input", S_IRUGO, show_in_reg, NULL, 0, 0); | |
693 | SENSOR_TEMPLATE_2(in_min, "in%d_min", S_IRUGO, show_in_reg, NULL, 0, 1); | |
694 | SENSOR_TEMPLATE_2(in_max, "in%d_max", S_IRUGO, show_in_reg, NULL, 0, 2); | |
695 | ||
696 | static struct sensor_device_template *nct6683_attributes_in_template[] = { | |
697 | &sensor_dev_template_in_label, | |
698 | &sensor_dev_template_in_input, | |
699 | &sensor_dev_template_in_min, | |
700 | &sensor_dev_template_in_max, | |
701 | NULL | |
702 | }; | |
703 | ||
704 | static struct sensor_template_group nct6683_in_template_group = { | |
705 | .templates = nct6683_attributes_in_template, | |
706 | .is_visible = nct6683_in_is_visible, | |
707 | }; | |
708 | ||
709 | static ssize_t | |
710 | show_fan(struct device *dev, struct device_attribute *attr, char *buf) | |
711 | { | |
712 | struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); | |
713 | struct nct6683_data *data = nct6683_update_device(dev); | |
714 | ||
715 | return sprintf(buf, "%d\n", data->rpm[sattr->index]); | |
716 | } | |
717 | ||
718 | static ssize_t | |
719 | show_fan_min(struct device *dev, struct device_attribute *attr, char *buf) | |
720 | { | |
721 | struct nct6683_data *data = nct6683_update_device(dev); | |
722 | struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); | |
723 | int nr = sattr->index; | |
724 | ||
725 | return sprintf(buf, "%d\n", data->fan_min[nr]); | |
726 | } | |
727 | ||
728 | static ssize_t | |
729 | show_fan_pulses(struct device *dev, struct device_attribute *attr, char *buf) | |
730 | { | |
731 | struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); | |
732 | struct nct6683_data *data = nct6683_update_device(dev); | |
733 | ||
734 | return sprintf(buf, "%d\n", | |
735 | ((data->fanin_cfg[sattr->index] >> 5) & 0x03) + 1); | |
736 | } | |
737 | ||
738 | static umode_t nct6683_fan_is_visible(struct kobject *kobj, | |
739 | struct attribute *attr, int index) | |
740 | { | |
741 | struct device *dev = container_of(kobj, struct device, kobj); | |
742 | struct nct6683_data *data = dev_get_drvdata(dev); | |
743 | int fan = index / 3; /* fan index */ | |
744 | int nr = index % 3; /* attribute index */ | |
745 | ||
746 | if (!(data->have_fan & (1 << fan))) | |
747 | return 0; | |
748 | ||
749 | /* | |
750 | * Intel may have minimum fan speed limits, | |
751 | * but register location and encoding are unknown. | |
752 | */ | |
753 | if (nr == 2 && data->customer_id == NCT6683_CUSTOMER_ID_INTEL) | |
754 | return 0; | |
755 | ||
756 | return attr->mode; | |
757 | } | |
758 | ||
759 | SENSOR_TEMPLATE(fan_input, "fan%d_input", S_IRUGO, show_fan, NULL, 0); | |
760 | SENSOR_TEMPLATE(fan_pulses, "fan%d_pulses", S_IRUGO, show_fan_pulses, NULL, 0); | |
761 | SENSOR_TEMPLATE(fan_min, "fan%d_min", S_IRUGO, show_fan_min, NULL, 0); | |
762 | ||
763 | /* | |
764 | * nct6683_fan_is_visible uses the index into the following array | |
765 | * to determine if attributes should be created or not. | |
766 | * Any change in order or content must be matched. | |
767 | */ | |
768 | static struct sensor_device_template *nct6683_attributes_fan_template[] = { | |
769 | &sensor_dev_template_fan_input, | |
770 | &sensor_dev_template_fan_pulses, | |
771 | &sensor_dev_template_fan_min, | |
772 | NULL | |
773 | }; | |
774 | ||
775 | static struct sensor_template_group nct6683_fan_template_group = { | |
776 | .templates = nct6683_attributes_fan_template, | |
777 | .is_visible = nct6683_fan_is_visible, | |
778 | .base = 1, | |
779 | }; | |
780 | ||
781 | static ssize_t | |
782 | show_temp_label(struct device *dev, struct device_attribute *attr, char *buf) | |
783 | { | |
784 | struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); | |
785 | struct nct6683_data *data = nct6683_update_device(dev); | |
786 | int nr = sattr->index; | |
787 | ||
788 | return sprintf(buf, "%s\n", nct6683_mon_label[data->temp_src[nr]]); | |
789 | } | |
790 | ||
791 | static ssize_t | |
792 | show_temp8(struct device *dev, struct device_attribute *attr, char *buf) | |
793 | { | |
794 | struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); | |
795 | struct nct6683_data *data = nct6683_update_device(dev); | |
796 | int index = sattr->index; | |
797 | int nr = sattr->nr; | |
798 | ||
799 | return sprintf(buf, "%d\n", data->temp[index][nr] * 1000); | |
800 | } | |
801 | ||
802 | static ssize_t | |
803 | show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf) | |
804 | { | |
805 | struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); | |
806 | struct nct6683_data *data = nct6683_update_device(dev); | |
807 | int nr = sattr->index; | |
808 | int temp = data->temp[1][nr] - data->temp[2][nr]; | |
809 | ||
810 | return sprintf(buf, "%d\n", temp * 1000); | |
811 | } | |
812 | ||
813 | static ssize_t | |
814 | show_temp16(struct device *dev, struct device_attribute *attr, char *buf) | |
815 | { | |
816 | struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); | |
817 | struct nct6683_data *data = nct6683_update_device(dev); | |
818 | int index = sattr->index; | |
819 | ||
820 | return sprintf(buf, "%d\n", (data->temp_in[index] / 128) * 500); | |
821 | } | |
822 | ||
823 | /* | |
824 | * Temperature sensor type is determined by temperature source | |
825 | * and can not be modified. | |
826 | * 0x02..0x07: Thermal diode | |
827 | * 0x08..0x18: Thermistor | |
828 | * 0x20..0x2b: Intel PECI | |
829 | * 0x42..0x49: AMD TSI | |
830 | * Others are unspecified (not visible) | |
831 | */ | |
832 | ||
833 | static int get_temp_type(u8 src) | |
834 | { | |
835 | if (src >= 0x02 && src <= 0x07) | |
836 | return 3; /* thermal diode */ | |
837 | else if (src >= 0x08 && src <= 0x18) | |
838 | return 4; /* thermistor */ | |
839 | else if (src >= 0x20 && src <= 0x2b) | |
840 | return 6; /* PECI */ | |
841 | else if (src >= 0x42 && src <= 0x49) | |
842 | return 5; | |
843 | ||
844 | return 0; | |
845 | } | |
846 | ||
847 | static ssize_t | |
848 | show_temp_type(struct device *dev, struct device_attribute *attr, char *buf) | |
849 | { | |
850 | struct nct6683_data *data = nct6683_update_device(dev); | |
851 | struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); | |
852 | int nr = sattr->index; | |
853 | return sprintf(buf, "%d\n", get_temp_type(data->temp_src[nr])); | |
854 | } | |
855 | ||
856 | static umode_t nct6683_temp_is_visible(struct kobject *kobj, | |
857 | struct attribute *attr, int index) | |
858 | { | |
859 | struct device *dev = container_of(kobj, struct device, kobj); | |
860 | struct nct6683_data *data = dev_get_drvdata(dev); | |
861 | int temp = index / 7; /* temp index */ | |
862 | int nr = index % 7; /* attribute index */ | |
863 | ||
864 | /* | |
865 | * Intel does not have low temperature limits or temperature hysteresis | |
866 | * registers, or at least register location and encoding is unknown. | |
867 | */ | |
868 | if ((nr == 2 || nr == 4) && | |
869 | data->customer_id == NCT6683_CUSTOMER_ID_INTEL) | |
870 | return 0; | |
871 | ||
872 | if (nr == 6 && get_temp_type(data->temp_src[temp]) == 0) | |
873 | return 0; /* type */ | |
874 | ||
875 | return attr->mode; | |
876 | } | |
877 | ||
878 | SENSOR_TEMPLATE(temp_input, "temp%d_input", S_IRUGO, show_temp16, NULL, 0); | |
879 | SENSOR_TEMPLATE(temp_label, "temp%d_label", S_IRUGO, show_temp_label, NULL, 0); | |
880 | SENSOR_TEMPLATE_2(temp_min, "temp%d_min", S_IRUGO, show_temp8, NULL, 0, 0); | |
881 | SENSOR_TEMPLATE_2(temp_max, "temp%d_max", S_IRUGO, show_temp8, NULL, 0, 1); | |
882 | SENSOR_TEMPLATE(temp_max_hyst, "temp%d_max_hyst", S_IRUGO, show_temp_hyst, NULL, | |
883 | 0); | |
884 | SENSOR_TEMPLATE_2(temp_crit, "temp%d_crit", S_IRUGO, show_temp8, NULL, 0, 3); | |
885 | SENSOR_TEMPLATE(temp_type, "temp%d_type", S_IRUGO, show_temp_type, NULL, 0); | |
886 | ||
887 | /* | |
888 | * nct6683_temp_is_visible uses the index into the following array | |
889 | * to determine if attributes should be created or not. | |
890 | * Any change in order or content must be matched. | |
891 | */ | |
892 | static struct sensor_device_template *nct6683_attributes_temp_template[] = { | |
893 | &sensor_dev_template_temp_input, | |
894 | &sensor_dev_template_temp_label, | |
895 | &sensor_dev_template_temp_min, /* 2 */ | |
896 | &sensor_dev_template_temp_max, /* 3 */ | |
897 | &sensor_dev_template_temp_max_hyst, /* 4 */ | |
898 | &sensor_dev_template_temp_crit, /* 5 */ | |
899 | &sensor_dev_template_temp_type, /* 6 */ | |
900 | NULL | |
901 | }; | |
902 | ||
903 | static struct sensor_template_group nct6683_temp_template_group = { | |
904 | .templates = nct6683_attributes_temp_template, | |
905 | .is_visible = nct6683_temp_is_visible, | |
906 | .base = 1, | |
907 | }; | |
908 | ||
909 | static ssize_t | |
910 | show_pwm(struct device *dev, struct device_attribute *attr, char *buf) | |
911 | { | |
912 | struct nct6683_data *data = nct6683_update_device(dev); | |
913 | struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); | |
914 | int index = sattr->index; | |
915 | ||
916 | return sprintf(buf, "%d\n", data->pwm[index]); | |
917 | } | |
918 | ||
919 | SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, NULL, 0); | |
920 | ||
921 | static umode_t nct6683_pwm_is_visible(struct kobject *kobj, | |
922 | struct attribute *attr, int index) | |
923 | { | |
924 | struct device *dev = container_of(kobj, struct device, kobj); | |
925 | struct nct6683_data *data = dev_get_drvdata(dev); | |
926 | int pwm = index; /* pwm index */ | |
927 | ||
928 | if (!(data->have_pwm & (1 << pwm))) | |
929 | return 0; | |
930 | ||
931 | return attr->mode; | |
932 | } | |
933 | ||
934 | static struct sensor_device_template *nct6683_attributes_pwm_template[] = { | |
935 | &sensor_dev_template_pwm, | |
936 | NULL | |
937 | }; | |
938 | ||
939 | static struct sensor_template_group nct6683_pwm_template_group = { | |
940 | .templates = nct6683_attributes_pwm_template, | |
941 | .is_visible = nct6683_pwm_is_visible, | |
942 | .base = 1, | |
943 | }; | |
944 | ||
945 | static ssize_t | |
946 | show_global_beep(struct device *dev, struct device_attribute *attr, char *buf) | |
947 | { | |
948 | struct nct6683_data *data = dev_get_drvdata(dev); | |
949 | int ret; | |
950 | u8 reg; | |
951 | ||
952 | mutex_lock(&data->update_lock); | |
953 | ||
954 | ret = superio_enter(data->sioreg); | |
955 | if (ret) | |
956 | goto error; | |
957 | superio_select(data->sioreg, NCT6683_LD_HWM); | |
958 | reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP); | |
959 | superio_exit(data->sioreg); | |
960 | ||
961 | mutex_unlock(&data->update_lock); | |
962 | ||
963 | return sprintf(buf, "%u\n", !!(reg & NCT6683_CR_BEEP_MASK)); | |
964 | ||
965 | error: | |
966 | mutex_unlock(&data->update_lock); | |
967 | return ret; | |
968 | } | |
969 | ||
970 | static ssize_t | |
971 | store_global_beep(struct device *dev, struct device_attribute *attr, | |
972 | const char *buf, size_t count) | |
973 | { | |
974 | struct nct6683_data *data = dev_get_drvdata(dev); | |
975 | unsigned long val; | |
976 | u8 reg; | |
977 | int ret; | |
978 | ||
979 | if (kstrtoul(buf, 10, &val) || (val != 0 && val != 1)) | |
980 | return -EINVAL; | |
981 | ||
982 | mutex_lock(&data->update_lock); | |
983 | ||
984 | ret = superio_enter(data->sioreg); | |
985 | if (ret) { | |
986 | count = ret; | |
987 | goto error; | |
988 | } | |
989 | ||
990 | superio_select(data->sioreg, NCT6683_LD_HWM); | |
991 | reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP); | |
992 | if (val) | |
993 | reg |= NCT6683_CR_BEEP_MASK; | |
994 | else | |
995 | reg &= ~NCT6683_CR_BEEP_MASK; | |
996 | superio_outb(data->sioreg, NCT6683_REG_CR_BEEP, reg); | |
997 | superio_exit(data->sioreg); | |
998 | error: | |
999 | mutex_unlock(&data->update_lock); | |
1000 | return count; | |
1001 | } | |
1002 | ||
1003 | /* Case open detection */ | |
1004 | ||
1005 | static ssize_t | |
1006 | show_caseopen(struct device *dev, struct device_attribute *attr, char *buf) | |
1007 | { | |
1008 | struct nct6683_data *data = dev_get_drvdata(dev); | |
1009 | int ret; | |
1010 | u8 reg; | |
1011 | ||
1012 | mutex_lock(&data->update_lock); | |
1013 | ||
1014 | ret = superio_enter(data->sioreg); | |
1015 | if (ret) | |
1016 | goto error; | |
1017 | superio_select(data->sioreg, NCT6683_LD_ACPI); | |
1018 | reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN); | |
1019 | superio_exit(data->sioreg); | |
1020 | ||
1021 | mutex_unlock(&data->update_lock); | |
1022 | ||
1023 | return sprintf(buf, "%u\n", !(reg & NCT6683_CR_CASEOPEN_MASK)); | |
1024 | ||
1025 | error: | |
1026 | mutex_unlock(&data->update_lock); | |
1027 | return ret; | |
1028 | } | |
1029 | ||
1030 | static ssize_t | |
1031 | clear_caseopen(struct device *dev, struct device_attribute *attr, | |
1032 | const char *buf, size_t count) | |
1033 | { | |
1034 | struct nct6683_data *data = dev_get_drvdata(dev); | |
1035 | unsigned long val; | |
1036 | u8 reg; | |
1037 | int ret; | |
1038 | ||
1039 | if (kstrtoul(buf, 10, &val) || val != 0) | |
1040 | return -EINVAL; | |
1041 | ||
1042 | mutex_lock(&data->update_lock); | |
1043 | ||
1044 | /* | |
1045 | * Use CR registers to clear caseopen status. | |
1046 | * Caseopen is activ low, clear by writing 1 into the register. | |
1047 | */ | |
1048 | ||
1049 | ret = superio_enter(data->sioreg); | |
1050 | if (ret) { | |
1051 | count = ret; | |
1052 | goto error; | |
1053 | } | |
1054 | ||
1055 | superio_select(data->sioreg, NCT6683_LD_ACPI); | |
1056 | reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN); | |
1057 | reg |= NCT6683_CR_CASEOPEN_MASK; | |
1058 | superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg); | |
1059 | reg &= ~NCT6683_CR_CASEOPEN_MASK; | |
1060 | superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg); | |
1061 | superio_exit(data->sioreg); | |
1062 | ||
1063 | data->valid = false; /* Force cache refresh */ | |
1064 | error: | |
1065 | mutex_unlock(&data->update_lock); | |
1066 | return count; | |
1067 | } | |
1068 | ||
1069 | static DEVICE_ATTR(intrusion0_alarm, S_IWUSR | S_IRUGO, show_caseopen, | |
1070 | clear_caseopen); | |
1071 | static DEVICE_ATTR(beep_enable, S_IWUSR | S_IRUGO, show_global_beep, | |
1072 | store_global_beep); | |
1073 | ||
1074 | static struct attribute *nct6683_attributes_other[] = { | |
1075 | &dev_attr_intrusion0_alarm.attr, | |
1076 | &dev_attr_beep_enable.attr, | |
1077 | NULL | |
1078 | }; | |
1079 | ||
1080 | static const struct attribute_group nct6683_group_other = { | |
1081 | .attrs = nct6683_attributes_other, | |
1082 | }; | |
1083 | ||
1084 | /* Get the monitoring functions started */ | |
1085 | static inline void nct6683_init_device(struct nct6683_data *data) | |
1086 | { | |
1087 | u8 tmp; | |
1088 | ||
1089 | /* Start hardware monitoring if needed */ | |
1090 | tmp = nct6683_read(data, NCT6683_HWM_CFG); | |
1091 | if (!(tmp & 0x80)) | |
1092 | nct6683_write(data, NCT6683_HWM_CFG, tmp | 0x80); | |
1093 | } | |
1094 | ||
1095 | /* | |
1096 | * There are a total of 24 fan inputs. Each can be configured as input | |
1097 | * or as output. A maximum of 16 inputs and 8 outputs is configurable. | |
1098 | */ | |
1099 | static void | |
1100 | nct6683_setup_fans(struct nct6683_data *data) | |
1101 | { | |
1102 | int i; | |
1103 | u8 reg; | |
1104 | ||
1105 | for (i = 0; i < NCT6683_NUM_REG_FAN; i++) { | |
1106 | reg = nct6683_read(data, NCT6683_REG_FANIN_CFG(i)); | |
1107 | if (reg & 0x80) | |
1108 | data->have_fan |= 1 << i; | |
1109 | data->fanin_cfg[i] = reg; | |
1110 | } | |
1111 | for (i = 0; i < NCT6683_NUM_REG_PWM; i++) { | |
1112 | reg = nct6683_read(data, NCT6683_REG_FANOUT_CFG(i)); | |
1113 | if (reg & 0x80) | |
1114 | data->have_pwm |= 1 << i; | |
1115 | data->fanout_cfg[i] = reg; | |
1116 | } | |
1117 | } | |
1118 | ||
1119 | /* | |
1120 | * Translation from monitoring register to temperature and voltage attributes | |
1121 | * ========================================================================== | |
1122 | * | |
1123 | * There are a total of 32 monitoring registers. Each can be assigned to either | |
1124 | * a temperature or voltage monitoring source. | |
1125 | * NCT6683_REG_MON_CFG(x) defines assignment for each monitoring source. | |
1126 | * | |
1127 | * Temperature and voltage attribute mapping is determined by walking through | |
1128 | * the NCT6683_REG_MON_CFG registers. If the assigned source is | |
1129 | * a temperature, temp_index[n] is set to the monitor register index, and | |
1130 | * temp_src[n] is set to the temperature source. If the assigned source is | |
1131 | * a voltage, the respective values are stored in in_index[] and in_src[], | |
1132 | * respectively. | |
1133 | */ | |
1134 | ||
1135 | static void nct6683_setup_sensors(struct nct6683_data *data) | |
1136 | { | |
1137 | u8 reg; | |
1138 | int i; | |
1139 | ||
1140 | data->temp_num = 0; | |
1141 | data->in_num = 0; | |
1142 | for (i = 0; i < NCT6683_NUM_REG_MON; i++) { | |
1143 | reg = nct6683_read(data, NCT6683_REG_MON_CFG(i)) & 0x7f; | |
1144 | /* Ignore invalid assignments */ | |
1145 | if (reg >= NUM_MON_LABELS) | |
1146 | continue; | |
1147 | /* Skip if disabled or reserved */ | |
1148 | if (nct6683_mon_label[reg] == NULL) | |
1149 | continue; | |
1150 | if (reg < MON_VOLTAGE_START) { | |
1151 | data->temp_index[data->temp_num] = i; | |
1152 | data->temp_src[data->temp_num] = reg; | |
1153 | data->temp_num++; | |
1154 | } else { | |
1155 | data->in_index[data->in_num] = i; | |
1156 | data->in_src[data->in_num] = reg; | |
1157 | data->in_num++; | |
1158 | } | |
1159 | } | |
1160 | } | |
1161 | ||
1162 | static int nct6683_probe(struct platform_device *pdev) | |
1163 | { | |
1164 | struct device *dev = &pdev->dev; | |
1165 | struct nct6683_sio_data *sio_data = dev->platform_data; | |
1166 | struct attribute_group *group; | |
1167 | struct nct6683_data *data; | |
1168 | struct device *hwmon_dev; | |
1169 | struct resource *res; | |
1170 | int groups = 0; | |
1171 | ||
1172 | res = platform_get_resource(pdev, IORESOURCE_IO, 0); | |
1173 | if (!devm_request_region(dev, res->start, IOREGION_LENGTH, DRVNAME)) | |
1174 | return -EBUSY; | |
1175 | ||
1176 | data = devm_kzalloc(dev, sizeof(struct nct6683_data), GFP_KERNEL); | |
1177 | if (!data) | |
1178 | return -ENOMEM; | |
1179 | ||
1180 | data->kind = sio_data->kind; | |
1181 | data->sioreg = sio_data->sioreg; | |
1182 | data->addr = res->start; | |
1183 | mutex_init(&data->update_lock); | |
1184 | platform_set_drvdata(pdev, data); | |
1185 | ||
1186 | data->customer_id = nct6683_read16(data, NCT6683_REG_CUSTOMER_ID); | |
1187 | ||
1188 | nct6683_init_device(data); | |
1189 | nct6683_setup_fans(data); | |
1190 | nct6683_setup_sensors(data); | |
1191 | ||
1192 | /* Register sysfs hooks */ | |
1193 | ||
1194 | if (data->have_pwm) { | |
1195 | group = nct6683_create_attr_group(dev, | |
1196 | &nct6683_pwm_template_group, | |
1197 | fls(data->have_pwm)); | |
1198 | if (IS_ERR(group)) | |
1199 | return PTR_ERR(group); | |
1200 | data->groups[groups++] = group; | |
1201 | } | |
1202 | ||
1203 | if (data->in_num) { | |
1204 | group = nct6683_create_attr_group(dev, | |
1205 | &nct6683_in_template_group, | |
1206 | data->in_num); | |
1207 | if (IS_ERR(group)) | |
1208 | return PTR_ERR(group); | |
1209 | data->groups[groups++] = group; | |
1210 | } | |
1211 | ||
1212 | if (data->have_fan) { | |
1213 | group = nct6683_create_attr_group(dev, | |
1214 | &nct6683_fan_template_group, | |
1215 | fls(data->have_fan)); | |
1216 | if (IS_ERR(group)) | |
1217 | return PTR_ERR(group); | |
1218 | data->groups[groups++] = group; | |
1219 | } | |
1220 | ||
1221 | if (data->temp_num) { | |
1222 | group = nct6683_create_attr_group(dev, | |
1223 | &nct6683_temp_template_group, | |
1224 | data->temp_num); | |
1225 | if (IS_ERR(group)) | |
1226 | return PTR_ERR(group); | |
1227 | data->groups[groups++] = group; | |
1228 | } | |
1229 | data->groups[groups++] = &nct6683_group_other; | |
1230 | ||
1231 | dev_info(dev, "%s EC firmware version %d.%d build %02x/%02x/%02x\n", | |
1232 | nct6683_chip_names[data->kind], | |
1233 | nct6683_read(data, NCT6683_REG_VERSION_HI), | |
1234 | nct6683_read(data, NCT6683_REG_VERSION_LO), | |
1235 | nct6683_read(data, NCT6683_REG_BUILD_MONTH), | |
1236 | nct6683_read(data, NCT6683_REG_BUILD_DAY), | |
1237 | nct6683_read(data, NCT6683_REG_BUILD_YEAR)); | |
1238 | ||
1239 | hwmon_dev = devm_hwmon_device_register_with_groups(dev, | |
1240 | nct6683_device_names[data->kind], data, data->groups); | |
1241 | return PTR_ERR_OR_ZERO(hwmon_dev); | |
1242 | } | |
1243 | ||
1244 | #ifdef CONFIG_PM | |
1245 | static int nct6683_suspend(struct device *dev) | |
1246 | { | |
1247 | struct nct6683_data *data = nct6683_update_device(dev); | |
1248 | ||
1249 | mutex_lock(&data->update_lock); | |
1250 | data->hwm_cfg = nct6683_read(data, NCT6683_HWM_CFG); | |
1251 | mutex_unlock(&data->update_lock); | |
1252 | ||
1253 | return 0; | |
1254 | } | |
1255 | ||
1256 | static int nct6683_resume(struct device *dev) | |
1257 | { | |
1258 | struct nct6683_data *data = dev_get_drvdata(dev); | |
1259 | ||
1260 | mutex_lock(&data->update_lock); | |
1261 | ||
1262 | nct6683_write(data, NCT6683_HWM_CFG, data->hwm_cfg); | |
1263 | ||
1264 | /* Force re-reading all values */ | |
1265 | data->valid = false; | |
1266 | mutex_unlock(&data->update_lock); | |
1267 | ||
1268 | return 0; | |
1269 | } | |
1270 | ||
1271 | static const struct dev_pm_ops nct6683_dev_pm_ops = { | |
1272 | .suspend = nct6683_suspend, | |
1273 | .resume = nct6683_resume, | |
1274 | .freeze = nct6683_suspend, | |
1275 | .restore = nct6683_resume, | |
1276 | }; | |
1277 | ||
1278 | #define NCT6683_DEV_PM_OPS (&nct6683_dev_pm_ops) | |
1279 | #else | |
1280 | #define NCT6683_DEV_PM_OPS NULL | |
1281 | #endif /* CONFIG_PM */ | |
1282 | ||
1283 | static struct platform_driver nct6683_driver = { | |
1284 | .driver = { | |
41082d66 GR |
1285 | .name = DRVNAME, |
1286 | .pm = NCT6683_DEV_PM_OPS, | |
1287 | }, | |
1288 | .probe = nct6683_probe, | |
1289 | }; | |
1290 | ||
1291 | static int __init nct6683_find(int sioaddr, struct nct6683_sio_data *sio_data) | |
1292 | { | |
1293 | const char *board_vendor; | |
1294 | int addr; | |
1295 | u16 val; | |
1296 | int err; | |
1297 | ||
1298 | /* | |
1299 | * Only run on Intel boards unless the 'force' module parameter is set | |
1300 | */ | |
1301 | if (!force) { | |
1302 | board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR); | |
1303 | if (!board_vendor || strcmp(board_vendor, "Intel Corporation")) | |
1304 | return -ENODEV; | |
1305 | } | |
1306 | ||
1307 | err = superio_enter(sioaddr); | |
1308 | if (err) | |
1309 | return err; | |
1310 | ||
1311 | val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) | |
1312 | | superio_inb(sioaddr, SIO_REG_DEVID + 1); | |
1313 | ||
1314 | switch (val & SIO_ID_MASK) { | |
1315 | case SIO_NCT6683_ID: | |
1316 | sio_data->kind = nct6683; | |
1317 | break; | |
1318 | default: | |
1319 | if (val != 0xffff) | |
1320 | pr_debug("unsupported chip ID: 0x%04x\n", val); | |
1321 | goto fail; | |
1322 | } | |
1323 | ||
1324 | /* We have a known chip, find the HWM I/O address */ | |
1325 | superio_select(sioaddr, NCT6683_LD_HWM); | |
1326 | val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8) | |
1327 | | superio_inb(sioaddr, SIO_REG_ADDR + 1); | |
1328 | addr = val & IOREGION_ALIGNMENT; | |
1329 | if (addr == 0) { | |
1330 | pr_err("EC base I/O port unconfigured\n"); | |
1331 | goto fail; | |
1332 | } | |
1333 | ||
1334 | /* Activate logical device if needed */ | |
1335 | val = superio_inb(sioaddr, SIO_REG_ENABLE); | |
1336 | if (!(val & 0x01)) { | |
1337 | pr_err("EC is disabled\n"); | |
1338 | goto fail; | |
1339 | } | |
1340 | ||
1341 | superio_exit(sioaddr); | |
1342 | pr_info("Found %s or compatible chip at %#x:%#x\n", | |
1343 | nct6683_chip_names[sio_data->kind], sioaddr, addr); | |
1344 | sio_data->sioreg = sioaddr; | |
1345 | ||
1346 | return addr; | |
1347 | ||
1348 | fail: | |
1349 | superio_exit(sioaddr); | |
1350 | return -ENODEV; | |
1351 | } | |
1352 | ||
1353 | /* | |
1354 | * when Super-I/O functions move to a separate file, the Super-I/O | |
1355 | * bus will manage the lifetime of the device and this module will only keep | |
1356 | * track of the nct6683 driver. But since we use platform_device_alloc(), we | |
1357 | * must keep track of the device | |
1358 | */ | |
1359 | static struct platform_device *pdev[2]; | |
1360 | ||
1361 | static int __init sensors_nct6683_init(void) | |
1362 | { | |
1363 | struct nct6683_sio_data sio_data; | |
1364 | int sioaddr[2] = { 0x2e, 0x4e }; | |
1365 | struct resource res; | |
1366 | bool found = false; | |
1367 | int address; | |
1368 | int i, err; | |
1369 | ||
1370 | err = platform_driver_register(&nct6683_driver); | |
1371 | if (err) | |
1372 | return err; | |
1373 | ||
1374 | /* | |
1375 | * initialize sio_data->kind and sio_data->sioreg. | |
1376 | * | |
1377 | * when Super-I/O functions move to a separate file, the Super-I/O | |
1378 | * driver will probe 0x2e and 0x4e and auto-detect the presence of a | |
1379 | * nct6683 hardware monitor, and call probe() | |
1380 | */ | |
1381 | for (i = 0; i < ARRAY_SIZE(pdev); i++) { | |
1382 | address = nct6683_find(sioaddr[i], &sio_data); | |
1383 | if (address <= 0) | |
1384 | continue; | |
1385 | ||
1386 | found = true; | |
1387 | ||
1388 | pdev[i] = platform_device_alloc(DRVNAME, address); | |
1389 | if (!pdev[i]) { | |
1390 | err = -ENOMEM; | |
30190c3c | 1391 | goto exit_device_unregister; |
41082d66 GR |
1392 | } |
1393 | ||
1394 | err = platform_device_add_data(pdev[i], &sio_data, | |
1395 | sizeof(struct nct6683_sio_data)); | |
1396 | if (err) | |
1397 | goto exit_device_put; | |
1398 | ||
1399 | memset(&res, 0, sizeof(res)); | |
1400 | res.name = DRVNAME; | |
1401 | res.start = address + IOREGION_OFFSET; | |
1402 | res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1; | |
1403 | res.flags = IORESOURCE_IO; | |
1404 | ||
1405 | err = acpi_check_resource_conflict(&res); | |
1406 | if (err) { | |
1407 | platform_device_put(pdev[i]); | |
1408 | pdev[i] = NULL; | |
1409 | continue; | |
1410 | } | |
1411 | ||
1412 | err = platform_device_add_resources(pdev[i], &res, 1); | |
1413 | if (err) | |
1414 | goto exit_device_put; | |
1415 | ||
1416 | /* platform_device_add calls probe() */ | |
1417 | err = platform_device_add(pdev[i]); | |
1418 | if (err) | |
1419 | goto exit_device_put; | |
1420 | } | |
1421 | if (!found) { | |
1422 | err = -ENODEV; | |
1423 | goto exit_unregister; | |
1424 | } | |
1425 | ||
1426 | return 0; | |
1427 | ||
1428 | exit_device_put: | |
30190c3c AL |
1429 | platform_device_put(pdev[i]); |
1430 | exit_device_unregister: | |
1431 | while (--i >= 0) { | |
41082d66 | 1432 | if (pdev[i]) |
30190c3c | 1433 | platform_device_unregister(pdev[i]); |
41082d66 GR |
1434 | } |
1435 | exit_unregister: | |
1436 | platform_driver_unregister(&nct6683_driver); | |
1437 | return err; | |
1438 | } | |
1439 | ||
1440 | static void __exit sensors_nct6683_exit(void) | |
1441 | { | |
1442 | int i; | |
1443 | ||
1444 | for (i = 0; i < ARRAY_SIZE(pdev); i++) { | |
1445 | if (pdev[i]) | |
1446 | platform_device_unregister(pdev[i]); | |
1447 | } | |
1448 | platform_driver_unregister(&nct6683_driver); | |
1449 | } | |
1450 | ||
1451 | MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>"); | |
1452 | MODULE_DESCRIPTION("NCT6683D driver"); | |
1453 | MODULE_LICENSE("GPL"); | |
1454 | ||
1455 | module_init(sensors_nct6683_init); | |
1456 | module_exit(sensors_nct6683_exit); |