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 { 0x40, 0x00, 0x42, 0x44, 0x46 }, 27 { 0x3f, 0x00, 0x41, 0x43, 0x45 }, 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_VENDOR_ID 0xfd 51 #define REG_CHIP_ID 0xfe 52 #define REG_VERSION_ID 0xff 53 54 /* 55 * Data structures and manipulation thereof 56 */ 57 58 struct nct7802_data { 59 struct regmap *regmap; 60 struct mutex access_lock; /* for multi-byte read and write operations */ 61 }; 62 63 static ssize_t temp_type_show(struct device *dev, 64 struct device_attribute *attr, char *buf) 65 { 66 struct nct7802_data *data = dev_get_drvdata(dev); 67 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 68 unsigned int mode; 69 int ret; 70 71 ret = regmap_read(data->regmap, REG_MODE, &mode); 72 if (ret < 0) 73 return ret; 74 75 return sprintf(buf, "%u\n", (mode >> (2 * sattr->index) & 3) + 2); 76 } 77 78 static ssize_t temp_type_store(struct device *dev, 79 struct device_attribute *attr, const char *buf, 80 size_t count) 81 { 82 struct nct7802_data *data = dev_get_drvdata(dev); 83 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 84 unsigned int type; 85 int err; 86 87 err = kstrtouint(buf, 0, &type); 88 if (err < 0) 89 return err; 90 if (sattr->index == 2 && type != 4) /* RD3 */ 91 return -EINVAL; 92 if (type < 3 || type > 4) 93 return -EINVAL; 94 err = regmap_update_bits(data->regmap, REG_MODE, 95 3 << 2 * sattr->index, (type - 2) << 2 * sattr->index); 96 return err ? : count; 97 } 98 99 static ssize_t pwm_mode_show(struct device *dev, 100 struct device_attribute *attr, char *buf) 101 { 102 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 103 struct nct7802_data *data = dev_get_drvdata(dev); 104 unsigned int regval; 105 int ret; 106 107 if (sattr->index > 1) 108 return sprintf(buf, "1\n"); 109 110 ret = regmap_read(data->regmap, 0x5E, ®val); 111 if (ret < 0) 112 return ret; 113 114 return sprintf(buf, "%u\n", !(regval & (1 << sattr->index))); 115 } 116 117 static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr, 118 char *buf) 119 { 120 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 121 struct nct7802_data *data = dev_get_drvdata(dev); 122 unsigned int val; 123 int ret; 124 125 if (!attr->index) 126 return sprintf(buf, "255\n"); 127 128 ret = regmap_read(data->regmap, attr->index, &val); 129 if (ret < 0) 130 return ret; 131 132 return sprintf(buf, "%d\n", val); 133 } 134 135 static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr, 136 const char *buf, size_t count) 137 { 138 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 139 struct nct7802_data *data = dev_get_drvdata(dev); 140 int err; 141 u8 val; 142 143 err = kstrtou8(buf, 0, &val); 144 if (err < 0) 145 return err; 146 147 err = regmap_write(data->regmap, attr->index, val); 148 return err ? : count; 149 } 150 151 static ssize_t pwm_enable_show(struct device *dev, 152 struct device_attribute *attr, char *buf) 153 { 154 struct nct7802_data *data = dev_get_drvdata(dev); 155 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 156 unsigned int reg, enabled; 157 int ret; 158 159 ret = regmap_read(data->regmap, REG_SMARTFAN_EN(sattr->index), ®); 160 if (ret < 0) 161 return ret; 162 enabled = reg >> SMARTFAN_EN_SHIFT(sattr->index) & 1; 163 return sprintf(buf, "%u\n", enabled + 1); 164 } 165 166 static ssize_t pwm_enable_store(struct device *dev, 167 struct device_attribute *attr, 168 const char *buf, size_t count) 169 { 170 struct nct7802_data *data = dev_get_drvdata(dev); 171 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 172 u8 val; 173 int ret; 174 175 ret = kstrtou8(buf, 0, &val); 176 if (ret < 0) 177 return ret; 178 if (val < 1 || val > 2) 179 return -EINVAL; 180 ret = regmap_update_bits(data->regmap, REG_SMARTFAN_EN(sattr->index), 181 1 << SMARTFAN_EN_SHIFT(sattr->index), 182 (val - 1) << SMARTFAN_EN_SHIFT(sattr->index)); 183 return ret ? : count; 184 } 185 186 static int nct7802_read_temp(struct nct7802_data *data, 187 u8 reg_temp, u8 reg_temp_low, int *temp) 188 { 189 unsigned int t1, t2 = 0; 190 int err; 191 192 *temp = 0; 193 194 mutex_lock(&data->access_lock); 195 err = regmap_read(data->regmap, reg_temp, &t1); 196 if (err < 0) 197 goto abort; 198 t1 <<= 8; 199 if (reg_temp_low) { /* 11 bit data */ 200 err = regmap_read(data->regmap, reg_temp_low, &t2); 201 if (err < 0) 202 goto abort; 203 } 204 t1 |= t2 & 0xe0; 205 *temp = (s16)t1 / 32 * 125; 206 abort: 207 mutex_unlock(&data->access_lock); 208 return err; 209 } 210 211 static int nct7802_read_fan(struct nct7802_data *data, u8 reg_fan) 212 { 213 unsigned int f1, f2; 214 int ret; 215 216 mutex_lock(&data->access_lock); 217 ret = regmap_read(data->regmap, reg_fan, &f1); 218 if (ret < 0) 219 goto abort; 220 ret = regmap_read(data->regmap, REG_FANCOUNT_LOW, &f2); 221 if (ret < 0) 222 goto abort; 223 ret = (f1 << 5) | (f2 >> 3); 224 /* convert fan count to rpm */ 225 if (ret == 0x1fff) /* maximum value, assume fan is stopped */ 226 ret = 0; 227 else if (ret) 228 ret = DIV_ROUND_CLOSEST(1350000U, ret); 229 abort: 230 mutex_unlock(&data->access_lock); 231 return ret; 232 } 233 234 static int nct7802_read_fan_min(struct nct7802_data *data, u8 reg_fan_low, 235 u8 reg_fan_high) 236 { 237 unsigned int f1, f2; 238 int ret; 239 240 mutex_lock(&data->access_lock); 241 ret = regmap_read(data->regmap, reg_fan_low, &f1); 242 if (ret < 0) 243 goto abort; 244 ret = regmap_read(data->regmap, reg_fan_high, &f2); 245 if (ret < 0) 246 goto abort; 247 ret = f1 | ((f2 & 0xf8) << 5); 248 /* convert fan count to rpm */ 249 if (ret == 0x1fff) /* maximum value, assume no limit */ 250 ret = 0; 251 else if (ret) 252 ret = DIV_ROUND_CLOSEST(1350000U, ret); 253 else 254 ret = 1350000U; 255 abort: 256 mutex_unlock(&data->access_lock); 257 return ret; 258 } 259 260 static int nct7802_write_fan_min(struct nct7802_data *data, u8 reg_fan_low, 261 u8 reg_fan_high, unsigned long limit) 262 { 263 int err; 264 265 if (limit) 266 limit = DIV_ROUND_CLOSEST(1350000U, limit); 267 else 268 limit = 0x1fff; 269 limit = clamp_val(limit, 0, 0x1fff); 270 271 mutex_lock(&data->access_lock); 272 err = regmap_write(data->regmap, reg_fan_low, limit & 0xff); 273 if (err < 0) 274 goto abort; 275 276 err = regmap_write(data->regmap, reg_fan_high, (limit & 0x1f00) >> 5); 277 abort: 278 mutex_unlock(&data->access_lock); 279 return err; 280 } 281 282 static u8 nct7802_vmul[] = { 4, 2, 2, 2, 2 }; 283 284 static int nct7802_read_voltage(struct nct7802_data *data, int nr, int index) 285 { 286 unsigned int v1, v2; 287 int ret; 288 289 mutex_lock(&data->access_lock); 290 if (index == 0) { /* voltage */ 291 ret = regmap_read(data->regmap, REG_VOLTAGE[nr], &v1); 292 if (ret < 0) 293 goto abort; 294 ret = regmap_read(data->regmap, REG_VOLTAGE_LOW, &v2); 295 if (ret < 0) 296 goto abort; 297 ret = ((v1 << 2) | (v2 >> 6)) * nct7802_vmul[nr]; 298 } else { /* limit */ 299 int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr]; 300 301 ret = regmap_read(data->regmap, 302 REG_VOLTAGE_LIMIT_LSB[index - 1][nr], &v1); 303 if (ret < 0) 304 goto abort; 305 ret = regmap_read(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr], 306 &v2); 307 if (ret < 0) 308 goto abort; 309 ret = (v1 | ((v2 << shift) & 0x300)) * nct7802_vmul[nr]; 310 } 311 abort: 312 mutex_unlock(&data->access_lock); 313 return ret; 314 } 315 316 static int nct7802_write_voltage(struct nct7802_data *data, int nr, int index, 317 unsigned long voltage) 318 { 319 int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr]; 320 int err; 321 322 voltage = clamp_val(voltage, 0, 0x3ff * nct7802_vmul[nr]); 323 voltage = DIV_ROUND_CLOSEST(voltage, nct7802_vmul[nr]); 324 325 mutex_lock(&data->access_lock); 326 err = regmap_write(data->regmap, 327 REG_VOLTAGE_LIMIT_LSB[index - 1][nr], 328 voltage & 0xff); 329 if (err < 0) 330 goto abort; 331 332 err = regmap_update_bits(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr], 333 0x0300 >> shift, (voltage & 0x0300) >> shift); 334 abort: 335 mutex_unlock(&data->access_lock); 336 return err; 337 } 338 339 static ssize_t in_show(struct device *dev, struct device_attribute *attr, 340 char *buf) 341 { 342 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 343 struct nct7802_data *data = dev_get_drvdata(dev); 344 int voltage; 345 346 voltage = nct7802_read_voltage(data, sattr->nr, sattr->index); 347 if (voltage < 0) 348 return voltage; 349 350 return sprintf(buf, "%d\n", voltage); 351 } 352 353 static ssize_t in_store(struct device *dev, struct device_attribute *attr, 354 const char *buf, size_t count) 355 { 356 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 357 struct nct7802_data *data = dev_get_drvdata(dev); 358 int index = sattr->index; 359 int nr = sattr->nr; 360 unsigned long val; 361 int err; 362 363 err = kstrtoul(buf, 10, &val); 364 if (err < 0) 365 return err; 366 367 err = nct7802_write_voltage(data, nr, index, val); 368 return err ? : count; 369 } 370 371 static ssize_t temp_show(struct device *dev, struct device_attribute *attr, 372 char *buf) 373 { 374 struct nct7802_data *data = dev_get_drvdata(dev); 375 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 376 int err, temp; 377 378 err = nct7802_read_temp(data, sattr->nr, sattr->index, &temp); 379 if (err < 0) 380 return err; 381 382 return sprintf(buf, "%d\n", temp); 383 } 384 385 static ssize_t temp_store(struct device *dev, struct device_attribute *attr, 386 const char *buf, size_t count) 387 { 388 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 389 struct nct7802_data *data = dev_get_drvdata(dev); 390 int nr = sattr->nr; 391 long val; 392 int err; 393 394 err = kstrtol(buf, 10, &val); 395 if (err < 0) 396 return err; 397 398 val = DIV_ROUND_CLOSEST(clamp_val(val, -128000, 127000), 1000); 399 400 err = regmap_write(data->regmap, nr, val & 0xff); 401 return err ? : count; 402 } 403 404 static ssize_t fan_show(struct device *dev, struct device_attribute *attr, 405 char *buf) 406 { 407 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 408 struct nct7802_data *data = dev_get_drvdata(dev); 409 int speed; 410 411 speed = nct7802_read_fan(data, sattr->index); 412 if (speed < 0) 413 return speed; 414 415 return sprintf(buf, "%d\n", speed); 416 } 417 418 static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr, 419 char *buf) 420 { 421 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 422 struct nct7802_data *data = dev_get_drvdata(dev); 423 int speed; 424 425 speed = nct7802_read_fan_min(data, sattr->nr, sattr->index); 426 if (speed < 0) 427 return speed; 428 429 return sprintf(buf, "%d\n", speed); 430 } 431 432 static ssize_t fan_min_store(struct device *dev, 433 struct device_attribute *attr, const char *buf, 434 size_t count) 435 { 436 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 437 struct nct7802_data *data = dev_get_drvdata(dev); 438 unsigned long val; 439 int err; 440 441 err = kstrtoul(buf, 10, &val); 442 if (err < 0) 443 return err; 444 445 err = nct7802_write_fan_min(data, sattr->nr, sattr->index, val); 446 return err ? : count; 447 } 448 449 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr, 450 char *buf) 451 { 452 struct nct7802_data *data = dev_get_drvdata(dev); 453 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 454 int bit = sattr->index; 455 unsigned int val; 456 int ret; 457 458 ret = regmap_read(data->regmap, sattr->nr, &val); 459 if (ret < 0) 460 return ret; 461 462 return sprintf(buf, "%u\n", !!(val & (1 << bit))); 463 } 464 465 static ssize_t 466 beep_show(struct device *dev, struct device_attribute *attr, char *buf) 467 { 468 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 469 struct nct7802_data *data = dev_get_drvdata(dev); 470 unsigned int regval; 471 int err; 472 473 err = regmap_read(data->regmap, sattr->nr, ®val); 474 if (err) 475 return err; 476 477 return sprintf(buf, "%u\n", !!(regval & (1 << sattr->index))); 478 } 479 480 static ssize_t 481 beep_store(struct device *dev, struct device_attribute *attr, const char *buf, 482 size_t count) 483 { 484 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 485 struct nct7802_data *data = dev_get_drvdata(dev); 486 unsigned long val; 487 int err; 488 489 err = kstrtoul(buf, 10, &val); 490 if (err < 0) 491 return err; 492 if (val > 1) 493 return -EINVAL; 494 495 err = regmap_update_bits(data->regmap, sattr->nr, 1 << sattr->index, 496 val ? 1 << sattr->index : 0); 497 return err ? : count; 498 } 499 500 static SENSOR_DEVICE_ATTR_RW(temp1_type, temp_type, 0); 501 static SENSOR_DEVICE_ATTR_2_RO(temp1_input, temp, 0x01, REG_TEMP_LSB); 502 static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, 0x31, 0); 503 static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, 0x30, 0); 504 static SENSOR_DEVICE_ATTR_2_RW(temp1_crit, temp, 0x3a, 0); 505 506 static SENSOR_DEVICE_ATTR_RW(temp2_type, temp_type, 1); 507 static SENSOR_DEVICE_ATTR_2_RO(temp2_input, temp, 0x02, REG_TEMP_LSB); 508 static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, 0x33, 0); 509 static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, 0x32, 0); 510 static SENSOR_DEVICE_ATTR_2_RW(temp2_crit, temp, 0x3b, 0); 511 512 static SENSOR_DEVICE_ATTR_RW(temp3_type, temp_type, 2); 513 static SENSOR_DEVICE_ATTR_2_RO(temp3_input, temp, 0x03, REG_TEMP_LSB); 514 static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, 0x35, 0); 515 static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, 0x34, 0); 516 static SENSOR_DEVICE_ATTR_2_RW(temp3_crit, temp, 0x3c, 0); 517 518 static SENSOR_DEVICE_ATTR_2_RO(temp4_input, temp, 0x04, 0); 519 static SENSOR_DEVICE_ATTR_2_RW(temp4_min, temp, 0x37, 0); 520 static SENSOR_DEVICE_ATTR_2_RW(temp4_max, temp, 0x36, 0); 521 static SENSOR_DEVICE_ATTR_2_RW(temp4_crit, temp, 0x3d, 0); 522 523 static SENSOR_DEVICE_ATTR_2_RO(temp5_input, temp, 0x06, REG_TEMP_PECI_LSB); 524 static SENSOR_DEVICE_ATTR_2_RW(temp5_min, temp, 0x39, 0); 525 static SENSOR_DEVICE_ATTR_2_RW(temp5_max, temp, 0x38, 0); 526 static SENSOR_DEVICE_ATTR_2_RW(temp5_crit, temp, 0x3e, 0); 527 528 static SENSOR_DEVICE_ATTR_2_RO(temp6_input, temp, 0x07, REG_TEMP_PECI_LSB); 529 530 static SENSOR_DEVICE_ATTR_2_RO(temp1_min_alarm, alarm, 0x18, 0); 531 static SENSOR_DEVICE_ATTR_2_RO(temp2_min_alarm, alarm, 0x18, 1); 532 static SENSOR_DEVICE_ATTR_2_RO(temp3_min_alarm, alarm, 0x18, 2); 533 static SENSOR_DEVICE_ATTR_2_RO(temp4_min_alarm, alarm, 0x18, 3); 534 static SENSOR_DEVICE_ATTR_2_RO(temp5_min_alarm, alarm, 0x18, 4); 535 536 static SENSOR_DEVICE_ATTR_2_RO(temp1_max_alarm, alarm, 0x19, 0); 537 static SENSOR_DEVICE_ATTR_2_RO(temp2_max_alarm, alarm, 0x19, 1); 538 static SENSOR_DEVICE_ATTR_2_RO(temp3_max_alarm, alarm, 0x19, 2); 539 static SENSOR_DEVICE_ATTR_2_RO(temp4_max_alarm, alarm, 0x19, 3); 540 static SENSOR_DEVICE_ATTR_2_RO(temp5_max_alarm, alarm, 0x19, 4); 541 542 static SENSOR_DEVICE_ATTR_2_RO(temp1_crit_alarm, alarm, 0x1b, 0); 543 static SENSOR_DEVICE_ATTR_2_RO(temp2_crit_alarm, alarm, 0x1b, 1); 544 static SENSOR_DEVICE_ATTR_2_RO(temp3_crit_alarm, alarm, 0x1b, 2); 545 static SENSOR_DEVICE_ATTR_2_RO(temp4_crit_alarm, alarm, 0x1b, 3); 546 static SENSOR_DEVICE_ATTR_2_RO(temp5_crit_alarm, alarm, 0x1b, 4); 547 548 static SENSOR_DEVICE_ATTR_2_RO(temp1_fault, alarm, 0x17, 0); 549 static SENSOR_DEVICE_ATTR_2_RO(temp2_fault, alarm, 0x17, 1); 550 static SENSOR_DEVICE_ATTR_2_RO(temp3_fault, alarm, 0x17, 2); 551 552 static SENSOR_DEVICE_ATTR_2_RW(temp1_beep, beep, 0x5c, 0); 553 static SENSOR_DEVICE_ATTR_2_RW(temp2_beep, beep, 0x5c, 1); 554 static SENSOR_DEVICE_ATTR_2_RW(temp3_beep, beep, 0x5c, 2); 555 static SENSOR_DEVICE_ATTR_2_RW(temp4_beep, beep, 0x5c, 3); 556 static SENSOR_DEVICE_ATTR_2_RW(temp5_beep, beep, 0x5c, 4); 557 static SENSOR_DEVICE_ATTR_2_RW(temp6_beep, beep, 0x5c, 5); 558 559 static struct attribute *nct7802_temp_attrs[] = { 560 &sensor_dev_attr_temp1_type.dev_attr.attr, 561 &sensor_dev_attr_temp1_input.dev_attr.attr, 562 &sensor_dev_attr_temp1_min.dev_attr.attr, 563 &sensor_dev_attr_temp1_max.dev_attr.attr, 564 &sensor_dev_attr_temp1_crit.dev_attr.attr, 565 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 566 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 567 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 568 &sensor_dev_attr_temp1_fault.dev_attr.attr, 569 &sensor_dev_attr_temp1_beep.dev_attr.attr, 570 571 &sensor_dev_attr_temp2_type.dev_attr.attr, /* 10 */ 572 &sensor_dev_attr_temp2_input.dev_attr.attr, 573 &sensor_dev_attr_temp2_min.dev_attr.attr, 574 &sensor_dev_attr_temp2_max.dev_attr.attr, 575 &sensor_dev_attr_temp2_crit.dev_attr.attr, 576 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 577 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 578 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 579 &sensor_dev_attr_temp2_fault.dev_attr.attr, 580 &sensor_dev_attr_temp2_beep.dev_attr.attr, 581 582 &sensor_dev_attr_temp3_type.dev_attr.attr, /* 20 */ 583 &sensor_dev_attr_temp3_input.dev_attr.attr, 584 &sensor_dev_attr_temp3_min.dev_attr.attr, 585 &sensor_dev_attr_temp3_max.dev_attr.attr, 586 &sensor_dev_attr_temp3_crit.dev_attr.attr, 587 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 588 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 589 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 590 &sensor_dev_attr_temp3_fault.dev_attr.attr, 591 &sensor_dev_attr_temp3_beep.dev_attr.attr, 592 593 &sensor_dev_attr_temp4_input.dev_attr.attr, /* 30 */ 594 &sensor_dev_attr_temp4_min.dev_attr.attr, 595 &sensor_dev_attr_temp4_max.dev_attr.attr, 596 &sensor_dev_attr_temp4_crit.dev_attr.attr, 597 &sensor_dev_attr_temp4_min_alarm.dev_attr.attr, 598 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr, 599 &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr, 600 &sensor_dev_attr_temp4_beep.dev_attr.attr, 601 602 &sensor_dev_attr_temp5_input.dev_attr.attr, /* 38 */ 603 &sensor_dev_attr_temp5_min.dev_attr.attr, 604 &sensor_dev_attr_temp5_max.dev_attr.attr, 605 &sensor_dev_attr_temp5_crit.dev_attr.attr, 606 &sensor_dev_attr_temp5_min_alarm.dev_attr.attr, 607 &sensor_dev_attr_temp5_max_alarm.dev_attr.attr, 608 &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr, 609 &sensor_dev_attr_temp5_beep.dev_attr.attr, 610 611 &sensor_dev_attr_temp6_input.dev_attr.attr, /* 46 */ 612 &sensor_dev_attr_temp6_beep.dev_attr.attr, 613 614 NULL 615 }; 616 617 static umode_t nct7802_temp_is_visible(struct kobject *kobj, 618 struct attribute *attr, int index) 619 { 620 struct device *dev = container_of(kobj, struct device, kobj); 621 struct nct7802_data *data = dev_get_drvdata(dev); 622 unsigned int reg; 623 int err; 624 625 err = regmap_read(data->regmap, REG_MODE, ®); 626 if (err < 0) 627 return 0; 628 629 if (index < 10 && 630 (reg & 03) != 0x01 && (reg & 0x03) != 0x02) /* RD1 */ 631 return 0; 632 633 if (index >= 10 && index < 20 && 634 (reg & 0x0c) != 0x04 && (reg & 0x0c) != 0x08) /* RD2 */ 635 return 0; 636 if (index >= 20 && index < 30 && (reg & 0x30) != 0x20) /* RD3 */ 637 return 0; 638 639 if (index >= 30 && index < 38) /* local */ 640 return attr->mode; 641 642 err = regmap_read(data->regmap, REG_PECI_ENABLE, ®); 643 if (err < 0) 644 return 0; 645 646 if (index >= 38 && index < 46 && !(reg & 0x01)) /* PECI 0 */ 647 return 0; 648 649 if (index >= 0x46 && (!(reg & 0x02))) /* PECI 1 */ 650 return 0; 651 652 return attr->mode; 653 } 654 655 static const struct attribute_group nct7802_temp_group = { 656 .attrs = nct7802_temp_attrs, 657 .is_visible = nct7802_temp_is_visible, 658 }; 659 660 static SENSOR_DEVICE_ATTR_2_RO(in0_input, in, 0, 0); 661 static SENSOR_DEVICE_ATTR_2_RW(in0_min, in, 0, 1); 662 static SENSOR_DEVICE_ATTR_2_RW(in0_max, in, 0, 2); 663 static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, alarm, 0x1e, 3); 664 static SENSOR_DEVICE_ATTR_2_RW(in0_beep, beep, 0x5a, 3); 665 666 static SENSOR_DEVICE_ATTR_2_RO(in1_input, in, 1, 0); 667 668 static SENSOR_DEVICE_ATTR_2_RO(in2_input, in, 2, 0); 669 static SENSOR_DEVICE_ATTR_2_RW(in2_min, in, 2, 1); 670 static SENSOR_DEVICE_ATTR_2_RW(in2_max, in, 2, 2); 671 static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, alarm, 0x1e, 0); 672 static SENSOR_DEVICE_ATTR_2_RW(in2_beep, beep, 0x5a, 0); 673 674 static SENSOR_DEVICE_ATTR_2_RO(in3_input, in, 3, 0); 675 static SENSOR_DEVICE_ATTR_2_RW(in3_min, in, 3, 1); 676 static SENSOR_DEVICE_ATTR_2_RW(in3_max, in, 3, 2); 677 static SENSOR_DEVICE_ATTR_2_RO(in3_alarm, alarm, 0x1e, 1); 678 static SENSOR_DEVICE_ATTR_2_RW(in3_beep, beep, 0x5a, 1); 679 680 static SENSOR_DEVICE_ATTR_2_RO(in4_input, in, 4, 0); 681 static SENSOR_DEVICE_ATTR_2_RW(in4_min, in, 4, 1); 682 static SENSOR_DEVICE_ATTR_2_RW(in4_max, in, 4, 2); 683 static SENSOR_DEVICE_ATTR_2_RO(in4_alarm, alarm, 0x1e, 2); 684 static SENSOR_DEVICE_ATTR_2_RW(in4_beep, beep, 0x5a, 2); 685 686 static struct attribute *nct7802_in_attrs[] = { 687 &sensor_dev_attr_in0_input.dev_attr.attr, 688 &sensor_dev_attr_in0_min.dev_attr.attr, 689 &sensor_dev_attr_in0_max.dev_attr.attr, 690 &sensor_dev_attr_in0_alarm.dev_attr.attr, 691 &sensor_dev_attr_in0_beep.dev_attr.attr, 692 693 &sensor_dev_attr_in1_input.dev_attr.attr, /* 5 */ 694 695 &sensor_dev_attr_in2_input.dev_attr.attr, /* 6 */ 696 &sensor_dev_attr_in2_min.dev_attr.attr, 697 &sensor_dev_attr_in2_max.dev_attr.attr, 698 &sensor_dev_attr_in2_alarm.dev_attr.attr, 699 &sensor_dev_attr_in2_beep.dev_attr.attr, 700 701 &sensor_dev_attr_in3_input.dev_attr.attr, /* 11 */ 702 &sensor_dev_attr_in3_min.dev_attr.attr, 703 &sensor_dev_attr_in3_max.dev_attr.attr, 704 &sensor_dev_attr_in3_alarm.dev_attr.attr, 705 &sensor_dev_attr_in3_beep.dev_attr.attr, 706 707 &sensor_dev_attr_in4_input.dev_attr.attr, /* 16 */ 708 &sensor_dev_attr_in4_min.dev_attr.attr, 709 &sensor_dev_attr_in4_max.dev_attr.attr, 710 &sensor_dev_attr_in4_alarm.dev_attr.attr, 711 &sensor_dev_attr_in4_beep.dev_attr.attr, 712 713 NULL, 714 }; 715 716 static umode_t nct7802_in_is_visible(struct kobject *kobj, 717 struct attribute *attr, int index) 718 { 719 struct device *dev = container_of(kobj, struct device, kobj); 720 struct nct7802_data *data = dev_get_drvdata(dev); 721 unsigned int reg; 722 int err; 723 724 if (index < 6) /* VCC, VCORE */ 725 return attr->mode; 726 727 err = regmap_read(data->regmap, REG_MODE, ®); 728 if (err < 0) 729 return 0; 730 731 if (index >= 6 && index < 11 && (reg & 0x03) != 0x03) /* VSEN1 */ 732 return 0; 733 if (index >= 11 && index < 16 && (reg & 0x0c) != 0x0c) /* VSEN2 */ 734 return 0; 735 if (index >= 16 && (reg & 0x30) != 0x30) /* VSEN3 */ 736 return 0; 737 738 return attr->mode; 739 } 740 741 static const struct attribute_group nct7802_in_group = { 742 .attrs = nct7802_in_attrs, 743 .is_visible = nct7802_in_is_visible, 744 }; 745 746 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0x10); 747 static SENSOR_DEVICE_ATTR_2_RW(fan1_min, fan_min, 0x49, 0x4c); 748 static SENSOR_DEVICE_ATTR_2_RO(fan1_alarm, alarm, 0x1a, 0); 749 static SENSOR_DEVICE_ATTR_2_RW(fan1_beep, beep, 0x5b, 0); 750 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 0x11); 751 static SENSOR_DEVICE_ATTR_2_RW(fan2_min, fan_min, 0x4a, 0x4d); 752 static SENSOR_DEVICE_ATTR_2_RO(fan2_alarm, alarm, 0x1a, 1); 753 static SENSOR_DEVICE_ATTR_2_RW(fan2_beep, beep, 0x5b, 1); 754 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 0x12); 755 static SENSOR_DEVICE_ATTR_2_RW(fan3_min, fan_min, 0x4b, 0x4e); 756 static SENSOR_DEVICE_ATTR_2_RO(fan3_alarm, alarm, 0x1a, 2); 757 static SENSOR_DEVICE_ATTR_2_RW(fan3_beep, beep, 0x5b, 2); 758 759 /* 7.2.89 Fan Control Output Type */ 760 static SENSOR_DEVICE_ATTR_RO(pwm1_mode, pwm_mode, 0); 761 static SENSOR_DEVICE_ATTR_RO(pwm2_mode, pwm_mode, 1); 762 static SENSOR_DEVICE_ATTR_RO(pwm3_mode, pwm_mode, 2); 763 764 /* 7.2.91... Fan Control Output Value */ 765 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, REG_PWM(0)); 766 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, REG_PWM(1)); 767 static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, REG_PWM(2)); 768 769 /* 7.2.95... Temperature to Fan mapping Relationships Register */ 770 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_enable, 0); 771 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_enable, 1); 772 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_enable, 2); 773 774 static struct attribute *nct7802_fan_attrs[] = { 775 &sensor_dev_attr_fan1_input.dev_attr.attr, 776 &sensor_dev_attr_fan1_min.dev_attr.attr, 777 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 778 &sensor_dev_attr_fan1_beep.dev_attr.attr, 779 &sensor_dev_attr_fan2_input.dev_attr.attr, 780 &sensor_dev_attr_fan2_min.dev_attr.attr, 781 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 782 &sensor_dev_attr_fan2_beep.dev_attr.attr, 783 &sensor_dev_attr_fan3_input.dev_attr.attr, 784 &sensor_dev_attr_fan3_min.dev_attr.attr, 785 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 786 &sensor_dev_attr_fan3_beep.dev_attr.attr, 787 788 NULL 789 }; 790 791 static umode_t nct7802_fan_is_visible(struct kobject *kobj, 792 struct attribute *attr, int index) 793 { 794 struct device *dev = container_of(kobj, struct device, kobj); 795 struct nct7802_data *data = dev_get_drvdata(dev); 796 int fan = index / 4; /* 4 attributes per fan */ 797 unsigned int reg; 798 int err; 799 800 err = regmap_read(data->regmap, REG_FAN_ENABLE, ®); 801 if (err < 0 || !(reg & (1 << fan))) 802 return 0; 803 804 return attr->mode; 805 } 806 807 static const struct attribute_group nct7802_fan_group = { 808 .attrs = nct7802_fan_attrs, 809 .is_visible = nct7802_fan_is_visible, 810 }; 811 812 static struct attribute *nct7802_pwm_attrs[] = { 813 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 814 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 815 &sensor_dev_attr_pwm1.dev_attr.attr, 816 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 817 &sensor_dev_attr_pwm2_mode.dev_attr.attr, 818 &sensor_dev_attr_pwm2.dev_attr.attr, 819 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 820 &sensor_dev_attr_pwm3_mode.dev_attr.attr, 821 &sensor_dev_attr_pwm3.dev_attr.attr, 822 NULL 823 }; 824 825 static const struct attribute_group nct7802_pwm_group = { 826 .attrs = nct7802_pwm_attrs, 827 }; 828 829 /* 7.2.115... 0x80-0x83, 0x84 Temperature (X-axis) transition */ 830 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_temp, temp, 0x80, 0); 831 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_temp, temp, 0x81, 0); 832 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_temp, temp, 0x82, 0); 833 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_temp, temp, 0x83, 0); 834 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_temp, temp, 0x84, 0); 835 836 /* 7.2.120... 0x85-0x88 PWM (Y-axis) transition */ 837 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm, 0x85); 838 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm, 0x86); 839 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point3_pwm, pwm, 0x87); 840 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point4_pwm, pwm, 0x88); 841 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point5_pwm, pwm, 0); 842 843 /* 7.2.124 Table 2 X-axis Transition Point 1 Register */ 844 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_temp, temp, 0x90, 0); 845 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_temp, temp, 0x91, 0); 846 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_temp, temp, 0x92, 0); 847 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_temp, temp, 0x93, 0); 848 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_temp, temp, 0x94, 0); 849 850 /* 7.2.129 Table 2 Y-axis Transition Point 1 Register */ 851 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm, 0x95); 852 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm, 0x96); 853 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point3_pwm, pwm, 0x97); 854 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point4_pwm, pwm, 0x98); 855 static SENSOR_DEVICE_ATTR_RO(pwm2_auto_point5_pwm, pwm, 0); 856 857 /* 7.2.133 Table 3 X-axis Transition Point 1 Register */ 858 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_temp, temp, 0xA0, 0); 859 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_temp, temp, 0xA1, 0); 860 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point3_temp, temp, 0xA2, 0); 861 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point4_temp, temp, 0xA3, 0); 862 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point5_temp, temp, 0xA4, 0); 863 864 /* 7.2.138 Table 3 Y-axis Transition Point 1 Register */ 865 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm, 0xA5); 866 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm, 0xA6); 867 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point3_pwm, pwm, 0xA7); 868 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point4_pwm, pwm, 0xA8); 869 static SENSOR_DEVICE_ATTR_RO(pwm3_auto_point5_pwm, pwm, 0); 870 871 static struct attribute *nct7802_auto_point_attrs[] = { 872 &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr, 873 &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr, 874 &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr, 875 &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr, 876 &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr, 877 878 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 879 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 880 &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr, 881 &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr, 882 &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr, 883 884 &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr, 885 &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr, 886 &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr, 887 &sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr, 888 &sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr, 889 890 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 891 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 892 &sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr, 893 &sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr, 894 &sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr, 895 896 &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr, 897 &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr, 898 &sensor_dev_attr_pwm3_auto_point3_temp.dev_attr.attr, 899 &sensor_dev_attr_pwm3_auto_point4_temp.dev_attr.attr, 900 &sensor_dev_attr_pwm3_auto_point5_temp.dev_attr.attr, 901 902 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 903 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr, 904 &sensor_dev_attr_pwm3_auto_point3_pwm.dev_attr.attr, 905 &sensor_dev_attr_pwm3_auto_point4_pwm.dev_attr.attr, 906 &sensor_dev_attr_pwm3_auto_point5_pwm.dev_attr.attr, 907 908 NULL 909 }; 910 911 static const struct attribute_group nct7802_auto_point_group = { 912 .attrs = nct7802_auto_point_attrs, 913 }; 914 915 static const struct attribute_group *nct7802_groups[] = { 916 &nct7802_temp_group, 917 &nct7802_in_group, 918 &nct7802_fan_group, 919 &nct7802_pwm_group, 920 &nct7802_auto_point_group, 921 NULL 922 }; 923 924 static int nct7802_detect(struct i2c_client *client, 925 struct i2c_board_info *info) 926 { 927 int reg; 928 929 /* 930 * Chip identification registers are only available in bank 0, 931 * so only attempt chip detection if bank 0 is selected 932 */ 933 reg = i2c_smbus_read_byte_data(client, REG_BANK); 934 if (reg != 0x00) 935 return -ENODEV; 936 937 reg = i2c_smbus_read_byte_data(client, REG_VENDOR_ID); 938 if (reg != 0x50) 939 return -ENODEV; 940 941 reg = i2c_smbus_read_byte_data(client, REG_CHIP_ID); 942 if (reg != 0xc3) 943 return -ENODEV; 944 945 reg = i2c_smbus_read_byte_data(client, REG_VERSION_ID); 946 if (reg < 0 || (reg & 0xf0) != 0x20) 947 return -ENODEV; 948 949 /* Also validate lower bits of voltage and temperature registers */ 950 reg = i2c_smbus_read_byte_data(client, REG_TEMP_LSB); 951 if (reg < 0 || (reg & 0x1f)) 952 return -ENODEV; 953 954 reg = i2c_smbus_read_byte_data(client, REG_TEMP_PECI_LSB); 955 if (reg < 0 || (reg & 0x3f)) 956 return -ENODEV; 957 958 reg = i2c_smbus_read_byte_data(client, REG_VOLTAGE_LOW); 959 if (reg < 0 || (reg & 0x3f)) 960 return -ENODEV; 961 962 strlcpy(info->type, "nct7802", I2C_NAME_SIZE); 963 return 0; 964 } 965 966 static bool nct7802_regmap_is_volatile(struct device *dev, unsigned int reg) 967 { 968 return (reg != REG_BANK && reg <= 0x20) || 969 (reg >= REG_PWM(0) && reg <= REG_PWM(2)); 970 } 971 972 static const struct regmap_config nct7802_regmap_config = { 973 .reg_bits = 8, 974 .val_bits = 8, 975 .cache_type = REGCACHE_RBTREE, 976 .volatile_reg = nct7802_regmap_is_volatile, 977 }; 978 979 static int nct7802_init_chip(struct nct7802_data *data) 980 { 981 int err; 982 983 /* Enable ADC */ 984 err = regmap_update_bits(data->regmap, REG_START, 0x01, 0x01); 985 if (err) 986 return err; 987 988 /* Enable local temperature sensor */ 989 err = regmap_update_bits(data->regmap, REG_MODE, 0x40, 0x40); 990 if (err) 991 return err; 992 993 /* Enable Vcore and VCC voltage monitoring */ 994 return regmap_update_bits(data->regmap, REG_VMON_ENABLE, 0x03, 0x03); 995 } 996 997 static int nct7802_probe(struct i2c_client *client, 998 const struct i2c_device_id *id) 999 { 1000 struct device *dev = &client->dev; 1001 struct nct7802_data *data; 1002 struct device *hwmon_dev; 1003 int ret; 1004 1005 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 1006 if (data == NULL) 1007 return -ENOMEM; 1008 1009 data->regmap = devm_regmap_init_i2c(client, &nct7802_regmap_config); 1010 if (IS_ERR(data->regmap)) 1011 return PTR_ERR(data->regmap); 1012 1013 mutex_init(&data->access_lock); 1014 1015 ret = nct7802_init_chip(data); 1016 if (ret < 0) 1017 return ret; 1018 1019 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 1020 data, 1021 nct7802_groups); 1022 return PTR_ERR_OR_ZERO(hwmon_dev); 1023 } 1024 1025 static const unsigned short nct7802_address_list[] = { 1026 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END 1027 }; 1028 1029 static const struct i2c_device_id nct7802_idtable[] = { 1030 { "nct7802", 0 }, 1031 { } 1032 }; 1033 MODULE_DEVICE_TABLE(i2c, nct7802_idtable); 1034 1035 static struct i2c_driver nct7802_driver = { 1036 .class = I2C_CLASS_HWMON, 1037 .driver = { 1038 .name = DRVNAME, 1039 }, 1040 .detect = nct7802_detect, 1041 .probe = nct7802_probe, 1042 .id_table = nct7802_idtable, 1043 .address_list = nct7802_address_list, 1044 }; 1045 1046 module_i2c_driver(nct7802_driver); 1047 1048 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>"); 1049 MODULE_DESCRIPTION("NCT7802Y Hardware Monitoring Driver"); 1050 MODULE_LICENSE("GPL v2"); 1051