1 /* 2 * nct6683 - Driver for the hardware monitoring functionality of 3 * Nuvoton NCT6683D eSIO 4 * 5 * Copyright (C) 2013 Guenter Roeck <linux@roeck-us.net> 6 * 7 * Derived from nct6775 driver 8 * Copyright (C) 2012, 2013 Guenter Roeck <linux@roeck-us.net> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * Supports the following chips: 21 * 22 * Chip #vin #fan #pwm #temp chip ID 23 * nct6683d 21(1) 16 8 32(1) 0xc730 24 * 25 * Notes: 26 * (1) Total number of vin and temp inputs is 32. 27 */ 28 29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 30 31 #include <linux/acpi.h> 32 #include <linux/dmi.h> 33 #include <linux/err.h> 34 #include <linux/init.h> 35 #include <linux/io.h> 36 #include <linux/jiffies.h> 37 #include <linux/hwmon.h> 38 #include <linux/hwmon-sysfs.h> 39 #include <linux/module.h> 40 #include <linux/mutex.h> 41 #include <linux/platform_device.h> 42 #include <linux/slab.h> 43 44 enum kinds { nct6683 }; 45 46 static bool force; 47 module_param(force, bool, 0); 48 MODULE_PARM_DESC(force, "Set to one to enable detection on non-Intel boards"); 49 50 static const char * const nct6683_device_names[] = { 51 "nct6683", 52 }; 53 54 static const char * const nct6683_chip_names[] = { 55 "NCT6683D", 56 }; 57 58 #define DRVNAME "nct6683" 59 60 /* 61 * Super-I/O constants and functions 62 */ 63 64 #define NCT6683_LD_ACPI 0x0a 65 #define NCT6683_LD_HWM 0x0b 66 #define NCT6683_LD_VID 0x0d 67 68 #define SIO_REG_LDSEL 0x07 /* Logical device select */ 69 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */ 70 #define SIO_REG_ENABLE 0x30 /* Logical device enable */ 71 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */ 72 73 #define SIO_NCT6681_ID 0xb270 /* for later */ 74 #define SIO_NCT6683_ID 0xc730 75 #define SIO_ID_MASK 0xFFF0 76 77 static inline void 78 superio_outb(int ioreg, int reg, int val) 79 { 80 outb(reg, ioreg); 81 outb(val, ioreg + 1); 82 } 83 84 static inline int 85 superio_inb(int ioreg, int reg) 86 { 87 outb(reg, ioreg); 88 return inb(ioreg + 1); 89 } 90 91 static inline void 92 superio_select(int ioreg, int ld) 93 { 94 outb(SIO_REG_LDSEL, ioreg); 95 outb(ld, ioreg + 1); 96 } 97 98 static inline int 99 superio_enter(int ioreg) 100 { 101 /* 102 * Try to reserve <ioreg> and <ioreg + 1> for exclusive access. 103 */ 104 if (!request_muxed_region(ioreg, 2, DRVNAME)) 105 return -EBUSY; 106 107 outb(0x87, ioreg); 108 outb(0x87, ioreg); 109 110 return 0; 111 } 112 113 static inline void 114 superio_exit(int ioreg) 115 { 116 outb(0xaa, ioreg); 117 outb(0x02, ioreg); 118 outb(0x02, ioreg + 1); 119 release_region(ioreg, 2); 120 } 121 122 /* 123 * ISA constants 124 */ 125 126 #define IOREGION_ALIGNMENT (~7) 127 #define IOREGION_OFFSET 4 /* Use EC port 1 */ 128 #define IOREGION_LENGTH 4 129 130 #define EC_PAGE_REG 0 131 #define EC_INDEX_REG 1 132 #define EC_DATA_REG 2 133 #define EC_EVENT_REG 3 134 135 /* Common and NCT6683 specific data */ 136 137 #define NCT6683_NUM_REG_MON 32 138 #define NCT6683_NUM_REG_FAN 16 139 #define NCT6683_NUM_REG_PWM 8 140 141 #define NCT6683_REG_MON(x) (0x100 + (x) * 2) 142 #define NCT6683_REG_FAN_RPM(x) (0x140 + (x) * 2) 143 #define NCT6683_REG_PWM(x) (0x160 + (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_CUSTOMER_ID 0x602 169 #define NCT6683_CUSTOMER_ID_INTEL 0x805 170 171 #define NCT6683_REG_BUILD_YEAR 0x604 172 #define NCT6683_REG_BUILD_MONTH 0x605 173 #define NCT6683_REG_BUILD_DAY 0x606 174 #define NCT6683_REG_SERIAL 0x607 175 #define NCT6683_REG_VERSION_HI 0x608 176 #define NCT6683_REG_VERSION_LO 0x609 177 178 #define NCT6683_REG_CR_CASEOPEN 0xe8 179 #define NCT6683_CR_CASEOPEN_MASK (1 << 7) 180 181 #define NCT6683_REG_CR_BEEP 0xe0 182 #define NCT6683_CR_BEEP_MASK (1 << 6) 183 184 static const char *const nct6683_mon_label[] = { 185 NULL, /* disabled */ 186 "Local", 187 "Diode 0 (curr)", 188 "Diode 1 (curr)", 189 "Diode 2 (curr)", 190 "Diode 0 (volt)", 191 "Diode 1 (volt)", 192 "Diode 2 (volt)", 193 "Thermistor 14", 194 "Thermistor 15", 195 "Thermistor 16", 196 "Thermistor 0", 197 "Thermistor 1", 198 "Thermistor 2", 199 "Thermistor 3", 200 "Thermistor 4", 201 "Thermistor 5", /* 0x10 */ 202 "Thermistor 6", 203 "Thermistor 7", 204 "Thermistor 8", 205 "Thermistor 9", 206 "Thermistor 10", 207 "Thermistor 11", 208 "Thermistor 12", 209 "Thermistor 13", 210 NULL, NULL, NULL, NULL, NULL, NULL, NULL, 211 "PECI 0.0", /* 0x20 */ 212 "PECI 1.0", 213 "PECI 2.0", 214 "PECI 3.0", 215 "PECI 0.1", 216 "PECI 1.1", 217 "PECI 2.1", 218 "PECI 3.1", 219 "PECI DIMM 0", 220 "PECI DIMM 1", 221 "PECI DIMM 2", 222 "PECI DIMM 3", 223 NULL, NULL, NULL, NULL, 224 "PCH CPU", /* 0x30 */ 225 "PCH CHIP", 226 "PCH CHIP CPU MAX", 227 "PCH MCH", 228 "PCH DIMM 0", 229 "PCH DIMM 1", 230 "PCH DIMM 2", 231 "PCH DIMM 3", 232 "SMBus 0", 233 "SMBus 1", 234 "SMBus 2", 235 "SMBus 3", 236 "SMBus 4", 237 "SMBus 5", 238 "DIMM 0", 239 "DIMM 1", 240 "DIMM 2", /* 0x40 */ 241 "DIMM 3", 242 "AMD TSI Addr 90h", 243 "AMD TSI Addr 92h", 244 "AMD TSI Addr 94h", 245 "AMD TSI Addr 96h", 246 "AMD TSI Addr 98h", 247 "AMD TSI Addr 9ah", 248 "AMD TSI Addr 9ch", 249 "AMD TSI Addr 9dh", 250 NULL, NULL, NULL, NULL, NULL, NULL, 251 "Virtual 0", /* 0x50 */ 252 "Virtual 1", 253 "Virtual 2", 254 "Virtual 3", 255 "Virtual 4", 256 "Virtual 5", 257 "Virtual 6", 258 "Virtual 7", 259 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 260 "VCC", /* 0x60 voltage sensors */ 261 "VSB", 262 "AVSB", 263 "VTT", 264 "VBAT", 265 "VREF", 266 "VIN0", 267 "VIN1", 268 "VIN2", 269 "VIN3", 270 "VIN4", 271 "VIN5", 272 "VIN6", 273 "VIN7", 274 "VIN8", 275 "VIN9", 276 "VIN10", 277 "VIN11", 278 "VIN12", 279 "VIN13", 280 "VIN14", 281 "VIN15", 282 "VIN16", 283 }; 284 285 #define NUM_MON_LABELS ARRAY_SIZE(nct6683_mon_label) 286 #define MON_VOLTAGE_START 0x60 287 288 /* ------------------------------------------------------- */ 289 290 struct nct6683_data { 291 int addr; /* IO base of EC space */ 292 int sioreg; /* SIO register */ 293 enum kinds kind; 294 u16 customer_id; 295 296 struct device *hwmon_dev; 297 const struct attribute_group *groups[6]; 298 299 int temp_num; /* number of temperature attributes */ 300 u8 temp_index[NCT6683_NUM_REG_MON]; 301 u8 temp_src[NCT6683_NUM_REG_MON]; 302 303 u8 in_num; /* number of voltage attributes */ 304 u8 in_index[NCT6683_NUM_REG_MON]; 305 u8 in_src[NCT6683_NUM_REG_MON]; 306 307 struct mutex update_lock; /* used to protect sensor updates */ 308 bool valid; /* true if following fields are valid */ 309 unsigned long last_updated; /* In jiffies */ 310 311 /* Voltage attribute values */ 312 u8 in[3][NCT6683_NUM_REG_MON]; /* [0]=in, [1]=in_max, [2]=in_min */ 313 314 /* Temperature attribute values */ 315 s16 temp_in[NCT6683_NUM_REG_MON]; 316 s8 temp[4][NCT6683_NUM_REG_MON];/* [0]=min, [1]=max, [2]=hyst, 317 * [3]=crit 318 */ 319 320 /* Fan attribute values */ 321 unsigned int rpm[NCT6683_NUM_REG_FAN]; 322 u16 fan_min[NCT6683_NUM_REG_FAN]; 323 u8 fanin_cfg[NCT6683_NUM_REG_FAN]; 324 u8 fanout_cfg[NCT6683_NUM_REG_FAN]; 325 u16 have_fan; /* some fan inputs can be disabled */ 326 327 u8 have_pwm; 328 u8 pwm[NCT6683_NUM_REG_PWM]; 329 330 #ifdef CONFIG_PM 331 /* Remember extra register values over suspend/resume */ 332 u8 hwm_cfg; 333 #endif 334 }; 335 336 struct nct6683_sio_data { 337 int sioreg; 338 enum kinds kind; 339 }; 340 341 struct sensor_device_template { 342 struct device_attribute dev_attr; 343 union { 344 struct { 345 u8 nr; 346 u8 index; 347 } s; 348 int index; 349 } u; 350 bool s2; /* true if both index and nr are used */ 351 }; 352 353 struct sensor_device_attr_u { 354 union { 355 struct sensor_device_attribute a1; 356 struct sensor_device_attribute_2 a2; 357 } u; 358 char name[32]; 359 }; 360 361 #define __TEMPLATE_ATTR(_template, _mode, _show, _store) { \ 362 .attr = {.name = _template, .mode = _mode }, \ 363 .show = _show, \ 364 .store = _store, \ 365 } 366 367 #define SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, _index) \ 368 { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \ 369 .u.index = _index, \ 370 .s2 = false } 371 372 #define SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store, \ 373 _nr, _index) \ 374 { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \ 375 .u.s.index = _index, \ 376 .u.s.nr = _nr, \ 377 .s2 = true } 378 379 #define SENSOR_TEMPLATE(_name, _template, _mode, _show, _store, _index) \ 380 static struct sensor_device_template sensor_dev_template_##_name \ 381 = SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, \ 382 _index) 383 384 #define SENSOR_TEMPLATE_2(_name, _template, _mode, _show, _store, \ 385 _nr, _index) \ 386 static struct sensor_device_template sensor_dev_template_##_name \ 387 = SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store, \ 388 _nr, _index) 389 390 struct sensor_template_group { 391 struct sensor_device_template **templates; 392 umode_t (*is_visible)(struct kobject *, struct attribute *, int); 393 int base; 394 }; 395 396 static struct attribute_group * 397 nct6683_create_attr_group(struct device *dev, struct sensor_template_group *tg, 398 int repeat) 399 { 400 struct sensor_device_attribute_2 *a2; 401 struct sensor_device_attribute *a; 402 struct sensor_device_template **t; 403 struct sensor_device_attr_u *su; 404 struct attribute_group *group; 405 struct attribute **attrs; 406 int i, j, count; 407 408 if (repeat <= 0) 409 return ERR_PTR(-EINVAL); 410 411 t = tg->templates; 412 for (count = 0; *t; t++, count++) 413 ; 414 415 if (count == 0) 416 return ERR_PTR(-EINVAL); 417 418 group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL); 419 if (group == NULL) 420 return ERR_PTR(-ENOMEM); 421 422 attrs = devm_kzalloc(dev, sizeof(*attrs) * (repeat * count + 1), 423 GFP_KERNEL); 424 if (attrs == NULL) 425 return ERR_PTR(-ENOMEM); 426 427 su = devm_kzalloc(dev, sizeof(*su) * repeat * count, 428 GFP_KERNEL); 429 if (su == NULL) 430 return ERR_PTR(-ENOMEM); 431 432 group->attrs = attrs; 433 group->is_visible = tg->is_visible; 434 435 for (i = 0; i < repeat; i++) { 436 t = tg->templates; 437 for (j = 0; *t != NULL; j++) { 438 snprintf(su->name, sizeof(su->name), 439 (*t)->dev_attr.attr.name, tg->base + i); 440 if ((*t)->s2) { 441 a2 = &su->u.a2; 442 sysfs_attr_init(&a2->dev_attr.attr); 443 a2->dev_attr.attr.name = su->name; 444 a2->nr = (*t)->u.s.nr + i; 445 a2->index = (*t)->u.s.index; 446 a2->dev_attr.attr.mode = 447 (*t)->dev_attr.attr.mode; 448 a2->dev_attr.show = (*t)->dev_attr.show; 449 a2->dev_attr.store = (*t)->dev_attr.store; 450 *attrs = &a2->dev_attr.attr; 451 } else { 452 a = &su->u.a1; 453 sysfs_attr_init(&a->dev_attr.attr); 454 a->dev_attr.attr.name = su->name; 455 a->index = (*t)->u.index + i; 456 a->dev_attr.attr.mode = 457 (*t)->dev_attr.attr.mode; 458 a->dev_attr.show = (*t)->dev_attr.show; 459 a->dev_attr.store = (*t)->dev_attr.store; 460 *attrs = &a->dev_attr.attr; 461 } 462 attrs++; 463 su++; 464 t++; 465 } 466 } 467 468 return group; 469 } 470 471 /* LSB is 16 mV, except for the following sources, where it is 32 mV */ 472 #define MON_SRC_VCC 0x60 473 #define MON_SRC_VSB 0x61 474 #define MON_SRC_AVSB 0x62 475 #define MON_SRC_VBAT 0x64 476 477 static inline long in_from_reg(u16 reg, u8 src) 478 { 479 int scale = 16; 480 481 if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB || 482 src == MON_SRC_VBAT) 483 scale <<= 1; 484 return reg * scale; 485 } 486 487 static inline u16 in_to_reg(u32 val, 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 495 return clamp_val(DIV_ROUND_CLOSEST(val, scale), 0, 127); 496 } 497 498 static u16 nct6683_read(struct nct6683_data *data, u16 reg) 499 { 500 int res; 501 502 outb_p(0xff, data->addr + EC_PAGE_REG); /* unlock */ 503 outb_p(reg >> 8, data->addr + EC_PAGE_REG); 504 outb_p(reg & 0xff, data->addr + EC_INDEX_REG); 505 res = inb_p(data->addr + EC_DATA_REG); 506 return res; 507 } 508 509 static u16 nct6683_read16(struct nct6683_data *data, u16 reg) 510 { 511 return (nct6683_read(data, reg) << 8) | nct6683_read(data, reg + 1); 512 } 513 514 static void nct6683_write(struct nct6683_data *data, u16 reg, u16 value) 515 { 516 outb_p(0xff, data->addr + EC_PAGE_REG); /* unlock */ 517 outb_p(reg >> 8, data->addr + EC_PAGE_REG); 518 outb_p(reg & 0xff, data->addr + EC_INDEX_REG); 519 outb_p(value & 0xff, data->addr + EC_DATA_REG); 520 } 521 522 static int get_in_reg(struct nct6683_data *data, int nr, int index) 523 { 524 int ch = data->in_index[index]; 525 int reg = -EINVAL; 526 527 switch (nr) { 528 case 0: 529 reg = NCT6683_REG_MON(ch); 530 break; 531 case 1: 532 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL) 533 reg = NCT6683_REG_MON_LOW(ch); 534 break; 535 case 2: 536 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL) 537 reg = NCT6683_REG_MON_HIGH(ch); 538 break; 539 default: 540 break; 541 } 542 return reg; 543 } 544 545 static int get_temp_reg(struct nct6683_data *data, int nr, int index) 546 { 547 int ch = data->temp_index[index]; 548 int reg = -EINVAL; 549 550 switch (data->customer_id) { 551 case NCT6683_CUSTOMER_ID_INTEL: 552 switch (nr) { 553 default: 554 case 1: /* max */ 555 reg = NCT6683_REG_INTEL_TEMP_MAX(ch); 556 break; 557 case 3: /* crit */ 558 reg = NCT6683_REG_INTEL_TEMP_CRIT(ch); 559 break; 560 } 561 break; 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 583 static 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 595 static 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 */ 653 static ssize_t 654 show_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 663 static ssize_t 664 show_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 675 static umode_t nct6683_in_is_visible(struct kobject *kobj, 676 struct attribute *attr, int index) 677 { 678 struct device *dev = container_of(kobj, struct device, 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 693 SENSOR_TEMPLATE(in_label, "in%d_label", S_IRUGO, show_in_label, NULL, 0); 694 SENSOR_TEMPLATE_2(in_input, "in%d_input", S_IRUGO, show_in_reg, NULL, 0, 0); 695 SENSOR_TEMPLATE_2(in_min, "in%d_min", S_IRUGO, show_in_reg, NULL, 0, 1); 696 SENSOR_TEMPLATE_2(in_max, "in%d_max", S_IRUGO, show_in_reg, NULL, 0, 2); 697 698 static 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 706 static struct sensor_template_group nct6683_in_template_group = { 707 .templates = nct6683_attributes_in_template, 708 .is_visible = nct6683_in_is_visible, 709 }; 710 711 static ssize_t 712 show_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 720 static ssize_t 721 show_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 730 static ssize_t 731 show_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 740 static umode_t nct6683_fan_is_visible(struct kobject *kobj, 741 struct attribute *attr, int index) 742 { 743 struct device *dev = container_of(kobj, struct device, 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 761 SENSOR_TEMPLATE(fan_input, "fan%d_input", S_IRUGO, show_fan, NULL, 0); 762 SENSOR_TEMPLATE(fan_pulses, "fan%d_pulses", S_IRUGO, show_fan_pulses, NULL, 0); 763 SENSOR_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 */ 770 static 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 777 static 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 783 static ssize_t 784 show_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 793 static ssize_t 794 show_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 804 static ssize_t 805 show_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 815 static ssize_t 816 show_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 835 static 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 849 static ssize_t 850 show_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 858 static umode_t nct6683_temp_is_visible(struct kobject *kobj, 859 struct attribute *attr, int index) 860 { 861 struct device *dev = container_of(kobj, struct device, 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 880 SENSOR_TEMPLATE(temp_input, "temp%d_input", S_IRUGO, show_temp16, NULL, 0); 881 SENSOR_TEMPLATE(temp_label, "temp%d_label", S_IRUGO, show_temp_label, NULL, 0); 882 SENSOR_TEMPLATE_2(temp_min, "temp%d_min", S_IRUGO, show_temp8, NULL, 0, 0); 883 SENSOR_TEMPLATE_2(temp_max, "temp%d_max", S_IRUGO, show_temp8, NULL, 0, 1); 884 SENSOR_TEMPLATE(temp_max_hyst, "temp%d_max_hyst", S_IRUGO, show_temp_hyst, NULL, 885 0); 886 SENSOR_TEMPLATE_2(temp_crit, "temp%d_crit", S_IRUGO, show_temp8, NULL, 0, 3); 887 SENSOR_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 */ 894 static 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 905 static 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 911 static ssize_t 912 show_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 921 SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, NULL, 0); 922 923 static umode_t nct6683_pwm_is_visible(struct kobject *kobj, 924 struct attribute *attr, int index) 925 { 926 struct device *dev = container_of(kobj, struct device, kobj); 927 struct nct6683_data *data = dev_get_drvdata(dev); 928 int pwm = index; /* pwm index */ 929 930 if (!(data->have_pwm & (1 << pwm))) 931 return 0; 932 933 return attr->mode; 934 } 935 936 static struct sensor_device_template *nct6683_attributes_pwm_template[] = { 937 &sensor_dev_template_pwm, 938 NULL 939 }; 940 941 static struct sensor_template_group nct6683_pwm_template_group = { 942 .templates = nct6683_attributes_pwm_template, 943 .is_visible = nct6683_pwm_is_visible, 944 .base = 1, 945 }; 946 947 static ssize_t 948 show_global_beep(struct device *dev, struct device_attribute *attr, char *buf) 949 { 950 struct nct6683_data *data = dev_get_drvdata(dev); 951 int ret; 952 u8 reg; 953 954 mutex_lock(&data->update_lock); 955 956 ret = superio_enter(data->sioreg); 957 if (ret) 958 goto error; 959 superio_select(data->sioreg, NCT6683_LD_HWM); 960 reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP); 961 superio_exit(data->sioreg); 962 963 mutex_unlock(&data->update_lock); 964 965 return sprintf(buf, "%u\n", !!(reg & NCT6683_CR_BEEP_MASK)); 966 967 error: 968 mutex_unlock(&data->update_lock); 969 return ret; 970 } 971 972 static ssize_t 973 store_global_beep(struct device *dev, struct device_attribute *attr, 974 const char *buf, size_t count) 975 { 976 struct nct6683_data *data = dev_get_drvdata(dev); 977 unsigned long val; 978 u8 reg; 979 int ret; 980 981 if (kstrtoul(buf, 10, &val) || (val != 0 && val != 1)) 982 return -EINVAL; 983 984 mutex_lock(&data->update_lock); 985 986 ret = superio_enter(data->sioreg); 987 if (ret) { 988 count = ret; 989 goto error; 990 } 991 992 superio_select(data->sioreg, NCT6683_LD_HWM); 993 reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP); 994 if (val) 995 reg |= NCT6683_CR_BEEP_MASK; 996 else 997 reg &= ~NCT6683_CR_BEEP_MASK; 998 superio_outb(data->sioreg, NCT6683_REG_CR_BEEP, reg); 999 superio_exit(data->sioreg); 1000 error: 1001 mutex_unlock(&data->update_lock); 1002 return count; 1003 } 1004 1005 /* Case open detection */ 1006 1007 static ssize_t 1008 show_caseopen(struct device *dev, struct device_attribute *attr, char *buf) 1009 { 1010 struct nct6683_data *data = dev_get_drvdata(dev); 1011 int ret; 1012 u8 reg; 1013 1014 mutex_lock(&data->update_lock); 1015 1016 ret = superio_enter(data->sioreg); 1017 if (ret) 1018 goto error; 1019 superio_select(data->sioreg, NCT6683_LD_ACPI); 1020 reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN); 1021 superio_exit(data->sioreg); 1022 1023 mutex_unlock(&data->update_lock); 1024 1025 return sprintf(buf, "%u\n", !(reg & NCT6683_CR_CASEOPEN_MASK)); 1026 1027 error: 1028 mutex_unlock(&data->update_lock); 1029 return ret; 1030 } 1031 1032 static ssize_t 1033 clear_caseopen(struct device *dev, struct device_attribute *attr, 1034 const char *buf, size_t count) 1035 { 1036 struct nct6683_data *data = dev_get_drvdata(dev); 1037 unsigned long val; 1038 u8 reg; 1039 int ret; 1040 1041 if (kstrtoul(buf, 10, &val) || val != 0) 1042 return -EINVAL; 1043 1044 mutex_lock(&data->update_lock); 1045 1046 /* 1047 * Use CR registers to clear caseopen status. 1048 * Caseopen is activ low, clear by writing 1 into the register. 1049 */ 1050 1051 ret = superio_enter(data->sioreg); 1052 if (ret) { 1053 count = ret; 1054 goto error; 1055 } 1056 1057 superio_select(data->sioreg, NCT6683_LD_ACPI); 1058 reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN); 1059 reg |= NCT6683_CR_CASEOPEN_MASK; 1060 superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg); 1061 reg &= ~NCT6683_CR_CASEOPEN_MASK; 1062 superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg); 1063 superio_exit(data->sioreg); 1064 1065 data->valid = false; /* Force cache refresh */ 1066 error: 1067 mutex_unlock(&data->update_lock); 1068 return count; 1069 } 1070 1071 static DEVICE_ATTR(intrusion0_alarm, S_IWUSR | S_IRUGO, show_caseopen, 1072 clear_caseopen); 1073 static DEVICE_ATTR(beep_enable, S_IWUSR | S_IRUGO, show_global_beep, 1074 store_global_beep); 1075 1076 static struct attribute *nct6683_attributes_other[] = { 1077 &dev_attr_intrusion0_alarm.attr, 1078 &dev_attr_beep_enable.attr, 1079 NULL 1080 }; 1081 1082 static const struct attribute_group nct6683_group_other = { 1083 .attrs = nct6683_attributes_other, 1084 }; 1085 1086 /* Get the monitoring functions started */ 1087 static inline void nct6683_init_device(struct nct6683_data *data) 1088 { 1089 u8 tmp; 1090 1091 /* Start hardware monitoring if needed */ 1092 tmp = nct6683_read(data, NCT6683_HWM_CFG); 1093 if (!(tmp & 0x80)) 1094 nct6683_write(data, NCT6683_HWM_CFG, tmp | 0x80); 1095 } 1096 1097 /* 1098 * There are a total of 24 fan inputs. Each can be configured as input 1099 * or as output. A maximum of 16 inputs and 8 outputs is configurable. 1100 */ 1101 static void 1102 nct6683_setup_fans(struct nct6683_data *data) 1103 { 1104 int i; 1105 u8 reg; 1106 1107 for (i = 0; i < NCT6683_NUM_REG_FAN; i++) { 1108 reg = nct6683_read(data, NCT6683_REG_FANIN_CFG(i)); 1109 if (reg & 0x80) 1110 data->have_fan |= 1 << i; 1111 data->fanin_cfg[i] = reg; 1112 } 1113 for (i = 0; i < NCT6683_NUM_REG_PWM; i++) { 1114 reg = nct6683_read(data, NCT6683_REG_FANOUT_CFG(i)); 1115 if (reg & 0x80) 1116 data->have_pwm |= 1 << i; 1117 data->fanout_cfg[i] = reg; 1118 } 1119 } 1120 1121 /* 1122 * Translation from monitoring register to temperature and voltage attributes 1123 * ========================================================================== 1124 * 1125 * There are a total of 32 monitoring registers. Each can be assigned to either 1126 * a temperature or voltage monitoring source. 1127 * NCT6683_REG_MON_CFG(x) defines assignment for each monitoring source. 1128 * 1129 * Temperature and voltage attribute mapping is determined by walking through 1130 * the NCT6683_REG_MON_CFG registers. If the assigned source is 1131 * a temperature, temp_index[n] is set to the monitor register index, and 1132 * temp_src[n] is set to the temperature source. If the assigned source is 1133 * a voltage, the respective values are stored in in_index[] and in_src[], 1134 * respectively. 1135 */ 1136 1137 static void nct6683_setup_sensors(struct nct6683_data *data) 1138 { 1139 u8 reg; 1140 int i; 1141 1142 data->temp_num = 0; 1143 data->in_num = 0; 1144 for (i = 0; i < NCT6683_NUM_REG_MON; i++) { 1145 reg = nct6683_read(data, NCT6683_REG_MON_CFG(i)) & 0x7f; 1146 /* Ignore invalid assignments */ 1147 if (reg >= NUM_MON_LABELS) 1148 continue; 1149 /* Skip if disabled or reserved */ 1150 if (nct6683_mon_label[reg] == NULL) 1151 continue; 1152 if (reg < MON_VOLTAGE_START) { 1153 data->temp_index[data->temp_num] = i; 1154 data->temp_src[data->temp_num] = reg; 1155 data->temp_num++; 1156 } else { 1157 data->in_index[data->in_num] = i; 1158 data->in_src[data->in_num] = reg; 1159 data->in_num++; 1160 } 1161 } 1162 } 1163 1164 static int nct6683_probe(struct platform_device *pdev) 1165 { 1166 struct device *dev = &pdev->dev; 1167 struct nct6683_sio_data *sio_data = dev->platform_data; 1168 struct attribute_group *group; 1169 struct nct6683_data *data; 1170 struct device *hwmon_dev; 1171 struct resource *res; 1172 int groups = 0; 1173 1174 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 1175 if (!devm_request_region(dev, res->start, IOREGION_LENGTH, DRVNAME)) 1176 return -EBUSY; 1177 1178 data = devm_kzalloc(dev, sizeof(struct nct6683_data), GFP_KERNEL); 1179 if (!data) 1180 return -ENOMEM; 1181 1182 data->kind = sio_data->kind; 1183 data->sioreg = sio_data->sioreg; 1184 data->addr = res->start; 1185 mutex_init(&data->update_lock); 1186 platform_set_drvdata(pdev, data); 1187 1188 data->customer_id = nct6683_read16(data, NCT6683_REG_CUSTOMER_ID); 1189 1190 nct6683_init_device(data); 1191 nct6683_setup_fans(data); 1192 nct6683_setup_sensors(data); 1193 1194 /* Register sysfs hooks */ 1195 1196 if (data->have_pwm) { 1197 group = nct6683_create_attr_group(dev, 1198 &nct6683_pwm_template_group, 1199 fls(data->have_pwm)); 1200 if (IS_ERR(group)) 1201 return PTR_ERR(group); 1202 data->groups[groups++] = group; 1203 } 1204 1205 if (data->in_num) { 1206 group = nct6683_create_attr_group(dev, 1207 &nct6683_in_template_group, 1208 data->in_num); 1209 if (IS_ERR(group)) 1210 return PTR_ERR(group); 1211 data->groups[groups++] = group; 1212 } 1213 1214 if (data->have_fan) { 1215 group = nct6683_create_attr_group(dev, 1216 &nct6683_fan_template_group, 1217 fls(data->have_fan)); 1218 if (IS_ERR(group)) 1219 return PTR_ERR(group); 1220 data->groups[groups++] = group; 1221 } 1222 1223 if (data->temp_num) { 1224 group = nct6683_create_attr_group(dev, 1225 &nct6683_temp_template_group, 1226 data->temp_num); 1227 if (IS_ERR(group)) 1228 return PTR_ERR(group); 1229 data->groups[groups++] = group; 1230 } 1231 data->groups[groups++] = &nct6683_group_other; 1232 1233 dev_info(dev, "%s EC firmware version %d.%d build %02x/%02x/%02x\n", 1234 nct6683_chip_names[data->kind], 1235 nct6683_read(data, NCT6683_REG_VERSION_HI), 1236 nct6683_read(data, NCT6683_REG_VERSION_LO), 1237 nct6683_read(data, NCT6683_REG_BUILD_MONTH), 1238 nct6683_read(data, NCT6683_REG_BUILD_DAY), 1239 nct6683_read(data, NCT6683_REG_BUILD_YEAR)); 1240 1241 hwmon_dev = devm_hwmon_device_register_with_groups(dev, 1242 nct6683_device_names[data->kind], data, data->groups); 1243 return PTR_ERR_OR_ZERO(hwmon_dev); 1244 } 1245 1246 #ifdef CONFIG_PM 1247 static int nct6683_suspend(struct device *dev) 1248 { 1249 struct nct6683_data *data = nct6683_update_device(dev); 1250 1251 mutex_lock(&data->update_lock); 1252 data->hwm_cfg = nct6683_read(data, NCT6683_HWM_CFG); 1253 mutex_unlock(&data->update_lock); 1254 1255 return 0; 1256 } 1257 1258 static int nct6683_resume(struct device *dev) 1259 { 1260 struct nct6683_data *data = dev_get_drvdata(dev); 1261 1262 mutex_lock(&data->update_lock); 1263 1264 nct6683_write(data, NCT6683_HWM_CFG, data->hwm_cfg); 1265 1266 /* Force re-reading all values */ 1267 data->valid = false; 1268 mutex_unlock(&data->update_lock); 1269 1270 return 0; 1271 } 1272 1273 static const struct dev_pm_ops nct6683_dev_pm_ops = { 1274 .suspend = nct6683_suspend, 1275 .resume = nct6683_resume, 1276 .freeze = nct6683_suspend, 1277 .restore = nct6683_resume, 1278 }; 1279 1280 #define NCT6683_DEV_PM_OPS (&nct6683_dev_pm_ops) 1281 #else 1282 #define NCT6683_DEV_PM_OPS NULL 1283 #endif /* CONFIG_PM */ 1284 1285 static struct platform_driver nct6683_driver = { 1286 .driver = { 1287 .name = DRVNAME, 1288 .pm = NCT6683_DEV_PM_OPS, 1289 }, 1290 .probe = nct6683_probe, 1291 }; 1292 1293 static int __init nct6683_find(int sioaddr, struct nct6683_sio_data *sio_data) 1294 { 1295 const char *board_vendor; 1296 int addr; 1297 u16 val; 1298 int err; 1299 1300 /* 1301 * Only run on Intel boards unless the 'force' module parameter is set 1302 */ 1303 if (!force) { 1304 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR); 1305 if (!board_vendor || strcmp(board_vendor, "Intel Corporation")) 1306 return -ENODEV; 1307 } 1308 1309 err = superio_enter(sioaddr); 1310 if (err) 1311 return err; 1312 1313 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) 1314 | superio_inb(sioaddr, SIO_REG_DEVID + 1); 1315 1316 switch (val & SIO_ID_MASK) { 1317 case SIO_NCT6683_ID: 1318 sio_data->kind = nct6683; 1319 break; 1320 default: 1321 if (val != 0xffff) 1322 pr_debug("unsupported chip ID: 0x%04x\n", val); 1323 goto fail; 1324 } 1325 1326 /* We have a known chip, find the HWM I/O address */ 1327 superio_select(sioaddr, NCT6683_LD_HWM); 1328 val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8) 1329 | superio_inb(sioaddr, SIO_REG_ADDR + 1); 1330 addr = val & IOREGION_ALIGNMENT; 1331 if (addr == 0) { 1332 pr_err("EC base I/O port unconfigured\n"); 1333 goto fail; 1334 } 1335 1336 /* Activate logical device if needed */ 1337 val = superio_inb(sioaddr, SIO_REG_ENABLE); 1338 if (!(val & 0x01)) { 1339 pr_err("EC is disabled\n"); 1340 goto fail; 1341 } 1342 1343 superio_exit(sioaddr); 1344 pr_info("Found %s or compatible chip at %#x:%#x\n", 1345 nct6683_chip_names[sio_data->kind], sioaddr, addr); 1346 sio_data->sioreg = sioaddr; 1347 1348 return addr; 1349 1350 fail: 1351 superio_exit(sioaddr); 1352 return -ENODEV; 1353 } 1354 1355 /* 1356 * when Super-I/O functions move to a separate file, the Super-I/O 1357 * bus will manage the lifetime of the device and this module will only keep 1358 * track of the nct6683 driver. But since we use platform_device_alloc(), we 1359 * must keep track of the device 1360 */ 1361 static struct platform_device *pdev[2]; 1362 1363 static int __init sensors_nct6683_init(void) 1364 { 1365 struct nct6683_sio_data sio_data; 1366 int sioaddr[2] = { 0x2e, 0x4e }; 1367 struct resource res; 1368 bool found = false; 1369 int address; 1370 int i, err; 1371 1372 err = platform_driver_register(&nct6683_driver); 1373 if (err) 1374 return err; 1375 1376 /* 1377 * initialize sio_data->kind and sio_data->sioreg. 1378 * 1379 * when Super-I/O functions move to a separate file, the Super-I/O 1380 * driver will probe 0x2e and 0x4e and auto-detect the presence of a 1381 * nct6683 hardware monitor, and call probe() 1382 */ 1383 for (i = 0; i < ARRAY_SIZE(pdev); i++) { 1384 address = nct6683_find(sioaddr[i], &sio_data); 1385 if (address <= 0) 1386 continue; 1387 1388 found = true; 1389 1390 pdev[i] = platform_device_alloc(DRVNAME, address); 1391 if (!pdev[i]) { 1392 err = -ENOMEM; 1393 goto exit_device_unregister; 1394 } 1395 1396 err = platform_device_add_data(pdev[i], &sio_data, 1397 sizeof(struct nct6683_sio_data)); 1398 if (err) 1399 goto exit_device_put; 1400 1401 memset(&res, 0, sizeof(res)); 1402 res.name = DRVNAME; 1403 res.start = address + IOREGION_OFFSET; 1404 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1; 1405 res.flags = IORESOURCE_IO; 1406 1407 err = acpi_check_resource_conflict(&res); 1408 if (err) { 1409 platform_device_put(pdev[i]); 1410 pdev[i] = NULL; 1411 continue; 1412 } 1413 1414 err = platform_device_add_resources(pdev[i], &res, 1); 1415 if (err) 1416 goto exit_device_put; 1417 1418 /* platform_device_add calls probe() */ 1419 err = platform_device_add(pdev[i]); 1420 if (err) 1421 goto exit_device_put; 1422 } 1423 if (!found) { 1424 err = -ENODEV; 1425 goto exit_unregister; 1426 } 1427 1428 return 0; 1429 1430 exit_device_put: 1431 platform_device_put(pdev[i]); 1432 exit_device_unregister: 1433 while (--i >= 0) { 1434 if (pdev[i]) 1435 platform_device_unregister(pdev[i]); 1436 } 1437 exit_unregister: 1438 platform_driver_unregister(&nct6683_driver); 1439 return err; 1440 } 1441 1442 static void __exit sensors_nct6683_exit(void) 1443 { 1444 int i; 1445 1446 for (i = 0; i < ARRAY_SIZE(pdev); i++) { 1447 if (pdev[i]) 1448 platform_device_unregister(pdev[i]); 1449 } 1450 platform_driver_unregister(&nct6683_driver); 1451 } 1452 1453 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>"); 1454 MODULE_DESCRIPTION("NCT6683D driver"); 1455 MODULE_LICENSE("GPL"); 1456 1457 module_init(sensors_nct6683_init); 1458 module_exit(sensors_nct6683_exit); 1459