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