1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * adm9240.c Part of lm_sensors, Linux kernel modules for hardware 4 * monitoring 5 * 6 * Copyright (C) 1999 Frodo Looijaard <frodol@dds.nl> 7 * Philip Edelbrock <phil@netroedge.com> 8 * Copyright (C) 2003 Michiel Rook <michiel@grendelproject.nl> 9 * Copyright (C) 2005 Grant Coady <gcoady.lk@gmail.com> with valuable 10 * guidance from Jean Delvare 11 * 12 * Driver supports Analog Devices ADM9240 13 * Dallas Semiconductor DS1780 14 * National Semiconductor LM81 15 * 16 * ADM9240 is the reference, DS1780 and LM81 are register compatibles 17 * 18 * Voltage Six inputs are scaled by chip, VID also reported 19 * Temperature Chip temperature to 0.5'C, maximum and max_hysteris 20 * Fans 2 fans, low speed alarm, automatic fan clock divider 21 * Alarms 16-bit map of active alarms 22 * Analog Out 0..1250 mV output 23 * 24 * Chassis Intrusion: clear CI latch with 'echo 0 > intrusion0_alarm' 25 * 26 * Test hardware: Intel SE440BX-2 desktop motherboard --Grant 27 * 28 * LM81 extended temp reading not implemented 29 */ 30 31 #include <linux/bits.h> 32 #include <linux/init.h> 33 #include <linux/module.h> 34 #include <linux/slab.h> 35 #include <linux/i2c.h> 36 #include <linux/hwmon-sysfs.h> 37 #include <linux/hwmon.h> 38 #include <linux/hwmon-vid.h> 39 #include <linux/err.h> 40 #include <linux/regmap.h> 41 42 /* Addresses to scan */ 43 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, 44 I2C_CLIENT_END }; 45 46 enum chips { adm9240, ds1780, lm81 }; 47 48 /* ADM9240 registers */ 49 #define ADM9240_REG_MAN_ID 0x3e 50 #define ADM9240_REG_DIE_REV 0x3f 51 #define ADM9240_REG_CONFIG 0x40 52 53 #define ADM9240_REG_IN(nr) (0x20 + (nr)) /* 0..5 */ 54 #define ADM9240_REG_IN_MAX(nr) (0x2b + (nr) * 2) 55 #define ADM9240_REG_IN_MIN(nr) (0x2c + (nr) * 2) 56 #define ADM9240_REG_FAN(nr) (0x28 + (nr)) /* 0..1 */ 57 #define ADM9240_REG_FAN_MIN(nr) (0x3b + (nr)) 58 #define ADM9240_REG_INT(nr) (0x41 + (nr)) 59 #define ADM9240_REG_INT_MASK(nr) (0x43 + (nr)) 60 #define ADM9240_REG_TEMP 0x27 61 #define ADM9240_REG_TEMP_MAX(nr) (0x39 + (nr)) /* 0, 1 = high, hyst */ 62 #define ADM9240_REG_ANALOG_OUT 0x19 63 #define ADM9240_REG_CHASSIS_CLEAR 0x46 64 #define ADM9240_REG_VID_FAN_DIV 0x47 65 #define ADM9240_REG_I2C_ADDR 0x48 66 #define ADM9240_REG_VID4 0x49 67 #define ADM9240_REG_TEMP_CONF 0x4b 68 69 /* generalised scaling with integer rounding */ 70 static inline int SCALE(long val, int mul, int div) 71 { 72 if (val < 0) 73 return (val * mul - div / 2) / div; 74 else 75 return (val * mul + div / 2) / div; 76 } 77 78 /* adm9240 internally scales voltage measurements */ 79 static const u16 nom_mv[] = { 2500, 2700, 3300, 5000, 12000, 2700 }; 80 81 static inline unsigned int IN_FROM_REG(u8 reg, int n) 82 { 83 return SCALE(reg, nom_mv[n], 192); 84 } 85 86 static inline u8 IN_TO_REG(unsigned long val, int n) 87 { 88 val = clamp_val(val, 0, nom_mv[n] * 255 / 192); 89 return SCALE(val, 192, nom_mv[n]); 90 } 91 92 /* temperature range: -40..125, 127 disables temperature alarm */ 93 static inline s8 TEMP_TO_REG(long val) 94 { 95 val = clamp_val(val, -40000, 127000); 96 return SCALE(val, 1, 1000); 97 } 98 99 /* two fans, each with low fan speed limit */ 100 static inline unsigned int FAN_FROM_REG(u8 reg, u8 div) 101 { 102 if (!reg) /* error */ 103 return -1; 104 105 if (reg == 255) 106 return 0; 107 108 return SCALE(1350000, 1, reg * div); 109 } 110 111 /* analog out 0..1250mV */ 112 static inline u8 AOUT_TO_REG(unsigned long val) 113 { 114 val = clamp_val(val, 0, 1250); 115 return SCALE(val, 255, 1250); 116 } 117 118 static inline unsigned int AOUT_FROM_REG(u8 reg) 119 { 120 return SCALE(reg, 1250, 255); 121 } 122 123 /* per client data */ 124 struct adm9240_data { 125 struct device *dev; 126 struct regmap *regmap; 127 128 u8 fan_div[2]; /* rw fan1_div, read-only accessor */ 129 u8 vrm; /* -- vrm set on startup, no accessor */ 130 }; 131 132 /* write new fan div, callers must hold data->update_lock */ 133 static int adm9240_write_fan_div(struct adm9240_data *data, int channel, u8 fan_div) 134 { 135 unsigned int reg, old, shift = (channel + 2) * 2; 136 int err; 137 138 err = regmap_read(data->regmap, ADM9240_REG_VID_FAN_DIV, ®); 139 if (err < 0) 140 return err; 141 old = (reg >> shift) & 3; 142 reg &= ~(3 << shift); 143 reg |= (fan_div << shift); 144 err = regmap_write(data->regmap, ADM9240_REG_VID_FAN_DIV, reg); 145 if (err < 0) 146 return err; 147 dev_dbg(data->dev, 148 "fan%d clock divider changed from %lu to %lu\n", 149 channel + 1, BIT(old), BIT(fan_div)); 150 151 return 0; 152 } 153 154 /* 155 * set fan speed low limit: 156 * 157 * - value is zero: disable fan speed low limit alarm 158 * 159 * - value is below fan speed measurement range: enable fan speed low 160 * limit alarm to be asserted while fan speed too slow to measure 161 * 162 * - otherwise: select fan clock divider to suit fan speed low limit, 163 * measurement code may adjust registers to ensure fan speed reading 164 */ 165 static int adm9240_fan_min_write(struct adm9240_data *data, int channel, long val) 166 { 167 u8 new_div; 168 u8 fan_min; 169 int err; 170 171 if (!val) { 172 fan_min = 255; 173 new_div = data->fan_div[channel]; 174 175 dev_dbg(data->dev, "fan%u low limit set disabled\n", channel + 1); 176 } else if (val < 1350000 / (8 * 254)) { 177 new_div = 3; 178 fan_min = 254; 179 180 dev_dbg(data->dev, "fan%u low limit set minimum %u\n", 181 channel + 1, FAN_FROM_REG(254, BIT(new_div))); 182 } else { 183 unsigned int new_min = 1350000 / val; 184 185 new_div = 0; 186 while (new_min > 192 && new_div < 3) { 187 new_div++; 188 new_min /= 2; 189 } 190 if (!new_min) /* keep > 0 */ 191 new_min++; 192 193 fan_min = new_min; 194 195 dev_dbg(data->dev, "fan%u low limit set fan speed %u\n", 196 channel + 1, FAN_FROM_REG(new_min, BIT(new_div))); 197 } 198 199 if (new_div != data->fan_div[channel]) { 200 data->fan_div[channel] = new_div; 201 adm9240_write_fan_div(data, channel, new_div); 202 } 203 err = regmap_write(data->regmap, ADM9240_REG_FAN_MIN(channel), fan_min); 204 205 return err; 206 } 207 208 static ssize_t cpu0_vid_show(struct device *dev, 209 struct device_attribute *attr, char *buf) 210 { 211 struct adm9240_data *data = dev_get_drvdata(dev); 212 unsigned int regval; 213 int err; 214 u8 vid; 215 216 err = regmap_read(data->regmap, ADM9240_REG_VID_FAN_DIV, ®val); 217 if (err < 0) 218 return err; 219 vid = regval & 0x0f; 220 err = regmap_read(data->regmap, ADM9240_REG_VID4, ®val); 221 if (err < 0) 222 return err; 223 vid |= (regval & 1) << 4; 224 return sprintf(buf, "%d\n", vid_from_reg(vid, data->vrm)); 225 } 226 static DEVICE_ATTR_RO(cpu0_vid); 227 228 static ssize_t aout_output_show(struct device *dev, 229 struct device_attribute *attr, char *buf) 230 { 231 struct adm9240_data *data = dev_get_drvdata(dev); 232 unsigned int regval; 233 int err; 234 235 err = regmap_read(data->regmap, ADM9240_REG_ANALOG_OUT, ®val); 236 if (err) 237 return err; 238 239 return sprintf(buf, "%d\n", AOUT_FROM_REG(regval)); 240 } 241 242 static ssize_t aout_output_store(struct device *dev, 243 struct device_attribute *attr, 244 const char *buf, size_t count) 245 { 246 struct adm9240_data *data = dev_get_drvdata(dev); 247 long val; 248 int err; 249 250 err = kstrtol(buf, 10, &val); 251 if (err) 252 return err; 253 254 err = regmap_write(data->regmap, ADM9240_REG_ANALOG_OUT, AOUT_TO_REG(val)); 255 return err < 0 ? err : count; 256 } 257 static DEVICE_ATTR_RW(aout_output); 258 259 static struct attribute *adm9240_attrs[] = { 260 &dev_attr_aout_output.attr, 261 &dev_attr_cpu0_vid.attr, 262 NULL 263 }; 264 265 ATTRIBUTE_GROUPS(adm9240); 266 267 /*** sensor chip detect and driver install ***/ 268 269 /* Return 0 if detection is successful, -ENODEV otherwise */ 270 static int adm9240_detect(struct i2c_client *new_client, 271 struct i2c_board_info *info) 272 { 273 struct i2c_adapter *adapter = new_client->adapter; 274 const char *name = ""; 275 int address = new_client->addr; 276 u8 man_id, die_rev; 277 278 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 279 return -ENODEV; 280 281 /* verify chip: reg address should match i2c address */ 282 if (i2c_smbus_read_byte_data(new_client, ADM9240_REG_I2C_ADDR) != address) 283 return -ENODEV; 284 285 /* check known chip manufacturer */ 286 man_id = i2c_smbus_read_byte_data(new_client, ADM9240_REG_MAN_ID); 287 if (man_id == 0x23) 288 name = "adm9240"; 289 else if (man_id == 0xda) 290 name = "ds1780"; 291 else if (man_id == 0x01) 292 name = "lm81"; 293 else 294 return -ENODEV; 295 296 /* successful detect, print chip info */ 297 die_rev = i2c_smbus_read_byte_data(new_client, ADM9240_REG_DIE_REV); 298 dev_info(&adapter->dev, "found %s revision %u\n", 299 man_id == 0x23 ? "ADM9240" : 300 man_id == 0xda ? "DS1780" : "LM81", die_rev); 301 302 strscpy(info->type, name, I2C_NAME_SIZE); 303 304 return 0; 305 } 306 307 static int adm9240_init_client(struct adm9240_data *data) 308 { 309 unsigned int regval; 310 u8 conf, mode; 311 int err; 312 313 err = regmap_raw_read(data->regmap, ADM9240_REG_CONFIG, &conf, 1); 314 if (err < 0) 315 return err; 316 err = regmap_raw_read(data->regmap, ADM9240_REG_TEMP_CONF, &mode, 1); 317 if (err < 0) 318 return err; 319 mode &= 3; 320 321 data->vrm = vid_which_vrm(); /* need this to report vid as mV */ 322 323 dev_info(data->dev, "Using VRM: %d.%d\n", data->vrm / 10, 324 data->vrm % 10); 325 326 if (conf & 1) { /* measurement cycle running: report state */ 327 328 dev_info(data->dev, "status: config 0x%02x mode %u\n", 329 conf, mode); 330 331 } else { /* cold start: open limits before starting chip */ 332 int i; 333 334 for (i = 0; i < 6; i++) { 335 err = regmap_write(data->regmap, 336 ADM9240_REG_IN_MIN(i), 0); 337 if (err < 0) 338 return err; 339 err = regmap_write(data->regmap, 340 ADM9240_REG_IN_MAX(i), 255); 341 if (err < 0) 342 return err; 343 } 344 for (i = 0; i < 2; i++) { 345 err = regmap_write(data->regmap, 346 ADM9240_REG_FAN_MIN(i), 255); 347 if (err < 0) 348 return err; 349 } 350 for (i = 0; i < 2; i++) { 351 err = regmap_write(data->regmap, 352 ADM9240_REG_TEMP_MAX(i), 127); 353 if (err < 0) 354 return err; 355 } 356 357 /* start measurement cycle */ 358 err = regmap_write(data->regmap, ADM9240_REG_CONFIG, 1); 359 if (err < 0) 360 return err; 361 362 dev_info(data->dev, 363 "cold start: config was 0x%02x mode %u\n", conf, mode); 364 } 365 366 /* read fan divs */ 367 err = regmap_read(data->regmap, ADM9240_REG_VID_FAN_DIV, ®val); 368 if (err < 0) 369 return err; 370 data->fan_div[0] = (regval >> 4) & 3; 371 data->fan_div[1] = (regval >> 6) & 3; 372 return 0; 373 } 374 375 static int adm9240_chip_read(struct device *dev, u32 attr, long *val) 376 { 377 struct adm9240_data *data = dev_get_drvdata(dev); 378 u8 regs[2]; 379 int err; 380 381 switch (attr) { 382 case hwmon_chip_alarms: 383 err = regmap_bulk_read(data->regmap, ADM9240_REG_INT(0), ®s, 2); 384 if (err < 0) 385 return err; 386 *val = regs[0] | regs[1] << 8; 387 break; 388 default: 389 return -EOPNOTSUPP; 390 } 391 return 0; 392 } 393 394 static int adm9240_intrusion_read(struct device *dev, u32 attr, long *val) 395 { 396 struct adm9240_data *data = dev_get_drvdata(dev); 397 unsigned int regval; 398 int err; 399 400 switch (attr) { 401 case hwmon_intrusion_alarm: 402 err = regmap_read(data->regmap, ADM9240_REG_INT(1), ®val); 403 if (err < 0) 404 return err; 405 *val = !!(regval & BIT(4)); 406 break; 407 default: 408 return -EOPNOTSUPP; 409 } 410 return 0; 411 } 412 413 static int adm9240_intrusion_write(struct device *dev, u32 attr, long val) 414 { 415 struct adm9240_data *data = dev_get_drvdata(dev); 416 int err; 417 418 switch (attr) { 419 case hwmon_intrusion_alarm: 420 if (val) 421 return -EINVAL; 422 err = regmap_write(data->regmap, ADM9240_REG_CHASSIS_CLEAR, 0x80); 423 if (err < 0) 424 return err; 425 dev_dbg(data->dev, "chassis intrusion latch cleared\n"); 426 break; 427 default: 428 return -EOPNOTSUPP; 429 } 430 return 0; 431 } 432 433 static int adm9240_in_read(struct device *dev, u32 attr, int channel, long *val) 434 { 435 struct adm9240_data *data = dev_get_drvdata(dev); 436 unsigned int regval; 437 int reg; 438 int err; 439 440 switch (attr) { 441 case hwmon_in_input: 442 reg = ADM9240_REG_IN(channel); 443 break; 444 case hwmon_in_min: 445 reg = ADM9240_REG_IN_MIN(channel); 446 break; 447 case hwmon_in_max: 448 reg = ADM9240_REG_IN_MAX(channel); 449 break; 450 case hwmon_in_alarm: 451 if (channel < 4) { 452 reg = ADM9240_REG_INT(0); 453 } else { 454 reg = ADM9240_REG_INT(1); 455 channel -= 4; 456 } 457 err = regmap_read(data->regmap, reg, ®val); 458 if (err < 0) 459 return err; 460 *val = !!(regval & BIT(channel)); 461 return 0; 462 default: 463 return -EOPNOTSUPP; 464 } 465 err = regmap_read(data->regmap, reg, ®val); 466 if (err < 0) 467 return err; 468 *val = IN_FROM_REG(regval, channel); 469 return 0; 470 } 471 472 static int adm9240_in_write(struct device *dev, u32 attr, int channel, long val) 473 { 474 struct adm9240_data *data = dev_get_drvdata(dev); 475 int reg; 476 477 switch (attr) { 478 case hwmon_in_min: 479 reg = ADM9240_REG_IN_MIN(channel); 480 break; 481 case hwmon_in_max: 482 reg = ADM9240_REG_IN_MAX(channel); 483 break; 484 default: 485 return -EOPNOTSUPP; 486 } 487 return regmap_write(data->regmap, reg, IN_TO_REG(val, channel)); 488 } 489 490 static int adm9240_fan_read(struct device *dev, u32 attr, int channel, long *val) 491 { 492 struct adm9240_data *data = dev_get_drvdata(dev); 493 unsigned int regval; 494 int err; 495 496 switch (attr) { 497 case hwmon_fan_input: 498 err = regmap_read(data->regmap, ADM9240_REG_FAN(channel), ®val); 499 if (err < 0) 500 return err; 501 if (regval == 255 && data->fan_div[channel] < 3) { 502 /* adjust fan clock divider on overflow */ 503 err = adm9240_write_fan_div(data, channel, 504 ++data->fan_div[channel]); 505 if (err) 506 return err; 507 } 508 *val = FAN_FROM_REG(regval, BIT(data->fan_div[channel])); 509 break; 510 case hwmon_fan_div: 511 *val = BIT(data->fan_div[channel]); 512 break; 513 case hwmon_fan_min: 514 err = regmap_read(data->regmap, ADM9240_REG_FAN_MIN(channel), ®val); 515 if (err < 0) 516 return err; 517 *val = FAN_FROM_REG(regval, BIT(data->fan_div[channel])); 518 break; 519 case hwmon_fan_alarm: 520 err = regmap_read(data->regmap, ADM9240_REG_INT(0), ®val); 521 if (err < 0) 522 return err; 523 *val = !!(regval & BIT(channel + 6)); 524 break; 525 default: 526 return -EOPNOTSUPP; 527 } 528 return 0; 529 } 530 531 static int adm9240_fan_write(struct device *dev, u32 attr, int channel, long val) 532 { 533 struct adm9240_data *data = dev_get_drvdata(dev); 534 int err; 535 536 switch (attr) { 537 case hwmon_fan_min: 538 err = adm9240_fan_min_write(data, channel, val); 539 if (err < 0) 540 return err; 541 break; 542 default: 543 return -EOPNOTSUPP; 544 } 545 return 0; 546 } 547 548 static int adm9240_temp_read(struct device *dev, u32 attr, int channel, long *val) 549 { 550 struct adm9240_data *data = dev_get_drvdata(dev); 551 unsigned int regval; 552 int err, temp; 553 554 switch (attr) { 555 case hwmon_temp_input: 556 err = regmap_read(data->regmap, ADM9240_REG_TEMP, ®val); 557 if (err < 0) 558 return err; 559 temp = regval << 1; 560 err = regmap_read(data->regmap, ADM9240_REG_TEMP_CONF, ®val); 561 if (err < 0) 562 return err; 563 temp |= regval >> 7; 564 *val = sign_extend32(temp, 8) * 500; 565 break; 566 case hwmon_temp_max: 567 err = regmap_read(data->regmap, ADM9240_REG_TEMP_MAX(0), ®val); 568 if (err < 0) 569 return err; 570 *val = (s8)regval * 1000; 571 break; 572 case hwmon_temp_max_hyst: 573 err = regmap_read(data->regmap, ADM9240_REG_TEMP_MAX(1), ®val); 574 if (err < 0) 575 return err; 576 *val = (s8)regval * 1000; 577 break; 578 case hwmon_temp_alarm: 579 err = regmap_read(data->regmap, ADM9240_REG_INT(0), ®val); 580 if (err < 0) 581 return err; 582 *val = !!(regval & BIT(4)); 583 break; 584 default: 585 return -EOPNOTSUPP; 586 } 587 return 0; 588 } 589 590 static int adm9240_temp_write(struct device *dev, u32 attr, int channel, long val) 591 { 592 struct adm9240_data *data = dev_get_drvdata(dev); 593 int reg; 594 595 switch (attr) { 596 case hwmon_temp_max: 597 reg = ADM9240_REG_TEMP_MAX(0); 598 break; 599 case hwmon_temp_max_hyst: 600 reg = ADM9240_REG_TEMP_MAX(1); 601 break; 602 default: 603 return -EOPNOTSUPP; 604 } 605 return regmap_write(data->regmap, reg, TEMP_TO_REG(val)); 606 } 607 608 static int adm9240_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, 609 int channel, long *val) 610 { 611 switch (type) { 612 case hwmon_chip: 613 return adm9240_chip_read(dev, attr, val); 614 case hwmon_intrusion: 615 return adm9240_intrusion_read(dev, attr, val); 616 case hwmon_in: 617 return adm9240_in_read(dev, attr, channel, val); 618 case hwmon_fan: 619 return adm9240_fan_read(dev, attr, channel, val); 620 case hwmon_temp: 621 return adm9240_temp_read(dev, attr, channel, val); 622 default: 623 return -EOPNOTSUPP; 624 } 625 } 626 627 static int adm9240_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, 628 int channel, long val) 629 { 630 switch (type) { 631 case hwmon_intrusion: 632 return adm9240_intrusion_write(dev, attr, val); 633 case hwmon_in: 634 return adm9240_in_write(dev, attr, channel, val); 635 case hwmon_fan: 636 return adm9240_fan_write(dev, attr, channel, val); 637 case hwmon_temp: 638 return adm9240_temp_write(dev, attr, channel, val); 639 default: 640 return -EOPNOTSUPP; 641 } 642 } 643 644 static umode_t adm9240_is_visible(const void *_data, enum hwmon_sensor_types type, 645 u32 attr, int channel) 646 { 647 umode_t mode = 0; 648 649 switch (type) { 650 case hwmon_chip: 651 switch (attr) { 652 case hwmon_chip_alarms: 653 mode = 0444; 654 break; 655 default: 656 break; 657 } 658 break; 659 case hwmon_intrusion: 660 switch (attr) { 661 case hwmon_intrusion_alarm: 662 mode = 0644; 663 break; 664 default: 665 break; 666 } 667 break; 668 case hwmon_temp: 669 switch (attr) { 670 case hwmon_temp: 671 case hwmon_temp_alarm: 672 mode = 0444; 673 break; 674 case hwmon_temp_max: 675 case hwmon_temp_max_hyst: 676 mode = 0644; 677 break; 678 default: 679 break; 680 } 681 break; 682 case hwmon_fan: 683 switch (attr) { 684 case hwmon_fan_input: 685 case hwmon_fan_div: 686 case hwmon_fan_alarm: 687 mode = 0444; 688 break; 689 case hwmon_fan_min: 690 mode = 0644; 691 break; 692 default: 693 break; 694 } 695 break; 696 case hwmon_in: 697 switch (attr) { 698 case hwmon_in_input: 699 case hwmon_in_alarm: 700 mode = 0444; 701 break; 702 case hwmon_in_min: 703 case hwmon_in_max: 704 mode = 0644; 705 break; 706 default: 707 break; 708 } 709 break; 710 default: 711 break; 712 } 713 return mode; 714 } 715 716 static const struct hwmon_ops adm9240_hwmon_ops = { 717 .is_visible = adm9240_is_visible, 718 .read = adm9240_read, 719 .write = adm9240_write, 720 }; 721 722 static const struct hwmon_channel_info * const adm9240_info[] = { 723 HWMON_CHANNEL_INFO(chip, HWMON_C_ALARMS), 724 HWMON_CHANNEL_INFO(intrusion, HWMON_INTRUSION_ALARM), 725 HWMON_CHANNEL_INFO(temp, 726 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST | HWMON_T_ALARM), 727 HWMON_CHANNEL_INFO(in, 728 HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, 729 HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, 730 HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, 731 HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, 732 HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, 733 HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM), 734 HWMON_CHANNEL_INFO(fan, 735 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_DIV | HWMON_F_ALARM, 736 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_DIV | HWMON_F_ALARM), 737 NULL 738 }; 739 740 static const struct hwmon_chip_info adm9240_chip_info = { 741 .ops = &adm9240_hwmon_ops, 742 .info = adm9240_info, 743 }; 744 745 static bool adm9240_volatile_reg(struct device *dev, unsigned int reg) 746 { 747 switch (reg) { 748 case ADM9240_REG_IN(0) ... ADM9240_REG_IN(5): 749 case ADM9240_REG_FAN(0) ... ADM9240_REG_FAN(1): 750 case ADM9240_REG_INT(0) ... ADM9240_REG_INT(1): 751 case ADM9240_REG_TEMP: 752 case ADM9240_REG_TEMP_CONF: 753 case ADM9240_REG_VID_FAN_DIV: 754 case ADM9240_REG_VID4: 755 case ADM9240_REG_ANALOG_OUT: 756 return true; 757 default: 758 return false; 759 } 760 } 761 762 static const struct regmap_config adm9240_regmap_config = { 763 .reg_bits = 8, 764 .val_bits = 8, 765 .use_single_read = true, 766 .use_single_write = true, 767 .volatile_reg = adm9240_volatile_reg, 768 }; 769 770 static int adm9240_probe(struct i2c_client *client) 771 { 772 struct device *dev = &client->dev; 773 struct device *hwmon_dev; 774 struct adm9240_data *data; 775 int err; 776 777 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 778 if (!data) 779 return -ENOMEM; 780 781 data->dev = dev; 782 data->regmap = devm_regmap_init_i2c(client, &adm9240_regmap_config); 783 if (IS_ERR(data->regmap)) 784 return PTR_ERR(data->regmap); 785 786 err = adm9240_init_client(data); 787 if (err < 0) 788 return err; 789 790 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data, 791 &adm9240_chip_info, 792 adm9240_groups); 793 return PTR_ERR_OR_ZERO(hwmon_dev); 794 } 795 796 static const struct i2c_device_id adm9240_id[] = { 797 { "adm9240", adm9240 }, 798 { "ds1780", ds1780 }, 799 { "lm81", lm81 }, 800 { } 801 }; 802 MODULE_DEVICE_TABLE(i2c, adm9240_id); 803 804 static struct i2c_driver adm9240_driver = { 805 .class = I2C_CLASS_HWMON, 806 .driver = { 807 .name = "adm9240", 808 }, 809 .probe = adm9240_probe, 810 .id_table = adm9240_id, 811 .detect = adm9240_detect, 812 .address_list = normal_i2c, 813 }; 814 815 module_i2c_driver(adm9240_driver); 816 817 MODULE_AUTHOR("Michiel Rook <michiel@grendelproject.nl>, " 818 "Grant Coady <gcoady.lk@gmail.com> and others"); 819 MODULE_DESCRIPTION("ADM9240/DS1780/LM81 driver"); 820 MODULE_LICENSE("GPL"); 821