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