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