1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * nct6775 - Platform driver for the hardware monitoring 4 * functionality of Nuvoton NCT677x Super-I/O chips 5 * 6 * Copyright (C) 2012 Guenter Roeck <linux@roeck-us.net> 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/acpi.h> 12 #include <linux/dmi.h> 13 #include <linux/hwmon-sysfs.h> 14 #include <linux/hwmon-vid.h> 15 #include <linux/init.h> 16 #include <linux/io.h> 17 #include <linux/module.h> 18 #include <linux/platform_device.h> 19 #include <linux/regmap.h> 20 #include <linux/wmi.h> 21 22 #include "nct6775.h" 23 24 enum sensor_access { access_direct, access_asuswmi }; 25 26 static const char * const nct6775_sio_names[] __initconst = { 27 "NCT6106D", 28 "NCT6116D", 29 "NCT6775F", 30 "NCT6776D/F", 31 "NCT6779D", 32 "NCT6791D", 33 "NCT6792D", 34 "NCT6793D", 35 "NCT6795D", 36 "NCT6796D", 37 "NCT6797D", 38 "NCT6798D", 39 }; 40 41 static unsigned short force_id; 42 module_param(force_id, ushort, 0); 43 MODULE_PARM_DESC(force_id, "Override the detected device ID"); 44 45 static unsigned short fan_debounce; 46 module_param(fan_debounce, ushort, 0); 47 MODULE_PARM_DESC(fan_debounce, "Enable debouncing for fan RPM signal"); 48 49 #define DRVNAME "nct6775" 50 51 #define NCT6775_PORT_CHIPID 0x58 52 53 /* 54 * ISA constants 55 */ 56 57 #define IOREGION_ALIGNMENT (~7) 58 #define IOREGION_OFFSET 5 59 #define IOREGION_LENGTH 2 60 #define ADDR_REG_OFFSET 0 61 #define DATA_REG_OFFSET 1 62 63 /* 64 * Super-I/O constants and functions 65 */ 66 67 #define NCT6775_LD_ACPI 0x0a 68 #define NCT6775_LD_HWM 0x0b 69 #define NCT6775_LD_VID 0x0d 70 #define NCT6775_LD_12 0x12 71 72 #define SIO_REG_LDSEL 0x07 /* Logical device select */ 73 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */ 74 #define SIO_REG_ENABLE 0x30 /* Logical device enable */ 75 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */ 76 77 #define SIO_NCT6106_ID 0xc450 78 #define SIO_NCT6116_ID 0xd280 79 #define SIO_NCT6775_ID 0xb470 80 #define SIO_NCT6776_ID 0xc330 81 #define SIO_NCT6779_ID 0xc560 82 #define SIO_NCT6791_ID 0xc800 83 #define SIO_NCT6792_ID 0xc910 84 #define SIO_NCT6793_ID 0xd120 85 #define SIO_NCT6795_ID 0xd350 86 #define SIO_NCT6796_ID 0xd420 87 #define SIO_NCT6797_ID 0xd450 88 #define SIO_NCT6798_ID 0xd428 89 #define SIO_ID_MASK 0xFFF8 90 91 /* 92 * Control registers 93 */ 94 #define NCT6775_REG_CR_FAN_DEBOUNCE 0xf0 95 96 struct nct6775_sio_data { 97 int sioreg; 98 int ld; 99 enum kinds kind; 100 enum sensor_access access; 101 102 /* superio_() callbacks */ 103 void (*sio_outb)(struct nct6775_sio_data *sio_data, int reg, int val); 104 int (*sio_inb)(struct nct6775_sio_data *sio_data, int reg); 105 void (*sio_select)(struct nct6775_sio_data *sio_data, int ld); 106 int (*sio_enter)(struct nct6775_sio_data *sio_data); 107 void (*sio_exit)(struct nct6775_sio_data *sio_data); 108 }; 109 110 #define ASUSWMI_MONITORING_GUID "466747A0-70EC-11DE-8A39-0800200C9A66" 111 #define ASUSWMI_METHODID_RSIO 0x5253494F 112 #define ASUSWMI_METHODID_WSIO 0x5753494F 113 #define ASUSWMI_METHODID_RHWM 0x5248574D 114 #define ASUSWMI_METHODID_WHWM 0x5748574D 115 #define ASUSWMI_UNSUPPORTED_METHOD 0xFFFFFFFE 116 117 static int nct6775_asuswmi_evaluate_method(u32 method_id, u8 bank, u8 reg, u8 val, u32 *retval) 118 { 119 #if IS_ENABLED(CONFIG_ACPI_WMI) 120 u32 args = bank | (reg << 8) | (val << 16); 121 struct acpi_buffer input = { (acpi_size) sizeof(args), &args }; 122 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; 123 acpi_status status; 124 union acpi_object *obj; 125 u32 tmp = ASUSWMI_UNSUPPORTED_METHOD; 126 127 status = wmi_evaluate_method(ASUSWMI_MONITORING_GUID, 0, 128 method_id, &input, &output); 129 130 if (ACPI_FAILURE(status)) 131 return -EIO; 132 133 obj = output.pointer; 134 if (obj && obj->type == ACPI_TYPE_INTEGER) 135 tmp = obj->integer.value; 136 137 if (retval) 138 *retval = tmp; 139 140 kfree(obj); 141 142 if (tmp == ASUSWMI_UNSUPPORTED_METHOD) 143 return -ENODEV; 144 return 0; 145 #else 146 return -EOPNOTSUPP; 147 #endif 148 } 149 150 static inline int nct6775_asuswmi_write(u8 bank, u8 reg, u8 val) 151 { 152 return nct6775_asuswmi_evaluate_method(ASUSWMI_METHODID_WHWM, bank, 153 reg, val, NULL); 154 } 155 156 static inline int nct6775_asuswmi_read(u8 bank, u8 reg, u8 *val) 157 { 158 u32 ret, tmp = 0; 159 160 ret = nct6775_asuswmi_evaluate_method(ASUSWMI_METHODID_RHWM, bank, 161 reg, 0, &tmp); 162 *val = tmp; 163 return ret; 164 } 165 166 static int superio_wmi_inb(struct nct6775_sio_data *sio_data, int reg) 167 { 168 int tmp = 0; 169 170 nct6775_asuswmi_evaluate_method(ASUSWMI_METHODID_RSIO, sio_data->ld, 171 reg, 0, &tmp); 172 return tmp; 173 } 174 175 static void superio_wmi_outb(struct nct6775_sio_data *sio_data, int reg, int val) 176 { 177 nct6775_asuswmi_evaluate_method(ASUSWMI_METHODID_WSIO, sio_data->ld, 178 reg, val, NULL); 179 } 180 181 static void superio_wmi_select(struct nct6775_sio_data *sio_data, int ld) 182 { 183 sio_data->ld = ld; 184 } 185 186 static int superio_wmi_enter(struct nct6775_sio_data *sio_data) 187 { 188 return 0; 189 } 190 191 static void superio_wmi_exit(struct nct6775_sio_data *sio_data) 192 { 193 } 194 195 static void superio_outb(struct nct6775_sio_data *sio_data, int reg, int val) 196 { 197 int ioreg = sio_data->sioreg; 198 199 outb(reg, ioreg); 200 outb(val, ioreg + 1); 201 } 202 203 static int superio_inb(struct nct6775_sio_data *sio_data, int reg) 204 { 205 int ioreg = sio_data->sioreg; 206 207 outb(reg, ioreg); 208 return inb(ioreg + 1); 209 } 210 211 static void superio_select(struct nct6775_sio_data *sio_data, int ld) 212 { 213 int ioreg = sio_data->sioreg; 214 215 outb(SIO_REG_LDSEL, ioreg); 216 outb(ld, ioreg + 1); 217 } 218 219 static int superio_enter(struct nct6775_sio_data *sio_data) 220 { 221 int ioreg = sio_data->sioreg; 222 223 /* 224 * Try to reserve <ioreg> and <ioreg + 1> for exclusive access. 225 */ 226 if (!request_muxed_region(ioreg, 2, DRVNAME)) 227 return -EBUSY; 228 229 outb(0x87, ioreg); 230 outb(0x87, ioreg); 231 232 return 0; 233 } 234 235 static void superio_exit(struct nct6775_sio_data *sio_data) 236 { 237 int ioreg = sio_data->sioreg; 238 239 outb(0xaa, ioreg); 240 outb(0x02, ioreg); 241 outb(0x02, ioreg + 1); 242 release_region(ioreg, 2); 243 } 244 245 static inline void nct6775_wmi_set_bank(struct nct6775_data *data, u16 reg) 246 { 247 u8 bank = reg >> 8; 248 249 data->bank = bank; 250 } 251 252 static int nct6775_wmi_reg_read(void *ctx, unsigned int reg, unsigned int *val) 253 { 254 struct nct6775_data *data = ctx; 255 int err, word_sized = nct6775_reg_is_word_sized(data, reg); 256 u8 tmp = 0; 257 u16 res; 258 259 nct6775_wmi_set_bank(data, reg); 260 261 err = nct6775_asuswmi_read(data->bank, reg & 0xff, &tmp); 262 if (err) 263 return err; 264 265 res = tmp; 266 if (word_sized) { 267 err = nct6775_asuswmi_read(data->bank, (reg & 0xff) + 1, &tmp); 268 if (err) 269 return err; 270 271 res = (res << 8) + tmp; 272 } 273 *val = res; 274 return 0; 275 } 276 277 static int nct6775_wmi_reg_write(void *ctx, unsigned int reg, unsigned int value) 278 { 279 struct nct6775_data *data = ctx; 280 int res, word_sized = nct6775_reg_is_word_sized(data, reg); 281 282 nct6775_wmi_set_bank(data, reg); 283 284 if (word_sized) { 285 res = nct6775_asuswmi_write(data->bank, reg & 0xff, value >> 8); 286 if (res) 287 return res; 288 289 res = nct6775_asuswmi_write(data->bank, (reg & 0xff) + 1, value); 290 } else { 291 res = nct6775_asuswmi_write(data->bank, reg & 0xff, value); 292 } 293 294 return res; 295 } 296 297 /* 298 * On older chips, only registers 0x50-0x5f are banked. 299 * On more recent chips, all registers are banked. 300 * Assume that is the case and set the bank number for each access. 301 * Cache the bank number so it only needs to be set if it changes. 302 */ 303 static inline void nct6775_set_bank(struct nct6775_data *data, u16 reg) 304 { 305 u8 bank = reg >> 8; 306 307 if (data->bank != bank) { 308 outb_p(NCT6775_REG_BANK, data->addr + ADDR_REG_OFFSET); 309 outb_p(bank, data->addr + DATA_REG_OFFSET); 310 data->bank = bank; 311 } 312 } 313 314 static int nct6775_reg_read(void *ctx, unsigned int reg, unsigned int *val) 315 { 316 struct nct6775_data *data = ctx; 317 int word_sized = nct6775_reg_is_word_sized(data, reg); 318 319 nct6775_set_bank(data, reg); 320 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET); 321 *val = inb_p(data->addr + DATA_REG_OFFSET); 322 if (word_sized) { 323 outb_p((reg & 0xff) + 1, 324 data->addr + ADDR_REG_OFFSET); 325 *val = (*val << 8) + inb_p(data->addr + DATA_REG_OFFSET); 326 } 327 return 0; 328 } 329 330 static int nct6775_reg_write(void *ctx, unsigned int reg, unsigned int value) 331 { 332 struct nct6775_data *data = ctx; 333 int word_sized = nct6775_reg_is_word_sized(data, reg); 334 335 nct6775_set_bank(data, reg); 336 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET); 337 if (word_sized) { 338 outb_p(value >> 8, data->addr + DATA_REG_OFFSET); 339 outb_p((reg & 0xff) + 1, 340 data->addr + ADDR_REG_OFFSET); 341 } 342 outb_p(value & 0xff, data->addr + DATA_REG_OFFSET); 343 return 0; 344 } 345 346 static void nct6791_enable_io_mapping(struct nct6775_sio_data *sio_data) 347 { 348 int val; 349 350 val = sio_data->sio_inb(sio_data, NCT6791_REG_HM_IO_SPACE_LOCK_ENABLE); 351 if (val & 0x10) { 352 pr_info("Enabling hardware monitor logical device mappings.\n"); 353 sio_data->sio_outb(sio_data, NCT6791_REG_HM_IO_SPACE_LOCK_ENABLE, 354 val & ~0x10); 355 } 356 } 357 358 static int __maybe_unused nct6775_suspend(struct device *dev) 359 { 360 int err; 361 u16 tmp; 362 struct nct6775_data *data = dev_get_drvdata(dev); 363 364 if (IS_ERR(data)) 365 return PTR_ERR(data); 366 367 mutex_lock(&data->update_lock); 368 err = nct6775_read_value(data, data->REG_VBAT, &tmp); 369 if (err) 370 goto out; 371 data->vbat = tmp; 372 if (data->kind == nct6775) { 373 err = nct6775_read_value(data, NCT6775_REG_FANDIV1, &tmp); 374 if (err) 375 goto out; 376 data->fandiv1 = tmp; 377 378 err = nct6775_read_value(data, NCT6775_REG_FANDIV2, &tmp); 379 if (err) 380 goto out; 381 data->fandiv2 = tmp; 382 } 383 out: 384 mutex_unlock(&data->update_lock); 385 386 return err; 387 } 388 389 static int __maybe_unused nct6775_resume(struct device *dev) 390 { 391 struct nct6775_data *data = dev_get_drvdata(dev); 392 struct nct6775_sio_data *sio_data = dev_get_platdata(dev); 393 int i, j, err = 0; 394 u8 reg; 395 396 mutex_lock(&data->update_lock); 397 data->bank = 0xff; /* Force initial bank selection */ 398 399 err = sio_data->sio_enter(sio_data); 400 if (err) 401 goto abort; 402 403 sio_data->sio_select(sio_data, NCT6775_LD_HWM); 404 reg = sio_data->sio_inb(sio_data, SIO_REG_ENABLE); 405 if (reg != data->sio_reg_enable) 406 sio_data->sio_outb(sio_data, SIO_REG_ENABLE, data->sio_reg_enable); 407 408 if (data->kind == nct6791 || data->kind == nct6792 || 409 data->kind == nct6793 || data->kind == nct6795 || 410 data->kind == nct6796 || data->kind == nct6797 || 411 data->kind == nct6798) 412 nct6791_enable_io_mapping(sio_data); 413 414 sio_data->sio_exit(sio_data); 415 416 /* Restore limits */ 417 for (i = 0; i < data->in_num; i++) { 418 if (!(data->have_in & BIT(i))) 419 continue; 420 421 err = nct6775_write_value(data, data->REG_IN_MINMAX[0][i], data->in[i][1]); 422 if (err) 423 goto abort; 424 err = nct6775_write_value(data, data->REG_IN_MINMAX[1][i], data->in[i][2]); 425 if (err) 426 goto abort; 427 } 428 429 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) { 430 if (!(data->has_fan_min & BIT(i))) 431 continue; 432 433 err = nct6775_write_value(data, data->REG_FAN_MIN[i], data->fan_min[i]); 434 if (err) 435 goto abort; 436 } 437 438 for (i = 0; i < NUM_TEMP; i++) { 439 if (!(data->have_temp & BIT(i))) 440 continue; 441 442 for (j = 1; j < ARRAY_SIZE(data->reg_temp); j++) 443 if (data->reg_temp[j][i]) { 444 err = nct6775_write_temp(data, data->reg_temp[j][i], 445 data->temp[j][i]); 446 if (err) 447 goto abort; 448 } 449 } 450 451 /* Restore other settings */ 452 err = nct6775_write_value(data, data->REG_VBAT, data->vbat); 453 if (err) 454 goto abort; 455 if (data->kind == nct6775) { 456 err = nct6775_write_value(data, NCT6775_REG_FANDIV1, data->fandiv1); 457 if (err) 458 goto abort; 459 err = nct6775_write_value(data, NCT6775_REG_FANDIV2, data->fandiv2); 460 } 461 462 abort: 463 /* Force re-reading all values */ 464 data->valid = false; 465 mutex_unlock(&data->update_lock); 466 467 return err; 468 } 469 470 static SIMPLE_DEV_PM_OPS(nct6775_dev_pm_ops, nct6775_suspend, nct6775_resume); 471 472 static void 473 nct6775_check_fan_inputs(struct nct6775_data *data, struct nct6775_sio_data *sio_data) 474 { 475 bool fan3pin = false, fan4pin = false, fan4min = false; 476 bool fan5pin = false, fan6pin = false, fan7pin = false; 477 bool pwm3pin = false, pwm4pin = false, pwm5pin = false; 478 bool pwm6pin = false, pwm7pin = false; 479 480 /* Store SIO_REG_ENABLE for use during resume */ 481 sio_data->sio_select(sio_data, NCT6775_LD_HWM); 482 data->sio_reg_enable = sio_data->sio_inb(sio_data, SIO_REG_ENABLE); 483 484 /* fan4 and fan5 share some pins with the GPIO and serial flash */ 485 if (data->kind == nct6775) { 486 int cr2c = sio_data->sio_inb(sio_data, 0x2c); 487 488 fan3pin = cr2c & BIT(6); 489 pwm3pin = cr2c & BIT(7); 490 491 /* On NCT6775, fan4 shares pins with the fdc interface */ 492 fan4pin = !(sio_data->sio_inb(sio_data, 0x2A) & 0x80); 493 } else if (data->kind == nct6776) { 494 bool gpok = sio_data->sio_inb(sio_data, 0x27) & 0x80; 495 const char *board_vendor, *board_name; 496 497 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR); 498 board_name = dmi_get_system_info(DMI_BOARD_NAME); 499 500 if (board_name && board_vendor && 501 !strcmp(board_vendor, "ASRock")) { 502 /* 503 * Auxiliary fan monitoring is not enabled on ASRock 504 * Z77 Pro4-M if booted in UEFI Ultra-FastBoot mode. 505 * Observed with BIOS version 2.00. 506 */ 507 if (!strcmp(board_name, "Z77 Pro4-M")) { 508 if ((data->sio_reg_enable & 0xe0) != 0xe0) { 509 data->sio_reg_enable |= 0xe0; 510 sio_data->sio_outb(sio_data, SIO_REG_ENABLE, 511 data->sio_reg_enable); 512 } 513 } 514 } 515 516 if (data->sio_reg_enable & 0x80) 517 fan3pin = gpok; 518 else 519 fan3pin = !(sio_data->sio_inb(sio_data, 0x24) & 0x40); 520 521 if (data->sio_reg_enable & 0x40) 522 fan4pin = gpok; 523 else 524 fan4pin = sio_data->sio_inb(sio_data, 0x1C) & 0x01; 525 526 if (data->sio_reg_enable & 0x20) 527 fan5pin = gpok; 528 else 529 fan5pin = sio_data->sio_inb(sio_data, 0x1C) & 0x02; 530 531 fan4min = fan4pin; 532 pwm3pin = fan3pin; 533 } else if (data->kind == nct6106) { 534 int cr24 = sio_data->sio_inb(sio_data, 0x24); 535 536 fan3pin = !(cr24 & 0x80); 537 pwm3pin = cr24 & 0x08; 538 } else if (data->kind == nct6116) { 539 int cr1a = sio_data->sio_inb(sio_data, 0x1a); 540 int cr1b = sio_data->sio_inb(sio_data, 0x1b); 541 int cr24 = sio_data->sio_inb(sio_data, 0x24); 542 int cr2a = sio_data->sio_inb(sio_data, 0x2a); 543 int cr2b = sio_data->sio_inb(sio_data, 0x2b); 544 int cr2f = sio_data->sio_inb(sio_data, 0x2f); 545 546 fan3pin = !(cr2b & 0x10); 547 fan4pin = (cr2b & 0x80) || // pin 1(2) 548 (!(cr2f & 0x10) && (cr1a & 0x04)); // pin 65(66) 549 fan5pin = (cr2b & 0x80) || // pin 126(127) 550 (!(cr1b & 0x03) && (cr2a & 0x02)); // pin 94(96) 551 552 pwm3pin = fan3pin && (cr24 & 0x08); 553 pwm4pin = fan4pin; 554 pwm5pin = fan5pin; 555 } else { 556 /* 557 * NCT6779D, NCT6791D, NCT6792D, NCT6793D, NCT6795D, NCT6796D, 558 * NCT6797D, NCT6798D 559 */ 560 int cr1a = sio_data->sio_inb(sio_data, 0x1a); 561 int cr1b = sio_data->sio_inb(sio_data, 0x1b); 562 int cr1c = sio_data->sio_inb(sio_data, 0x1c); 563 int cr1d = sio_data->sio_inb(sio_data, 0x1d); 564 int cr2a = sio_data->sio_inb(sio_data, 0x2a); 565 int cr2b = sio_data->sio_inb(sio_data, 0x2b); 566 int cr2d = sio_data->sio_inb(sio_data, 0x2d); 567 int cr2f = sio_data->sio_inb(sio_data, 0x2f); 568 bool dsw_en = cr2f & BIT(3); 569 bool ddr4_en = cr2f & BIT(4); 570 int cre0; 571 int creb; 572 int cred; 573 574 sio_data->sio_select(sio_data, NCT6775_LD_12); 575 cre0 = sio_data->sio_inb(sio_data, 0xe0); 576 creb = sio_data->sio_inb(sio_data, 0xeb); 577 cred = sio_data->sio_inb(sio_data, 0xed); 578 579 fan3pin = !(cr1c & BIT(5)); 580 fan4pin = !(cr1c & BIT(6)); 581 fan5pin = !(cr1c & BIT(7)); 582 583 pwm3pin = !(cr1c & BIT(0)); 584 pwm4pin = !(cr1c & BIT(1)); 585 pwm5pin = !(cr1c & BIT(2)); 586 587 switch (data->kind) { 588 case nct6791: 589 fan6pin = cr2d & BIT(1); 590 pwm6pin = cr2d & BIT(0); 591 break; 592 case nct6792: 593 fan6pin = !dsw_en && (cr2d & BIT(1)); 594 pwm6pin = !dsw_en && (cr2d & BIT(0)); 595 break; 596 case nct6793: 597 fan5pin |= cr1b & BIT(5); 598 fan5pin |= creb & BIT(5); 599 600 fan6pin = !dsw_en && (cr2d & BIT(1)); 601 fan6pin |= creb & BIT(3); 602 603 pwm5pin |= cr2d & BIT(7); 604 pwm5pin |= (creb & BIT(4)) && !(cr2a & BIT(0)); 605 606 pwm6pin = !dsw_en && (cr2d & BIT(0)); 607 pwm6pin |= creb & BIT(2); 608 break; 609 case nct6795: 610 fan5pin |= cr1b & BIT(5); 611 fan5pin |= creb & BIT(5); 612 613 fan6pin = (cr2a & BIT(4)) && 614 (!dsw_en || (cred & BIT(4))); 615 fan6pin |= creb & BIT(3); 616 617 pwm5pin |= cr2d & BIT(7); 618 pwm5pin |= (creb & BIT(4)) && !(cr2a & BIT(0)); 619 620 pwm6pin = (cr2a & BIT(3)) && (cred & BIT(2)); 621 pwm6pin |= creb & BIT(2); 622 break; 623 case nct6796: 624 fan5pin |= cr1b & BIT(5); 625 fan5pin |= (cre0 & BIT(3)) && !(cr1b & BIT(0)); 626 fan5pin |= creb & BIT(5); 627 628 fan6pin = (cr2a & BIT(4)) && 629 (!dsw_en || (cred & BIT(4))); 630 fan6pin |= creb & BIT(3); 631 632 fan7pin = !(cr2b & BIT(2)); 633 634 pwm5pin |= cr2d & BIT(7); 635 pwm5pin |= (cre0 & BIT(4)) && !(cr1b & BIT(0)); 636 pwm5pin |= (creb & BIT(4)) && !(cr2a & BIT(0)); 637 638 pwm6pin = (cr2a & BIT(3)) && (cred & BIT(2)); 639 pwm6pin |= creb & BIT(2); 640 641 pwm7pin = !(cr1d & (BIT(2) | BIT(3))); 642 break; 643 case nct6797: 644 fan5pin |= !ddr4_en && (cr1b & BIT(5)); 645 fan5pin |= creb & BIT(5); 646 647 fan6pin = cr2a & BIT(4); 648 fan6pin |= creb & BIT(3); 649 650 fan7pin = cr1a & BIT(1); 651 652 pwm5pin |= (creb & BIT(4)) && !(cr2a & BIT(0)); 653 pwm5pin |= !ddr4_en && (cr2d & BIT(7)); 654 655 pwm6pin = creb & BIT(2); 656 pwm6pin |= cred & BIT(2); 657 658 pwm7pin = cr1d & BIT(4); 659 break; 660 case nct6798: 661 fan6pin = !(cr1b & BIT(0)) && (cre0 & BIT(3)); 662 fan6pin |= cr2a & BIT(4); 663 fan6pin |= creb & BIT(5); 664 665 fan7pin = cr1b & BIT(5); 666 fan7pin |= !(cr2b & BIT(2)); 667 fan7pin |= creb & BIT(3); 668 669 pwm6pin = !(cr1b & BIT(0)) && (cre0 & BIT(4)); 670 pwm6pin |= !(cred & BIT(2)) && (cr2a & BIT(3)); 671 pwm6pin |= (creb & BIT(4)) && !(cr2a & BIT(0)); 672 673 pwm7pin = !(cr1d & (BIT(2) | BIT(3))); 674 pwm7pin |= cr2d & BIT(7); 675 pwm7pin |= creb & BIT(2); 676 break; 677 default: /* NCT6779D */ 678 break; 679 } 680 681 fan4min = fan4pin; 682 } 683 684 /* fan 1 and 2 (0x03) are always present */ 685 data->has_fan = 0x03 | (fan3pin << 2) | (fan4pin << 3) | 686 (fan5pin << 4) | (fan6pin << 5) | (fan7pin << 6); 687 data->has_fan_min = 0x03 | (fan3pin << 2) | (fan4min << 3) | 688 (fan5pin << 4) | (fan6pin << 5) | (fan7pin << 6); 689 data->has_pwm = 0x03 | (pwm3pin << 2) | (pwm4pin << 3) | 690 (pwm5pin << 4) | (pwm6pin << 5) | (pwm7pin << 6); 691 } 692 693 static ssize_t 694 cpu0_vid_show(struct device *dev, struct device_attribute *attr, char *buf) 695 { 696 struct nct6775_data *data = dev_get_drvdata(dev); 697 698 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm)); 699 } 700 701 static DEVICE_ATTR_RO(cpu0_vid); 702 703 /* Case open detection */ 704 705 static const u8 NCT6775_REG_CR_CASEOPEN_CLR[] = { 0xe6, 0xee }; 706 static const u8 NCT6775_CR_CASEOPEN_CLR_MASK[] = { 0x20, 0x01 }; 707 708 static ssize_t 709 clear_caseopen(struct device *dev, struct device_attribute *attr, 710 const char *buf, size_t count) 711 { 712 struct nct6775_data *data = dev_get_drvdata(dev); 713 struct nct6775_sio_data *sio_data = data->driver_data; 714 int nr = to_sensor_dev_attr(attr)->index - INTRUSION_ALARM_BASE; 715 unsigned long val; 716 u8 reg; 717 int ret; 718 719 if (kstrtoul(buf, 10, &val) || val != 0) 720 return -EINVAL; 721 722 mutex_lock(&data->update_lock); 723 724 /* 725 * Use CR registers to clear caseopen status. 726 * The CR registers are the same for all chips, and not all chips 727 * support clearing the caseopen status through "regular" registers. 728 */ 729 ret = sio_data->sio_enter(sio_data); 730 if (ret) { 731 count = ret; 732 goto error; 733 } 734 735 sio_data->sio_select(sio_data, NCT6775_LD_ACPI); 736 reg = sio_data->sio_inb(sio_data, NCT6775_REG_CR_CASEOPEN_CLR[nr]); 737 reg |= NCT6775_CR_CASEOPEN_CLR_MASK[nr]; 738 sio_data->sio_outb(sio_data, NCT6775_REG_CR_CASEOPEN_CLR[nr], reg); 739 reg &= ~NCT6775_CR_CASEOPEN_CLR_MASK[nr]; 740 sio_data->sio_outb(sio_data, NCT6775_REG_CR_CASEOPEN_CLR[nr], reg); 741 sio_data->sio_exit(sio_data); 742 743 data->valid = false; /* Force cache refresh */ 744 error: 745 mutex_unlock(&data->update_lock); 746 return count; 747 } 748 749 static SENSOR_DEVICE_ATTR(intrusion0_alarm, 0644, nct6775_show_alarm, 750 clear_caseopen, INTRUSION_ALARM_BASE); 751 static SENSOR_DEVICE_ATTR(intrusion1_alarm, 0644, nct6775_show_alarm, 752 clear_caseopen, INTRUSION_ALARM_BASE + 1); 753 static SENSOR_DEVICE_ATTR(intrusion0_beep, 0644, nct6775_show_beep, 754 nct6775_store_beep, INTRUSION_ALARM_BASE); 755 static SENSOR_DEVICE_ATTR(intrusion1_beep, 0644, nct6775_show_beep, 756 nct6775_store_beep, INTRUSION_ALARM_BASE + 1); 757 static SENSOR_DEVICE_ATTR(beep_enable, 0644, nct6775_show_beep, 758 nct6775_store_beep, BEEP_ENABLE_BASE); 759 760 static umode_t nct6775_other_is_visible(struct kobject *kobj, 761 struct attribute *attr, int index) 762 { 763 struct device *dev = kobj_to_dev(kobj); 764 struct nct6775_data *data = dev_get_drvdata(dev); 765 766 if (index == 0 && !data->have_vid) 767 return 0; 768 769 if (index == 1 || index == 2) { 770 if (data->ALARM_BITS[INTRUSION_ALARM_BASE + index - 1] < 0) 771 return 0; 772 } 773 774 if (index == 3 || index == 4) { 775 if (data->BEEP_BITS[INTRUSION_ALARM_BASE + index - 3] < 0) 776 return 0; 777 } 778 779 return nct6775_attr_mode(data, attr); 780 } 781 782 /* 783 * nct6775_other_is_visible uses the index into the following array 784 * to determine if attributes should be created or not. 785 * Any change in order or content must be matched. 786 */ 787 static struct attribute *nct6775_attributes_other[] = { 788 &dev_attr_cpu0_vid.attr, /* 0 */ 789 &sensor_dev_attr_intrusion0_alarm.dev_attr.attr, /* 1 */ 790 &sensor_dev_attr_intrusion1_alarm.dev_attr.attr, /* 2 */ 791 &sensor_dev_attr_intrusion0_beep.dev_attr.attr, /* 3 */ 792 &sensor_dev_attr_intrusion1_beep.dev_attr.attr, /* 4 */ 793 &sensor_dev_attr_beep_enable.dev_attr.attr, /* 5 */ 794 795 NULL 796 }; 797 798 static const struct attribute_group nct6775_group_other = { 799 .attrs = nct6775_attributes_other, 800 .is_visible = nct6775_other_is_visible, 801 }; 802 803 static int nct6775_platform_probe_init(struct nct6775_data *data) 804 { 805 int err; 806 u8 cr2a; 807 struct nct6775_sio_data *sio_data = data->driver_data; 808 809 err = sio_data->sio_enter(sio_data); 810 if (err) 811 return err; 812 813 cr2a = sio_data->sio_inb(sio_data, 0x2a); 814 switch (data->kind) { 815 case nct6775: 816 data->have_vid = (cr2a & 0x40); 817 break; 818 case nct6776: 819 data->have_vid = (cr2a & 0x60) == 0x40; 820 break; 821 case nct6106: 822 case nct6116: 823 case nct6779: 824 case nct6791: 825 case nct6792: 826 case nct6793: 827 case nct6795: 828 case nct6796: 829 case nct6797: 830 case nct6798: 831 break; 832 } 833 834 /* 835 * Read VID value 836 * We can get the VID input values directly at logical device D 0xe3. 837 */ 838 if (data->have_vid) { 839 sio_data->sio_select(sio_data, NCT6775_LD_VID); 840 data->vid = sio_data->sio_inb(sio_data, 0xe3); 841 data->vrm = vid_which_vrm(); 842 } 843 844 if (fan_debounce) { 845 u8 tmp; 846 847 sio_data->sio_select(sio_data, NCT6775_LD_HWM); 848 tmp = sio_data->sio_inb(sio_data, 849 NCT6775_REG_CR_FAN_DEBOUNCE); 850 switch (data->kind) { 851 case nct6106: 852 case nct6116: 853 tmp |= 0xe0; 854 break; 855 case nct6775: 856 tmp |= 0x1e; 857 break; 858 case nct6776: 859 case nct6779: 860 tmp |= 0x3e; 861 break; 862 case nct6791: 863 case nct6792: 864 case nct6793: 865 case nct6795: 866 case nct6796: 867 case nct6797: 868 case nct6798: 869 tmp |= 0x7e; 870 break; 871 } 872 sio_data->sio_outb(sio_data, NCT6775_REG_CR_FAN_DEBOUNCE, 873 tmp); 874 pr_info("Enabled fan debounce for chip %s\n", data->name); 875 } 876 877 nct6775_check_fan_inputs(data, sio_data); 878 879 sio_data->sio_exit(sio_data); 880 881 return nct6775_add_attr_group(data, &nct6775_group_other); 882 } 883 884 static const struct regmap_config nct6775_regmap_config = { 885 .reg_bits = 16, 886 .val_bits = 16, 887 .reg_read = nct6775_reg_read, 888 .reg_write = nct6775_reg_write, 889 }; 890 891 static const struct regmap_config nct6775_wmi_regmap_config = { 892 .reg_bits = 16, 893 .val_bits = 16, 894 .reg_read = nct6775_wmi_reg_read, 895 .reg_write = nct6775_wmi_reg_write, 896 }; 897 898 static int nct6775_platform_probe(struct platform_device *pdev) 899 { 900 struct device *dev = &pdev->dev; 901 struct nct6775_sio_data *sio_data = dev_get_platdata(dev); 902 struct nct6775_data *data; 903 struct resource *res; 904 const struct regmap_config *regmapcfg; 905 906 if (sio_data->access == access_direct) { 907 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 908 if (!devm_request_region(&pdev->dev, res->start, IOREGION_LENGTH, DRVNAME)) 909 return -EBUSY; 910 } 911 912 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 913 if (!data) 914 return -ENOMEM; 915 916 data->kind = sio_data->kind; 917 data->sioreg = sio_data->sioreg; 918 919 if (sio_data->access == access_direct) { 920 data->addr = res->start; 921 regmapcfg = &nct6775_regmap_config; 922 } else { 923 regmapcfg = &nct6775_wmi_regmap_config; 924 } 925 926 platform_set_drvdata(pdev, data); 927 928 data->driver_data = sio_data; 929 data->driver_init = nct6775_platform_probe_init; 930 931 return nct6775_probe(&pdev->dev, data, regmapcfg); 932 } 933 934 static struct platform_driver nct6775_driver = { 935 .driver = { 936 .name = DRVNAME, 937 .pm = &nct6775_dev_pm_ops, 938 }, 939 .probe = nct6775_platform_probe, 940 }; 941 942 /* nct6775_find() looks for a '627 in the Super-I/O config space */ 943 static int __init nct6775_find(int sioaddr, struct nct6775_sio_data *sio_data) 944 { 945 u16 val; 946 int err; 947 int addr; 948 949 sio_data->access = access_direct; 950 sio_data->sioreg = sioaddr; 951 952 err = sio_data->sio_enter(sio_data); 953 if (err) 954 return err; 955 956 val = (sio_data->sio_inb(sio_data, SIO_REG_DEVID) << 8) | 957 sio_data->sio_inb(sio_data, SIO_REG_DEVID + 1); 958 if (force_id && val != 0xffff) 959 val = force_id; 960 961 switch (val & SIO_ID_MASK) { 962 case SIO_NCT6106_ID: 963 sio_data->kind = nct6106; 964 break; 965 case SIO_NCT6116_ID: 966 sio_data->kind = nct6116; 967 break; 968 case SIO_NCT6775_ID: 969 sio_data->kind = nct6775; 970 break; 971 case SIO_NCT6776_ID: 972 sio_data->kind = nct6776; 973 break; 974 case SIO_NCT6779_ID: 975 sio_data->kind = nct6779; 976 break; 977 case SIO_NCT6791_ID: 978 sio_data->kind = nct6791; 979 break; 980 case SIO_NCT6792_ID: 981 sio_data->kind = nct6792; 982 break; 983 case SIO_NCT6793_ID: 984 sio_data->kind = nct6793; 985 break; 986 case SIO_NCT6795_ID: 987 sio_data->kind = nct6795; 988 break; 989 case SIO_NCT6796_ID: 990 sio_data->kind = nct6796; 991 break; 992 case SIO_NCT6797_ID: 993 sio_data->kind = nct6797; 994 break; 995 case SIO_NCT6798_ID: 996 sio_data->kind = nct6798; 997 break; 998 default: 999 if (val != 0xffff) 1000 pr_debug("unsupported chip ID: 0x%04x\n", val); 1001 sio_data->sio_exit(sio_data); 1002 return -ENODEV; 1003 } 1004 1005 /* We have a known chip, find the HWM I/O address */ 1006 sio_data->sio_select(sio_data, NCT6775_LD_HWM); 1007 val = (sio_data->sio_inb(sio_data, SIO_REG_ADDR) << 8) 1008 | sio_data->sio_inb(sio_data, SIO_REG_ADDR + 1); 1009 addr = val & IOREGION_ALIGNMENT; 1010 if (addr == 0) { 1011 pr_err("Refusing to enable a Super-I/O device with a base I/O port 0\n"); 1012 sio_data->sio_exit(sio_data); 1013 return -ENODEV; 1014 } 1015 1016 /* Activate logical device if needed */ 1017 val = sio_data->sio_inb(sio_data, SIO_REG_ENABLE); 1018 if (!(val & 0x01)) { 1019 pr_warn("Forcibly enabling Super-I/O. Sensor is probably unusable.\n"); 1020 sio_data->sio_outb(sio_data, SIO_REG_ENABLE, val | 0x01); 1021 } 1022 1023 if (sio_data->kind == nct6791 || sio_data->kind == nct6792 || 1024 sio_data->kind == nct6793 || sio_data->kind == nct6795 || 1025 sio_data->kind == nct6796 || sio_data->kind == nct6797 || 1026 sio_data->kind == nct6798) 1027 nct6791_enable_io_mapping(sio_data); 1028 1029 sio_data->sio_exit(sio_data); 1030 pr_info("Found %s or compatible chip at %#x:%#x\n", 1031 nct6775_sio_names[sio_data->kind], sioaddr, addr); 1032 1033 return addr; 1034 } 1035 1036 /* 1037 * when Super-I/O functions move to a separate file, the Super-I/O 1038 * bus will manage the lifetime of the device and this module will only keep 1039 * track of the nct6775 driver. But since we use platform_device_alloc(), we 1040 * must keep track of the device 1041 */ 1042 static struct platform_device *pdev[2]; 1043 1044 static const char * const asus_wmi_boards[] = { 1045 "PRO H410T", 1046 "ProArt X570-CREATOR WIFI", 1047 "Pro B550M-C", 1048 "Pro WS X570-ACE", 1049 "PRIME B360-PLUS", 1050 "PRIME B460-PLUS", 1051 "PRIME B550-PLUS", 1052 "PRIME B550M-A", 1053 "PRIME B550M-A (WI-FI)", 1054 "PRIME H410M-R", 1055 "PRIME X570-P", 1056 "PRIME X570-PRO", 1057 "ROG CROSSHAIR VIII DARK HERO", 1058 "ROG CROSSHAIR VIII FORMULA", 1059 "ROG CROSSHAIR VIII HERO", 1060 "ROG CROSSHAIR VIII IMPACT", 1061 "ROG STRIX B550-A GAMING", 1062 "ROG STRIX B550-E GAMING", 1063 "ROG STRIX B550-F GAMING", 1064 "ROG STRIX B550-F GAMING (WI-FI)", 1065 "ROG STRIX B550-F GAMING WIFI II", 1066 "ROG STRIX B550-I GAMING", 1067 "ROG STRIX B550-XE GAMING (WI-FI)", 1068 "ROG STRIX X570-E GAMING", 1069 "ROG STRIX X570-E GAMING WIFI II", 1070 "ROG STRIX X570-F GAMING", 1071 "ROG STRIX X570-I GAMING", 1072 "ROG STRIX Z390-E GAMING", 1073 "ROG STRIX Z390-F GAMING", 1074 "ROG STRIX Z390-H GAMING", 1075 "ROG STRIX Z390-I GAMING", 1076 "ROG STRIX Z490-A GAMING", 1077 "ROG STRIX Z490-E GAMING", 1078 "ROG STRIX Z490-F GAMING", 1079 "ROG STRIX Z490-G GAMING", 1080 "ROG STRIX Z490-G GAMING (WI-FI)", 1081 "ROG STRIX Z490-H GAMING", 1082 "ROG STRIX Z490-I GAMING", 1083 "TUF GAMING B550M-PLUS", 1084 "TUF GAMING B550M-PLUS (WI-FI)", 1085 "TUF GAMING B550-PLUS", 1086 "TUF GAMING B550-PRO", 1087 "TUF GAMING X570-PLUS", 1088 "TUF GAMING X570-PLUS (WI-FI)", 1089 "TUF GAMING X570-PRO (WI-FI)", 1090 "TUF GAMING Z490-PLUS", 1091 "TUF GAMING Z490-PLUS (WI-FI)", 1092 }; 1093 1094 static int __init sensors_nct6775_platform_init(void) 1095 { 1096 int i, err; 1097 bool found = false; 1098 int address; 1099 struct resource res; 1100 struct nct6775_sio_data sio_data; 1101 int sioaddr[2] = { 0x2e, 0x4e }; 1102 enum sensor_access access = access_direct; 1103 const char *board_vendor, *board_name; 1104 u8 tmp; 1105 1106 err = platform_driver_register(&nct6775_driver); 1107 if (err) 1108 return err; 1109 1110 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR); 1111 board_name = dmi_get_system_info(DMI_BOARD_NAME); 1112 1113 if (board_name && board_vendor && 1114 !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) { 1115 err = match_string(asus_wmi_boards, ARRAY_SIZE(asus_wmi_boards), 1116 board_name); 1117 if (err >= 0) { 1118 /* if reading chip id via WMI succeeds, use WMI */ 1119 if (!nct6775_asuswmi_read(0, NCT6775_PORT_CHIPID, &tmp) && tmp) { 1120 pr_info("Using Asus WMI to access %#x chip.\n", tmp); 1121 access = access_asuswmi; 1122 } else { 1123 pr_err("Can't read ChipID by Asus WMI.\n"); 1124 } 1125 } 1126 } 1127 1128 /* 1129 * initialize sio_data->kind and sio_data->sioreg. 1130 * 1131 * when Super-I/O functions move to a separate file, the Super-I/O 1132 * driver will probe 0x2e and 0x4e and auto-detect the presence of a 1133 * nct6775 hardware monitor, and call probe() 1134 */ 1135 for (i = 0; i < ARRAY_SIZE(pdev); i++) { 1136 sio_data.sio_outb = superio_outb; 1137 sio_data.sio_inb = superio_inb; 1138 sio_data.sio_select = superio_select; 1139 sio_data.sio_enter = superio_enter; 1140 sio_data.sio_exit = superio_exit; 1141 1142 address = nct6775_find(sioaddr[i], &sio_data); 1143 if (address <= 0) 1144 continue; 1145 1146 found = true; 1147 1148 sio_data.access = access; 1149 1150 if (access == access_asuswmi) { 1151 sio_data.sio_outb = superio_wmi_outb; 1152 sio_data.sio_inb = superio_wmi_inb; 1153 sio_data.sio_select = superio_wmi_select; 1154 sio_data.sio_enter = superio_wmi_enter; 1155 sio_data.sio_exit = superio_wmi_exit; 1156 } 1157 1158 pdev[i] = platform_device_alloc(DRVNAME, address); 1159 if (!pdev[i]) { 1160 err = -ENOMEM; 1161 goto exit_device_unregister; 1162 } 1163 1164 err = platform_device_add_data(pdev[i], &sio_data, 1165 sizeof(struct nct6775_sio_data)); 1166 if (err) 1167 goto exit_device_put; 1168 1169 if (sio_data.access == access_direct) { 1170 memset(&res, 0, sizeof(res)); 1171 res.name = DRVNAME; 1172 res.start = address + IOREGION_OFFSET; 1173 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1; 1174 res.flags = IORESOURCE_IO; 1175 1176 err = acpi_check_resource_conflict(&res); 1177 if (err) { 1178 platform_device_put(pdev[i]); 1179 pdev[i] = NULL; 1180 continue; 1181 } 1182 1183 err = platform_device_add_resources(pdev[i], &res, 1); 1184 if (err) 1185 goto exit_device_put; 1186 } 1187 1188 /* platform_device_add calls probe() */ 1189 err = platform_device_add(pdev[i]); 1190 if (err) 1191 goto exit_device_put; 1192 } 1193 if (!found) { 1194 err = -ENODEV; 1195 goto exit_unregister; 1196 } 1197 1198 return 0; 1199 1200 exit_device_put: 1201 platform_device_put(pdev[i]); 1202 exit_device_unregister: 1203 while (--i >= 0) { 1204 if (pdev[i]) 1205 platform_device_unregister(pdev[i]); 1206 } 1207 exit_unregister: 1208 platform_driver_unregister(&nct6775_driver); 1209 return err; 1210 } 1211 1212 static void __exit sensors_nct6775_platform_exit(void) 1213 { 1214 int i; 1215 1216 for (i = 0; i < ARRAY_SIZE(pdev); i++) { 1217 if (pdev[i]) 1218 platform_device_unregister(pdev[i]); 1219 } 1220 platform_driver_unregister(&nct6775_driver); 1221 } 1222 1223 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>"); 1224 MODULE_DESCRIPTION("Platform driver for NCT6775F and compatible chips"); 1225 MODULE_LICENSE("GPL"); 1226 MODULE_IMPORT_NS(HWMON_NCT6775); 1227 1228 module_init(sensors_nct6775_platform_init); 1229 module_exit(sensors_nct6775_platform_exit); 1230