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