1 /* 2 * nct7802 - Driver for Nuvoton NCT7802Y 3 * 4 * Copyright (C) 2014 Guenter Roeck <linux@roeck-us.net> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 */ 16 17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18 19 #include <linux/err.h> 20 #include <linux/i2c.h> 21 #include <linux/init.h> 22 #include <linux/hwmon.h> 23 #include <linux/hwmon-sysfs.h> 24 #include <linux/jiffies.h> 25 #include <linux/module.h> 26 #include <linux/mutex.h> 27 #include <linux/regmap.h> 28 #include <linux/slab.h> 29 30 #define DRVNAME "nct7802" 31 32 static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; 33 34 static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { 35 { 0x40, 0x00, 0x42, 0x44, 0x46 }, 36 { 0x3f, 0x00, 0x41, 0x43, 0x45 }, 37 }; 38 39 static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 }; 40 41 static const u8 REG_VOLTAGE_LIMIT_MSB_SHIFT[2][5] = { 42 { 0, 0, 4, 0, 4 }, 43 { 2, 0, 6, 2, 6 }, 44 }; 45 46 #define REG_BANK 0x00 47 #define REG_TEMP_LSB 0x05 48 #define REG_TEMP_PECI_LSB 0x08 49 #define REG_VOLTAGE_LOW 0x0f 50 #define REG_FANCOUNT_LOW 0x13 51 #define REG_START 0x21 52 #define REG_MODE 0x22 53 #define REG_PECI_ENABLE 0x23 54 #define REG_FAN_ENABLE 0x24 55 #define REG_VMON_ENABLE 0x25 56 #define REG_VENDOR_ID 0xfd 57 #define REG_CHIP_ID 0xfe 58 #define REG_VERSION_ID 0xff 59 60 /* 61 * Data structures and manipulation thereof 62 */ 63 64 struct nct7802_data { 65 struct regmap *regmap; 66 struct mutex access_lock; /* for multi-byte read and write operations */ 67 }; 68 69 static int nct7802_read_temp(struct nct7802_data *data, 70 u8 reg_temp, u8 reg_temp_low, int *temp) 71 { 72 unsigned int t1, t2 = 0; 73 int err; 74 75 *temp = 0; 76 77 mutex_lock(&data->access_lock); 78 err = regmap_read(data->regmap, reg_temp, &t1); 79 if (err < 0) 80 goto abort; 81 t1 <<= 8; 82 if (reg_temp_low) { /* 11 bit data */ 83 err = regmap_read(data->regmap, reg_temp_low, &t2); 84 if (err < 0) 85 goto abort; 86 } 87 t1 |= t2 & 0xe0; 88 *temp = (s16)t1 / 32 * 125; 89 abort: 90 mutex_unlock(&data->access_lock); 91 return err; 92 } 93 94 static int nct7802_read_fan(struct nct7802_data *data, u8 reg_fan) 95 { 96 unsigned int f1, f2; 97 int ret; 98 99 mutex_lock(&data->access_lock); 100 ret = regmap_read(data->regmap, reg_fan, &f1); 101 if (ret < 0) 102 goto abort; 103 ret = regmap_read(data->regmap, REG_FANCOUNT_LOW, &f2); 104 if (ret < 0) 105 goto abort; 106 ret = (f1 << 5) | (f2 >> 3); 107 /* convert fan count to rpm */ 108 if (ret == 0x1fff) /* maximum value, assume fan is stopped */ 109 ret = 0; 110 else if (ret) 111 ret = DIV_ROUND_CLOSEST(1350000U, ret); 112 abort: 113 mutex_unlock(&data->access_lock); 114 return ret; 115 } 116 117 static int nct7802_read_fan_min(struct nct7802_data *data, u8 reg_fan_low, 118 u8 reg_fan_high) 119 { 120 unsigned int f1, f2; 121 int ret; 122 123 mutex_lock(&data->access_lock); 124 ret = regmap_read(data->regmap, reg_fan_low, &f1); 125 if (ret < 0) 126 goto abort; 127 ret = regmap_read(data->regmap, reg_fan_high, &f2); 128 if (ret < 0) 129 goto abort; 130 ret = f1 | ((f2 & 0xf8) << 5); 131 /* convert fan count to rpm */ 132 if (ret == 0x1fff) /* maximum value, assume no limit */ 133 ret = 0; 134 else if (ret) 135 ret = DIV_ROUND_CLOSEST(1350000U, ret); 136 abort: 137 mutex_unlock(&data->access_lock); 138 return ret; 139 } 140 141 static int nct7802_write_fan_min(struct nct7802_data *data, u8 reg_fan_low, 142 u8 reg_fan_high, unsigned int limit) 143 { 144 int err; 145 146 if (limit) 147 limit = DIV_ROUND_CLOSEST(1350000U, limit); 148 else 149 limit = 0x1fff; 150 limit = clamp_val(limit, 0, 0x1fff); 151 152 mutex_lock(&data->access_lock); 153 err = regmap_write(data->regmap, reg_fan_low, limit & 0xff); 154 if (err < 0) 155 goto abort; 156 157 err = regmap_write(data->regmap, reg_fan_high, (limit & 0x1f00) >> 5); 158 abort: 159 mutex_unlock(&data->access_lock); 160 return err; 161 } 162 163 static u8 nct7802_vmul[] = { 4, 2, 2, 2, 2 }; 164 165 static int nct7802_read_voltage(struct nct7802_data *data, int nr, int index) 166 { 167 unsigned int v1, v2; 168 int ret; 169 170 mutex_lock(&data->access_lock); 171 if (index == 0) { /* voltage */ 172 ret = regmap_read(data->regmap, REG_VOLTAGE[nr], &v1); 173 if (ret < 0) 174 goto abort; 175 ret = regmap_read(data->regmap, REG_VOLTAGE_LOW, &v2); 176 if (ret < 0) 177 goto abort; 178 ret = ((v1 << 2) | (v2 >> 6)) * nct7802_vmul[nr]; 179 } else { /* limit */ 180 int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr]; 181 182 ret = regmap_read(data->regmap, 183 REG_VOLTAGE_LIMIT_LSB[index - 1][nr], &v1); 184 if (ret < 0) 185 goto abort; 186 ret = regmap_read(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr], 187 &v2); 188 if (ret < 0) 189 goto abort; 190 ret = (v1 | ((v2 << shift) & 0x300)) * nct7802_vmul[nr]; 191 } 192 abort: 193 mutex_unlock(&data->access_lock); 194 return ret; 195 } 196 197 static int nct7802_write_voltage(struct nct7802_data *data, int nr, int index, 198 unsigned int voltage) 199 { 200 int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr]; 201 int err; 202 203 voltage = DIV_ROUND_CLOSEST(voltage, nct7802_vmul[nr]); 204 voltage = clamp_val(voltage, 0, 0x3ff); 205 206 mutex_lock(&data->access_lock); 207 err = regmap_write(data->regmap, 208 REG_VOLTAGE_LIMIT_LSB[index - 1][nr], 209 voltage & 0xff); 210 if (err < 0) 211 goto abort; 212 213 err = regmap_update_bits(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr], 214 0x0300 >> shift, (voltage & 0x0300) >> shift); 215 abort: 216 mutex_unlock(&data->access_lock); 217 return err; 218 } 219 220 static ssize_t show_in(struct device *dev, struct device_attribute *attr, 221 char *buf) 222 { 223 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 224 struct nct7802_data *data = dev_get_drvdata(dev); 225 int voltage; 226 227 voltage = nct7802_read_voltage(data, sattr->nr, sattr->index); 228 if (voltage < 0) 229 return voltage; 230 231 return sprintf(buf, "%d\n", voltage); 232 } 233 234 static ssize_t store_in(struct device *dev, struct device_attribute *attr, 235 const char *buf, size_t count) 236 { 237 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 238 struct nct7802_data *data = dev_get_drvdata(dev); 239 int index = sattr->index; 240 int nr = sattr->nr; 241 unsigned long val; 242 int err; 243 244 err = kstrtoul(buf, 10, &val); 245 if (err < 0) 246 return err; 247 248 err = nct7802_write_voltage(data, nr, index, val); 249 return err ? : count; 250 } 251 252 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, 253 char *buf) 254 { 255 struct nct7802_data *data = dev_get_drvdata(dev); 256 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 257 int err, temp; 258 259 err = nct7802_read_temp(data, sattr->nr, sattr->index, &temp); 260 if (err < 0) 261 return err; 262 263 return sprintf(buf, "%d\n", temp); 264 } 265 266 static ssize_t store_temp(struct device *dev, struct device_attribute *attr, 267 const char *buf, size_t count) 268 { 269 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 270 struct nct7802_data *data = dev_get_drvdata(dev); 271 int nr = sattr->nr; 272 long val; 273 int err; 274 275 err = kstrtol(buf, 10, &val); 276 if (err < 0) 277 return err; 278 279 val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -128, 127); 280 281 err = regmap_write(data->regmap, nr, val & 0xff); 282 return err ? : count; 283 } 284 285 static ssize_t show_fan(struct device *dev, struct device_attribute *attr, 286 char *buf) 287 { 288 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 289 struct nct7802_data *data = dev_get_drvdata(dev); 290 int speed; 291 292 speed = nct7802_read_fan(data, sattr->index); 293 if (speed < 0) 294 return speed; 295 296 return sprintf(buf, "%d\n", speed); 297 } 298 299 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr, 300 char *buf) 301 { 302 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 303 struct nct7802_data *data = dev_get_drvdata(dev); 304 int speed; 305 306 speed = nct7802_read_fan_min(data, sattr->nr, sattr->index); 307 if (speed < 0) 308 return speed; 309 310 return sprintf(buf, "%d\n", speed); 311 } 312 313 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr, 314 const char *buf, size_t count) 315 { 316 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 317 struct nct7802_data *data = dev_get_drvdata(dev); 318 unsigned long val; 319 int err; 320 321 err = kstrtoul(buf, 10, &val); 322 if (err < 0) 323 return err; 324 325 err = nct7802_write_fan_min(data, sattr->nr, sattr->index, val); 326 return err ? : count; 327 } 328 329 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 330 char *buf) 331 { 332 struct nct7802_data *data = dev_get_drvdata(dev); 333 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 334 int bit = sattr->index; 335 unsigned int val; 336 int ret; 337 338 ret = regmap_read(data->regmap, sattr->nr, &val); 339 if (ret < 0) 340 return ret; 341 342 return sprintf(buf, "%u\n", !!(val & (1 << bit))); 343 } 344 345 static ssize_t 346 show_beep(struct device *dev, struct device_attribute *attr, char *buf) 347 { 348 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 349 struct nct7802_data *data = dev_get_drvdata(dev); 350 unsigned int regval; 351 int err; 352 353 err = regmap_read(data->regmap, sattr->nr, ®val); 354 if (err) 355 return err; 356 357 return sprintf(buf, "%u\n", !!(regval & (1 << sattr->index))); 358 } 359 360 static ssize_t 361 store_beep(struct device *dev, struct device_attribute *attr, const char *buf, 362 size_t count) 363 { 364 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 365 struct nct7802_data *data = dev_get_drvdata(dev); 366 unsigned long val; 367 int err; 368 369 err = kstrtoul(buf, 10, &val); 370 if (err < 0) 371 return err; 372 if (val > 1) 373 return -EINVAL; 374 375 err = regmap_update_bits(data->regmap, sattr->nr, 1 << sattr->index, 376 val ? 1 << sattr->index : 0); 377 return err ? : count; 378 } 379 380 static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0x01, 381 REG_TEMP_LSB); 382 static SENSOR_DEVICE_ATTR_2(temp1_min, S_IRUGO | S_IWUSR, show_temp, 383 store_temp, 0x31, 0); 384 static SENSOR_DEVICE_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp, 385 store_temp, 0x30, 0); 386 static SENSOR_DEVICE_ATTR_2(temp1_crit, S_IRUGO | S_IWUSR, show_temp, 387 store_temp, 0x3a, 0); 388 389 static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 0x02, 390 REG_TEMP_LSB); 391 static SENSOR_DEVICE_ATTR_2(temp2_min, S_IRUGO | S_IWUSR, show_temp, 392 store_temp, 0x33, 0); 393 static SENSOR_DEVICE_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp, 394 store_temp, 0x32, 0); 395 static SENSOR_DEVICE_ATTR_2(temp2_crit, S_IRUGO | S_IWUSR, show_temp, 396 store_temp, 0x3b, 0); 397 398 static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, 0x03, 399 REG_TEMP_LSB); 400 static SENSOR_DEVICE_ATTR_2(temp3_min, S_IRUGO | S_IWUSR, show_temp, 401 store_temp, 0x35, 0); 402 static SENSOR_DEVICE_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp, 403 store_temp, 0x34, 0); 404 static SENSOR_DEVICE_ATTR_2(temp3_crit, S_IRUGO | S_IWUSR, show_temp, 405 store_temp, 0x3c, 0); 406 407 static SENSOR_DEVICE_ATTR_2(temp4_input, S_IRUGO, show_temp, NULL, 0x04, 0); 408 static SENSOR_DEVICE_ATTR_2(temp4_min, S_IRUGO | S_IWUSR, show_temp, 409 store_temp, 0x37, 0); 410 static SENSOR_DEVICE_ATTR_2(temp4_max, S_IRUGO | S_IWUSR, show_temp, 411 store_temp, 0x36, 0); 412 static SENSOR_DEVICE_ATTR_2(temp4_crit, S_IRUGO | S_IWUSR, show_temp, 413 store_temp, 0x3d, 0); 414 415 static SENSOR_DEVICE_ATTR_2(temp5_input, S_IRUGO, show_temp, NULL, 0x06, 416 REG_TEMP_PECI_LSB); 417 static SENSOR_DEVICE_ATTR_2(temp5_min, S_IRUGO | S_IWUSR, show_temp, 418 store_temp, 0x39, 0); 419 static SENSOR_DEVICE_ATTR_2(temp5_max, S_IRUGO | S_IWUSR, show_temp, 420 store_temp, 0x38, 0); 421 static SENSOR_DEVICE_ATTR_2(temp5_crit, S_IRUGO | S_IWUSR, show_temp, 422 store_temp, 0x3e, 0); 423 424 static SENSOR_DEVICE_ATTR_2(temp6_input, S_IRUGO, show_temp, NULL, 0x07, 425 REG_TEMP_PECI_LSB); 426 427 static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 428 0x18, 0); 429 static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 430 0x18, 1); 431 static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 432 0x18, 2); 433 static SENSOR_DEVICE_ATTR_2(temp4_min_alarm, S_IRUGO, show_alarm, NULL, 434 0x18, 3); 435 static SENSOR_DEVICE_ATTR_2(temp5_min_alarm, S_IRUGO, show_alarm, NULL, 436 0x18, 4); 437 438 static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 439 0x19, 0); 440 static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 441 0x19, 1); 442 static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 443 0x19, 2); 444 static SENSOR_DEVICE_ATTR_2(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 445 0x19, 3); 446 static SENSOR_DEVICE_ATTR_2(temp5_max_alarm, S_IRUGO, show_alarm, NULL, 447 0x19, 4); 448 449 static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 450 0x1b, 0); 451 static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 452 0x1b, 1); 453 static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 454 0x1b, 2); 455 static SENSOR_DEVICE_ATTR_2(temp4_crit_alarm, S_IRUGO, show_alarm, NULL, 456 0x1b, 3); 457 static SENSOR_DEVICE_ATTR_2(temp5_crit_alarm, S_IRUGO, show_alarm, NULL, 458 0x1b, 4); 459 460 static SENSOR_DEVICE_ATTR_2(temp1_fault, S_IRUGO, show_alarm, NULL, 0x17, 0); 461 static SENSOR_DEVICE_ATTR_2(temp2_fault, S_IRUGO, show_alarm, NULL, 0x17, 1); 462 static SENSOR_DEVICE_ATTR_2(temp3_fault, S_IRUGO, show_alarm, NULL, 0x17, 2); 463 464 static SENSOR_DEVICE_ATTR_2(temp1_beep, S_IRUGO | S_IWUSR, show_beep, 465 store_beep, 0x5c, 0); 466 static SENSOR_DEVICE_ATTR_2(temp2_beep, S_IRUGO | S_IWUSR, show_beep, 467 store_beep, 0x5c, 1); 468 static SENSOR_DEVICE_ATTR_2(temp3_beep, S_IRUGO | S_IWUSR, show_beep, 469 store_beep, 0x5c, 2); 470 static SENSOR_DEVICE_ATTR_2(temp4_beep, S_IRUGO | S_IWUSR, show_beep, 471 store_beep, 0x5c, 3); 472 static SENSOR_DEVICE_ATTR_2(temp5_beep, S_IRUGO | S_IWUSR, show_beep, 473 store_beep, 0x5c, 4); 474 static SENSOR_DEVICE_ATTR_2(temp6_beep, S_IRUGO | S_IWUSR, show_beep, 475 store_beep, 0x5c, 5); 476 477 static struct attribute *nct7802_temp_attrs[] = { 478 &sensor_dev_attr_temp1_input.dev_attr.attr, 479 &sensor_dev_attr_temp1_min.dev_attr.attr, 480 &sensor_dev_attr_temp1_max.dev_attr.attr, 481 &sensor_dev_attr_temp1_crit.dev_attr.attr, 482 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 483 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 484 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 485 &sensor_dev_attr_temp1_fault.dev_attr.attr, 486 &sensor_dev_attr_temp1_beep.dev_attr.attr, 487 488 &sensor_dev_attr_temp2_input.dev_attr.attr, /* 9 */ 489 &sensor_dev_attr_temp2_min.dev_attr.attr, 490 &sensor_dev_attr_temp2_max.dev_attr.attr, 491 &sensor_dev_attr_temp2_crit.dev_attr.attr, 492 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 493 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 494 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 495 &sensor_dev_attr_temp2_fault.dev_attr.attr, 496 &sensor_dev_attr_temp2_beep.dev_attr.attr, 497 498 &sensor_dev_attr_temp3_input.dev_attr.attr, /* 18 */ 499 &sensor_dev_attr_temp3_min.dev_attr.attr, 500 &sensor_dev_attr_temp3_max.dev_attr.attr, 501 &sensor_dev_attr_temp3_crit.dev_attr.attr, 502 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 503 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 504 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 505 &sensor_dev_attr_temp3_fault.dev_attr.attr, 506 &sensor_dev_attr_temp3_beep.dev_attr.attr, 507 508 &sensor_dev_attr_temp4_input.dev_attr.attr, /* 27 */ 509 &sensor_dev_attr_temp4_min.dev_attr.attr, 510 &sensor_dev_attr_temp4_max.dev_attr.attr, 511 &sensor_dev_attr_temp4_crit.dev_attr.attr, 512 &sensor_dev_attr_temp4_min_alarm.dev_attr.attr, 513 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr, 514 &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr, 515 &sensor_dev_attr_temp4_beep.dev_attr.attr, 516 517 &sensor_dev_attr_temp5_input.dev_attr.attr, /* 35 */ 518 &sensor_dev_attr_temp5_min.dev_attr.attr, 519 &sensor_dev_attr_temp5_max.dev_attr.attr, 520 &sensor_dev_attr_temp5_crit.dev_attr.attr, 521 &sensor_dev_attr_temp5_min_alarm.dev_attr.attr, 522 &sensor_dev_attr_temp5_max_alarm.dev_attr.attr, 523 &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr, 524 &sensor_dev_attr_temp5_beep.dev_attr.attr, 525 526 &sensor_dev_attr_temp6_input.dev_attr.attr, /* 43 */ 527 &sensor_dev_attr_temp6_beep.dev_attr.attr, 528 529 NULL 530 }; 531 532 static umode_t nct7802_temp_is_visible(struct kobject *kobj, 533 struct attribute *attr, int index) 534 { 535 struct device *dev = container_of(kobj, struct device, kobj); 536 struct nct7802_data *data = dev_get_drvdata(dev); 537 unsigned int reg; 538 int err; 539 540 err = regmap_read(data->regmap, REG_MODE, ®); 541 if (err < 0) 542 return 0; 543 544 if (index < 9 && 545 (reg & 03) != 0x01 && (reg & 0x03) != 0x02) /* RD1 */ 546 return 0; 547 if (index >= 9 && index < 18 && 548 (reg & 0x0c) != 0x04 && (reg & 0x0c) != 0x08) /* RD2 */ 549 return 0; 550 if (index >= 18 && index < 27 && (reg & 0x30) != 0x10) /* RD3 */ 551 return 0; 552 if (index >= 27 && index < 35) /* local */ 553 return attr->mode; 554 555 err = regmap_read(data->regmap, REG_PECI_ENABLE, ®); 556 if (err < 0) 557 return 0; 558 559 if (index >= 35 && index < 43 && !(reg & 0x01)) /* PECI 0 */ 560 return 0; 561 562 if (index >= 0x43 && (!(reg & 0x02))) /* PECI 1 */ 563 return 0; 564 565 return attr->mode; 566 } 567 568 static struct attribute_group nct7802_temp_group = { 569 .attrs = nct7802_temp_attrs, 570 .is_visible = nct7802_temp_is_visible, 571 }; 572 573 static SENSOR_DEVICE_ATTR_2(in0_input, S_IRUGO, show_in, NULL, 0, 0); 574 static SENSOR_DEVICE_ATTR_2(in0_min, S_IRUGO | S_IWUSR, show_in, store_in, 575 0, 1); 576 static SENSOR_DEVICE_ATTR_2(in0_max, S_IRUGO | S_IWUSR, show_in, store_in, 577 0, 2); 578 static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 3); 579 static SENSOR_DEVICE_ATTR_2(in0_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 580 0x5a, 3); 581 582 static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, show_in, NULL, 1, 0); 583 584 static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, show_in, NULL, 2, 0); 585 static SENSOR_DEVICE_ATTR_2(in2_min, S_IRUGO | S_IWUSR, show_in, store_in, 586 2, 1); 587 static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_in, store_in, 588 2, 2); 589 static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 0); 590 static SENSOR_DEVICE_ATTR_2(in2_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 591 0x5a, 0); 592 593 static SENSOR_DEVICE_ATTR_2(in3_input, S_IRUGO, show_in, NULL, 3, 0); 594 static SENSOR_DEVICE_ATTR_2(in3_min, S_IRUGO | S_IWUSR, show_in, store_in, 595 3, 1); 596 static SENSOR_DEVICE_ATTR_2(in3_max, S_IRUGO | S_IWUSR, show_in, store_in, 597 3, 2); 598 static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 1); 599 static SENSOR_DEVICE_ATTR_2(in3_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 600 0x5a, 1); 601 602 static SENSOR_DEVICE_ATTR_2(in4_input, S_IRUGO, show_in, NULL, 4, 0); 603 static SENSOR_DEVICE_ATTR_2(in4_min, S_IRUGO | S_IWUSR, show_in, store_in, 604 4, 1); 605 static SENSOR_DEVICE_ATTR_2(in4_max, S_IRUGO | S_IWUSR, show_in, store_in, 606 4, 2); 607 static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 2); 608 static SENSOR_DEVICE_ATTR_2(in4_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 609 0x5a, 2); 610 611 static struct attribute *nct7802_in_attrs[] = { 612 &sensor_dev_attr_in0_input.dev_attr.attr, 613 &sensor_dev_attr_in0_min.dev_attr.attr, 614 &sensor_dev_attr_in0_max.dev_attr.attr, 615 &sensor_dev_attr_in0_alarm.dev_attr.attr, 616 &sensor_dev_attr_in0_beep.dev_attr.attr, 617 618 &sensor_dev_attr_in1_input.dev_attr.attr, /* 5 */ 619 620 &sensor_dev_attr_in2_input.dev_attr.attr, /* 6 */ 621 &sensor_dev_attr_in2_min.dev_attr.attr, 622 &sensor_dev_attr_in2_max.dev_attr.attr, 623 &sensor_dev_attr_in2_alarm.dev_attr.attr, 624 &sensor_dev_attr_in2_beep.dev_attr.attr, 625 626 &sensor_dev_attr_in3_input.dev_attr.attr, /* 11 */ 627 &sensor_dev_attr_in3_min.dev_attr.attr, 628 &sensor_dev_attr_in3_max.dev_attr.attr, 629 &sensor_dev_attr_in3_alarm.dev_attr.attr, 630 &sensor_dev_attr_in3_beep.dev_attr.attr, 631 632 &sensor_dev_attr_in4_input.dev_attr.attr, /* 17 */ 633 &sensor_dev_attr_in4_min.dev_attr.attr, 634 &sensor_dev_attr_in4_max.dev_attr.attr, 635 &sensor_dev_attr_in4_alarm.dev_attr.attr, 636 &sensor_dev_attr_in4_beep.dev_attr.attr, 637 638 NULL, 639 }; 640 641 static umode_t nct7802_in_is_visible(struct kobject *kobj, 642 struct attribute *attr, int index) 643 { 644 struct device *dev = container_of(kobj, struct device, kobj); 645 struct nct7802_data *data = dev_get_drvdata(dev); 646 unsigned int reg; 647 int err; 648 649 if (index < 6) /* VCC, VCORE */ 650 return attr->mode; 651 652 err = regmap_read(data->regmap, REG_MODE, ®); 653 if (err < 0) 654 return 0; 655 656 if (index >= 6 && index < 11 && (reg & 0x03) != 0x03) /* VSEN1 */ 657 return 0; 658 if (index >= 11 && index < 17 && (reg & 0x0c) != 0x0c) /* VSEN2 */ 659 return 0; 660 if (index >= 17 && (reg & 0x30) != 0x30) /* VSEN3 */ 661 return 0; 662 663 return attr->mode; 664 } 665 666 static struct attribute_group nct7802_in_group = { 667 .attrs = nct7802_in_attrs, 668 .is_visible = nct7802_in_is_visible, 669 }; 670 671 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0x10); 672 static SENSOR_DEVICE_ATTR_2(fan1_min, S_IRUGO | S_IWUSR, show_fan_min, 673 store_fan_min, 0x49, 0x4c); 674 static SENSOR_DEVICE_ATTR_2(fan1_alarm, S_IRUGO, show_alarm, NULL, 0x1a, 0); 675 static SENSOR_DEVICE_ATTR_2(fan1_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 676 0x5b, 0); 677 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 0x11); 678 static SENSOR_DEVICE_ATTR_2(fan2_min, S_IRUGO | S_IWUSR, show_fan_min, 679 store_fan_min, 0x4a, 0x4d); 680 static SENSOR_DEVICE_ATTR_2(fan2_alarm, S_IRUGO, show_alarm, NULL, 0x1a, 1); 681 static SENSOR_DEVICE_ATTR_2(fan2_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 682 0x5b, 1); 683 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 0x12); 684 static SENSOR_DEVICE_ATTR_2(fan3_min, S_IRUGO | S_IWUSR, show_fan_min, 685 store_fan_min, 0x4b, 0x4e); 686 static SENSOR_DEVICE_ATTR_2(fan3_alarm, S_IRUGO, show_alarm, NULL, 0x1a, 2); 687 static SENSOR_DEVICE_ATTR_2(fan3_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 688 0x5b, 2); 689 690 static struct attribute *nct7802_fan_attrs[] = { 691 &sensor_dev_attr_fan1_input.dev_attr.attr, 692 &sensor_dev_attr_fan1_min.dev_attr.attr, 693 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 694 &sensor_dev_attr_fan1_beep.dev_attr.attr, 695 &sensor_dev_attr_fan2_input.dev_attr.attr, 696 &sensor_dev_attr_fan2_min.dev_attr.attr, 697 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 698 &sensor_dev_attr_fan2_beep.dev_attr.attr, 699 &sensor_dev_attr_fan3_input.dev_attr.attr, 700 &sensor_dev_attr_fan3_min.dev_attr.attr, 701 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 702 &sensor_dev_attr_fan3_beep.dev_attr.attr, 703 704 NULL 705 }; 706 707 static umode_t nct7802_fan_is_visible(struct kobject *kobj, 708 struct attribute *attr, int index) 709 { 710 struct device *dev = container_of(kobj, struct device, kobj); 711 struct nct7802_data *data = dev_get_drvdata(dev); 712 int fan = index / 4; /* 4 attributes per fan */ 713 unsigned int reg; 714 int err; 715 716 err = regmap_read(data->regmap, REG_FAN_ENABLE, ®); 717 if (err < 0 || !(reg & (1 << fan))) 718 return 0; 719 720 return attr->mode; 721 } 722 723 static struct attribute_group nct7802_fan_group = { 724 .attrs = nct7802_fan_attrs, 725 .is_visible = nct7802_fan_is_visible, 726 }; 727 728 static const struct attribute_group *nct7802_groups[] = { 729 &nct7802_temp_group, 730 &nct7802_in_group, 731 &nct7802_fan_group, 732 NULL 733 }; 734 735 static int nct7802_detect(struct i2c_client *client, 736 struct i2c_board_info *info) 737 { 738 int reg; 739 740 /* 741 * Chip identification registers are only available in bank 0, 742 * so only attempt chip detection if bank 0 is selected 743 */ 744 reg = i2c_smbus_read_byte_data(client, REG_BANK); 745 if (reg != 0x00) 746 return -ENODEV; 747 748 reg = i2c_smbus_read_byte_data(client, REG_VENDOR_ID); 749 if (reg != 0x50) 750 return -ENODEV; 751 752 reg = i2c_smbus_read_byte_data(client, REG_CHIP_ID); 753 if (reg != 0xc3) 754 return -ENODEV; 755 756 reg = i2c_smbus_read_byte_data(client, REG_VERSION_ID); 757 if (reg < 0 || (reg & 0xf0) != 0x20) 758 return -ENODEV; 759 760 /* Also validate lower bits of voltage and temperature registers */ 761 reg = i2c_smbus_read_byte_data(client, REG_TEMP_LSB); 762 if (reg < 0 || (reg & 0x1f)) 763 return -ENODEV; 764 765 reg = i2c_smbus_read_byte_data(client, REG_TEMP_PECI_LSB); 766 if (reg < 0 || (reg & 0x3f)) 767 return -ENODEV; 768 769 reg = i2c_smbus_read_byte_data(client, REG_VOLTAGE_LOW); 770 if (reg < 0 || (reg & 0x3f)) 771 return -ENODEV; 772 773 strlcpy(info->type, "nct7802", I2C_NAME_SIZE); 774 return 0; 775 } 776 777 static bool nct7802_regmap_is_volatile(struct device *dev, unsigned int reg) 778 { 779 return reg != REG_BANK && reg <= 0x20; 780 } 781 782 static const struct regmap_config nct7802_regmap_config = { 783 .reg_bits = 8, 784 .val_bits = 8, 785 .cache_type = REGCACHE_RBTREE, 786 .volatile_reg = nct7802_regmap_is_volatile, 787 }; 788 789 static int nct7802_init_chip(struct nct7802_data *data) 790 { 791 int err; 792 793 /* Enable ADC */ 794 err = regmap_update_bits(data->regmap, REG_START, 0x01, 0x01); 795 if (err) 796 return err; 797 798 /* Enable local temperature sensor */ 799 err = regmap_update_bits(data->regmap, REG_MODE, 0x40, 0x40); 800 if (err) 801 return err; 802 803 /* Enable Vcore and VCC voltage monitoring */ 804 return regmap_update_bits(data->regmap, REG_VMON_ENABLE, 0x03, 0x03); 805 } 806 807 static int nct7802_probe(struct i2c_client *client, 808 const struct i2c_device_id *id) 809 { 810 struct device *dev = &client->dev; 811 struct nct7802_data *data; 812 struct device *hwmon_dev; 813 int ret; 814 815 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 816 if (data == NULL) 817 return -ENOMEM; 818 819 data->regmap = devm_regmap_init_i2c(client, &nct7802_regmap_config); 820 if (IS_ERR(data->regmap)) 821 return PTR_ERR(data->regmap); 822 823 mutex_init(&data->access_lock); 824 825 ret = nct7802_init_chip(data); 826 if (ret < 0) 827 return ret; 828 829 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 830 data, 831 nct7802_groups); 832 return PTR_ERR_OR_ZERO(hwmon_dev); 833 } 834 835 static const unsigned short nct7802_address_list[] = { 836 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END 837 }; 838 839 static const struct i2c_device_id nct7802_idtable[] = { 840 { "nct7802", 0 }, 841 { } 842 }; 843 MODULE_DEVICE_TABLE(i2c, nct7802_idtable); 844 845 static struct i2c_driver nct7802_driver = { 846 .class = I2C_CLASS_HWMON, 847 .driver = { 848 .name = DRVNAME, 849 }, 850 .detect = nct7802_detect, 851 .probe = nct7802_probe, 852 .id_table = nct7802_idtable, 853 .address_list = nct7802_address_list, 854 }; 855 856 module_i2c_driver(nct7802_driver); 857 858 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>"); 859 MODULE_DESCRIPTION("NCT7802Y Hardware Monitoring Driver"); 860 MODULE_LICENSE("GPL v2"); 861