1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * nct7802 - Driver for Nuvoton NCT7802Y 4 * 5 * Copyright (C) 2014 Guenter Roeck <linux@roeck-us.net> 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/err.h> 11 #include <linux/i2c.h> 12 #include <linux/init.h> 13 #include <linux/hwmon.h> 14 #include <linux/hwmon-sysfs.h> 15 #include <linux/jiffies.h> 16 #include <linux/module.h> 17 #include <linux/mutex.h> 18 #include <linux/regmap.h> 19 #include <linux/slab.h> 20 21 #define DRVNAME "nct7802" 22 23 static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; 24 25 static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { 26 { 0x46, 0x00, 0x40, 0x42, 0x44 }, 27 { 0x45, 0x00, 0x3f, 0x41, 0x43 }, 28 }; 29 30 static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 }; 31 32 static const u8 REG_VOLTAGE_LIMIT_MSB_SHIFT[2][5] = { 33 { 0, 0, 4, 0, 4 }, 34 { 2, 0, 6, 2, 6 }, 35 }; 36 37 #define REG_BANK 0x00 38 #define REG_TEMP_LSB 0x05 39 #define REG_TEMP_PECI_LSB 0x08 40 #define REG_VOLTAGE_LOW 0x0f 41 #define REG_FANCOUNT_LOW 0x13 42 #define REG_START 0x21 43 #define REG_MODE 0x22 /* 7.2.32 Mode Selection Register */ 44 #define REG_PECI_ENABLE 0x23 45 #define REG_FAN_ENABLE 0x24 46 #define REG_VMON_ENABLE 0x25 47 #define REG_PWM(x) (0x60 + (x)) 48 #define REG_SMARTFAN_EN(x) (0x64 + (x) / 2) 49 #define SMARTFAN_EN_SHIFT(x) ((x) % 2 * 4) 50 #define REG_SMARTFAN_STEP_UP_TIME 0x6e 51 #define REG_SMARTFAN_STEP_DOWN_TIME 0x6f 52 #define REG_VENDOR_ID 0xfd 53 #define REG_CHIP_ID 0xfe 54 #define REG_VERSION_ID 0xff 55 56 /* 57 * Resistance temperature detector (RTD) modes according to 7.2.32 Mode 58 * Selection Register 59 */ 60 #define RTD_MODE_CURRENT 0x1 61 #define RTD_MODE_THERMISTOR 0x2 62 #define RTD_MODE_VOLTAGE 0x3 63 64 #define MODE_RTD_MASK 0x3 65 #define MODE_LTD_EN 0x40 66 67 /* 68 * Bit offset for sensors modes in REG_MODE. 69 * Valid for index 0..2, indicating RTD1..3. 70 */ 71 #define MODE_BIT_OFFSET_RTD(index) ((index) * 2) 72 73 /* 74 * Data structures and manipulation thereof 75 */ 76 77 struct nct7802_data { 78 struct regmap *regmap; 79 struct mutex access_lock; /* for multi-byte read and write operations */ 80 u8 in_status; 81 struct mutex in_alarm_lock; 82 }; 83 84 static ssize_t temp_type_show(struct device *dev, 85 struct device_attribute *attr, char *buf) 86 { 87 struct nct7802_data *data = dev_get_drvdata(dev); 88 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 89 unsigned int mode; 90 int ret; 91 92 ret = regmap_read(data->regmap, REG_MODE, &mode); 93 if (ret < 0) 94 return ret; 95 96 return sprintf(buf, "%u\n", (mode >> (2 * sattr->index) & 3) + 2); 97 } 98 99 static ssize_t temp_type_store(struct device *dev, 100 struct device_attribute *attr, const char *buf, 101 size_t count) 102 { 103 struct nct7802_data *data = dev_get_drvdata(dev); 104 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 105 unsigned int type; 106 int err; 107 108 err = kstrtouint(buf, 0, &type); 109 if (err < 0) 110 return err; 111 if (sattr->index == 2 && type != 4) /* RD3 */ 112 return -EINVAL; 113 if (type < 3 || type > 4) 114 return -EINVAL; 115 err = regmap_update_bits(data->regmap, REG_MODE, 116 3 << 2 * sattr->index, (type - 2) << 2 * sattr->index); 117 return err ? : count; 118 } 119 120 static ssize_t pwm_mode_show(struct device *dev, 121 struct device_attribute *attr, char *buf) 122 { 123 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 124 struct nct7802_data *data = dev_get_drvdata(dev); 125 unsigned int regval; 126 int ret; 127 128 if (sattr->index > 1) 129 return sprintf(buf, "1\n"); 130 131 ret = regmap_read(data->regmap, 0x5E, ®val); 132 if (ret < 0) 133 return ret; 134 135 return sprintf(buf, "%u\n", !(regval & (1 << sattr->index))); 136 } 137 138 static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr, 139 char *buf) 140 { 141 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 142 struct nct7802_data *data = dev_get_drvdata(dev); 143 unsigned int val; 144 int ret; 145 146 if (!attr->index) 147 return sprintf(buf, "255\n"); 148 149 ret = regmap_read(data->regmap, attr->index, &val); 150 if (ret < 0) 151 return ret; 152 153 return sprintf(buf, "%d\n", val); 154 } 155 156 static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr, 157 const char *buf, size_t count) 158 { 159 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 160 struct nct7802_data *data = dev_get_drvdata(dev); 161 int err; 162 u8 val; 163 164 err = kstrtou8(buf, 0, &val); 165 if (err < 0) 166 return err; 167 168 err = regmap_write(data->regmap, attr->index, val); 169 return err ? : count; 170 } 171 172 static ssize_t pwm_enable_show(struct device *dev, 173 struct device_attribute *attr, char *buf) 174 { 175 struct nct7802_data *data = dev_get_drvdata(dev); 176 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 177 unsigned int reg, enabled; 178 int ret; 179 180 ret = regmap_read(data->regmap, REG_SMARTFAN_EN(sattr->index), ®); 181 if (ret < 0) 182 return ret; 183 enabled = reg >> SMARTFAN_EN_SHIFT(sattr->index) & 1; 184 return sprintf(buf, "%u\n", enabled + 1); 185 } 186 187 static ssize_t pwm_enable_store(struct device *dev, 188 struct device_attribute *attr, 189 const char *buf, size_t count) 190 { 191 struct nct7802_data *data = dev_get_drvdata(dev); 192 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 193 u8 val; 194 int ret; 195 196 ret = kstrtou8(buf, 0, &val); 197 if (ret < 0) 198 return ret; 199 if (val < 1 || val > 2) 200 return -EINVAL; 201 ret = regmap_update_bits(data->regmap, REG_SMARTFAN_EN(sattr->index), 202 1 << SMARTFAN_EN_SHIFT(sattr->index), 203 (val - 1) << SMARTFAN_EN_SHIFT(sattr->index)); 204 return ret ? : count; 205 } 206 207 static int nct7802_read_temp(struct nct7802_data *data, 208 u8 reg_temp, u8 reg_temp_low, int *temp) 209 { 210 unsigned int t1, t2 = 0; 211 int err; 212 213 *temp = 0; 214 215 mutex_lock(&data->access_lock); 216 err = regmap_read(data->regmap, reg_temp, &t1); 217 if (err < 0) 218 goto abort; 219 t1 <<= 8; 220 if (reg_temp_low) { /* 11 bit data */ 221 err = regmap_read(data->regmap, reg_temp_low, &t2); 222 if (err < 0) 223 goto abort; 224 } 225 t1 |= t2 & 0xe0; 226 *temp = (s16)t1 / 32 * 125; 227 abort: 228 mutex_unlock(&data->access_lock); 229 return err; 230 } 231 232 static int nct7802_read_fan(struct nct7802_data *data, u8 reg_fan) 233 { 234 unsigned int regs[2] = {reg_fan, REG_FANCOUNT_LOW}; 235 u8 f[2]; 236 int ret; 237 238 ret = regmap_multi_reg_read(data->regmap, regs, f, 2); 239 if (ret) 240 return ret; 241 ret = (f[0] << 5) | (f[1] >> 3); 242 /* convert fan count to rpm */ 243 if (ret == 0x1fff) /* maximum value, assume fan is stopped */ 244 ret = 0; 245 else if (ret) 246 ret = DIV_ROUND_CLOSEST(1350000U, ret); 247 return ret; 248 } 249 250 static int nct7802_read_fan_min(struct nct7802_data *data, u8 reg_fan_low, 251 u8 reg_fan_high) 252 { 253 unsigned int regs[2] = {reg_fan_low, reg_fan_high}; 254 u8 f[2]; 255 int ret; 256 257 ret = regmap_multi_reg_read(data->regmap, regs, f, 2); 258 if (ret < 0) 259 return ret; 260 261 ret = f[0] | ((f[1] & 0xf8) << 5); 262 /* convert fan count to rpm */ 263 if (ret == 0x1fff) /* maximum value, assume no limit */ 264 ret = 0; 265 else if (ret) 266 ret = DIV_ROUND_CLOSEST(1350000U, ret); 267 else 268 ret = 1350000U; 269 return ret; 270 } 271 272 static int nct7802_write_fan_min(struct nct7802_data *data, u8 reg_fan_low, 273 u8 reg_fan_high, unsigned long limit) 274 { 275 int err; 276 277 if (limit) 278 limit = DIV_ROUND_CLOSEST(1350000U, limit); 279 else 280 limit = 0x1fff; 281 limit = clamp_val(limit, 0, 0x1fff); 282 283 mutex_lock(&data->access_lock); 284 err = regmap_write(data->regmap, reg_fan_low, limit & 0xff); 285 if (err < 0) 286 goto abort; 287 288 err = regmap_write(data->regmap, reg_fan_high, (limit & 0x1f00) >> 5); 289 abort: 290 mutex_unlock(&data->access_lock); 291 return err; 292 } 293 294 static u8 nct7802_vmul[] = { 4, 2, 2, 2, 2 }; 295 296 static int nct7802_read_voltage(struct nct7802_data *data, int nr, int index) 297 { 298 u8 v[2]; 299 int ret; 300 301 if (index == 0) { /* voltage */ 302 unsigned int regs[2] = {REG_VOLTAGE[nr], REG_VOLTAGE_LOW}; 303 304 ret = regmap_multi_reg_read(data->regmap, regs, v, 2); 305 if (ret < 0) 306 return ret; 307 ret = ((v[0] << 2) | (v[1] >> 6)) * nct7802_vmul[nr]; 308 } else { /* limit */ 309 int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr]; 310 unsigned int regs[2] = {REG_VOLTAGE_LIMIT_LSB[index - 1][nr], 311 REG_VOLTAGE_LIMIT_MSB[nr]}; 312 313 ret = regmap_multi_reg_read(data->regmap, regs, v, 2); 314 if (ret < 0) 315 return ret; 316 ret = (v[0] | ((v[1] << shift) & 0x300)) * nct7802_vmul[nr]; 317 } 318 return ret; 319 } 320 321 static int nct7802_write_voltage(struct nct7802_data *data, int nr, int index, 322 unsigned long voltage) 323 { 324 int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr]; 325 int err; 326 327 voltage = clamp_val(voltage, 0, 0x3ff * nct7802_vmul[nr]); 328 voltage = DIV_ROUND_CLOSEST(voltage, nct7802_vmul[nr]); 329 330 mutex_lock(&data->access_lock); 331 err = regmap_write(data->regmap, 332 REG_VOLTAGE_LIMIT_LSB[index - 1][nr], 333 voltage & 0xff); 334 if (err < 0) 335 goto abort; 336 337 err = regmap_update_bits(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr], 338 0x0300 >> shift, (voltage & 0x0300) >> shift); 339 abort: 340 mutex_unlock(&data->access_lock); 341 return err; 342 } 343 344 static ssize_t in_show(struct device *dev, struct device_attribute *attr, 345 char *buf) 346 { 347 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 348 struct nct7802_data *data = dev_get_drvdata(dev); 349 int voltage; 350 351 voltage = nct7802_read_voltage(data, sattr->nr, sattr->index); 352 if (voltage < 0) 353 return voltage; 354 355 return sprintf(buf, "%d\n", voltage); 356 } 357 358 static ssize_t in_store(struct device *dev, struct device_attribute *attr, 359 const char *buf, size_t count) 360 { 361 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 362 struct nct7802_data *data = dev_get_drvdata(dev); 363 int index = sattr->index; 364 int nr = sattr->nr; 365 unsigned long val; 366 int err; 367 368 err = kstrtoul(buf, 10, &val); 369 if (err < 0) 370 return err; 371 372 err = nct7802_write_voltage(data, nr, index, val); 373 return err ? : count; 374 } 375 376 static ssize_t in_alarm_show(struct device *dev, struct device_attribute *attr, 377 char *buf) 378 { 379 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 380 struct nct7802_data *data = dev_get_drvdata(dev); 381 int volt, min, max, ret; 382 unsigned int val; 383 384 mutex_lock(&data->in_alarm_lock); 385 386 /* 387 * The SMI Voltage status register is the only register giving a status 388 * for voltages. A bit is set for each input crossing a threshold, in 389 * both direction, but the "inside" or "outside" limits info is not 390 * available. Also this register is cleared on read. 391 * Note: this is not explicitly spelled out in the datasheet, but 392 * from experiment. 393 * To deal with this we use a status cache with one validity bit and 394 * one status bit for each input. Validity is cleared at startup and 395 * each time the register reports a change, and the status is processed 396 * by software based on current input value and limits. 397 */ 398 ret = regmap_read(data->regmap, 0x1e, &val); /* SMI Voltage status */ 399 if (ret < 0) 400 goto abort; 401 402 /* invalidate cached status for all inputs crossing a threshold */ 403 data->in_status &= ~((val & 0x0f) << 4); 404 405 /* if cached status for requested input is invalid, update it */ 406 if (!(data->in_status & (0x10 << sattr->index))) { 407 ret = nct7802_read_voltage(data, sattr->nr, 0); 408 if (ret < 0) 409 goto abort; 410 volt = ret; 411 412 ret = nct7802_read_voltage(data, sattr->nr, 1); 413 if (ret < 0) 414 goto abort; 415 min = ret; 416 417 ret = nct7802_read_voltage(data, sattr->nr, 2); 418 if (ret < 0) 419 goto abort; 420 max = ret; 421 422 if (volt < min || volt > max) 423 data->in_status |= (1 << sattr->index); 424 else 425 data->in_status &= ~(1 << sattr->index); 426 427 data->in_status |= 0x10 << sattr->index; 428 } 429 430 ret = sprintf(buf, "%u\n", !!(data->in_status & (1 << sattr->index))); 431 abort: 432 mutex_unlock(&data->in_alarm_lock); 433 return ret; 434 } 435 436 static ssize_t temp_show(struct device *dev, struct device_attribute *attr, 437 char *buf) 438 { 439 struct nct7802_data *data = dev_get_drvdata(dev); 440 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 441 int err, temp; 442 443 err = nct7802_read_temp(data, sattr->nr, sattr->index, &temp); 444 if (err < 0) 445 return err; 446 447 return sprintf(buf, "%d\n", temp); 448 } 449 450 static ssize_t temp_store(struct device *dev, struct device_attribute *attr, 451 const char *buf, size_t count) 452 { 453 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 454 struct nct7802_data *data = dev_get_drvdata(dev); 455 int nr = sattr->nr; 456 long val; 457 int err; 458 459 err = kstrtol(buf, 10, &val); 460 if (err < 0) 461 return err; 462 463 val = DIV_ROUND_CLOSEST(clamp_val(val, -128000, 127000), 1000); 464 465 err = regmap_write(data->regmap, nr, val & 0xff); 466 return err ? : count; 467 } 468 469 static ssize_t fan_show(struct device *dev, struct device_attribute *attr, 470 char *buf) 471 { 472 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 473 struct nct7802_data *data = dev_get_drvdata(dev); 474 int speed; 475 476 speed = nct7802_read_fan(data, sattr->index); 477 if (speed < 0) 478 return speed; 479 480 return sprintf(buf, "%d\n", speed); 481 } 482 483 static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr, 484 char *buf) 485 { 486 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 487 struct nct7802_data *data = dev_get_drvdata(dev); 488 int speed; 489 490 speed = nct7802_read_fan_min(data, sattr->nr, sattr->index); 491 if (speed < 0) 492 return speed; 493 494 return sprintf(buf, "%d\n", speed); 495 } 496 497 static ssize_t fan_min_store(struct device *dev, 498 struct device_attribute *attr, const char *buf, 499 size_t count) 500 { 501 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 502 struct nct7802_data *data = dev_get_drvdata(dev); 503 unsigned long val; 504 int err; 505 506 err = kstrtoul(buf, 10, &val); 507 if (err < 0) 508 return err; 509 510 err = nct7802_write_fan_min(data, sattr->nr, sattr->index, val); 511 return err ? : count; 512 } 513 514 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr, 515 char *buf) 516 { 517 struct nct7802_data *data = dev_get_drvdata(dev); 518 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 519 int bit = sattr->index; 520 unsigned int val; 521 int ret; 522 523 ret = regmap_read(data->regmap, sattr->nr, &val); 524 if (ret < 0) 525 return ret; 526 527 return sprintf(buf, "%u\n", !!(val & (1 << bit))); 528 } 529 530 static ssize_t 531 beep_show(struct device *dev, struct device_attribute *attr, char *buf) 532 { 533 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 534 struct nct7802_data *data = dev_get_drvdata(dev); 535 unsigned int regval; 536 int err; 537 538 err = regmap_read(data->regmap, sattr->nr, ®val); 539 if (err) 540 return err; 541 542 return sprintf(buf, "%u\n", !!(regval & (1 << sattr->index))); 543 } 544 545 static ssize_t 546 beep_store(struct device *dev, struct device_attribute *attr, const char *buf, 547 size_t count) 548 { 549 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 550 struct nct7802_data *data = dev_get_drvdata(dev); 551 unsigned long val; 552 int err; 553 554 err = kstrtoul(buf, 10, &val); 555 if (err < 0) 556 return err; 557 if (val > 1) 558 return -EINVAL; 559 560 err = regmap_update_bits(data->regmap, sattr->nr, 1 << sattr->index, 561 val ? 1 << sattr->index : 0); 562 return err ? : count; 563 } 564 565 static ssize_t step_time_show(struct device *dev, struct device_attribute *attr, 566 char *buf, bool step_up) 567 { 568 struct nct7802_data *data = dev_get_drvdata(dev); 569 unsigned int reg, val; 570 int ret; 571 572 if (step_up) 573 reg = REG_SMARTFAN_STEP_UP_TIME; 574 else 575 reg = REG_SMARTFAN_STEP_DOWN_TIME; 576 577 ret = regmap_read(data->regmap, reg, &val); 578 if (ret < 0) 579 return ret; 580 581 return sprintf(buf, "%u\n", val * 100); /* Convert from ds to ms */ 582 } 583 584 static ssize_t step_up_time_show(struct device *dev, 585 struct device_attribute *attr, char *buf) 586 { 587 return step_time_show(dev, attr, buf, true); 588 } 589 590 static ssize_t step_down_time_show(struct device *dev, 591 struct device_attribute *attr, char *buf) 592 { 593 return step_time_show(dev, attr, buf, false); 594 } 595 596 static ssize_t step_time_store(struct device *dev, 597 struct device_attribute *attr, const char *buf, 598 size_t count, bool step_up) 599 { 600 struct nct7802_data *data = dev_get_drvdata(dev); 601 unsigned long val; 602 unsigned int reg; 603 int ret; 604 605 ret = kstrtoul(buf, 10, &val); 606 if (ret < 0) 607 return ret; 608 609 /* Clamp range, and convert from ms to ds */ 610 val = DIV_ROUND_CLOSEST(clamp_val(val, 100, 25500), 100); 611 612 if (step_up) 613 reg = REG_SMARTFAN_STEP_UP_TIME; 614 else 615 reg = REG_SMARTFAN_STEP_DOWN_TIME; 616 617 ret = regmap_write(data->regmap, reg, val); 618 619 return ret ? : count; 620 } 621 622 static ssize_t step_up_time_store(struct device *dev, 623 struct device_attribute *attr, 624 const char *buf, size_t count) 625 { 626 return step_time_store(dev, attr, buf, count, true); 627 } 628 629 static ssize_t step_down_time_store(struct device *dev, 630 struct device_attribute *attr, 631 const char *buf, size_t count) 632 { 633 return step_time_store(dev, attr, buf, count, false); 634 } 635 636 static SENSOR_DEVICE_ATTR_RW(temp1_type, temp_type, 0); 637 static SENSOR_DEVICE_ATTR_2_RO(temp1_input, temp, 0x01, REG_TEMP_LSB); 638 static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, 0x31, 0); 639 static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, 0x30, 0); 640 static SENSOR_DEVICE_ATTR_2_RW(temp1_crit, temp, 0x3a, 0); 641 642 static SENSOR_DEVICE_ATTR_RW(temp2_type, temp_type, 1); 643 static SENSOR_DEVICE_ATTR_2_RO(temp2_input, temp, 0x02, REG_TEMP_LSB); 644 static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, 0x33, 0); 645 static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, 0x32, 0); 646 static SENSOR_DEVICE_ATTR_2_RW(temp2_crit, temp, 0x3b, 0); 647 648 static SENSOR_DEVICE_ATTR_RW(temp3_type, temp_type, 2); 649 static SENSOR_DEVICE_ATTR_2_RO(temp3_input, temp, 0x03, REG_TEMP_LSB); 650 static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, 0x35, 0); 651 static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, 0x34, 0); 652 static SENSOR_DEVICE_ATTR_2_RW(temp3_crit, temp, 0x3c, 0); 653 654 static SENSOR_DEVICE_ATTR_2_RO(temp4_input, temp, 0x04, 0); 655 static SENSOR_DEVICE_ATTR_2_RW(temp4_min, temp, 0x37, 0); 656 static SENSOR_DEVICE_ATTR_2_RW(temp4_max, temp, 0x36, 0); 657 static SENSOR_DEVICE_ATTR_2_RW(temp4_crit, temp, 0x3d, 0); 658 659 static SENSOR_DEVICE_ATTR_2_RO(temp5_input, temp, 0x06, REG_TEMP_PECI_LSB); 660 static SENSOR_DEVICE_ATTR_2_RW(temp5_min, temp, 0x39, 0); 661 static SENSOR_DEVICE_ATTR_2_RW(temp5_max, temp, 0x38, 0); 662 static SENSOR_DEVICE_ATTR_2_RW(temp5_crit, temp, 0x3e, 0); 663 664 static SENSOR_DEVICE_ATTR_2_RO(temp6_input, temp, 0x07, REG_TEMP_PECI_LSB); 665 666 static SENSOR_DEVICE_ATTR_2_RO(temp1_min_alarm, alarm, 0x18, 0); 667 static SENSOR_DEVICE_ATTR_2_RO(temp2_min_alarm, alarm, 0x18, 1); 668 static SENSOR_DEVICE_ATTR_2_RO(temp3_min_alarm, alarm, 0x18, 2); 669 static SENSOR_DEVICE_ATTR_2_RO(temp4_min_alarm, alarm, 0x18, 3); 670 static SENSOR_DEVICE_ATTR_2_RO(temp5_min_alarm, alarm, 0x18, 4); 671 672 static SENSOR_DEVICE_ATTR_2_RO(temp1_max_alarm, alarm, 0x19, 0); 673 static SENSOR_DEVICE_ATTR_2_RO(temp2_max_alarm, alarm, 0x19, 1); 674 static SENSOR_DEVICE_ATTR_2_RO(temp3_max_alarm, alarm, 0x19, 2); 675 static SENSOR_DEVICE_ATTR_2_RO(temp4_max_alarm, alarm, 0x19, 3); 676 static SENSOR_DEVICE_ATTR_2_RO(temp5_max_alarm, alarm, 0x19, 4); 677 678 static SENSOR_DEVICE_ATTR_2_RO(temp1_crit_alarm, alarm, 0x1b, 0); 679 static SENSOR_DEVICE_ATTR_2_RO(temp2_crit_alarm, alarm, 0x1b, 1); 680 static SENSOR_DEVICE_ATTR_2_RO(temp3_crit_alarm, alarm, 0x1b, 2); 681 static SENSOR_DEVICE_ATTR_2_RO(temp4_crit_alarm, alarm, 0x1b, 3); 682 static SENSOR_DEVICE_ATTR_2_RO(temp5_crit_alarm, alarm, 0x1b, 4); 683 684 static SENSOR_DEVICE_ATTR_2_RO(temp1_fault, alarm, 0x17, 0); 685 static SENSOR_DEVICE_ATTR_2_RO(temp2_fault, alarm, 0x17, 1); 686 static SENSOR_DEVICE_ATTR_2_RO(temp3_fault, alarm, 0x17, 2); 687 688 static SENSOR_DEVICE_ATTR_2_RW(temp1_beep, beep, 0x5c, 0); 689 static SENSOR_DEVICE_ATTR_2_RW(temp2_beep, beep, 0x5c, 1); 690 static SENSOR_DEVICE_ATTR_2_RW(temp3_beep, beep, 0x5c, 2); 691 static SENSOR_DEVICE_ATTR_2_RW(temp4_beep, beep, 0x5c, 3); 692 static SENSOR_DEVICE_ATTR_2_RW(temp5_beep, beep, 0x5c, 4); 693 static SENSOR_DEVICE_ATTR_2_RW(temp6_beep, beep, 0x5c, 5); 694 695 static struct attribute *nct7802_temp_attrs[] = { 696 &sensor_dev_attr_temp1_type.dev_attr.attr, 697 &sensor_dev_attr_temp1_input.dev_attr.attr, 698 &sensor_dev_attr_temp1_min.dev_attr.attr, 699 &sensor_dev_attr_temp1_max.dev_attr.attr, 700 &sensor_dev_attr_temp1_crit.dev_attr.attr, 701 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 702 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 703 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 704 &sensor_dev_attr_temp1_fault.dev_attr.attr, 705 &sensor_dev_attr_temp1_beep.dev_attr.attr, 706 707 &sensor_dev_attr_temp2_type.dev_attr.attr, /* 10 */ 708 &sensor_dev_attr_temp2_input.dev_attr.attr, 709 &sensor_dev_attr_temp2_min.dev_attr.attr, 710 &sensor_dev_attr_temp2_max.dev_attr.attr, 711 &sensor_dev_attr_temp2_crit.dev_attr.attr, 712 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 713 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 714 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 715 &sensor_dev_attr_temp2_fault.dev_attr.attr, 716 &sensor_dev_attr_temp2_beep.dev_attr.attr, 717 718 &sensor_dev_attr_temp3_type.dev_attr.attr, /* 20 */ 719 &sensor_dev_attr_temp3_input.dev_attr.attr, 720 &sensor_dev_attr_temp3_min.dev_attr.attr, 721 &sensor_dev_attr_temp3_max.dev_attr.attr, 722 &sensor_dev_attr_temp3_crit.dev_attr.attr, 723 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 724 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 725 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 726 &sensor_dev_attr_temp3_fault.dev_attr.attr, 727 &sensor_dev_attr_temp3_beep.dev_attr.attr, 728 729 &sensor_dev_attr_temp4_input.dev_attr.attr, /* 30 */ 730 &sensor_dev_attr_temp4_min.dev_attr.attr, 731 &sensor_dev_attr_temp4_max.dev_attr.attr, 732 &sensor_dev_attr_temp4_crit.dev_attr.attr, 733 &sensor_dev_attr_temp4_min_alarm.dev_attr.attr, 734 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr, 735 &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr, 736 &sensor_dev_attr_temp4_beep.dev_attr.attr, 737 738 &sensor_dev_attr_temp5_input.dev_attr.attr, /* 38 */ 739 &sensor_dev_attr_temp5_min.dev_attr.attr, 740 &sensor_dev_attr_temp5_max.dev_attr.attr, 741 &sensor_dev_attr_temp5_crit.dev_attr.attr, 742 &sensor_dev_attr_temp5_min_alarm.dev_attr.attr, 743 &sensor_dev_attr_temp5_max_alarm.dev_attr.attr, 744 &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr, 745 &sensor_dev_attr_temp5_beep.dev_attr.attr, 746 747 &sensor_dev_attr_temp6_input.dev_attr.attr, /* 46 */ 748 &sensor_dev_attr_temp6_beep.dev_attr.attr, 749 750 NULL 751 }; 752 753 static umode_t nct7802_temp_is_visible(struct kobject *kobj, 754 struct attribute *attr, int index) 755 { 756 struct device *dev = kobj_to_dev(kobj); 757 struct nct7802_data *data = dev_get_drvdata(dev); 758 unsigned int reg; 759 int err; 760 761 err = regmap_read(data->regmap, REG_MODE, ®); 762 if (err < 0) 763 return 0; 764 765 if (index < 10 && 766 (reg & 03) != 0x01 && (reg & 0x03) != 0x02) /* RD1 */ 767 return 0; 768 769 if (index >= 10 && index < 20 && 770 (reg & 0x0c) != 0x04 && (reg & 0x0c) != 0x08) /* RD2 */ 771 return 0; 772 if (index >= 20 && index < 30 && (reg & 0x30) != 0x20) /* RD3 */ 773 return 0; 774 775 if (index >= 30 && index < 38) /* local */ 776 return attr->mode; 777 778 err = regmap_read(data->regmap, REG_PECI_ENABLE, ®); 779 if (err < 0) 780 return 0; 781 782 if (index >= 38 && index < 46 && !(reg & 0x01)) /* PECI 0 */ 783 return 0; 784 785 if (index >= 46 && !(reg & 0x02)) /* PECI 1 */ 786 return 0; 787 788 return attr->mode; 789 } 790 791 static const struct attribute_group nct7802_temp_group = { 792 .attrs = nct7802_temp_attrs, 793 .is_visible = nct7802_temp_is_visible, 794 }; 795 796 static SENSOR_DEVICE_ATTR_2_RO(in0_input, in, 0, 0); 797 static SENSOR_DEVICE_ATTR_2_RW(in0_min, in, 0, 1); 798 static SENSOR_DEVICE_ATTR_2_RW(in0_max, in, 0, 2); 799 static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, in_alarm, 0, 3); 800 static SENSOR_DEVICE_ATTR_2_RW(in0_beep, beep, 0x5a, 3); 801 802 static SENSOR_DEVICE_ATTR_2_RO(in1_input, in, 1, 0); 803 804 static SENSOR_DEVICE_ATTR_2_RO(in2_input, in, 2, 0); 805 static SENSOR_DEVICE_ATTR_2_RW(in2_min, in, 2, 1); 806 static SENSOR_DEVICE_ATTR_2_RW(in2_max, in, 2, 2); 807 static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, in_alarm, 2, 0); 808 static SENSOR_DEVICE_ATTR_2_RW(in2_beep, beep, 0x5a, 0); 809 810 static SENSOR_DEVICE_ATTR_2_RO(in3_input, in, 3, 0); 811 static SENSOR_DEVICE_ATTR_2_RW(in3_min, in, 3, 1); 812 static SENSOR_DEVICE_ATTR_2_RW(in3_max, in, 3, 2); 813 static SENSOR_DEVICE_ATTR_2_RO(in3_alarm, in_alarm, 3, 1); 814 static SENSOR_DEVICE_ATTR_2_RW(in3_beep, beep, 0x5a, 1); 815 816 static SENSOR_DEVICE_ATTR_2_RO(in4_input, in, 4, 0); 817 static SENSOR_DEVICE_ATTR_2_RW(in4_min, in, 4, 1); 818 static SENSOR_DEVICE_ATTR_2_RW(in4_max, in, 4, 2); 819 static SENSOR_DEVICE_ATTR_2_RO(in4_alarm, in_alarm, 4, 2); 820 static SENSOR_DEVICE_ATTR_2_RW(in4_beep, beep, 0x5a, 2); 821 822 static struct attribute *nct7802_in_attrs[] = { 823 &sensor_dev_attr_in0_input.dev_attr.attr, 824 &sensor_dev_attr_in0_min.dev_attr.attr, 825 &sensor_dev_attr_in0_max.dev_attr.attr, 826 &sensor_dev_attr_in0_alarm.dev_attr.attr, 827 &sensor_dev_attr_in0_beep.dev_attr.attr, 828 829 &sensor_dev_attr_in1_input.dev_attr.attr, /* 5 */ 830 831 &sensor_dev_attr_in2_input.dev_attr.attr, /* 6 */ 832 &sensor_dev_attr_in2_min.dev_attr.attr, 833 &sensor_dev_attr_in2_max.dev_attr.attr, 834 &sensor_dev_attr_in2_alarm.dev_attr.attr, 835 &sensor_dev_attr_in2_beep.dev_attr.attr, 836 837 &sensor_dev_attr_in3_input.dev_attr.attr, /* 11 */ 838 &sensor_dev_attr_in3_min.dev_attr.attr, 839 &sensor_dev_attr_in3_max.dev_attr.attr, 840 &sensor_dev_attr_in3_alarm.dev_attr.attr, 841 &sensor_dev_attr_in3_beep.dev_attr.attr, 842 843 &sensor_dev_attr_in4_input.dev_attr.attr, /* 16 */ 844 &sensor_dev_attr_in4_min.dev_attr.attr, 845 &sensor_dev_attr_in4_max.dev_attr.attr, 846 &sensor_dev_attr_in4_alarm.dev_attr.attr, 847 &sensor_dev_attr_in4_beep.dev_attr.attr, 848 849 NULL, 850 }; 851 852 static umode_t nct7802_in_is_visible(struct kobject *kobj, 853 struct attribute *attr, int index) 854 { 855 struct device *dev = kobj_to_dev(kobj); 856 struct nct7802_data *data = dev_get_drvdata(dev); 857 unsigned int reg; 858 int err; 859 860 if (index < 6) /* VCC, VCORE */ 861 return attr->mode; 862 863 err = regmap_read(data->regmap, REG_MODE, ®); 864 if (err < 0) 865 return 0; 866 867 if (index >= 6 && index < 11 && (reg & 0x03) != 0x03) /* VSEN1 */ 868 return 0; 869 if (index >= 11 && index < 16 && (reg & 0x0c) != 0x0c) /* VSEN2 */ 870 return 0; 871 if (index >= 16 && (reg & 0x30) != 0x30) /* VSEN3 */ 872 return 0; 873 874 return attr->mode; 875 } 876 877 static const struct attribute_group nct7802_in_group = { 878 .attrs = nct7802_in_attrs, 879 .is_visible = nct7802_in_is_visible, 880 }; 881 882 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0x10); 883 static SENSOR_DEVICE_ATTR_2_RW(fan1_min, fan_min, 0x49, 0x4c); 884 static SENSOR_DEVICE_ATTR_2_RO(fan1_alarm, alarm, 0x1a, 0); 885 static SENSOR_DEVICE_ATTR_2_RW(fan1_beep, beep, 0x5b, 0); 886 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 0x11); 887 static SENSOR_DEVICE_ATTR_2_RW(fan2_min, fan_min, 0x4a, 0x4d); 888 static SENSOR_DEVICE_ATTR_2_RO(fan2_alarm, alarm, 0x1a, 1); 889 static SENSOR_DEVICE_ATTR_2_RW(fan2_beep, beep, 0x5b, 1); 890 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 0x12); 891 static SENSOR_DEVICE_ATTR_2_RW(fan3_min, fan_min, 0x4b, 0x4e); 892 static SENSOR_DEVICE_ATTR_2_RO(fan3_alarm, alarm, 0x1a, 2); 893 static SENSOR_DEVICE_ATTR_2_RW(fan3_beep, beep, 0x5b, 2); 894 895 /* 7.2.89 Fan Control Output Type */ 896 static SENSOR_DEVICE_ATTR_RO(pwm1_mode, pwm_mode, 0); 897 static SENSOR_DEVICE_ATTR_RO(pwm2_mode, pwm_mode, 1); 898 static SENSOR_DEVICE_ATTR_RO(pwm3_mode, pwm_mode, 2); 899 900 /* 7.2.91... Fan Control Output Value */ 901 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, REG_PWM(0)); 902 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, REG_PWM(1)); 903 static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, REG_PWM(2)); 904 905 /* 7.2.95... Temperature to Fan mapping Relationships Register */ 906 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_enable, 0); 907 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_enable, 1); 908 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_enable, 2); 909 910 static struct attribute *nct7802_fan_attrs[] = { 911 &sensor_dev_attr_fan1_input.dev_attr.attr, 912 &sensor_dev_attr_fan1_min.dev_attr.attr, 913 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 914 &sensor_dev_attr_fan1_beep.dev_attr.attr, 915 &sensor_dev_attr_fan2_input.dev_attr.attr, 916 &sensor_dev_attr_fan2_min.dev_attr.attr, 917 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 918 &sensor_dev_attr_fan2_beep.dev_attr.attr, 919 &sensor_dev_attr_fan3_input.dev_attr.attr, 920 &sensor_dev_attr_fan3_min.dev_attr.attr, 921 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 922 &sensor_dev_attr_fan3_beep.dev_attr.attr, 923 924 NULL 925 }; 926 927 static umode_t nct7802_fan_is_visible(struct kobject *kobj, 928 struct attribute *attr, int index) 929 { 930 struct device *dev = kobj_to_dev(kobj); 931 struct nct7802_data *data = dev_get_drvdata(dev); 932 int fan = index / 4; /* 4 attributes per fan */ 933 unsigned int reg; 934 int err; 935 936 err = regmap_read(data->regmap, REG_FAN_ENABLE, ®); 937 if (err < 0 || !(reg & (1 << fan))) 938 return 0; 939 940 return attr->mode; 941 } 942 943 static const struct attribute_group nct7802_fan_group = { 944 .attrs = nct7802_fan_attrs, 945 .is_visible = nct7802_fan_is_visible, 946 }; 947 948 static struct attribute *nct7802_pwm_attrs[] = { 949 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 950 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 951 &sensor_dev_attr_pwm1.dev_attr.attr, 952 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 953 &sensor_dev_attr_pwm2_mode.dev_attr.attr, 954 &sensor_dev_attr_pwm2.dev_attr.attr, 955 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 956 &sensor_dev_attr_pwm3_mode.dev_attr.attr, 957 &sensor_dev_attr_pwm3.dev_attr.attr, 958 NULL 959 }; 960 961 static const struct attribute_group nct7802_pwm_group = { 962 .attrs = nct7802_pwm_attrs, 963 }; 964 965 /* 7.2.115... 0x80-0x83, 0x84 Temperature (X-axis) transition */ 966 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_temp, temp, 0x80, 0); 967 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_temp, temp, 0x81, 0); 968 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_temp, temp, 0x82, 0); 969 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_temp, temp, 0x83, 0); 970 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_temp, temp, 0x84, 0); 971 972 /* 7.2.120... 0x85-0x88 PWM (Y-axis) transition */ 973 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm, 0x85); 974 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm, 0x86); 975 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point3_pwm, pwm, 0x87); 976 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point4_pwm, pwm, 0x88); 977 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point5_pwm, pwm, 0); 978 979 /* 7.2.124 Table 2 X-axis Transition Point 1 Register */ 980 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_temp, temp, 0x90, 0); 981 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_temp, temp, 0x91, 0); 982 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_temp, temp, 0x92, 0); 983 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_temp, temp, 0x93, 0); 984 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_temp, temp, 0x94, 0); 985 986 /* 7.2.129 Table 2 Y-axis Transition Point 1 Register */ 987 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm, 0x95); 988 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm, 0x96); 989 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point3_pwm, pwm, 0x97); 990 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point4_pwm, pwm, 0x98); 991 static SENSOR_DEVICE_ATTR_RO(pwm2_auto_point5_pwm, pwm, 0); 992 993 /* 7.2.133 Table 3 X-axis Transition Point 1 Register */ 994 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_temp, temp, 0xA0, 0); 995 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_temp, temp, 0xA1, 0); 996 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point3_temp, temp, 0xA2, 0); 997 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point4_temp, temp, 0xA3, 0); 998 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point5_temp, temp, 0xA4, 0); 999 1000 /* 7.2.138 Table 3 Y-axis Transition Point 1 Register */ 1001 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm, 0xA5); 1002 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm, 0xA6); 1003 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point3_pwm, pwm, 0xA7); 1004 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point4_pwm, pwm, 0xA8); 1005 static SENSOR_DEVICE_ATTR_RO(pwm3_auto_point5_pwm, pwm, 0); 1006 1007 static struct attribute *nct7802_auto_point_attrs[] = { 1008 &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr, 1009 &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr, 1010 &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr, 1011 &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr, 1012 &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr, 1013 1014 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 1015 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 1016 &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr, 1017 &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr, 1018 &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr, 1019 1020 &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr, 1021 &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr, 1022 &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr, 1023 &sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr, 1024 &sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr, 1025 1026 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 1027 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 1028 &sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr, 1029 &sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr, 1030 &sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr, 1031 1032 &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr, 1033 &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr, 1034 &sensor_dev_attr_pwm3_auto_point3_temp.dev_attr.attr, 1035 &sensor_dev_attr_pwm3_auto_point4_temp.dev_attr.attr, 1036 &sensor_dev_attr_pwm3_auto_point5_temp.dev_attr.attr, 1037 1038 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 1039 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr, 1040 &sensor_dev_attr_pwm3_auto_point3_pwm.dev_attr.attr, 1041 &sensor_dev_attr_pwm3_auto_point4_pwm.dev_attr.attr, 1042 &sensor_dev_attr_pwm3_auto_point5_pwm.dev_attr.attr, 1043 1044 NULL 1045 }; 1046 1047 static const struct attribute_group nct7802_auto_point_group = { 1048 .attrs = nct7802_auto_point_attrs, 1049 }; 1050 1051 /* 7.2.102 0x6E FANCTL Step Up Time Register */ 1052 static SENSOR_DEVICE_ATTR_RW(step_up_time, step_up_time, 0); 1053 1054 /* 7.2.103 0x6F FANCTL Step Down Time Register */ 1055 static SENSOR_DEVICE_ATTR_RW(step_down_time, step_down_time, 0); 1056 1057 static struct attribute *nct7802_step_time_attrs[] = { 1058 &sensor_dev_attr_step_up_time.dev_attr.attr, 1059 &sensor_dev_attr_step_down_time.dev_attr.attr, 1060 1061 NULL 1062 }; 1063 1064 static const struct attribute_group nct7802_step_time_group = { 1065 .attrs = nct7802_step_time_attrs, 1066 }; 1067 1068 static const struct attribute_group *nct7802_groups[] = { 1069 &nct7802_temp_group, 1070 &nct7802_in_group, 1071 &nct7802_fan_group, 1072 &nct7802_pwm_group, 1073 &nct7802_auto_point_group, 1074 &nct7802_step_time_group, 1075 NULL 1076 }; 1077 1078 static int nct7802_detect(struct i2c_client *client, 1079 struct i2c_board_info *info) 1080 { 1081 int reg; 1082 1083 /* 1084 * Chip identification registers are only available in bank 0, 1085 * so only attempt chip detection if bank 0 is selected 1086 */ 1087 reg = i2c_smbus_read_byte_data(client, REG_BANK); 1088 if (reg != 0x00) 1089 return -ENODEV; 1090 1091 reg = i2c_smbus_read_byte_data(client, REG_VENDOR_ID); 1092 if (reg != 0x50) 1093 return -ENODEV; 1094 1095 reg = i2c_smbus_read_byte_data(client, REG_CHIP_ID); 1096 if (reg != 0xc3) 1097 return -ENODEV; 1098 1099 reg = i2c_smbus_read_byte_data(client, REG_VERSION_ID); 1100 if (reg < 0 || (reg & 0xf0) != 0x20) 1101 return -ENODEV; 1102 1103 /* Also validate lower bits of voltage and temperature registers */ 1104 reg = i2c_smbus_read_byte_data(client, REG_TEMP_LSB); 1105 if (reg < 0 || (reg & 0x1f)) 1106 return -ENODEV; 1107 1108 reg = i2c_smbus_read_byte_data(client, REG_TEMP_PECI_LSB); 1109 if (reg < 0 || (reg & 0x3f)) 1110 return -ENODEV; 1111 1112 reg = i2c_smbus_read_byte_data(client, REG_VOLTAGE_LOW); 1113 if (reg < 0 || (reg & 0x3f)) 1114 return -ENODEV; 1115 1116 strscpy(info->type, "nct7802", I2C_NAME_SIZE); 1117 return 0; 1118 } 1119 1120 static bool nct7802_regmap_is_volatile(struct device *dev, unsigned int reg) 1121 { 1122 return (reg != REG_BANK && reg <= 0x20) || 1123 (reg >= REG_PWM(0) && reg <= REG_PWM(2)); 1124 } 1125 1126 static const struct regmap_config nct7802_regmap_config = { 1127 .reg_bits = 8, 1128 .val_bits = 8, 1129 .cache_type = REGCACHE_MAPLE, 1130 .volatile_reg = nct7802_regmap_is_volatile, 1131 }; 1132 1133 static int nct7802_get_channel_config(struct device *dev, 1134 struct device_node *node, u8 *mode_mask, 1135 u8 *mode_val) 1136 { 1137 u32 reg; 1138 const char *type_str, *md_str; 1139 u8 md; 1140 1141 if (!node->name || of_node_cmp(node->name, "channel")) 1142 return 0; 1143 1144 if (of_property_read_u32(node, "reg", ®)) { 1145 dev_err(dev, "Could not read reg value for '%s'\n", 1146 node->full_name); 1147 return -EINVAL; 1148 } 1149 1150 if (reg > 3) { 1151 dev_err(dev, "Invalid reg (%u) in '%s'\n", reg, 1152 node->full_name); 1153 return -EINVAL; 1154 } 1155 1156 if (reg == 0) { 1157 if (!of_device_is_available(node)) 1158 *mode_val &= ~MODE_LTD_EN; 1159 else 1160 *mode_val |= MODE_LTD_EN; 1161 *mode_mask |= MODE_LTD_EN; 1162 return 0; 1163 } 1164 1165 /* At this point we have reg >= 1 && reg <= 3 */ 1166 1167 if (!of_device_is_available(node)) { 1168 *mode_val &= ~(MODE_RTD_MASK << MODE_BIT_OFFSET_RTD(reg - 1)); 1169 *mode_mask |= MODE_RTD_MASK << MODE_BIT_OFFSET_RTD(reg - 1); 1170 return 0; 1171 } 1172 1173 if (of_property_read_string(node, "sensor-type", &type_str)) { 1174 dev_err(dev, "No type for '%s'\n", node->full_name); 1175 return -EINVAL; 1176 } 1177 1178 if (!strcmp(type_str, "voltage")) { 1179 *mode_val |= (RTD_MODE_VOLTAGE & MODE_RTD_MASK) 1180 << MODE_BIT_OFFSET_RTD(reg - 1); 1181 *mode_mask |= MODE_RTD_MASK << MODE_BIT_OFFSET_RTD(reg - 1); 1182 return 0; 1183 } 1184 1185 if (strcmp(type_str, "temperature")) { 1186 dev_err(dev, "Invalid type '%s' for '%s'\n", type_str, 1187 node->full_name); 1188 return -EINVAL; 1189 } 1190 1191 if (reg == 3) { 1192 /* RTD3 only supports thermistor mode */ 1193 md = RTD_MODE_THERMISTOR; 1194 } else { 1195 if (of_property_read_string(node, "temperature-mode", 1196 &md_str)) { 1197 dev_err(dev, "No mode for '%s'\n", node->full_name); 1198 return -EINVAL; 1199 } 1200 1201 if (!strcmp(md_str, "thermal-diode")) 1202 md = RTD_MODE_CURRENT; 1203 else if (!strcmp(md_str, "thermistor")) 1204 md = RTD_MODE_THERMISTOR; 1205 else { 1206 dev_err(dev, "Invalid mode '%s' for '%s'\n", md_str, 1207 node->full_name); 1208 return -EINVAL; 1209 } 1210 } 1211 1212 *mode_val |= (md & MODE_RTD_MASK) << MODE_BIT_OFFSET_RTD(reg - 1); 1213 *mode_mask |= MODE_RTD_MASK << MODE_BIT_OFFSET_RTD(reg - 1); 1214 1215 return 0; 1216 } 1217 1218 static int nct7802_configure_channels(struct device *dev, 1219 struct nct7802_data *data) 1220 { 1221 /* Enable local temperature sensor by default */ 1222 u8 mode_mask = MODE_LTD_EN, mode_val = MODE_LTD_EN; 1223 int err; 1224 1225 if (dev->of_node) { 1226 for_each_child_of_node_scoped(dev->of_node, node) { 1227 err = nct7802_get_channel_config(dev, node, &mode_mask, 1228 &mode_val); 1229 if (err) 1230 return err; 1231 } 1232 } 1233 1234 return regmap_update_bits(data->regmap, REG_MODE, mode_mask, mode_val); 1235 } 1236 1237 static int nct7802_init_chip(struct device *dev, struct nct7802_data *data) 1238 { 1239 int err; 1240 1241 /* Enable ADC */ 1242 err = regmap_update_bits(data->regmap, REG_START, 0x01, 0x01); 1243 if (err) 1244 return err; 1245 1246 err = nct7802_configure_channels(dev, data); 1247 if (err) 1248 return err; 1249 1250 /* Enable Vcore and VCC voltage monitoring */ 1251 return regmap_update_bits(data->regmap, REG_VMON_ENABLE, 0x03, 0x03); 1252 } 1253 1254 static int nct7802_probe(struct i2c_client *client) 1255 { 1256 struct device *dev = &client->dev; 1257 struct nct7802_data *data; 1258 struct device *hwmon_dev; 1259 int ret; 1260 1261 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 1262 if (data == NULL) 1263 return -ENOMEM; 1264 1265 data->regmap = devm_regmap_init_i2c(client, &nct7802_regmap_config); 1266 if (IS_ERR(data->regmap)) 1267 return PTR_ERR(data->regmap); 1268 1269 mutex_init(&data->access_lock); 1270 mutex_init(&data->in_alarm_lock); 1271 1272 ret = nct7802_init_chip(dev, data); 1273 if (ret < 0) 1274 return ret; 1275 1276 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 1277 data, 1278 nct7802_groups); 1279 return PTR_ERR_OR_ZERO(hwmon_dev); 1280 } 1281 1282 static const unsigned short nct7802_address_list[] = { 1283 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END 1284 }; 1285 1286 static const struct i2c_device_id nct7802_idtable[] = { 1287 { .name = "nct7802" }, 1288 { } 1289 }; 1290 MODULE_DEVICE_TABLE(i2c, nct7802_idtable); 1291 1292 static struct i2c_driver nct7802_driver = { 1293 .class = I2C_CLASS_HWMON, 1294 .driver = { 1295 .name = DRVNAME, 1296 }, 1297 .detect = nct7802_detect, 1298 .probe = nct7802_probe, 1299 .id_table = nct7802_idtable, 1300 .address_list = nct7802_address_list, 1301 }; 1302 1303 module_i2c_driver(nct7802_driver); 1304 1305 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>"); 1306 MODULE_DESCRIPTION("NCT7802Y Hardware Monitoring Driver"); 1307 MODULE_LICENSE("GPL v2"); 1308