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